@lwrjs/module-registry 0.5.11 → 0.6.0-0.6.0-alpha.15.0

package/build/cjs/index.cjs

@@ -38,6 +38,7 @@ var LwrModuleRegistry = class {
     this.providers = [];
     this.moduleDefCache = new Map();
     this.moduleLinkedCache = new Map();
+    this.inflightModuleDefinitions = new import_shared_utils.InflightTasks();
     this.name = "lwr-module-registry";
     this.context = context;
     this.globalConfig = globalConfig;
@@ -88,12 +89,23 @@ var LwrModuleRegistry = class {
     return this.delegateGetModuleEntryOnServices(moduleId, runtimeParams);
   }
   async getModule(moduleId, runtimeParams) {
-    const {locker} = this.globalConfig;
     const moduleEntry = await this.getModuleEntry(moduleId, runtimeParams);
     const cacheDisabled = process.env.NOCACHE === "true";
     if (cacheDisabled === false && this.moduleDefCache.has(moduleEntry.id)) {
       return this.moduleDefCache.get(moduleEntry.id);
     }
+    const createModulePromiseCtor = async () => {
+      return this.createModuleDefinition(moduleId, runtimeParams).then((moduleDef) => {
+        if (cacheDisabled === false) {
+          this.moduleDefCache.set(moduleDef.id, moduleDef);
+        }
+        return moduleDef;
+      });
+    };
+    return this.inflightModuleDefinitions.execute(moduleEntry.id, createModulePromiseCtor, this);
+  }
+  async createModuleDefinition(moduleId, runtimeParams) {
+    const {locker} = this.globalConfig;
     const moduleCompiled = await this.delegateGetModuleOnProviders(moduleId, runtimeParams);
     if (locker.enabled && !locker.clientOnly) {
       const {runtimeEnvironment} = this.context;
@@ -102,11 +114,7 @@ var LwrModuleRegistry = class {
       moduleCompiled.compiledSource = lockerizedCode;
     }
     const moduleRecord = await (0, import_module_record.getModuleRecord)(moduleCompiled, this, this.context.compiler);
-    const moduleDef = {...moduleCompiled, moduleRecord};
-    if (cacheDisabled === false) {
-      this.moduleDefCache.set(moduleDef.id, moduleDef);
-    }
-    return moduleDef;
+    return {...moduleCompiled, moduleRecord};
   }
   async getLinkedModule(moduleId, runtimeEnvironment, runtimeParams) {
     const moduleEntry = await this.getModuleEntry(moduleId, runtimeParams);
@@ -153,7 +161,7 @@ var LwrModuleRegistry = class {
         id,
         code: linkedES6,
         linkedModuleRecord
-      } = await (0, import_linker.link)(this, moduleDef, import_amd_strategy.default, runtimeEnvironment, runtimeParams, {
+      } = await (0, import_linker.link)(this, moduleDef, import_amd_strategy.default, import_esm_strategy.default, runtimeEnvironment, runtimeParams, {
         amdLoaderModule: loaderModuleEntry
       }, this.interchangeableModules);
       const {code: amdSource} = await this.context.compiler.convertToAmd(linkedES6, {
@@ -164,6 +172,7 @@ var LwrModuleRegistry = class {
         const {code: minifiedCode} = await this.context.compiler.minifyJavascript(amdSource);
         linkedAmdSource = minifiedCode;
       }
+      linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== import_shared_utils.ModuleNameType.unresolved);
       return {
         ...moduleDef,
         linkedSource: linkedAmdSource,
@@ -176,10 +185,10 @@ var LwrModuleRegistry = class {
     } else {
       let loaderModuleEntry;
       const dynamicImports = moduleDef.moduleRecord.dynamicImports;
-      if (moduleDef.moduleEntry.specifier !== esmLoader && dynamicImports && dynamicImports.some((d) => d.moduleNameType === import_shared_utils.ModuleNameType.unresolved)) {
+      if (moduleDef.moduleEntry.specifier !== esmLoader && dynamicImports) {
         loaderModuleEntry = await this.getModuleEntry({specifier: esmLoader}, runtimeParams);
       }
-      const {code: esmLinkedSource, linkedModuleRecord} = await (0, import_linker.link)(this, moduleDef, import_esm_strategy.default, runtimeEnvironment, runtimeParams, loaderModuleEntry && {
+      const {code: esmLinkedSource, linkedModuleRecord} = await (0, import_linker.link)(this, moduleDef, import_amd_strategy.default, import_esm_strategy.default, runtimeEnvironment, runtimeParams, loaderModuleEntry && {
         esmLoaderModule: loaderModuleEntry
       }, this.interchangeableModules, this.globalConfig.bundleConfig?.exclude);
       let transformedEsmCode = esmLinkedSource;
@@ -187,6 +196,7 @@ var LwrModuleRegistry = class {
         const {code: minifiedEsm} = await this.context.compiler.minifyJavascript(transformedEsmCode);
         transformedEsmCode = minifiedEsm;
       }
+      linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== import_shared_utils.ModuleNameType.unresolved);
       return {
         ...moduleDef,
         linkedConfig: {

package/build/cjs/linker/linker.cjs

@@ -26,15 +26,16 @@ __markAsModule(exports);
 __export(exports, {
   link: () => link
 });
-var import_magic_string = __toModule(require("magic-string"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_shared_utils2 = __toModule(require("@lwrjs/shared-utils"));
 var import_signature = __toModule(require("../signature.cjs"));
-async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, exclude) {
+async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, exclude) {
   const {specifier, version, compiledSource, moduleRecord} = moduleDef;
   const {imports, dynamicImports} = moduleRecord;
-  const codeStringBuilder = new import_magic_string.default(compiledSource);
+  const codeStringBuilder = (0, import_shared_utils.createStringBuilder)(compiledSource);
   const amdLoaderModule = config?.amdLoaderModule;
   const esmLoaderModule = config?.esmLoaderModule;
+  const strategy = amdLoaderModule ? versionStrategy : uriStrategy;
   const id = strategy({specifier, version}, runtimeEnvironment, runtimeParams);
   let linkedImports = [];
   let linkedDynamicImports = [];
@@ -80,22 +81,22 @@ async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironment, run
     linkedDynamicImports = await Promise.all(dynamicImports.map(async (importRef) => {
       const {locations, sourceSpecifier} = importRef;
       let signature;
-      const isStringLiteral = importRef.moduleNameType === import_shared_utils.ModuleNameType.string;
+      const isStringLiteral = importRef.moduleNameType === import_shared_utils2.ModuleNameType.string;
       if (isStringLiteral && runtimeEnvironment.bundle && runtimeEnvironment.format === "esm") {
         signature = await (0, import_signature.getBundleSignature)(importRef, moduleRegistry);
       }
-      const link2 = isStringLiteral ? strategy(importRef, runtimeEnvironment, runtimeParams, signature) : importRef.specifier;
+      const link2 = isStringLiteral ? versionStrategy(importRef, runtimeEnvironment, runtimeParams, signature) : importRef.specifier;
       const linkedLocations = locations.map(({location, importLocation}) => {
         const {startColumn, endColumn} = location;
         const {startColumn: importStart, endColumn: importEnd} = importLocation;
         if (isStringLiteral) {
           codeStringBuilder.overwrite(startColumn + 1, endColumn - 1, link2);
         }
-        if (amdLoaderModule || esmLoaderModule && !isStringLiteral) {
+        if (amdLoaderModule || esmLoaderModule) {
           codeStringBuilder.overwrite(importStart, importEnd, "load(");
           loaderSizeOffset = 2;
           if (!isStringLiteral) {
-            const importerSpecifier = (0, import_shared_utils.getSpecifier)({specifier, version});
+            const importerSpecifier = (0, import_shared_utils2.getSpecifier)({specifier, version});
             codeStringBuilder.overwrite(endColumn, endColumn + 1, `, '${importerSpecifier}')`);
             loaderSizeOffset = -1 * importerSpecifier.length - 2;
           }
@@ -116,8 +117,12 @@ async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironment, run
   }
   if (dynamicImports && dynamicImports.length > 0 && (amdLoaderModule || esmLoaderModule)) {
     const {version: version2, specifier: specifier2} = amdLoaderModule || esmLoaderModule;
-    const {namespace, name} = (0, import_shared_utils.explodeSpecifier)(specifier2);
-    const loaderLink = strategy({specifier: specifier2, version: version2}, runtimeEnvironment, runtimeParams);
+    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);
+    }
+    const loaderLink = strategy({specifier: specifier2, version: version2}, runtimeEnvironment, runtimeParams, signature);
     codeStringBuilder.prepend(`import { load } from "${loaderLink}";
 `);
     linkedImports.unshift({

package/build/cjs/linker/strategies/esm-strategy.cjs

@@ -37,7 +37,7 @@ function linkEsm(moduleId, environment, params = {}, signature) {
   const encodedVSpecifier = encodeURIComponent(vSpecifier);
   const latestSignature = signature === void 0 || signature === LATEST_SIG;
   const sigilSignature = latestSignature ? LATEST_SIG : `${SIGNATURE_SIGIL}/${signature}`;
-  const prettyUrl = (bundle ? "bundle_" : "") + `${specifier.replace(/[\/\.\#]/g, "_")}`;
+  const prettyUrl = (bundle ? "bundle_" : "") + (0, import_shared_utils.prettyModuleUriSuffix)(specifier);
   const debugModifier = debug ? "?debug=true" : "";
   return `${uriPrefix}${encodedVSpecifier}/${sigilSignature}/${prettyUrl}.js${debugModifier}`;
 }

package/build/cjs/module-record.cjs

@@ -79,7 +79,7 @@ async function getModuleRecord(compiledModule, registry, compiler) {
     imports: compiledModuleImports,
     dynamicImports: compiledModuleDynamicImports
   });
-  if (compiledMetadata && compiledMetadata.imports) {
+  if (compiledMetadata && compiledMetadata.imports && compiledMetadata.imports.length > 0) {
     const visitedImports = new Set();
     for (const {moduleSpecifier, location} of compiledMetadata.imports) {
       if (!visitedImports.has(moduleSpecifier)) {
@@ -99,7 +99,7 @@ async function getModuleRecord(compiledModule, registry, compiler) {
       }
     }
   }
-  if (compiledMetadata && compiledMetadata.dynamicImports) {
+  if (compiledMetadata && compiledMetadata.dynamicImports && compiledMetadata.dynamicImports.length > 0) {
     const visitedDynamicImports = new Set();
     for (const {
       moduleSpecifier,

package/build/cjs/signature.cjs

@@ -28,6 +28,7 @@ __export(exports, {
 });
 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_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var LWC_VERSION = getLWCVersion();
@@ -62,7 +63,7 @@ async function getBundleSignature(moduleId, registry) {
   return hash.digest("hex");
 }
 function getLWCVersion() {
-  const require2 = (0, import_module.createRequire)(import_path.default.join(process.cwd(), "./env-config.js"));
+  const require2 = (0, import_module.createRequire)(import_path.default.join((0, import_process.cwd)(), "./env-config.js"));
   const {version} = require2("lwc/package.json");
   return version;
 }

package/build/es/index.d.ts

@@ -14,11 +14,13 @@ export declare class LwrModuleRegistry implements ModuleRegistry {
     emitter: LwrAppEmitter;
     globalConfig: NormalizedLwrGlobalConfig;
     private interchangeableModules?;
+    private inflightModuleDefinitions;
     constructor(context: RegistryContext, globalConfig: NormalizedLwrGlobalConfig, registries?: ModuleProvider[]);
     resolveModuleUri<R extends RuntimeEnvironment, S extends string | undefined>(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, runtimeEnvironment: R, runtimeParams?: RuntimeParams, signature?: S): S extends string ? string : Promise<string>;
     addModuleProviders(registries: ModuleProvider[]): void;
     getModuleEntry<T extends AbstractModuleId>(moduleId: T, runtimeParams?: RuntimeParams): Promise<ModuleEntry>;
     getModule<T extends AbstractModuleId>(moduleId: T, runtimeParams?: RuntimeParams): Promise<ModuleDefinition>;
+    private createModuleDefinition;
     getLinkedModule<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams): Promise<LinkedModuleDefinition>;
     private createLinkedModuleDefinition;
     private delegateGetModuleEntryOnServices;

package/build/es/index.js

@@ -1,5 +1,5 @@
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
-import { discoverInterchangeableModules, getCacheKeyFromJson, LATEST_SIGNATURE, ModuleNameType, } from '@lwrjs/shared-utils';
+import { discoverInterchangeableModules, getCacheKeyFromJson, InflightTasks, LATEST_SIGNATURE, ModuleNameType, } from '@lwrjs/shared-utils';
 import { link } from './linker/linker.js';
 import { getModuleRecord } from './module-record.js';
 import amdLinkingStrategy from './linker/strategies/amd-strategy.js';
@@ -10,6 +10,7 @@ export class LwrModuleRegistry {
         this.providers = [];
         this.moduleDefCache = new Map();
         this.moduleLinkedCache = new Map();
+        this.inflightModuleDefinitions = new InflightTasks();
         this.name = 'lwr-module-registry';
         this.context = context;
         this.globalConfig = globalConfig;
@@ -72,12 +73,25 @@ export class LwrModuleRegistry {
         return this.delegateGetModuleEntryOnServices(moduleId, runtimeParams);
     }
     async getModule(moduleId, runtimeParams) {
-        const { locker } = this.globalConfig;
         const moduleEntry = await this.getModuleEntry(moduleId, runtimeParams);
         const cacheDisabled = process.env.NOCACHE === 'true';
         if (cacheDisabled === false && this.moduleDefCache.has(moduleEntry.id)) {
+            // TODO add to profiling
+            // console.log('[INFO] Module Cache Hit: %s', moduleEntry.id);
             return this.moduleDefCache.get(moduleEntry.id);
         }
+        const createModulePromiseCtor = async () => {
+            return this.createModuleDefinition(moduleId, runtimeParams).then((moduleDef) => {
+                if (cacheDisabled === false) {
+                    this.moduleDefCache.set(moduleDef.id, moduleDef);
+                }
+                return moduleDef;
+            });
+        };
+        return this.inflightModuleDefinitions.execute(moduleEntry.id, createModulePromiseCtor, this);
+    }
+    async createModuleDefinition(moduleId, runtimeParams) {
+        const { locker } = this.globalConfig;
         const moduleCompiled = await this.delegateGetModuleOnProviders(moduleId, runtimeParams); // provider source + hash
         /** Locker before collecting dep module records so locker imports are processed normally */
         if (locker.enabled && !locker.clientOnly) {
@@ -87,11 +101,7 @@ export class LwrModuleRegistry {
             moduleCompiled.compiledSource = lockerizedCode;
         }
         const moduleRecord = await getModuleRecord(moduleCompiled, this, this.context.compiler);
-        const moduleDef = { ...moduleCompiled, moduleRecord };
-        if (cacheDisabled === false) {
-            this.moduleDefCache.set(moduleDef.id, moduleDef);
-        }
-        return moduleDef;
+        return { ...moduleCompiled, moduleRecord };
     }
     async getLinkedModule(moduleId, runtimeEnvironment, runtimeParams) {
         const moduleEntry = await this.getModuleEntry(moduleId, runtimeParams);
@@ -137,7 +147,7 @@ export class LwrModuleRegistry {
             // Resolve the loader entry
             const loaderModuleEntry = await this.getModuleEntry({ specifier: amdLoader }, runtimeParams);
             // transforms compiledModule into linkedModule (which means the imports may have changed)
-            const { id, code: linkedES6, linkedModuleRecord, } = await link(this, moduleDef, amdLinkingStrategy, runtimeEnvironment, runtimeParams, {
+            const { id, code: linkedES6, linkedModuleRecord, } = await link(this, moduleDef, amdLinkingStrategy, esmLinkingStrategy, runtimeEnvironment, runtimeParams, {
                 amdLoaderModule: loaderModuleEntry,
             }, this.interchangeableModules);
             // convert the linkedSource to the transport AMD format.
@@ -149,6 +159,8 @@ export class LwrModuleRegistry {
                 const { code: minifiedCode } = await this.context.compiler.minifyJavascript(amdSource);
                 linkedAmdSource = minifiedCode;
             }
+            // Filter out variable dynamic imports
+            linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== ModuleNameType.unresolved);
             return {
                 ...moduleDef,
                 linkedSource: linkedAmdSource,
@@ -163,14 +175,12 @@ export class LwrModuleRegistry {
             // resolve the loader entry if there are VARIABLE dynamic imports
             let loaderModuleEntry;
             const dynamicImports = moduleDef.moduleRecord.dynamicImports;
-            if (moduleDef.moduleEntry.specifier !== esmLoader &&
-                dynamicImports &&
-                dynamicImports.some((d) => d.moduleNameType === ModuleNameType.unresolved)) {
-                // ONLY include the ESM loader if there are VARIABLE dynamic imports
+            if (moduleDef.moduleEntry.specifier !== esmLoader && dynamicImports) {
+                // ONLY include the ESM loader if there are dynamic imports
                 // AND this is not the ESM loader itself (it uses a variable dynamic import we DO NOT want to link)
                 loaderModuleEntry = await this.getModuleEntry({ specifier: esmLoader }, runtimeParams);
             }
-            const { code: esmLinkedSource, linkedModuleRecord } = await link(this, moduleDef, esmLinkingStrategy, runtimeEnvironment, runtimeParams, loaderModuleEntry && {
+            const { code: esmLinkedSource, linkedModuleRecord } = await link(this, moduleDef, amdLinkingStrategy, esmLinkingStrategy, runtimeEnvironment, runtimeParams, loaderModuleEntry && {
                 esmLoaderModule: loaderModuleEntry,
             }, this.interchangeableModules, this.globalConfig.bundleConfig?.exclude);
             let transformedEsmCode = esmLinkedSource;
@@ -178,6 +188,8 @@ export class LwrModuleRegistry {
                 const { code: minifiedEsm } = await this.context.compiler.minifyJavascript(transformedEsmCode);
                 transformedEsmCode = minifiedEsm;
             }
+            // Filter out variable dynamic imports
+            linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== ModuleNameType.unresolved);
             return {
                 ...moduleDef,
                 linkedConfig: {

package/build/es/linker/linker.d.ts

@@ -24,6 +24,6 @@ export interface ModuleLinkResult {
  * @param moduleRecord
  * @param strategy
  */
-export declare function link(moduleRegistry: LwrModuleRegistry, moduleDef: ModuleDefinition, strategy: LinkingStrategy, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, config?: LinkerConfig, interchangeableModules?: InterchangeableModuleMap, exclude?: string[]): Promise<ModuleLinkResult>;
+export declare function link(moduleRegistry: LwrModuleRegistry, moduleDef: ModuleDefinition, versionStrategy: LinkingStrategy, uriStrategy: LinkingStrategy, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, config?: LinkerConfig, interchangeableModules?: InterchangeableModuleMap, exclude?: string[]): Promise<ModuleLinkResult>;
 export {};
 //# sourceMappingURL=linker.d.ts.map

package/build/es/linker/linker.js

@@ -1,4 +1,4 @@
-import MagicString from 'magic-string';
+import { createStringBuilder } from '@lwrjs/shared-utils';
 import { explodeSpecifier, getSpecifier, ModuleNameType } from '@lwrjs/shared-utils';
 import { getBundleSignature } from '../signature.js';
 /**
@@ -7,12 +7,13 @@ import { getBundleSignature } from '../signature.js';
  * @param moduleRecord
  * @param strategy
  */
-export async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, exclude) {
+export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, exclude) {
     const { specifier, version, compiledSource, moduleRecord } = moduleDef;
     const { imports, dynamicImports } = moduleRecord;
-    const codeStringBuilder = new MagicString(compiledSource);
+    const codeStringBuilder = createStringBuilder(compiledSource);
     const amdLoaderModule = config?.amdLoaderModule;
     const esmLoaderModule = config?.esmLoaderModule;
+    const strategy = amdLoaderModule ? versionStrategy : uriStrategy;
     const id = strategy({ specifier, version }, runtimeEnvironment, runtimeParams);
     // transform each import using the provided linking strategy.
     let linkedImports = [];
@@ -70,9 +71,11 @@ export async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironme
             if (isStringLiteral && runtimeEnvironment.bundle && runtimeEnvironment.format === 'esm') {
                 signature = await getBundleSignature(importRef, moduleRegistry);
             }
+            // 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
             const link = isStringLiteral
-                ? strategy(importRef, runtimeEnvironment, runtimeParams, signature) // dynamic import of a static string
-                : importRef.specifier; // variable dynamic import; keep the variable name as-is
+                ? versionStrategy(importRef, runtimeEnvironment, runtimeParams, signature) // dynamic import of a static string
+                : importRef.specifier; // variable dynamic imports: keep the variable name as-is
             // transform locations
             // replace all locations of importee with the link
             const linkedLocations = locations.map(({ location, importLocation }) => {
@@ -82,9 +85,8 @@ export async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironme
                 if (isStringLiteral) {
                     codeStringBuilder.overwrite(startColumn + 1, endColumn - 1, link);
                 }
-                if (amdLoaderModule || (esmLoaderModule && !isStringLiteral)) {
+                if (amdLoaderModule || esmLoaderModule) {
                     // replace the dynamic import with a configured loader
-                    // ONLY do this in ESM if the dynamic import is VARIABLE
                     // e.g. - await import('dynamic/module'); -> await load('dynamic/module');
                     codeStringBuilder.overwrite(importStart, importEnd, 'load(');
                     loaderSizeOffset = 2;
@@ -114,7 +116,12 @@ export async function link(moduleRegistry, moduleDef, strategy, runtimeEnvironme
         // mutate ModuleEntry to ImportModuleRecord
         const { version, specifier } = amdLoaderModule || esmLoaderModule;
         const { namespace, name } = explodeSpecifier(specifier);
-        const loaderLink = strategy({ specifier, version }, runtimeEnvironment, runtimeParams);
+        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);
+        }
+        const loaderLink = strategy({ specifier, version }, runtimeEnvironment, runtimeParams, signature);
         // import {load} from 'loader/loader'
         codeStringBuilder.prepend(`import { load } from "${loaderLink}";\n`);
         linkedImports.unshift({

package/build/es/linker/strategies/esm-strategy.js

@@ -1,4 +1,4 @@
-import { getModuleUriPrefix, getSpecifier, normalizeVersionToUri } from '@lwrjs/shared-utils';
+import { getModuleUriPrefix, getSpecifier, normalizeVersionToUri, prettyModuleUriSuffix, } from '@lwrjs/shared-utils';
 const SIGNATURE_SIGIL = 's';
 const LATEST_SIG = 'latest';
 export default function linkEsm(moduleId, environment, params = {}, signature) {
@@ -9,8 +9,7 @@ export default function linkEsm(moduleId, environment, params = {}, signature) {
     const encodedVSpecifier = encodeURIComponent(vSpecifier);
     const latestSignature = signature === undefined || signature === LATEST_SIG;
     const sigilSignature = latestSignature ? LATEST_SIG : `${SIGNATURE_SIGIL}/${signature}`;
-    // eslint-disable-next-line no-useless-escape
-    const prettyUrl = (bundle ? 'bundle_' : '') + `${specifier.replace(/[\/\.\#]/g, '_')}`;
+    const prettyUrl = (bundle ? 'bundle_' : '') + prettyModuleUriSuffix(specifier);
     const debugModifier = debug ? '?debug=true' : '';
     return `${uriPrefix}${encodedVSpecifier}/${sigilSignature}/${prettyUrl}.js${debugModifier}`;
 }

package/build/es/module-record.js

@@ -63,7 +63,7 @@ export async function getModuleRecord(compiledModule, registry, compiler) {
         dynamicImports: compiledModuleDynamicImports,
     });
     // Process imports
-    if (compiledMetadata && compiledMetadata.imports) {
+    if (compiledMetadata && compiledMetadata.imports && compiledMetadata.imports.length > 0) {
         const visitedImports = new Set(); // Avoids multiple imports to the same specifier
         for (const { moduleSpecifier, location } of compiledMetadata.imports) {
             // Check for dupes first
@@ -90,7 +90,7 @@ export async function getModuleRecord(compiledModule, registry, compiler) {
         }
     }
     // Process dynamic imports
-    if (compiledMetadata && compiledMetadata.dynamicImports) {
+    if (compiledMetadata && compiledMetadata.dynamicImports && compiledMetadata.dynamicImports.length > 0) {
         const visitedDynamicImports = new Set(); // Avoids multiple imports to the same specifier
         for (const { moduleSpecifier, location, importLocation, moduleNameType, } of compiledMetadata.dynamicImports) {
             // Check for dupes first

package/build/es/signature.js

@@ -1,5 +1,6 @@
 import crypto from 'crypto';
 import path from 'path';
+import { cwd } from 'process';
 import { createRequire } from 'module';
 import { getExperimentalFeatures } from '@lwrjs/shared-utils';
 const LWC_VERSION = getLWCVersion();
@@ -37,7 +38,7 @@ export async function getBundleSignature(moduleId, registry) {
  * Get the configured LWC version
  */
 function getLWCVersion() {
-    const require = createRequire(path.join(process.cwd(), './env-config.js'));
+    const require = createRequire(path.join(cwd(), './env-config.js'));
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const { version } = require('lwc/package.json');
     return version;

package/package.json

@@ -4,8 +4,8 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.5.11",
-    "homepage": "https://lwr.dev/",
+    "version": "0.6.0-0.6.0-alpha.15.0",
+    "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
         "url": "https://github.com/salesforce/lwr.git",
@@ -30,19 +30,18 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.5.11",
-        "@lwrjs/shared-utils": "0.5.11",
+        "@lwrjs/diagnostics": "0.6.0-0.6.0-alpha.15.0",
+        "@lwrjs/shared-utils": "0.6.0-0.6.0-alpha.15.0",
         "es-module-lexer": "^0.3.18",
-        "magic-string": "^0.25.7",
         "ws": "^7.2.5"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.5.11",
+        "@lwrjs/types": "0.6.0-0.6.0-alpha.15.0",
         "@types/es-module-lexer": "^0.3.0",
         "@types/ws": "^7.2.4"
     },
     "engines": {
         "node": ">=14.15.4 <17"
     },
-    "gitHead": "2ee810c0a4f1f36d1e0f8378a1fe00c19b4c5bc1"
+    "gitHead": "101ad971f5a7b0631dd149ee4e3aa1d1799a7af2"
 }