| @@ -6,37 +6,26 @@ | ||
| 6 | 6 | * @package automattic/jetpack |
| 7 | 7 | */ |
| 8 | 8 | |
| 9 | 9 | use Automattic\Jetpack\Assets; |
| 10 | +use Automattic\Jetpack\Assets\Shared_Stores_Assets; | |
| 10 | 11 | use Automattic\Jetpack\Blocks; |
| 11 | 12 | use Automattic\Jetpack\Connection\Initial_State as Connection_Initial_State; |
| 12 | 13 | use Automattic\Jetpack\Connection\Manager as Connection_Manager; |
| 13 | 14 | use Automattic\Jetpack\Constants; |
| 14 | 15 | use Automattic\Jetpack\Current_Plan as Jetpack_Plan; |
| 15 | -use Automattic\Jetpack\Publicize\Jetpack_Social_Settings\Dismissed_Notices; | |
| 16 | +use Automattic\Jetpack\Modules; | |
| 17 | +use Automattic\Jetpack\My_Jetpack\Initializer as My_Jetpack_Initializer; | |
| 16 | 18 | use Automattic\Jetpack\Status; |
| 17 | 19 | use Automattic\Jetpack\Status\Host; |
| 18 | 20 | |
| 19 | -// phpcs:disable Universal.Files.SeparateFunctionsFromOO.Mixed -- TODO: Move the functions and such to some other file. | |
| 21 | +if ( ! defined( 'ABSPATH' ) ) { | |
| 22 | + exit( 0 ); | |
| 23 | +} | |
| 20 | 24 | |
| 21 | -/** | |
| 22 | - * Wrapper function to safely register a gutenberg block type | |
| 23 | - * | |
| 24 | - * @deprecated 9.1.0 Use Automattic\\Jetpack\\Blocks::jetpack_register_block instead | |
| 25 | - * | |
| 26 | - * @see register_block_type | |
| 27 | - * | |
| 28 | - * @since 6.7.0 | |
| 29 | - * | |
| 30 | - * @param string $slug Slug of the block. | |
| 31 | - * @param array $args Arguments that are passed into register_block_type. | |
| 32 | - * | |
| 33 | - * @return WP_Block_Type|false The registered block type on success, or false on failure. | |
| 34 | - */ | |
| 35 | -function jetpack_register_block( $slug, $args = array() ) { | |
| 36 | - _deprecated_function( __METHOD__, '9.1.0', 'Automattic\\Jetpack\\Blocks::jetpack_register_block' ); | |
| 37 | - return Blocks::jetpack_register_block( $slug, $args ); | |
| 38 | -} | |
| 25 | +// Required directly so the AI master-gate helper is available regardless of | |
| 26 | +// which loader pulled this class in. | |
| 27 | +require_once __DIR__ . '/_inc/lib/class-jetpack-ai-settings.php'; | |
| 39 | 28 | |
| 40 | 29 | /** |
| 41 | 30 | * General Gutenberg editor specific functionality |
| 42 | 31 | */ |
| @@ -82,8 +71,133 @@ | ||
| 82 | 71 | 'jetpack/revue', |
| 83 | 72 | ); |
| 84 | 73 | |
| 85 | 74 | /** |
| 75 | + * Display-only blocks whose registration PHP can be deferred until the block | |
| 76 | + * actually appears on a front-end page. | |
| 77 | + * | |
| 78 | + * Every block listed here has been verified to be "pure": the callback it hooks | |
| 79 | + * to `init` does nothing but call Blocks::jetpack_register_block() (plus trivial | |
| 80 | + * connection/module guards). It registers exactly one block type named | |
| 81 | + * `jetpack/<dir>` (matching its directory), and any front-end hooks it adds (asset | |
| 82 | + * enqueues, wp_footer, filters, …) live inside its render callback, so they only | |
| 83 | + * run when the block is rendered. | |
| 84 | + * | |
| 85 | + * On plain front-end requests these blocks are NOT loaded on `init`. Instead they | |
| 86 | + * are registered just-in-time the first time the block (or a block whose subtree | |
| 87 | + * contains it) is encountered while rendering, via self::lazy_register_deferred_block() | |
| 88 | + * on `pre_render_block`. On admin/REST/cron/CLI/XML-RPC (block-editor) requests they | |
| 89 | + * keep loading eagerly so the editor, the block-types REST endpoint and server-side | |
| 90 | + * rendering are unaffected. | |
| 91 | + * | |
| 92 | + * One class of front-end request is NOT safe to defer on: front-end block editors | |
| 93 | + * (e.g. P2) render the inserter on a plain front-end page, so is_block_editor_context() | |
| 94 | + * is false, yet the block must be registered at `init` for get_availability() to report | |
| 95 | + * it as available. self::load_independent_blocks() therefore never defers a block that | |
| 96 | + * ships in the `no-post-editor` preset (extensions/index.json) — those are exactly the | |
| 97 | + * blocks available in editors other than the post editor. A block listed here that is | |
| 98 | + * also in `no-post-editor` simply keeps loading eagerly. | |
| 99 | + * | |
| 100 | + * A block must NOT be added here if: | |
| 101 | + * - its `init` callback registers any other hook, post meta, REST route, | |
| 102 | + * shortcode, block pattern or hooked-block; | |
| 103 | + * - it registers more than one block type, or a block name that differs from its | |
| 104 | + * directory name (e.g. videopress registers `jetpack/videopress-block`); or | |
| 105 | + * - it uses `plan_check` (its availability is computed from the init-time | |
| 106 | + * `jetpack_register_gutenberg_extensions` hook, which lazy registration bypasses, | |
| 107 | + * so the front-end availability nudge/render could read a stale value); or | |
| 108 | + * - a front-end path reads its entry from get_cached_availability() before the | |
| 109 | + * block renders. Deferred blocks appear unavailable there until the lazy | |
| 110 | + * registration callback runs; or | |
| 111 | + * - its block file can be `require`d by another runtime code path after `init` | |
| 112 | + * (e.g. slideshow is included by modules/shortcodes/slideshow.php). The lazy | |
| 113 | + * loader registers a block by running the `init` callback its include adds; if | |
| 114 | + * the file was already included elsewhere, the include is a no-op and the | |
| 115 | + * callback would never run, so the block would silently fail to register; or | |
| 116 | + * - another runtime code path calls a function defined in its block file | |
| 117 | + * (e.g. button defines Button\render_email(), called by subscriptions and | |
| 118 | + * memberships for WooCommerce e-mail rendering). Deferring the file would leave | |
| 119 | + * that function undefined when the dependent path runs; or | |
| 120 | + * - it registers a `render_email_callback`. That callback is read off the | |
| 121 | + * registered block type by the WooCommerce e-mail editor — an out-of-band | |
| 122 | + * renderer that does not go through `pre_render_block`/`do_blocks` — so the block | |
| 123 | + * must already be registered when an e-mail containing it is rendered, which can | |
| 124 | + * happen on a front-end request (e.g. a transactional e-mail sent during checkout). | |
| 125 | + * | |
| 126 | + * When in doubt, leave it out: omitted blocks simply keep their current eager | |
| 127 | + * behavior. | |
| 128 | + * | |
| 129 | + * @since 16.0 | |
| 130 | + * @var string[] Block feature names (directory names, without the `jetpack/` prefix). | |
| 131 | + */ | |
| 132 | + private static $lazy_blocks = array( | |
| 133 | + 'blog-stats', | |
| 134 | + 'blogging-prompt', | |
| 135 | + 'business-hours', | |
| 136 | + 'eventbrite', | |
| 137 | + 'gif', | |
| 138 | + 'goodreads', | |
| 139 | + 'google-calendar', | |
| 140 | + 'google-docs-embed', | |
| 141 | + 'image-compare', | |
| 142 | + 'like', | |
| 143 | + 'markdown', | |
| 144 | + 'nextdoor', | |
| 145 | + 'payments-intro', | |
| 146 | + 'pinterest', | |
| 147 | + 'related-posts', | |
| 148 | + 'repeat-visitor', | |
| 149 | + 'sharing-buttons', | |
| 150 | + 'story', | |
| 151 | + 'tock', | |
| 152 | + 'top-posts', | |
| 153 | + 'voice-to-content', | |
| 154 | + ); | |
| 155 | + | |
| 156 | + /** | |
| 157 | + * Blocks that were deferred on the current request and still need to be | |
| 158 | + * registered just-in-time when first rendered. Keyed by block feature name. | |
| 159 | + * | |
| 160 | + * @since 16.0 | |
| 161 | + * @var array<string,bool> | |
| 162 | + */ | |
| 163 | + private static $deferred_blocks = array(); | |
| 164 | + | |
| 165 | + /** | |
| 166 | + * Fallback minimum plan requirements for WordPress.com/Atomic sites. | |
| 167 | + * | |
| 168 | + * Used when features have conditional availability (e.g., sticker-based gating) | |
| 169 | + * and don't appear in features_data['available']. This only affects the upsell | |
| 170 | + * message shown to users. | |
| 171 | + * | |
| 172 | + * @since 15.5 | |
| 173 | + * @var array Feature slug => minimum WordPress.com plan slug. | |
| 174 | + */ | |
| 175 | + private static $wpcom_minimum_plan_fallbacks = array( | |
| 176 | + 'donations' => 'value_bundle', | |
| 177 | + 'payment-buttons' => 'value_bundle', | |
| 178 | + 'paypal-payment-buttons' => 'value_bundle', | |
| 179 | + ); | |
| 180 | + | |
| 181 | + /** | |
| 182 | + * Storing the contents of the preset file. | |
| 183 | + * | |
| 184 | + * Already been json_decode. | |
| 185 | + * | |
| 186 | + * @var null|object JSON decoded object after first usage. | |
| 187 | + */ | |
| 188 | + private static $preset_cache = null; | |
| 189 | + | |
| 190 | + /** | |
| 191 | + * Keep track of JS loading strategies for each block that needs it. | |
| 192 | + * | |
| 193 | + * @var array<string, array|bool> | |
| 194 | + * | |
| 195 | + * @since 15.0 | |
| 196 | + */ | |
| 197 | + private static $block_js_loading_strategies = array(); | |
| 198 | + | |
| 199 | + /** | |
| 86 | 200 | * Check to see if a minimum version of Gutenberg is available. Because a Gutenberg version is not available in |
| 87 | 201 | * php if the Gutenberg plugin is not installed, if we know which minimum WP release has the required version we can |
| 88 | 202 | * optionally fall back to that. |
| 89 | 203 | * |
| @@ -117,8 +231,9 @@ | ||
| 117 | 231 | $version_available = version_compare( $wp_version, $version_requirements['wp'], '>=' ); |
| 118 | 232 | } |
| 119 | 233 | |
| 120 | 234 | if ( ! $version_available ) { |
| 235 | + $slug = self::remove_extension_prefix( $slug ); | |
| 121 | 236 | self::set_extension_unavailable( |
| 122 | 237 | $slug, |
| 123 | 238 | 'incorrect_gutenberg_version', |
| 124 | 239 | array( |
| @@ -177,9 +292,10 @@ | ||
| 177 | 292 | * |
| 178 | 293 | * @param string $slug Slug of the extension. |
| 179 | 294 | */ |
| 180 | 295 | public static function set_extension_available( $slug ) { |
| 181 | - self::$availability[ self::remove_extension_prefix( $slug ) ] = true; | |
| 296 | + $slug = self::remove_extension_prefix( $slug ); | |
| 297 | + self::$availability[ $slug ] = true; | |
| 182 | 298 | } |
| 183 | 299 | |
| 184 | 300 | /** |
| 185 | 301 | * Set the reason why an extension (block or plugin) is unavailable |
| @@ -212,10 +328,10 @@ | ||
| 212 | 328 | // The block editor may apply an upgrade nudge if `missing_plan` is the reason. |
| 213 | 329 | // Add a descriptive suffix to disable behavior but provide informative reason. |
| 214 | 330 | $reason .= '__nudge_disabled'; |
| 215 | 331 | } |
| 216 | - | |
| 217 | - self::$availability[ self::remove_extension_prefix( $slug ) ] = array( | |
| 332 | + $slug = self::remove_extension_prefix( $slug ); | |
| 333 | + self::$availability[ $slug ] = array( | |
| 218 | 334 | 'reason' => $reason, |
| 219 | 335 | 'details' => $details, |
| 220 | 336 | ); |
| 221 | 337 | } |
| @@ -237,11 +353,13 @@ | ||
| 237 | 353 | * |
| 238 | 354 | * @return void |
| 239 | 355 | */ |
| 240 | 356 | public static function reset() { |
| 241 | - self::$extensions = null; | |
| 242 | - self::$availability = array(); | |
| 243 | - self::$cached_availability = null; | |
| 357 | + self::$extensions = null; | |
| 358 | + self::$availability = array(); | |
| 359 | + self::$cached_availability = null; | |
| 360 | + self::$block_js_loading_strategies = array(); | |
| 361 | + self::$deferred_blocks = array(); | |
| 244 | 362 | } |
| 245 | 363 | |
| 246 | 364 | /** |
| 247 | 365 | * Return the Gutenberg extensions (blocks and plugins) directory |
| @@ -261,28 +379,49 @@ | ||
| 261 | 379 | |
| 262 | 380 | /** |
| 263 | 381 | * Checks for a given .json file in the blocks folder. |
| 264 | 382 | * |
| 383 | + * @deprecated 14.3 | |
| 384 | + * | |
| 265 | 385 | * @param string $preset The name of the .json file to look for. |
| 266 | 386 | * |
| 267 | 387 | * @return bool True if the file is found. |
| 268 | 388 | */ |
| 269 | 389 | public static function preset_exists( $preset ) { |
| 390 | + _deprecated_function( __METHOD__, '14.3' ); | |
| 270 | 391 | return file_exists( JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $preset . '.json' ); |
| 271 | 392 | } |
| 272 | 393 | |
| 273 | 394 | /** |
| 274 | - * Decodes JSON loaded from a preset file in the blocks folder | |
| 395 | + * Decodes JSON loaded from the preset file in the blocks folder | |
| 275 | 396 | * |
| 276 | - * @param string $preset The name of the .json file to load. | |
| 397 | + * @since 14.3 Deprecated argument. Only one value is ever used. | |
| 277 | 398 | * |
| 399 | + * @param null $deprecated No longer used. | |
| 400 | + * | |
| 278 | 401 | * @return mixed Returns an object if the file is present, or false if a valid .json file is not present. |
| 279 | 402 | */ |
| 280 | - public static function get_preset( $preset ) { | |
| 281 | - return json_decode( | |
| 282 | - // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents | |
| 283 | - file_get_contents( JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $preset . '.json' ) | |
| 284 | - ); | |
| 403 | + public static function get_preset( $deprecated = null ) { | |
| 404 | + if ( $deprecated ) { | |
| 405 | + _deprecated_argument( __METHOD__, '14.3', 'The $preset argument is no longer needed or used.' ); | |
| 406 | + } | |
| 407 | + | |
| 408 | + if ( self::$preset_cache ) { | |
| 409 | + return self::$preset_cache; | |
| 410 | + } | |
| 411 | + | |
| 412 | + /* | |
| 413 | + * The manifest is a build artifact and is absent in a source checkout (e.g. when | |
| 414 | + * running the test suite). Return false — as documented — rather than calling | |
| 415 | + * wp_json_file_decode() on a missing file, which triggers _doing_it_wrong(). | |
| 416 | + */ | |
| 417 | + $preset_file = JETPACK__PLUGIN_DIR . self::get_blocks_directory() . 'index.json'; | |
| 418 | + if ( ! file_exists( $preset_file ) ) { | |
| 419 | + return false; | |
| 420 | + } | |
| 421 | + | |
| 422 | + self::$preset_cache = wp_json_file_decode( $preset_file ); | |
| 423 | + return self::$preset_cache; | |
| 285 | 424 | } |
| 286 | 425 | |
| 287 | 426 | /** |
| 288 | 427 | * Returns a list of Jetpack Gutenberg extensions (blocks and plugins), based on index.json |
| @@ -289,11 +428,9 @@ | ||
| 289 | 428 | * |
| 290 | 429 | * @return array A list of blocks: eg [ 'publicize', 'markdown' ] |
| 291 | 430 | */ |
| 292 | 431 | public static function get_jetpack_gutenberg_extensions_allowed_list() { |
| 293 | - $preset_extensions_manifest = self::preset_exists( 'index' ) | |
| 294 | - ? self::get_preset( 'index' ) | |
| 295 | - : (object) array(); | |
| 432 | + $preset_extensions_manifest = ( defined( 'TESTING_IN_JETPACK' ) && TESTING_IN_JETPACK ) ? array() : self::get_preset(); | |
| 296 | 433 | $blocks_variation = self::blocks_variation(); |
| 297 | 434 | |
| 298 | 435 | return self::get_extensions_preset_for_variation( $preset_extensions_manifest, $blocks_variation ); |
| 299 | 436 | } |
| @@ -308,8 +445,13 @@ | ||
| 308 | 445 | public static function get_available_extensions( $allowed_extensions = null ) { |
| 309 | 446 | $exclusions = get_option( 'jetpack_excluded_extensions', array() ); |
| 310 | 447 | $allowed_extensions = $allowed_extensions === null ? self::get_jetpack_gutenberg_extensions_allowed_list() : $allowed_extensions; |
| 311 | 448 | |
| 449 | + // Avoid errors if option data is not as expected. | |
| 450 | + if ( ! is_array( $exclusions ) ) { | |
| 451 | + $exclusions = array(); | |
| 452 | + } | |
| 453 | + | |
| 312 | 454 | return array_diff( $allowed_extensions, $exclusions ); |
| 313 | 455 | } |
| 314 | 456 | |
| 315 | 457 | /** |
| @@ -405,8 +547,13 @@ | ||
| 405 | 547 | * |
| 406 | 548 | * @param array |
| 407 | 549 | */ |
| 408 | 550 | self::$extensions = apply_filters( 'jetpack_set_available_extensions', self::get_available_extensions() ); |
| 551 | + | |
| 552 | + if ( ! is_array( self::$extensions ) ) { | |
| 553 | + _doing_it_wrong( __METHOD__, esc_html__( 'The jetpack_set_available_extensions filter must return an array.', 'jetpack' ), '14.9' ); | |
| 554 | + self::$extensions = array(); | |
| 555 | + } | |
| 409 | 556 | } |
| 410 | 557 | |
| 411 | 558 | return self::$extensions; |
| 412 | 559 | } |
| @@ -449,20 +596,25 @@ | ||
| 449 | 596 | if ( ! Jetpack::is_connection_ready() && ! ( new Status() )->is_offline_mode() ) { |
| 450 | 597 | return false; |
| 451 | 598 | } |
| 452 | 599 | |
| 453 | - if ( get_option( 'jetpack_blocks_disabled', false ) ) { | |
| 454 | - return false; | |
| 600 | + $return = true; | |
| 601 | + | |
| 602 | + if ( ! ( new Modules() )->is_active( 'blocks' ) ) { | |
| 603 | + $return = false; | |
| 455 | 604 | } |
| 456 | 605 | |
| 457 | 606 | /** |
| 458 | - * Filter to disable Gutenberg blocks | |
| 607 | + * Filter to enable Gutenberg blocks. | |
| 459 | 608 | * |
| 609 | + * Defaults to true if (connected or in offline mode) and the Blocks module is active. | |
| 610 | + * | |
| 460 | 611 | * @since 6.5.0 |
| 612 | + * @since 13.9 Filter is able to activate or deactivate Gutenberg blocks. | |
| 461 | 613 | * |
| 462 | 614 | * @param bool true Whether to load Gutenberg blocks |
| 463 | 615 | */ |
| 464 | - return (bool) apply_filters( 'jetpack_gutenberg', true ); | |
| 616 | + return (bool) apply_filters( 'jetpack_gutenberg', $return ); | |
| 465 | 617 | } |
| 466 | 618 | |
| 467 | 619 | /** |
| 468 | 620 | * Queue a script to set `Jetpack_Block_Assets_Base_Url`. |
| @@ -475,11 +627,15 @@ | ||
| 475 | 627 | private static function register_blocks_assets_base_url() { |
| 476 | 628 | if ( ! wp_script_is( 'jetpack-blocks-assets-base-url', 'registered' ) ) { |
| 477 | 629 | // phpcs:ignore WordPress.WP.EnqueuedResourceParameters.MissingVersion -- No actual script, so no version needed. |
| 478 | 630 | wp_register_script( 'jetpack-blocks-assets-base-url', false, array(), null, array( 'in_footer' => false ) ); |
| 631 | + $json_encode_flags = JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP; | |
| 632 | + if ( get_option( 'blog_charset' ) === 'UTF-8' ) { | |
| 633 | + $json_encode_flags |= JSON_UNESCAPED_UNICODE; | |
| 634 | + } | |
| 479 | 635 | wp_add_inline_script( |
| 480 | 636 | 'jetpack-blocks-assets-base-url', |
| 481 | - 'var Jetpack_Block_Assets_Base_Url=' . wp_json_encode( plugins_url( self::get_blocks_directory(), JETPACK__PLUGIN_FILE ), JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP ) . ';', | |
| 637 | + 'var Jetpack_Block_Assets_Base_Url=' . wp_json_encode( plugins_url( self::get_blocks_directory(), JETPACK__PLUGIN_FILE ), $json_encode_flags ) . ';', | |
| 482 | 638 | 'before' |
| 483 | 639 | ); |
| 484 | 640 | } |
| 485 | 641 | } |
| @@ -569,9 +725,8 @@ | ||
| 569 | 725 | |
| 570 | 726 | // Enqueue script. |
| 571 | 727 | $script_relative_path = self::get_blocks_directory() . $type . '/view.js'; |
| 572 | 728 | $script_deps_path = JETPACK__PLUGIN_DIR . self::get_blocks_directory() . $type . '/view.asset.php'; |
| 573 | - $script_dependencies[] = 'wp-polyfill'; | |
| 574 | 729 | $script_dependencies[] = 'jetpack-blocks-assets-base-url'; |
| 575 | 730 | if ( file_exists( $script_deps_path ) ) { |
| 576 | 731 | $asset_manifest = include $script_deps_path; |
| 577 | 732 | $script_dependencies = array_unique( array_merge( $script_dependencies, $asset_manifest['dependencies'] ) ); |
| @@ -580,11 +735,12 @@ | ||
| 580 | 735 | if ( ! Blocks::is_amp_request() && self::block_has_asset( $script_relative_path ) ) { |
| 581 | 736 | $script_version = self::get_asset_version( $script_relative_path ); |
| 582 | 737 | $view_script = plugins_url( $script_relative_path, JETPACK__PLUGIN_FILE ); |
| 583 | 738 | $view_script = add_query_arg( 'minify', 'false', $view_script ); |
| 739 | + $strategy = self::get_block_js_loading_strategy( $type ); | |
| 584 | 740 | |
| 585 | 741 | // Enqueue dependencies. |
| 586 | - wp_enqueue_script( 'jetpack-block-' . $type, $view_script, $script_dependencies, $script_version, false ); | |
| 742 | + wp_enqueue_script( 'jetpack-block-' . $type, $view_script, $script_dependencies, $script_version, $strategy ); | |
| 587 | 743 | |
| 588 | 744 | // If this is a customizer preview, enqueue the dependencies and render the script directly to the preview after autosave. |
| 589 | 745 | // phpcs:ignore WordPress.Security.NonceVerification.Recommended |
| 590 | 746 | if ( is_customize_preview() && ! empty( $_GET['customize_autosaved'] ) ) { |
| @@ -590,9 +746,9 @@ | ||
| 590 | 746 | if ( is_customize_preview() && ! empty( $_GET['customize_autosaved'] ) ) { |
| 591 | 747 | // The Map block is dependent on wp-element, and it doesn't appear to to be possible to load |
| 592 | 748 | // this dynamically into the customizer iframe currently. |
| 593 | 749 | if ( 'map' === $type ) { |
| 594 | - echo '<div>' . esc_html_e( 'No map preview available. Publish and refresh to see this widget.', 'jetpack' ) . '</div>'; | |
| 750 | + echo '<div>' . esc_html__( 'No map preview available. Publish and refresh to see this widget.', 'jetpack' ) . '</div>'; | |
| 595 | 751 | echo '<script>'; |
| 596 | 752 | echo 'Array.from(document.getElementsByClassName(\'wp-block-jetpack-map\')).forEach(function(element){element.style.display = \'none\';})'; |
| 597 | 753 | echo '</script>'; |
| 598 | 754 | } else { |
| @@ -637,18 +793,40 @@ | ||
| 637 | 793 | if ( ! self::should_load() ) { |
| 638 | 794 | return; |
| 639 | 795 | } |
| 640 | 796 | |
| 641 | - /** | |
| 642 | - * This can be called multiple times per page load in the admin, during the `enqueue_block_assets` action. | |
| 643 | - * These assets are necessary for the admin for editing but are not necessary for each pattern preview. | |
| 644 | - * Therefore we dequeue them, so they don't load for each pattern preview iframe. | |
| 797 | + /* | |
| 798 | + * When the user returns to the editor right after a successful plan | |
| 799 | + * purchase (signalled by the `plan_upgraded` redirect argument), refresh | |
| 800 | + * the locally cached plan from WordPress.com before block availability is | |
| 801 | + * computed below. Otherwise `available_blocks` is derived from the stale | |
| 802 | + * `jetpack_active_plan` option (only refreshed by the daily heartbeat) and | |
| 803 | + * paid blocks keep showing their upgrade nudge even though the plan is now | |
| 804 | + * active. Simple sites gate features live via `wpcom_site_has_feature()`, | |
| 805 | + * so they neither need nor benefit from this. | |
| 806 | + * | |
| 807 | + * The refresh is a blocking WordPress.com request, so it is guarded to run | |
| 808 | + * only on a connected, non-WPCOM site, throttled to once per minute (a | |
| 809 | + * repeated or bookmarked `?plan_upgraded` URL cannot trigger a request on | |
| 810 | + * every load), and time-boxed so a slow origin cannot hang the editor. The | |
| 811 | + * client-side reload fallback covers a skipped or failed refresh. The value | |
| 812 | + * is only used to trigger a cache refresh from an authoritative source, so | |
| 813 | + * no nonce is required. See FORMS-712. | |
| 645 | 814 | */ |
| 646 | - if ( ! wp_should_load_block_editor_scripts_and_styles() ) { | |
| 647 | - wp_dequeue_script( 'jp-tracks' ); | |
| 648 | - wp_dequeue_script( 'jetpack-blocks-editor' ); | |
| 815 | + if ( | |
| 816 | + ! empty( $_GET['plan_upgraded'] ) // phpcs:ignore WordPress.Security.NonceVerification.Recommended | |
| 817 | + && ! ( defined( 'IS_WPCOM' ) && IS_WPCOM ) | |
| 818 | + && Jetpack::is_connection_ready() | |
| 819 | + && ! get_transient( 'jetpack_plan_upgraded_refresh' ) | |
| 820 | + ) { | |
| 821 | + set_transient( 'jetpack_plan_upgraded_refresh', 1, MINUTE_IN_SECONDS ); | |
| 649 | 822 | |
| 650 | - return; | |
| 823 | + $cap_plan_refresh_timeout = static function () { | |
| 824 | + return 5; | |
| 825 | + }; | |
| 826 | + add_filter( 'http_request_timeout', $cap_plan_refresh_timeout, PHP_INT_MAX ); | |
| 827 | + Jetpack_Plan::refresh_from_wpcom(); | |
| 828 | + remove_filter( 'http_request_timeout', $cap_plan_refresh_timeout, PHP_INT_MAX ); | |
| 651 | 829 | } |
| 652 | 830 | |
| 653 | 831 | $status = new Status(); |
| 654 | 832 | |
| @@ -677,12 +855,28 @@ | ||
| 677 | 855 | 'dependencies' => array( 'jetpack-blocks-assets-base-url' ), |
| 678 | 856 | ) |
| 679 | 857 | ); |
| 680 | 858 | |
| 859 | + /** | |
| 860 | + * This can be called multiple times per page load in the admin, during the `enqueue_block_assets` action. | |
| 861 | + * These assets are necessary for the admin for editing but are not necessary for each pattern preview. | |
| 862 | + * Therefore we dequeue them, so they don't load for each pattern preview iframe. | |
| 863 | + */ | |
| 864 | + if ( ! wp_should_load_block_editor_scripts_and_styles() ) { | |
| 865 | + wp_dequeue_script( 'jp-tracks' ); | |
| 866 | + wp_dequeue_script( 'jetpack-blocks-editor' ); | |
| 867 | + | |
| 868 | + return; | |
| 869 | + } | |
| 870 | + | |
| 681 | 871 | // Hack around #20357 (specifically, that the editor bundle depends on |
| 682 | 872 | // wp-edit-post but wp-edit-post's styles break the Widget Editor and |
| 683 | 873 | // Site Editor) until a real fix gets unblocked. |
| 684 | 874 | // @todo Remove this once #20357 is properly fixed. |
| 875 | + $wp_styles_fix = wp_styles()->query( 'jetpack-blocks-editor', 'registered' ); | |
| 876 | + if ( empty( $wp_styles_fix ) ) { | |
| 877 | + wp_die( 'Your installation of Jetpack is incomplete. Please run "jetpack build plugins/jetpack" in your dev env.' ); | |
| 878 | + } | |
| 685 | 879 | wp_styles()->query( 'jetpack-blocks-editor', 'registered' )->deps = array(); |
| 686 | 880 | |
| 687 | 881 | Assets::enqueue_script( 'jetpack-blocks-editor' ); |
| 688 | 882 | |
| @@ -705,15 +899,16 @@ | ||
| 705 | 899 | wp_enqueue_style( 'recoleta-font', '//s1.wp.com/i/fonts/recoleta/css/400.min.css', array(), Constants::get_constant( 'JETPACK__VERSION' ) ); |
| 706 | 900 | } |
| 707 | 901 | // AI Assistant |
| 708 | 902 | $ai_assistant_state = array( |
| 709 | - 'is-enabled' => apply_filters( 'jetpack_ai_enabled', true ), | |
| 710 | - 'is-playground-visible' => Constants::is_true( 'JETPACK_AI_ASSISTANT_PLAYGROUND' ), | |
| 903 | + 'is-enabled' => Jetpack_AI_Settings::is_ai_enabled(), | |
| 904 | + 'is-seo-enabled' => Jetpack_AI_Settings::is_ai_seo_enabled(), | |
| 711 | 905 | ); |
| 712 | 906 | |
| 713 | 907 | $screen_base = null; |
| 714 | 908 | if ( function_exists( 'get_current_screen' ) ) { |
| 715 | - $screen_base = get_current_screen()->base; | |
| 909 | + $current_screen = get_current_screen(); | |
| 910 | + $screen_base = $current_screen ? $current_screen->base : null; | |
| 716 | 911 | } |
| 717 | 912 | |
| 718 | 913 | $modules = array(); |
| 719 | 914 | if ( class_exists( 'Jetpack_Core_API_Module_List_Endpoint' ) ) { |
| @@ -720,8 +915,9 @@ | ||
| 720 | 915 | $module_list_endpoint = new Jetpack_Core_API_Module_List_Endpoint(); |
| 721 | 916 | $modules = $module_list_endpoint->get_modules(); |
| 722 | 917 | } |
| 723 | 918 | |
| 919 | + $jetpack_plan = Jetpack_Plan::get(); | |
| 724 | 920 | $initial_state = array( |
| 725 | 921 | 'available_blocks' => self::get_availability(), |
| 726 | 922 | 'blocks_variation' => $blocks_variation, |
| 727 | 923 | 'modules' => $modules, |
| @@ -733,8 +929,28 @@ | ||
| 733 | 929 | 'is_private_site' => $status->is_private_site(), |
| 734 | 930 | 'is_coming_soon' => $status->is_coming_soon(), |
| 735 | 931 | 'is_offline_mode' => $status->is_offline_mode(), |
| 736 | 932 | 'is_newsletter_feature_enabled' => class_exists( '\Jetpack_Memberships' ), |
| 933 | + // Whether the current user may send a newsletter test email to an | |
| 934 | + // address other than their own. The wpcom guard enforces this on send | |
| 935 | + // (also checking add_users and site stickers); this flag only controls | |
| 936 | + // whether the editor's recipient field is editable. Approximated with | |
| 937 | + // manage_options so editors, who can only test-send to themselves, | |
| 938 | + // aren't shown an editable field that would always be rejected. | |
| 939 | + 'can_send_test_email_to_others' => current_user_can( 'manage_options' ), | |
| 940 | + // Which settings-driven subscribe placements are on, for the Site Editor's admin-only notice. | |
| 941 | + 'subscribe_placements' => current_user_can( 'manage_options' ) ? array( | |
| 942 | + 'sm_enabled' => (bool) get_option( 'sm_enabled', false ), | |
| 943 | + 'jetpack_subscribe_overlay_enabled' => (bool) get_option( 'jetpack_subscribe_overlay_enabled', false ), | |
| 944 | + 'jetpack_subscribe_floating_button_enabled' => (bool) get_option( 'jetpack_subscribe_floating_button_enabled', false ), | |
| 945 | + 'wpcom_action_bar' => ( new Host() )->is_wpcom_simple() && ! get_option( 'wpcom_hide_action_bar' ), | |
| 946 | + ) : null, | |
| 947 | + // this is the equivalent of JP initial state siteData.showMyJetpack (class-jetpack-redux-state-helper) | |
| 948 | + // used to determine if we can link to My Jetpack from the block editor | |
| 949 | + 'is_my_jetpack_available' => My_Jetpack_Initializer::should_initialize(), | |
| 950 | + 'jetpack_plan' => array( | |
| 951 | + 'data' => $jetpack_plan['product_slug'], | |
| 952 | + ), | |
| 737 | 953 | /** |
| 738 | 954 | * Enable the RePublicize UI in the block editor context. |
| 739 | 955 | * |
| 740 | 956 | * @module publicize |
| @@ -739,18 +955,13 @@ | ||
| 739 | 955 | * |
| 740 | 956 | * @module publicize |
| 741 | 957 | * |
| 742 | 958 | * @since 10.3.0 |
| 743 | - * @deprecated $$next_version$$ This is a feature flag that is no longer used. | |
| 959 | + * @deprecated 11.5 This is a feature flag that is no longer used. | |
| 744 | 960 | * |
| 745 | 961 | * @param bool true Enable the RePublicize UI in the block editor context. Defaults to true. |
| 746 | 962 | */ |
| 747 | 963 | 'republicize_enabled' => apply_filters( 'jetpack_block_editor_republicize_feature', true ), |
| 748 | - /** | |
| 749 | - * Prevent the registration of the blocks from extensions/blocks/contact-form | |
| 750 | - * if the Forms package is enabled. | |
| 751 | - */ | |
| 752 | - 'is_form_package_enabled' => apply_filters( 'jetpack_contact_form_use_package', true ), | |
| 753 | 964 | ), |
| 754 | 965 | 'siteFragment' => $status->get_site_suffix(), |
| 755 | 966 | 'adminUrl' => esc_url( admin_url() ), |
| 756 | 967 | 'tracksUserData' => $user_data, |
| @@ -758,31 +969,23 @@ | ||
| 758 | 969 | 'allowedMimeTypes' => wp_get_mime_types(), |
| 759 | 970 | 'siteLocale' => str_replace( '_', '-', get_locale() ), |
| 760 | 971 | 'ai-assistant' => $ai_assistant_state, |
| 761 | 972 | 'screenBase' => $screen_base, |
| 973 | + /** | |
| 974 | + * Add your own feature flags to the block editor. | |
| 975 | + * | |
| 976 | + * You can access the feature flags in the block editor via hasFeatureFlag( 'your-feature-flag' ) function. | |
| 977 | + * | |
| 978 | + * @since 14.8 | |
| 979 | + * | |
| 980 | + * @param array true Enable the RePublicize UI in the block editor context. Defaults to true. | |
| 981 | + */ | |
| 982 | + 'feature_flags' => apply_filters( 'jetpack_block_editor_feature_flags', array() ), | |
| 762 | 983 | 'pluginBasePath' => plugins_url( '', Constants::get_constant( 'JETPACK__PLUGIN_FILE' ) ), |
| 763 | 984 | ); |
| 764 | 985 | |
| 765 | - if ( Jetpack::is_module_active( 'publicize' ) && function_exists( 'publicize_init' ) ) { | |
| 766 | - $publicize = publicize_init(); | |
| 767 | - $jetpack_social_settings = new Automattic\Jetpack\Publicize\Jetpack_Social_Settings\Settings(); | |
| 768 | - $settings = $jetpack_social_settings->get_settings( true ); | |
| 769 | - | |
| 770 | - $initial_state['social'] = array( | |
| 771 | - 'sharesData' => $publicize->get_publicize_shares_info( $blog_id ), | |
| 772 | - 'hasPaidPlan' => $publicize->has_paid_plan(), | |
| 773 | - 'isEnhancedPublishingEnabled' => $publicize->has_enhanced_publishing_feature(), | |
| 774 | - 'isSocialImageGeneratorAvailable' => $settings['socialImageGeneratorSettings']['available'], | |
| 775 | - 'isSocialImageGeneratorEnabled' => $settings['socialImageGeneratorSettings']['enabled'], | |
| 776 | - 'dismissedNotices' => Dismissed_Notices::get_dismissed_notices(), | |
| 777 | - 'supportedAdditionalConnections' => $publicize->get_supported_additional_connections(), | |
| 778 | - 'autoConversionSettings' => $settings['autoConversionSettings'], | |
| 779 | - 'jetpackSharingSettingsUrl' => esc_url_raw( admin_url( 'admin.php?page=jetpack#/sharing' ) ), | |
| 780 | - ); | |
| 781 | - } | |
| 782 | - | |
| 783 | 986 | wp_localize_script( |
| 784 | - 'jetpack-blocks-editor', | |
| 987 | + Shared_Stores_Assets::SCRIPT_HANDLE, | |
| 785 | 988 | 'Jetpack_Editor_Initial_State', |
| 786 | 989 | $initial_state |
| 787 | 990 | ); |
| 788 | 991 | |
| @@ -790,13 +993,33 @@ | ||
| 790 | 993 | Connection_Initial_State::render_script( 'jetpack-blocks-editor' ); |
| 791 | 994 | } |
| 792 | 995 | |
| 793 | 996 | /** |
| 997 | + * Block feature names in the `no-post-editor` preset (extensions/index.json): blocks | |
| 998 | + * whose editor bundle is usable outside the post editor, so they appear in front-end | |
| 999 | + * block editors such as P2. These must never be deferred (see self::$lazy_blocks and | |
| 1000 | + * self::load_independent_blocks()). | |
| 1001 | + * | |
| 1002 | + * @since 16.2 | |
| 1003 | + * | |
| 1004 | + * @return string[] Feature names, or an empty array when the preset is unavailable. | |
| 1005 | + */ | |
| 1006 | + private static function get_no_post_editor_extensions() { | |
| 1007 | + $preset = self::get_preset(); | |
| 1008 | + if ( is_object( $preset ) && isset( $preset->{'no-post-editor'} ) && is_array( $preset->{'no-post-editor'} ) ) { | |
| 1009 | + return $preset->{'no-post-editor'}; | |
| 1010 | + } | |
| 1011 | + return array(); | |
| 1012 | + } | |
| 1013 | + | |
| 1014 | + /** | |
| 794 | 1015 | * Some blocks do not depend on a specific module, |
| 795 | 1016 | * and can consequently be loaded outside of the usual modules. |
| 796 | 1017 | * We will look for such modules in the extensions/ directory. |
| 797 | 1018 | * |
| 798 | 1019 | * @since 7.1.0 |
| 1020 | + * @since 16.0 Pure display blocks are deferred on front-end requests and registered on first render. | |
| 1021 | + * @since 16.2 Blocks in the `no-post-editor` preset are never deferred, so front-end editors (e.g. P2) keep them. | |
| 799 | 1022 | * @see wp_common_block_scripts_and_styles() |
| 800 | 1023 | */ |
| 801 | 1024 | public static function load_independent_blocks() { |
| 802 | 1025 | if ( self::should_load() ) { |
| @@ -803,11 +1026,38 @@ | ||
| 803 | 1026 | /** |
| 804 | 1027 | * Look for files that match our list of available Jetpack Gutenberg extensions (blocks and plugins). |
| 805 | 1028 | * If available, load them. |
| 806 | 1029 | */ |
| 807 | - $directories = array( 'blocks', 'plugins', 'extended-blocks', 'shared', 'store' ); | |
| 1030 | + $directories = array( 'blocks', 'plugins', 'extended-blocks' ); | |
| 808 | 1031 | |
| 1032 | + /* | |
| 1033 | + * On plain front-end requests, defer the registration PHP of pure display | |
| 1034 | + * blocks (see self::$lazy_blocks) until the block is actually encountered | |
| 1035 | + * while rendering. The block editor, the block-types REST endpoint and | |
| 1036 | + * server-side rendering all run in a "block-editor context" and keep loading | |
| 1037 | + * every block eagerly, so their behavior is unchanged. | |
| 1038 | + */ | |
| 1039 | + $defer = ! self::is_block_editor_context(); | |
| 1040 | + | |
| 1041 | + /* | |
| 1042 | + * Front-end block editors (e.g. P2) render the inserter on a plain front-end | |
| 1043 | + * request, so is_block_editor_context() is false there, yet a block must be | |
| 1044 | + * registered on `init` for get_availability() to report it and keep it in the | |
| 1045 | + * inserter. Never defer a block that ships in the `no-post-editor` preset — | |
| 1046 | + * those are precisely the blocks usable outside the post editor. | |
| 1047 | + */ | |
| 1048 | + $no_post_editor_blocks = $defer ? self::get_no_post_editor_extensions() : array(); | |
| 1049 | + | |
| 809 | 1050 | foreach ( static::get_extensions() as $extension ) { |
| 1051 | + if ( | |
| 1052 | + $defer | |
| 1053 | + && in_array( $extension, self::$lazy_blocks, true ) | |
| 1054 | + && ! in_array( $extension, $no_post_editor_blocks, true ) | |
| 1055 | + ) { | |
| 1056 | + self::$deferred_blocks[ $extension ] = true; | |
| 1057 | + continue; | |
| 1058 | + } | |
| 1059 | + | |
| 810 | 1060 | foreach ( $directories as $dirname ) { |
| 811 | 1061 | $path = JETPACK__PLUGIN_DIR . "extensions/{$dirname}/{$extension}/{$extension}.php"; |
| 812 | 1062 | |
| 813 | 1063 | if ( file_exists( $path ) ) { |
| @@ -815,12 +1065,314 @@ | ||
| 815 | 1065 | continue 2; |
| 816 | 1066 | } |
| 817 | 1067 | } |
| 818 | 1068 | } |
| 1069 | + | |
| 1070 | + if ( ! empty( self::$deferred_blocks ) ) { | |
| 1071 | + add_filter( 'pre_render_block', array( __CLASS__, 'lazy_register_deferred_block' ), 10, 3 ); | |
| 1072 | + } | |
| 819 | 1073 | } |
| 820 | 1074 | } |
| 821 | 1075 | |
| 822 | 1076 | /** |
| 1077 | + * Register deferred blocks present in a top-level block's subtree before it renders. | |
| 1078 | + * | |
| 1079 | + * Hooked to `pre_render_block`. For a top-level block ($parent_block is null) the | |
| 1080 | + * filter fires before core builds the block's WP_Block object, so we walk the whole | |
| 1081 | + * parsed subtree and register every deferred Jetpack block it contains. This must | |
| 1082 | + * happen at the top level: core resolves an inner block's `block_type` when it | |
| 1083 | + * constructs that inner WP_Block, which is *before* the inner block's own | |
| 1084 | + * `pre_render_block` fires — so registering a deferred dynamic block only when its | |
| 1085 | + * own inner filter fires would be too late and its render_callback would be skipped. | |
| 1086 | + * Inner-block invocations (non-null $parent_block) are ignored because the top-level | |
| 1087 | + * walk has already handled the whole tree. Returns $pre_render untouched. | |
| 1088 | + * | |
| 1089 | + * @since 16.0 | |
| 1090 | + * | |
| 1091 | + * @param string|null $pre_render The pre-rendered content. Default null. | |
| 1092 | + * @param array $parsed_block The parsed block being rendered. | |
| 1093 | + * @param \WP_Block|null $parent_block Parent block, or null for a top-level block. | |
| 1094 | + * | |
| 1095 | + * @return string|null Unchanged $pre_render. | |
| 1096 | + */ | |
| 1097 | + public static function lazy_register_deferred_block( $pre_render, $parsed_block, $parent_block = null ) { | |
| 1098 | + // Respect any earlier short-circuit, only act on top-level blocks, and stop | |
| 1099 | + // once every deferred block on the page has been registered. | |
| 1100 | + if ( null !== $pre_render || null !== $parent_block || empty( self::$deferred_blocks ) ) { | |
| 1101 | + return $pre_render; | |
| 1102 | + } | |
| 1103 | + | |
| 1104 | + self::register_deferred_blocks_in_subtree( $parsed_block ); | |
| 1105 | + | |
| 1106 | + return $pre_render; | |
| 1107 | + } | |
| 1108 | + | |
| 1109 | + /** | |
| 1110 | + * Recursively register any deferred Jetpack blocks found in a parsed block subtree. | |
| 1111 | + * | |
| 1112 | + * @since 16.0 | |
| 1113 | + * | |
| 1114 | + * @param array $parsed_block A parsed block (with optional `innerBlocks`). | |
| 1115 | + * @param array $seen_refs Reusable-block IDs already visited, to guard against cycles. | |
| 1116 | + * | |
| 1117 | + * @return void | |
| 1118 | + */ | |
| 1119 | + private static function register_deferred_blocks_in_subtree( $parsed_block, &$seen_refs = array() ) { | |
| 1120 | + if ( empty( self::$deferred_blocks ) ) { | |
| 1121 | + return; | |
| 1122 | + } | |
| 1123 | + | |
| 1124 | + $block_name = $parsed_block['blockName'] ?? ''; | |
| 1125 | + if ( '' !== $block_name && str_starts_with( $block_name, 'jetpack/' ) ) { | |
| 1126 | + $feature = substr( $block_name, strlen( 'jetpack/' ) ); | |
| 1127 | + if ( ! empty( self::$deferred_blocks[ $feature ] ) ) { | |
| 1128 | + // Only attempt registration once per block, whether or not it succeeds | |
| 1129 | + // (a block guarded by a connection/module check may intentionally not register). | |
| 1130 | + unset( self::$deferred_blocks[ $feature ] ); | |
| 1131 | + | |
| 1132 | + if ( ! self::is_registered( $block_name ) ) { | |
| 1133 | + self::load_and_register_deferred_block( $feature ); | |
| 1134 | + } | |
| 1135 | + } | |
| 1136 | + } | |
| 1137 | + | |
| 1138 | + /* | |
| 1139 | + * A synced pattern / reusable block (core/block) keeps its content in a separate | |
| 1140 | + * wp_block post that core only parses at render time (render_block_core_block), | |
| 1141 | + * so it is absent from this parsed tree. Resolve the reference and recurse so a | |
| 1142 | + * deferred block inside the pattern is registered before core builds its WP_Block. | |
| 1143 | + * | |
| 1144 | + * core/navigation has the same ref-based hidden-content shape (a wp_navigation | |
| 1145 | + * post) but is intentionally not handled: none of the deferred blocks can be | |
| 1146 | + * inserted into a navigation menu through the editor, and resolving the ref would | |
| 1147 | + * add a get_post()/parse_blocks() on essentially every front-end page (menus are | |
| 1148 | + * near-ubiquitous) for a case that cannot occur without hand-authored markup. | |
| 1149 | + */ | |
| 1150 | + if ( 'core/block' === $block_name && ! empty( $parsed_block['attrs']['ref'] ) ) { | |
| 1151 | + $ref = (int) $parsed_block['attrs']['ref']; | |
| 1152 | + if ( ! isset( $seen_refs[ $ref ] ) ) { | |
| 1153 | + $seen_refs[ $ref ] = true; | |
| 1154 | + $reusable_block = get_post( $ref ); | |
| 1155 | + if ( $reusable_block instanceof \WP_Post && 'wp_block' === $reusable_block->post_type ) { | |
| 1156 | + foreach ( parse_blocks( $reusable_block->post_content ) as $inner_block ) { | |
| 1157 | + self::register_deferred_blocks_in_subtree( $inner_block, $seen_refs ); | |
| 1158 | + } | |
| 1159 | + } | |
| 1160 | + } | |
| 1161 | + } | |
| 1162 | + | |
| 1163 | + if ( ! empty( $parsed_block['innerBlocks'] ) ) { | |
| 1164 | + foreach ( $parsed_block['innerBlocks'] as $inner_block ) { | |
| 1165 | + self::register_deferred_blocks_in_subtree( $inner_block, $seen_refs ); | |
| 1166 | + } | |
| 1167 | + } | |
| 1168 | + } | |
| 1169 | + | |
| 1170 | + /** | |
| 1171 | + * Include a deferred block's registration PHP and run the `init` callback it | |
| 1172 | + * adds, immediately. | |
| 1173 | + * | |
| 1174 | + * The block files register themselves with `add_action( 'init', … )`. By render | |
| 1175 | + * time `init` has long since fired, so including the file is not enough on its | |
| 1176 | + * own: we capture the callback(s) the include adds to `init` and invoke them now. | |
| 1177 | + * Only blocks in self::$lazy_blocks reach this path, and each adds exactly its | |
| 1178 | + * own registration callback to `init`, so this runs that single registration. | |
| 1179 | + * | |
| 1180 | + * @since 16.0 | |
| 1181 | + * | |
| 1182 | + * @param string $feature Block feature name (directory name without the `jetpack/` prefix). | |
| 1183 | + * | |
| 1184 | + * @return void | |
| 1185 | + */ | |
| 1186 | + private static function load_and_register_deferred_block( $feature ) { | |
| 1187 | + $path = JETPACK__PLUGIN_DIR . "extensions/blocks/{$feature}/{$feature}.php"; | |
| 1188 | + if ( ! file_exists( $path ) ) { | |
| 1189 | + self::warn_about_deferred_block_registration_failure( $feature, 'missing block registration file' ); | |
| 1190 | + return; | |
| 1191 | + } | |
| 1192 | + | |
| 1193 | + global $wp_filter; | |
| 1194 | + | |
| 1195 | + $before = isset( $wp_filter['init'] ) ? $wp_filter['init']->callbacks : array(); | |
| 1196 | + | |
| 1197 | + include_once $path; | |
| 1198 | + | |
| 1199 | + if ( ! isset( $wp_filter['init'] ) ) { | |
| 1200 | + self::warn_about_deferred_block_registration_failure( $feature, 'block file did not add an init callback' ); | |
| 1201 | + return; | |
| 1202 | + } | |
| 1203 | + | |
| 1204 | + $registered_callback = false; | |
| 1205 | + | |
| 1206 | + // Run (and then detach) any callback the include just added to `init`. | |
| 1207 | + foreach ( $wp_filter['init']->callbacks as $priority => $callbacks ) { | |
| 1208 | + foreach ( $callbacks as $id => $callback ) { | |
| 1209 | + if ( isset( $before[ $priority ][ $id ] ) ) { | |
| 1210 | + continue; | |
| 1211 | + } | |
| 1212 | + $registered_callback = true; | |
| 1213 | + if ( is_callable( $callback['function'] ) ) { | |
| 1214 | + call_user_func( $callback['function'] ); | |
| 1215 | + } | |
| 1216 | + remove_action( 'init', $callback['function'], $priority ); | |
| 1217 | + } | |
| 1218 | + } | |
| 1219 | + | |
| 1220 | + if ( ! $registered_callback ) { | |
| 1221 | + self::warn_about_deferred_block_registration_failure( $feature, 'block file did not add a new init callback' ); | |
| 1222 | + } | |
| 1223 | + } | |
| 1224 | + | |
| 1225 | + /** | |
| 1226 | + * Surface lazy-registration mistakes during debugging without adding front-end noise. | |
| 1227 | + * | |
| 1228 | + * @since 16.0 | |
| 1229 | + * | |
| 1230 | + * @param string $feature Block feature name (directory name without the `jetpack/` prefix). | |
| 1231 | + * @param string $reason Short reason for the failure. | |
| 1232 | + * | |
| 1233 | + * @return void | |
| 1234 | + */ | |
| 1235 | + private static function warn_about_deferred_block_registration_failure( $feature, $reason ) { | |
| 1236 | + if ( ! ( defined( 'WP_DEBUG' ) && WP_DEBUG ) || ! function_exists( '_doing_it_wrong' ) ) { | |
| 1237 | + return; | |
| 1238 | + } | |
| 1239 | + | |
| 1240 | + _doing_it_wrong( | |
| 1241 | + __METHOD__, | |
| 1242 | + sprintf( | |
| 1243 | + /* translators: 1: Jetpack block feature name. 2: Failure reason. */ | |
| 1244 | + esc_html__( 'Lazy Jetpack block registration failed for "%1$s": %2$s.', 'jetpack' ), | |
| 1245 | + esc_html( $feature ), | |
| 1246 | + esc_html( $reason ) | |
| 1247 | + ), | |
| 1248 | + '16.0' | |
| 1249 | + ); | |
| 1250 | + } | |
| 1251 | + | |
| 1252 | + /** | |
| 1253 | + * Determine whether the current request is a block-editor context that needs | |
| 1254 | + * every Jetpack block loaded eagerly on `init`. | |
| 1255 | + * | |
| 1256 | + * Returns true for admin, REST, cron, WP-CLI and XML-RPC requests so the editor, | |
| 1257 | + * the `/wp/v2/block-types` endpoint and server-side rendering keep seeing the full | |
| 1258 | + * set of blocks. Returns false only for plain front-end web requests, where pure | |
| 1259 | + * display blocks are registered just-in-time as they render. | |
| 1260 | + * | |
| 1261 | + * This runs at module-load time (around after_setup_theme), before core defines | |
| 1262 | + * REST_REQUEST during parse_request, so self-hosted and Atomic REST requests are | |
| 1263 | + * detected from the request URL instead of the constant. That URL check cannot | |
| 1264 | + * work on WordPress.com Simple: its public API filters `rest_url_prefix` to an | |
| 1265 | + * empty string, so rest_get_url_prefix() returns '' and the REST roots computed | |
| 1266 | + * below collapse to '//', which no request path can match. Simple's requests are | |
| 1267 | + * detected via REST_API_REQUEST instead, which its API entry points define before | |
| 1268 | + * wp-load.php runs. | |
| 1269 | + * | |
| 1270 | + * @since 16.0 | |
| 1271 | + * | |
| 1272 | + * @return bool True for block-editor (non-front-end) contexts, false for plain front-end requests. | |
| 1273 | + */ | |
| 1274 | + private static function is_block_editor_context() { | |
| 1275 | + if ( is_admin() ) { | |
| 1276 | + return true; | |
| 1277 | + } | |
| 1278 | + | |
| 1279 | + /* | |
| 1280 | + * Treat any non-front-end execution context as block-editor. These are not the | |
| 1281 | + * front-end hot path this gate optimizes, and some still render block content | |
| 1282 | + * (e.g. cron-generated subscription e-mails) that depends on full registration. | |
| 1283 | + * | |
| 1284 | + * Core defines REST_REQUEST during parse_request, after this runs, so it is | |
| 1285 | + * normally still unset here; it is checked anyway so the result stays correct | |
| 1286 | + * if this is ever called later in the request. REST_API_REQUEST is what catches | |
| 1287 | + * WordPress.com Simple, where the URL check below cannot work at all (see the | |
| 1288 | + * method docblock). | |
| 1289 | + */ | |
| 1290 | + if ( | |
| 1291 | + Constants::is_true( 'DOING_CRON' ) | |
| 1292 | + || Constants::is_true( 'WP_CLI' ) | |
| 1293 | + || Constants::is_true( 'XMLRPC_REQUEST' ) | |
| 1294 | + || Constants::is_true( 'REST_REQUEST' ) | |
| 1295 | + || Constants::is_true( 'REST_API_REQUEST' ) | |
| 1296 | + ) { | |
| 1297 | + return true; | |
| 1298 | + } | |
| 1299 | + | |
| 1300 | + /* | |
| 1301 | + * No request URI means a non-web execution context (WP-CLI without it, test | |
| 1302 | + * suites, etc.). A genuine front-end page request always carries one, so it | |
| 1303 | + * costs nothing on the hot path to treat the empty case as "load eagerly". | |
| 1304 | + */ | |
| 1305 | + $request_uri = isset( $_SERVER['REQUEST_URI'] ) ? sanitize_text_field( wp_unslash( $_SERVER['REQUEST_URI'] ) ) : ''; | |
| 1306 | + if ( '' === $request_uri ) { | |
| 1307 | + return true; | |
| 1308 | + } | |
| 1309 | + | |
| 1310 | + /* | |
| 1311 | + * Anchor the REST root (home path + prefix) at the start of the request path, | |
| 1312 | + * so a front-end URL that merely carries the prefix in a query value or a | |
| 1313 | + * deeper path segment is not misread as a REST request. home_url() is used | |
| 1314 | + * rather than rest_url() so detection does not depend on permalink structure. | |
| 1315 | + * Both the rewritten `/wp-json/` form and the index-permalink | |
| 1316 | + * `/index.php/wp-json/` form (used when the site lacks pretty permalinks) are | |
| 1317 | + * matched. | |
| 1318 | + */ | |
| 1319 | + $path = (string) wp_parse_url( $request_uri, PHP_URL_PATH ); | |
| 1320 | + if ( '' !== $path ) { | |
| 1321 | + $home_path = trailingslashit( (string) wp_parse_url( home_url(), PHP_URL_PATH ) ); | |
| 1322 | + $rest_prefix = trailingslashit( rest_get_url_prefix() ); | |
| 1323 | + $rest_roots = array( | |
| 1324 | + $home_path . $rest_prefix, | |
| 1325 | + $home_path . 'index.php/' . $rest_prefix, | |
| 1326 | + ); | |
| 1327 | + foreach ( $rest_roots as $rest_root ) { | |
| 1328 | + if ( str_starts_with( trailingslashit( $path ), $rest_root ) ) { | |
| 1329 | + return true; | |
| 1330 | + } | |
| 1331 | + } | |
| 1332 | + } | |
| 1333 | + | |
| 1334 | + // Plain-permalink REST uses a `rest_route` query var; match the exact key. | |
| 1335 | + $query = (string) wp_parse_url( $request_uri, PHP_URL_QUERY ); | |
| 1336 | + if ( '' !== $query ) { | |
| 1337 | + parse_str( $query, $query_vars ); | |
| 1338 | + if ( ! empty( $query_vars['rest_route'] ) ) { | |
| 1339 | + return true; | |
| 1340 | + } | |
| 1341 | + } | |
| 1342 | + | |
| 1343 | + return false; | |
| 1344 | + } | |
| 1345 | + | |
| 1346 | + /** | |
| 1347 | + * Editor-oriented extensions that nonetheless have front-end side effects and must | |
| 1348 | + * therefore keep loading on every request, even outside the block editor. | |
| 1349 | + * | |
| 1350 | + * Keyed by directory ('plugins' / 'extended-blocks') for an exact, intentional match. | |
| 1351 | + * | |
| 1352 | + * @since 16.0 | |
| 1353 | + * | |
| 1354 | + * @var array | |
| 1355 | + */ | |
| 1356 | + private static $frontend_editor_extensions = array( | |
| 1357 | + 'plugins' => array( | |
| 1358 | + // Mounts the Reader Chat widget on the front end (wp_enqueue_scripts) and | |
| 1359 | + // wires the AI sidebar/provider registration AI Assistant depends on. | |
| 1360 | + 'ai-assistant-plugin', | |
| 1361 | + // Signals Big Sky via the jetpack_image_studio_enabled filter on `init`, | |
| 1362 | + // which can run on the front end. | |
| 1363 | + 'image-studio', | |
| 1364 | + ), | |
| 1365 | + 'extended-blocks' => array( | |
| 1366 | + // Registers the videopress/video block on `init`, required to render it on the front end. | |
| 1367 | + 'videopress-video', | |
| 1368 | + // Registers the `premium-content/container` plan availability that the Premium Content | |
| 1369 | + // block's front-end render reads via required_plan_checks(); skipping it breaks the paywall. | |
| 1370 | + 'premium-content-container', | |
| 1371 | + ), | |
| 1372 | + ); | |
| 1373 | + | |
| 1374 | + /** | |
| 823 | 1375 | * Loads PHP components of block editor extensions. |
| 824 | 1376 | * |
| 825 | 1377 | * @since 8.9.0 |
| 826 | 1378 | */ |
| @@ -831,15 +1383,30 @@ | ||
| 831 | 1383 | 'extended-blocks', |
| 832 | 1384 | 'plugins', |
| 833 | 1385 | ); |
| 834 | 1386 | |
| 1387 | + $is_editor_context = self::is_block_editor_context(); | |
| 1388 | + | |
| 835 | 1389 | // Collect the extension paths. |
| 836 | 1390 | foreach ( $extensions_to_load as $extension_to_load ) { |
| 837 | 1391 | $extensions_folder = glob( JETPACK__PLUGIN_DIR . 'extensions/' . $extension_to_load . '/*' ); |
| 838 | 1392 | |
| 1393 | + $frontend_allow_list = self::$frontend_editor_extensions[ $extension_to_load ] ?? array(); | |
| 1394 | + | |
| 839 | 1395 | // Require each of the extension files, in case it exists. |
| 840 | 1396 | foreach ( $extensions_folder as $extension_folder ) { |
| 841 | - $name = basename( $extension_folder ); | |
| 1397 | + $name = basename( $extension_folder ); | |
| 1398 | + | |
| 1399 | + /* | |
| 1400 | + * On plain front-end requests, only load extensions that have known | |
| 1401 | + * front-end side effects. Editor-only extensions are skipped here and | |
| 1402 | + * loaded on admin/REST (block-editor) requests instead, reducing the | |
| 1403 | + * per-front-end-request PHP/opcache footprint. | |
| 1404 | + */ | |
| 1405 | + if ( ! $is_editor_context && ! in_array( $name, $frontend_allow_list, true ) ) { | |
| 1406 | + continue; | |
| 1407 | + } | |
| 1408 | + | |
| 842 | 1409 | $extension_file_path = JETPACK__PLUGIN_DIR . 'extensions/' . $extension_to_load . '/' . $name . '/' . $name . '.php'; |
| 843 | 1410 | |
| 844 | 1411 | if ( file_exists( $extension_file_path ) ) { |
| 845 | 1412 | include_once $extension_file_path; |
| @@ -849,24 +1416,8 @@ | ||
| 849 | 1416 | } |
| 850 | 1417 | } |
| 851 | 1418 | |
| 852 | 1419 | /** |
| 853 | - * Get CSS classes for a block. | |
| 854 | - * | |
| 855 | - * @since 7.7.0 | |
| 856 | - * | |
| 857 | - * @param string $slug Block slug. | |
| 858 | - * @param array $attr Block attributes. | |
| 859 | - * @param array $extra Potential extra classes you may want to provide. | |
| 860 | - * | |
| 861 | - * @return string $classes List of CSS classes for a block. | |
| 862 | - */ | |
| 863 | - public static function block_classes( $slug, $attr, $extra = array() ) { | |
| 864 | - _deprecated_function( __METHOD__, '9.0.0', 'Automattic\\Jetpack\\Blocks::classes' ); | |
| 865 | - return Blocks::classes( $slug, $attr, $extra ); | |
| 866 | - } | |
| 867 | - | |
| 868 | - /** | |
| 869 | 1420 | * Determine whether a site should use the default set of blocks, or a custom set. |
| 870 | 1421 | * Possible variations are currently beta, experimental, and production. |
| 871 | 1422 | * |
| 872 | 1423 | * @since 8.1.0 |
| @@ -962,9 +1513,9 @@ | ||
| 962 | 1513 | * Get a list of extensions available for the variation you chose. |
| 963 | 1514 | * |
| 964 | 1515 | * @since 8.1.0 |
| 965 | 1516 | * |
| 966 | - * @param obj $preset_extensions_manifest List of extensions available in Jetpack. | |
| 1517 | + * @param object $preset_extensions_manifest List of extensions available in Jetpack. | |
| 967 | 1518 | * @param string $blocks_variation Subset of blocks. production|beta|experimental. |
| 968 | 1519 | * |
| 969 | 1520 | * @return array $preset_extensions Array of extensions for that variation |
| 970 | 1521 | */ |
| @@ -1036,11 +1587,11 @@ | ||
| 1036 | 1587 | |
| 1037 | 1588 | // Normalize URL. |
| 1038 | 1589 | $url = sprintf( |
| 1039 | 1590 | '%s://%s%s%s', |
| 1040 | - isset( $url_components['scheme'] ) ? $url_components['scheme'] : 'https', | |
| 1591 | + $url_components['scheme'] ?? 'https', | |
| 1041 | 1592 | $url_components['host'], |
| 1042 | - isset( $url_components['path'] ) ? $url_components['path'] : '/', | |
| 1593 | + $url_components['path'] ?? '/', | |
| 1043 | 1594 | isset( $url_components['query'] ) ? '?' . $url_components['query'] : '' |
| 1044 | 1595 | ); |
| 1045 | 1596 | |
| 1046 | 1597 | if ( ! empty( $url_components['fragment'] ) ) { |
| @@ -1228,8 +1779,12 @@ | ||
| 1228 | 1779 | } |
| 1229 | 1780 | |
| 1230 | 1781 | if ( ! empty( $features_data['available'][ $slug ] ) ) { |
| 1231 | 1782 | $plan = $features_data['available'][ $slug ][0]; |
| 1783 | + } elseif ( isset( self::$wpcom_minimum_plan_fallbacks[ $slug ] ) ) { | |
| 1784 | + // Fallback for features with conditional availability (e.g., sticker-based gating) | |
| 1785 | + // that don't appear in features_data['available']. | |
| 1786 | + $plan = self::$wpcom_minimum_plan_fallbacks[ $slug ]; | |
| 1232 | 1787 | } |
| 1233 | 1788 | } else { |
| 1234 | 1789 | // Jetpack sites. |
| 1235 | 1790 | $plan = Jetpack_Plan::get_minimum_plan_for_feature( $slug ); |
| @@ -1256,15 +1811,15 @@ | ||
| 1256 | 1811 | return function ( $prepared_attributes, $block_content, $block ) use ( $render_callback, $slug ) { |
| 1257 | 1812 | $availability = self::get_cached_availability(); |
| 1258 | 1813 | $bare_slug = self::remove_extension_prefix( $slug ); |
| 1259 | 1814 | if ( isset( $availability[ $bare_slug ] ) && $availability[ $bare_slug ]['available'] ) { |
| 1260 | - return call_user_func( $render_callback, $prepared_attributes, $block_content ); | |
| 1815 | + return call_user_func( $render_callback, $prepared_attributes, $block_content, $block ); | |
| 1261 | 1816 | } |
| 1262 | 1817 | |
| 1263 | 1818 | // A preview of the block is rendered for admins on the frontend with an upgrade nudge. |
| 1264 | 1819 | if ( isset( $availability[ $bare_slug ] ) ) { |
| 1265 | 1820 | if ( self::should_show_frontend_preview( $availability[ $bare_slug ] ) ) { |
| 1266 | - $block_preview = call_user_func( $render_callback, $prepared_attributes, $block_content ); | |
| 1821 | + $block_preview = call_user_func( $render_callback, $prepared_attributes, $block_content, $block ); | |
| 1267 | 1822 | |
| 1268 | 1823 | // If the upgrade nudge isn't already being displayed by a parent block, display the nudge. |
| 1269 | 1824 | if ( isset( $block->attributes['shouldDisplayFrontendBanner'] ) && $block->attributes['shouldDisplayFrontendBanner'] ) { |
| 1270 | 1825 | $upgrade_nudge = self::upgrade_nudge( $availability[ $bare_slug ]['details']['required_plan'] ); |
| @@ -1290,9 +1845,9 @@ | ||
| 1290 | 1845 | * |
| 1291 | 1846 | * @return string |
| 1292 | 1847 | */ |
| 1293 | 1848 | public static function display_deprecated_block_message( $block_content, $block ) { |
| 1294 | - if ( in_array( $block['blockName'], self::$deprecated_blocks, true ) ) { | |
| 1849 | + if ( isset( $block['blockName'] ) && in_array( $block['blockName'], self::$deprecated_blocks, true ) ) { | |
| 1295 | 1850 | if ( current_user_can( 'edit_posts' ) ) { |
| 1296 | 1851 | $block_content = self::notice( |
| 1297 | 1852 | __( 'This block is no longer supported. Its contents will no longer be displayed to your visitors and as such this block should be removed.', 'jetpack' ), |
| 1298 | 1853 | 'warning', |
| @@ -1303,8 +1858,67 @@ | ||
| 1303 | 1858 | } |
| 1304 | 1859 | } |
| 1305 | 1860 | |
| 1306 | 1861 | return $block_content; |
| 1862 | + } | |
| 1863 | + | |
| 1864 | + /** | |
| 1865 | + * Register block metadata collection for Jetpack blocks. | |
| 1866 | + * This allows for more efficient block metadata loading by avoiding | |
| 1867 | + * individual block.json file reads at runtime. | |
| 1868 | + * | |
| 1869 | + * Uses wp_register_block_metadata_collection() if the manifest file | |
| 1870 | + * exists. The manifest file is auto-generated during the build process. | |
| 1871 | + * | |
| 1872 | + * Runs on plugins_loaded to ensure registration happens before individual | |
| 1873 | + * blocks register themselves on init. | |
| 1874 | + * | |
| 1875 | + * @static | |
| 1876 | + * @since 14.1 | |
| 1877 | + * @return void | |
| 1878 | + */ | |
| 1879 | + public static function register_block_metadata_collection() { | |
| 1880 | + $meta_file_path = JETPACK__PLUGIN_DIR . '_inc/blocks/blocks-manifest.php'; | |
| 1881 | + if ( file_exists( $meta_file_path ) ) { | |
| 1882 | + wp_register_block_metadata_collection( | |
| 1883 | + JETPACK__PLUGIN_DIR . '_inc/blocks/', | |
| 1884 | + $meta_file_path | |
| 1885 | + ); | |
| 1886 | + } | |
| 1887 | + } | |
| 1888 | + | |
| 1889 | + /** | |
| 1890 | + * Set the JS loading strategy for a block. | |
| 1891 | + * | |
| 1892 | + * @param string $block_name The block name. | |
| 1893 | + * @param array|bool $strategy The JS loading strategy. | |
| 1894 | + * | |
| 1895 | + * @since 15.0 | |
| 1896 | + */ | |
| 1897 | + public static function set_block_js_loading_strategy( $block_name, $strategy ) { | |
| 1898 | + self::$block_js_loading_strategies[ $block_name ] = $strategy; | |
| 1899 | + } | |
| 1900 | + | |
| 1901 | + /** | |
| 1902 | + * Get the JS loading strategy for a block. | |
| 1903 | + * | |
| 1904 | + * @param string $block_name The block name. | |
| 1905 | + * | |
| 1906 | + * @return array|bool The JS loading strategy for the block. | |
| 1907 | + * | |
| 1908 | + * @since 15.0 | |
| 1909 | + */ | |
| 1910 | + public static function get_block_js_loading_strategy( $block_name ) { | |
| 1911 | + $strategy = array( | |
| 1912 | + 'strategy' => 'defer', | |
| 1913 | + 'in_footer' => true, | |
| 1914 | + ); | |
| 1915 | + | |
| 1916 | + if ( isset( self::$block_js_loading_strategies[ $block_name ] ) ) { | |
| 1917 | + $strategy = self::$block_js_loading_strategies[ $block_name ]; | |
| 1918 | + } | |
| 1919 | + | |
| 1920 | + return $strategy; | |
| 1307 | 1921 | } |
| 1308 | 1922 | } |
| 1309 | 1923 | |
| 1310 | 1924 | if ( ( new Host() )->is_woa_site() ) { |
