@wordpress/interactivity-router 2.24.0 → 2.26.0

package/build-types/assets/dynamic-importmap/resolver.d.ts

@@ -0,0 +1,35 @@
+/**
+ * This code is derived from the following projects:
+ *
+ * 1. dynamic-importmap (https://github.com/keller-mark/dynamic-importmap)
+ * 2. es-module-shims (https://github.com/guybedford/es-module-shims)
+ *
+ * The original implementation was created by Guy Bedford in es-module-shims,
+ * then adapted by Mark Keller in dynamic-importmap, and further modified
+ * for use in this project.
+ *
+ * Both projects are licensed under the MIT license.
+ *
+ * MIT License: https://opensource.org/licenses/MIT
+ */
+/**
+ * Extends the internal dynamic import map with the passed one.
+ *
+ * @param importMapIn         Import map.
+ * @param importMapIn.imports Imports declaration.
+ * @param importMapIn.scopes  Scopes declaration.
+ */
+export declare function addImportMap(importMapIn: {
+    imports?: Record<string, string>;
+    scopes?: Record<string, any>;
+}): void;
+/**
+ * Resolves the URL of the passed module ID against the current internal
+ * dynamic import map.
+ *
+ * @param id        Module ID.
+ * @param parentUrl Parent URL, in case the module ID is relative.
+ * @return Resolved module URL.
+ */
+export declare function resolve(id: string, parentUrl: string): string;
+//# sourceMappingURL=resolver.d.ts.map

package/build-types/assets/dynamic-importmap/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/assets/dynamic-importmap/resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAyPH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAE,WAAW,EAAE;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAE,MAAM,EAAE,MAAM,CAAE,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAE,MAAM,EAAE,GAAG,CAAE,CAAC;CAC/B,QAMA;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAI,MAAM,CAG/D"}

package/build-types/assets/script-modules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Internal dependencies
+ */
+import { type ModuleLoad } from './dynamic-importmap';
+/**
+ * Marks the specified module as natively resolved.
+ * @param url Script module URL.
+ */
+export declare const markScriptModuleAsResolved: (url: string) => void;
+/**
+ * Resolves and fetches modules present in the passed document, using the
+ * document's import map to resolve them.
+ *
+ * @param doc Document containing the modules to preload.
+ * @return Array of promises that resolve to a `ScriptModuleLoad` instance.
+ */
+export declare const preloadScriptModules: (doc: Document) => Promise<ModuleLoad>[];
+/**
+ * Imports modules respresented by the passed `ScriptModuleLoad` instances.
+ *
+ * @param modules Array of `MoudleLoad` instances.
+ * @return Promise that resolves once all modules are imported.
+ */
+export declare const importScriptModules: (modules: ScriptModuleLoad[]) => Promise<unknown[]>;
+export type ScriptModuleLoad = ModuleLoad;
+//# sourceMappingURL=script-modules.d.ts.map

package/build-types/assets/script-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-modules.d.ts","sourceRoot":"","sources":["../../src/assets/script-modules.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAIN,KAAK,UAAU,EACf,MAAM,qBAAqB,CAAC;AAQ7B;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAU,MAAM,SAEtD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,QAAU,QAAQ,0BA0BlD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,YAAc,gBAAgB,EAAE,uBACE,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC"}

package/build-types/assets/scs.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calculates the Shortest Common Supersequence (SCS) of two sequences.
+ *
+ * A supersequence is a sequence that contains both input sequences as subsequences.
+ * The shortest common supersequence is the shortest possible such sequence.
+ *
+ * This implementation uses dynamic programming with a time complexity of O(mn)
+ * and space complexity of O(mn), where m and n are the lengths of sequences X and Y.
+ *
+ * @example
+ * ```ts
+ * const seq1 = [1, 3, 5];
+ * const seq2 = [2, 3, 4];
+ * const scs = shortestCommonSupersequence(seq1, seq2); // [1, 2, 3, 4, 5]
+ * ```
+ *
+ * @param X       The first sequence.
+ * @param Y       The second sequence.
+ * @param isEqual Optional equality function to compare elements.
+ *                Defaults to strict equality (===).
+ * @return The shortest common supersequence of X and Y.
+ */
+export declare function shortestCommonSupersequence<E = unknown>(X: E[], Y: E[], isEqual?: (a: E, b: E) => boolean): E[];
+//# sourceMappingURL=scs.d.ts.map

