@lwrjs/loader 0.13.0-alpha.2 → 0.13.0-alpha.21

package/build/modules/lwr/loader/errors/messages.js

@@ -0,0 +1,128 @@
+import { templateString } from './utils.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function generateErrorMessage(errorInfo, args) {
+    const message = Array.isArray(args) ? templateString(errorInfo.message, args) : errorInfo.message;
+    return `LWR${errorInfo.code}: ${message}`;
+}
+class LoaderError extends Error {
+    constructor(errorInfo, errorArgs) {
+        super();
+        this.message = generateErrorMessage(errorInfo, errorArgs);
+    }
+}
+function invariant(condition, errorInfo) {
+    if (!condition) {
+        throw new LoaderError(errorInfo);
+    }
+}
+const MISSING_NAME = Object.freeze({
+    code: 3000,
+    message: 'A module name is required.',
+    level: 0,
+});
+const FAIL_INSTANTIATE = Object.freeze({
+    code: 3004,
+    message: 'Failed to instantiate module: {0}',
+    level: 0,
+});
+const NO_AMD_REQUIRE = Object.freeze({
+    code: 3005,
+    message: 'AMD require not supported.',
+    level: 0,
+});
+const FAILED_DEP = Object.freeze({
+    code: 3006,
+    level: 0,
+    message: 'Failed to load dependency: {0}',
+});
+const INVALID_DEPS = Object.freeze({
+    code: 3007,
+    message: 'Unexpected value received for dependencies argument; expected an array.',
+    level: 0,
+});
+const FAIL_LOAD = Object.freeze({
+    code: 3008,
+    level: 0,
+    message: 'Error loading {0}',
+});
+const UNRESOLVED = Object.freeze({
+    code: 3009,
+    level: 0,
+    message: 'Unable to resolve bare specifier: {0}',
+});
+const NO_BASE_URL = Object.freeze({
+    code: 3010,
+    level: 0,
+    message: 'baseUrl not set',
+});
+const HOOK_ALREADY_SET = Object.freeze({
+    code: 3011,
+    level: 0,
+    message: 'Cannot set a loader service multiple times',
+});
+const INVALID_HOOK = Object.freeze({
+    code: 3012,
+    level: 0,
+    message: 'Invalid hook received',
+});
+const INVALID_LOADER_SERVICE_RESPONSE = Object.freeze({
+    code: 3013,
+    level: 0,
+    message: 'Invalid response received from hook',
+});
+const MODULE_LOAD_TIMEOUT = Object.freeze({
+    code: 3014,
+    level: 0,
+    message: 'Error loading {0} - timed out',
+});
+const HTTP_FAIL_LOAD = Object.freeze({
+    code: 3015,
+    level: 0,
+    message: 'Error loading {0}, status code {1}',
+});
+const STALE_HOOK_ERROR = Object.freeze({
+    code: 3016,
+    level: 0,
+    message: 'An error occurred handling module conflict',
+});
+const MODULE_ALREADY_LOADED = Object.freeze({
+    code: 3017,
+    level: 0,
+    message: 'Marking module(s) as externally loaded, but they are already loaded:',
+});
+const FAIL_HOOK_LOAD = Object.freeze({
+    code: 3018,
+    level: 0,
+    message: 'Error loading "{0}" from hook',
+});
+const NO_MAPPING_URL = Object.freeze({
+    code: 3019,
+    level: 0,
+    message: 'Mapping endpoint not set',
+});
+const BAD_IMPORT_METADATA = Object.freeze({
+    code: 3020,
+    level: 0,
+    message: 'Invalid import metadata: {0} {1}',
+});
+const EXPORTER_ERROR = Object.freeze({
+    code: 3021,
+    level: 0,
+    message: 'Error evaluating module "{0}", error was "{1}"',
+});
+const UNRESOLVEABLE_MAPPING_ERROR = Object.freeze({
+    code: 3022,
+    level: 0,
+    message: 'Unexpected undefined URI resolving mapping for "{0}"',
+});
+/* importMap errors */
+const BAD_IMPORT_MAP = Object.freeze({
+    code: 3011,
+    level: 0,
+    message: 'import map is not valid',
+});
+/* Errors */
+export { MISSING_NAME, FAIL_INSTANTIATE, NO_AMD_REQUIRE, FAILED_DEP, INVALID_DEPS, FAIL_LOAD, UNRESOLVED, NO_BASE_URL, NO_MAPPING_URL, BAD_IMPORT_MAP, BAD_IMPORT_METADATA, HOOK_ALREADY_SET, INVALID_HOOK, INVALID_LOADER_SERVICE_RESPONSE, MODULE_LOAD_TIMEOUT, HTTP_FAIL_LOAD, STALE_HOOK_ERROR, MODULE_ALREADY_LOADED, FAIL_HOOK_LOAD, EXPORTER_ERROR, UNRESOLVEABLE_MAPPING_ERROR, };
+/* API */
+export { invariant, LoaderError };
+//# sourceMappingURL=messages.js.map

