@lwrjs/everywhere 0.12.0-alpha.7 → 0.12.0-alpha.8

package/build/assets/amd/lwr-everywhere.js

@@ -20,7 +20,7 @@ function getConfiguration(options) {
         : `${ORIGIN}${PREFIX}/module/${format}/${POSTFIX}/mi/`;
 
     // Component specifiers and URIs
-    const BOOT_MODULE = `lwr/everywhere${format === 'esm' ? 'Esm' : 'Amd'}/v/0_12_0-alpha_7`;
+    const BOOT_MODULE = `lwr/everywhere${format === 'esm' ? 'Esm' : 'Amd'}/v/0_12_0-alpha_8`;
     const BOOT_URI = `${ENDPOINT}${encodeURIComponent(BOOT_MODULE)}/latest${debug ? '?debug' : ''}`;
 
     // Client Bootstrap Config
@@ -52,7 +52,7 @@ function getConfiguration(options) {
 * 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.12.0-alpha.7 */
+/* LWR Module Loader v0.12.0-alpha.8 */
 const templateRegex = /\{([0-9]+)\}/g;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function templateString(template, args) {
@@ -846,13 +846,22 @@ async function evaluateLoadHook(
 
 
 
-
-
 
 
 
 class ModuleRegistry {
     
+    
+    // A registry for named AMD defines containing the *metadata* of AMD module
+     __init() {this.namedDefineRegistry = new Map();}
+    // The evaluated module registry where the module identifier (name or URL?) is the key
+     __init2() {this.moduleRegistry = new Map();}
+    // Aliases of modules in the registry
+    __init3() {this.aliases = new Map();}
+    
+    
+    
+    
 
     constructor(config) {ModuleRegistry.prototype.__init.call(this);ModuleRegistry.prototype.__init2.call(this);ModuleRegistry.prototype.__init3.call(this);
         this.profiler = config.profiler;
@@ -862,6 +871,9 @@ class ModuleRegistry {
         );
     }
 
+    /**
+     * Module import
+     */
     async load(id, importer) {
         const metadata = importer ? { importer } : {};
         this.profiler.logOperationStart({
@@ -869,18 +881,23 @@ class ModuleRegistry {
             specifier: id,
             metadata,
         });
+
         const resolvedId = await this.resolve(id, importer);
-        const moduleRecord = await this.getModuleRecord(resolvedId, id);
+        const moduleRecord = this.getModuleRecord(resolvedId, id);
+
         if (moduleRecord.evaluated) {
             return moduleRecord.module;
         } else {
             if (!moduleRecord.evaluationPromise) {
-                moduleRecord.evaluationPromise = this.topLevelEvaluation(moduleRecord);
+                moduleRecord.evaluationPromise = this.evaluateModule(moduleRecord, {});
             }
             return moduleRecord.evaluationPromise;
         }
     }
 
+    /**
+     * Resolve id for a module
+     */
     async resolve(id, importer) {
         const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
 
@@ -896,7 +913,7 @@ class ModuleRegistry {
                     // eslint-disable-next-line no-await-in-loop
                     result = isResponseAPromise(response) ? await response : response;
                 }
-                if (!this.isValidResolveResponse(result)) {
+                if (!isValidResolveResponse(result)) {
                     throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
                 }
 
@@ -982,6 +999,9 @@ class ModuleRegistry {
         return this.moduleRegistry.has(id);
     }
 
+    /**
+     * Module entry point LWR.define()
+     */
     define(name, dependencies, exporter) {
         const mod = this.namedDefineRegistry.get(name);
         // Don't allow redefining a module.
@@ -1048,19 +1068,6 @@ class ModuleRegistry {
         });
     }
 
-    
-
-    // A registry for named AMD defines containing the *metadata* of AMD module
-     __init() {this.namedDefineRegistry = new Map();}
-
-    // The evaluated module registry where the module identifier (name or URL?) is the key
-     __init2() {this.moduleRegistry = new Map();}
-
-    // Aliases of modules in the registry
-    __init3() {this.aliases = new Map();}
-
-    
-
     getImportMetadataResolver() {
         return this.resolver;
     }
@@ -1086,7 +1093,7 @@ class ModuleRegistry {
         return moduleRecord;
     }
 
-     async getModuleRecord(resolvedId, id) {
+     getModuleRecord(resolvedId, id) {
         // Look for an existing record
         const existingRecord = this.getExistingModuleRecord(resolvedId, id);
         if (existingRecord) {
@@ -1094,29 +1101,10 @@ class ModuleRegistry {
             return existingRecord;
         }
 
-        // Create a new Module Record
-        const instantiation = this.getModuleDef(resolvedId, id);
-        const dependencyRecords = instantiation.then((moduleDef) => {
-            const dependencies = moduleDef.dependencies || [];
-            // get dep and filter out exports
-            const filtered = dependencies
-                .map((dep) => {
-                    if (dep === 'exports') {
-                        return;
-                    }
-                    invariant(dep !== 'require', NO_AMD_REQUIRE);
-                    return this.getModuleDependencyRecord.call(this, dep);
-                })
-                .filter((depRecord) => depRecord !== undefined) ;
-
-            return Promise.all(filtered);
-        });
-
         const newModuleRecord = {
             id: resolvedId,
             module: Object.create(null),
-            dependencyRecords,
-            instantiation,
+            instantiation: this.getModuleDef(resolvedId, id),
             evaluated: false,
             evaluationPromise: null,
         };
@@ -1124,8 +1112,7 @@ class ModuleRegistry {
         this.moduleRegistry.set(resolvedId, newModuleRecord);
         this.storeModuleAlias(id, resolvedId);
 
-        // Wait for the dependencies to resolve the return the moduleRecord
-        return dependencyRecords.then(() => newModuleRecord);
+        return newModuleRecord;
     }
 
      storeModuleAlias(aliasId, resolvedId) {
@@ -1146,95 +1133,87 @@ class ModuleRegistry {
         }
     }
 
-     async getModuleDependencyRecord(dependency) {
-        const resolvedDepId = await this.resolve(dependency);
-        return this.getModuleRecord(resolvedDepId, dependency);
-    }
+    /**
+     * Evaluate all module dependencies
+     */
+     async evaluateDependencies(
+        dependencies,
+        evaluationMap,
+    ) {
+        const exports = {};
+        const promiseArray = [];
+
+        if (dependencies) {
+            for (const dep of dependencies) {
+                if (dep === 'exports') {
+                    promiseArray.push(Promise.resolve(exports));
+                } else {
+                    invariant(dep !== 'require', NO_AMD_REQUIRE);
+                    promiseArray.push(this.evaluateDependent(dep, evaluationMap));
+                }
+            }
+        }
 
-    // execute the "top-level code" (the code outside of functions) of a module
-     async topLevelEvaluation(moduleRecord) {
-        await this.instantiateAll(moduleRecord, {});
-        return this.evaluateModule(moduleRecord, {});
+        return Promise.all(promiseArray).then((results) => {
+            const depsMapped = results.filter((result) => result !== undefined);
+            return { depsMapped, exports };
+        });
     }
 
-    // Returns a promise when a module and all of it's dependencies have finished instantiation
-     async instantiateAll(
-        moduleRecord,
-        instantiatedMap,
-    ) {
-        if (!instantiatedMap[moduleRecord.id]) {
-            instantiatedMap[moduleRecord.id] = true;
-            const dependencyModuleRecords = await moduleRecord.dependencyRecords;
-            if (dependencyModuleRecords) {
-                for (let i = 0; i < dependencyModuleRecords.length; i++) {
-                    const depRecord = dependencyModuleRecords[i];
-                    // eslint-disable-next-line no-await-in-loop
-                    await this.instantiateAll(depRecord, instantiatedMap);
-                }
+     async evaluateDependent(dep, evaluationMap) {
+        const resolvedDepId = await this.resolve(dep);
+
+        const depModuleRecord = this.getModuleRecord(resolvedDepId, dep);
+        let module = depModuleRecord.module;
+
+        const handleReturn = (module) => {
+            if (module) {
+                return module.__defaultInterop ? module.default : module;
             }
+            throw new LoaderError(FAILED_DEP, [resolvedDepId]);
+        };
+
+        // If evaluated return the module
+        if (depModuleRecord.evaluated) {
+            return handleReturn(module);
+        }
+        /**
+         * Circular dependencies are handled properly when named exports are used,
+         * however, for default exports there is a bug: https://github.com/rollup/rollup/issues/3384
+         *
+         * The workaround below applies for circular dependencies (!moduleRecord.evaluated)
+         */
+        if (!evaluationMap[depModuleRecord.id]) {
+            // If we have not started dependency evaluation kick it off
+            if (!depModuleRecord.evaluationPromise) {
+                depModuleRecord.evaluationPromise = this.evaluateModule(depModuleRecord, evaluationMap);
+            }
+            return depModuleRecord.evaluationPromise.then((module) => {
+                return handleReturn(module);
+            });
+        } else {
+            // Otherwise return a dummy circular module wrapper
+            module = getCircularDependencyWrapper(module);
         }
+        return handleReturn(module);
     }
 
      async evaluateModule(
         moduleRecord,
         evaluationMap,
     ) {
-        const dependencyModuleRecords = await moduleRecord.dependencyRecords;
-        if (dependencyModuleRecords.length > 0) {
-            evaluationMap[moduleRecord.id] = true;
-            // evaluate dependencies first
-            await this.evaluateModuleDependencies(dependencyModuleRecords, evaluationMap);
-        }
+        // Create a evaluationMap to detect cycles in this dep chain
+        const chainMap = { ...evaluationMap };
+        chainMap[moduleRecord.id] = true;
 
+        // Wait for load to finish
         const { exporter, dependencies } = await moduleRecord.instantiation;
-        // The exports object automatically gets filled in by the exporter evaluation
-        const exports = {};
-        const depsMapped = dependencies
-            ? await Promise.all(
-                  dependencies.map(async (dep) => {
-                      if (dep === 'exports') {
-                          return exports;
-                      }
-                      const resolvedDepId = await this.resolve(dep);
-
-                      const moduleRecord = this.moduleRegistry.get(resolvedDepId) ;
-                      if (!moduleRecord) {
-                          throw new LoaderError(FAILED_DEP, [resolvedDepId]);
-                      }
-
-                      const module = moduleRecord.module;
-
-                      /**
-                       * Circular dependencies are handled properly when named exports are used,
-                       * however, for default exports there is a bug: https://github.com/rollup/rollup/issues/3384
-                       *
-                       * The workaround below applies for circular dependencies (!moduleRecord.evaluated)
-                       */
-                      if (!moduleRecord.evaluated) {
-                          return this.getCircularDependencyWrapper(module);
-                      }
-
-                      if (module) {
-                          return module.__defaultInterop ? module.default : module;
-                      }
-
-                      throw new LoaderError(FAILED_DEP, [resolvedDepId]);
-                  }),
-              )
-            : [];
-
-        // W-10029836 - In the case where we could be instantiating multiple graphs at the same time lets make sure the module have not already been evaluated
-        if (moduleRecord.evaluated) {
-            return moduleRecord.module;
-        }
+
+        // Evaluate all it's dependents
+        const { depsMapped, exports } = await this.evaluateDependencies(dependencies, chainMap);
 
         // evaluates the module function
-        let moduleDefault;
-        try {
-            moduleDefault = exporter(...depsMapped);
-        } catch (e) {
-            throw new LoaderError(EXPORTER_ERROR, [moduleRecord.id, e.message || e]);
-        }
+        let moduleDefault = this.evaluateModuleCode(exporter, depsMapped, moduleRecord);
         // value is returned from exporter, then we are not using named exports
         if (moduleDefault !== undefined) {
             moduleDefault = { default: moduleDefault };
@@ -1246,7 +1225,7 @@ class ModuleRegistry {
         // if no return value, then we are using the exports object
         else {
             // handle only default export with Rollup forced named exports
-            if (this.isNamedExportDefaultOnly(exports)) {
+            if (isNamedExportDefaultOnly(exports)) {
                 Object.defineProperty(exports, '__useDefault', { value: true });
             }
         }
@@ -1278,42 +1257,17 @@ class ModuleRegistry {
             Object.defineProperty(moduleRecord.module, '__esModule', { value: true });
         }
 
-        moduleRecord.evaluated = true;
         Object.freeze(moduleRecord.module);
+        moduleRecord.evaluated = true;
+        moduleRecord.evaluationPromise = null;
         return moduleRecord.module;
     }
 
-    // Determines if named exports module has only default export
-     isNamedExportDefaultOnly(exports) {
-        return (
-            exports !== undefined &&
-            Object.getOwnPropertyNames(exports).length === 2 &&
-            Object.prototype.hasOwnProperty.call(exports, 'default') &&
-            Object.prototype.hasOwnProperty.call(exports, '__esModule')
-        );
-    }
-
-    // Wrap the dependency in a function that can be called and detected by __circular__ property.
-    // The LWC engine checks for __circular__ to detect circular dependencies.
-     getCircularDependencyWrapper(module) {
-        const tmp = () => {
-            return module.__useDefault || module.__defaultInterop ? module.default : module;
-        };
-        tmp.__circular__ = true;
-        return tmp;
-    }
-
-     async evaluateModuleDependencies(
-        dependencyModuleRecords,
-        evaluationMap,
-    ) {
-        for (let i = 0; i < dependencyModuleRecords.length; i++) {
-            const depRecord = dependencyModuleRecords[i];
-            if (!depRecord.evaluated && !evaluationMap[depRecord.id]) {
-                evaluationMap[depRecord.id] = true;
-                // eslint-disable-next-line no-await-in-loop
-                await this.evaluateModule(depRecord, evaluationMap);
-            }
+     evaluateModuleCode(evaluatedExporter, depsMapped, moduleRecord) {
+        try {
+            return evaluatedExporter(...depsMapped);
+        } catch (e) {
+            throw new LoaderError(EXPORTER_ERROR, [moduleRecord.id, e.message || e]);
         }
     }
 
@@ -1393,9 +1347,6 @@ class ModuleRegistry {
             });
     }
 
-    
-    
-    
     addLoaderPlugin(hooks) {
         if (typeof hooks !== 'object') {
             throw new LoaderError(INVALID_HOOK);
@@ -1437,7 +1388,6 @@ class ModuleRegistry {
         }
     }
 
-    
     registerHandleStaleModuleHook(handleStaleModule) {
         if (this.handleStaleModuleHook) {
             this.handleStaleModuleHook.push(handleStaleModule);
@@ -1445,12 +1395,30 @@ class ModuleRegistry {
             this.handleStaleModuleHook = [handleStaleModule];
         }
     }
+}
 
-    isValidResolveResponse(res) {
-        return (
-            res === null || typeof res === 'string' || (res && typeof (res ).url === 'string')
-        );
-    }
+// Determines if named exports module has only default export
+function isNamedExportDefaultOnly(exports) {
+    return (
+        exports !== undefined &&
+        Object.getOwnPropertyNames(exports).length === 2 &&
+        Object.prototype.hasOwnProperty.call(exports, 'default') &&
+        Object.prototype.hasOwnProperty.call(exports, '__esModule')
+    );
+}
+
+// Wrap the dependency in a function that can be called and detected by __circular__ property.
+// The LWC engine checks for __circular__ to detect circular dependencies.
+function getCircularDependencyWrapper(module) {
+    const tmp = () => {
+        return module.__useDefault || module.__defaultInterop ? module.default : module;
+    };
+    tmp.__circular__ = true;
+    return tmp;
+}
+
+function isValidResolveResponse(res) {
+    return res === null || typeof res === 'string' || (res && typeof (res ).url === 'string');
 }
 
 /**
@@ -1598,7 +1566,7 @@ const { bootstrapModule, endpoints, baseUrl, imports, index } = configuration;
 
 // Initialize the AMD loader (its code is bundled into the LWR Everywhere module)
 const loader = new Loader({ endpoints, baseUrl });
-loader.define('lwr/loader/v/0_12_0-alpha_7', ['exports'], (exports) => {
+loader.define('lwr/loader/v/0_12_0-alpha_8', ['exports'], (exports) => {
     Object.assign(exports, {
         define: loader.define.bind(loader),
         load: loader.load.bind(loader),
@@ -1608,12 +1576,12 @@ await loader.registerImportMappings({ imports, index }, [bootstrapModule]);
 (globalThis ).LWR = Object.freeze({ define: loader.define.bind(loader) });
 
 // Define preload modules (ie: ABS, vault, etc) BEFORE loading them
-LWR.define('lwr/everywhereAmd/v/0_12_0-alpha_7', ['exports', 'lwr/vault/v/0_12_0-alpha_7'], (function (exports, _0_12_0Alpha_7) {
+LWR.define('lwr/everywhereAmd/v/0_12_0-alpha_8', ['exports', 'lwr/vault/v/0_12_0-alpha_8'], (function (exports, _0_12_0Alpha_8) {
   // IMPORTANT: Do not add any static imports to this file that are not bundled with the amd-client
 
   // Do an OAuthed fetch
   async function authFetch(url, accept = 'javascript') {
-    const authInfo = _0_12_0Alpha_7.getAuthInfo();
+    const authInfo = _0_12_0Alpha_8.getAuthInfo();
     if (authInfo) {
       return fetch(url, {
         headers: {
@@ -1662,7 +1630,7 @@ LWR.define('lwr/everywhereAmd/v/0_12_0-alpha_7', ['exports', 'lwr/vault/v/0_12_0
   function authenticate(authInfo) {
     // Put OAuth info into the vault
     if (authInfo) {
-      _0_12_0Alpha_7.setAuthInfo(authInfo);
+      _0_12_0Alpha_8.setAuthInfo(authInfo);
     }
   }
 
@@ -1672,7 +1640,7 @@ LWR.define('lwr/everywhereAmd/v/0_12_0-alpha_7', ['exports', 'lwr/vault/v/0_12_0
   Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-LWR.define('lwr/vault/v/0_12_0-alpha_7', ['exports'], (function (exports) {
+LWR.define('lwr/vault/v/0_12_0-alpha_8', ['exports'], (function (exports) {
   // Credential vault for storing setters and subscribers for OAuth info
   // This module is a SINGLETON and must be excluded from ESM bundling
 
@@ -1696,7 +1664,7 @@ LWR.define('lwr/vault/v/0_12_0-alpha_7', ['exports'], (function (exports) {
 
 // Set up the AMD loader hooks for OAuth
 const { initAmd, authenticate } = await loader.load(bootstrapModule);
-initAmd(loader.services, _optionalChain([endpoints, 'optionalAccess', _ => _.uris, 'access', _2 => _2.mapping]), '0_12_0-alpha_7');
+initAmd(loader.services, _optionalChain([endpoints, 'optionalAccess', _ => _.uris, 'access', _2 => _2.mapping]), '0_12_0-alpha_8');
 
 // Wrap the createComponent API to allow proper ordering of module definitions:
 //  1. LWRE module bundle (this): lwr/loader, lwr/everywhereAmd, lwr/vault