package/build-types/assets/scs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scs.d.ts","sourceRoot":"","sources":["../../src/assets/scs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2BAA2B,CAAE,CAAC,GAAG,OAAO,EACvD,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,OAAQ,CAAC,KAAK,CAAC,YAAa,OAmCnC"}

package/build-types/assets/styles.d.ts

@@ -0,0 +1,69 @@
+export type StyleElement = HTMLLinkElement | HTMLStyleElement;
+/**
+ * Normalizes the passed style or link element, reverting the changes
+ * made by {@link prepareStylePromise|`prepareStylePromise`} to the
+ * `data-original-media` and `media`.
+ *
+ * @example
+ * The following elements should be normalized to the same element:
+ * ```html
+ * <link rel="stylesheet" src="./assets/styles.css">
+ * <link rel="stylesheet" src="./assets/styles.css" media="all">
+ * <link rel="stylesheet" src="./assets/styles.css" media="preload">
+ * <link rel="stylesheet" src="./assets/styles.css" media="preload" data-original-media="all">
+ * ```
+ *
+ * @param element `<style>` or `<link>` element.
+ * @return Normalized node.
+ */
+export declare const normalizeMedia: (element: StyleElement) => StyleElement;
+/**
+ * Adds the minimum style elements from Y around those in X using a
+ * shortest common supersequence algorithm, returning a list of
+ * promises for all the elements in Y.
+ *
+ * If X is empty, it appends all elements in Y to the passed parent
+ * element or to `document.head` instead.
+ *
+ * The returned promises resolve once the corresponding style element
+ * is loaded and ready. Those elements that are also in X return a
+ * cached promise.
+ *
+ * The algorithm ensures that the final style elements present in the
+ * document (or the passed `parent` element) are in the correct order
+ * and they are included in either X or Y.
+ *
+ * @param X      Base list of style elements.
+ * @param Y      List of style elements.
+ * @param parent Optional parent element to append to the new style elements.
+ * @return List of promises that resolve once the elements in Y are ready.
+ */
+export declare function updateStylesWithSCS(X: StyleElement[], Y: StyleElement[], parent?: Element): any[];
+/**
+ * Prepares all style elements contained in the passed document.
+ *
+ * This function calls {@link updateStylesWithSCS|`updateStylesWithSCS`}
+ * to insert only the minimum amount of style elements into the DOM, so
+ * those present in the passed document end up in the DOM while the order
+ * is respected.
+ *
+ * New appended style elements contain a `media=preload` attribute to
+ * make them effectively disabled until they are applied with the
+ * {@link applyStyles|`applyStyles`} function.
+ *
+ * @param doc Document instance.
+ * @param url URL for the passed document.
+ * @return A list of promises for each style element in the passed document.
+ */
+export declare const preloadStyles: (doc: Document, url: string) => Promise<StyleElement>[];
+/**
+ * Traverses all style elements in the DOM, enabling only those included
+ * in the passed list and disabling the others.
+ *
+ * If the style element has the `data-original-media` attribute, the
+ * original `media` value is restored.
+ *
+ * @param styles List of style elements to apply.
+ */
+export declare const applyStyles: (styles: StyleElement[]) => void;
+//# sourceMappingURL=styles.d.ts.map

package/build-types/assets/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/assets/styles.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,gBAAgB,CAAC;AAa9D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,YAAc,YAAY,KAAI,YAYxD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAClC,CAAC,EAAE,YAAY,EAAE,EACjB,CAAC,EAAE,YAAY,EAAE,EACjB,MAAM,GAAE,OAA8B,SAqDtC;AAiFD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,QACpB,QAAQ,OACR,MAAM,KACT,OAAO,CAAE,YAAY,CAAE,EAoBzB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,WAAa,YAAY,EAAE,SAclD,CAAC"}

