@lwrjs/module-registry 0.9.0-alpha.2 → 0.9.0-alpha.21

package/build/cjs/index.cjs

@@ -28,6 +28,7 @@ __export(exports, {
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_compiler = __toModule(require("@lwrjs/shared-utils/compiler"));
 var import_linker = __toModule(require("./linker/linker.cjs"));
 var import_module_record = __toModule(require("./module-record.cjs"));
 var import_amd_strategy = __toModule(require("./linker/strategies/amd-strategy.cjs"));
@@ -109,23 +110,16 @@ var LwrModuleRegistry = class {
       const {runtimeEnvironment} = this.context;
       const {minify, sourceMapUrl} = runtimeEnvironment;
       const sourcemap = typeof sourceMapUrl === "string" || !minify;
-      const {code: lockerizedCode} = this.context.compiler.lockerize(moduleCompiled, locker, sourcemap);
+      const {code: lockerizedCode} = (0, import_compiler.lockerize)(moduleCompiled, locker, sourcemap);
       moduleCompiled.compiledSource = lockerizedCode;
     }
-    const moduleRecord = await (0, import_module_record.getModuleRecord)(moduleCompiled, this, this.context.compiler);
+    const moduleRecord = await (0, import_module_record.getModuleRecord)(moduleCompiled, this);
     return {...moduleCompiled, moduleRecord};
   }
   async getLinkedModule(moduleId, runtimeEnvironment, runtimeParams) {
     const moduleEntry = await this.getModuleEntry(moduleId, runtimeParams);
     const id = moduleEntry.id;
-    const {
-      format,
-      compat,
-      debug,
-      minify,
-      bundle,
-      env: {NODE_ENV: envMode}
-    } = runtimeEnvironment;
+    const {format, compat, debug, minify, bundle} = runtimeEnvironment;
     const locale = runtimeParams?.["locale"];
     const environment = runtimeParams?.["environment"];
     const {
@@ -152,17 +146,10 @@ var LwrModuleRegistry = class {
     const moduleDef = await this.getModule(moduleId, runtimeParams);
     const moduleLinked = await this.createLinkedModuleDefinition(moduleDef, runtimeEnvironment, runtimeParams);
     if (format === "amd" && !bundle) {
-      moduleLinked.linkedSource = (await this.context.compiler.convertToAmd(moduleLinked.linkedSource, {
+      moduleLinked.linkedSource = (await (0, import_compiler.convertToAmd)(moduleLinked.linkedSource, {
         id: moduleLinked.id
       })).code;
     }
-    const minified = !!minify && !debug;
-    if (minified && !bundle) {
-      moduleLinked.linkedSource = (await this.context.compiler.minifyJavascript(moduleLinked.linkedSource)).code;
-      moduleLinked.linkedConfig.minified = true;
-    } else {
-      moduleLinked.linkedSource = (await this.context.compiler.parseJavascript(moduleLinked.linkedSource, {envMode})).code;
-    }
     if (cacheDisabled === false) {
       const linkedMap = this.moduleLinkedCache.get(id) || new Map();
       linkedMap.set((0, import_shared_utils.getCacheKeyFromJson)({
@@ -255,6 +242,7 @@ var LwrModuleRegistry = class {
     return {
       getModuleEntry: this.getModuleEntry.bind(this),
       getModule: this.getModule.bind(this),
+      getLinkedModule: this.getLinkedModule.bind(this),
       resolveModuleUri: this.resolveModuleUri.bind(this)
     };
   }

package/build/cjs/module-record.cjs

@@ -69,12 +69,12 @@ async function resolveExternalImport(registry, moduleSpecifier, importeeEntry, l
     interchangeable: dependencyModuleEntry.interchangeable
   };
 }
-async function getModuleRecord(compiledModule, registry, compiler) {
+async function getModuleRecord(compiledModule, registry) {
   const imports = [];
   const dynamicImports = [];
   const {compiledMetadata: defaultCompilerMetadata, moduleEntry, version} = compiledModule;
   const compiledMetadata = defaultCompilerMetadata || {};
-  const {imports: compiledModuleImports, dynamicImports: compiledModuleDynamicImports} = await compiler.getModuleMetadata(compiledModule.compiledSource);
+  const {imports: compiledModuleImports, dynamicImports: compiledModuleDynamicImports} = await (0, import_shared_utils.getImportMetadata)(compiledModule.compiledSource);
   Object.assign(compiledMetadata, {
     imports: compiledModuleImports,
     dynamicImports: compiledModuleDynamicImports

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/index.d.ts

@@ -1,8 +1,7 @@
-import { ModuleProvider, LinkedModuleDefinition, LwrAppObserver, Compiler, RuntimeEnvironment, LwrAppEmitter, ModuleRegistry, ModuleEntry, PublicModuleRegistry, NormalizedLwrGlobalConfig, ModuleDefinition, AbstractModuleId, ModuleId, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, LinkedModuleDefinition, LwrAppEmitter, LwrAppObserver, ModuleDefinition, ModuleEntry, ModuleId, ModuleProvider, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 interface RegistryContext {
     appObserver: LwrAppObserver;
     appEmitter: LwrAppEmitter;
-    compiler: Compiler;
     runtimeEnvironment: RuntimeEnvironment;
 }
 export declare class LwrModuleRegistry implements ModuleRegistry {

package/build/es/index.js

@@ -1,5 +1,7 @@
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { discoverInterchangeableModules, getCacheKeyFromJson, InflightTasks, LATEST_SIGNATURE, ModuleNameType, } from '@lwrjs/shared-utils';
+// dependencies @locker/compiler and rollup are in this package.json is to satisfy the shared-utils/compiler optional dependencies
+import { convertToAmd, lockerize } from '@lwrjs/shared-utils/compiler';
 import { link } from './linker/linker.js';
 import { getModuleRecord } from './module-record.js';
 import amdLinkingStrategy from './linker/strategies/amd-strategy.js';
@@ -98,17 +100,17 @@ export class LwrModuleRegistry {
             // in addition to being explicitly enabled.
             const { minify, sourceMapUrl } = runtimeEnvironment;
             const sourcemap = typeof sourceMapUrl === 'string' || !minify;
-            const { code: lockerizedCode } = this.context.compiler.lockerize(moduleCompiled, locker, sourcemap);
+            const { code: lockerizedCode } = lockerize(moduleCompiled, locker, sourcemap);
             moduleCompiled.compiledSource = lockerizedCode;
         }
-        const moduleRecord = await getModuleRecord(moduleCompiled, this, this.context.compiler);
+        const moduleRecord = await getModuleRecord(moduleCompiled, this);
         return { ...moduleCompiled, moduleRecord };
     }
     async getLinkedModule(moduleId, runtimeEnvironment, runtimeParams) {
         const moduleEntry = await this.getModuleEntry(moduleId, runtimeParams);
         const id = moduleEntry.id;
         // cache key pivots from the runtimeEnvironment
-        const { format, compat, debug, minify, bundle, env: { NODE_ENV: envMode }, } = runtimeEnvironment;
+        const { format, compat, debug, minify, bundle } = runtimeEnvironment;
         const locale = runtimeParams?.['locale'];
         const environment = runtimeParams?.['environment'];
         const { locker: { enabled: lockerEnabled }, } = this.globalConfig;
@@ -135,19 +137,10 @@ export class LwrModuleRegistry {
         // the bundler will convert the linked source to AMD when bundling is enabled
         if (format === 'amd' && !bundle) {
             // convert the linkedSource to the transport AMD format
-            moduleLinked.linkedSource = (await this.context.compiler.convertToAmd(moduleLinked.linkedSource, {
+            moduleLinked.linkedSource = (await convertToAmd(moduleLinked.linkedSource, {
                 id: moduleLinked.id,
             })).code;
         }
-        const minified = !!minify && !debug;
-        // the bundler will minify when bundling is enabled
-        if (minified && !bundle) {
-            moduleLinked.linkedSource = (await this.context.compiler.minifyJavascript(moduleLinked.linkedSource)).code;
-            moduleLinked.linkedConfig.minified = true;
-        }
-        else {
-            moduleLinked.linkedSource = (await this.context.compiler.parseJavascript(moduleLinked.linkedSource, { envMode })).code;
-        }
         // Add to cache
         if (cacheDisabled === false) {
             const linkedMap = this.moduleLinkedCache.get(id) || new Map();
@@ -245,6 +238,7 @@ export class LwrModuleRegistry {
         return {
             getModuleEntry: this.getModuleEntry.bind(this),
             getModule: this.getModule.bind(this),
+            getLinkedModule: this.getLinkedModule.bind(this),
             resolveModuleUri: this.resolveModuleUri.bind(this),
         };
     }

package/build/es/module-record.d.ts

@@ -1,3 +1,3 @@
-import { ModuleCompiled, ModuleRecord, ModuleRegistry, Compiler } from '@lwrjs/types';
-export declare function getModuleRecord(compiledModule: ModuleCompiled, registry: ModuleRegistry, compiler: Compiler): Promise<ModuleRecord>;
+import type { ModuleCompiled, ModuleRecord, ModuleRegistry } from '@lwrjs/types';
+export declare function getModuleRecord(compiledModule: ModuleCompiled, registry: ModuleRegistry): Promise<ModuleRecord>;
 //# sourceMappingURL=module-record.d.ts.map

package/build/es/module-record.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { explodeSpecifier, ModuleNameType } from '@lwrjs/shared-utils';
+import { explodeSpecifier, getImportMetadata, ModuleNameType } from '@lwrjs/shared-utils';
 async function resolveRelativeImport(registry, moduleSpecifier, importeeEntry, version, location) {
     // Resolve any relative parts in the import specifier
     // eg: "c/app#app.html" => "c/app"
@@ -51,13 +51,13 @@ async function resolveExternalImport(registry, moduleSpecifier, importeeEntry, l
         interchangeable: dependencyModuleEntry.interchangeable,
     };
 }
-export async function getModuleRecord(compiledModule, registry, compiler) {
+export async function getModuleRecord(compiledModule, registry) {
     const imports = [];
     const dynamicImports = [];
     const { compiledMetadata: defaultCompilerMetadata, moduleEntry, version } = compiledModule;
     const compiledMetadata = defaultCompilerMetadata || {};
     // Get imports metadata and merge with rest of compiledModule metadata
-    const { imports: compiledModuleImports, dynamicImports: compiledModuleDynamicImports } = await compiler.getModuleMetadata(compiledModule.compiledSource);
+    const { imports: compiledModuleImports, dynamicImports: compiledModuleDynamicImports } = await getImportMetadata(compiledModule.compiledSource);
     Object.assign(compiledMetadata, {
         imports: compiledModuleImports,
         dynamicImports: compiledModuleDynamicImports,

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,15 +4,15 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.2",
+    "version": "0.9.0-alpha.21",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
-        "url": "https://github.com/salesforce/lwr.git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
         "directory": "packages/@lwrjs/module-registry"
     },
     "bugs": {
-        "url": "https://github.com/salesforce/lwr/issues"
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
     },
     "type": "module",
     "types": "build/es/index.d.ts",
@@ -30,16 +30,18 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.2",
-        "@lwrjs/shared-utils": "0.9.0-alpha.2",
-        "es-module-lexer": "^0.3.18"
+        "@locker/compiler": "0.18.9",
+        "@lwrjs/diagnostics": "0.9.0-alpha.21",
+        "@lwrjs/shared-utils": "0.9.0-alpha.21",
+        "es-module-lexer": "^0.3.18",
+        "rollup": "~2.45.2"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.2",
+        "@lwrjs/types": "0.9.0-alpha.21",
         "@types/es-module-lexer": "^0.3.0"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "bcf63de23d1a2a53fb0e961dba4396e8753710dd"
+    "gitHead": "a89adcac80601f657becd6fd734c765e6b2a2745"
 }