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

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

@@ -0,0 +1,128 @@
+import { hasDocument } from './dom.js';
+export function getBaseUrl() {
+    let baseUrl = undefined;
+    if (hasDocument) {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        const baseEl = document.querySelector('base[href]');
+        baseUrl = baseEl && baseEl.href;
+    }
+    // eslint-disable-next-line lwr/no-unguarded-apis
+    if (!baseUrl && typeof location !== 'undefined') {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        baseUrl = location.href.split('#')[0].split('?')[0];
+        const lastSepIndex = baseUrl.lastIndexOf('/');
+        if (lastSepIndex !== -1) {
+            baseUrl = baseUrl.slice(0, lastSepIndex + 1);
+        }
+    }
+    return baseUrl;
+}
+/**
+ * Check if a string is a URL based on Common Internet Scheme Syntax
+ * https://www.ietf.org/rfc/rfc1738.txt
+ *
+ * URL Format:
+ *  <scheme>:<scheme-specific-part>
+ * Common Internet Scheme Syntax:
+ *  The scheme specific part starts with a double slash('//')
+ *
+ * A valid URL has a colon that is followed by a double slash.
+ *
+ * @param url - the url that is being checked
+ * @returns boolean
+ *
+ * @example Valid URLs
+ * 'https://salesforce.com'
+ * 'http://localhost:3000'
+ *
+ * @example Invalid URLs
+ * 'salesforce.com'
+ * 'localhost:3000'
+ * '@salesforce/label/type:namespace:name'
+ */
+export function isUrl(url) {
+    return url.indexOf('://') !== -1;
+}
+// Borrowed and adapted from https://github.com/systemjs/systemjs/blob/master/src/common.js
+// Resolves the first path segment relative to the second/parent URL
+// eg: resolveIfNotPlainOrUrl('../test', 'http://www.site.com/one/two') => 'http://www.site.com/test'
+// eg: resolveIfNotPlainOrUrl('./x/y/z', 'https://my.com/segment')).toBe('https://my.com/x/y/z')
+export function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
+    const backslashRegEx = /\\/g;
+    if (relUrl.indexOf('\\') !== -1)
+        relUrl = relUrl.replace(backslashRegEx, '/');
+    // protocol-relative
+    if (relUrl[0] === '/' && relUrl[1] === '/') {
+        return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
+    }
+    // relative-url
+    else if ((relUrl[0] === '.' &&
+        (relUrl[1] === '/' ||
+            (relUrl[1] === '.' && (relUrl[2] === '/' || (relUrl.length === 2 && (relUrl += '/')))) ||
+            (relUrl.length === 1 && (relUrl += '/')))) ||
+        relUrl[0] === '/') {
+        const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
+        let pathname;
+        if (parentUrl[parentProtocol.length + 1] === '/') {
+            // resolving to a :// so we need to read out the auth and host
+            if (parentProtocol !== 'file:') {
+                pathname = parentUrl.slice(parentProtocol.length + 2);
+                pathname = pathname.slice(pathname.indexOf('/') + 1);
+            }
+            else {
+                pathname = parentUrl.slice(8);
+            }
+        }
+        else {
+            // resolving to :/ so pathname is the /... part
+            pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/' ? 1 : 0));
+        }
+        if (relUrl[0] === '/')
+            return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+        // join together and split for removal of .. and . segments
+        // looping the string instead of anything fancy for perf reasons
+        // '../../../../../z' resolved to 'x/y' is just 'z'
+        const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
+        const output = [];
+        let segmentIndex = -1;
+        for (let i = 0; i < segmented.length; i++) {
+            // busy reading a segment - only terminate on '/'
+            if (segmentIndex !== -1) {
+                if (segmented[i] === '/') {
+                    output.push(segmented.slice(segmentIndex, i + 1));
+                    segmentIndex = -1;
+                }
+            }
+            // new segment - check if it is relative
+            else if (segmented[i] === '.') {
+                // ../ segment
+                if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
+                    output.pop();
+                    i += 2;
+                }
+                // ./ segment
+                else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
+                    i += 1;
+                }
+                else {
+                    // the start of a new segment as below
+                    segmentIndex = i;
+                }
+            }
+            // it is the start of a new segment
+            else {
+                segmentIndex = i;
+            }
+        }
+        // finish reading out the last segment
+        if (segmentIndex !== -1)
+            output.push(segmented.slice(segmentIndex));
+        return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
+    }
+}
+export function resolveUrl(relUrl, parentUrl) {
+    const resolvedUrl = resolveIfNotPlainOrUrl(relUrl, parentUrl) ||
+        (isUrl(relUrl) ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
+    return resolvedUrl;
+}
+//# sourceMappingURL=url.js.map

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

@@ -0,0 +1,2 @@
+export declare const MODULE_LOAD_TIMEOUT_TIMER: number;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,2 @@
+export const MODULE_LOAD_TIMEOUT_TIMER = 60 * 1000; // 1m
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,30 @@
+declare class LoaderError extends Error {
+    constructor(errorInfo: ErrorInfo, errorArgs?: string[]);
+}
+declare function invariant(condition: boolean, errorInfo: ErrorInfo): void;
+interface ErrorInfo {
+    code: number;
+    message: string;
+    level: number;
+}
+declare const MISSING_NAME: ErrorInfo;
+declare const FAIL_INSTANTIATE: ErrorInfo;
+declare const NO_AMD_REQUIRE: ErrorInfo;
+declare const FAILED_DEP: ErrorInfo;
+declare const INVALID_DEPS: ErrorInfo;
+declare const FAIL_LOAD: ErrorInfo;
+declare const UNRESOLVED: ErrorInfo;
+declare const NO_BASE_URL: ErrorInfo;
+declare const HOOK_ALREADY_SET: ErrorInfo;
+declare const INVALID_HOOK: ErrorInfo;
+declare const INVALID_LOADER_SERVICE_RESPONSE: ErrorInfo;
+declare const MODULE_LOAD_TIMEOUT: ErrorInfo;
+declare const HTTP_FAIL_LOAD: ErrorInfo;
+declare const STALE_HOOK_ERROR: ErrorInfo;
+declare const MODULE_ALREADY_LOADED: ErrorInfo;
+declare const FAIL_HOOK_LOAD: ErrorInfo;
+declare const EXPORTER_ERROR: ErrorInfo;
+declare const BAD_IMPORT_MAP: ErrorInfo;
+export { MISSING_NAME, FAIL_INSTANTIATE, NO_AMD_REQUIRE, FAILED_DEP, INVALID_DEPS, FAIL_LOAD, UNRESOLVED, NO_BASE_URL, BAD_IMPORT_MAP, 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, };
+export { invariant, LoaderError };
+//# sourceMappingURL=messages.d.ts.map

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

@@ -0,0 +1,113 @@
+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: {0}',
+});
+const FAIL_HOOK_LOAD = Object.freeze({
+    code: 3018,
+    level: 0,
+    message: 'Error loading "{0}" from hook',
+});
+const EXPORTER_ERROR = Object.freeze({
+    code: 3021,
+    level: 0,
+    message: 'Error evaluating module "{0}", error was {1}',
+});
+/* 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, BAD_IMPORT_MAP, 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, };
+/* API */
+export { invariant, LoaderError };
+//# sourceMappingURL=messages.js.map

