@lwrjs/module-registry 0.7.0-alpha.1 → 0.7.0-alpha.12

package/build/cjs/index.cjs

@@ -74,7 +74,7 @@ var LwrModuleRegistry = class {
     const {bundle, format} = runtimeEnvironment;
     if (bundle) {
       return new Promise((resolve, reject) => {
-        (0, import_signature.getBundleSignature)(moduleId, this).then((bundleSignature) => resolve((0, import_esm_strategy.default)(moduleId, runtimeEnvironment, runtimeParams, bundleSignature))).catch(reject);
+        (0, import_signature.getBundleSignature)(moduleId, this, this.globalConfig?.bundleConfig?.exclude).then((bundleSignature) => resolve((0, import_esm_strategy.default)(moduleId, runtimeEnvironment, runtimeParams, bundleSignature))).catch(reject);
       });
     } else {
       return new Promise((resolve, reject) => {
@@ -163,7 +163,12 @@ var LwrModuleRegistry = class {
     return moduleLinked;
   }
   async createLinkedModuleDefinition(moduleDef, runtimeEnvironment, runtimeParams) {
-    const {format, minify, debug} = runtimeEnvironment;
+    const {
+      format,
+      minify,
+      debug,
+      env: {NODE_ENV: envMode}
+    } = runtimeEnvironment;
     const minified = !!minify && !debug;
     const {amdLoader, esmLoader} = this.globalConfig;
     if (format === "amd") {
@@ -182,6 +187,11 @@ var LwrModuleRegistry = class {
       if (minified) {
         const {code: minifiedCode} = await this.context.compiler.minifyJavascript(amdSource);
         linkedAmdSource = minifiedCode;
+      } else {
+        const {code: minifiedCode} = await this.context.compiler.parseJavascript(amdSource, {
+          envMode
+        });
+        linkedAmdSource = minifiedCode;
       }
       linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== import_shared_utils.ModuleNameType.unresolved);
       return {
@@ -206,6 +216,11 @@ var LwrModuleRegistry = class {
       if (minified) {
         const {code: minifiedEsm} = await this.context.compiler.minifyJavascript(transformedEsmCode);
         transformedEsmCode = minifiedEsm;
+      } else {
+        const {code: parsedEsm} = await this.context.compiler.parseJavascript(transformedEsmCode, {
+          envMode
+        });
+        transformedEsmCode = parsedEsm;
       }
       linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== import_shared_utils.ModuleNameType.unresolved);
       return {

package/build/cjs/linker/linker.cjs

@@ -61,7 +61,7 @@ async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, run
       }
       let signature;
       if (runtimeEnvironment.bundle && runtimeEnvironment.format === "esm" && exclude?.includes(importRef.specifier)) {
-        signature = await (0, import_signature.getBundleSignature)(importRef, moduleRegistry);
+        signature = await (0, import_signature.getBundleSignature)(importRef, moduleRegistry, exclude);
       }
       const {locations, sourceSpecifier} = importRef;
       const link2 = strategy(importRef, runtimeEnvironment, runtimeParams, signature);
@@ -83,7 +83,7 @@ async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, run
       let signature;
       const isStringLiteral = importRef.moduleNameType === import_shared_utils2.ModuleNameType.string;
       if (isStringLiteral && runtimeEnvironment.bundle && runtimeEnvironment.format === "esm") {
-        signature = await (0, import_signature.getBundleSignature)(importRef, moduleRegistry);
+        signature = await (0, import_signature.getBundleSignature)(importRef, moduleRegistry, exclude);
       }
       const link2 = isStringLiteral ? versionStrategy(importRef, runtimeEnvironment, runtimeParams, signature) : importRef.specifier;
       const linkedLocations = locations.map(({location, importLocation}) => {
@@ -120,7 +120,7 @@ async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, run
     const {namespace, name} = (0, import_shared_utils2.explodeSpecifier)(specifier2);
     let signature;
     if (esmLoaderModule && runtimeEnvironment.bundle) {
-      signature = await (0, import_signature.getBundleSignature)({version: version2, specifier: specifier2}, moduleRegistry);
+      signature = await (0, import_signature.getBundleSignature)({version: version2, specifier: specifier2}, moduleRegistry, exclude);
     }
     const loaderLink = strategy({specifier: specifier2, version: version2}, runtimeEnvironment, runtimeParams, signature);
     codeStringBuilder.prepend(`import { load } from "${loaderLink}";

package/build/cjs/signature.cjs

@@ -34,32 +34,29 @@ var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var LWC_VERSION = getLWCVersion();
 var ENABLED_FINGERPRINTS = !(0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER;
 var ENV_KEY = `LWC:${LWC_VERSION},FINGERPRINTS:${ENABLED_FINGERPRINTS}`;
-async function getRecursiveModuleHash(definitions, registry, hash, visitedDefinitions = new Set()) {
-  if (!definitions.length) {
+async function getRecursiveModuleHash(modules, registry, hash, visitedDefinitions = new Set()) {
+  if (!modules.length) {
     return;
   }
-  const imports = [];
+  const definitions = await Promise.all(modules.map((module2) => registry.getModule(module2)));
+  const imports = new Map();
   for (const definition of definitions) {
-    if (visitedDefinitions.has(definition.id)) {
-      continue;
-    }
     const {ownHash, moduleRecord} = definition;
     hash.update(ownHash);
-    if (moduleRecord.imports) {
-      imports.push(...moduleRecord.imports);
-    }
-    visitedDefinitions.add(definition.id);
+    visitedDefinitions.add((0, import_shared_utils.getSpecifier)(definition));
+    moduleRecord.imports?.forEach((importReference) => {
+      imports.set((0, import_shared_utils.getSpecifier)(importReference), importReference);
+    });
   }
-  if (imports.length) {
-    const dependencies = await Promise.all(imports.map(async (dependency) => registry.getModule(dependency)));
+  const dependencies = Array.from(imports, ([_, dependency]) => dependency).filter((dependency) => !visitedDefinitions.has(dependency.specifier) && !visitedDefinitions.has((0, import_shared_utils.getSpecifier)(dependency)));
+  if (dependencies.length) {
     return getRecursiveModuleHash(dependencies, registry, hash, visitedDefinitions);
   }
 }
-async function getBundleSignature(moduleId, registry) {
-  const root = await registry.getModule(moduleId);
+async function getBundleSignature(moduleId, registry, exclude) {
   const hash = import_crypto.default.createHash("sha1");
   hash.update(ENV_KEY);
-  await getRecursiveModuleHash([root], registry, hash);
+  await getRecursiveModuleHash([moduleId], registry, hash, new Set(exclude));
   return hash.digest("hex");
 }
 function getLWCVersion() {

package/build/es/index.js

@@ -49,7 +49,7 @@ export class LwrModuleRegistry {
         const { bundle, format } = runtimeEnvironment;
         if (bundle) {
             return new Promise((resolve, reject) => {
-                getBundleSignature(moduleId, this)
+                getBundleSignature(moduleId, this, this.globalConfig?.bundleConfig?.exclude)
                     .then((bundleSignature) => resolve(esmLinkingStrategy(moduleId, runtimeEnvironment, runtimeParams, bundleSignature)))
                     .catch(reject);
             });
@@ -152,7 +152,7 @@ export class LwrModuleRegistry {
         return moduleLinked;
     }
     async createLinkedModuleDefinition(moduleDef, runtimeEnvironment, runtimeParams) {
-        const { format, minify, debug } = runtimeEnvironment;
+        const { format, minify, debug, env: { NODE_ENV: envMode }, } = runtimeEnvironment;
         const minified = !!minify && !debug;
         const { amdLoader, esmLoader } = this.globalConfig;
         // TODO: compat transformation based on runtimeEnvironment.compat
@@ -172,6 +172,12 @@ export class LwrModuleRegistry {
                 const { code: minifiedCode } = await this.context.compiler.minifyJavascript(amdSource);
                 linkedAmdSource = minifiedCode;
             }
+            else {
+                const { code: minifiedCode } = await this.context.compiler.parseJavascript(amdSource, {
+                    envMode,
+                });
+                linkedAmdSource = minifiedCode;
+            }
             // Filter out variable dynamic imports
             linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== ModuleNameType.unresolved);
             return {
@@ -201,6 +207,12 @@ export class LwrModuleRegistry {
                 const { code: minifiedEsm } = await this.context.compiler.minifyJavascript(transformedEsmCode);
                 transformedEsmCode = minifiedEsm;
             }
+            else {
+                const { code: parsedEsm } = await this.context.compiler.parseJavascript(transformedEsmCode, {
+                    envMode,
+                });
+                transformedEsmCode = parsedEsm;
+            }
             // Filter out variable dynamic imports
             linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== ModuleNameType.unresolved);
             return {

package/build/es/linker/linker.js

@@ -44,7 +44,7 @@ export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrate
             if (runtimeEnvironment.bundle &&
                 runtimeEnvironment.format === 'esm' &&
                 exclude?.includes(importRef.specifier)) {
-                signature = await getBundleSignature(importRef, moduleRegistry);
+                signature = await getBundleSignature(importRef, moduleRegistry, exclude);
             }
             const { locations, sourceSpecifier } = importRef;
             const link = strategy(importRef, runtimeEnvironment, runtimeParams, signature);
@@ -69,7 +69,7 @@ export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrate
             const isStringLiteral = importRef.moduleNameType === ModuleNameType.string;
             // get signature for dynamic imports when bundling esm
             if (isStringLiteral && runtimeEnvironment.bundle && runtimeEnvironment.format === 'esm') {
-                signature = await getBundleSignature(importRef, moduleRegistry);
+                signature = await getBundleSignature(importRef, moduleRegistry, exclude);
             }
             // always link [literal] dynamic imports as versioned specifiers (AMD strategy)
             // linking them as URIs (ESM strategy) causes caching issues since they can contain stale signatures
@@ -119,7 +119,7 @@ export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrate
         let signature;
         if (esmLoaderModule && runtimeEnvironment.bundle) {
             // Ensure the ESM loader is signed, or there may be a clash between this import and an existing one
-            signature = await getBundleSignature({ version, specifier }, moduleRegistry);
+            signature = await getBundleSignature({ version, specifier }, moduleRegistry, exclude);
         }
         const loaderLink = strategy({ specifier, version }, runtimeEnvironment, runtimeParams, signature);
         // import {load} from 'loader/loader'

package/build/es/signature.d.ts

@@ -1,3 +1,16 @@
 import { ModuleRegistry, ModuleId } from '@lwrjs/types';
-export declare function getBundleSignature(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, registry: ModuleRegistry): Promise<string>;
+/**
+ * Generate a bundle signature
+ *
+ * Traverses the module graph from the specified root module to generate a
+ *  signature. Modules that are marked for exclusion will be skipped. The
+ *  bundle signature will be generated based on the environment
+ *  keys(i.e. LWC version) and the ownHash of each module in the graph.
+ *
+ * @param moduleId - root module id
+ * @param registry - module registry
+ * @param exclude - bundle config exclusions
+ * @returns a bungle signature
+ */
+export declare function getBundleSignature(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, registry: ModuleRegistry, exclude?: string[]): Promise<string>;
 //# sourceMappingURL=signature.d.ts.map

package/build/es/signature.js

@@ -2,36 +2,58 @@ import crypto from 'crypto';
 import path from 'path';
 import { cwd } from 'process';
 import { createRequire } from 'module';
-import { getFeatureFlags } from '@lwrjs/shared-utils';
+import { getFeatureFlags, getSpecifier } from '@lwrjs/shared-utils';
 const LWC_VERSION = getLWCVersion();
 const ENABLED_FINGERPRINTS = !getFeatureFlags().LEGACY_LOADER;
 const ENV_KEY = `LWC:${LWC_VERSION},FINGERPRINTS:${ENABLED_FINGERPRINTS}`;
-async function getRecursiveModuleHash(definitions, registry, hash, visitedDefinitions = new Set()) {
-    if (!definitions.length) {
+async function getRecursiveModuleHash(modules, registry, hash, visitedDefinitions = new Set()) {
+    if (!modules.length) {
         return;
     }
-    const imports = [];
+    const definitions = await Promise.all(modules.map((module) => registry.getModule(module)));
+    const imports = new Map();
     for (const definition of definitions) {
-        if (visitedDefinitions.has(definition.id)) {
-            continue;
-        }
         const { ownHash, moduleRecord } = definition;
+        // include module in the bundle signature
         hash.update(ownHash);
-        if (moduleRecord.imports) {
-            imports.push(...moduleRecord.imports);
-        }
-        visitedDefinitions.add(definition.id);
+        // track the module to ensure it is only processed once
+        visitedDefinitions.add(getSpecifier(definition));
+        // map imports to prevent processing duplicates
+        moduleRecord.imports?.forEach((importReference) => {
+            imports.set(getSpecifier(importReference), importReference);
+        });
     }
-    if (imports.length) {
-        const dependencies = await Promise.all(imports.map(async (dependency) => registry.getModule(dependency)));
+    // filter out bundle config exclusions and already visited dependencies
+    const dependencies = Array.from(imports, ([_, dependency]) => dependency).filter((dependency) => 
+    // exclusions are not versioned
+    !visitedDefinitions.has(dependency.specifier) &&
+        // already visited dependencies will be versioned
+        !visitedDefinitions.has(getSpecifier(dependency)));
+    if (dependencies.length) {
         return getRecursiveModuleHash(dependencies, registry, hash, visitedDefinitions);
     }
 }
-export async function getBundleSignature(moduleId, registry) {
-    const root = await registry.getModule(moduleId);
+/**
+ * Generate a bundle signature
+ *
+ * Traverses the module graph from the specified root module to generate a
+ *  signature. Modules that are marked for exclusion will be skipped. The
+ *  bundle signature will be generated based on the environment
+ *  keys(i.e. LWC version) and the ownHash of each module in the graph.
+ *
+ * @param moduleId - root module id
+ * @param registry - module registry
+ * @param exclude - bundle config exclusions
+ * @returns a bungle signature
+ */
+export async function getBundleSignature(moduleId, registry, exclude) {
     const hash = crypto.createHash('sha1');
     hash.update(ENV_KEY);
-    await getRecursiveModuleHash([root], registry, hash);
+    // add bundle config exclusions to visited definitions to prevent including
+    //  them in the bundle signature
+    // Note: if the root module is an excluded module, it will be included in
+    //  the signature
+    await getRecursiveModuleHash([moduleId], registry, hash, new Set(exclude));
     return hash.digest('hex');
 }
 /**

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.7.0-alpha.1",
+    "version": "0.7.0-alpha.12",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -30,18 +30,18 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.7.0-alpha.1",
-        "@lwrjs/shared-utils": "0.7.0-alpha.1",
+        "@lwrjs/diagnostics": "0.7.0-alpha.12",
+        "@lwrjs/shared-utils": "0.7.0-alpha.12",
         "es-module-lexer": "^0.3.18",
         "ws": "^7.2.5"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.7.0-alpha.1",
+        "@lwrjs/types": "0.7.0-alpha.12",
         "@types/es-module-lexer": "^0.3.0",
         "@types/ws": "^7.2.4"
     },
     "engines": {
         "node": ">=14.15.4 <17"
     },
-    "gitHead": "24245670d6908d37e465f2316f92385df63d22aa"
+    "gitHead": "785b8380a821b43b7320783dddaf20d1433216e2"
 }