package/build/modules/lwr/loader/errors/reportError.d.ts

@@ -0,0 +1,4 @@
+import type { LoaderError } from './messages.js';
+declare function reportError(error: LoaderError): void;
+export { reportError };
+//# sourceMappingURL=reportError.d.ts.map

package/build/modules/lwr/loader/errors/reportError.js

@@ -0,0 +1,9 @@
+import { hasConsole } from '../utils/dom.js';
+function reportError(error) {
+    // TODO eventually this should be configurable instrumentation to send this somewhere
+    // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+    if (hasConsole)
+        console.error(error);
+}
+export { reportError };
+//# sourceMappingURL=reportError.js.map

package/build/modules/lwr/loader/errors/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function templateString(template: string, args: any[]): string;
+//# sourceMappingURL=utils.d.ts.map

package/build/modules/lwr/loader/errors/utils.js

@@ -0,0 +1,8 @@
+const templateRegex = /\{([0-9]+)\}/g;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function templateString(template, args) {
+    return template.replace(templateRegex, (_, index) => {
+        return args[index];
+    });
+}
+//# sourceMappingURL=utils.js.map

package/build/modules/lwr/loader/hooks/moduleInvalidation.d.ts

@@ -0,0 +1,3 @@
+import type { HandleStaleModuleHookArgs, HandleStaleModuleHook } from '@lwrjs/types';
+export declare function evaluateHandleStaleModuleHooks(handleStaleModuleHooks: HandleStaleModuleHook[], hookArgs: HandleStaleModuleHookArgs): void;
+//# sourceMappingURL=moduleInvalidation.d.ts.map

package/build/modules/lwr/loader/hooks/moduleInvalidation.js

@@ -0,0 +1,19 @@
+import { LoaderError, STALE_HOOK_ERROR } from '../errors/messages.js';
+import { reportError } from '../errors/reportError.js';
+export function evaluateHandleStaleModuleHooks(handleStaleModuleHooks, hookArgs) {
+    const { name, oldUrl, newUrl } = hookArgs;
+    // keep evaluating hooks if return value is null
+    for (let i = 0; i < handleStaleModuleHooks.length; i++) {
+        const hook = handleStaleModuleHooks[i];
+        try {
+            const hookResult = hook({ name, oldUrl, newUrl });
+            if (hookResult !== null) {
+                break;
+            }
+        }
+        catch (e) {
+            reportError(new LoaderError(STALE_HOOK_ERROR));
+        }
+    }
+}
+//# sourceMappingURL=moduleInvalidation.js.map

package/build/modules/lwr/loader/hooks/resolveAndLoadHook.d.ts

@@ -0,0 +1,7 @@
+import type { CustomResponse, LoadHookResponse, ResolveHookResponse } from '@lwrjs/types';
+export declare function isCustomResponse(response: CustomResponse | globalThis.Response): response is CustomResponse;
+export declare function isFetchResponse(response: globalThis.Response | CustomResponse): response is globalThis.Response;
+export declare function isResponseAPromise(response: ResolveHookResponse | LoadHookResponse | Promise<ResolveHookResponse> | Promise<LoadHookResponse>): boolean;
+export declare function evaluateLoadHookResponse(response: LoadHookResponse, id: string): Promise<boolean>;
+export declare function evaluateLoadHook(id: string, hookPromise: Promise<LoadHookResponse>): Promise<LoadHookResponse>;
+//# sourceMappingURL=resolveAndLoadHook.d.ts.map

