├── .editorconfig
├── .gitignore
├── README.md
├── composer.json
├── config
    └── blocks.php
└── src
    ├── AcfBlock.php
    ├── AcfBlockServiceProvider.php
    ├── Block.php
    └── Facades
        └── AcfBlock.php


/.editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | 
 3 | root = true
 4 | 
 5 | [*]
 6 | indent_style = space
 7 | indent_size = 2
 8 | end_of_line = lf
 9 | charset = utf-8
10 | trim_trailing_whitespace = true
11 | insert_final_newline = true
12 | 
13 | [*.php]
14 | indent_size = 4
15 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | composer.lock
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Sage ACF Blocks
  2 | 
  3 | A Sage 10 helper package for building ACF blocks rendered using blade templates.
  4 | 
  5 | The main difference between this and others similar packages is that it's designed for also rendering the blocks directly from templates that do not have a Block Editor. It also supports rendering different templates per block style.
  6 | 
  7 | _WordPress 5.3 or more is required. A Bedrock installation with Acorn is also required._
  8 | 
  9 | ### Installation
 10 | 
 11 | 1. If not installed already, add Acorn at the site level in your Bedrocks setup installation
 12 | 
 13 |     ```sh
 14 |     composer require roots/acorn
 15 |     ````
 16 | 
 17 | 2. Install the package in yor theme
 18 | 
 19 |     ```sh
 20 |     composer config repositories.sage-acfblocks vcs https://github.com/generoi/sage-acfblocks.git
 21 |     composer require generoi/sage-acfblocks:dev-master
 22 |     ```   
 23 | 
 24 | 3. Add `Generoi\Sage\AcfBlocks\BlockServiceProvider::class` to the providers in `config/app.php` or add automatically with:
 25 | 
 26 |     ```sh
 27 |     wp acorn package:discover
 28 |     ```
 29 | 
 30 | 3. Publish the default `config/blocks.php` file.
 31 | 
 32 |     ```sh
 33 |     wp acorn vendor:publish
 34 |     ```
 35 | 
 36 | ### Getting started example
 37 | 
 38 | 1. Create a directory to store your blocks.
 39 | 
 40 |     ```sh
 41 |     app/Blocks
 42 |     └── ContentListing
 43 |         ├── ContentListing.php
 44 |         ├── assets
 45 |         │   ├── content-listing.css
 46 |         │   └── content-listing.js
 47 |         └── views
 48 |             ├── content-listing-accordion.blade.php
 49 |             └── content-listing.blade.php
 50 |     ```
 51 | 
 52 | 2. Configure your block in `app/Blocks/ContentListing/ContentListing.php`
 53 | 
 54 |     ```php
 55 |     <?php
 56 | 
 57 |     namespace App\Blocks\ContentListing;
 58 | 
 59 |     use Genero\Sage\AcfBlocks\Block;
 60 |     use Illuminate\View\View;
 61 | 
 62 |     class ContentListing extends Block
 63 |     {
 64 |         /** @var array The block registration settings. */
 65 |         public static $register = [
 66 |             'name' => 'content-listing',
 67 |             'title' => 'Content listing',
 68 |             'description' => 'A block listing content based on filters',
 69 |             'category' => 'sage',
 70 |             'align' => 'wide',
 71 |             'mode' => 'preview',
 72 |             'icon' => 'excerpt-view',
 73 |             'keywords' => ['post', 'query'],
 74 |             'supports' => [],
 75 | 
 76 |             // Unless set dynamically to a URL using the static register() method
 77 |             // these will be loaded from in the root diretory of the block.
 78 |             'enqueue_style' => 'assets/content-listing.css',
 79 |             'enqueue_script' => 'assets/content-listing.js',
 80 | 
 81 |             // Define block styles which will be automatically added and used
 82 |             // when looking for block templates.
 83 |             'styles' => [
 84 |                 'accordion' => 'Accordion',
 85 |             ],
 86 |         ];
 87 | 
 88 |         /**
 89 |          * Data to be passed to the rendered block.
 90 |          */
 91 |         public function with($data, $view)
 92 |         {
 93 |             $data['fields'] = (object) array_merge([
 94 |                 'posts_per_page' => 3,
 95 |                 'order_by' => ['date'],
 96 |                 'order' => 'DESC',
 97 |                 'post_type' => 'post',
 98 |             ], $this->block['fields'] ?? get_fields() ?: []);
 99 | 
100 |             $data['posts'] = get_posts($this->query($data['fields']));
101 | 
102 |             return $data;
103 |         }
104 | 
105 |         protected function query($data): array
106 |         {
107 |             $query = [
108 |                 'posts_per_page' => $data->posts_per_page,
109 |                 'orderby' => implode(' ', $data->order_by),
110 |                 'order' => $data->order,
111 |                 'post_type' => $data->post_type,
112 |                 'post_status' => 'publish',
113 |             ];
114 | 
115 |             return $query;
116 |         }
117 | 
118 |         /**
119 |         * {@inhertiDoc}
120 |         */
121 |         public function render(View $view): string
122 |         {
123 |             if (empty($view->posts)) {
124 |                 if ($this->isPreview()) {
125 |                     return '<div class="acf-block-placeholder">' . __('No results found...') . '</div>';
126 |                 }
127 |                 return '';
128 |             }
129 | 
130 |             return parent::render($view);
131 |         }
132 |     }
133 |     ```
134 | 
135 | 3. Add the block to `config/block.php`
136 | 
137 |     ```php
138 |     'blocks' => [
139 |         App\Blocks\ContentListing\ContentListing::class,
140 |     ],
141 |     ```
142 | 
143 | 4. Create your default template: `views/content-listing.blade.php`
144 | 
145 |     ```blade
146 |     <div class="{{ $classes }} flex">
147 |       @foreach ($posts as $post)
148 |         <div class="w-1/3">
149 |           <h3>{{ get_the_title($post) }}</h3>
150 | 
151 |           {{ get_the_excerpt($post) }}
152 |         </div>
153 |       @endforeach
154 |     </div>
155 |     ```
156 | 
157 | 5. Create your style variation template: `views/content-listing-<style>.blade.php`
158 | 
159 |     ```blade
160 |     <div class="{{ $classes }}">
161 |       @foreach ($posts as $post)
162 |         <details>
163 |           <summary>{{ get_the_title($post) }}</summary>
164 | 
165 |           {{ get_the_excerpt($post) }}
166 |         </details>
167 |       @endforeach
168 |     </div>
169 |     ```
170 | 
171 | ### Additional features
172 | 
173 | #### Manual rendering outside of block editor.
174 | 
175 | If you want to render this block manually from a template rather than through the editor you can as long as you have enabled the in directive in `config/blocks.php`
176 | 
177 | ```
178 | @acfblock('acf/content-listing', [
179 |   'post_type' => 'page',
180 |   'className' => 'is-style-accordion',
181 |   'align' => 'center',
182 | ])
183 | ```
184 | 
185 | If you want to include the template, each block has a registered view namespace.
186 | 
187 | ```
188 | @include('ContentListing::content-listing', [
189 |   'classes' => 'acf-content-listing',
190 |   'posts' => get_posts(),
191 | ])
192 | ```
193 | 
194 | #### Re-using templates and blocks
195 | 
196 | What if you wanted a block for _Handpicked content listing_ that uses an ACF relationship field to retrieve posts. The template would actually stay the same so let's add a block that extends the previous block and inherits templates and styles.
197 | 
198 | ```php
199 | <?php
200 | 
201 | namespace App\Blocks\FeaturedListing;
202 | 
203 | use App\Blocks\ContentListing\ContentListing;
204 | use Genero\Sage\AcfBlocks\Facades\AcfBlock;
205 | 
206 | class FeaturedListing extends ContentListing
207 | {
208 | 
209 |     /**
210 |      * Block registration settings.
211 |      *
212 |      * @link https://www.advancedcustomfields.com/resources/acf_register_block_type/
213 |      */
214 |     public static function register(): array
215 |     {
216 |         $register = parent::register();
217 |         $register['name'] = 'featured-listing';
218 |         $register['title'] = 'Featured listing';
219 |         $register['description'] = 'A block listing featured content picked manually';
220 | 
221 |         // The enqueues need to be updated to point to the correct block as they're
222 |         // set based on the called class.
223 |         $register['enqueue_style'] = AcfBlock::get(ContentListing::class . '.settings.enqueue_style');
224 |         $register['enqueue_script'] = AcfBlock::get(ContentListing::class . '.settings.enqueue_script');
225 | 
226 |         return $register;
227 |     }
228 | 
229 |     /**
230 |      * Data to be passed to the rendered block.
231 |      */
232 |     public function with($data, $view)
233 |     {
234 |         $data['fields'] = (object) array_merge([
235 |             'posts' => [],
236 |         ], $this->block['fields'] ?? get_fields() ?: []);
237 | 
238 |         $data['posts'] = $data['fields']->posts ?: [];
239 | 
240 |         return $data;
241 |     }
242 | 
243 |     /**
244 |      * Data to be passed to the rendered block.
245 |      */
246 |     public function override($data, $view)
247 |     {
248 |         return [
249 |             'classes' => $data['classes'] . ' acf-content-listing',
250 |         ];
251 |     }
252 | 
253 |     /**
254 |      * {@inhertiDoc}
255 |      */
256 |     public function views(): array
257 |     {
258 |         return [
259 |             "ContentListing::content-listing-{$this->style}",
260 |             "ContentListing::content-listing",
261 |         ];
262 |     }
263 | }
264 | ```
265 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "generoi/sage-acfblocks",
 3 |   "type": "library",
 4 |   "license": "MIT",
 5 |   "description": "",
 6 |   "homepage": "https://github.com/generoi/sage-foundation",
 7 |   "authors": [
 8 |     {
 9 |       "name": "Oskar Schöldström",
10 |       "email": "public@oxy.fi"
11 |     }
12 |   ],
13 |   "autoload": {
14 |     "psr-4": {
15 |       "Genero\\Sage\\AcfBlocks\\": "src/"
16 |     }
17 |   },
18 |   "require-dev": {
19 |     "squizlabs/php_codesniffer": "~3.0"
20 |   },
21 |   "minimum-stability": "dev",
22 |   "prefer-stable": true,
23 |   "scripts": {
24 |     "test": [
25 |       "phpcs --ignore=vendor --extensions=php --standard=PSR2 ."
26 |     ]
27 |   },
28 |   "archive" : {
29 |     "exclude": [
30 |       ".gitignore"
31 |     ]
32 |   },
33 |   "extra": {
34 |     "acorn": {
35 |       "providers": [
36 |         "Genero\\Sage\\AcfBlocks\\AcfBlockServiceProvider"
37 |       ],
38 |       "aliases": {
39 |         "AcfBlock": "Genero\\Sage\\AcfBlocks\\Facades\\AcfBlock"
40 |       }
41 |     }
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/config/blocks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     /*
 5 |     |--------------------------------------------------------------------------
 6 |     | Autoloaded Gutenberg Blocks
 7 |     |--------------------------------------------------------------------------
 8 |     |
 9 |     | The Gutenberg blocks listed here will be automatically loaded on the
10 |     | request to your application.
11 |     |
12 |     */
13 |     'blocks' => [
14 |         // App\Blocks\Example\Example::class,
15 |     ],
16 | 
17 |     /*
18 |     |--------------------------------------------------------------------------
19 |     | Blade directive
20 |     |--------------------------------------------------------------------------
21 |     |
22 |     | Attach an @acfblock blade directive for manually triggering the rendering
23 |     | of a block.
24 |     |
25 |     */
26 |     'directive' => true,
27 | ];
28 | 


--------------------------------------------------------------------------------
/src/AcfBlock.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Genero\Sage\AcfBlocks;
  4 | 
  5 | use Illuminate\Support\Arr;
  6 | use \Illuminate\Contracts\Foundation\Application;
  7 | 
  8 | class AcfBlock
  9 | {
 10 |     /** @var array Registered blocks. */
 11 |     protected $blocks = [];
 12 |     protected $styles = [];
 13 |     protected $app;
 14 | 
 15 |     public function __construct(Application $app) {
 16 |         $this->app = $app;
 17 |     }
 18 | 
 19 |     public function registerBlock(string $composer): void
 20 |     {
 21 |         $settings = $this::getSettings($composer);
 22 |         $this->set("$composer.settings", $settings);
 23 | 
 24 |         if (!empty($settings['styles'])) {
 25 |             $this->addBlockStyles("acf/{$settings['name']}", $settings['styles']);
 26 |             unset($settings['styles']);
 27 |         }
 28 | 
 29 |         acf_register_block(array_merge([
 30 |             'render_callback' => function ($block, $content = '', $isPreview = false, $postId = 0) use ($composer) {
 31 |                 $this->set("$composer.composer", new $composer(
 32 |                     $this->get("$composer.settings.name"),
 33 |                     $block,
 34 |                     $content,
 35 |                     is_bool($isPreview) ? $isPreview : false,
 36 |                     (int) $postId
 37 |                 ));
 38 | 
 39 |                 $this->renderBlock($this->get("$composer.composer"));
 40 |             },
 41 |         ], $settings));
 42 |     }
 43 | 
 44 |     public function renderBlock(Block $composer)
 45 |     {
 46 |         try {
 47 |             $view = $this->app['view']->first($composer->views());
 48 |         } catch (\InvalidArgumentException $e) {
 49 |             if ($composer->isPreview()) {
 50 |                 echo sprintf('<div>%s</div', $e->getMessage());
 51 |                 return;
 52 |             }
 53 |             throw $e;
 54 |         }
 55 | 
 56 |         $composer->compose($view);
 57 |         echo $composer->render($view);
 58 |     }
 59 | 
 60 |     public function getSettings(string $composer): ?array
 61 |     {
 62 |         $data = $composer::register();
 63 |         if (!$data) {
 64 |             return null;
 65 |         }
 66 |         // Unless assets are URLs, prefix them with the URL to the block directory.
 67 |         foreach (['enqueue_style', 'enqueue_script'] as $attribute) {
 68 |             if (!empty($data[$attribute]) && !filter_var($data[$attribute], FILTER_VALIDATE_URL)) {
 69 |                 $path = dirname((new \ReflectionClass($composer))->getFileName());
 70 |                 $data[$attribute] = $this->uri($path . '/' . $data[$attribute]);
 71 |             }
 72 |         }
 73 | 
 74 |         return $data;
 75 |     }
 76 | 
 77 |     public function registerFields(string $composer): void
 78 |     {
 79 |         $fields = $composer::fields();
 80 |         if (empty($fields)) {
 81 |             return;
 82 |         }
 83 | 
 84 |         acf_add_local_field_group($fields);
 85 |     }
 86 | 
 87 |     public function uri(string $path): string
 88 |     {
 89 |         return str_replace(
 90 |             get_theme_file_path(),
 91 |             get_template_directory_uri(),
 92 |             $path
 93 |         );
 94 |     }
 95 | 
 96 |     public function addBlockStyles(string $block, array $styles): void
 97 |     {
 98 |         $this->styles[$block] = $styles;
 99 |     }
100 | 
101 |     public function getBlockStyles(): array
102 |     {
103 |         return collect($this->styles)
104 |             ->map(function ($styles) {
105 |                 return collect($styles)
106 |                     ->map(function ($label, $name) {
107 |                         return ['name' => $name, 'label' => $label];
108 |                     })
109 |                     ->values()
110 |                     ->all();
111 |             })
112 |             ->all();
113 |     }
114 | 
115 |     public function get(string $key = null, $default = null)
116 |     {
117 |         return Arr::get($this->blocks, $key, $default);
118 |     }
119 | 
120 |     public function set(string $key, $value = null)
121 |     {
122 |         return Arr::set($this->blocks, $key, $value);
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/src/AcfBlockServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Genero\Sage\AcfBlocks;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | 
 7 | class AcfBlockServiceProvider extends ServiceProvider
 8 | {
 9 |     /**
10 |      * Register blocks.
11 |      *
12 |      * @return void
13 |      */
14 |     public function register()
15 |     {
16 |         $this->app->singleton('acfblock', AcfBlock::class);
17 | 
18 |         $this->registerBlocks();
19 |         $this->registerStyles();
20 | 
21 |         if ($this->app->config->get('blocks.directive')) {
22 |             $this->attachBladeDirective();
23 |         }
24 |     }
25 | 
26 |     public function registerBlocks()
27 |     {
28 |         collect($this->app->config->get('blocks.blocks'))->each(function ($composerClass) {
29 |             add_action('acf/init', function () use ($composerClass) {
30 |                 $this->app['acfblock']->registerBlock($composerClass);
31 |                 $this->app['acfblock']->registerFields($composerClass);
32 |             });
33 | 
34 |             $this->addViewNamespace($composerClass);
35 |         });
36 | 
37 |         add_action('enqueue_block_editor_assets', [$this, 'registerStyles'], 1, 100);
38 |     }
39 | 
40 |     public function registerStyles()
41 |     {
42 |         if ($styles = $this->app['acfblock']->getBlockStyles()) {
43 |             foreach ($styles as $blockname => $allstyles) {
44 |                 foreach ($allstyles as $key => $style) {
45 |                     register_block_style($blockname, $style);
46 |                 }
47 |             }
48 |         }
49 |     }
50 | 
51 |     public function addViewNamespace($composerClass)
52 |     {
53 |         $hint = dirname((new \ReflectionClass($composerClass))->getFileName()) . '/views';
54 |         $this->app['view']->addNamespace($composerClass::namespace(), $hint);
55 |     }
56 | 
57 |     public function attachBladeDirective()
58 |     {
59 |         $blade = $this->app['view']->getEngineResolver()->resolve('blade')->getCompiler();
60 |         $blade->directive('acfblock', function ($expression) {
61 |             $expression = collect(explode(',', $expression, 2))
62 |                 ->map(function ($argument) {
63 |                     return trim($argument);
64 |                 });
65 | 
66 |             $block = "<?php \$block = acf_get_block_type({$expression->get(0)}); ?>";
67 | 
68 |             if (!empty($expression->get(1))) {
69 |                 $block .= "<?php \$block = array_merge(\$block, {$expression->get(1)}); ?>";
70 |             }
71 |             $block .= "<?php \$block = array_merge(\$block, ['id' => acf_get_block_id(\$block)]); ?>";
72 | 
73 |             return $block .
74 |                 "<?php acf_render_block(\$block); ?>" .
75 |                 "<?php wp_reset_postdata(); ?>";
76 |         });
77 |     }
78 | 
79 |     /**
80 |      * Bootstrap any application services.
81 |      *
82 |      * @return void
83 |      */
84 |     public function boot()
85 |     {
86 |         $this->publishes([
87 |             __DIR__ . '/../config/blocks.php' => $this->app->configPath('blocks.php'),
88 |         ], 'config');
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/src/Block.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Genero\Sage\AcfBlocks;
  4 | 
  5 | use Illuminate\View\View;
  6 | 
  7 | abstract class Block
  8 | {
  9 |     /** @var array The block settings and attributes. */
 10 |     protected static $register;
 11 | 
 12 |     /** @var string Machine name of block. */
 13 |     protected $name;
 14 | 
 15 |     /** @var array The block settings and attributes. */
 16 |     protected $block;
 17 | 
 18 |     /** @var string The block inner HTML. */
 19 |     protected $content;
 20 | 
 21 |     /** @var bool If the block is being previewed. */
 22 |     protected $isPreview;
 23 | 
 24 |     /** @var int The post ID this block is saved to. */
 25 |     protected $postId;
 26 | 
 27 |     /** @var string The block style this block is displayed with. */
 28 |     protected $style;
 29 | 
 30 |     /** @var string View namespace. */
 31 |     protected $namsepace;
 32 | 
 33 |     /**
 34 |      * Block registration settings.
 35 |      *
 36 |      * @link https://www.advancedcustomfields.com/resources/acf_register_block_type/
 37 |      */
 38 |     public static function register(): array
 39 |     {
 40 |         if (static::$register) {
 41 |             return static::$register;
 42 |         }
 43 | 
 44 |         return [];
 45 |     }
 46 | 
 47 |     /**
 48 |      * Register ACF fields.
 49 |      */
 50 |     public static function fields(): array
 51 |     {
 52 |         return [];
 53 |     }
 54 | 
 55 |     /**
 56 |      * View namespace.
 57 |      */
 58 |     public static function namespace(): string
 59 |     {
 60 |         return (new \ReflectionClass(get_called_class()))->getShortName();
 61 |     }
 62 | 
 63 |     /**
 64 |      * @param string $name The name of the block
 65 |      * @param array $block The block settings and attributes.
 66 |      * @param string $content The block inner HTML (empty).
 67 |      * @param bool $isPreview True during AJAX preview.
 68 |      * @param int $postId The post ID this block is saved to.
 69 |      * @return \App\Blocks\Block
 70 |      */
 71 |     public function __construct(string $name, array $block, string $content, bool $isPreview, int $postId)
 72 |     {
 73 |         $this->name = $name;
 74 |         $this->block = $block;
 75 |         $this->content = $content;
 76 |         $this->isPreview = $isPreview;
 77 |         $this->postId = $postId;
 78 |         $this->style = $this->gatherStyle($block['className'] ?? '');
 79 |         $this->namespace = self::namespace();
 80 |     }
 81 | 
 82 |     /**
 83 |      * List of views for this block, where the first found will be used.
 84 |      */
 85 |     public function views(): array
 86 |     {
 87 |         return [
 88 |             "{$this->namespace}::{$this->name}-{$this->style}",
 89 |             "{$this->namespace}::{$this->name}",
 90 |         ];
 91 |     }
 92 | 
 93 |     /**
 94 |      * Get the style name this block uses.
 95 |      */
 96 |     protected function gatherStyle(string $className): string
 97 |     {
 98 |         return preg_match('/is-style-([^\s]+)/', $className, $matches) ? $matches[1] : 'default';
 99 |     }
100 | 
101 |     /**
102 |      * If the block is being previewed.
103 |     */
104 |     public function isPreview(): bool
105 |     {
106 |         return $this->isPreview;
107 |     }
108 | 
109 |     /**
110 |      * The block settings and attributes.
111 |      */
112 |     public function getBlock(string $key = null): array
113 |     {
114 |         return $this->block;
115 |     }
116 | 
117 |     /**
118 |      * Get the block classes.
119 |      */
120 |     protected function getClasses(): array
121 |     {
122 |         return collect(explode(' ', $this->block['className'] ?? ''))
123 |             ->prepend(str_replace('/', '-', $this->block['name']))
124 |             ->push(!empty($this->block['align']) ? 'align' . $this->block['align'] : null)
125 |             ->flatten()
126 |             ->filter()
127 |             ->all();
128 |     }
129 | 
130 |     /**
131 |      * The block style this block is displayed with.
132 |      */
133 |     public function getStyle(): string
134 |     {
135 |         return $this->style;
136 |     }
137 | 
138 |     /**
139 |      * The post ID this block is saved to.
140 |      */
141 |     public function getPostId(): int
142 |     {
143 |         return $this->postId;
144 |     }
145 | 
146 |     /**
147 |      * The block inner HTML.
148 |      */
149 |     public function getContent(): string
150 |     {
151 |         return $this->content;
152 |     }
153 | 
154 |     /**
155 |      * View used for rendering the block.
156 |      */
157 |     public function compose(View $view): void
158 |     {
159 |         $view->with($this->defaults());
160 |         $view->with(array_merge(
161 |             $this->with($view->getData(), $view),
162 |             $view->getData(),
163 |             $this->override($view->getData(), $view)
164 |         ));
165 |     }
166 | 
167 |     /**
168 |      * Default data avilable in the block.
169 |      */
170 |     public function defaults(): array
171 |     {
172 |         return [
173 |             'classes' => implode(' ', $this->getClasses()),
174 |             'is_preview' => $this->isPreview(),
175 |             'style' => $this->getStyle(),
176 |             'post_id' => $this->getPostId(),
177 |             'content' => $this->getContent(),
178 |         ];
179 |     }
180 | 
181 |     /**
182 |      * Get the string contents of the view.
183 |      */
184 |     public function render(View $view): string
185 |     {
186 |         return $view->render();
187 |     }
188 | 
189 |     /**
190 |      * Data to be passed to the rendered block.
191 |      */
192 |     public function override($data, $view)
193 |     {
194 |         return [];
195 |     }
196 | 
197 |     /**
198 |      * Data to be passed to the rendered block.
199 |      */
200 |     public function with($data, $view)
201 |     {
202 |         return [];
203 |     }
204 | }
205 | 


--------------------------------------------------------------------------------
/src/Facades/AcfBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Genero\Sage\AcfBlocks\Facades;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | 
 7 | class AcfBlock extends Facade
 8 | {
 9 |     /**
10 |      * Get the registered name of the component.
11 |      *
12 |      * @return string
13 |      */
14 |     protected static function getFacadeAccessor()
15 |     {
16 |         return 'acfblock';
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------