@lwrjs/loader 0.24.2 → 0.24.4

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

@@ -1,58 +1,57 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {get: all[name], enumerable: true});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/loader/src/modules/lwr/loader/hooks/resolveAndLoadHook.ts
-__markAsModule(exports);
-__export(exports, {
+var resolveAndLoadHook_exports = {};
+__export(resolveAndLoadHook_exports, {
   evaluateLoadHook: () => evaluateLoadHook,
   evaluateLoadHookResponse: () => evaluateLoadHookResponse,
   isCustomResponse: () => isCustomResponse,
   isFetchResponse: () => isFetchResponse,
   isResponseAPromise: () => isResponseAPromise
 });
-var import_messages = __toModule(require("../errors/messages.cjs"));
-var import_constants = __toModule(require("../constants/constants.cjs"));
-var import_dom = __toModule(require("../utils/dom.cjs"));
-var import_trusted_types = __toModule(require("@locker/trusted-types"));
+module.exports = __toCommonJS(resolveAndLoadHook_exports);
+var import_messages = require("../errors/messages.cjs");
+var import_constants = require("../constants/constants.cjs");
+var import_dom = require("../utils/dom.cjs");
+var import_trusted_types = require("@locker/trusted-types");
 var lastWindowError;
 if (import_dom.hasDocument) {
   globalThis.addEventListener("error", (evt) => {
     lastWindowError = evt.error;
   });
 }
-if (process.env.NODE_ENV !== "production") {
+function resetLastWindowError() {
+  lastWindowError = null;
+}
+if (true) {
   if (!import_dom.hasSetTimeout && import_dom.hasConsole) {
     console.warn("setTimeout API is not available, watchdog timer on load hook will not be set");
   }
 }
-function isCustomResponse(response) {
-  return Object.prototype.hasOwnProperty.call(response, "data") && !Object.prototype.hasOwnProperty.call(response, "blob");
+function isCustomResponse(response2) {
+  return Object.prototype.hasOwnProperty.call(response2, "data") && !Object.prototype.hasOwnProperty.call(response2, "blob");
 }
-function isFetchResponse(response) {
-  return typeof response.blob === "function";
+function isFetchResponse(response2) {
+  return typeof response2.blob === "function";
 }
-function isResponseAPromise(response) {
-  return !!(response && response.then);
+function isResponseAPromise(response2) {
+  return !!(response2 && response2.then);
 }
 async function evaluateLoadHookResponse(response, id) {
   return Promise.resolve().then(async () => {
@@ -76,34 +75,35 @@ async function evaluateLoadHookResponse(response, id) {
     }
     code = `${code}
 //# sourceURL=${id}`;
+    resetLastWindowError();
     try {
       eval(import_trusted_types.trusted.createScript(code));
     } catch (e) {
-      if (process.env.NODE_ENV !== "production" && import_dom.hasConsole) {
+      if (import_dom.hasConsole) {
         console.error(e);
       }
       throw new import_messages.LoaderError(import_messages.FAIL_LOAD, [`"${id}": ${e instanceof Error ? e.message : String(e)}`]);
     }
     if (lastWindowError) {
-      throw new import_messages.LoaderError(import_messages.FAIL_LOAD, [
-        `"${id}": window error ${lastWindowError instanceof Error ? lastWindowError.message : String(lastWindowError)}`
-      ]);
+      const message = lastWindowError instanceof Error ? lastWindowError.message : String(lastWindowError);
+      resetLastWindowError();
+      throw new import_messages.LoaderError(import_messages.FAIL_LOAD, [`"${id}": window error ${message}`]);
     }
     return true;
   });
 }
-async function evaluateLoadHook(id, hookPromise) {
+async function evaluateLoadHook(id2, hookPromise) {
   if (!import_dom.hasSetTimeout) {
     return hookPromise;
   }
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      reject(new import_messages.LoaderError(import_messages.MODULE_LOAD_TIMEOUT, [id]));
+      reject(new import_messages.LoaderError(import_messages.MODULE_LOAD_TIMEOUT, [id2]));
     }, import_constants.MODULE_LOAD_TIMEOUT_TIMER);
-    hookPromise.then((response) => {
-      resolve(response);
+    hookPromise.then((response2) => {
+      resolve(response2);
     }).catch(() => {
-      reject(new import_messages.LoaderError(import_messages.FAIL_HOOK_LOAD, [id]));
+      reject(new import_messages.LoaderError(import_messages.FAIL_HOOK_LOAD, [id2]));
     }).finally(() => {
       clearTimeout(timer);
     });

package/build/cjs/modules/lwr/loader/moduleRegistry/importMetadataResolver.cjs

@@ -1,39 +1,38 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {get: all[name], enumerable: true});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/loader/src/modules/lwr/loader/moduleRegistry/importMetadataResolver.ts
-__markAsModule(exports);
-__export(exports, {
+var importMetadataResolver_exports = {};
+__export(importMetadataResolver_exports, {
   ImportMetadataResolver: () => ImportMetadataResolver
 });
-var import_messages = __toModule(require("../errors/messages.cjs"));
-var import_url = __toModule(require("../utils/url.cjs"));
-var import_metrics = __toModule(require("lwr/metrics"));
+module.exports = __toCommonJS(importMetadataResolver_exports);
+var import_messages = require("../errors/messages.cjs");
+var import_url = require("../utils/url.cjs");
+var import_metrics = require("lwr/metrics");
 var ImportMetadataResolver = class {
+  // Default to empty mappings
+  importURICache = /* @__PURE__ */ new Map();
+  pendingURICache = /* @__PURE__ */ new Map();
+  config;
+  invalidationCallback;
+  loadMappingHooks = [];
   constructor(config, invalidationCallback) {
-    this.importURICache = new Map();
-    this.pendingURICache = new Map();
-    this.loadMappingHooks = [];
     this.config = config;
     this.invalidationCallback = invalidationCallback;
   }
@@ -92,9 +91,16 @@ var ImportMetadataResolver = class {
       });
     }
   }
+  /**
+   * Returns the raw URI stored for a specifier, or `undefined` if not yet mapped.
+   * Used by the runtime `importMap()` path to detect cross-call duplicates while
+   * allowing truly idempotent re-registrations (same specifier, same URI) to pass
+   * through silently.
+   */
   getMappingUri(specifier) {
     return this.importURICache.get(specifier)?.uri;
   }
+  // Get URL from the local cache or return undefiend
   getURI(specifier) {
     return this.importURICache && this.importURICache.has(specifier) ? (0, import_url.resolveUrl)(this.importURICache.get(specifier).uri, this.getBaseUrl()) : void 0;
   }
@@ -107,6 +113,16 @@ var ImportMetadataResolver = class {
     }
     return void 0;
   }
+  /**
+   *  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
+   */
   async resolve(specifier) {
     let uri = this.getURI(specifier);
     if (uri) {
@@ -118,7 +134,7 @@ var ImportMetadataResolver = class {
       if (pending) {
         return pending;
       }
-      this.config.profiler.logOperationStart({id: import_metrics.MAPPINGS_FETCH, specifier});
+      this.config.profiler.logOperationStart({ id: import_metrics.MAPPINGS_FETCH, specifier });
       const fetchMappingService = this.hasMappingHooks() ? this.evaluateMappingHooks : this.fetchNewMappings;
       const promise = fetchMappingService.bind(this)(specifier).then((importMetadata) => {
         if (!importMetadata || !importMetadata.imports) {
@@ -129,7 +145,7 @@ var ImportMetadataResolver = class {
         if (!uri) {
           throw new import_messages.LoaderError(import_messages.UNRESOLVED, [specifier]);
         }
-        this.config.profiler.logOperationEnd({id: import_metrics.MAPPINGS_FETCH, specifier});
+        this.config.profiler.logOperationEnd({ id: import_metrics.MAPPINGS_FETCH, specifier });
         return uri;
       }).finally(() => {
         this.pendingURICache.delete(specifier);
@@ -141,13 +157,18 @@ var ImportMetadataResolver = class {
   hasMappingHooks() {
     return this.loadMappingHooks.length > 0;
   }
+  /**
+   *  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
+   */
   async evaluateMappingHooks(specifier) {
     const loadMappingHooks = this.loadMappingHooks;
     if (loadMappingHooks.length) {
       const knownModules = Array.from(this.importURICache.keys());
       for (let i = 0; i < loadMappingHooks.length; i++) {
         const loadMappingHook = loadMappingHooks[i];
-        const response = await loadMappingHook(specifier, {knownModules});
+        const response = await loadMappingHook(specifier, { knownModules });
         if (response || response === void 0) {
           return response;
         }
@@ -165,7 +186,7 @@ var ImportMetadataResolver = class {
     }
     return globalThis.fetch(uri).then((res) => {
       if (!res.ok) {
-        this.config.profiler.logOperationStart({id: import_metrics.MAPPINGS_ERROR, specifier});
+        this.config.profiler.logOperationStart({ id: import_metrics.MAPPINGS_ERROR, specifier });
         throw new import_messages.LoaderError(import_messages.UNRESOLVED, [specifier]);
       }
       return res.json().then((ret) => {