@lwrjs/loader 0.12.0-alpha.9 → 0.13.0-alpha.0

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.12.0-alpha.9 */
+/* LWR Module Loader v0.13.0-alpha.0 */
 const templateRegex = /\{([0-9]+)\}/g;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function templateString(template, args) {
@@ -646,7 +646,7 @@ try {
   // swallow
 }
 const trusted = createPolicy('trusted', policyOptions);
-/*! version: 0.21.0 */
+/*! version: 0.21.4 */
 
 /* global console,process */
 
@@ -798,22 +798,13 @@ 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;
@@ -823,9 +814,6 @@ class ModuleRegistry {
         );
     }
 
-    /**
-     * Module import
-     */
     async load(id, importer) {
         const metadata = importer ? { importer } : {};
         this.profiler.logOperationStart({
@@ -833,23 +821,18 @@ class ModuleRegistry {
             specifier: id,
             metadata,
         });
-
         const resolvedId = await this.resolve(id, importer);
-        const moduleRecord = this.getModuleRecord(resolvedId, id);
-
+        const moduleRecord = await this.getModuleRecord(resolvedId, id);
         if (moduleRecord.evaluated) {
             return moduleRecord.module;
         } else {
             if (!moduleRecord.evaluationPromise) {
-                moduleRecord.evaluationPromise = this.evaluateModule(moduleRecord, {});
+                moduleRecord.evaluationPromise = this.topLevelEvaluation(moduleRecord);
             }
             return moduleRecord.evaluationPromise;
         }
     }
 
-    /**
-     * Resolve id for a module
-     */
     async resolve(id, importer) {
         const parentUrl = this.resolver.getBaseUrl(); // only support baseUrl for now
 
@@ -865,7 +848,7 @@ class ModuleRegistry {
                     // eslint-disable-next-line no-await-in-loop
                     result = isResponseAPromise(response) ? await response : response;
                 }
-                if (!isValidResolveResponse(result)) {
+                if (!this.isValidResolveResponse(result)) {
                     throw new LoaderError(INVALID_LOADER_SERVICE_RESPONSE);
                 }
 
@@ -951,9 +934,6 @@ 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.
@@ -1020,6 +1000,19 @@ 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;
     }
@@ -1045,7 +1038,7 @@ class ModuleRegistry {
         return moduleRecord;
     }
 
-     getModuleRecord(resolvedId, id) {
+     async getModuleRecord(resolvedId, id) {
         // Look for an existing record
         const existingRecord = this.getExistingModuleRecord(resolvedId, id);
         if (existingRecord) {
@@ -1053,10 +1046,29 @@ 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),
-            instantiation: this.getModuleDef(resolvedId, id),
+            dependencyRecords,
+            instantiation,
             evaluated: false,
             evaluationPromise: null,
         };
@@ -1064,7 +1076,8 @@ class ModuleRegistry {
         this.moduleRegistry.set(resolvedId, newModuleRecord);
         this.storeModuleAlias(id, resolvedId);
 
-        return newModuleRecord;
+        // Wait for the dependencies to resolve the return the moduleRecord
+        return dependencyRecords.then(() => newModuleRecord);
     }
 
      storeModuleAlias(aliasId, resolvedId) {
@@ -1085,87 +1098,95 @@ class ModuleRegistry {
         }
     }
 
-    /**
-     * 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));
-                }
-            }
-        }
-
-        return Promise.all(promiseArray).then((results) => {
-            const depsMapped = results.filter((result) => result !== undefined);
-            return { depsMapped, exports };
-        });
+     async getModuleDependencyRecord(dependency) {
+        const resolvedDepId = await this.resolve(dependency);
+        return this.getModuleRecord(resolvedDepId, dependency);
     }
 
-     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]);
-        };
+    // execute the "top-level code" (the code outside of functions) of a module
+     async topLevelEvaluation(moduleRecord) {
+        await this.instantiateAll(moduleRecord, {});
+        return this.evaluateModule(moduleRecord, {});
+    }
 
-        // 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);
+    // 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);
+                }
             }
-            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,
     ) {
-        // Create a evaluationMap to detect cycles in this dep chain
-        const chainMap = { ...evaluationMap };
-        chainMap[moduleRecord.id] = true;
+        const dependencyModuleRecords = await moduleRecord.dependencyRecords;
+        if (dependencyModuleRecords.length > 0) {
+            evaluationMap[moduleRecord.id] = true;
+            // evaluate dependencies first
+            await this.evaluateModuleDependencies(dependencyModuleRecords, evaluationMap);
+        }
 
-        // Wait for load to finish
         const { exporter, dependencies } = await moduleRecord.instantiation;
-
-        // Evaluate all it's dependents
-        const { depsMapped, exports } = await this.evaluateDependencies(dependencies, chainMap);
+        // 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;
+        }
 
         // evaluates the module function
-        let moduleDefault = this.evaluateModuleCode(exporter, depsMapped, moduleRecord);
+        let moduleDefault;
+        try {
+            moduleDefault = exporter(...depsMapped);
+        } catch (e) {
+            throw new LoaderError(EXPORTER_ERROR, [moduleRecord.id, e.message || e]);
+        }
         // value is returned from exporter, then we are not using named exports
         if (moduleDefault !== undefined) {
             moduleDefault = { default: moduleDefault };
@@ -1177,7 +1198,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 (isNamedExportDefaultOnly(exports)) {
+            if (this.isNamedExportDefaultOnly(exports)) {
                 Object.defineProperty(exports, '__useDefault', { value: true });
             }
         }
@@ -1209,17 +1230,42 @@ class ModuleRegistry {
             Object.defineProperty(moduleRecord.module, '__esModule', { value: true });
         }
 
-        Object.freeze(moduleRecord.module);
         moduleRecord.evaluated = true;
-        moduleRecord.evaluationPromise = null;
+        Object.freeze(moduleRecord.module);
         return moduleRecord.module;
     }
 
-     evaluateModuleCode(evaluatedExporter, depsMapped, moduleRecord) {
-        try {
-            return evaluatedExporter(...depsMapped);
-        } catch (e) {
-            throw new LoaderError(EXPORTER_ERROR, [moduleRecord.id, e.message || e]);
+    // 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);
+            }
         }
     }
 
@@ -1231,8 +1277,8 @@ class ModuleRegistry {
         const moduleName = !isUrl(resolvedId)
             ? resolvedId
             : originalId !== resolvedId
-            ? originalId
-            : undefined;
+              ? originalId
+              : undefined;
         let moduleDef = moduleName && this.namedDefineRegistry.get(moduleName);
         if (moduleDef && moduleDef.external) {
             return moduleDef.external.moduleDefPromise;
@@ -1299,6 +1345,9 @@ class ModuleRegistry {
             });
     }
 
+    
+    
+    
     addLoaderPlugin(hooks) {
         if (typeof hooks !== 'object') {
             throw new LoaderError(INVALID_HOOK);
@@ -1340,6 +1389,7 @@ class ModuleRegistry {
         }
     }
 
+    
     registerHandleStaleModuleHook(handleStaleModule) {
         if (this.handleStaleModuleHook) {
             this.handleStaleModuleHook.push(handleStaleModule);
@@ -1347,30 +1397,12 @@ class ModuleRegistry {
             this.handleStaleModuleHook = [handleStaleModule];
         }
     }
-}
 
-// 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');
+    isValidResolveResponse(res) {
+        return (
+            res === null || typeof res === 'string' || (res && typeof (res ).url === 'string')
+        );
+    }
 }
 
 /**