package/build/modules/lwr/loader/hooks/resolveAndLoadHook.js

@@ -0,0 +1,94 @@
+/* global console,process */
+import { LoaderError, INVALID_LOADER_SERVICE_RESPONSE, FAIL_LOAD, HTTP_FAIL_LOAD, MODULE_LOAD_TIMEOUT, FAIL_HOOK_LOAD, } from '../errors/messages.js';
+import { MODULE_LOAD_TIMEOUT_TIMER } from '../constants/constants.js';
+import { hasDocument, hasSetTimeout, hasConsole } from '../utils/dom.js';
+// eslint-disable-next-line lwr/only-allowed-imports
+import { trusted } from '@locker/trusted-types';
+let lastWindowError;
+if (hasDocument) {
+    globalThis.addEventListener('error', (evt) => {
+        lastWindowError = evt.error;
+    });
+}
+if (process.env.NODE_ENV !== 'production') {
+    if (!hasSetTimeout && hasConsole) {
+        // eslint-disable-next-line lwr/no-unguarded-apis
+        console.warn('setTimeout API is not available, watchdog timer on load hook will not be set');
+    }
+}
+export function isCustomResponse(response) {
+    return (Object.prototype.hasOwnProperty.call(response, 'data') &&
+        !Object.prototype.hasOwnProperty.call(response, 'blob'));
+}
+export function isFetchResponse(response) {
+    // if it quacks like a duck...
+    return typeof response.blob === 'function';
+}
+export function isResponseAPromise(response) {
+    return !!(response && response.then);
+}
+export async function evaluateLoadHookResponse(response, id) {
+    return Promise.resolve().then(async () => {
+        if (!response || !response.status) {
+            throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+        }
+        if (response.status !== 200) {
+            throw new LoaderError(HTTP_FAIL_LOAD, [id, `${response.status}`]);
+        }
+        const isResponse = isFetchResponse(response);
+        let code;
+        if (isCustomResponse(response)) {
+            code = response.data;
+        }
+        else if (isResponse) {
+            // handle fetch response
+            code = await response.text();
+        }
+        else {
+            throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
+        }
+        if (!code) {
+            throw new LoaderError(FAIL_LOAD, [id]);
+        }
+        code = `${code}\n//# sourceURL=${id}`; // append sourceURL for debugging
+        try {
+            // TODO eval source maps for debugging
+            eval(trusted.createScript(code));
+        }
+        catch (e) {
+            if (process.env.NODE_ENV !== 'production' && hasConsole) {
+                // eslint-disable-next-line lwr/no-unguarded-apis
+                console.error(e);
+            }
+            throw new LoaderError(FAIL_LOAD, [id]);
+        }
+        if (lastWindowError) {
+            throw new LoaderError(FAIL_LOAD, [id]);
+        }
+        return true;
+    });
+}
+export async function evaluateLoadHook(id, hookPromise) {
+    if (!hasSetTimeout) {
+        return hookPromise;
+    }
+    return new Promise((resolve, reject) => {
+        // wrap the hook in a watchdog timer
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        const timer = setTimeout(() => {
+            reject(new LoaderError(MODULE_LOAD_TIMEOUT, [id]));
+        }, MODULE_LOAD_TIMEOUT_TIMER);
+        hookPromise
+            .then((response) => {
+            resolve(response);
+        })
+            .catch(() => {
+            reject(new LoaderError(FAIL_HOOK_LOAD, [id]));
+        })
+            .finally(() => {
+            // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+            clearTimeout(timer);
+        });
+    });
+}
+//# sourceMappingURL=resolveAndLoadHook.js.map

package/build/modules/lwr/loader/loader.d.ts

