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

package/build/modules/lwr/loaderLegacy/importMap/utils.d.ts

@@ -0,0 +1,4 @@
+declare function getMatch(path: string, matchObj: Record<string, unknown>): string | undefined;
+declare function targetWarning(match: string, target: string, msg: string): void;
+export { getMatch, targetWarning };
+//# sourceMappingURL=utils.d.ts.map

package/build/modules/lwr/loaderLegacy/importMap/utils.js

@@ -0,0 +1,23 @@
+import { hasConsole } from '../utils/dom.js';
+// find the longest set of segments from path which are a key in matchObj
+// eg: getMatch('/a/b/c', { '/a/b': ..., '/a': ..., '/d/e/f': ...}) => '/a/b'
+function getMatch(path, matchObj) {
+    if (matchObj[path]) {
+        return path;
+    }
+    let sepIndex = path.length;
+    do {
+        const segment = path.slice(0, sepIndex + 1);
+        if (segment in matchObj) {
+            return segment;
+        }
+    } while (path.length > 1 && (sepIndex = path.lastIndexOf('/', sepIndex - 1)) !== -1);
+}
+function targetWarning(match, target, msg) {
+    if (hasConsole) {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        console.warn('Package target ' + msg + ", resolving target '" + target + "' for " + match);
+    }
+}
+export { getMatch, targetWarning };
+//# sourceMappingURL=utils.js.map

package/build/modules/lwr/loaderLegacy/importResolver/importResolver.d.ts

@@ -0,0 +1,6 @@
+import type { ImportDefinition, ImportMap } from '../importMap/importMap.js';
+export interface ImportResolver {
+    importMap: ImportMap;
+    resolve(resolvedOrPlain: string, parentUrl: string): ImportDefinition | undefined;
+}
+//# sourceMappingURL=importResolver.d.ts.map

package/build/modules/lwr/loaderLegacy/importResolver/importResolver.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=importResolver.js.map

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

@@ -0,0 +1,57 @@
+import { Module, ModuleDefinitionSignatures } from './moduleRegistry/moduleRegistry.js';
+import { ImportMap } from './importMap/importMap.js';
+import type { ServiceAPI } from '@lwrjs/types';
+import type { 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;
+    private baseUrl;
+    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
+     * @param {ModuleDefinitionSignatures} signatures Object containing the module signature and the signatures of its dependencies
+     * @return {void}
+     */
+    define(name: string, dependencies: string[], execute: Function, signatures: ModuleDefinitionSignatures): 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>;
+    private parentImportMap?;
+    registerImportMappings(mappings?: ImportMap): 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=loaderLegacy.d.ts.map

package/build/modules/lwr/loaderLegacy/loaderLegacy.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 Legacy Module Loader v0.13.0-alpha.2 */
+/* LWR Legacy 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) {
@@ -377,7 +377,7 @@ try {
   // swallow
 }
 const trusted = createPolicy('trusted', policyOptions);
-/*! version: 0.22.1 */
+/*! version: 0.22.3 */
 
 /* global console,process */
 
@@ -519,7 +519,7 @@ function evaluateHandleStaleModuleHooks(
 // 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`;
 
@@ -572,8 +572,6 @@ const MODULE_ERROR = `${LOADER_PREFIX}module.error`;
 
 
 
-
-
 
 
 
@@ -620,7 +618,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);
                 }
 
@@ -674,7 +672,7 @@ class ModuleRegistry {
                         resolvedOrPlain,
                     ) ;
                     if (namedDefineRecord.external || namedDefineRecord.defined) {
-                        const record = this.moduleRegistry.get(resolved);
+                        const record = this.moduleRegistry.get(resolved );
                         if (!record || !this.aliases.has(resolvedOrPlain)) {
                             return resolvedOrPlain;
                         }
@@ -759,7 +757,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);
@@ -1464,6 +1462,9 @@ async function evaluateImportMaps(baseUrl) {
     return importMapPromise;
 }
 
+function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
 /**
  * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
  */
@@ -1473,9 +1474,9 @@ class Loader {
 
     
     constructor(config) {
-        config = config || {};
-        let baseUrl = config.baseUrl;
-        let profiler = config.profiler;
+        const loaderConfig = config || {};
+        let baseUrl = loaderConfig.baseUrl;
+        let profiler = loaderConfig.profiler;
         if (baseUrl) {
             // add a trailing slash, if it does not exist
             baseUrl = baseUrl.replace(/\/?$/, '/');
@@ -1506,8 +1507,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: _optionalChain([config, 'optionalAccess', _ => _.appMetadata]) ,
         });
     }
 

package/build/modules/lwr/loaderLegacy/moduleRegistry/moduleRegistry.d.ts

@@ -0,0 +1,53 @@
+import type { ImportMapResolver } from '../importMap/importMapResolver.js';
+import type { HandleStaleModuleHook, LoaderHooks, ResolveHookResponse } from '@lwrjs/types';
+import type { LoaderConfig } from '../../../../types.js';
+export type ModuleDefinitionSignatures = {
+    ownHash: string;
+    hashes: {
+        [key: string]: string;
+    };
+};
+export type Module = {
+    [key: string]: any;
+    __useDefault?: boolean;
+};
+export declare class ModuleRegistry {
+    private profiler;
+    constructor(config: LoaderConfig);
+    load(id: string, importer?: string): Promise<Module>;
+    resolve(id: string, importer?: string): Promise<string>;
+    has(id: string): boolean;
+    define(name: string, dependencies: string[], exporter: Function, signatures: ModuleDefinitionSignatures): void;
+    /**
+     * Marks modules as "externally" loaded/provided, so that the loader does not attempt to fetch them.
+     *
+     * @param modules - list of module identifiers
+     */
+    registerExternalModules(modules: string[]): void;
+    private checkModuleSignature;
+    private resolver?;
+    setImportResolver(resolver: ImportMapResolver): void;
+    private baseUrl;
+    private namedDefineRegistry;
+    private moduleRegistry;
+    aliases: Map<string, string>;
+    private lastDefine;
+    private getExistingModuleRecord;
+    private getModuleRecord;
+    private storeModuleAlias;
+    private getModuleDependencyRecord;
+    private topLevelEvaluation;
+    private instantiateAll;
+    private evaluateModule;
+    private isNamedExportDefaultOnly;
+    private getCircularDependencyWrapper;
+    private evaluateModuleDependencies;
+    private getModuleDef;
+    private resolveHook?;
+    private loadHook?;
+    addLoaderPlugin(hooks: LoaderHooks): void;
+    private handleStaleModuleHook?;
+    registerHandleStaleModuleHook(handleStaleModule: HandleStaleModuleHook): void;
+    isValidResolveResponse(res: ResolveHookResponse): boolean;
+}
+//# sourceMappingURL=moduleRegistry.d.ts.map