js
2 months ago
class-assets.php
3 weeks ago
class-script-data.php
1 month ago
class-semver.php
2 years ago
class-shared-stores-assets.php
2 months ago
class-assets.php
814 lines
| 1 | <?php |
| 2 | /** |
| 3 | * Jetpack Assets package. |
| 4 | * |
| 5 | * @package automattic/jetpack-assets |
| 6 | */ |
| 7 | |
| 8 | namespace Automattic\Jetpack; |
| 9 | |
| 10 | use Automattic\Jetpack\Assets\Semver; |
| 11 | use Automattic\Jetpack\Constants as Jetpack_Constants; |
| 12 | use InvalidArgumentException; |
| 13 | |
| 14 | /** |
| 15 | * Class Assets |
| 16 | */ |
| 17 | class Assets { |
| 18 | /** |
| 19 | * Holds all the scripts handles that should be loaded in a deferred fashion. |
| 20 | * |
| 21 | * @var array |
| 22 | */ |
| 23 | private $defer_script_handles = array(); |
| 24 | |
| 25 | /** |
| 26 | * The singleton instance of this class. |
| 27 | * |
| 28 | * @var Assets |
| 29 | */ |
| 30 | protected static $instance; |
| 31 | |
| 32 | /** |
| 33 | * The registered textdomain mappings. |
| 34 | * |
| 35 | * @var array `array( mapped_domain => array( string target_domain, string target_type, string semver ) )`. |
| 36 | */ |
| 37 | private static $domain_map = array(); |
| 38 | |
| 39 | /** |
| 40 | * The registered package paths, by textdomain. |
| 41 | * |
| 42 | * Separate from `$domain_map` because the two answer different questions: |
| 43 | * the map says which domain a package's strings are translated under, while |
| 44 | * this says where the package's files live — the prefix WordPress hashes to |
| 45 | * name a JS translation file. A package whose textdomain is already its |
| 46 | * plugin's has nothing to alias but still needs the path. |
| 47 | * |
| 48 | * Note the entries are keyed by domain, not by script: `downloadI18n()` |
| 49 | * prepends a domain's prefix to every bundle path looked up under it. That |
| 50 | * is only ever one package's path, so a plugin must not both bundle a |
| 51 | * package whose textdomain is the plugin's own and load its own |
| 52 | * `wp-jp-i18n-loader` bundles under that same domain — the package's prefix |
| 53 | * would be applied to the plugin's catalogs too, and they would all 404. No |
| 54 | * plugin does both today. One that needs to should give the package a |
| 55 | * distinct textdomain, the way `jetpack-backup-pkg` and |
| 56 | * `jetpack-videopress-pkg` do. |
| 57 | * |
| 58 | * @var array `array( domain => array( string semver, string path_prefix ) )`. |
| 59 | */ |
| 60 | private static $domain_paths = array(); |
| 61 | |
| 62 | /** |
| 63 | * Constructor. |
| 64 | * |
| 65 | * Static-only class, so nothing here. |
| 66 | */ |
| 67 | private function __construct() {} |
| 68 | |
| 69 | // //////////////////// |
| 70 | // region Async script loading |
| 71 | |
| 72 | /** |
| 73 | * Get the singleton instance of the class. |
| 74 | * |
| 75 | * @return Assets |
| 76 | */ |
| 77 | public static function instance() { |
| 78 | if ( ! isset( self::$instance ) ) { |
| 79 | self::$instance = new Assets(); |
| 80 | } |
| 81 | |
| 82 | return self::$instance; |
| 83 | } |
| 84 | |
| 85 | /** |
| 86 | * A public method for adding the async script. |
| 87 | * |
| 88 | * @deprecated Since 2.1.0, the `strategy` feature should be used instead, with the "defer" setting. |
| 89 | * |
| 90 | * @param string $script_handle Script handle. |
| 91 | */ |
| 92 | public static function add_async_script( $script_handle ) { |
| 93 | _deprecated_function( __METHOD__, '2.1.0' ); |
| 94 | |
| 95 | wp_script_add_data( $script_handle, 'strategy', 'defer' ); |
| 96 | } |
| 97 | |
| 98 | /** |
| 99 | * Add an async attribute to scripts that can be loaded deferred. |
| 100 | * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script |
| 101 | * |
| 102 | * @deprecated Since 2.1.0, the `strategy` feature should be used instead. |
| 103 | * |
| 104 | * @param string $tag The <script> tag for the enqueued script. |
| 105 | * @param string $handle The script's registered handle. |
| 106 | */ |
| 107 | public function script_add_async( $tag, $handle ) { |
| 108 | _deprecated_function( __METHOD__, '2.1.0' ); |
| 109 | if ( empty( $this->defer_script_handles ) ) { |
| 110 | return $tag; |
| 111 | } |
| 112 | |
| 113 | if ( in_array( $handle, $this->defer_script_handles, true ) ) { |
| 114 | // phpcs:ignore WordPress.WP.EnqueuedResources.NonEnqueuedScript |
| 115 | return preg_replace( '/<script( [^>]*)? src=/i', '<script defer$1 src=', $tag ); |
| 116 | } |
| 117 | |
| 118 | return $tag; |
| 119 | } |
| 120 | |
| 121 | /** |
| 122 | * A helper function that lets you enqueue scripts in an async fashion. |
| 123 | * |
| 124 | * @deprecated Since 2.1.0 - use the strategy feature instead. |
| 125 | * |
| 126 | * @param string $handle Name of the script. Should be unique. |
| 127 | * @param string $min_path Minimized script path. |
| 128 | * @param string $non_min_path Full Script path. |
| 129 | * @param array $deps Array of script dependencies. |
| 130 | * @param bool $ver The script version. |
| 131 | * @param bool $in_footer Should the script be included in the footer. |
| 132 | */ |
| 133 | public static function enqueue_async_script( $handle, $min_path, $non_min_path, $deps = array(), $ver = false, $in_footer = true ) { |
| 134 | _deprecated_function( __METHOD__, '2.1.0' ); |
| 135 | wp_enqueue_script( $handle, self::get_file_url_for_environment( $min_path, $non_min_path ), $deps, $ver, $in_footer ); |
| 136 | wp_script_add_data( $handle, 'strategy', 'defer' ); |
| 137 | } |
| 138 | |
| 139 | // endregion . |
| 140 | |
| 141 | // //////////////////// |
| 142 | // region Utils |
| 143 | |
| 144 | /** |
| 145 | * Given a minified path, and a non-minified path, will return |
| 146 | * a minified or non-minified file URL based on whether SCRIPT_DEBUG is set and truthy. |
| 147 | * |
| 148 | * If $package_path is provided, then the minified or non-minified file URL will be generated |
| 149 | * relative to the root package directory. |
| 150 | * |
| 151 | * Both `$min_base` and `$non_min_base` can be either full URLs, or are expected to be relative to the |
| 152 | * root Jetpack directory. |
| 153 | * |
| 154 | * @param string $min_path minified path. |
| 155 | * @param string $non_min_path non-minified path. |
| 156 | * @param string $package_path Optional. A full path to a file inside a package directory |
| 157 | * The URL will be relative to its directory. Default empty. |
| 158 | * Typically this is done by passing __FILE__ as the argument. |
| 159 | * |
| 160 | * @return string The URL to the file |
| 161 | * @since 1.0.3 |
| 162 | * @since-jetpack 5.6.0 |
| 163 | */ |
| 164 | public static function get_file_url_for_environment( $min_path, $non_min_path, $package_path = '' ) { |
| 165 | $path = ( Jetpack_Constants::is_defined( 'SCRIPT_DEBUG' ) && Jetpack_Constants::get_constant( 'SCRIPT_DEBUG' ) ) |
| 166 | ? $non_min_path |
| 167 | : $min_path; |
| 168 | |
| 169 | /* |
| 170 | * If the path is actually a full URL, keep that. |
| 171 | * We look for a host value, since enqueues are sometimes without a scheme. |
| 172 | */ |
| 173 | $file_parts = wp_parse_url( $path ); |
| 174 | if ( ! empty( $file_parts['host'] ) ) { |
| 175 | $url = $path; |
| 176 | } else { |
| 177 | $plugin_path = empty( $package_path ) ? Jetpack_Constants::get_constant( 'JETPACK__PLUGIN_FILE' ) : $package_path; |
| 178 | |
| 179 | $url = plugins_url( $path, $plugin_path ); |
| 180 | } |
| 181 | |
| 182 | /** |
| 183 | * Filters the URL for a file passed through the get_file_url_for_environment function. |
| 184 | * |
| 185 | * @since 1.0.3 |
| 186 | * |
| 187 | * @package assets |
| 188 | * |
| 189 | * @param string $url The URL to the file. |
| 190 | * @param string $min_path The minified path. |
| 191 | * @param string $non_min_path The non-minified path. |
| 192 | */ |
| 193 | return apply_filters( 'jetpack_get_file_for_environment', $url, $min_path, $non_min_path ); |
| 194 | } |
| 195 | |
| 196 | /** |
| 197 | * Passes an array of URLs to wp_resource_hints. |
| 198 | * |
| 199 | * @since 1.5.0 |
| 200 | * |
| 201 | * @param string|array $urls URLs to hint. |
| 202 | * @param string $type One of the supported resource types: dns-prefetch (default), preconnect, prefetch, or prerender. |
| 203 | */ |
| 204 | public static function add_resource_hint( $urls, $type = 'dns-prefetch' ) { |
| 205 | add_filter( |
| 206 | 'wp_resource_hints', |
| 207 | function ( $hints, $resource_type ) use ( $urls, $type ) { |
| 208 | if ( $resource_type === $type ) { |
| 209 | // Type casting to array required since the function accepts a single string. |
| 210 | foreach ( (array) $urls as $url ) { |
| 211 | $hints[] = $url; |
| 212 | } |
| 213 | } |
| 214 | return $hints; |
| 215 | }, |
| 216 | 10, |
| 217 | 2 |
| 218 | ); |
| 219 | } |
| 220 | |
| 221 | /** |
| 222 | * Serve a WordPress.com static resource via a randomized wp.com subdomain. |
| 223 | * |
| 224 | * @since 1.9.0 |
| 225 | * |
| 226 | * @param string $url WordPress.com static resource URL. |
| 227 | * |
| 228 | * @return string $url |
| 229 | */ |
| 230 | public static function staticize_subdomain( $url ) { |
| 231 | // Extract hostname from URL. |
| 232 | $host = wp_parse_url( $url, PHP_URL_HOST ); |
| 233 | |
| 234 | // Explode hostname on '.'. |
| 235 | $exploded_host = explode( '.', $host ); |
| 236 | |
| 237 | // Retrieve the name and TLD. |
| 238 | if ( count( $exploded_host ) > 1 ) { |
| 239 | $name = $exploded_host[ count( $exploded_host ) - 2 ]; |
| 240 | $tld = $exploded_host[ count( $exploded_host ) - 1 ]; |
| 241 | // Rebuild domain excluding subdomains. |
| 242 | $domain = $name . '.' . $tld; |
| 243 | } else { |
| 244 | $domain = $host; |
| 245 | } |
| 246 | // Array of Automattic domains. |
| 247 | $domains_allowed = array( 'wordpress.com', 'wp.com' ); |
| 248 | |
| 249 | // Return $url if not an Automattic domain. |
| 250 | if ( ! in_array( $domain, $domains_allowed, true ) ) { |
| 251 | return $url; |
| 252 | } |
| 253 | |
| 254 | if ( \is_ssl() ) { |
| 255 | return preg_replace( '|https?://[^/]++/|', 'https://s-ssl.wordpress.com/', $url ); |
| 256 | } |
| 257 | |
| 258 | /* |
| 259 | * Generate a random subdomain id by taking the modulus of the crc32 value of the URL. |
| 260 | * Valid values are 0, 1, and 2. |
| 261 | */ |
| 262 | $static_counter = abs( crc32( basename( $url ) ) % 3 ); |
| 263 | |
| 264 | return preg_replace( '|://[^/]+?/|', "://s$static_counter.wp.com/", $url ); |
| 265 | } |
| 266 | |
| 267 | /** |
| 268 | * Resolve '.' and '..' components in a path or URL. |
| 269 | * |
| 270 | * @since 1.12.0 |
| 271 | * @param string $path Path or URL. |
| 272 | * @return string Normalized path or URL. |
| 273 | */ |
| 274 | public static function normalize_path( $path ) { |
| 275 | $parts = wp_parse_url( $path ); |
| 276 | if ( ! isset( $parts['path'] ) ) { |
| 277 | return $path; |
| 278 | } |
| 279 | |
| 280 | $ret = ''; |
| 281 | $ret .= isset( $parts['scheme'] ) ? $parts['scheme'] . '://' : ''; |
| 282 | if ( isset( $parts['user'] ) || isset( $parts['pass'] ) ) { |
| 283 | $ret .= $parts['user'] ?? ''; |
| 284 | $ret .= isset( $parts['pass'] ) ? ':' . $parts['pass'] : ''; |
| 285 | $ret .= '@'; |
| 286 | } |
| 287 | $ret .= $parts['host'] ?? ''; |
| 288 | $ret .= isset( $parts['port'] ) ? ':' . $parts['port'] : ''; |
| 289 | |
| 290 | $pp = explode( '/', $parts['path'] ); |
| 291 | if ( '' === $pp[0] ) { |
| 292 | $ret .= '/'; |
| 293 | array_shift( $pp ); |
| 294 | } |
| 295 | $i = 0; |
| 296 | while ( $i < count( $pp ) ) { // phpcs:ignore Squiz.PHP.DisallowSizeFunctionsInLoops.Found |
| 297 | if ( '' === $pp[ $i ] || '.' === $pp[ $i ] || 0 === $i && '..' === $pp[ $i ] ) { |
| 298 | array_splice( $pp, $i, 1 ); |
| 299 | } elseif ( '..' === $pp[ $i ] ) { |
| 300 | array_splice( $pp, --$i, 2 ); |
| 301 | } else { |
| 302 | ++$i; |
| 303 | } |
| 304 | } |
| 305 | $ret .= implode( '/', $pp ); |
| 306 | |
| 307 | $ret .= isset( $parts['query'] ) ? '?' . $parts['query'] : ''; |
| 308 | $ret .= isset( $parts['fragment'] ) ? '#' . $parts['fragment'] : ''; |
| 309 | |
| 310 | return $ret; |
| 311 | } |
| 312 | |
| 313 | // endregion . |
| 314 | |
| 315 | // //////////////////// |
| 316 | // region Webpack-built script registration |
| 317 | |
| 318 | /** |
| 319 | * Register a Webpack-built script. |
| 320 | * |
| 321 | * Our Webpack-built scripts tend to need a bunch of boilerplate: |
| 322 | * - A call to `Assets::get_file_url_for_environment()` for possible debugging. |
| 323 | * - A call to `wp_register_style()` for extracted CSS, possibly with detection of RTL. |
| 324 | * - Loading of dependencies and version provided by `@wordpress/dependency-extraction-webpack-plugin`. |
| 325 | * - Avoiding WPCom's broken minifier. |
| 326 | * |
| 327 | * This wrapper handles all of that. |
| 328 | * |
| 329 | * @since 1.12.0 |
| 330 | * @since 2.1.0 Add a new `strategy` option to leverage WP >= 6.3 script strategy feature. The `async` option is deprecated. |
| 331 | * @param string $handle Name of the script. Should be unique across both scripts and styles. |
| 332 | * @param string $path Minimized script path. |
| 333 | * @param string $relative_to File that `$path` is relative to. Pass `__FILE__`. |
| 334 | * @param array $options Additional options: |
| 335 | * - `asset_path`: (string|null) `.asset.php` to load. Default is to base it on `$path`. |
| 336 | * - `async`: (bool) Set true to register the script as deferred, like `Assets::enqueue_async_script()`. Deprecated in favor of `strategy`. |
| 337 | * - `css_dependencies`: (string[]) Additional style dependencies to queue. |
| 338 | * - `css_path`: (string|null) `.css` to load. Default is to base it on `$path`. |
| 339 | * - `dependencies`: (string[]) Additional script dependencies to queue. |
| 340 | * - `enqueue`: (bool) Set true to enqueue the script immediately. |
| 341 | * - `in_footer`: (bool) Set true to register script for the footer. |
| 342 | * - `media`: (string) Media for the css file. Default 'all'. |
| 343 | * - `minify`: (bool|null) Set true to pass `minify=true` in the query string, or `null` to suppress the normal `minify=false`. |
| 344 | * - `nonmin_path`: (string) Non-minified script path. |
| 345 | * - `strategy`: (string) Specify a script strategy to use, eg. `defer` or `async`. Default is `""`. |
| 346 | * - `textdomain`: (string) Text domain for the script. Required if the script depends on wp-i18n. |
| 347 | * - `version`: (string) Override the version from the `asset_path` file. |
| 348 | * @phan-param array{asset_path?:?string,async?:bool,css_dependencies?:string[],css_path?:?string,dependencies?:string[],enqueue?:bool,in_footer?:bool,media?:string,minify?:?bool,nonmin_path?:string,strategy?:string,textdomain?:string,version?:string} $options |
| 349 | * @throws \InvalidArgumentException If arguments are invalid. |
| 350 | */ |
| 351 | public static function register_script( $handle, $path, $relative_to, array $options = array() ) { |
| 352 | if ( substr( $path, -3 ) !== '.js' ) { |
| 353 | throw new \InvalidArgumentException( '$path must end in ".js"' ); |
| 354 | } |
| 355 | |
| 356 | if ( isset( $options['async'] ) ) { |
| 357 | _deprecated_argument( __METHOD__, '2.1.0', 'The `async` option is deprecated in favor of `strategy`' ); |
| 358 | } |
| 359 | |
| 360 | $dir = dirname( $relative_to ); |
| 361 | $base = substr( $path, 0, -3 ); |
| 362 | $options += array( |
| 363 | 'asset_path' => "$base.asset.php", |
| 364 | 'async' => false, |
| 365 | 'css_dependencies' => array(), |
| 366 | 'css_path' => "$base.css", |
| 367 | 'dependencies' => array(), |
| 368 | 'enqueue' => false, |
| 369 | 'in_footer' => false, |
| 370 | 'media' => 'all', |
| 371 | 'minify' => false, |
| 372 | 'strategy' => '', |
| 373 | 'textdomain' => null, |
| 374 | ); |
| 375 | '@phan-var array{asset_path:?string,async:bool,css_dependencies:string[],css_path:?string,dependencies:string[],enqueue:bool,in_footer:bool,media:string,minify:?bool,nonmin_path?:string,strategy:string,textdomain:string,version?:string} $options'; // Phan gets confused by the array addition. |
| 376 | |
| 377 | if ( is_string( $options['css_path'] ) && $options['css_path'] !== '' && substr( $options['css_path'], -4 ) !== '.css' ) { |
| 378 | throw new \InvalidArgumentException( '$options[\'css_path\'] must end in ".css"' ); |
| 379 | } |
| 380 | |
| 381 | if ( isset( $options['nonmin_path'] ) ) { |
| 382 | $url = self::get_file_url_for_environment( $path, $options['nonmin_path'], $relative_to ); |
| 383 | } else { |
| 384 | $url = plugins_url( $path, $relative_to ); |
| 385 | } |
| 386 | $url = self::normalize_path( $url ); |
| 387 | if ( null !== $options['minify'] ) { |
| 388 | $url = add_query_arg( 'minify', $options['minify'] ? 'true' : 'false', $url ); |
| 389 | } |
| 390 | |
| 391 | if ( $options['asset_path'] && file_exists( "$dir/{$options['asset_path']}" ) ) { |
| 392 | $asset = require "$dir/{$options['asset_path']}"; // phpcs:ignore WordPressVIPMinimum.Files.IncludingFile.NotAbsolutePath |
| 393 | $options['dependencies'] = array_merge( $asset['dependencies'], $options['dependencies'] ); |
| 394 | $options['css_dependencies'] = array_merge( |
| 395 | array_filter( |
| 396 | $asset['dependencies'], |
| 397 | function ( $d ) { |
| 398 | return wp_style_is( $d, 'registered' ); |
| 399 | } |
| 400 | ), |
| 401 | $options['css_dependencies'] |
| 402 | ); |
| 403 | $ver = $options['version'] ?? $asset['version']; |
| 404 | } else { |
| 405 | // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged |
| 406 | $ver = $options['version'] ?? @filemtime( "$dir/$path" ); |
| 407 | } |
| 408 | |
| 409 | if ( $options['async'] && '' === $options['strategy'] ) { // Handle the deprecated `async` option |
| 410 | $options['strategy'] = 'defer'; |
| 411 | } |
| 412 | wp_register_script( |
| 413 | $handle, |
| 414 | $url, |
| 415 | $options['dependencies'], |
| 416 | $ver, |
| 417 | array( |
| 418 | 'in_footer' => $options['in_footer'], |
| 419 | 'strategy' => $options['strategy'], |
| 420 | ) |
| 421 | ); |
| 422 | |
| 423 | if ( $options['textdomain'] ) { |
| 424 | // phpcs:ignore Jetpack.Functions.I18n.DomainNotLiteral |
| 425 | wp_set_script_translations( $handle, $options['textdomain'] ); |
| 426 | } elseif ( in_array( 'wp-i18n', $options['dependencies'], true ) ) { |
| 427 | _doing_it_wrong( |
| 428 | __METHOD__, |
| 429 | /* translators: %s is the script handle. */ |
| 430 | esc_html( sprintf( __( 'Script "%s" depends on wp-i18n but does not specify "textdomain"', 'jetpack-assets' ), $handle ) ), |
| 431 | '' |
| 432 | ); |
| 433 | } |
| 434 | |
| 435 | if ( is_string( $options['css_path'] ) && $options['css_path'] !== '' && file_exists( "$dir/{$options['css_path']}" ) ) { |
| 436 | $csspath = $options['css_path']; |
| 437 | if ( is_rtl() ) { |
| 438 | $rtlcsspath = substr( $csspath, 0, -4 ) . '.rtl.css'; |
| 439 | if ( file_exists( "$dir/$rtlcsspath" ) ) { |
| 440 | $csspath = $rtlcsspath; |
| 441 | } |
| 442 | } |
| 443 | |
| 444 | $url = self::normalize_path( plugins_url( $csspath, $relative_to ) ); |
| 445 | if ( null !== $options['minify'] ) { |
| 446 | $url = add_query_arg( 'minify', $options['minify'] ? 'true' : 'false', $url ); |
| 447 | } |
| 448 | wp_register_style( $handle, $url, $options['css_dependencies'], $ver, $options['media'] ); |
| 449 | wp_script_add_data( $handle, 'Jetpack::Assets::hascss', true ); |
| 450 | } else { |
| 451 | wp_script_add_data( $handle, 'Jetpack::Assets::hascss', false ); |
| 452 | } |
| 453 | |
| 454 | if ( $options['enqueue'] ) { |
| 455 | self::enqueue_script( $handle ); |
| 456 | } |
| 457 | } |
| 458 | |
| 459 | /** |
| 460 | * Enqueue a script registered with `Assets::register_script`. |
| 461 | * |
| 462 | * @since 1.12.0 |
| 463 | * @param string $handle Name of the script. Should be unique across both scripts and styles. |
| 464 | */ |
| 465 | public static function enqueue_script( $handle ) { |
| 466 | wp_enqueue_script( $handle ); |
| 467 | if ( wp_scripts()->get_data( $handle, 'Jetpack::Assets::hascss' ) ) { |
| 468 | wp_enqueue_style( $handle ); |
| 469 | } |
| 470 | } |
| 471 | |
| 472 | /** |
| 473 | * 'wp_default_scripts' action handler. |
| 474 | * |
| 475 | * This registers the `wp-jp-i18n-loader` script for use by Webpack bundles built with |
| 476 | * `@automattic/i18n-loader-webpack-plugin`. |
| 477 | * |
| 478 | * @since 1.14.0 |
| 479 | * @param \WP_Scripts $wp_scripts WP_Scripts instance. |
| 480 | */ |
| 481 | public static function wp_default_scripts_hook( $wp_scripts ) { |
| 482 | $data = array( |
| 483 | 'baseUrl' => false, |
| 484 | 'locale' => determine_locale(), |
| 485 | 'domainMap' => array(), |
| 486 | 'domainPaths' => array(), |
| 487 | ); |
| 488 | |
| 489 | $lang_dir = Jetpack_Constants::get_constant( 'WP_LANG_DIR' ); |
| 490 | $content_dir = Jetpack_Constants::get_constant( 'WP_CONTENT_DIR' ); |
| 491 | $abspath = Jetpack_Constants::get_constant( 'ABSPATH' ); |
| 492 | |
| 493 | // Note: str_starts_with() is not used here, as wp-includes/compat.php may not be loaded at this point. |
| 494 | if ( strpos( $lang_dir, $content_dir ) === 0 ) { |
| 495 | $data['baseUrl'] = content_url( substr( trailingslashit( $lang_dir ), strlen( trailingslashit( $content_dir ) ) ) ); |
| 496 | } elseif ( strpos( $lang_dir, $abspath ) === 0 ) { |
| 497 | $data['baseUrl'] = site_url( substr( trailingslashit( $lang_dir ), strlen( untrailingslashit( $abspath ) ) ) ); |
| 498 | } |
| 499 | |
| 500 | foreach ( self::$domain_map as $from => list( $to, $type ) ) { |
| 501 | $data['domainMap'][ $from ] = ( 'core' === $type ? '' : "{$type}/" ) . $to; |
| 502 | } |
| 503 | foreach ( self::$domain_paths as $from => list( , $path ) ) { |
| 504 | if ( '' !== $path ) { |
| 505 | $data['domainPaths'][ $from ] = trailingslashit( $path ); |
| 506 | } |
| 507 | } |
| 508 | |
| 509 | /** |
| 510 | * Filters the i18n state data for use by Webpack bundles built with |
| 511 | * `@automattic/i18n-loader-webpack-plugin`. |
| 512 | * |
| 513 | * @since 1.14.0 |
| 514 | * @package assets |
| 515 | * @param array $data The state data to generate. Expected fields are: |
| 516 | * - `baseUrl`: (string|false) The URL to the languages directory. False if no URL could be determined. |
| 517 | * - `locale`: (string) The locale for the page. |
| 518 | * - `domainMap`: (string[]) A mapping from Composer package textdomains to the corresponding |
| 519 | * `plugins/textdomain` or `themes/textdomain` (or core `textdomain`, but that's unlikely). |
| 520 | * - `domainPaths`: (string[]) A mapping from Composer package textdomains to the corresponding package |
| 521 | * paths. |
| 522 | */ |
| 523 | $data = apply_filters( 'jetpack_i18n_state', $data ); |
| 524 | |
| 525 | // Can't use self::register_script(), this action is called too early. |
| 526 | if ( file_exists( __DIR__ . '/../build/i18n-loader.asset.php' ) ) { |
| 527 | $path = '../build/i18n-loader.js'; |
| 528 | $asset = require __DIR__ . '/../build/i18n-loader.asset.php'; |
| 529 | } else { |
| 530 | $path = 'js/i18n-loader.js'; |
| 531 | $asset = array( |
| 532 | 'dependencies' => array( 'wp-i18n' ), |
| 533 | 'version' => filemtime( __DIR__ . "/$path" ), |
| 534 | ); |
| 535 | } |
| 536 | $url = self::normalize_path( plugins_url( $path, __FILE__ ) ); |
| 537 | $url = add_query_arg( 'minify', 'true', $url ); |
| 538 | |
| 539 | $handle = 'wp-jp-i18n-loader'; |
| 540 | |
| 541 | $wp_scripts->add( $handle, $url, $asset['dependencies'], $asset['version'] ); |
| 542 | |
| 543 | // Ensure the script is loaded in the footer and deferred. |
| 544 | $wp_scripts->add_data( $handle, 'group', 1 ); |
| 545 | |
| 546 | if ( ! is_array( $data ) || |
| 547 | ! isset( $data['baseUrl'] ) || ! ( is_string( $data['baseUrl'] ) || false === $data['baseUrl'] ) || |
| 548 | ! isset( $data['locale'] ) || ! is_string( $data['locale'] ) || |
| 549 | ! isset( $data['domainMap'] ) || ! is_array( $data['domainMap'] ) || |
| 550 | ! isset( $data['domainPaths'] ) || ! is_array( $data['domainPaths'] ) |
| 551 | ) { |
| 552 | $wp_scripts->add_inline_script( $handle, 'console.warn( "I18n state deleted by jetpack_i18n_state hook" );' ); |
| 553 | } elseif ( ! $data['baseUrl'] ) { |
| 554 | $wp_scripts->add_inline_script( $handle, 'console.warn( "Failed to determine languages base URL. Is WP_LANG_DIR in the WordPress root?" );' ); |
| 555 | } else { |
| 556 | $data['domainMap'] = (object) $data['domainMap']; // Ensure it becomes a json object. |
| 557 | $data['domainPaths'] = (object) $data['domainPaths']; // Ensure it becomes a json object. |
| 558 | $wp_scripts->add_inline_script( $handle, 'wp.jpI18nLoader.state = ' . wp_json_encode( $data, JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP ) . ';' ); |
| 559 | } |
| 560 | |
| 561 | // Deprecated state module: Depend on wp-i18n to ensure global `wp` exists and because anything needing this will need that too. |
| 562 | $wp_scripts->add( 'wp-jp-i18n-state', false, array( 'wp-deprecated', $handle ) ); |
| 563 | $wp_scripts->add_inline_script( 'wp-jp-i18n-state', 'wp.deprecated( "wp-jp-i18n-state", { alternative: "wp-jp-i18n-loader" } );' ); |
| 564 | $wp_scripts->add_inline_script( 'wp-jp-i18n-state', 'wp.jpI18nState = wp.jpI18nLoader.state;' ); |
| 565 | } |
| 566 | |
| 567 | // endregion . |
| 568 | |
| 569 | // //////////////////// |
| 570 | // region Textdomain aliasing |
| 571 | |
| 572 | /** |
| 573 | * Register a textdomain alias. |
| 574 | * |
| 575 | * Composer packages included in plugins will likely not use the textdomain of the plugin, while |
| 576 | * WordPress's i18n infrastructure will include the translations in the plugin's domain. This |
| 577 | * allows for mapping the package's domain to the plugin's. |
| 578 | * |
| 579 | * Since multiple plugins may use the same package, we include the package's version here so |
| 580 | * as to choose the most recent translations (which are most likely to match the package |
| 581 | * selected by jetpack-autoloader). |
| 582 | * |
| 583 | * @since 1.15.0 |
| 584 | * @param string $from Domain to alias. |
| 585 | * @param string $to Domain to alias it to. |
| 586 | * @param string $totype What is the target of the alias: 'plugins', 'themes', or 'core'. |
| 587 | * @param string $ver Version of the `$from` domain. |
| 588 | * @param string $path Path to prepend when lazy-loading from JavaScript. |
| 589 | * @throws InvalidArgumentException If arguments are invalid. |
| 590 | */ |
| 591 | public static function alias_textdomain( $from, $to, $totype, $ver, $path = '' ) { |
| 592 | if ( ! in_array( $totype, array( 'plugins', 'themes', 'core' ), true ) ) { |
| 593 | throw new InvalidArgumentException( 'Type must be "plugins", "themes", or "core"' ); |
| 594 | } |
| 595 | |
| 596 | if ( |
| 597 | did_action( 'wp_default_scripts' ) && |
| 598 | // Don't complain during plugin activation. |
| 599 | ! defined( 'WP_SANDBOX_SCRAPING' ) |
| 600 | ) { |
| 601 | _doing_it_wrong( |
| 602 | __METHOD__, |
| 603 | sprintf( |
| 604 | /* translators: 1: wp_default_scripts. 2: Name of the domain being aliased. */ |
| 605 | esc_html__( 'Textdomain aliases should be registered before the %1$s hook. This notice was triggered by the %2$s domain.', 'jetpack-assets' ), |
| 606 | '<code>wp_default_scripts</code>', |
| 607 | '<code>' . esc_html( $from ) . '</code>' |
| 608 | ), |
| 609 | '' |
| 610 | ); |
| 611 | } |
| 612 | |
| 613 | // Where the package lives is needed for JS translation files whether or |
| 614 | // not its domain is aliased, so it is recorded before the self-alias |
| 615 | // check below. |
| 616 | if ( |
| 617 | empty( self::$domain_paths[ $from ] ) || |
| 618 | Semver::compare( $ver, self::$domain_paths[ $from ][0] ) > 0 |
| 619 | ) { |
| 620 | self::$domain_paths[ $from ] = array( $ver, $path ); |
| 621 | } |
| 622 | |
| 623 | // A self-alias would make filter_gettext() re-translate into the same |
| 624 | // domain, recursing infinitely on any untranslated string (a package |
| 625 | // textdomain can collide with its containing plugin's slug). |
| 626 | if ( $from === $to ) { |
| 627 | return; |
| 628 | } |
| 629 | |
| 630 | if ( empty( self::$domain_map[ $from ] ) ) { |
| 631 | self::init_domain_map_hooks( $from, array() === self::$domain_map ); |
| 632 | self::$domain_map[ $from ] = array( $to, $totype, $ver ); |
| 633 | } elseif ( Semver::compare( $ver, self::$domain_map[ $from ][2] ) > 0 ) { |
| 634 | self::$domain_map[ $from ] = array( $to, $totype, $ver ); |
| 635 | } |
| 636 | } |
| 637 | |
| 638 | /** |
| 639 | * Register textdomain aliases from a mapping file. |
| 640 | * |
| 641 | * The mapping file is simply a PHP file that returns an array |
| 642 | * with the following properties: |
| 643 | * - 'domain': String, `$to` |
| 644 | * - 'type': String, `$totype` |
| 645 | * - 'packages': Array, mapping `$from` to `array( 'path' => $path, 'ver' => $ver )` (or to the string `$ver` for back compat). |
| 646 | * - 'paths': Array, same shape, for packages whose textdomain is already |
| 647 | * `$to`. Those must not be aliased — that would recurse — but their |
| 648 | * paths are still needed to locate their JavaScript translations. |
| 649 | * |
| 650 | * @since 1.15.0 |
| 651 | * @param string $file Mapping file. |
| 652 | */ |
| 653 | public static function alias_textdomains_from_file( $file ) { |
| 654 | $data = require $file; |
| 655 | foreach ( $data['packages'] as $from => $fromdata ) { |
| 656 | if ( ! is_array( $fromdata ) ) { |
| 657 | $fromdata = array( |
| 658 | 'path' => '', |
| 659 | 'ver' => $fromdata, |
| 660 | ); |
| 661 | } |
| 662 | self::alias_textdomain( $from, $data['domain'], $data['type'], $fromdata['ver'], $fromdata['path'] ); |
| 663 | } |
| 664 | // Aliasing a domain to itself is a no-op that `alias_textdomain()` |
| 665 | // declines, leaving just the path registration these entries are for. |
| 666 | foreach ( $data['paths'] ?? array() as $from => $fromdata ) { |
| 667 | self::alias_textdomain( $from, $from, $data['type'], $fromdata['ver'], $fromdata['path'] ); |
| 668 | } |
| 669 | } |
| 670 | |
| 671 | /** |
| 672 | * Register the hooks for textdomain aliasing. |
| 673 | * |
| 674 | * @param string $domain Domain to alias. |
| 675 | * @param bool $firstcall If this is the first call. |
| 676 | */ |
| 677 | private static function init_domain_map_hooks( $domain, $firstcall ) { |
| 678 | // If WordPress's plugin API is available already, use it. If not, |
| 679 | // drop data into `$wp_filter` for `WP_Hook::build_preinitialized_hooks()`. |
| 680 | if ( function_exists( 'add_filter' ) ) { |
| 681 | $add_filter = 'add_filter'; |
| 682 | } else { |
| 683 | $add_filter = function ( $hook_name, $callback, $priority = 10, $accepted_args = 1 ) { |
| 684 | global $wp_filter; |
| 685 | // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited |
| 686 | $wp_filter[ $hook_name ][ $priority ][] = array( |
| 687 | 'accepted_args' => $accepted_args, |
| 688 | 'function' => $callback, |
| 689 | ); |
| 690 | }; |
| 691 | } |
| 692 | |
| 693 | $add_filter( "gettext_{$domain}", array( self::class, 'filter_gettext' ), 10, 3 ); |
| 694 | $add_filter( "ngettext_{$domain}", array( self::class, 'filter_ngettext' ), 10, 5 ); |
| 695 | $add_filter( "gettext_with_context_{$domain}", array( self::class, 'filter_gettext_with_context' ), 10, 4 ); |
| 696 | $add_filter( "ngettext_with_context_{$domain}", array( self::class, 'filter_ngettext_with_context' ), 10, 6 ); |
| 697 | if ( $firstcall ) { |
| 698 | $add_filter( 'load_script_translation_file', array( self::class, 'filter_load_script_translation_file' ), 10, 3 ); |
| 699 | } |
| 700 | } |
| 701 | |
| 702 | /** |
| 703 | * Filter for `gettext`. |
| 704 | * |
| 705 | * @since 1.15.0 |
| 706 | * @param string $translation Translated text. |
| 707 | * @param string $text Text to translate. |
| 708 | * @param string $domain Text domain. |
| 709 | * @return string Translated text. |
| 710 | */ |
| 711 | public static function filter_gettext( $translation, $text, $domain ) { |
| 712 | if ( $translation === $text ) { |
| 713 | // phpcs:ignore WordPress.WP.I18n -- This is a filter hook to map the text domains from our Composer packages to the domain for a containing plugin. See https://wp.me/p2gHKz-oRh#problem-6-text-domains-in-composer-packages |
| 714 | $newtext = __( $text, self::$domain_map[ $domain ][0] ); |
| 715 | if ( $newtext !== $text ) { |
| 716 | return $newtext; |
| 717 | } |
| 718 | } |
| 719 | return $translation; |
| 720 | } |
| 721 | |
| 722 | /** |
| 723 | * Filter for `ngettext`. |
| 724 | * |
| 725 | * @since 1.15.0 |
| 726 | * @param string $translation Translated text. |
| 727 | * @param string $single The text to be used if the number is singular. |
| 728 | * @param string $plural The text to be used if the number is plural. |
| 729 | * @param int $number The number to compare against to use either the singular or plural form. |
| 730 | * @param string $domain Text domain. |
| 731 | * @return string Translated text. |
| 732 | */ |
| 733 | public static function filter_ngettext( $translation, $single, $plural, $number, $domain ) { |
| 734 | if ( $translation === $single || $translation === $plural ) { |
| 735 | // phpcs:ignore WordPress.WP.I18n -- This is a filter hook to map the text domains from our Composer packages to the domain for a containing plugin. See https://wp.me/p2gHKz-oRh#problem-6-text-domains-in-composer-packages |
| 736 | $translation = _n( $single, $plural, $number, self::$domain_map[ $domain ][0] ); |
| 737 | } |
| 738 | return $translation; |
| 739 | } |
| 740 | |
| 741 | /** |
| 742 | * Filter for `gettext_with_context`. |
| 743 | * |
| 744 | * @since 1.15.0 |
| 745 | * @param string $translation Translated text. |
| 746 | * @param string $text Text to translate. |
| 747 | * @param string $context Context information for the translators. |
| 748 | * @param string $domain Text domain. |
| 749 | * @return string Translated text. |
| 750 | */ |
| 751 | public static function filter_gettext_with_context( $translation, $text, $context, $domain ) { |
| 752 | if ( $translation === $text ) { |
| 753 | // phpcs:ignore WordPress.WP.I18n -- This is a filter hook to map the text domains from our Composer packages to the domain for a containing plugin. See https://wp.me/p2gHKz-oRh#problem-6-text-domains-in-composer-packages |
| 754 | $translation = _x( $text, $context, self::$domain_map[ $domain ][0] ); |
| 755 | } |
| 756 | return $translation; |
| 757 | } |
| 758 | |
| 759 | /** |
| 760 | * Filter for `ngettext_with_context`. |
| 761 | * |
| 762 | * @since 1.15.0 |
| 763 | * @param string $translation Translated text. |
| 764 | * @param string $single The text to be used if the number is singular. |
| 765 | * @param string $plural The text to be used if the number is plural. |
| 766 | * @param int $number The number to compare against to use either the singular or plural form. |
| 767 | * @param string $context Context information for the translators. |
| 768 | * @param string $domain Text domain. |
| 769 | * @return string Translated text. |
| 770 | */ |
| 771 | public static function filter_ngettext_with_context( $translation, $single, $plural, $number, $context, $domain ) { |
| 772 | if ( $translation === $single || $translation === $plural ) { |
| 773 | // phpcs:ignore WordPress.WP.I18n -- This is a filter hook to map the text domains from our Composer packages to the domain for a containing plugin. See https://wp.me/p2gHKz-oRh#problem-6-text-domains-in-composer-packages |
| 774 | $translation = _nx( $single, $plural, $number, $context, self::$domain_map[ $domain ][0] ); |
| 775 | } |
| 776 | return $translation; |
| 777 | } |
| 778 | |
| 779 | /** |
| 780 | * Filter for `load_script_translation_file`. |
| 781 | * |
| 782 | * @since 1.15.0 |
| 783 | * @param string|false $file Path to the translation file to load. False if there isn't one. |
| 784 | * @param string $handle Name of the script to register a translation domain to. |
| 785 | * @param string $domain The text domain. |
| 786 | */ |
| 787 | public static function filter_load_script_translation_file( $file, $handle, $domain ) { |
| 788 | if ( false !== $file && isset( self::$domain_map[ $domain ] ) && ! is_readable( $file ) ) { |
| 789 | // Determine the part of the filename after the domain. |
| 790 | $suffix = basename( $file ); |
| 791 | $l = strlen( $domain ); |
| 792 | if ( substr( $suffix, 0, $l ) !== $domain || '-' !== $suffix[ $l ] ) { |
| 793 | return $file; |
| 794 | } |
| 795 | $suffix = substr( $suffix, $l ); |
| 796 | $lang_dir = Jetpack_Constants::get_constant( 'WP_LANG_DIR' ); |
| 797 | |
| 798 | // Look for replacement files. |
| 799 | list( $newdomain, $type ) = self::$domain_map[ $domain ]; |
| 800 | $newfile = $lang_dir . ( 'core' === $type ? '/' : "/{$type}/" ) . $newdomain . $suffix; |
| 801 | if ( is_readable( $newfile ) ) { |
| 802 | return $newfile; |
| 803 | } |
| 804 | } |
| 805 | return $file; |
| 806 | } |
| 807 | |
| 808 | // endregion . |
| 809 | } |
| 810 | |
| 811 | // Enable section folding in vim: |
| 812 | // vim: foldmarker=//\ region,//\ endregion foldmethod=marker |
| 813 | // . |
| 814 |