@@ -0,0 +1,53 @@
+import { Module } from './moduleRegistry/moduleRegistry.js';
+import type { ServiceAPI, ImportMetadata } from '@lwrjs/types';
+import type { FingerprintsLoaderConfig as LoaderConfig } from '../../../types.js';
+/**
+ * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
+ */
+export declare class Loader {
+    private registry;
+    readonly services: Readonly<Pick<ServiceAPI, 'addLoaderPlugin' | 'handleStaleModule' | 'appMetadata'>>;
+    constructor(config: LoaderConfig);
+    /**
+     * Defines/registers a single named AMD module definition.
+     *
+     * @param {string} name The module name
+     * @param {string[]} dependencies A list of module dependencies (module imports)
+     * @param {Function} execute The function containing the module code. AKA exporter as it also returns the modules exports when executed
+     * @return {void}
+     */
+    define(name: string, dependencies: string[], execute: Function): void;
+    /**
+     * Retrieves/loads a module, returning it from the registry if it exists and fetching it if it doesn't.
+     *
+     * @param {string} id - A module identifier or URL
+     * @param {string} importer - The versioned specifier of the module importer
+     *                            Used when the ID is not versioned (eg: variable dynamic imports)
+     * @return {Promise<Module>}
+     */
+    load(id: string, importer?: string): Promise<Module>;
+    /**
+     * Checks if a Module exists in the registry.  Note, returns false even if the ModuleDefinition exists but the Module has not been instantiated yet (executed).
+     *
+     * @param {string} id - A module identifier or URL
+     * @return {boolean}
+     */
+    has(id: string): boolean;
+    /**
+     * Resolves the module identifier or URL.  Returns the module identifier if the moduleDefinition exists, or the full resolved URL if a URL is given.
+     *
+     * @param {string} id - A module identifier or URL
+     * @param {string} importer - The versioned specifier of the module importer
+     *                            Used when the ID is not versioned (eg: variable dynamic imports)
+     * @return {string}
+     */
+    resolve(id: string, importer?: string): Promise<string>;
+    registerImportMappings(mappings: ImportMetadata, rootSpecifiers: string[]): Promise<void>;
+    /**
+     * Marks modules as "externally" loaded/provided (e.g. preloaded), so that the loader does not attempt to load them.
+     *
+     * @param modules - list of module identifiers
+     */
+    registerExternalModules(modules: string[]): void;
+}
+//# sourceMappingURL=loader.d.ts.map

package/build/modules/lwr/loader/loader.js

@@ -4,7 +4,7 @@
 * SPDX-License-Identifier: MIT
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
 */
