@lwrjs/module-registry 0.9.0-alpha.0 → 0.9.0-alpha.10

package/build/cjs/signature.cjs

@@ -27,51 +27,43 @@ __export(exports, {
   getBundleSignature: () => getBundleSignature
 });
 var import_crypto = __toModule(require("crypto"));
-var import_path = __toModule(require("path"));
-var import_process = __toModule(require("process"));
-var import_module = __toModule(require("module"));
+var import_resolve = __toModule(require("resolve"));
 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(modules, registry, hash, visitedDefinitions = new Set()) {
+async function getRecursiveModuleHash(modules, registry, hash, visitedDefinitions = new Set(), excludes = new Set()) {
   if (!modules.length) {
     return;
   }
   const definitions = await Promise.all(modules.map((module2) => registry.getModule(module2)));
   const imports = new Map();
   for (const definition of definitions) {
-    const {ownHash, moduleRecord} = definition;
-    hash.update(ownHash);
-    visitedDefinitions.add((0, import_shared_utils.getSpecifier)(definition));
-    moduleRecord.imports?.forEach((importReference) => {
-      imports.set((0, import_shared_utils.getSpecifier)(importReference), importReference);
-    });
+    const {specifier, version, ownHash, moduleRecord} = definition;
+    if (excludes.has(specifier)) {
+      hash.update(`${specifier}@${version}@${ownHash}`);
+      visitedDefinitions.add(specifier);
+    } else {
+      hash.update(ownHash);
+      visitedDefinitions.add((0, import_shared_utils.getSpecifier)(definition));
+      moduleRecord.imports?.forEach((importReference) => {
+        imports.set((0, import_shared_utils.getSpecifier)(importReference), importReference);
+      });
+    }
   }
   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);
+    return getRecursiveModuleHash(dependencies, registry, hash, visitedDefinitions, excludes);
   }
 }