package/build-types/full-page.d.ts

@@ -0,0 +1,3 @@
+declare const isValidLink: (ref: HTMLAnchorElement) => boolean;
+declare const isValidEvent: (event: MouseEvent) => boolean;
+//# sourceMappingURL=full-page.d.ts.map

package/build-types/full-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full-page.d.ts","sourceRoot":"","sources":["../src/full-page.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,WAAW,QAAU,iBAAiB,YASS,CAAC;AAGtD,QAAA,MAAM,YAAY,UAAY,UAAU,YAOf,CAAC"}

package/build-types/index.d.ts

@@ -1,4 +1,4 @@
-interface NavigateOptions {
+export interface NavigateOptions {
     force?: boolean;
     html?: string;
     replace?: boolean;
@@ -6,7 +6,7 @@ interface NavigateOptions {
     loadingAnimation?: boolean;
     screenReaderAnnouncement?: boolean;
 }
-interface PrefetchOptions {
+export interface PrefetchOptions {
     force?: boolean;
     html?: string;
 }
@@ -17,8 +17,7 @@ export declare const state: {
         hasFinished: boolean;
     };
 }, actions: {
-    navigate: (href: string, options?: NavigateOptions) => void;
-    prefetch: (url: string, options?: PrefetchOptions) => void;
+    navigate: (href: string, options?: NavigateOptions) => Promise<void>;
+    prefetch: (url: string, options?: PrefetchOptions) => Promise<void>;
 };
-export {};
 //# sourceMappingURL=index.d.ts.map

package/build-types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAuBA,UAAU,eAAe;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,UAAU,eAAe;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAwMD,eAAO,MAAQ,KAAK;SAZb,MAAM;;oBAEE,OAAO;qBACN,OAAO;;GASD,OAAO;cALjB,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAM,IAAI;cACnD,CAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAM,IAAI;CAgJ3D,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiCA,MAAM,WAAW,eAAe;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAiPD,eAAO,MAAQ,KAAK;SAfb,MAAM;;oBAEE,OAAO;qBACN,OAAO;;GAYD,OAAO;cARjB,CACT,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,eAAe,KACrB,OAAO,CAAE,IAAI,CAAE;cACV,CAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAM,OAAO,CAAE,IAAI,CAAE;CAqJtE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/interactivity-router",
-	"version": "2.24.0",
+	"version": "2.26.0",
 	"description": "Package that exposes state and actions from the `core/router` store, part of the Interactivity API.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -25,14 +25,18 @@
 	"main": "build/index.js",
 	"module": "build-module/index.js",
 	"react-native": "src/index",
-	"wpScriptModuleExports": "./build-module/index.js",
+	"wpScriptModuleExports": {
+		".": "./build-module/index.js",
+		"./full-page": "./build-module/full-page.js"
+	},
 	"types": "build-types",
 	"dependencies": {
-		"@wordpress/a11y": "^4.24.0",
-		"@wordpress/interactivity": "^6.24.0"
+		"@wordpress/a11y": "^4.26.0",
+		"@wordpress/interactivity": "^6.26.0",
+		"es-module-lexer": "^1.5.4"
 	},
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "9c03d1458cae76792ae15e67b421205836bf4393"
+	"gitHead": "35e26942820d8237771af0c58e45b4303f0497f1"
 }

package/src/assets/dynamic-importmap/fetch.ts

@@ -0,0 +1,58 @@
+/**
+ * This code is derived from the following projects:
+ *
+ * 1. dynamic-importmap (https://github.com/keller-mark/dynamic-importmap)
+ * 2. es-module-shims (https://github.com/guybedford/es-module-shims)
+ *
+ * The original implementation was created by Guy Bedford in es-module-shims,
+ * then adapted by Mark Keller in dynamic-importmap, and further modified
+ * for use in this project.
+ *
+ * Both projects are licensed under the MIT license.
+ *
+ * MIT License: https://opensource.org/licenses/MIT
+ */
+
+/**
+ * Internal dependencies
+ */
+import { type ModuleLoad } from './loader';
+
+const fetching = ( url: string, parent?: string ) => {
+	return ` fetching ${ url }${ parent ? ` from ${ parent }` : '' }`;
+};
+
+const jsContentType = /^(text|application)\/(x-)?javascript(;|$)/;
+
+/**
+ * Fetches the passed module URL and return the corresponding `ModuleLoad`
+ * instance. If the passed URL does not point to a JS file, the function
+ * throws and error.
+ *
+ * @param url       Module URL.
+ * @param fetchOpts Fetch init options.
+ * @param parent    Parent module URL referencing this URL (if any).
+ * @return Promise with a `ModuleLoad` instance.
+ */
+export async function fetchModule(
+	url: string,
+	fetchOpts: RequestInit,
+	parent: string
+): Promise< ModuleLoad > {
+	let res: Response;
+	try {
+		res = await fetch( url, fetchOpts );
+	} catch ( e ) {
+		throw Error( `Network error${ fetching( url, parent ) }.` );
+	}
+	if ( ! res.ok ) {
+		throw Error( `Error ${ res.status }${ fetching( url, parent ) }.` );
+	}
+	const contentType = res.headers.get( 'content-type' );
+	if ( ! jsContentType.test( contentType ) ) {
+		throw Error(
+			`Bad Content-Type "${ contentType }"${ fetching( url, parent ) }.`
+		);
+	}
+	return { responseUrl: res.url, source: await res.text() };
+}

package/src/assets/dynamic-importmap/index.ts

@@ -0,0 +1,87 @@
+/**
+ * This code is derived from the following projects:
+ *
+ * 1. dynamic-importmap (https://github.com/keller-mark/dynamic-importmap)
+ * 2. es-module-shims (https://github.com/guybedford/es-module-shims)
+ *
+ * The original implementation was created by Guy Bedford in es-module-shims,
+ * then adapted by Mark Keller in dynamic-importmap, and further modified
+ * for use in this project.
+ *
+ * Both projects are licensed under the MIT license.
+ *
+ * MIT License: https://opensource.org/licenses/MIT
+ */
+
+/**
+ * Internal dependencies
+ */
+import { addImportMap, resolve } from './resolver';
+import { initPromise, topLevelLoad, preloadModule } from './loader';
+
+type ImportMap = {
+	imports?: Record< string, string >;
+	scopes?: Record< string, Record< string, string > >;
+};
+
+// TODO: check if this baseURI should change per document, and so
+// it need to be passed as a parameter to methods like `importWithMap`
+// and `preloadWithMap`.
+const baseUrl = document.baseURI;
+const pageBaseUrl = baseUrl;
+
+Object.defineProperty( self, 'wpInteractivityRouterImport', {
+	value: importShim,
+	writable: false,
+	enumerable: false,
+	configurable: false,
+} );
+
+async function importShim< Module = unknown >( id: string ) {
+	await initPromise;
+	return topLevelLoad< Module >( resolve( id, pageBaseUrl ), {
+		credentials: 'same-origin',
+	} );
+}
+
+/**
+ * Imports the module with the passed ID.
+ *
+ * The module is resolved against the internal dynamic import map,
+ * extended with the passed import map.
+ *
+ * @param id          Module ID.
+ * @param importMapIn Import map.
+ * @return Resolved module.
+ */
+export async function importWithMap< Module = unknown >(
+	id: string,
+	importMapIn: ImportMap
+) {
+	addImportMap( importMapIn );
+	return importShim< Module >( id );
+}
+
+/**
+ * Preloads the module with the passed ID along with its dependencies.
+ *
+ * The module is resolved against the internal dynamic import map,
+ * extended with the passed import map.
+ *
+ * @param id          Module ID.
+ * @param importMapIn Import map.
+ * @return Resolved `ModuleLoad` instance.
+ */
+export async function preloadWithMap( id: string, importMapIn: ImportMap ) {
+	addImportMap( importMapIn );
+	await initPromise;
+	return preloadModule( resolve( id, pageBaseUrl ), {
+		credentials: 'same-origin',
+	} );
+}
+
+export {
+	initialImportMap,
+	importPreloadedModule,
+	type ModuleLoad,
+} from './loader';