package/build/modules/lwr/loaderLegacy/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/loaderLegacy/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/loaderLegacy/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/loaderLegacy/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/loaderLegacy/hooks/moduleInvalidation.d.ts

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

package/build/modules/lwr/loaderLegacy/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, oldHash, newHash } = 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, oldHash, newHash });
+            if (hookResult !== null) {
+                break;
+            }
+        }
+        catch (e) {
+            reportError(new LoaderError(STALE_HOOK_ERROR));
+        }
+    }
+}
+//# sourceMappingURL=moduleInvalidation.js.map

package/build/modules/lwr/loaderLegacy/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/loaderLegacy/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/loaderLegacy/importMap/dom.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Import map support for LWR based on the spec: https://github.com/WICG/import-maps
+ *
+ * This implementation is adapted from https://github.com/systemjs/systemjs/blob/master/src/features/import-map.js
+ */
+import { ImportMap } from './importMap.js';
+declare const IMPORTMAP_SCRIPT_TYPE = "lwr-importmap";
+declare function evaluateImportMaps(baseUrl?: string): Promise<ImportMap | undefined>;
+export { IMPORTMAP_SCRIPT_TYPE, evaluateImportMaps };
+//# sourceMappingURL=dom.d.ts.map

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

@@ -0,0 +1,63 @@
+/**
+ * Import map support for LWR based on the spec: https://github.com/WICG/import-maps
+ *
+ * This implementation is adapted from https://github.com/systemjs/systemjs/blob/master/src/features/import-map.js
+ */
+import { resolveAndComposeImportMap } from './importMap.js';
+import { getBaseUrl } from '../utils/url.js';
+import { hasDocument, hasConsole } from '../utils/dom.js';
+import { LoaderError, BAD_IMPORT_MAP, NO_BASE_URL } from '../errors/messages.js';
+const IMPORTMAP_SCRIPT_TYPE = 'lwr-importmap';
+// iterates on the any <script type="${IMPORTMAP_SCRIPT_TYPE}", invoking the given callback for each
+function iterateDocumentImportMaps(callBack, extraSelector) {
+    // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+    const nodeList = document.querySelectorAll(`script[type="${IMPORTMAP_SCRIPT_TYPE}"]` + extraSelector);
+    const filtered = Array.from(nodeList).filter((node) => {
+        if (node.src) {
+            // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+            if (hasConsole)
+                console.warn('LWR does not support import maps from script src');
+            return false;
+        }
+        return true;
+    });
+    Array.prototype.forEach.call(filtered, callBack);
+}
+// retrives the import map text from a <script type="${IMPORTMAP_SCRIPT_TYPE}"
+async function getImportMapFromScript(script) {
+    return Promise.resolve(script.innerHTML);
+}
+// get importMap from <script type="lwr-importmap">
+async function evaluateImportMaps(baseUrl) {
+    let importMap = { imports: {}, scopes: {} };
+    let importMapPromise = Promise.resolve(importMap);
+    if (hasDocument) {
+        if (!baseUrl) {
+            baseUrl = getBaseUrl();
+        }
+        if (!baseUrl) {
+            throw new LoaderError(NO_BASE_URL);
+        }
+        iterateDocumentImportMaps((script) => {
+            importMapPromise = importMapPromise
+                .then(() => {
+                return getImportMapFromScript(script);
+            })
+                .then((importMapTxt) => {
+                try {
+                    return JSON.parse(importMapTxt);
+                }
+                catch (e) {
+                    throw new LoaderError(BAD_IMPORT_MAP);
+                }
+            })
+                .then((jsonImportMap) => {
+                importMap = resolveAndComposeImportMap(jsonImportMap, script.src || baseUrl, importMap);
+                return importMap;
+            });
+        }, '');
+    }
+    return importMapPromise;
+}
+export { IMPORTMAP_SCRIPT_TYPE, evaluateImportMaps };
+//# sourceMappingURL=dom.js.map

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