-async function getBundleSignature(moduleId, registry, exclude) {
+async function getBundleSignature(moduleId, registry, excludes) {
   const hash = import_crypto.default.createHash("sha1");
   hash.update(ENV_KEY);
-  await getRecursiveModuleHash([moduleId], registry, hash, new Set(exclude));
+  await getRecursiveModuleHash([moduleId], registry, hash, new Set(), new Set(excludes));
   return hash.digest("hex");
 }
 function getLWCVersion() {
-  let lwcVersion;
-  try {
-    if (LWR?.LWC_VERSION) {
-      lwcVersion = LWR.LWC_VERSION;
-    }
-  } catch (err) {
-  }
-  if (!lwcVersion) {
-    const require2 = (0, import_module.createRequire)(import_path.default.join((0, import_process.cwd)(), "./env-config.js"));
-    const {version} = require2("lwc/package.json");
-    lwcVersion = version;
-  }
-  import_shared_utils.logger.debug(`Signature LWC Version: ${lwcVersion}`);
-  return lwcVersion;
+  const packageJsonPath = import_resolve.default.sync(`lwc/package.json`);
+  const {version} = JSON.parse((0, import_shared_utils.readFile)(packageJsonPath));
+  return version;
 }

package/build/es/signature.d.ts

@@ -1,4 +1,4 @@
-import { ModuleRegistry, ModuleId } from '@lwrjs/types';
+import type { ModuleRegistry, ModuleId } from '@lwrjs/types';
 /**
  * Generate a bundle signature
  *
@@ -12,5 +12,5 @@ import { ModuleRegistry, ModuleId } from '@lwrjs/types';
  * @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>;
+export declare function getBundleSignature(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, registry: ModuleRegistry, excludes?: string[]): Promise<string>;
 //# sourceMappingURL=signature.d.ts.map

package/build/es/signature.js

@@ -1,27 +1,35 @@
 import crypto from 'crypto';
-import path from 'path';
-import { cwd } from 'process';
-import { createRequire } from 'module';
-import { getFeatureFlags, getSpecifier, logger } from '@lwrjs/shared-utils';
+import resolve from 'resolve';
+import { getFeatureFlags, getSpecifier, readFile } 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(modules, registry, hash, visitedDefinitions = new Set()) {
+async function getRecursiveModuleHash(modules, registry, hash, visitedDefinitions = new Set(), excludes = new Set()) {
     if (!modules.length) {
         return;
     }
+    // Fetch all the definitions from the registry
     const definitions = await Promise.all(modules.map((module) => registry.getModule(module)));
     const imports = new Map();
     for (const definition of definitions) {
-        const { ownHash, moduleRecord } = definition;
-        // include module in the bundle signature
-        hash.update(ownHash);
-        // 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);
-        });
+        const { specifier, version, ownHash, moduleRecord } = definition;
+        // check if this definition was in the bundle excludes
+        if (excludes.has(specifier)) {
+            // add the version do not worry about crawling its dependents
+            hash.update(`${specifier}@${version}@${ownHash}`);
+            // add just the specifier to the visited list
+            visitedDefinitions.add(specifier);
+        }
+        else {
+            // include module in the bundle signature
+            hash.update(ownHash);
+            // 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);
+            });
+        }
     }
     // filter out bundle config exclusions and already visited dependencies
     const dependencies = Array.from(imports, ([_, dependency]) => dependency).filter((dependency) => 
@@ -30,7 +38,7 @@ async function getRecursiveModuleHash(modules, registry, hash, visitedDefinition
         // already visited dependencies will be versioned
         !visitedDefinitions.has(getSpecifier(dependency)));
     if (dependencies.length) {
-        return getRecursiveModuleHash(dependencies, registry, hash, visitedDefinitions);
+        return getRecursiveModuleHash(dependencies, registry, hash, visitedDefinitions, excludes);
     }
 }
 /**
@@ -46,37 +54,23 @@ async function getRecursiveModuleHash(modules, registry, hash, visitedDefinition
  * @param exclude - bundle config exclusions
  * @returns a bungle signature
  */
-export async function getBundleSignature(moduleId, registry, exclude) {
+export async function getBundleSignature(moduleId, registry, excludes) {
     const hash = crypto.createHash('sha1');
+    // Add the environment key
     hash.update(ENV_KEY);
     // 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));
+    await getRecursiveModuleHash([moduleId], registry, hash, new Set(), new Set(excludes));
     return hash.digest('hex');
 }
 /**
  * Get the configured LWC version
  */
 function getLWCVersion() {
-    let lwcVersion;
-    try {
-        // check if it is set on the global shim
-        if (LWR?.LWC_VERSION) {
-            lwcVersion = LWR.LWC_VERSION;
-        }
-    }
-    catch (err) {
-        // No-op throws an error in cli when LWR versison not set in global
-    }
-    if (!lwcVersion) {
-        const require = createRequire(path.join(cwd(), './env-config.js'));
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { version } = require('lwc/package.json');
-        lwcVersion = version;
-    }
-    logger.debug(`Signature LWC Version: ${lwcVersion}`);
-    return lwcVersion;
+    const packageJsonPath = resolve.sync(`lwc/package.json`);
+    const { version } = JSON.parse(readFile(packageJsonPath));
+    return version;
 }
 //# sourceMappingURL=signature.js.map

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.0",
+    "version": "0.9.0-alpha.10",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -30,16 +30,16 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.0",
-        "@lwrjs/shared-utils": "0.9.0-alpha.0",
+        "@lwrjs/diagnostics": "0.9.0-alpha.10",
+        "@lwrjs/shared-utils": "0.9.0-alpha.10",
         "es-module-lexer": "^0.3.18"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.0",
+        "@lwrjs/types": "0.9.0-alpha.10",
         "@types/es-module-lexer": "^0.3.0"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "6890d8619b295a49ee1ed8253a372337d83863be"
+    "gitHead": "ecbf031157dd87d2b1a3d528b7fae8f9142eba7e"
 }