public/wp-bundle/plugins/advanced-custom-fields-pro/pro/blocks.php line 724

Open in your IDE?
  1. <?php
  2. /**
  3.  * The ACF Blocks PHP code.
  4.  *
  5.  * @package ACF
  6.  */
  8. // Exit if accessed directly.
  9. defined( 'ABSPATH' ) || exit;
  11. // Register store.
  12. acf_register_store( 'block-types' );
  13. acf_register_store( 'block-cache' );
  14. acf_register_store( 'block-meta-values' );
  16. // Register block.json support handlers.
  17. add_filter( 'block_type_metadata', 'acf_add_block_namespace' );
  18. add_filter( 'block_type_metadata_settings', 'acf_handle_json_block_registration', 99, 2 );
  19. add_action( 'acf_block_render_template', 'acf_block_render_template', 10, 6 );
  21. /**
  22.  * Prefix block names for ACF blocks registered through block.json
  23.  *
  24.  * @since 6.0.0
  25.  *
  26.  * @param array $metadata The block metadata array.
  27.  * @return array The original array with a prefixed block name if it's an ACF block.
  28.  */
  29. function acf_add_block_namespace( $metadata ) {
  30.     if ( acf_is_acf_block_json( $metadata ) ) {
  31.         // If the block doesn't already have a namespace, append ACF's.
  32.         if ( strpos( $metadata['name'], '/' ) === false ) {
  33.             $metadata['name'] = 'acf/' . acf_slugify( $metadata['name'] );
  34.         }
  35.     }
  36.     return $metadata;
  37. }
  39. /**
  40.  * Handle an ACF block registered through block.json
  41.  *
  42.  * @since 6.0.0
  43.  *
  44.  * @param array $settings The compiled block settings.
  45.  * @param array $metadata The raw json metadata.
  46.  *
  47.  * @return array Block registration settings with ACF required additions.
  48.  */
  49. function acf_handle_json_block_registration( $settings, $metadata ) {
  50.     if ( ! acf_is_acf_block_json( $metadata ) ) {
  51.         return $settings;
  52.     }
  54.     // Setup ACF defaults.
  55.     $settings = wp_parse_args(
  56.         $settings,
  57.         array(
  58.             'render_template'   => false,
  59.             'render_callback'   => false,
  60.             'enqueue_style'     => false,
  61.             'enqueue_script'    => false,
  62.             'enqueue_assets'    => false,
  63.             'post_types'        => array(),
  64.             'uses_context'      => array(),
  65.             'supports'          => array(),
  66.             'attributes'        => array(),
  67.             'acf_block_version' => 2,
  68.             'api_version'       => 2,
  69.             'validate'          => true,
  70.             'validate_on_load'  => true,
  71.             'use_post_meta'     => false,
  72.         )
  73.     );
  75.     // Add user provided attributes to ACF's required defaults.
  76.     $settings['attributes'] = wp_parse_args(
  77.         acf_get_block_type_default_attributes( $metadata ),
  78.         $settings['attributes']
  79.     );
  81.     // Add default ACF 'supports' settings.
  82.     $settings['supports'] = wp_parse_args(
  83.         $settings['supports'],
  84.         array(
  85.             'align'    => true,
  86.             'html'     => false,
  87.             'mode'     => true,
  88.             'jsx'      => true,
  89.             'multiple' => true,
  90.         )
  91.     );
  93.     // Add default ACF 'uses_context' settings.
  94.     $settings['uses_context'] = array_values(
  95.         array_unique(
  96.             array_merge(
  97.                 $settings['uses_context'],
  98.                 array(
  99.                     'postId',
  100.                     'postType',
  101.                 )
  102.             )
  103.         )
  104.     );
  106.     // Map custom ACF properties from the ACF key, with localization.
  107.     $property_mappings = array(
  108.         'renderCallback' => 'render_callback',
  109.         'renderTemplate' => 'render_template',
  110.         'mode'           => 'mode',
  111.         'blockVersion'   => 'acf_block_version',
  112.         'postTypes'      => 'post_types',
  113.         'validate'       => 'validate',
  114.         'validateOnLoad' => 'validate_on_load',
  115.         'usePostMeta'    => 'use_post_meta',
  116.     );
  117.     $textdomain        = ! empty( $metadata['textdomain'] ) ? $metadata['textdomain'] : 'acf';
  118.     $i18n_schema       = get_block_metadata_i18n_schema();
  120.     foreach ( $property_mappings as $key => $mapped_key ) {
  121.         if ( isset( $metadata['acf'][ $key ] ) ) {
  122.             unset( $settings[ $key ] );
  123.             $settings[ $mapped_key ] = $metadata['acf'][ $key ];
  124.             if ( $textdomain && isset( $i18n_schema->$key ) ) {
  125.                 $settings[ $mapped_key ] = translate_settings_using_i18n_schema( $i18n_schema->$key, $settings[ $key ], $textdomain );
  126.             }
  127.         }
  128.     }
  130.     // Add the block name and registration path to settings.
  131.     $settings['name'] = $metadata['name'];
  132.     $settings['path'] = dirname( $metadata['file'] );
  134.     // Prevent blocks that usePostMeta from being nested or saving multiple.
  135.     if ( ! empty( $settings['use_post_meta'] ) ) {
  136.         $settings['parent']               = array( 'core/post-content' );
  137.         $settings['supports']['multiple'] = false;
  138.     }
  140.     acf_get_store( 'block-types' )->set( $metadata['name'], $settings );
  141.     add_action( 'enqueue_block_editor_assets', 'acf_enqueue_block_assets' );
  143.     // Ensure our render callback is used.
  144.     $settings['render_callback'] = 'acf_render_block_callback';
  146.     return $settings;
  147. }
  149. /**
  150.  * Check if a block.json block is an ACF block.
  151.  *
  152.  * @since 6.0.0
  153.  *
  154.  * @param array $metadata The raw block metadata array.
  155.  * @return boolean
  156.  */
  157. function acf_is_acf_block_json( $metadata ) {
  158.     return ( isset( $metadata['acf'] ) && $metadata['acf'] );
  159. }
  162. /**
  163.  * Registers a block type.
  164.  *
  165.  * @date    18/2/19
  166.  * @since   5.8.0
  167.  *
  168.  * @param   array $block The block settings.
  169.  * @return  (array|false)
  170.  */
  171. function acf_register_block_type( $block ) {
  172.     // Validate block type settings.
  173.     $block = acf_validate_block_type( $block );
  175.     /**
  176.      * Filters the arguments for registering a block type.
  177.      *
  178.      * @since   5.8.9
  179.      *
  180.      * @param   array $block The array of arguments for registering a block type.
  181.      */
  182.     $block = apply_filters( 'acf/register_block_type_args', $block );
  184.     // Require name.
  185.     if ( ! $block['name'] ) {
  186.         $message = __( 'Block type name is required.', 'acf' );
  187.         _doing_it_wrong( __FUNCTION__, $message, '5.8.0' ); //phpcs:ignore -- escape not required.
  188.         return false;
  189.     }
  191.     // Bail early if already exists.
  192.     if ( acf_has_block_type( $block['name'] ) ) {
  193.         /* translators: The name of the block type */
  194.         $message = sprintf( __( 'Block type "%s" is already registered.', 'acf' ), $block['name'] );
  195.         _doing_it_wrong( __FUNCTION__, $message, '5.8.0' ); //phpcs:ignore -- escape not required.
  196.         return false;
  197.     }
  199.     // Set ACF required attributes.
  200.     $block['attributes'] = acf_get_block_type_default_attributes( $block );
  201.     if ( ! isset( $block['api_version'] ) ) {
  202.         $block['api_version'] = 2;
  203.     }
  204.     if ( ! isset( $block['acf_block_version'] ) ) {
  205.         $block['acf_block_version'] = 1;
  206.     }
  208.     // Add to storage.
  209.     acf_get_store( 'block-types' )->set( $block['name'], $block );
  211.     // Overwrite callback for WordPress registration.
  212.     $block['render_callback'] = 'acf_render_block_callback';
  214.     // Register block type in WP.
  215.     if ( function_exists( 'register_block_type' ) ) {
  216.         register_block_type(
  217.             $block['name'],
  218.             $block
  219.         );
  220.     }
  222.     // Register action.
  223.     add_action( 'enqueue_block_editor_assets', 'acf_enqueue_block_assets' );
  225.     // Return block.
  226.     return $block;
  227. }
  229. /**
  230.  * See acf_register_block_type().
  231.  *
  232.  * @date    18/2/19
  233.  * @since   5.7.12
  234.  *
  235.  * @param   array $block The block settings.
  236.  * @return  (array|false)
  237.  */
  238. function acf_register_block( $block ) {
  239.     return acf_register_block_type( $block );
  240. }
  242. /**
  243.  * Returns true if a block type exists for the given name.
  244.  *
  245.  * @since   5.7.12
  246.  *
  247.  * @param   string $name The block type name.
  248.  * @return  boolean
  249.  */
  250. function acf_has_block_type( $name ) {
  251.     return acf_get_store( 'block-types' )->has( $name );
  252. }
  254. /**
  255.  * Returns an array of all registered block types.
  256.  *
  257.  * @since   5.7.12
  258.  *
  259.  * @return  array
  260.  */
  261. function acf_get_block_types() {
  262.     return acf_get_store( 'block-types' )->get();
  263. }
  265. /**
  266.  * Returns a block type for the given name.
  267.  *
  268.  * @since   5.7.12
  269.  *
  270.  * @param   string $name The block type name.
  271.  * @return  (array|null)
  272.  */
  273. function acf_get_block_type( $name ) {
  274.     return acf_get_store( 'block-types' )->get( $name );
  275. }
  277. /**
  278.  * Removes a block type for the given name.
  279.  *
  280.  * @since   5.7.12
  281.  *
  282.  * @param   string $name The block type name.
  283.  * @return  void
  284.  */
  285. function acf_remove_block_type( $name ) {
  286.     acf_get_store( 'block-types' )->remove( $name );
  287. }
  289. /**
  290.  * Returns an array of default attribute settings for a block type.
  291.  *
  292.  * @date    19/11/18
  293.  * @since   5.8.0
  294.  *
  295.  * @param array $block_type A block configuration array.
  296.  * @return array
  297.  */
  298. function acf_get_block_type_default_attributes( $block_type ) {
  299.     $attributes = array(
  300.         'name'  => array(
  301.             'type'    => 'string',
  302.             'default' => '',
  303.         ),
  304.         'data'  => array(
  305.             'type'    => 'object',
  306.             'default' => array(),
  307.         ),
  308.         'align' => array(
  309.             'type'    => 'string',
  310.             'default' => '',
  311.         ),
  312.         'mode'  => array(
  313.             'type'    => 'string',
  314.             'default' => '',
  315.         ),
  316.     );
  318.     foreach ( acf_get_block_back_compat_attribute_key_array() as $new => $old ) {
  319.         if ( isset( $block_type['supports'][ $old ] ) ) {
  320.             $block_type['supports'][ $new ] = $block_type['supports'][ $old ];
  321.             unset( $block_type['supports'][ $old ] );
  322.         }
  323.     }
  325.     if ( ! empty( $block_type['supports']['alignText'] ) ) {
  326.         $attributes['alignText'] = array(
  327.             'type'    => 'string',
  328.             'default' => '',
  329.         );
  330.     }
  331.     if ( ! empty( $block_type['supports']['alignContent'] ) ) {
  332.         $attributes['alignContent'] = array(
  333.             'type'    => 'string',
  334.             'default' => '',
  335.         );
  336.     }
  337.     if ( ! empty( $block_type['supports']['fullHeight'] ) ) {
  338.         $attributes['fullHeight'] = array(
  339.             'type'    => 'boolean',
  340.             'default' => '',
  341.         );
  342.     }
  344.     // For each of ACF's block attributes, check if the user's block attributes contains a default value we should use.
  345.     if ( isset( $block_type['attributes'] ) && is_array( $block_type['attributes'] ) ) {
  346.         foreach ( array_keys( $attributes ) as $key ) {
  347.             if ( isset( $block_type['attributes'][ $key ] ) && is_array( $block_type['attributes'][ $key ] ) && isset( $block_type['attributes'][ $key ]['default'] ) ) {
  348.                 $attributes[ $key ]['default'] = $block_type['attributes'][ $key ]['default'];
  349.             }
  350.         }
  351.     }
  353.     return $attributes;
  354. }
  356. /**
  357.  * Validates a block type ensuring all settings exist.
  358.  *
  359.  * @since   5.8.0
  360.  *
  361.  * @param   array $block The block settings.
  362.  * @return  array
  363.  */
  364. function acf_validate_block_type( $block ) {
  366.     // Add default settings.
  367.     $block = wp_parse_args(
  368.         $block,
  369.         array(
  370.             'name'            => '',
  371.             'title'           => '',
  372.             'description'     => '',
  373.             'category'        => 'common',
  374.             'icon'            => '',
  375.             'mode'            => 'preview',
  376.             'keywords'        => array(),
  377.             'supports'        => array(),
  378.             'post_types'      => array(),
  379.             'uses_context'    => array(),
  380.             'render_template' => false,
  381.             'render_callback' => false,
  382.             'enqueue_style'   => false,
  383.             'enqueue_script'  => false,
  384.             'enqueue_assets'  => false,
  385.         )
  386.     );
  388.     // Generate name with prefix.
  389.     if ( $block['name'] ) {
  390.         $block['name'] = 'acf/' . acf_slugify( $block['name'] );
  391.     }
  393.     // Add default 'supports' settings.
  394.     $block['supports'] = wp_parse_args(
  395.         $block['supports'],
  396.         array(
  397.             'align' => true,
  398.             'html'  => false,
  399.             'mode'  => true,
  400.         )
  401.     );
  403.     // Add default 'uses_context' settings.
  404.     $block['uses_context'] = wp_parse_args(
  405.         $block['uses_context'],
  406.         array(
  407.             'postId',
  408.             'postType',
  409.         )
  410.     );
  412.     // Correct "Experimental" flags.
  413.     if ( isset( $block['supports']['__experimental_jsx'] ) ) {
  414.         $block['supports']['jsx'] = $block['supports']['__experimental_jsx'];
  415.     }
  417.     // Normalize block 'parent' setting.
  418.     if ( array_key_exists( 'parent', $block ) ) {
  419.         // As of WP 6.8, parent must be an array.
  420.         if ( null === $block['parent'] ) {
  421.             unset( $block['parent'] );
  422.         } elseif ( is_string( $block['parent'] ) ) {
  423.             $block['parent'] = array( $block['parent'] );
  424.         }
  425.     }
  427.     // Return block.
  428.     return $block;
  429. }
  431. /**
  432.  * Prepares a block for use in render_callback by merging in all settings and attributes.
  433.  *
  434.  * @since   5.8.0
  435.  *
  436.  * @param   array $block The block props.
  437.  * @return  array|boolean
  438.  */
  439. function acf_prepare_block( $block ) {
  440.     // Bail early if no name.
  441.     if ( ! isset( $block['name'] ) ) {
  442.         return false;
  443.     }
  445.     // Ensure a block ID is always prefixed with `block_` for meta.
  446.     $block['id'] = acf_ensure_block_id_prefix( $block['id'] );
  448.     // Get block type and return false if doesn't exist.
  449.     $block_type = acf_get_block_type( $block['name'] );
  450.     if ( ! $block_type ) {
  451.         return false;
  452.     }
  454.     // Prevent protected attributes being overridden.
  455.     $protected = array(
  456.         'render_template',
  457.         'render_callback',
  458.         'enqueue_script',
  459.         'enqueue_style',
  460.         'enqueue_assets',
  461.         'post_types',
  462.         'use_post_meta',
  463.     );
  464.     $block     = array_diff_key( $block, array_flip( $protected ) );
  466.     // Generate default attributes.
  467.     $attributes = array();
  468.     foreach ( acf_get_block_type_default_attributes( $block_type ) as $k => $v ) {
  469.         $attributes[ $k ] = $v['default'];
  470.     }
  472.     // Merge together arrays in order of least to most specific.
  473.     $block = array_merge( $block_type, $attributes, $block );
  475.     // Add backward compatibility attributes.
  476.     $block = acf_add_back_compat_attributes( $block );
  478.     // Return block.
  479.     return $block;
  480. }
  482. /**
  483.  * Add backwards compatible attribute values.
  484.  *
  485.  * @since 6.0.0
  486.  *
  487.  * @param array $block The original block.
  488.  * @return array Modified block array with backwards compatibility attributes.
  489.  */
  490. function acf_add_back_compat_attributes( $block ) {
  491.     foreach ( acf_get_block_back_compat_attribute_key_array() as $new => $old ) {
  492.         if ( ! empty( $block[ $new ] ) || ( isset( $block[ $new ] ) && ! isset( $block[ $old ] ) ) ) {
  493.             $block[ $old ] = $block[ $new ];
  494.         }
  495.     }
  497.     return $block;
  498. }
  500. /**
  501.  * Get back compat new values and old values.
  502.  *
  503.  * @since 6.0.0
  504.  *
  505.  * @return array back compat key array.
  506.  */
  507. function acf_get_block_back_compat_attribute_key_array() {
  508.     return array(
  509.         'fullHeight'   => 'full_height',
  510.         'alignText'    => 'align_text',
  511.         'alignContent' => 'align_content',
  512.     );
  513. }
  516. /**
  517.  * The render callback for all ACF blocks.
  518.  *
  519.  * @date    28/10/20
  520.  * @since   5.9.2
  521.  *
  522.  * @param   array    $attributes The block attributes.
  523.  * @param   string   $content    The block content.
  524.  * @param   WP_Block $wp_block   The block instance (since WP 5.5).
  525.  * @return  string The block HTML.
  526.  */
  527. function acf_render_block_callback( $attributes, $content = '', $wp_block = null ) {
  529.     $is_preview = false;
  530.     $post_id    = get_the_ID();
  532.     // Set preview flag to true when rendering for the block editor.
  533.     if ( is_admin() && acf_is_block_editor() ) {
  534.         $is_preview = true;
  535.     }
  537.     // If ACF's block save method hasn't been called yet, try to initialize a default block.
  538.     if ( empty( $attributes['name'] ) && ! empty( $wp_block->name ) ) {
  539.         $attributes['name'] = $wp_block->name;
  540.     }
  542.     // Return rendered block HTML.
  543.     return acf_rendered_block( $attributes, $content, $is_preview, $post_id, $wp_block );
  544. }
  546. /**
  547.  * Returns the rendered block HTML.
  548.  *
  549.  * @date    28/2/19
  550.  * @since   5.7.13
  551.  *
  552.  * @param   array    $attributes     The block attributes.
  553.  * @param   string   $content        The block content.
  554.  * @param   boolean  $is_preview     Whether or not the block is being rendered for editing preview.
  555.  * @param   integer  $post_id        The current post being edited or viewed.
  556.  * @param   WP_Block $wp_block       The block instance (since WP 5.5).
  557.  * @param   array    $context        The block context array.
  558.  * @param   boolean  $is_ajax_render Whether or not this is an ACF AJAX render.
  559.  * @return  string   The block HTML.
  560.  */
  561. function acf_rendered_block( $attributes, $content = '', $is_preview = false, $post_id = 0, $wp_block = null, $context = false, $is_ajax_render = false ) {
  562.     $mode = isset( $attributes['mode'] ) ? $attributes['mode'] : 'auto';
  563.     $form = ( 'edit' === $mode && $is_preview );
  565.     // If context is available from the WP_Block class object and we have no context of our own, use that.
  566.     if ( empty( $context ) && ! empty( $wp_block->context ) ) {
  567.         $context = $wp_block->context;
  568.     }
  570.     // Check if we need to generate a block ID.
  571.     $force_new_id = false;
  572.     if ( acf_block_uses_post_meta( $attributes ) && ! empty( $attributes['id'] ) && empty( $attributes['data'] ) ) {
  573.         $force_new_id = true;
  574.     }
  575.     $attributes['id'] = acf_get_block_id( $attributes, $context, $force_new_id );
  577.     // Check if we've already got a cache of this block ID and return it to save rendering if we're in the backend.
  578.     if ( $is_preview ) {
  579.         $cached_block = acf_get_store( 'block-cache' )->get( $attributes['id'] );
  580.         if ( $cached_block ) {
  581.             if ( $form ) {
  582.                 if ( $cached_block['form'] ) {
  583.                     return $cached_block['html'];
  584.                 }
  585.             } elseif ( ! $cached_block['form'] ) {
  586.                     return $cached_block['html'];
  587.             }
  588.         }
  589.     }
  591.     ob_start();
  593.     $validation = false;
  595.     if ( $form ) {
  596.         // Load the block form since we're in edit mode.
  597.         // Set flag for post REST cleanup of media enqueue count during preloads.
  598.         acf_set_data( 'acf_did_render_block_form', true );
  600.         $block = acf_prepare_block( $attributes );
  601.         $block = acf_add_block_meta_values( $block, $post_id );
  602.         acf_setup_meta( $block['data'], $block['id'], true );
  604.         if ( ! empty( $block['validate'] ) ) {
  605.             $validation = acf_get_block_validation_state( $block, false, false, true );
  606.         }
  608.         $fields = acf_get_block_fields( $block );
  609.         if ( $fields ) {
  610.             acf_prefix_fields( $fields, "acf-{$block['id']}" );
  612.             echo '<div class="acf-block-fields acf-fields" data-block-id="' . esc_attr( $block['id'] ) . '">';
  613.             acf_render_fields( $fields, acf_ensure_block_id_prefix( $block['id'] ), 'div', 'field' );
  614.             echo '</div>';
  615.         } else {
  616.             echo acf_get_empty_block_form_html( $attributes['name'] ); //phpcs:ignore -- escaped in function.
  617.         }
  618.     } else {
  619.         if ( $is_preview ) {
  620.             acf_set_data( 'acf_doing_block_preview', true );
  621.         }
  623.         // Capture block render output.
  624.         acf_render_block( $attributes, $content, $is_preview, $post_id, $wp_block, $context );
  626.         if ( $is_preview && ! $is_ajax_render ) {
  627.             /**
  628.              * If we're in preloaded preview, we need to get the validation state for a preview too.
  629.              * Because the block render resets meta once it's finished to not pollute $post_id, we need to redo that process here.
  630.              */
  631.             $block = acf_prepare_block( $attributes );
  632.             $block = acf_add_block_meta_values( $block, $post_id );
  633.             acf_setup_meta( $block['data'], $block['id'], true );
  634.             if ( ! empty( $block['validate'] ) ) {
  635.                 $validation = acf_get_block_validation_state( $block, false, false, true );
  636.             }
  637.         }
  638.     }
  640.     $html = ob_get_clean();
  641.     $html = is_string( $html ) ? $html : '';
  643.     // Replace <InnerBlocks /> placeholder on front-end, or if we're rendering an ACF block inside another ACF block template.
  644.     if ( ! $is_preview || doing_action( 'acf_block_render_template' ) ) {
  645.         // Escape "$" character to avoid "capture group" interpretation.
  646.         $content = str_replace( '$', '\$', $content );
  648.         // Wrap content in our acf-inner-container wrapper if necessary.
  649.         if ( $wp_block && $wp_block->block_type->acf_block_version > 1 && apply_filters( 'acf/blocks/wrap_frontend_innerblocks', true, $attributes['name'] ) ) {
  650.             // Check for a class (or className) provided in the template to become the InnerBlocks wrapper class.
  651.             $matches = array();
  652.             if ( preg_match( '/<InnerBlocks(?:[^<]+?)(?:class|className)=(?:["\']\W+\s*(?:\w+)\()?["\']([^\'"]+)[\'"]/', $html, $matches ) ) {
  653.                 $class = isset( $matches[1] ) ? $matches[1] : 'acf-innerblocks-container';
  654.             } else {
  655.                 $class = 'acf-innerblocks-container';
  656.             }
  657.             $content = '<div class="' . $class . '">' . $content . '</div>';
  658.         }
  659.         $html = preg_replace( '/<InnerBlocks([\S\s]*?)\/>/', $content, $html );
  660.     }
  662.     $block_cache = array(
  663.         'form' => $form,
  664.         'html' => $html,
  665.     );
  667.     if ( $is_preview && $validation ) {
  668.         // If we're in the preview, also store the validation status in the block cache.
  669.         $block_cache['validation'] = $validation;
  670.     }
  672.     // Store in cache for preloading if we're in the backend.
  673.     acf_get_store( 'block-cache' )->set(
  674.         $attributes['id'],
  675.         $block_cache
  676.     );
  678.     acf_set_data( 'acf_doing_block_preview', false );
  680.     // Prevent edit forms being output to rest endpoints.
  681.     if ( $form && acf_get_data( 'acf_inside_rest_call' ) && apply_filters( 'acf/blocks/prevent_edit_forms_on_rest_endpoints', true ) ) {
  682.         return '';
  683.     }
  685.     return $html;
  686. }
  688. /**
  689.  * Renders the block HTML.
  690.  *
  691.  * @since   5.7.12
  692.  *
  693.  * @param   array    $attributes The block attributes.
  694.  * @param   string   $content    The block content.
  695.  * @param   boolean  $is_preview Whether or not the block is being rendered for editing preview.
  696.  * @param   integer  $post_id    The current post being edited or viewed.
  697.  * @param   WP_Block $wp_block   The block instance (since WP 5.5).
  698.  * @param   array    $context    The block context array.
  699.  * @return  void|string
  700.  */
  701. function acf_render_block( $attributes, $content = '', $is_preview = false, $post_id = 0, $wp_block = null, $context = false ) {
  703.     // Prepare block ensuring all settings and attributes exist.
  704.     $block = acf_prepare_block( $attributes );
  705.     if ( ! $block ) {
  706.         return '';
  707.     }
  709.     // Find post_id if not defined.
  710.     if ( ! $post_id ) {
  711.         $post_id = get_the_ID();
  712.     }
  714.     // Enqueue block type assets.
  715.     acf_enqueue_block_type_assets( $block );
  717.     $block = acf_add_block_meta_values( $block, $post_id );
  719.     // Setup postdata allowing get_field() to work.
  720.     acf_setup_meta( $block['data'], $block['id'], true );
  722.     // Call render_callback.
  723.     if ( is_callable( $block['render_callback'] ) ) {
  724.         call_user_func( $block['render_callback'], $block, $content, $is_preview, $post_id, $wp_block, $context );
  726.         // Or include template.
  727.     } elseif ( $block['render_template'] ) {
  728.         do_action( 'acf_block_render_template', $block, $content, $is_preview, $post_id, $wp_block, $context );
  729.     }
  731.     // Reset postdata.
  732.     acf_reset_meta( $block['id'] );
  733. }
  735. /**
  736.  * Locate and include an ACF block's template.
  737.  *
  738.  * @since   6.0.4
  739.  *
  740.  * @param   array $block The block props.
  741.  */
  742. function acf_block_render_template( $block, $content, $is_preview, $post_id, $wp_block, $context ) {
  743.     // Locate template.
  744.     if ( isset( $block['path'] ) && file_exists( $block['path'] . '/' . $block['render_template'] ) ) {
  745.         $path = $block['path'] . '/' . $block['render_template'];
  746.     } elseif ( file_exists( $block['render_template'] ) ) {
  747.         $path = $block['render_template'];
  748.     } else {
  749.         $path = locate_template( $block['render_template'] );
  750.     }
  752.     // Include template.
  753.     if ( file_exists( $path ) ) {
  754.         include $path;
  755.     } elseif ( $is_preview ) {
  756.         echo acf_esc_html( apply_filters( 'acf/blocks/template_not_found_message', '<p>' . __( 'The render template for this ACF Block was not found', 'acf' ) . '</p>' ) );
  757.     }
  758. }
  760. /**
  761.  * Returns an array of all fields for the given block.
  762.  *
  763.  * @date    24/10/18
  764.  * @since   5.8.0
  765.  *
  766.  * @param   array $block The block props.
  767.  * @return  array
  768.  */
  769. function acf_get_block_fields( $block ) {
  770.     $fields = array();
  772.     // We need at least a block name to check.
  773.     if ( empty( $block['name'] ) ) {
  774.         return $fields;
  775.     }
  777.     // Get field groups for this block.
  778.     $field_groups = acf_get_field_groups(
  779.         array(
  780.             'block' => $block['name'],
  781.         )
  782.     );
  784.     // Loop over results and append fields.
  785.     if ( $field_groups ) {
  786.         foreach ( $field_groups as $field_group ) {
  787.             $fields = array_merge( $fields, acf_get_fields( $field_group ) );
  788.         }
  789.     }
  791.     return $fields;
  792. }
  794. /**
  795.  * Enqueues and localizes block scripts and styles.
  796.  *
  797.  * @since   5.7.13
  798.  *
  799.  * @return  void
  800.  */
  801. function acf_enqueue_block_assets() {
  803.     // Localize text.
  804.     acf_localize_text(
  805.         array(
  806.             'Switch to Edit'           => __( 'Switch to Edit', 'acf' ),
  807.             'Switch to Preview'        => __( 'Switch to Preview', 'acf' ),
  808.             'Change content alignment' => __( 'Change content alignment', 'acf' ),
  809.             'Error previewing block'   => __( 'An error occurred when loading the preview for this block.', 'acf' ),
  810.             'Error loading block form' => __( 'An error occurred when loading the block in edit mode.', 'acf' ),
  812.             /* translators: %s: Block type title */
  813.             '%s settings'              => __( '%s settings', 'acf' ),
  814.         )
  815.     );
  817.     // Get block types.
  818.     $block_types = array_map(
  819.         function ( $block ) {
  820.             // Render Callback may contain a incompatible class for JSON encoding. Turn it into a boolean for the frontend.
  821.             $block['render_callback'] = ! empty( $block['render_callback'] );
  822.             return $block;
  823.         },
  824.         acf_get_block_types()
  825.     );
  827.     // Localize data.
  828.     acf_localize_data(
  829.         array(
  830.             'blockTypes' => array_values( $block_types ),
  831.             'postType'   => get_post_type(),
  832.         )
  833.     );
  835.     // Enqueue script.
  836.     $min = defined( 'ACF_DEVELOPMENT_MODE' ) && ACF_DEVELOPMENT_MODE ? '' : '.min';
  838.     $blocks_js_path = acf_get_url( "assets/build/js/pro/acf-pro-blocks{$min}.js" );
  840.     wp_enqueue_script( 'acf-blocks', $blocks_js_path, array( 'acf-input', 'wp-blocks' ), ACF_VERSION, true );
  842.     // Enqueue block assets.
  843.     array_map( 'acf_enqueue_block_type_assets', $block_types );
  845.     // During the edit screen loading, WordPress renders all blocks in its own attempt to preload data.
  846.     // Retrieve any cached block HTML and include this in the localized data.
  847.     if ( acf_get_setting( 'preload_blocks' ) ) {
  848.         $preloaded_blocks = acf_get_store( 'block-cache' )->get_data();
  849.         acf_localize_data(
  850.             array(
  851.                 'preloadedBlocks' => $preloaded_blocks,
  852.             )
  853.         );
  854.     }
  855. }
  857. /**
  858.  * Enqueues scripts and styles for a specific block type.
  859.  *
  860.  * @since   5.7.13
  861.  *
  862.  * @param   array $block_type The block type settings.
  863.  * @return  void
  864.  */
  865. function acf_enqueue_block_type_assets( $block_type ) {
  867.     // Generate handle from name.
  868.     $handle = 'block-' . acf_slugify( $block_type['name'] );
  870.     // Enqueue style.
  871.     if ( $block_type['enqueue_style'] ) {
  872.         wp_enqueue_style( $handle, $block_type['enqueue_style'], array(), ACF_VERSION, 'all' );
  873.     }
  875.     // Enqueue script.
  876.     if ( $block_type['enqueue_script'] ) {
  877.         wp_enqueue_script( $handle, $block_type['enqueue_script'], array(), ACF_VERSION, true );
  878.     }
  880.     // Enqueue assets callback.
  881.     if ( $block_type['enqueue_assets'] && is_callable( $block_type['enqueue_assets'] ) ) {
  882.         call_user_func( $block_type['enqueue_assets'], $block_type );
  883.     }
  884. }
  886. /**
  887.  * Handles the ajax request for block data.
  888.  *
  889.  * @since   5.7.13
  890.  *
  891.  * @return  void
  892.  */
  893. function acf_ajax_fetch_block() {
  894.     // Validate ajax request.
  895.     if ( ! acf_verify_ajax() ) {
  896.         wp_send_json_error();
  897.     }
  899.     // Get request args.
  900.     $args = acf_request_args(
  901.         array(
  902.             'post_id'  => 0,
  903.             'clientId' => null,
  904.             'query'    => array(),
  905.         )
  906.     );
  908.     // Verify capability.
  909.     if ( ! empty( $args['post_id'] ) && is_numeric( $args['post_id'] ) ) {
  910.         // Editing a normal post - we can verify if the user has access to that post.
  911.         if ( ! acf_current_user_can_edit_post( (int) $args['post_id'] ) ) {
  912.             wp_send_json_error();
  913.         }
  914.     } else {
  915.         // Could be editing a widget, using the site editor, etc.
  916.         $render_capability = apply_filters( 'acf/blocks/render_capability', 'edit_theme_options', $args['post_id'] );
  918.         if ( ! current_user_can( $render_capability ) ) {
  919.             wp_send_json_error();
  920.         }
  921.     }
  923.     $args['block']   = isset( $_REQUEST['block'] ) ? $_REQUEST['block'] : false; //phpcs:ignore -- requires auth; designed to contain unescaped html.
  924.     $args['context'] = isset( $_REQUEST['context'] ) ? $_REQUEST['context'] : array(); //phpcs:ignore -- requires auth; designed to contain unescaped html.
  926.     $block       = $args['block'];
  927.     $query       = $args['query'];
  928.     $client_id   = $args['clientId'];
  929.     $raw_context = $args['context'];
  930.     $post_id     = $args['post_id'];
  932.     // Bail early if no block.
  933.     if ( ! $block ) {
  934.         wp_send_json_error();
  935.     }
  937.     // Unslash and decode $_POST data for block and context.
  938.     $block = wp_unslash( $block );
  939.     $block = json_decode( $block, true );
  941.     $context = false;
  942.     if ( ! empty( $raw_context ) ) {
  943.         $raw_context = wp_unslash( $raw_context );
  944.         $raw_context = json_decode( $raw_context, true );
  945.         if ( is_array( $raw_context ) ) {
  946.             $context = $raw_context;
  947.             // Check if a postId is set in the context, otherwise try and use it the default post_id.
  948.             $post_id = isset( $context['postId'] ) ? intval( $context['postId'] ) : intval( $args['post_id'] );
  949.         }
  950.     }
  952.     // Check if clientId should become $block['id'].
  953.     if ( empty( $block['id'] ) && ! empty( $client_id ) ) {
  954.         $block['id'] = $client_id;
  955.     }
  957.     // Prepare block ensuring all settings and attributes exist.
  958.     $block = acf_prepare_block( $block );
  959.     $block = acf_add_block_meta_values( $block, $post_id );
  961.     if ( ! $block ) {
  962.         wp_send_json_error();
  963.     }
  965.     // Load field defaults when first previewing a block.
  966.     $first_preview = false;
  967.     if ( ! empty( $query['preview'] ) && ! $block['data'] ) {
  968.         $fields = acf_get_block_fields( $block );
  969.         foreach ( $fields as $field ) {
  970.             $block['data'][ "_{$field['name']}" ] = $field['key'];
  971.         }
  972.         $first_preview = true;
  973.     }
  975.     // Setup postdata allowing form to load meta.
  976.     acf_setup_meta( $block['data'], $block['id'], true );
  978.     // Setup main postdata for post_id.
  979.     global $post;
  980.     //phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- required for block template rendering.
  981.     $post = get_post( $post_id );
  982.     setup_postdata( $post );
  984.     // Vars.
  985.     $response = array( 'clientId' => $client_id );
  987.     // Check if we've recieved serialised form data
  988.     $use_post_data = false;
  989.     if ( ! empty( $block['data'] ) && is_array( $block['data'] ) ) {
  990.         // Ensure we've got field keys posted.
  991.         $valid_field_keys = array_filter( array_keys( $block['data'] ), 'acf_is_field_key' );
  992.         if ( ! empty( $valid_field_keys ) ) {
  993.             $use_post_data = true;
  994.         }
  995.     }
  997.     $query['validate'] = ( ! empty( $query['validate'] ) && ( $query['validate'] === 'true' || $query['validate'] === true ) );
  998.     if ( ! empty( $query['validate'] ) || ! empty( $block['validate'] ) ) {
  999.         $response['validation'] = acf_get_block_validation_state( $block, $first_preview, $use_post_data );
  1000.     }
  1002.     // Query form.
  1003.     if ( ! empty( $query['form'] ) ) {
  1005.         // Load fields for form.
  1006.         $fields = acf_get_block_fields( $block );
  1008.         // Prefix field inputs to avoid multiple blocks using the same name/id attributes.
  1009.         acf_prefix_fields( $fields, "acf-{$block['id']}" );
  1011.         if ( $fields ) {
  1012.             // Start Capture.
  1013.             ob_start();
  1015.             // Render.
  1016.             echo '<div class="acf-block-fields acf-fields" data-block-id="' . esc_attr( $block['id'] ) . '">';
  1017.                 acf_render_fields( $fields, $block['id'], 'div', 'field' );
  1018.             echo '</div>';
  1020.             // Store Capture.
  1021.             $response['form'] = ob_get_clean();
  1022.         } else {
  1023.             // There are no fields on this block.
  1024.             $response['form'] = acf_get_empty_block_form_html( $block['name'] ); //phpcs:ignore -- escaped in function.
  1025.         }
  1026.     }
  1028.     // Query preview.
  1029.     if ( ! empty( $query['preview'] ) ) {
  1030.         // Render_callback vars.
  1031.         $content    = '';
  1032.         $is_preview = true;
  1034.         // Render and store HTML.
  1035.         $response['preview'] = acf_rendered_block( $block, $content, $is_preview, $post_id, null, $context, true );
  1036.     }
  1038.     // Send response.
  1039.     wp_send_json_success( $response );
  1040. }
  1042. // Register ajax action.
  1043. acf_register_ajax( 'fetch-block', 'acf_ajax_fetch_block' );
  1045. /**
  1046.  * Render the empty block form for when a block has no fields assigned.
  1047.  *
  1048.  * @since   6.0.0
  1049.  *
  1050.  * @param   string $block_name The block name current being rendered.
  1051.  * @return  string The html that makes up a block form with no fields.
  1052.  */
  1053. function acf_get_empty_block_form_html( $block_name ) {
  1055.     $message = __( 'This block contains no editable fields.', 'acf' );
  1057.     if ( acf_current_user_can_admin() ) {
  1058.         $message .= ' ';
  1059.         $message .= sprintf(
  1060.             /* translators: %s: an admin URL to the field group edit screen */
  1061.             __( 'Assign a <a href="%s" target="_blank">field group</a> to add fields to this block.', 'acf' ),
  1062.             admin_url( 'edit.php?post_type=acf-field-group' )
  1063.         );
  1064.     }
  1066.     $message = apply_filters( 'acf/blocks/no_fields_assigned_message', $message, $block_name );
  1068.     if ( ! is_string( $message ) ) {
  1069.         $message = '';
  1070.     }
  1072.     if ( empty( $message ) ) {
  1073.         return acf_esc_html( '<div class="acf-empty-block-fields"></div>' );
  1074.     } else {
  1075.         return acf_esc_html( '<div class="acf-block-fields acf-fields acf-empty-block-fields">' . $message . '</div>' );
  1076.     }
  1077. }
  1079. /**
  1080.  * Parse content that may contain HTML block comments and saves ACF block meta.
  1081.  *
  1082.  * @since   5.7.13
  1083.  *
  1084.  * @param   string $text Content that may contain HTML block comments.
  1085.  * @return  string
  1086.  */
  1087. function acf_parse_save_blocks( $text = '' ) {
  1089.     // Search text for dynamic blocks and modify attrs.
  1090.     return addslashes(
  1091.         preg_replace_callback(
  1092.             '/<!--\s+wp:(?P<name>[\S]+)\s+(?P<attrs>{[\S\s]+?})\s+(?P<void>\/)?-->/',
  1093.             'acf_parse_save_blocks_callback',
  1094.             stripslashes( $text )
  1095.         )
  1096.     );
  1097. }
  1099. // Hook into saving process.
  1100. add_filter( 'content_save_pre', 'acf_parse_save_blocks', 5, 1 );
  1102. /**
  1103.  * Callback used in preg_replace to modify ACF Block comment.
  1104.  *
  1105.  * @since   5.7.13
  1106.  *
  1107.  * @param   array $matches The preg matches.
  1108.  * @return  string
  1109.  */
  1110. function acf_parse_save_blocks_callback( $matches ) {
  1111.     // Defaults.
  1112.     $name  = isset( $matches['name'] ) ? $matches['name'] : '';
  1113.     $attrs = isset( $matches['attrs'] ) ? json_decode( $matches['attrs'], true ) : '';
  1114.     $void  = isset( $matches['void'] ) ? $matches['void'] : '';
  1116.     // Bail early if missing data or not an ACF Block.
  1117.     if ( ! $name || ! $attrs || ! acf_has_block_type( $name ) ) {
  1118.         return $matches[0];
  1119.     }
  1121.     // Check if we need to generate a block ID.
  1122.     $block_id = acf_ensure_block_id_prefix( acf_get_block_id( $attrs ) );
  1124.     if ( ! empty( $attrs['data'] ) ) {
  1125.         if ( acf_block_uses_post_meta( $attrs ) ) {
  1126.             // Block ID is used later to retrieve & save values.
  1127.             $attrs['id'] = $block_id;
  1129.             // Cache the values until we have a post ID and can save.
  1130.             $store = acf_get_store( 'block-meta-values' );
  1131.             $store->set( $block_id, $attrs['data'] );
  1133.             // No need to store values in post content.
  1134.             unset( $attrs['data'] );
  1135.         } else {
  1136.             // Convert "data" to "meta".
  1137.             // No need to check if already in meta format. Local Meta will do this for us.
  1138.             $attrs['data'] = acf_setup_meta( $attrs['data'], $block_id );
  1139.         }
  1140.     }
  1142.     /**
  1143.      * Filters the block attributes before saving.
  1144.      *
  1145.      * @since 5.7.14
  1146.      *
  1147.      * @param array $attrs The block attributes.
  1148.      */
  1149.     $attrs = apply_filters( 'acf/pre_save_block', $attrs );
  1151.     // Gutenberg expects a specific encoding format.
  1152.     $attrs = acf_serialize_block_attributes( $attrs );
  1154.     return '<!-- wp:' . $name . ' ' . $attrs . ' ' . $void . '-->';
  1155. }
  1157. /**
  1158.  * Return or generate a block ID.
  1159.  *
  1160.  * @since 6.0.0
  1161.  *
  1162.  * @param array   $attributes A block attributes array.
  1163.  * @param array   $context    The block context array, defaults to an empty array.
  1164.  * @param boolean $force      If we should generate a new block ID even if one exists.
  1165.  * @return string A block ID.
  1166.  */
  1167. function acf_get_block_id( $attributes, $context = array(), $force = false ) {
  1168.     $context = is_array( $context ) ? $context : array();
  1170.     ksort( $context );
  1171.     $attributes['_acf_context'] = $context;
  1172.     if ( empty( $attributes['id'] ) || $force ) {
  1173.         unset( $attributes['id'] );
  1175.         // Remove all empty string values as they're not present in JS hash building.
  1176.         foreach ( $attributes as $key => $value ) {
  1177.             if ( '' === $value ) {
  1178.                 unset( $attributes[ $key ] );
  1179.             }
  1180.         }
  1182.         // Check if data is empty and remove it if so to match JS hash building.
  1183.         if ( isset( $attributes['data'] ) && empty( $attributes['data'] ) ) {
  1184.             unset( $attributes['data'] );
  1185.         }
  1187.         ksort( $attributes );
  1188.         return md5( wp_json_encode( $attributes, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE ) );
  1189.     }
  1190.     return $attributes['id'];
  1191. }
  1193. /**
  1194.  * Ensure a block ID always has a block_ prefix for post meta internals.
  1195.  *
  1196.  * @since 6.0.0
  1197.  *
  1198.  * @param string $block_id A possibly non-prefixed block ID.
  1199.  * @return string A prefixed block ID.
  1200.  */
  1201. function acf_ensure_block_id_prefix( $block_id ) {
  1202.     if ( substr( $block_id, 0, 6 ) === 'block_' ) {
  1203.         return $block_id;
  1204.     }
  1205.     return 'block_' . $block_id;
  1206. }
  1208. /**
  1209.  * This directly copied from the WordPress core `serialize_block_attributes()` function.
  1210.  *
  1211.  * We need this in order to make sure that block attributes are stored in a way that is
  1212.  * consistent with how Gutenberg sends them over from JS, and so that things like wp_kses()
  1213.  * work as expected. Copied from core to get around a bug that was fixed in 5.8.1 or on the off chance
  1214.  * that folks are still using WP 5.3 or below.
  1215.  *
  1216.  * TODO: Remove this when we refactor `acf_parse_save_blocks_callback()` to use `serialize_block()`,
  1217.  * or when we're confident that folks aren't using WP versions prior to 5.8.
  1218.  *
  1219.  * @since 5.12
  1220.  *
  1221.  * @param array $block_attributes Attributes object.
  1222.  * @return string Serialized attributes.
  1223.  */
  1224. function acf_serialize_block_attributes( $block_attributes ) {
  1225.     $encoded_attributes = wp_json_encode( $block_attributes, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE );
  1226.     $encoded_attributes = preg_replace( '/--/', '\\u002d\\u002d', $encoded_attributes );
  1227.     $encoded_attributes = preg_replace( '/</', '\\u003c', $encoded_attributes );
  1228.     $encoded_attributes = preg_replace( '/>/', '\\u003e', $encoded_attributes );
  1229.     $encoded_attributes = preg_replace( '/&/', '\\u0026', $encoded_attributes );
  1230.     // Regex: /\\"/.
  1231.     $encoded_attributes = preg_replace( '/\\\\"/', '\\u0022', $encoded_attributes );
  1233.     return $encoded_attributes;
  1234. }
  1236. /**
  1237.  * Handle validating a block's fields and return the validity, and any errors.
  1238.  *
  1239.  * This function can use values loaded into Local Meta, which means they have to be
  1240.  * converted back to the data format before they can be validated.
  1241.  *
  1242.  * @since 6.3
  1243.  *
  1244.  * @param array   $block          An array of the block's data attribute.
  1245.  * @param boolean $using_defaults True if the block is currently being generated with default values. Default false.
  1246.  * @param boolean $use_post_data  True if we should validate the POSTed data rather than local meta values. Default false.
  1247.  * @param boolean $on_load        True if we're validating as part of a render. This is essentially the same as a first load. Default false.
  1248.  * @return array An array containing a valid boolean, and an errors array.
  1249.  */
  1250. function acf_get_block_validation_state( $block, $using_defaults = false, $use_post_data = false, $on_load = false ) {
  1251.     $block_id = $block['id'];
  1253.     if ( $on_load && empty( $block['validate_on_load'] ) ) {
  1254.         // If we're in a page load render, and validate on load is false, skip validation.
  1255.         $errors = false;
  1256.     } elseif ( $use_post_data ) {
  1257.         $errors = acf_validate_block_from_post_data( $block );
  1258.     } elseif ( $using_defaults || empty( $block['data'] ) ) {
  1259.         // If data is empty or it's first preview, load the default fields for this block so we can get a required validation state from the current field set.
  1260.         // Treat as "on load" if it's the first render of a block.
  1261.         if ( empty( $block['validate_on_load'] ) ) {
  1262.             $errors = false;
  1263.         } else {
  1264.             $errors = acf_validate_block_from_local_meta( $block_id, acf_get_block_fields( $block ), true );
  1265.         }
  1266.     } else {
  1267.         $errors = acf_validate_block_from_local_meta( $block_id, get_field_objects( $block_id, false ), false );
  1268.     }
  1270.     return array(
  1271.         'valid'  => empty( $errors ),
  1272.         'errors' => $errors,
  1273.     );
  1274. }
  1276. /**
  1277.  * Handle the specific validation for a block from POSTed values.
  1278.  *
  1279.  * @since 6.3.1
  1280.  *
  1281.  * @param array $block The block object containing the POSTed values and other block data
  1282.  * @return array|boolean An array containing the validation errors, or false if there are no errors.
  1283.  */
  1284. function acf_validate_block_from_post_data( $block ) {
  1285.     acf_reset_validation_errors();
  1286.     acf_validate_values( $block['data'], "acf-{$block['id']}" );
  1287.     $errors = acf_get_validation_errors();
  1288.     return $errors;
  1289. }
  1291. /**
  1292.  * Handle the specific validation for a block from local meta.
  1293.  *
  1294.  * This function uses the values loaded into Local Meta, which means they have to be
  1295.  * converted back to the data format because they can be validated.
  1296.  *
  1297.  * @since 6.3.1
  1298.  *
  1299.  * @param string  $block_id       The block ID.
  1300.  * @param array   $field_objects  The field objects in local meta to be validated.
  1301.  * @param boolean $using_defaults True if this is the first load of the block, when special validation may apply.
  1302.  * @return array|boolean An array containing the validation errors, or false if there are no errors.
  1303.  */
  1304. function acf_validate_block_from_local_meta( $block_id, $field_objects, $using_defaults = false ) {
  1305.     if ( empty( $field_objects ) ) {
  1306.         return false;
  1307.     }
  1309.     $using_loaded_meta = false;
  1310.     if ( acf_get_data( $block_id . '_loaded_meta_values' ) ) {
  1311.         $using_loaded_meta = true;
  1312.     }
  1314.     acf_reset_validation_errors();
  1315.     foreach ( $field_objects as $field ) {
  1316.         // Skip for nested fields - these don't work correctly on initial load of a saved block.
  1317.         if ( ! empty( $field['sub_fields'] ) ) {
  1318.             continue;
  1319.         }
  1321.         // If we're using default values, or loaded meta we may have values which are about to be populated at field render, so shouldn't raise errors here.
  1322.         if ( $using_defaults || $using_loaded_meta ) {
  1323.             // Fields with conditional logic applied shouldn't be validated during first load as conditionals aren't respected.
  1324.             if ( ! empty( $field['conditional_logic'] ) ) {
  1325.                 continue;
  1326.             }
  1328.             // If we've got a empty value with a default value set and it's first load, don't produce a validation error as it will be substituted on render.
  1329.             if ( $field['required'] && empty( $field['value'] ) && ! empty( $field['default_value'] ) ) {
  1330.                 continue;
  1331.             }
  1333.             // If we're loading a few radio or select-like fields, without allow null, HTML will automatically select the first value on render, so skip here.
  1334.             if ( $field['required'] && in_array( $field['type'], array( 'radio', 'button_group', 'select' ), true ) && ! $field['allow_null'] ) {
  1335.                 continue;
  1336.             }
  1337.         }
  1339.         $key   = $field['key'];
  1340.         $value = $field['value'];
  1341.         acf_validate_value( $value, $field, "acf-{$block_id}[{$key}]" );
  1342.     }
  1344.     return acf_get_validation_errors();
  1345. }
  1347. /**
  1348.  * Set ACF data before a rest call if media scripts have not been enqueued yet for after REST reset.
  1349.  *
  1350.  * @date    07/06/22
  1351.  * @since   6.0
  1352.  *
  1353.  * @param   WP_REST_Response|WP_HTTP_Response|WP_Error|mixed $response The WordPress response object.
  1354.  * @return  mixed
  1355.  */
  1356. function acf_set_after_rest_media_enqueue_reset_flag( $response ) {
  1357.     global $wp_actions;
  1359.     acf_set_data( 'acf_inside_rest_call', true );
  1360.     acf_set_data( 'acf_should_reset_media_enqueue', empty( $wp_actions['wp_enqueue_media'] ) );
  1361.     acf_set_data( 'acf_did_render_block_form', false );
  1363.     return $response;
  1364. }
  1365. add_filter( 'rest_request_before_callbacks', 'acf_set_after_rest_media_enqueue_reset_flag' );
  1367. /**
  1368.  * Reset wp_enqueue_media action count after REST call so it can happen inside the main execution if required.
  1369.  *
  1370.  * @date    07/06/22
  1371.  * @since   6.0
  1372.  *
  1373.  * @param   WP_REST_Response|WP_HTTP_Response|WP_Error|mixed $response The WordPress response object.
  1374.  * @return  mixed
  1375.  */
  1376. function acf_reset_media_enqueue_after_rest( $response ) {
  1377.     acf_set_data( 'acf_inside_rest_call', false );
  1378.     if ( acf_get_data( 'acf_should_reset_media_enqueue' ) && acf_get_data( 'acf_did_render_block_form' ) ) {
  1379.         global $wp_actions;
  1380.         //phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- no other option here as this works around a breaking WordPress change with REST preload scopes.
  1381.         $wp_actions['wp_enqueue_media'] = 0;
  1382.     }
  1384.     return $response;
  1385. }
  1386. add_filter( 'rest_request_after_callbacks', 'acf_reset_media_enqueue_after_rest' );
  1388. /**
  1389.  * Checks if the provided block is configured to save/load post meta.
  1390.  *
  1391.  * @since 6.3
  1392.  *
  1393.  * @param array $block The block to check.
  1394.  * @return boolean
  1395.  */
  1396. function acf_block_uses_post_meta( $block ): bool {
  1397.     if ( ! empty( $block['name'] ) && ! isset( $block['use_post_meta'] ) ) {
  1398.         $block = acf_get_block_type( $block['name'] );
  1399.     }
  1401.     return ! empty( $block['use_post_meta'] );
  1402. }
  1404. /**
  1405.  * Loads ACF field values from the post meta if the block is configured to do so.
  1406.  *
  1407.  * @since 6.3
  1408.  *
  1409.  * @param array   $block   The block to get values for.
  1410.  * @param integer $post_id The ID of the post to retrieve meta from.
  1411.  * @return array
  1412.  */
  1413. function acf_add_block_meta_values( $block, $post_id ) {
  1414.     // Bail if the block already has data (i.e. previewing an update).
  1415.     if ( ! is_array( $block ) || ! empty( $block['data'] ) ) {
  1416.         return $block;
  1417.     }
  1419.     // Bail if block doesn't load from meta.
  1420.     if ( ! acf_block_uses_post_meta( $block ) ) {
  1421.         return $block;
  1422.     }
  1424.     // Bail if we don't have a post ID or block ID.
  1425.     if ( empty( $post_id ) || empty( $block['id'] ) ) {
  1426.         return $block;
  1427.     }
  1429.     $fields = acf_get_block_fields( $block );
  1431.     if ( empty( $fields ) ) {
  1432.         return $block;
  1433.     }
  1435.     $values   = array();
  1436.     $store    = acf_get_store( 'values' );
  1437.     $block_id = acf_ensure_block_id_prefix( $block['id'] );
  1439.     foreach ( $fields as $field ) {
  1440.         $value = acf_get_value( $post_id, $field );
  1442.         // Make sure we got a value (i.e. $allow_load = true).
  1443.         if ( ! $store->has( "{$post_id}:{$field['name']}" ) ) {
  1444.             continue;
  1445.         }
  1447.         $store->set( "{$block_id}:{$field['name']}", $value );
  1449.         $values[ $field['name'] ]       = $value;
  1450.         $values[ '_' . $field['name'] ] = $field['key']; // TODO: Is there a better way to generate this?
  1451.     }
  1453.     $block['data'] = $values;
  1455.     acf_set_data( $block_id . '_loaded_meta_values', true );
  1457.     return $block;
  1458. }
  1460. /**
  1461.  * Stores ACF field values in post meta for any blocks configured to do so.
  1462.  *
  1463.  * @since 6.3
  1464.  *
  1465.  * @param integer $post_id The ID of the post being saved.
  1466.  * @param WP_Post $post    The post object.
  1467.  * @return void
  1468.  */
  1469. function acf_save_block_meta_values( $post_id, $post ) {
  1470.     $meta_values = acf_get_block_meta_values_to_save( $post->post_content );
  1472.     if ( empty( $meta_values ) ) {
  1473.         return;
  1474.     }
  1476.     // Save values for any post meta blocks.
  1477.     acf_save_post( $post_id, $meta_values );
  1478. }
  1479. add_action( 'save_post', 'acf_save_block_meta_values', 10, 2 );
  1481. /**
  1482.  * Iterates over blocks in post content and retrieves values
  1483.  * that need to be saved to post meta.
  1484.  *
  1485.  * @since 6.3
  1486.  *
  1487.  * @param string $content The content saved for the post.
  1488.  * @return array An array containing the field values that need to be saved.
  1489.  */
  1490. function acf_get_block_meta_values_to_save( $content = '' ) {
  1491.     $meta_values = array();
  1493.     // Bail early if not in a format we expect or if it has no blocks.
  1494.     if ( ! is_string( $content ) || empty( $content ) || ! has_blocks( $content ) ) {
  1495.         return $meta_values;
  1496.     }
  1498.     $blocks = parse_blocks( $content );
  1500.     // Bail if no blocks to save.
  1501.     if ( ! is_array( $blocks ) || empty( $blocks ) ) {
  1502.         return $meta_values;
  1503.     }
  1505.     foreach ( $blocks as $block ) {
  1506.         // Verify this is an ACF block that should save to meta.
  1507.         if ( ! acf_block_uses_post_meta( $block['attrs'] ) ) {
  1508.             continue;
  1509.         }
  1511.         // We need a block ID to retrieve the values from cache.
  1512.         $block_id = ! empty( $block['attrs']['id'] ) ? $block['attrs']['id'] : false;
  1513.         if ( ! $block_id ) {
  1514.             continue;
  1515.         }
  1517.         // Verify that we have values for this block.
  1518.         $store = acf_get_store( 'block-meta-values' );
  1519.         if ( ! $store->has( $block_id ) ) {
  1520.             continue;
  1521.         }
  1523.         // Get the values and remove from cache.
  1524.         $block_values = $store->get( $block_id );
  1525.         $store->remove( $block_id );
  1527.         $meta_values = array_merge( $meta_values, $block_values );
  1528.     }
  1530.     return $meta_values;
  1531. }