WordPress.org
Get WordPress

Make WordPress Core

Changeset 57327


Ignore:
Timestamp:
01/23/2024 03:32:03 AM (3 years ago)
Author:
dmsnell
Message:

Script Modules API: Rename wp_module to wp_script_module

Renames all mentions to "module" with "script module", including function names, comments, and tests.

Follow up to [57269]

The list of functions renamed are:

  • wp_module() -> wp_script_module().
  • wp_register_module() -> wp_register_script_module().
  • wp_enqueue_module() -> wp_enqueue_script_module().
  • wp_dequeue_module() -> wp_dequeue_script_module().
  • WP_Script_Modules::print_enqueued_modules() -> WP_Script_Modules::print_enqueued_script_modules().
  • WP_Script_Modules::print_module_preloads() -> WP_Script_Modules::print_script_module_preloads().

It also adds PHP 7 typing to all the functions and improves the types of the $deps argument of wp_register_script_module() and wp_enqueue_script_module() using @type.

Props luisherranz, idad5, costdev, nefff, joemcgill, jorbin, swisspidy, jonsurrel, flixos90, gziolo, westonruter, bernhard-reiter, kamranzafar4343
See #56313

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/class-wp-script-modules.php

    r57271 r57327  
    11<?php
    22/**
    3  * Modules API: WP_Script_Modules class.
     3 * Script Modules API: WP_Script_Modules class.
    44 *
    55 * Native support for ES Modules and Import Maps.
    … …  
    1010
    1111/**
    12  * Core class used to register modules.
     12 * Core class used to register script modules.
    1313 *
    1414 * @since 6.5.0
    … …  
    1616class WP_Script_Modules {
    1717        /**
    18          * Holds the registered modules, keyed by module identifier.
     18         * Holds the registered script modules, keyed by script module identifier.
    1919         *
    2020         * @since 6.5.0
    … …  
    2424
    2525        /**
    26          * Holds the module identifiers that were enqueued before registered.
    27          *
    28          * @since 6.5.0
    29          * @var array
     26         * Holds the script module identifiers that were enqueued before registered.
     27         *
     28         * @since 6.5.0
     29         * @var array<string, true>
    3030         */
    3131        private $enqueued_before_registered = array();
    3232
    3333        /**
    34          * Registers the module if no module with that module identifier has already
    35          * been registered.
    36          *
    37          * @since 6.5.0
    38          *
    39          * @param string                                                        $module_id The identifier of the module.
    40          *                                                                                 Should be unique. It will be used
    41          *                                                                                 in the final import map.
    42          * @param string                                                        $src       Full URL of the module, or path of
    43          *                                                                                 the module relative to the
    44          *                                                                                 WordPress root directory.
    45          * @param array<string|array{id: string, import?: 'static'|'dynamic' }> $deps      Optional. An array of module
    46          *                                                                                 identifiers of the dependencies of
    47          *                                                                                 this module. The dependencies can
    48          *                                                                                 be strings or arrays. If they are
    49          *                                                                                 arrays, they need an `id` key with
    50          *                                                                                 the module identifier, and can
    51          *                                                                                 contain an `import` key with either
    52          *                                                                                 `static` or `dynamic`. By default,
    53          *                                                                                 dependencies that don't contain an
    54          *                                                                                 `import` key are considered static.
    55          * @param string|false|null                                             $version   Optional. String specifying the
    56          *                                                                                 module version number. Defaults to
    57          *                                                                                 false. It is added to the URL as a
    58          *                                                                                 query string for cache busting
    59          *                                                                                 purposes. If $version is set to
    60          *                                                                                 false, the version number is the
    61          *                                                                                 currently installed WordPress
    62          *                                                                                 version. If $version is set to
    63          *                                                                                 null, no version is added.
    64          */
    65         public function register( $module_id, $src, $deps = array(), $version = false ) {
    66                 if ( ! isset( $this->registered[ $module_id ] ) ) {
     34         * Registers the script module if no script module with that script module
     35         * identifier has already been registered.
     36         *
     37         * @since 6.5.0
     38         *
     39         * @param string            $id       The identifier of the script module. Should be unique. It will be used in the
     40         *                                    final import map.
     41         * @param string            $src      Optional. Full URL of the script module, or path of the script module relative
     42         *                                    to the WordPress root directory. If it is provided and the script module has
     43         *                                    not been registered yet, it will be registered.
     44         * @param array             $deps     {
     45         *                                        Optional. List of dependencies.
     46         *
     47         *                                        @type string|array $0... {
     48         *                                            An array of script module identifiers of the dependencies of this script
     49         *                                            module. The dependencies can be strings or arrays. If they are arrays,
     50         *                                            they need an `id` key with the script module identifier, and can contain
     51         *                                            an `import` key with either `static` or `dynamic`. By default,
     52         *                                            dependencies that don't contain an `import` key are considered static.
     53         *
     54         *                                            @type string $id     The script module identifier.
     55         *                                            @type string $import Optional. Import type. May be either `static` or
     56         *                                                                 `dynamic`. Defaults to `static`.
     57         *                                        }
     58         *                                    }
     59         * @param string|false|null $version  Optional. String specifying the script module version number. Defaults to false.
     60         *                                    It is added to the URL as a query string for cache busting purposes. If $version
     61         *                                    is set to false, the version number is the currently installed WordPress version.
     62         *                                    If $version is set to null, no version is added.
     63         */
     64        public function register( string $id, string $src, array $deps = array(), $version = false ) {
     65                if ( ! isset( $this->registered[ $id ] ) ) {
    6766                        $dependencies = array();
    6867                        foreach ( $deps as $dependency ) {
    … …  
    8685                        }
    8786
    88                         $this->registered[ $module_id ] = array(
     87                        $this->registered[ $id ] = array(
    8988                                'src'          => $src,
    9089                                'version'      => $version,
    91                                 'enqueue'      => isset( $this->enqueued_before_registered[ $module_id ] ),
     90                                'enqueue'      => isset( $this->enqueued_before_registered[ $id ] ),
    9291                                'dependencies' => $dependencies,
    9392                                'enqueued'     => false,
    … …  
    9897
    9998        /**
    100          * Marks the module to be enqueued in the page the next time
    101          * `prints_enqueued_modules` is called.
    102          *
    103          * If a src is provided and the module has not been registered yet, it will be
    104          * registered.
    105          *
    106          * @since 6.5.0
    107          *
    108          * @param string                                                        $module_id The identifier of the module.
    109          *                                                                                 Should be unique. It will be used
    110          *                                                                                 in the final import map.
    111          * @param string                                                        $src       Optional. Full URL of the module,
    112          *                                                                                 or path of the module relative to
    113          *                                                                                 the WordPress root directory. If
    114          *                                                                                 it is provided and the module has
    115          *                                                                                 not been registered yet, it will be
    116          *                                                                                 registered.
    117          * @param array<string|array{id: string, import?: 'static'|'dynamic' }> $deps      Optional. An array of module
    118          *                                                                                 identifiers of the dependencies of
    119          *                                                                                 this module. The dependencies can
    120          *                                                                                 be strings or arrays. If they are
    121          *                                                                                 arrays, they need an `id` key with
    122          *                                                                                 the module identifier, and can
    123          *                                                                                 contain an `import` key with either
    124          *                                                                                 `static` or `dynamic`. By default,
    125          *                                                                                 dependencies that don't contain an
    126          *                                                                                 `import` key are considered static.
    127          * @param string|false|null                                             $version   Optional. String specifying the
    128          *                                                                                 module version number. Defaults to
    129          *                                                                                 false. It is added to the URL as a
    130          *                                                                                 query string for cache busting
    131          *                                                                                 purposes. If $version is set to
    132          *                                                                                 false, the version number is the
    133          *                                                                                 currently installed WordPress
    134          *                                                                                 version. If $version is set to
    135          *                                                                                 null, no version is added.
    136          */
    137         public function enqueue( $module_id, $src = '', $deps = array(), $version = false ) {
    138                 if ( isset( $this->registered[ $module_id ] ) ) {
    139                         $this->registered[ $module_id ]['enqueue'] = true;
     99         * Marks the script module to be enqueued in the page the next time
     100         * `print_enqueued_script_modules` is called.
     101         *
     102         * If a src is provided and the script module has not been registered yet, it
     103         * will be registered.
     104         *
     105         * @since 6.5.0
     106         *
     107         * @param string            $id       The identifier of the script module. Should be unique. It will be used in the
     108         *                                    final import map.
     109         * @param string            $src      Optional. Full URL of the script module, or path of the script module relative
     110         *                                    to the WordPress root directory. If it is provided and the script module has
     111         *                                    not been registered yet, it will be registered.
     112         * @param array             $deps     {
     113         *                                        Optional. List of dependencies.
     114         *
     115         *                                        @type string|array $0... {
     116         *                                            An array of script module identifiers of the dependencies of this script
     117         *                                            module. The dependencies can be strings or arrays. If they are arrays,
     118         *                                            they need an `id` key with the script module identifier, and can contain
     119         *                                            an `import` key with either `static` or `dynamic`. By default,
     120         *                                            dependencies that don't contain an `import` key are considered static.
     121         *
     122         *                                            @type string $id     The script module identifier.
     123         *                                            @type string $import Optional. Import type. May be either `static` or
     124         *                                                                 `dynamic`. Defaults to `static`.
     125         *                                        }
     126         *                                    }
     127         * @param string|false|null $version  Optional. String specifying the script module version number. Defaults to false.
     128         *                                    It is added to the URL as a query string for cache busting purposes. If $version
     129         *                                    is set to false, the version number is the currently installed WordPress version.
     130         *                                    If $version is set to null, no version is added.
     131         */
     132        public function enqueue( string $id, string $src = '', array $deps = array(), $version = false ) {
     133                if ( isset( $this->registered[ $id ] ) ) {
     134                        $this->registered[ $id ]['enqueue'] = true;
    140135                } elseif ( $src ) {
    141                         $this->register( $module_id, $src, $deps, $version );
    142                         $this->registered[ $module_id ]['enqueue'] = true;
     136                        $this->register( $id, $src, $deps, $version );
     137                        $this->registered[ $id ]['enqueue'] = true;
    143138                } else {
    144                         $this->enqueued_before_registered[ $module_id ] = true;
    145                 }
    146         }
    147 
    148         /**
    149          * Unmarks the module so it will no longer be enqueued in the page.
    150          *
    151          * @since 6.5.0
    152          *
    153          * @param string $module_id The identifier of the module.
    154          */
    155         public function dequeue( $module_id ) {
    156                 if ( isset( $this->registered[ $module_id ] ) ) {
    157                         $this->registered[ $module_id ]['enqueue'] = false;
    158                 }
    159                 unset( $this->enqueued_before_registered[ $module_id ] );
    160         }
    161 
    162         /**
    163          * Adds the hooks to print the import map, enqueued modules and module
    164          * preloads.
    165          *
    166          * It adds the actions to print the enqueued modules and module preloads to
    167          * both `wp_head` and `wp_footer` because in classic themes, the modules
    168          * used by the theme and plugins will likely be able to be printed in the
    169          * `head`, but the ones used by the blocks will need to be enqueued in the
    170          * `footer`.
    171          *
    172          * As all modules are deferred and dependencies are handled by the browser,
    173          * the order of the modules is not important, but it's still better to print
    174          * the ones that are available when the `wp_head` is rendered, so the browser
    175          * starts downloading those as soon as possible.
     139                        $this->enqueued_before_registered[ $id ] = true;
     140                }
     141        }
     142
     143        /**
     144         * Unmarks the script module so it will no longer be enqueued in the page.
     145         *
     146         * @since 6.5.0
     147         *
     148         * @param string $id The identifier of the script module.
     149         */
     150        public function dequeue( string $id ) {
     151                if ( isset( $this->registered[ $id ] ) ) {
     152                        $this->registered[ $id ]['enqueue'] = false;
     153                }
     154                unset( $this->enqueued_before_registered[ $id ] );
     155        }
     156
     157        /**
     158         * Adds the hooks to print the import map, enqueued script modules and script
     159         * module preloads.
     160         *
     161         * It adds the actions to print the enqueued script modules and script module
     162         * preloads to both `wp_head` and `wp_footer` because in classic themes, the
     163         * script modules used by the theme and plugins will likely be able to be
     164         * printed in the `head`, but the ones used by the blocks will need to be
     165         * enqueued in the `footer`.
     166         *
     167         * As all script modules are deferred and dependencies are handled by the
     168         * browser, the order of the script modules is not important, but it's still
     169         * better to print the ones that are available when the `wp_head` is rendered,
     170         * so the browser starts downloading those as soon as possible.
    176171         *
    177172         * The import map is also printed in the footer to be able to include the
    178          * dependencies of all the modules, including the ones printed in the footer.
     173         * dependencies of all the script modules, including the ones printed in the
     174         * footer.
    179175         *
    180176         * @since 6.5.0
    181177         */
    182178        public function add_hooks() {
    183                 add_action( 'wp_head', array( $this, 'print_enqueued_modules' ) );
    184                 add_action( 'wp_head', array( $this, 'print_module_preloads' ) );
    185                 add_action( 'wp_footer', array( $this, 'print_enqueued_modules' ) );
    186                 add_action( 'wp_footer', array( $this, 'print_module_preloads' ) );
     179                add_action( 'wp_head', array( $this, 'print_enqueued_script_modules' ) );
     180                add_action( 'wp_head', array( $this, 'print_script_module_preloads' ) );
     181                add_action( 'wp_footer', array( $this, 'print_enqueued_script_modules' ) );
     182                add_action( 'wp_footer', array( $this, 'print_script_module_preloads' ) );
    187183                add_action( 'wp_footer', array( $this, 'print_import_map' ) );
    188184        }
    189185
    190186        /**
    191          * Prints the enqueued modules using script tags with type="module"
     187         * Prints the enqueued script modules using script tags with type="module"
    192188         * attributes.
    193189         *
    194          * If a enqueued module has already been printed, it will not be printed again
    195          * on subsequent calls to this function.
    196          *
    197          * @since 6.5.0
    198          */
    199         public function print_enqueued_modules() {
    200                 foreach ( $this->get_marked_for_enqueue() as $module_id => $module ) {
    201                         if ( false === $module['enqueued'] ) {
     190         * If a enqueued script module has already been printed, it will not be
     191         * printed again on subsequent calls to this function.
     192         *
     193         * @since 6.5.0
     194         */
     195        public function print_enqueued_script_modules() {
     196                foreach ( $this->get_marked_for_enqueue() as $id => $script_module ) {
     197                        if ( false === $script_module['enqueued'] ) {
    202198                                // Mark it as enqueued so it doesn't get enqueued again.
    203                                 $this->registered[ $module_id ]['enqueued'] = true;
     199                                $this->registered[ $id ]['enqueued'] = true;
    204200
    205201                                wp_print_script_tag(
    206202                                        array(
    207203                                                'type' => 'module',
    208                                                 'src'  => $this->get_versioned_src( $module ),
    209                                                 'id'   => $module_id . '-js-module',
     204                                                'src'  => $this->get_versioned_src( $script_module ),
     205                                                'id'   => $id . '-js-module',
    210206                                        )
    211207                                );
    … …  
    215211
    216212        /**
    217          * Prints the the static dependencies of the enqueued modules using link tags
    218          * with rel="modulepreload" attributes.
    219          *
    220          * If a module is marked for enqueue, it will not be preloaded. If a preloaded
    221          * module has already been printed, it will not be printed again on subsequent
    222          * calls to this function.
    223          *
    224          * @since 6.5.0
    225          */
    226         public function print_module_preloads() {
    227                 foreach ( $this->get_dependencies( array_keys( $this->get_marked_for_enqueue() ), array( 'static' ) ) as $module_id => $module ) {
     213         * Prints the the static dependencies of the enqueued script modules using
     214         * link tags with rel="modulepreload" attributes.
     215         *
     216         * If a script module is marked for enqueue, it will not be preloaded. If a
     217         * preloaded script module has already been printed, it will not be printed
     218         * again on subsequent calls to this function.
     219         *
     220         * @since 6.5.0
     221         */
     222        public function print_script_module_preloads() {
     223                foreach ( $this->get_dependencies( array_keys( $this->get_marked_for_enqueue() ), array( 'static' ) ) as $id => $script_module ) {
    228224                        // Don't preload if it's marked for enqueue or has already been preloaded.
    229                         if ( true !== $module['enqueue'] && false === $module['preloaded'] ) {
     225                        if ( true !== $script_module['enqueue'] && false === $script_module['preloaded'] ) {
    230226                                // Mark it as preloaded so it doesn't get preloaded again.
    231                                 $this->registered[ $module_id ]['preloaded'] = true;
     227                                $this->registered[ $id ]['preloaded'] = true;
    232228
    233229                                echo sprintf(
    234230                                        '<link rel="modulepreload" href="%s" id="%s">',
    235                                         esc_url( $this->get_versioned_src( $module ) ),
    236                                         esc_attr( $module_id . '-js-modulepreload' )
     231                                        esc_url( $this->get_versioned_src( $script_module ) ),
     232                                        esc_attr( $id . '-js-modulepreload' )
    237233                                );
    238234                        }
    … …  
    263259         * @since 6.5.0
    264260         *
    265          * @return array Array with an `imports` key mapping to an array of module identifiers and their respective URLs,
    266          *               including the version query.
    267          */
    268         private function get_import_map() {
     261         * @return array Array with an `imports` key mapping to an array of script module identifiers and their respective
     262         *               URLs, including the version query.
     263         */
     264        private function get_import_map(): array {
    269265                $imports = array();
    270                 foreach ( $this->get_dependencies( array_keys( $this->get_marked_for_enqueue() ) ) as $module_id => $module ) {
    271                         $imports[ $module_id ] = $this->get_versioned_src( $module );
     266                foreach ( $this->get_dependencies( array_keys( $this->get_marked_for_enqueue() ) ) as $id => $script_module ) {
     267                        $imports[ $id ] = $this->get_versioned_src( $script_module );
    272268                }
    273269                return array( 'imports' => $imports );
    … …  
    275271
    276272        /**
    277          * Retrieves the list of modules marked for enqueue.
    278          *
    279          * @since 6.5.0
    280          *
    281          * @return array Modules marked for enqueue, keyed by module identifier.
    282          */
    283         private function get_marked_for_enqueue() {
     273         * Retrieves the list of script modules marked for enqueue.
     274         *
     275         * @since 6.5.0
     276         *
     277         * @return array Script modules marked for enqueue, keyed by script module identifier.
     278         */
     279        private function get_marked_for_enqueue(): array {
    284280                $enqueued = array();
    285                 foreach ( $this->registered as $module_id => $module ) {
    286                         if ( true === $module['enqueue'] ) {
    287                                 $enqueued[ $module_id ] = $module;
     281                foreach ( $this->registered as $id => $script_module ) {
     282                        if ( true === $script_module['enqueue'] ) {
     283                                $enqueued[ $id ] = $script_module;
    288284                        }
    289285                }
    … …  
    292288
    293289        /**
    294          * Retrieves all the dependencies for the given module identifiers, filtered
    295          * by import types.
     290         * Retrieves all the dependencies for the given script module identifiers,
     291         * filtered by import types.
    296292         *
    297293         * It will consolidate an array containing a set of unique dependencies based
    … …  
    301297         * @since 6.5.0
    302298         *
    303          * @param array $module_ids   The identifiers of the modules for which to gather dependencies.
    304          * @param array $import_types Optional. Import types of dependencies to retrieve: 'static', 'dynamic', or both.
    305          *                            Default is both.
    306          * @return array List of dependencies, keyed by module identifier.
    307          */
    308         private function get_dependencies( $module_ids, $import_types = array( 'static', 'dynamic' ) ) {
     299
     300         * @param string[] $ids          The identifiers of the script modules for which to gather dependencies.
     301         * @param array    $import_types Optional. Import types of dependencies to retrieve: 'static', 'dynamic', or both.
     302         *                               Default is both.
     303         * @return array List of dependencies, keyed by script module identifier.
     304         */
     305        private function get_dependencies( array $ids, array $import_types = array( 'static', 'dynamic' ) ) {
    309306                return array_reduce(
    310                         $module_ids,
    311                         function ( $dependency_modules, $module_id ) use ( $import_types ) {
     307                        $ids,
     308                        function ( $dependency_script_modules, $id ) use ( $import_types ) {
    312309                                $dependencies = array();
    313                                 foreach ( $this->registered[ $module_id ]['dependencies'] as $dependency ) {
     310                                foreach ( $this->registered[ $id ]['dependencies'] as $dependency ) {
    314311                                        if (
    315312                                        in_array( $dependency['import'], $import_types, true ) &&
    316313                                        isset( $this->registered[ $dependency['id'] ] ) &&
    317                                         ! isset( $dependency_modules[ $dependency['id'] ] )
     314                                        ! isset( $dependency_script_modules[ $dependency['id'] ] )
    318315                                        ) {
    319316                                                $dependencies[ $dependency['id'] ] = $this->registered[ $dependency['id'] ];
    320317                                        }
    321318                                }
    322                                 return array_merge( $dependency_modules, $dependencies, $this->get_dependencies( array_keys( $dependencies ), $import_types ) );
     319                                return array_merge( $dependency_script_modules, $dependencies, $this->get_dependencies( array_keys( $dependencies ), $import_types ) );
    323320                        },
    324321                        array()
    … …  
    327324
    328325        /**
    329          * Gets the versioned URL for a module src.
     326         * Gets the versioned URL for a script module src.
    330327         *
    331328         * If $version is set to false, the version number is the currently installed
    … …  
    335332         * @since 6.5.0
    336333         *
    337          * @param array $module The module.
    338          * @return string The module src with a version if relevant.
    339          */
    340         private function get_versioned_src( array $module ) {
     334         * @param array $script_module The script module.
     335         * @return string The script module src with a version if relevant.
     336         */
     337        private function get_versioned_src( array $script_module ): string {
    341338                $args = array();
    342                 if ( false === $module['version'] ) {
     339                if ( false === $script_module['version'] ) {
    343340                        $args['ver'] = get_bloginfo( 'version' );
    344                 } elseif ( null !== $module['version'] ) {
    345                         $args['ver'] = $module['version'];
     341                } elseif ( null !== $script_module['version'] ) {
     342                        $args['ver'] = $script_module['version'];
    346343                }
    347344                if ( $args ) {
    348                         return add_query_arg( $args, $module['src'] );
    349                 }
    350                 return $module['src'];
     345                        return add_query_arg( $args, $script_module['src'] );
     346                }
     347                return $script_module['src'];
    351348        }
    352349}

  • trunk/src/wp-includes/script-modules.php

    r57269 r57327  
    11<?php
    22/**
    3  * Script Modules API: Module functions
     3 * Script Modules API: Script Module functions
    44 *
    55 * @since 6.5.0
    … …  
    1919 * @return WP_Script_Modules The main WP_Script_Modules instance.
    2020 */
    21 function wp_modules() {
     21function wp_script_modules(): WP_Script_Modules {
    2222        static $instance = null;
    2323        if ( is_null( $instance ) ) {
    … …  
    2929
    3030/**
    31  * Registers the module if no module with that module identifier has already
    32  * been registered.
     31 * Registers the script module if no script module with that script module
     32 * identifier has already been registered.
    3333 *
    3434 * @since 6.5.0
    3535 *
    36  * @param string                                                        $module_id The identifier of the module.
    37  *                                                                                 Should be unique. It will be used
    38  *                                                                                 in the final import map.
    39  * @param string                                                        $src       Full URL of the module, or path of
    40  *                                                                                 the module relative to the
    41  *                                                                                 WordPress root directory.
    42  * @param array<string|array{id: string, import?: 'static'|'dynamic' }> $deps      Optional. An array of module
    43  *                                                                                 identifiers of the dependencies of
    44  *                                                                                 this module. The dependencies can
    45  *                                                                                 be strings or arrays. If they are
    46  *                                                                                 arrays, they need an `id` key with
    47  *                                                                                 the module identifier, and can
    48  *                                                                                 contain an `import` key with either
    49  *                                                                                 `static` or `dynamic`. By default,
    50  *                                                                                 dependencies that don't contain an
    51  *                                                                                 `import` key are considered static.
    52  * @param string|false|null                                             $version   Optional. String specifying the
    53  *                                                                                 module version number. Defaults to
    54  *                                                                                 false. It is added to the URL as a
    55  *                                                                                 query string for cache busting
    56  *                                                                                 purposes. If $version is set to
    57  *                                                                                 false, the version number is the
    58  *                                                                                 currently installed WordPress
    59  *                                                                                 version. If $version is set to
    60  *                                                                                 null, no version is added.
     36 * @param string            $id       The identifier of the script module. Should be unique. It will be used in the
     37 *                                    final import map.
     38 * @param string            $src      Optional. Full URL of the script module, or path of the script module relative
     39 *                                    to the WordPress root directory. If it is provided and the script module has
     40 *                                    not been registered yet, it will be registered.
     41 * @param array             $deps     {
     42 *                                        Optional. List of dependencies.
     43 *
     44 *                                        @type string|array $0... {
     45 *                                            An array of script module identifiers of the dependencies of this script
     46 *                                            module. The dependencies can be strings or arrays. If they are arrays,
     47 *                                            they need an `id` key with the script module identifier, and can contain
     48 *                                            an `import` key with either `static` or `dynamic`. By default,
     49 *                                            dependencies that don't contain an `import` key are considered static.
     50 *
     51 *                                            @type string $id     The script module identifier.
     52 *                                            @type string $import Optional. Import type. May be either `static` or
     53 *                                                                 `dynamic`. Defaults to `static`.
     54 *                                        }
     55 *                                    }
     56 * @param string|false|null $version  Optional. String specifying the script module version number. Defaults to false.
     57 *                                    It is added to the URL as a query string for cache busting purposes. If $version
     58 *                                    is set to false, the version number is the currently installed WordPress version.
     59 *                                    If $version is set to null, no version is added.
    6160 */
    62 function wp_register_module( $module_id, $src, $deps = array(), $version = false ) {
    63         wp_modules()->register( $module_id, $src, $deps, $version );
     61function wp_register_script_module( string $id, string $src, array $deps = array(), $version = false ) {
     62        wp_script_modules()->register( $id, $src, $deps, $version );
    6463}
    6564
    6665/**
    67  * Marks the module to be enqueued in the page.
     66 * Marks the script module to be enqueued in the page.
    6867 *
    69  * If a src is provided and the module has not been registered yet, it will be
    70  * registered.
     68 * If a src is provided and the script module has not been registered yet, it
     69 * will be registered.
    7170 *
    7271 * @since 6.5.0
    7372 *
    74  * @param string                                                        $module_id The identifier of the module.
    75  *                                                                                 Should be unique. It will be used
    76  *                                                                                 in the final import map.
    77  * @param string                                                        $src       Optional. Full URL of the module,
    78  *                                                                                 or path of the module relative to
    79  *                                                                                 the WordPress root directory. If
    80  *                                                                                 it is provided and the module has
    81  *                                                                                 not been registered yet, it will be
    82  *                                                                                 registered.
    83  * @param array<string|array{id: string, import?: 'static'|'dynamic' }> $deps      Optional. An array of module
    84  *                                                                                 identifiers of the dependencies of
    85  *                                                                                 this module. The dependencies can
    86  *                                                                                 be strings or arrays. If they are
    87  *                                                                                 arrays, they need an `id` key with
    88  *                                                                                 the module identifier, and can
    89  *                                                                                 contain an `import` key with either
    90  *                                                                                 `static` or `dynamic`. By default,
    91  *                                                                                 dependencies that don't contain an
    92  *                                                                                 `import` key are considered static.
    93  * @param string|false|null                                             $version   Optional. String specifying the
    94  *                                                                                 module version number. Defaults to
    95  *                                                                                 false. It is added to the URL as a
    96  *                                                                                 query string for cache busting
    97  *                                                                                 purposes. If $version is set to
    98  *                                                                                 false, the version number is the
    99  *                                                                                 currently installed WordPress
    100  *                                                                                 version. If $version is set to
    101  *                                                                                 null, no version is added.
     73 * @param string            $id       The identifier of the script module. Should be unique. It will be used in the
     74 *                                    final import map.
     75 * @param string            $src      Optional. Full URL of the script module, or path of the script module relative
     76 *                                    to the WordPress root directory. If it is provided and the script module has
     77 *                                    not been registered yet, it will be registered.
     78 * @param array             $deps     {
     79 *                                        Optional. List of dependencies.
     80 *
     81 *                                        @type string|array $0... {
     82 *                                            An array of script module identifiers of the dependencies of this script
     83 *                                            module. The dependencies can be strings or arrays. If they are arrays,
     84 *                                            they need an `id` key with the script module identifier, and can contain
     85 *                                            an `import` key with either `static` or `dynamic`. By default,
     86 *                                            dependencies that don't contain an `import` key are considered static.
     87 *
     88 *                                            @type string $id     The script module identifier.
     89 *                                            @type string $import Optional. Import type. May be either `static` or
     90 *                                                                 `dynamic`. Defaults to `static`.
     91 *                                        }
     92 *                                    }
     93 * @param string|false|null $version  Optional. String specifying the script module version number. Defaults to false.
     94 *                                    It is added to the URL as a query string for cache busting purposes. If $version
     95 *                                    is set to false, the version number is the currently installed WordPress version.
     96 *                                    If $version is set to null, no version is added.
    10297 */
    103 function wp_enqueue_module( $module_id, $src = '', $deps = array(), $version = false ) {
    104         wp_modules()->enqueue( $module_id, $src, $deps, $version );
     98function wp_enqueue_script_module( string $id, string $src = '', array $deps = array(), $version = false ) {
     99        wp_script_modules()->enqueue( $id, $src, $deps, $version );
    105100}
    106101
    107102/**
    108  * Unmarks the module so it is no longer enqueued in the page.
     103 * Unmarks the script module so it is no longer enqueued in the page.
    109104 *
    110105 * @since 6.5.0
    111106 *
    112  * @param string $module_id The identifier of the module.
     107 * @param string $id The identifier of the script module.
    113108 */
    114 function wp_dequeue_module( $module_id ) {
    115         wp_modules()->dequeue( $module_id );
     109function wp_dequeue_script_module( string $id ) {
     110        wp_script_modules()->dequeue( $id );
    116111}

  • trunk/tests/phpunit/tests/script-modules/wpScriptModules.php

    r57269 r57327  
    1818         * @var WP_Script_Modules
    1919         */
    20         protected $modules;
     20        protected $script_modules;
    2121
    2222        /**
    … …  
    2525        public function set_up() {
    2626                parent::set_up();
    27                 $this->modules = new WP_Script_Modules();
    28         }
    29 
    30         /**
    31          * Gets a list of the enqueued modules.
    32          *
    33          * @return array Enqueued module URLs, keyed by module identifier.
    34          */
    35         public function get_enqueued_modules() {
    36                 $modules_markup   = get_echo( array( $this->modules, 'print_enqueued_modules' ) );
    37                 $p                = new WP_HTML_Tag_Processor( $modules_markup );
    38                 $enqueued_modules = array();
    39 
    40                 while ( $p->next_tag(
    41                         array(
    42                                 'tag'    => 'SCRIPT',
    43                                 'import' => 'module',
    44                         )
    45                 ) ) {
    46                         $id                      = preg_replace( '/-js-module$/', '', $p->get_attribute( 'id' ) );
    47                         $enqueued_modules[ $id ] = $p->get_attribute( 'src' );
     27                $this->script_modules = new WP_Script_Modules();
     28        }
     29
     30        /**
     31         * Gets a list of the enqueued script modules.
     32         *
     33         * @return array Enqueued script module URLs, keyed by script module identifier.
     34         */
     35        public function get_enqueued_script_modules() {
     36                $script_modules_markup   = get_echo( array( $this->script_modules, 'print_enqueued_script_modules' ) );
     37                $p                       = new WP_HTML_Tag_Processor( $script_modules_markup );
     38                $enqueued_script_modules = array();
     39
     40                while ( $p->next_tag( array( 'tag' => 'SCRIPT' ) ) ) {
     41                        if ( 'module' === $p->get_attribute( 'type' ) ) {
     42                                $id                             = preg_replace( '/-js-module$/', '', $p->get_attribute( 'id' ) );
     43                                $enqueued_script_modules[ $id ] = $p->get_attribute( 'src' );
     44                        }
    4845                }
    4946
    50                 return $enqueued_modules;
    51         }
    52 
    53         /**
    54          * Gets the modules listed in the import map.
    55          *
    56          * @return array Import map entry URLs, keyed by module identifier.
     47                return $enqueued_script_modules;
     48        }
     49
     50        /**
     51         * Gets the script modules listed in the import map.
     52         *
     53         * @return array Import map entry URLs, keyed by script module identifier.
    5754         */
    5855        public function get_import_map() {
    59                 $import_map_markup = get_echo( array( $this->modules, 'print_import_map' ) );
     56                $import_map_markup = get_echo( array( $this->script_modules, 'print_import_map' ) );
    6057                preg_match( '/<script type="importmap" id="wp-importmap">.*?(\{.*\}).*?<\/script>/s', $import_map_markup, $import_map_string );
    6158                return json_decode( $import_map_string[1], true )['imports'];
    … …  
    6360
    6461        /**
    65          * Gets a list of preloaded modules.
    66          *
    67          * @return array Preloaded module URLs, keyed by module identifier.
    68          */
    69         public function get_preloaded_modules() {
    70                 $preloaded_markup  = get_echo( array( $this->modules, 'print_module_preloads' ) );
    71                 $p                 = new WP_HTML_Tag_Processor( $preloaded_markup );
    72                 $preloaded_modules = array();
    73 
    74                 while ( $p->next_tag(
    75                         array(
    76                                 'tag' => 'LINK',
    77                                 'rel' => 'modulepreload',
    78                         )
    79                 ) ) {
    80                         $id                       = preg_replace( '/-js-modulepreload$/', '', $p->get_attribute( 'id' ) );
    81                         $preloaded_modules[ $id ] = $p->get_attribute( 'href' );
     62         * Gets a list of preloaded script modules.
     63         *
     64         * @return array Preloaded script module URLs, keyed by script module identifier.
     65         */
     66        public function get_preloaded_script_modules() {
     67                $preloaded_markup         = get_echo( array( $this->script_modules, 'print_script_module_preloads' ) );
     68                $p                        = new WP_HTML_Tag_Processor( $preloaded_markup );
     69                $preloaded_script_modules = array();
     70
     71                while ( $p->next_tag( array( 'tag' => 'LINK' ) ) ) {
     72                        if ( 'modulepreload' === $p->get_attribute( 'rel' ) ) {
     73                                $id                              = preg_replace( '/-js-modulepreload$/', '', $p->get_attribute( 'id' ) );
     74                                $preloaded_script_modules[ $id ] = $p->get_attribute( 'href' );
     75                        }
    8276                }
    8377
    84                 return $preloaded_modules;
    85         }
    86 
    87         /**
    88          * Tests that a module gets enqueued correctly after being registered.
    89          *
    90          * @ticket 56313
    91          *
    92          * @covers ::register()
    93          * @covers ::enqueue()
    94          * @covers ::print_enqueued_modules()
    95          */
    96         public function test_wp_enqueue_module() {
    97                 $this->modules->register( 'foo', '/foo.js' );
    98                 $this->modules->register( 'bar', '/bar.js' );
    99                 $this->modules->enqueue( 'foo' );
    100                 $this->modules->enqueue( 'bar' );
    101 
    102                 $enqueued_modules = $this->get_enqueued_modules();
    103 
    104                 $this->assertCount( 2, $enqueued_modules );
    105                 $this->assertStringStartsWith( '/foo.js', $enqueued_modules['foo'] );
    106                 $this->assertStringStartsWith( '/bar.js', $enqueued_modules['bar'] );
    107         }
    108 
    109         /**
    110         * Tests that a module can be dequeued after being enqueued.
     78                return $preloaded_script_modules;
     79        }
     80
     81        /**
     82         * Tests that a script module gets enqueued correctly after being registered.
     83         *
     84         * @ticket 56313
     85         *
     86         * @covers ::register()
     87         * @covers ::enqueue()
     88         * @covers ::print_enqueued_script_modules()
     89         */
     90        public function test_wp_enqueue_script_module() {
     91                $this->script_modules->register( 'foo', '/foo.js' );
     92                $this->script_modules->register( 'bar', '/bar.js' );
     93                $this->script_modules->enqueue( 'foo' );
     94                $this->script_modules->enqueue( 'bar' );
     95
     96                $enqueued_script_modules = $this->get_enqueued_script_modules();
     97
     98                $this->assertCount( 2, $enqueued_script_modules );
     99                $this->assertStringStartsWith( '/foo.js', $enqueued_script_modules['foo'] );
     100                $this->assertStringStartsWith( '/bar.js', $enqueued_script_modules['bar'] );
     101        }
     102
     103        /**
     104        * Tests that a script module can be dequeued after being enqueued.
    111105        *
    112106        * @ticket 56313
    … …  
    115109        * @covers ::enqueue()
    116110        * @covers ::dequeue()
    117         * @covers ::print_enqueued_modules()
     111        * @covers ::print_enqueued_script_modules()
    118112        */
    119         public function test_wp_dequeue_module() {
    120                 $this->modules->register( 'foo', '/foo.js' );
    121                 $this->modules->register( 'bar', '/bar.js' );
    122                 $this->modules->enqueue( 'foo' );
    123                 $this->modules->enqueue( 'bar' );
    124                 $this->modules->dequeue( 'foo' ); // Dequeued.
    125 
    126                 $enqueued_modules = $this->get_enqueued_modules();
    127 
    128                 $this->assertCount( 1, $enqueued_modules );
    129                 $this->assertFalse( isset( $enqueued_modules['foo'] ) );
    130                 $this->assertTrue( isset( $enqueued_modules['bar'] ) );
    131         }
    132 
    133         /**
    134         * Tests that a module can be enqueued before it is registered, and will be
    135         * handled correctly once registered.
     113        public function test_wp_dequeue_script_module() {
     114                $this->script_modules->register( 'foo', '/foo.js' );
     115                $this->script_modules->register( 'bar', '/bar.js' );
     116                $this->script_modules->enqueue( 'foo' );
     117                $this->script_modules->enqueue( 'bar' );
     118                $this->script_modules->dequeue( 'foo' ); // Dequeued.
     119
     120                $enqueued_script_modules = $this->get_enqueued_script_modules();
     121
     122                $this->assertCount( 1, $enqueued_script_modules );
     123                $this->assertFalse( isset( $enqueued_script_modules['foo'] ) );
     124                $this->assertTrue( isset( $enqueued_script_modules['bar'] ) );
     125        }
     126
     127        /**
     128        * Tests that a script module can be enqueued before it is registered, and will
     129        * be handled correctly once registered.
    136130        *
    137131        * @ticket 56313
    … …  
    139133        * @covers ::register()
    140134        * @covers ::enqueue()
    141         * @covers ::print_enqueued_modules()
     135        * @covers ::print_enqueued_script_modules()
    142136        */
    143         public function test_wp_enqueue_module_works_before_register() {
    144                 $this->modules->enqueue( 'foo' );
    145                 $this->modules->register( 'foo', '/foo.js' );
    146                 $this->modules->enqueue( 'bar' ); // Not registered.
    147 
    148                 $enqueued_modules = $this->get_enqueued_modules();
    149 
    150                 $this->assertCount( 1, $enqueued_modules );
    151                 $this->assertStringStartsWith( '/foo.js', $enqueued_modules['foo'] );
    152                 $this->assertFalse( isset( $enqueued_modules['bar'] ) );
    153         }
    154 
    155         /**
    156          * Tests that a module can be dequeued before it is registered and ensures
    157          * that it is not enqueued after registration.
     137        public function test_wp_enqueue_script_module_works_before_register() {
     138                $this->script_modules->enqueue( 'foo' );
     139                $this->script_modules->register( 'foo', '/foo.js' );
     140                $this->script_modules->enqueue( 'bar' ); // Not registered.
     141
     142                $enqueued_script_modules = $this->get_enqueued_script_modules();
     143
     144                $this->assertCount( 1, $enqueued_script_modules );
     145                $this->assertStringStartsWith( '/foo.js', $enqueued_script_modules['foo'] );
     146                $this->assertFalse( isset( $enqueued_script_modules['bar'] ) );
     147        }
     148
     149        /**
     150         * Tests that a script module can be dequeued before it is registered and
     151         * ensures that it is not enqueued after registration.
    158152         *
    159153         * @ticket 56313
    … …  
    162156         * @covers ::enqueue()
    163157         * @covers ::dequeue()
    164          * @covers ::print_enqueued_modules()
    165          */
    166         public function test_wp_dequeue_module_works_before_register() {
    167                 $this->modules->enqueue( 'foo' );
    168                 $this->modules->enqueue( 'bar' );
    169                 $this->modules->dequeue( 'foo' );
    170                 $this->modules->register( 'foo', '/foo.js' );
    171                 $this->modules->register( 'bar', '/bar.js' );
    172 
    173                 $enqueued_modules = $this->get_enqueued_modules();
    174 
    175                 $this->assertCount( 1, $enqueued_modules );
    176                 $this->assertFalse( isset( $enqueued_modules['foo'] ) );
    177                 $this->assertTrue( isset( $enqueued_modules['bar'] ) );
     158         * @covers ::print_enqueued_script_modules()
     159         */
     160        public function test_wp_dequeue_script_module_works_before_register() {
     161                $this->script_modules->enqueue( 'foo' );
     162                $this->script_modules->enqueue( 'bar' );
     163                $this->script_modules->dequeue( 'foo' );
     164                $this->script_modules->register( 'foo', '/foo.js' );
     165                $this->script_modules->register( 'bar', '/bar.js' );
     166
     167                $enqueued_script_modules = $this->get_enqueued_script_modules();
     168
     169                $this->assertCount( 1, $enqueued_script_modules );
     170                $this->assertFalse( isset( $enqueued_script_modules['foo'] ) );
     171                $this->assertTrue( isset( $enqueued_script_modules['bar'] ) );
    178172        }
    179173
    180174        /**
    181175         * Tests that dependencies for a registered module are added to the import map
    182          * when the module is enqueued.
     176         * when the script module is enqueued.
    183177         *
    184178         * @ticket 56313
    … …  
    189183         */
    190184        public function test_wp_import_map_dependencies() {
    191                 $this->modules->register( 'foo', '/foo.js', array( 'dep' ) );
    192                 $this->modules->register( 'dep', '/dep.js' );
    193                 $this->modules->register( 'no-dep', '/no-dep.js' );
    194                 $this->modules->enqueue( 'foo' );
     185                $this->script_modules->register( 'foo', '/foo.js', array( 'dep' ) );
     186                $this->script_modules->register( 'dep', '/dep.js' );
     187                $this->script_modules->register( 'no-dep', '/no-dep.js' );
     188                $this->script_modules->enqueue( 'foo' );
    195189
    196190                $import_map = $this->get_import_map();
    … …  
    203197        /**
    204198         * Tests that dependencies are not duplicated in the import map when multiple
    205          * modules require the same dependency.
     199         * script modules require the same dependency.
    206200         *
    207201         * @ticket 56313
    … …  
    212206         */
    213207        public function test_wp_import_map_no_duplicate_dependencies() {
    214                 $this->modules->register( 'foo', '/foo.js', array( 'dep' ) );
    215                 $this->modules->register( 'bar', '/bar.js', array( 'dep' ) );
    216                 $this->modules->register( 'dep', '/dep.js' );
    217                 $this->modules->enqueue( 'foo' );
    218                 $this->modules->enqueue( 'bar' );
     208                $this->script_modules->register( 'foo', '/foo.js', array( 'dep' ) );
     209                $this->script_modules->register( 'bar', '/bar.js', array( 'dep' ) );
     210                $this->script_modules->register( 'dep', '/dep.js' );
     211                $this->script_modules->enqueue( 'foo' );
     212                $this->script_modules->enqueue( 'bar' );
    219213
    220214                $import_map = $this->get_import_map();
    … …  
    235229         */
    236230        public function test_wp_import_map_recursive_dependencies() {
    237                 $this->modules->register(
     231                $this->script_modules->register(
    238232                        'foo',
    239233                        '/foo.js',
    … …  
    246240                        )
    247241                );
    248                 $this->modules->register(
     242                $this->script_modules->register(
    249243                        'static-dep',
    250244                        '/static-dep.js',
    … …  
    260254                        )
    261255                );
    262                 $this->modules->register( 'dynamic-dep', '/dynamic-dep.js' );
    263                 $this->modules->register( 'nested-static-dep', '/nested-static-dep.js' );
    264                 $this->modules->register( 'nested-dynamic-dep', '/nested-dynamic-dep.js' );
    265                 $this->modules->register( 'no-dep', '/no-dep.js' );
    266                 $this->modules->enqueue( 'foo' );
     256                $this->script_modules->register( 'dynamic-dep', '/dynamic-dep.js' );
     257                $this->script_modules->register( 'nested-static-dep', '/nested-static-dep.js' );
     258                $this->script_modules->register( 'nested-dynamic-dep', '/nested-dynamic-dep.js' );
     259                $this->script_modules->register( 'no-dep', '/no-dep.js' );
     260                $this->script_modules->enqueue( 'foo' );
    267261
    268262                $import_map = $this->get_import_map();
    … …  
    286280         */
    287281        public function test_wp_import_map_doesnt_print_if_no_dependencies() {
    288                 $this->modules->register( 'foo', '/foo.js' ); // No deps.
    289                 $this->modules->enqueue( 'foo' );
    290 
    291                 $import_map_markup = get_echo( array( $this->modules, 'print_import_map' ) );
     282                $this->script_modules->register( 'foo', '/foo.js' ); // No deps.
     283                $this->script_modules->enqueue( 'foo' );
     284
     285                $import_map_markup = get_echo( array( $this->script_modules, 'print_import_map' ) );
    292286
    293287                $this->assertEmpty( $import_map_markup );
    … …  
    302296         * @covers ::register()
    303297         * @covers ::enqueue()
    304          * @covers ::print_module_preloads()
     298         * @covers ::print_script_module_preloads()
    305299         */
    306300        public function test_wp_enqueue_preloaded_static_dependencies() {
    307                 $this->modules->register(
     301                $this->script_modules->register(
    308302                        'foo',
    309303                        '/foo.js',
    … …  
    316310                        )
    317311                );
    318                 $this->modules->register(
     312                $this->script_modules->register(
    319313                        'static-dep',
    320314                        '/static-dep.js',
    … …  
    330324                        )
    331325                );
    332                 $this->modules->register( 'dynamic-dep', '/dynamic-dep.js' );
    333                 $this->modules->register( 'nested-static-dep', '/nested-static-dep.js' );
    334                 $this->modules->register( 'nested-dynamic-dep', '/nested-dynamic-dep.js' );
    335                 $this->modules->register( 'no-dep', '/no-dep.js' );
    336                 $this->modules->enqueue( 'foo' );
    337 
    338                 $preloaded_modules = $this->get_preloaded_modules();
    339 
    340                 $this->assertCount( 2, $preloaded_modules );
    341                 $this->assertStringStartsWith( '/static-dep.js', $preloaded_modules['static-dep'] );
    342                 $this->assertStringStartsWith( '/nested-static-dep.js', $preloaded_modules['nested-static-dep'] );
    343                 $this->assertFalse( isset( $preloaded_modules['no-dep'] ) );
    344                 $this->assertFalse( isset( $preloaded_modules['dynamic-dep'] ) );
    345                 $this->assertFalse( isset( $preloaded_modules['nested-dynamic-dep'] ) );
     326                $this->script_modules->register( 'dynamic-dep', '/dynamic-dep.js' );
     327                $this->script_modules->register( 'nested-static-dep', '/nested-static-dep.js' );
     328                $this->script_modules->register( 'nested-dynamic-dep', '/nested-dynamic-dep.js' );
     329                $this->script_modules->register( 'no-dep', '/no-dep.js' );
     330                $this->script_modules->enqueue( 'foo' );
     331
     332                $preloaded_script_modules = $this->get_preloaded_script_modules();
     333
     334                $this->assertCount( 2, $preloaded_script_modules );
     335                $this->assertStringStartsWith( '/static-dep.js', $preloaded_script_modules['static-dep'] );
     336                $this->assertStringStartsWith( '/nested-static-dep.js', $preloaded_script_modules['nested-static-dep'] );
     337                $this->assertFalse( isset( $preloaded_script_modules['no-dep'] ) );
     338                $this->assertFalse( isset( $preloaded_script_modules['dynamic-dep'] ) );
     339                $this->assertFalse( isset( $preloaded_script_modules['nested-dynamic-dep'] ) );
    346340        }
    347341
    … …  
    353347         * @covers ::register()
    354348         * @covers ::enqueue()
    355          * @covers ::print_module_preloads()
     349         * @covers ::print_script_module_preloads()
    356350         */
    357351        public function test_wp_dont_preload_static_dependencies_of_dynamic_dependencies() {
    358                 $this->modules->register(
     352                $this->script_modules->register(
    359353                        'foo',
    360354                        '/foo.js',
    … …  
    367361                        )
    368362                );
    369                 $this->modules->register( 'static-dep', '/static-dep.js' );
    370                 $this->modules->register( 'dynamic-dep', '/dynamic-dep.js', array( 'nested-static-dep' ) );
    371                 $this->modules->register( 'nested-static-dep', '/nested-static-dep.js' );
    372                 $this->modules->register( 'no-dep', '/no-dep.js' );
    373                 $this->modules->enqueue( 'foo' );
    374 
    375                 $preloaded_modules = $this->get_preloaded_modules();
    376 
    377                 $this->assertCount( 1, $preloaded_modules );
    378                 $this->assertStringStartsWith( '/static-dep.js', $preloaded_modules['static-dep'] );
    379                 $this->assertFalse( isset( $preloaded_modules['dynamic-dep'] ) );
    380                 $this->assertFalse( isset( $preloaded_modules['nested-static-dep'] ) );
    381                 $this->assertFalse( isset( $preloaded_modules['no-dep'] ) );
    382         }
    383 
    384         /**
    385          * Tests that preloaded dependencies don't include enqueued modules.
    386          *
    387          * @ticket 56313
    388          *
    389          * @covers ::register()
    390          * @covers ::enqueue()
    391          * @covers ::print_module_preloads()
    392          */
    393         public function test_wp_preloaded_dependencies_filter_enqueued_modules() {
    394                 $this->modules->register(
     363                $this->script_modules->register( 'static-dep', '/static-dep.js' );
     364                $this->script_modules->register( 'dynamic-dep', '/dynamic-dep.js', array( 'nested-static-dep' ) );
     365                $this->script_modules->register( 'nested-static-dep', '/nested-static-dep.js' );
     366                $this->script_modules->register( 'no-dep', '/no-dep.js' );
     367                $this->script_modules->enqueue( 'foo' );
     368
     369                $preloaded_script_modules = $this->get_preloaded_script_modules();
     370
     371                $this->assertCount( 1, $preloaded_script_modules );
     372                $this->assertStringStartsWith( '/static-dep.js', $preloaded_script_modules['static-dep'] );
     373                $this->assertFalse( isset( $preloaded_script_modules['dynamic-dep'] ) );
     374                $this->assertFalse( isset( $preloaded_script_modules['nested-static-dep'] ) );
     375                $this->assertFalse( isset( $preloaded_script_modules['no-dep'] ) );
     376        }
     377
     378        /**
     379         * Tests that preloaded dependencies don't include enqueued script modules.
     380         *
     381         * @ticket 56313
     382         *
     383         * @covers ::register()
     384         * @covers ::enqueue()
     385         * @covers ::print_script_module_preloads()
     386         */
     387        public function test_wp_preloaded_dependencies_filter_enqueued_script_modules() {
     388                $this->script_modules->register(
    395389                        'foo',
    396390                        '/foo.js',
    … …  
    400394                        )
    401395                );
    402                 $this->modules->register( 'dep', '/dep.js' );
    403                 $this->modules->register( 'enqueued-dep', '/enqueued-dep.js' );
    404                 $this->modules->enqueue( 'foo' );
    405                 $this->modules->enqueue( 'enqueued-dep' ); // Not preloaded.
    406 
    407                 $preloaded_modules = $this->get_preloaded_modules();
    408 
    409                 $this->assertCount( 1, $preloaded_modules );
    410                 $this->assertTrue( isset( $preloaded_modules['dep'] ) );
    411                 $this->assertFalse( isset( $preloaded_modules['enqueued-dep'] ) );
    412         }
    413 
    414         /**
    415          * Tests that enqueued modules with dependants correctly add both the module
    416          * and its dependencies to the import map.
     396                $this->script_modules->register( 'dep', '/dep.js' );
     397                $this->script_modules->register( 'enqueued-dep', '/enqueued-dep.js' );
     398                $this->script_modules->enqueue( 'foo' );
     399                $this->script_modules->enqueue( 'enqueued-dep' ); // Not preloaded.
     400
     401                $preloaded_script_modules = $this->get_preloaded_script_modules();
     402
     403                $this->assertCount( 1, $preloaded_script_modules );
     404                $this->assertTrue( isset( $preloaded_script_modules['dep'] ) );
     405                $this->assertFalse( isset( $preloaded_script_modules['enqueued-dep'] ) );
     406        }
     407
     408        /**
     409         * Tests that enqueued script modules with dependants correctly add both the
     410         * script module and its dependencies to the import map.
    417411         *
    418412         * @ticket 56313
    … …  
    422416         * @covers ::print_import_map()
    423417         */
    424         public function test_wp_enqueued_modules_with_dependants_add_import_map() {
    425                 $this->modules->register(
     418        public function test_wp_enqueued_script_modules_with_dependants_add_import_map() {
     419                $this->script_modules->register(
    426420                        'foo',
    427421                        '/foo.js',
    … …  
    431425                        )
    432426                );
    433                 $this->modules->register( 'dep', '/dep.js' );
    434                 $this->modules->register( 'enqueued-dep', '/enqueued-dep.js' );
    435                 $this->modules->enqueue( 'foo' );
    436                 $this->modules->enqueue( 'enqueued-dep' ); // Also in the import map.
     427                $this->script_modules->register( 'dep', '/dep.js' );
     428                $this->script_modules->register( 'enqueued-dep', '/enqueued-dep.js' );
     429                $this->script_modules->enqueue( 'foo' );
     430                $this->script_modules->enqueue( 'enqueued-dep' ); // Also in the import map.
    437431
    438432                $import_map = $this->get_import_map();
    … …  
    452446         */
    453447        public function test_get_versioned_src() {
    454                 $get_versioned_src = new ReflectionMethod( $this->modules, 'get_versioned_src' );
     448                $get_versioned_src = new ReflectionMethod( $this->script_modules, 'get_versioned_src' );
    455449                $get_versioned_src->setAccessible( true );
    456450
    … …  
    460454                );
    461455
    462                 $result = $get_versioned_src->invoke( $this->modules, $module_with_version );
     456                $result = $get_versioned_src->invoke( $this->script_modules, $module_with_version );
    463457                $this->assertEquals( 'http://example.com/module.js?ver=1.0', $result );
    464458
    … …  
    468462                );
    469463
    470                 $result = $get_versioned_src->invoke( $this->modules, $module_without_version );
     464                $result = $get_versioned_src->invoke( $this->script_modules, $module_without_version );
    471465                $this->assertEquals( 'http://example.com/module.js', $result );
    472466
    … …  
    476470                );
    477471
    478                 $result = $get_versioned_src->invoke( $this->modules, $module_with_wp_version );
     472                $result = $get_versioned_src->invoke( $this->script_modules, $module_with_wp_version );
    479473                $this->assertEquals( 'http://example.com/module.js?ver=' . get_bloginfo( 'version' ), $result );
    480474
    … …  
    484478                );
    485479
    486                 $result = $get_versioned_src->invoke( $this->modules, $module_with_existing_query_string );
     480                $result = $get_versioned_src->invoke( $this->script_modules, $module_with_existing_query_string );
    487481                $this->assertEquals( 'http://example.com/module.js?foo=bar&ver=1.0', $result );
    488482        }
    … …  
    490484        /**
    491485         * Tests that the correct version is propagated to the import map, enqueued
    492          * modules and preloaded modules.
    493          *
    494          * @ticket 56313
    495          *
    496          * @covers ::register()
    497          * @covers ::enqueue()
    498          * @covers ::print_enqueued_modules()
     486         * script modules and preloaded script modules.
     487         *
     488         * @ticket 56313
     489         *
     490         * @covers ::register()
     491         * @covers ::enqueue()
     492         * @covers ::print_enqueued_script_modules()
    499493         * @covers ::print_import_map()
    500          * @covers ::print_module_preloads()
     494         * @covers ::print_script_module_preloads()
    501495         * @covers ::get_version_query_string()
    502496         */
    503497        public function test_version_is_propagated_correctly() {
    504                 $this->modules->register(
     498                $this->script_modules->register(
    505499                        'foo',
    506500                        '/foo.js',
    … …  
    510504                        '1.0'
    511505                );
    512                 $this->modules->register( 'dep', '/dep.js', array(), '2.0' );
    513                 $this->modules->enqueue( 'foo' );
    514 
    515                 $enqueued_modules = $this->get_enqueued_modules();
    516                 $this->assertEquals( '/foo.js?ver=1.0', $enqueued_modules['foo'] );
     506                $this->script_modules->register( 'dep', '/dep.js', array(), '2.0' );
     507                $this->script_modules->enqueue( 'foo' );
     508
     509                $enqueued_script_modules = $this->get_enqueued_script_modules();
     510                $this->assertEquals( '/foo.js?ver=1.0', $enqueued_script_modules['foo'] );
    517511
    518512                $import_map = $this->get_import_map();
    519513                $this->assertEquals( '/dep.js?ver=2.0', $import_map['dep'] );
    520514
    521                 $preloaded_modules = $this->get_preloaded_modules();
    522                 $this->assertEquals( '/dep.js?ver=2.0', $preloaded_modules['dep'] );
    523         }
    524 
    525         /**
    526          * Tests that it can print the enqueued modules multiple times, and it will
    527          * only print the modules that have not been printed before.
    528          *
    529          * @ticket 56313
    530          *
    531          * @covers ::register()
    532          * @covers ::enqueue()
    533          * @covers ::print_enqueued_modules()
    534          */
    535         public function test_print_enqueued_modules_can_be_called_multiple_times() {
    536                 $this->modules->register( 'foo', '/foo.js' );
    537                 $this->modules->register( 'bar', '/bar.js' );
    538                 $this->modules->enqueue( 'foo' );
    539 
    540                 $enqueued_modules = $this->get_enqueued_modules();
    541                 $this->assertCount( 1, $enqueued_modules );
    542                 $this->assertTrue( isset( $enqueued_modules['foo'] ) );
    543 
    544                 $this->modules->enqueue( 'bar' );
    545 
    546                 $enqueued_modules = $this->get_enqueued_modules();
    547                 $this->assertCount( 1, $enqueued_modules );
    548                 $this->assertTrue( isset( $enqueued_modules['bar'] ) );
    549 
    550                 $enqueued_modules = $this->get_enqueued_modules();
    551                 $this->assertCount( 0, $enqueued_modules );
    552         }
    553 
    554         /**
    555          * Tests that it can print the preloaded modules multiple times, and it will
    556          * only print the modules that have not been printed before.
    557          *
    558          * @ticket 56313
    559          *
    560          * @covers ::register()
    561          * @covers ::enqueue()
    562          * @covers ::print_module_preloads()
    563          */
    564         public function test_print_preloaded_modules_can_be_called_multiple_times() {
    565                 $this->modules->register( 'foo', '/foo.js', array( 'static-dep-1', 'static-dep-2' ) );
    566                 $this->modules->register( 'bar', '/bar.js', array( 'static-dep-3' ) );
    567                 $this->modules->register( 'static-dep-1', '/static-dep-1.js' );
    568                 $this->modules->register( 'static-dep-3', '/static-dep-3.js' );
    569                 $this->modules->enqueue( 'foo' );
    570 
    571                 $preloaded_modules = $this->get_preloaded_modules();
    572                 $this->assertCount( 1, $preloaded_modules );
    573                 $this->assertTrue( isset( $preloaded_modules['static-dep-1'] ) );
    574 
    575                 $this->modules->register( 'static-dep-2', '/static-dep-2.js' );
    576                 $this->modules->enqueue( 'bar' );
    577 
    578                 $preloaded_modules = $this->get_preloaded_modules();
    579                 $this->assertCount( 2, $preloaded_modules );
    580                 $this->assertTrue( isset( $preloaded_modules['static-dep-2'] ) );
    581                 $this->assertTrue( isset( $preloaded_modules['static-dep-3'] ) );
    582 
    583                 $preloaded_modules = $this->get_preloaded_modules();
    584                 $this->assertCount( 0, $preloaded_modules );
    585         }
    586 
    587         /**
    588          * Tests that a module is not registered when calling enqueue without a valid
     515                $preloaded_script_modules = $this->get_preloaded_script_modules();
     516                $this->assertEquals( '/dep.js?ver=2.0', $preloaded_script_modules['dep'] );
     517        }
     518
     519        /**
     520         * Tests that it can print the enqueued script modules multiple times, and it
     521         * will only print the script modules that have not been printed before.
     522         *
     523         * @ticket 56313
     524         *
     525         * @covers ::register()
     526         * @covers ::enqueue()
     527         * @covers ::print_enqueued_script_modules()
     528         */
     529        public function test_print_enqueued_script_modules_can_be_called_multiple_times() {
     530                $this->script_modules->register( 'foo', '/foo.js' );
     531                $this->script_modules->register( 'bar', '/bar.js' );
     532                $this->script_modules->enqueue( 'foo' );
     533
     534                $enqueued_script_modules = $this->get_enqueued_script_modules();
     535                $this->assertCount( 1, $enqueued_script_modules );
     536                $this->assertTrue( isset( $enqueued_script_modules['foo'] ) );
     537
     538                $this->script_modules->enqueue( 'bar' );
     539
     540                $enqueued_script_modules = $this->get_enqueued_script_modules();
     541                $this->assertCount( 1, $enqueued_script_modules );
     542                $this->assertTrue( isset( $enqueued_script_modules['bar'] ) );
     543
     544                $enqueued_script_modules = $this->get_enqueued_script_modules();
     545                $this->assertCount( 0, $enqueued_script_modules );
     546        }
     547
     548        /**
     549         * Tests that it can print the preloaded script modules multiple times, and it
     550         * will only print the script modules that have not been printed before.
     551         *
     552         * @ticket 56313
     553         *
     554         * @covers ::register()
     555         * @covers ::enqueue()
     556         * @covers ::print_script_module_preloads()
     557         */
     558        public function test_print_preloaded_script_modules_can_be_called_multiple_times() {
     559                $this->script_modules->register( 'foo', '/foo.js', array( 'static-dep-1', 'static-dep-2' ) );
     560                $this->script_modules->register( 'bar', '/bar.js', array( 'static-dep-3' ) );
     561                $this->script_modules->register( 'static-dep-1', '/static-dep-1.js' );
     562                $this->script_modules->register( 'static-dep-3', '/static-dep-3.js' );
     563                $this->script_modules->enqueue( 'foo' );
     564
     565                $preloaded_script_modules = $this->get_preloaded_script_modules();
     566                $this->assertCount( 1, $preloaded_script_modules );
     567                $this->assertTrue( isset( $preloaded_script_modules['static-dep-1'] ) );
     568
     569                $this->script_modules->register( 'static-dep-2', '/static-dep-2.js' );
     570                $this->script_modules->enqueue( 'bar' );
     571
     572                $preloaded_script_modules = $this->get_preloaded_script_modules();
     573                $this->assertCount( 2, $preloaded_script_modules );
     574                $this->assertTrue( isset( $preloaded_script_modules['static-dep-2'] ) );
     575                $this->assertTrue( isset( $preloaded_script_modules['static-dep-3'] ) );
     576
     577                $preloaded_script_modules = $this->get_preloaded_script_modules();
     578                $this->assertCount( 0, $preloaded_script_modules );
     579        }
     580
     581        /**
     582         * Tests that a script module is not registered when calling enqueue without a
     583         * valid src.
     584         *
     585         * @ticket 56313
     586         *
     587         * @covers ::enqueue()
     588         * @covers ::print_enqueued_script_modules()
     589         */
     590        public function test_wp_enqueue_script_module_doesnt_register_without_a_valid_src() {
     591                $this->script_modules->enqueue( 'foo' );
     592
     593                $enqueued_script_modules = $this->get_enqueued_script_modules();
     594
     595                $this->assertCount( 0, $enqueued_script_modules );
     596                $this->assertFalse( isset( $enqueued_script_modules['foo'] ) );
     597        }
     598
     599        /**
     600         * Tests that a script module is registered when calling enqueue with a valid
    589601         * src.
    590602         *
    … …  
    592604         *
    593605         * @covers ::enqueue()
    594          * @covers ::print_enqueued_modules()
    595          */
    596         public function test_wp_enqueue_module_doesnt_register_without_a_valid_src() {
    597                 $this->modules->enqueue( 'foo' );
    598 
    599                 $enqueued_modules = $this->get_enqueued_modules();
    600 
    601                 $this->assertCount( 0, $enqueued_modules );
    602                 $this->assertFalse( isset( $enqueued_modules['foo'] ) );
    603         }
    604 
    605         /**
    606          * Tests that a module is registered when calling enqueue with a valid src.
    607          *
    608          * @ticket 56313
    609          *
    610          * @covers ::enqueue()
    611          * @covers ::print_enqueued_modules()
    612          */
    613         public function test_wp_enqueue_module_registers_with_valid_src() {
    614                 $this->modules->enqueue( 'foo', '/foo.js' );
    615 
    616                 $enqueued_modules = $this->get_enqueued_modules();
    617 
    618                 $this->assertCount( 1, $enqueued_modules );
    619                 $this->assertStringStartsWith( '/foo.js', $enqueued_modules['foo'] );
    620         }
    621 
    622         /**
    623          * Tests that a module is registered when calling enqueue with a valid src the
    624          * second time.
    625          *
    626          * @ticket 56313
    627          *
    628          * @covers ::enqueue()
    629          * @covers ::print_enqueued_modules()
    630          */
    631         public function test_wp_enqueue_module_registers_with_valid_src_the_second_time() {
    632                 $this->modules->enqueue( 'foo' ); // Not valid src.
    633 
    634                 $enqueued_modules = $this->get_enqueued_modules();
    635 
    636                 $this->assertCount( 0, $enqueued_modules );
    637                 $this->assertFalse( isset( $enqueued_modules['foo'] ) );
    638 
    639                 $this->modules->enqueue( 'foo', '/foo.js' ); // Valid src.
    640 
    641                 $enqueued_modules = $this->get_enqueued_modules();
    642 
    643                 $this->assertCount( 1, $enqueued_modules );
    644                 $this->assertStringStartsWith( '/foo.js', $enqueued_modules['foo'] );
    645         }
    646 
    647         /**
    648          * Tests that a module is registered with all the params when calling enqueue.
    649          *
    650          * @ticket 56313
    651          *
    652          * @covers ::register()
    653          * @covers ::enqueue()
    654          * @covers ::print_enqueued_modules()
     606         * @covers ::print_enqueued_script_modules()
     607         */
     608        public function test_wp_enqueue_script_module_registers_with_valid_src() {
     609                $this->script_modules->enqueue( 'foo', '/foo.js' );
     610
     611                $enqueued_script_modules = $this->get_enqueued_script_modules();
     612
     613                $this->assertCount( 1, $enqueued_script_modules );
     614                $this->assertStringStartsWith( '/foo.js', $enqueued_script_modules['foo'] );
     615        }
     616
     617        /**
     618         * Tests that a script module is registered when calling enqueue with a valid
     619         * src the second time.
     620         *
     621         * @ticket 56313
     622         *
     623         * @covers ::enqueue()
     624         * @covers ::print_enqueued_script_modules()
     625         */
     626        public function test_wp_enqueue_script_module_registers_with_valid_src_the_second_time() {
     627                $this->script_modules->enqueue( 'foo' ); // Not valid src.
     628
     629                $enqueued_script_modules = $this->get_enqueued_script_modules();
     630
     631                $this->assertCount( 0, $enqueued_script_modules );
     632                $this->assertFalse( isset( $enqueued_script_modules['foo'] ) );
     633
     634                $this->script_modules->enqueue( 'foo', '/foo.js' ); // Valid src.
     635
     636                $enqueued_script_modules = $this->get_enqueued_script_modules();
     637
     638                $this->assertCount( 1, $enqueued_script_modules );
     639                $this->assertStringStartsWith( '/foo.js', $enqueued_script_modules['foo'] );
     640        }
     641
     642        /**
     643         * Tests that a script module is registered with all the params when calling
     644         * enqueue.
     645         *
     646         * @ticket 56313
     647         *
     648         * @covers ::register()
     649         * @covers ::enqueue()
     650         * @covers ::print_enqueued_script_modules()
    655651         * @covers ::print_import_map()
    656652         */
    657         public function test_wp_enqueue_module_registers_all_params() {
    658                 $this->modules->enqueue( 'foo', '/foo.js', array( 'dep' ), '1.0' );
    659                 $this->modules->register( 'dep', '/dep.js' );
    660 
    661                 $enqueued_modules = $this->get_enqueued_modules();
    662                 $import_map       = $this->get_import_map();
    663 
    664                 $this->assertCount( 1, $enqueued_modules );
    665                 $this->assertEquals( '/foo.js?ver=1.0', $enqueued_modules['foo'] );
     653        public function test_wp_enqueue_script_module_registers_all_params() {
     654                $this->script_modules->enqueue( 'foo', '/foo.js', array( 'dep' ), '1.0' );
     655                $this->script_modules->register( 'dep', '/dep.js' );
     656
     657                $enqueued_script_modules = $this->get_enqueued_script_modules();
     658                $import_map              = $this->get_import_map();
     659
     660                $this->assertCount( 1, $enqueued_script_modules );
     661                $this->assertEquals( '/foo.js?ver=1.0', $enqueued_script_modules['foo'] );
    666662                $this->assertCount( 1, $import_map );
    667663                $this->assertStringStartsWith( '/dep.js', $import_map['dep'] );
Note: See TracChangeset for help on using the changeset viewer.