@@ -0,0 +1,22 @@
+export interface ImportMap {
+    imports?: ImportMapImports;
+    scopes?: {
+        [key: string]: ImportMapImports;
+    };
+    default?: string;
+}
+export type ImportMapImports = {
+    [key: string]: string;
+};
+/**
+ * Return type of the import resolver
+ *
+ */
+export type ImportDefinition = {
+    uri: string;
+    defaultUri?: boolean;
+};
+declare function resolveImportMapEntry(importMap: ImportMap, resolvedOrPlain: string, parentUrl?: string): ImportDefinition | undefined;
+declare function resolveAndComposeImportMap(json: ImportMap, baseUrl: string, parentMap?: ImportMap): ImportMap;
+export { resolveAndComposeImportMap, resolveImportMapEntry };
+//# sourceMappingURL=importMap.d.ts.map

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

@@ -0,0 +1,108 @@
+/**
+ * Import map support for LWR based on the spec: https://github.com/WICG/import-maps
+ *
+ * This implementation is adapted from https://github.com/systemjs/systemjs/blob/master/src/features/import-map.js
+ */
+import { resolveUrl, resolveIfNotPlainOrUrl, isUrl } from '../utils/url.js';
+import { getMatch, targetWarning } from './utils.js';
+// Resolves an import map package entry
+function applyPackages(id, packages, defaultUri) {
+    const pkgName = getMatch(id, packages);
+    if (pkgName) {
+        const pkg = packages[pkgName];
+        if (pkg === null) {
+            return;
+        }
+        if (id.length > pkgName.length && pkg[pkg.length - 1] !== '/') {
+            targetWarning(pkgName, pkg, "should have a trailing '/'");
+        }
+        else {
+            const isPackage = id.length > pkgName.length &&
+                pkg[pkg.length - 1] === '/' &&
+                pkg.lastIndexOf(pkgName) === pkg.length - pkgName.length;
+            if (isPackage) {
+                // Encode the specifier to create a well-formed LWR module URI
+                const uri = pkg.substring(0, pkg.lastIndexOf(pkgName)) + encodeURIComponent(id);
+                return { uri };
+            }
+            const uri = pkg + id.slice(pkgName.length);
+            return { uri };
+        }
+    }
+    else if (defaultUri) {
+        // When a specifier's URI cannot be resolved via the imports, fallback to "default".
+        //     -> https://rfcs.lwc.dev/rfcs/lwr/0000-import-metadata#json-schema
+        // However, if `id` is already a fully resolved url,
+        // we cannot prepend the defaultUri -> https://github.com/salesforce-experience-platform-emu/lwr/issues/378.
+        // In this case we do not apply any package mappings and allow the caller (resolveImportMapEntry) to handle it.
+        if (!isUrl(id)) {
+            const uri = defaultUri + encodeURIComponent(id);
+            return {
+                uri,
+                defaultUri: true,
+            };
+        }
+    }
+}
+// Resolves an entry in the import map
+function resolveImportMapEntry(importMap, resolvedOrPlain, parentUrl) {
+    if (!importMap.scopes) {
+        importMap.scopes = {};
+    }
+    if (!importMap.imports) {
+        importMap.imports = {};
+    }
+    const scopes = importMap.scopes;
+    let scopeUrl = parentUrl && getMatch(parentUrl, scopes);
+    while (scopeUrl) {
+        const packageResolution = applyPackages(resolvedOrPlain, scopes[scopeUrl]);
+        if (packageResolution) {
+            return packageResolution;
+        }
+        scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf('/')), scopes);
+    }
+    return (applyPackages(resolvedOrPlain, importMap.imports, importMap.default) ||
+        (isUrl(resolvedOrPlain) && { uri: resolvedOrPlain }) ||
+        undefined);
+}
+// In place transformation of the ImportMap object
+function resolveAndComposePackages(packages, outPackages, baseUrl, parentMap, parentUrl) {
+    for (const p in packages) {
+        const resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
+        const rhs = packages[p];
+        // package fallbacks not currently supported
+        if (typeof rhs !== 'string') {
+            continue;
+        }
+        const mapped = resolveImportMapEntry(parentMap, resolveIfNotPlainOrUrl(rhs, baseUrl) || rhs, parentUrl);
+        if (!mapped) {
+            targetWarning(p, rhs, 'bare specifier did not resolve');
+        }
+        else {
+            outPackages[resolvedLhs] = mapped.uri;
+        }
+    }
+}
+// Composes a single import map object given a child and parent import map
+function resolveAndComposeImportMap(json, baseUrl, parentMap = { imports: {}, scopes: {} }) {
+    const outMap = {
+        imports: Object.assign({}, parentMap.imports),
+        scopes: Object.assign({}, parentMap.scopes),
+        default: json.default,
+    };
+    if (json.imports) {
+        resolveAndComposePackages(json.imports, outMap.imports, baseUrl, parentMap);
+    }
+    if (json.scopes) {
+        for (const s in json.scopes) {
+            const resolvedScope = resolveUrl(s, baseUrl);
+            resolveAndComposePackages(json.scopes[s], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, parentMap, resolvedScope);
+        }
+    }
+    if (json.default) {
+        outMap.default = resolveIfNotPlainOrUrl(json.default, baseUrl);
+    }
+    return outMap;
+}
+export { resolveAndComposeImportMap, resolveImportMapEntry };
+//# sourceMappingURL=importMap.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { resolveImportMapEntry } from './importMap.js';
+/* spec based import map resolver */
+export class ImportMapResolver {
+    constructor(importMap) {
+        this.importMap = importMap;
+    }
+    resolve(resolvedOrPlain, parentUrl) {
+        return resolveImportMapEntry(this.importMap, resolvedOrPlain, parentUrl);
+    }
+}
+//# sourceMappingURL=importMapResolver.js.map