-/* LWR Module Loader v0.13.0-alpha.2 */
+/* LWR Module Loader v0.13.0-alpha.21 */
 const templateRegex = /\{([0-9]+)\}/g;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function templateString(template, args) {
@@ -133,6 +133,11 @@ const EXPORTER_ERROR = Object.freeze({
     level: 0,
     message: 'Error evaluating module "{0}", error was "{1}"',
 });
+const UNRESOLVEABLE_MAPPING_ERROR = Object.freeze({
+    code: 3022,
+    level: 0,
+    message: 'Unexpected undefined URI resolving mapping for "{0}"',
+});
 
 /* importMap errors */
 Object.freeze({
@@ -329,7 +334,7 @@ if (hasDocument) {
 // Loader: modules
 const LOADER_PREFIX = 'lwr.loader.';
 const MODULE_DEFINE = `${LOADER_PREFIX}module.define`;
-const MODULE_DYNAMIC_LOAD = `${LOADER_PREFIX}moduleRegistry.dynamicLoad`;
+const MODULE_DYNAMIC_LOAD = `${LOADER_PREFIX}module.dynamicLoad`;
 const MODULE_FETCH = `${LOADER_PREFIX}module.fetch`;
 const MODULE_ERROR = `${LOADER_PREFIX}module.error`;
 
@@ -383,7 +388,7 @@ class ImportMetadataResolver {
     }
 
     getBaseUrl() {
-        return this.config.baseUrl;
+        return this.config.baseUrl || '';
     }
 
     registerImportMappings(newImportMetadata, rootSpecifiers) {
@@ -424,8 +429,8 @@ class ImportMetadataResolver {
 
     // Get URL from the local cache or return undefiend
      getURI(specifier) {
-        return this.importURICache.has(specifier)
-            ? resolveUrl(this.importURICache.get(specifier).uri, this.getBaseUrl())
+        return this.importURICache && this.importURICache.has(specifier)
+            ? resolveUrl((this.importURICache.get(specifier) ).uri, this.getBaseUrl())
             : undefined;
     }
 
@@ -526,6 +531,9 @@ class ImportMetadataResolver {
         // TODO For module invalidation with bundles it is recommended we have to send back all loaded root specified
         // to ensure we detect all conflicts.
         const uri = resolveUrl(this.buildMappingUrl(specifier), this.getBaseUrl());
+        if (!uri) {
+            throw new LoaderError(UNRESOLVEABLE_MAPPING_ERROR, [specifier]);
+        }
         return globalThis.fetch(uri).then((res) => {
             if (!res.ok) {
                 this.config.profiler.logOperationStart({ id: MAPPINGS_ERROR, specifier });
@@ -646,7 +654,7 @@ try {
   // swallow
 }
 const trusted = createPolicy('trusted', policyOptions);
-/*! version: 0.22.1 */
+/*! version: 0.22.3 */
 
 /* global console,process */
 
@@ -848,7 +856,7 @@ class ModuleRegistry {
                     // eslint-disable-next-line no-await-in-loop
                     result = isResponseAPromise(response) ? await response : response;
                 }
-                if (!this.isValidResolveResponse(result)) {
+                if (!this.isValidResolveResponse(result )) {
                     throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
                 }
 
@@ -979,7 +987,7 @@ class ModuleRegistry {
                     // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
                     timer = setTimeout(() => {
                         reject(new LoaderError(MODULE_LOAD_TIMEOUT, [id]));
-                    }, MODULE_LOAD_TIMEOUT_TIMER);
+                    }, MODULE_LOAD_TIMEOUT_TIMER) ;
                 }).finally(() => {
                     // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
                     clearTimeout(timer);
@@ -1417,7 +1425,7 @@ class Loader {
         const mappingEndpoint = config.endpoints ? config.endpoints.uris.mapping : undefined;
         let profiler = config.profiler;
 
-        if (!mappingEndpoint) {
+        if (!mappingEndpoint || !config.endpoints) {
             throw new LoaderError(NO_MAPPING_URL);
         }
 
@@ -1462,8 +1470,7 @@ class Loader {
         this.services = Object.freeze({
             addLoaderPlugin: this.registry.addLoaderPlugin.bind(this.registry),
             handleStaleModule: this.registry.registerHandleStaleModuleHook.bind(this.registry),
-            appMetadata: config.appMetadata,
-            serverData: config.serverData || {},
+            appMetadata: config.appMetadata ,
         });
     }
 

package/build/modules/lwr/loader/moduleRegistry/importMetadataResolver.d.ts

@@ -0,0 +1,44 @@
+import type { ImportMetadata, LoadMappingHook } from '@lwrjs/types';
+import type { FingerprintsLoaderConfig as LoaderConfig } from '../../../../types.js';
+export type InvalidationCallback = (details: {
+    name: string;
+    oldUrl: string;
+    newUrl: string;
+}) => void;
+export declare class ImportMetadataResolver {
+    private importURICache;
+    private pendingURICache;
+    private config;
+    private invalidationCallback;
+    private loadMappingHooks;
+    constructor(config: LoaderConfig, invalidationCallback: Function);
+    addLoadMappingHook(hook: LoadMappingHook): void;
+    getMappingEndpoint(): string | undefined;
+    getModifiersAsUrlParams(): string;
+    buildMappingUrl(specifier: string): string;
+    getBaseUrl(): string;
+    registerImportMappings(newImportMetadata: ImportMetadata, rootSpecifiers: string[]): void;
+    private getURI;
+    resolveLocal(specifier: string): string | undefined;
+    /**
+     *  Resolves a the URI for a specified module.  It will return the value in this order:
+     *
+     *  1) Mapping from local URI cache
+     *  2) The URI if a specifier is already an absolute URI
+     *  3) Mapping fetched from a registered loader hook
+     *  4)
+     *  @param specifier
+     *  @returns module URI
+     */
+    resolve(specifier: string): Promise<string>;
+    private hasMappingHooks;
+    /**
+     *  Evaluates mapping hooks.  Returns first match. If all hooks return null call the mapping service.
+     *  @param specifier Request module identifier
+     *  @returns Import Metadata from the module root
+     */
+    private evaluateMappingHooks;
+    private fetchNewMappings;
+    private saveImportURIRecord;
+}
+//# sourceMappingURL=importMetadataResolver.d.ts.map