@lwrjs/lwc-module-provider 0.12.0-alpha.2 → 0.12.0-alpha.3

package/build/cjs/cache.cjs

@@ -32,7 +32,8 @@ __export(exports, {
   setupModuleCache: () => setupModuleCache
 });
 var import_path = __toModule(require("path"));
-var import_fs = __toModule(require("fs"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var DEFAULT_COMPILED_DIR = "lwc_compiled_modules";
 var DEFAULT_CACHE_FOLDER = "cache";
 var DEFAULT_CACHE_INDEX = `compiled.json`;
@@ -40,42 +41,58 @@ var NORMALIZE_PATH_REGEX = /[@\/#\.\?<>\\:\*\|"]/gm;
 function setupModuleCache(cacheDir) {
   const lwcCacheDir = import_path.default.join(cacheDir, `${DEFAULT_COMPILED_DIR}`);
   const lwcCacheIndexPath = import_path.default.join(lwcCacheDir, DEFAULT_CACHE_INDEX);
-  import_fs.default.mkdirSync(`${lwcCacheDir}/${DEFAULT_CACHE_FOLDER}`, {recursive: true});
-  if (!import_fs.default.existsSync(lwcCacheIndexPath)) {
-    import_fs.default.writeFileSync(lwcCacheIndexPath, "[]");
+  import_fs_extra.default.mkdirSync(`${lwcCacheDir}/${DEFAULT_CACHE_FOLDER}`, {recursive: true});
+  if (!import_fs_extra.default.existsSync(lwcCacheIndexPath)) {
+    import_fs_extra.default.writeFileSync(lwcCacheIndexPath, "[]");
     return {lwcCacheDir, lwcCacheIndex: new Map()};
   } else {
-    const rawIndex = import_fs.default.readFileSync(lwcCacheIndexPath, "utf-8");
-    try {
-      const cacheIndexJson = JSON.parse(rawIndex);
-      return {lwcCacheDir, lwcCacheIndex: new Map(cacheIndexJson)};
-    } catch (err) {
-      const newErr = new Error("Invalid LWC Index: " + rawIndex);
-      if (err.stack) {
-        newErr.stack += "\nCaused by: " + err.stack;
-      }
-      throw newErr;
-    }
+    const cacheIndexJson = import_fs_extra.default.readJSONSync(lwcCacheIndexPath, "utf-8");
+    return {lwcCacheDir, lwcCacheIndex: new Map(cacheIndexJson)};
   }
 }
-function addCompiledModuleCacheEntry(moduleSource, compilerResult, {lwcCacheIndex, lwcCacheDir}) {
+var IndexPersister = class {
+  async persist({lwcCacheIndex, lwcCacheDir}) {
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+    }
+    this.lwcCacheIndex = lwcCacheIndex;
+    this.lwcCacheDir = lwcCacheDir;
+    this.updateTimer = setTimeout(() => {
+      this.persistData();
+      this.lwcCacheIndex = void 0;
+      this.lwcCacheDir = void 0;
+      this.updateTimer = void 0;
+    }, 1e3);
+  }
+  persistData() {
+    const lwcCacheIndexPath = import_path.default.join(this.lwcCacheDir, DEFAULT_CACHE_INDEX);
+    import_fs_extra.default.writeJSONSync(lwcCacheIndexPath, [...this.lwcCacheIndex]);
+    import_diagnostics.logger.debug("lwc-module-provider", `LWC Index Updated`);
+  }
+};
+var INDEX_PERSISTER = new IndexPersister();
+var moduleCount = 0;
+async function addCompiledModuleCacheEntry(moduleSource, compilerResult, {lwcCacheIndex, lwcCacheDir}) {
   const {specifier, version, ownHash} = moduleSource;
-  const lwcCacheIndexPath = import_path.default.join(lwcCacheDir, DEFAULT_CACHE_INDEX);
   const cacheKey = `${specifier}@${version}`;
+  if (++moduleCount % 1e3 === 0) {
+    import_diagnostics.logger.debug({label: `lwc-module-provider`, message: `Compiled Modules >${moduleCount}`});
+  }
   const normalizedSpecifier = specifier.replace(NORMALIZE_PATH_REGEX, "_");
   const normalizedVersion = version.replace(NORMALIZE_PATH_REGEX, "_");
   const moduleFileName = `${normalizedSpecifier}_${normalizedVersion}.js`;
   const cachedModulePath = import_path.default.join(lwcCacheDir, DEFAULT_CACHE_FOLDER, moduleFileName);
-  import_fs.default.writeFileSync(cachedModulePath, compilerResult.code);
+  const writeModulePromise = import_fs_extra.default.writeFile(cachedModulePath, compilerResult.code);
   const moduleMetaFileName = `${normalizedSpecifier}_${normalizedVersion}.meta.json`;
   const cachedMetaPath = import_path.default.join(lwcCacheDir, DEFAULT_CACHE_FOLDER, moduleMetaFileName);
-  import_fs.default.writeFileSync(cachedMetaPath, JSON.stringify(compilerResult.metadata, null, "  "));
+  const writeMetadataPromise = import_fs_extra.default.writeJSON(cachedMetaPath, compilerResult.metadata);
   lwcCacheIndex.set(cacheKey, {
     ownHash,
     module: `./${DEFAULT_CACHE_FOLDER}/${moduleFileName}`,
     moduleMeta: `./${DEFAULT_CACHE_FOLDER}/${moduleMetaFileName}`
   });
-  import_fs.default.writeFileSync(lwcCacheIndexPath, JSON.stringify([...lwcCacheIndex], null, "  "));
+  const writeMetadata = INDEX_PERSISTER.persist({lwcCacheIndex, lwcCacheDir});
+  return Promise.all([writeModulePromise, writeMetadataPromise, writeMetadata]);
 }
 function getCompiledModuleCacheEntry({specifier, version, ownHash}, {lwcCacheIndex, lwcCacheDir}) {
   const cacheKey = `${specifier}@${version}`;
@@ -85,10 +102,10 @@ function getCompiledModuleCacheEntry({specifier, version, ownHash}, {lwcCacheInd
   }
   const cacheModulePath = import_path.default.join(lwcCacheDir, cacheEntry.module);
   const cacheMetaPath = import_path.default.join(lwcCacheDir, cacheEntry.moduleMeta);
-  if (ownHash === cacheEntry.ownHash && import_fs.default.existsSync(cacheModulePath) && import_fs.default.existsSync(cacheMetaPath)) {
+  if (ownHash === cacheEntry.ownHash && import_fs_extra.default.existsSync(cacheModulePath) && import_fs_extra.default.existsSync(cacheMetaPath)) {
     return {
-      code: import_fs.default.readFileSync(cacheModulePath, "utf-8"),
-      metadata: JSON.parse(import_fs.default.readFileSync(cacheMetaPath, "utf-8"))
+      code: import_fs_extra.default.readFileSync(cacheModulePath, "utf-8"),
+      metadata: JSON.parse(import_fs_extra.default.readFileSync(cacheMetaPath, "utf-8"))
     };
   }
 }

package/build/cjs/index.cjs

@@ -38,7 +38,7 @@ function getModuleEntryCacheKey(specifier, version) {
 var LwcModuleProvider = class {
   constructor(options = {}, {
     appEmitter,
-    config: {locker, modules, rootDir, cacheDir, environment},
+    config: {modules, rootDir, cacheDir, environment},
     runtimeEnvironment: {watchFiles},
     watcherFactory
   }) {
@@ -47,12 +47,12 @@ var LwcModuleProvider = class {
     this.packageVersionCache = new Map();
     this.watchedModuleContextMap = new Map();
     this.moduleEntryVersionCache = new Map();
+    this.importerMappingCache = new Map();
     this.lwcCompiler = new import_compiler.LwcCompiler();
     this.inflightGetModuleJobs = new import_shared_utils.InflightTasks();
     this.inflightGetModuleEntryJobs = new import_shared_utils.InflightTasks();
     const {disableCaching} = options;
     this.emitter = appEmitter;
-    this.locker = locker;
     this.modules = modules;
     this.rootDir = rootDir;
     this.watcher = watchFiles && watcherFactory ? (0, import_utils.setUpWatcher)(watcherFactory, this.onModuleChange.bind(this)) : void 0;
@@ -101,10 +101,7 @@ var LwcModuleProvider = class {
     import_diagnostics.logger.debug({
       label: `${this.name}`,
       message: "module source",
-      additionalInfo: {
-        moduleId,
-        isPreCompiled: compiledModule != void 0
-      }
+      additionalInfo: {moduleId, isPreCompiled: compiledModule != void 0}
     });
     if (!compiledModule) {
       const [name] = rawName.split("#");
@@ -136,7 +133,7 @@ var LwcModuleProvider = class {
         }
       });
       if (moduleFsCacheEnabled) {
-        (0, import_cache.addCompiledModuleCacheEntry)(moduleSource, compiledModule, cacheConfig);
+        await (0, import_cache.addCompiledModuleCacheEntry)(moduleSource, compiledModule, cacheConfig);
       }
     }
     if (watcher && !watchedModuleContextMap.has(moduleEntry.entry)) {
@@ -180,15 +177,12 @@ var LwcModuleProvider = class {
       label: `${this.name}`,
       message: `getModuleEntry ${specifier}@${version}@${importer}`
     });
-    const versionId = version || importer;
-    if (versionId) {
-      const cacheKey2 = getModuleEntryCacheKey(specifier, versionId);
-      if (this.moduleEntryVersionCache.has(cacheKey2)) {
-        return this.moduleEntryVersionCache.get(cacheKey2);
-      }
+    const moduleEntry = this.getCachedModuleEntry(specifier, version, importer);
+    if (moduleEntry) {
+      return moduleEntry;
     }
-    const cacheKey = `${specifier}@${version}@${importer}`;
-    return this.inflightGetModuleEntryJobs.execute(cacheKey, async () => {
+    const jobKey = `${specifier}@${version}@${importer}`;
+    return this.inflightGetModuleEntryJobs.execute(jobKey, async () => {
       return this.createModuleEntry({specifier, importer, version});
     });
   }
@@ -210,9 +204,8 @@ var LwcModuleProvider = class {
     const [baseSpecifier, fileRelativePathRaw] = specifier.split("#");
     const fileRelativePath = fileRelativePathRaw?.split("?")[0];
     let moduleEntry;
-    if (fileRelativePath && version) {
-      const cacheKey2 = getModuleEntryCacheKey(specifier, version);
-      moduleEntry = this.moduleEntryVersionCache.get(cacheKey2);
+    if (fileRelativePath) {
+      moduleEntry = this.getCachedModuleEntry(specifier, version, importer);
     }
     if (!moduleEntry) {
       try {
@@ -222,8 +215,7 @@ var LwcModuleProvider = class {
           additionalInfo: {
             baseSpecifier,
             importer,
-            rootDir: this.rootDir,
-            modules: this.modules
+            rootDir: this.rootDir
           }
         });
         const registryEntry = (0, import_utils.resolveModuleSpecifier)(baseSpecifier, importer || this.rootDir, this.modules, this.packageVersionCache);
@@ -268,11 +260,26 @@ var LwcModuleProvider = class {
     const cacheKey = getModuleEntryCacheKey(specifier, moduleEntry.version);
     const finalModuleEntry = {...moduleEntry, id: cacheKey};
     this.moduleEntryVersionCache.set(cacheKey, finalModuleEntry);
-    if (!version && importer) {
-      const importerCacheKey = getModuleEntryCacheKey(specifier, importer);
-      this.moduleEntryVersionCache.set(importerCacheKey, finalModuleEntry);
+    if (!version) {
+      const importerCacheKey = getModuleEntryCacheKey(specifier, importer || this.rootDir);
+      this.importerMappingCache.set(importerCacheKey, cacheKey);
     }
     return finalModuleEntry;
   }
+  getCachedModuleEntry(specifier, version, importer) {
+    let moduleEntry;
+    if (version) {
+      const cacheKey = getModuleEntryCacheKey(specifier, version);
+      moduleEntry = this.moduleEntryVersionCache.get(cacheKey);
+    }
+    if (!moduleEntry) {
+      const importerKey = getModuleEntryCacheKey(specifier, importer || this.rootDir);
+      const cacheKey = this.importerMappingCache.get(importerKey);
+      if (cacheKey) {
+        moduleEntry = this.moduleEntryVersionCache.get(cacheKey);
+      }
+    }
+    return moduleEntry;
+  }
 };
 var src_default = LwcModuleProvider;

package/build/cjs/utils.cjs

@@ -41,7 +41,7 @@ function resolveModuleSpecifier(specifier, importer, modules = [], packageVersio
   import_diagnostics.logger.debug({
     label: `lwc-module-provider`,
     message: "resolveModuleSpecifier",
-    additionalInfo: {specifier, importer, modules}
+    additionalInfo: {specifier, importer}
   });
   let resolvedModule;
   try {

package/build/es/cache.d.ts

@@ -16,6 +16,6 @@ export interface ModuleCacheContext {
  * We store an index file and the compiler modules individually
  */
 export declare function setupModuleCache(cacheDir: string): ModuleCacheContext;
-export declare function addCompiledModuleCacheEntry(moduleSource: ModuleSource, compilerResult: CompilerResult, { lwcCacheIndex, lwcCacheDir }: ModuleCacheContext): void;
+export declare function addCompiledModuleCacheEntry(moduleSource: ModuleSource, compilerResult: CompilerResult, { lwcCacheIndex, lwcCacheDir }: ModuleCacheContext): Promise<any>;
 export declare function getCompiledModuleCacheEntry({ specifier, version, ownHash }: ModuleSource, { lwcCacheIndex, lwcCacheDir }: ModuleCacheContext): CompilerResult | undefined;
 //# sourceMappingURL=cache.d.ts.map

package/build/es/cache.js

@@ -1,5 +1,6 @@
 import path from 'path';
-import fs from 'fs';
+import fs from 'fs-extra';
+import { logger } from '@lwrjs/diagnostics';
 export const DEFAULT_COMPILED_DIR = 'lwc_compiled_modules';
 export const DEFAULT_CACHE_FOLDER = 'cache';
 export const DEFAULT_CACHE_INDEX = `compiled.json`;
@@ -18,35 +19,52 @@ export function setupModuleCache(cacheDir) {
         return { lwcCacheDir, lwcCacheIndex: new Map() };
     }
     else {
-        const rawIndex = fs.readFileSync(lwcCacheIndexPath, 'utf-8');
-        try {
-            const cacheIndexJson = JSON.parse(rawIndex);
-            return { lwcCacheDir, lwcCacheIndex: new Map(cacheIndexJson) };
-        }
-        catch (err) {
-            const newErr = new Error('Invalid LWC Index: ' + rawIndex);
-            if (err.stack) {
-                newErr.stack += '\nCaused by: ' + err.stack;
-            }
-            throw newErr;
+        const cacheIndexJson = fs.readJSONSync(lwcCacheIndexPath, 'utf-8');
+        return { lwcCacheDir, lwcCacheIndex: new Map(cacheIndexJson) };
+    }
+}
+class IndexPersister {
+    async persist({ lwcCacheIndex, lwcCacheDir }) {
+        // Clear previous timer
+        if (this.updateTimer) {
+            clearTimeout(this.updateTimer);
         }
+        this.lwcCacheIndex = lwcCacheIndex;
+        this.lwcCacheDir = lwcCacheDir;
+        // Set a new timer for 1 second
+        this.updateTimer = setTimeout(() => {
+            this.persistData();
+            this.lwcCacheIndex = undefined;
+            this.lwcCacheDir = undefined;
+            this.updateTimer = undefined;
+        }, 1000);
+    }
+    persistData() {
+        // Write data to disk
+        const lwcCacheIndexPath = path.join(this.lwcCacheDir, DEFAULT_CACHE_INDEX);
+        fs.writeJSONSync(lwcCacheIndexPath, [...this.lwcCacheIndex]);
+        logger.debug('lwc-module-provider', `LWC Index Updated`);
     }
 }
-export function addCompiledModuleCacheEntry(moduleSource, compilerResult, { lwcCacheIndex, lwcCacheDir }) {
+const INDEX_PERSISTER = new IndexPersister();
+let moduleCount = 0;
+export async function addCompiledModuleCacheEntry(moduleSource, compilerResult, { lwcCacheIndex, lwcCacheDir }) {
     const { specifier, version, ownHash } = moduleSource;
-    const lwcCacheIndexPath = path.join(lwcCacheDir, DEFAULT_CACHE_INDEX);
     const cacheKey = `${specifier}@${version}`;
+    if (++moduleCount % 1000 === 0) {
+        logger.debug({ label: `lwc-module-provider`, message: `Compiled Modules >${moduleCount}` });
+    }
     // Normalize name for fs storage
     const normalizedSpecifier = specifier.replace(NORMALIZE_PATH_REGEX, '_');
     const normalizedVersion = version.replace(NORMALIZE_PATH_REGEX, '_');
     // Store module cached file
     const moduleFileName = `${normalizedSpecifier}_${normalizedVersion}.js`;
     const cachedModulePath = path.join(lwcCacheDir, DEFAULT_CACHE_FOLDER, moduleFileName);
-    fs.writeFileSync(cachedModulePath, compilerResult.code);
+    const writeModulePromise = fs.writeFile(cachedModulePath, compilerResult.code);
     // Store module metadata
     const moduleMetaFileName = `${normalizedSpecifier}_${normalizedVersion}.meta.json`;
     const cachedMetaPath = path.join(lwcCacheDir, DEFAULT_CACHE_FOLDER, moduleMetaFileName);
-    fs.writeFileSync(cachedMetaPath, JSON.stringify(compilerResult.metadata, null, '  '));
+    const writeMetadataPromise = fs.writeJSON(cachedMetaPath, compilerResult.metadata);
     // WIP: Store sourcemaps
     // Set new cache key in memory and persistent storage
     lwcCacheIndex.set(cacheKey, {
@@ -54,7 +72,9 @@ export function addCompiledModuleCacheEntry(moduleSource, compilerResult, { lwcC
         module: `./${DEFAULT_CACHE_FOLDER}/${moduleFileName}`,
         moduleMeta: `./${DEFAULT_CACHE_FOLDER}/${moduleMetaFileName}`,
     });
-    fs.writeFileSync(lwcCacheIndexPath, JSON.stringify([...lwcCacheIndex], null, '  '));
+    // Will persist the index after 1 second of inactivity
+    const writeMetadata = INDEX_PERSISTER.persist({ lwcCacheIndex, lwcCacheDir });
+    return Promise.all([writeModulePromise, writeMetadataPromise, writeMetadata]);
 }
 export function getCompiledModuleCacheEntry({ specifier, version, ownHash }, { lwcCacheIndex, lwcCacheDir }) {
     const cacheKey = `${specifier}@${version}`;

package/build/es/index.d.ts

@@ -7,7 +7,6 @@ export default class LwcModuleProvider implements ModuleProvider {
     private rootDir;
     private moduleFsCacheEnabled;
     private interchangeableModulesEnabled;
-    private locker;
     private lwcCacheDir?;
     private lwcCacheIndex?;
     private moduleSourceCache;
@@ -17,10 +16,11 @@ export default class LwcModuleProvider implements ModuleProvider {
     private watcher?;
     private watchedModuleContextMap;
     private moduleEntryVersionCache;
+    private importerMappingCache;
     private lwcCompiler;
     private inflightGetModuleJobs;
     private inflightGetModuleEntryJobs;
-    constructor(options: LwcModuleProviderOptions | undefined, { appEmitter, config: { locker, modules, rootDir, cacheDir, environment }, runtimeEnvironment: { watchFiles }, watcherFactory, }: ProviderContext);
+    constructor(options: LwcModuleProviderOptions | undefined, { appEmitter, config: { modules, rootDir, cacheDir, environment }, runtimeEnvironment: { watchFiles }, watcherFactory, }: ProviderContext);
     onModuleChange(fileChanged: string): Promise<void>;
     getModule(moduleId: AbstractModuleId): Promise<ModuleCompiled | undefined>;
     /**
@@ -32,5 +32,6 @@ export default class LwcModuleProvider implements ModuleProvider {
     getModuleSource({ name, namespace, specifier }: AbstractModuleId, moduleEntry: ModuleEntry): Promise<ModuleSource>;
     getModuleEntry({ specifier, importer, version, }: AbstractModuleId): Promise<ModuleEntry | undefined>;
     createModuleEntry({ specifier, importer, version, }: AbstractModuleId): Promise<ModuleEntry | undefined>;
+    private getCachedModuleEntry;
 }
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -8,18 +8,18 @@ function getModuleEntryCacheKey(specifier, version) {
     return `${specifier}@${version}`;
 }
 export default class LwcModuleProvider {
-    constructor(options = {}, { appEmitter, config: { locker, modules, rootDir, cacheDir, environment }, runtimeEnvironment: { watchFiles }, watcherFactory, }) {
+    constructor(options = {}, { appEmitter, config: { modules, rootDir, cacheDir, environment }, runtimeEnvironment: { watchFiles }, watcherFactory, }) {
         this.name = 'lwc-module-provider';
         this.moduleSourceCache = new Map();
         this.packageVersionCache = new Map();
         this.watchedModuleContextMap = new Map();
         this.moduleEntryVersionCache = new Map();
+        this.importerMappingCache = new Map();
         this.lwcCompiler = new LwcCompiler();
         this.inflightGetModuleJobs = new InflightTasks();
         this.inflightGetModuleEntryJobs = new InflightTasks();
         const { disableCaching } = options;
         this.emitter = appEmitter;
-        this.locker = locker;
         this.modules = modules;
         this.rootDir = rootDir;
         this.watcher =
@@ -77,10 +77,7 @@ export default class LwcModuleProvider {
         logger.debug({
             label: `${this.name}`,
             message: 'module source',
-            additionalInfo: {
-                moduleId,
-                isPreCompiled: compiledModule != undefined,
-            },
+            additionalInfo: { moduleId, isPreCompiled: compiledModule != undefined },
         });
         if (!compiledModule) {
             const [name] = rawName.split('#');
@@ -113,7 +110,7 @@ export default class LwcModuleProvider {
                 },
             });
             if (moduleFsCacheEnabled) {
-                addCompiledModuleCacheEntry(moduleSource, compiledModule, cacheConfig);
+                await addCompiledModuleCacheEntry(moduleSource, compiledModule, cacheConfig);
             }
         }
         if (watcher && !watchedModuleContextMap.has(moduleEntry.entry)) {
@@ -154,15 +151,12 @@ export default class LwcModuleProvider {
             message: `getModuleEntry ${specifier}@${version}@${importer}`,
         });
         // Check cache
-        const versionId = version || importer;
-        if (versionId) {
-            const cacheKey = getModuleEntryCacheKey(specifier, versionId);
-            if (this.moduleEntryVersionCache.has(cacheKey)) {
-                return this.moduleEntryVersionCache.get(cacheKey);
-            }
+        const moduleEntry = this.getCachedModuleEntry(specifier, version, importer);
+        if (moduleEntry) {
+            return moduleEntry;
         }
-        const cacheKey = `${specifier}@${version}@${importer}`;
-        return this.inflightGetModuleEntryJobs.execute(cacheKey, async () => {
+        const jobKey = `${specifier}@${version}@${importer}`;
+        return this.inflightGetModuleEntryJobs.execute(jobKey, async () => {
             return this.createModuleEntry({ specifier, importer, version });
         });
     }
@@ -184,9 +178,8 @@ export default class LwcModuleProvider {
         const fileRelativePath = fileRelativePathRaw?.split('?')[0]; // Remove queryString as LWC uses it for scope style
         let moduleEntry;
         // If this is a relative import, check the cache for the base specifier first
-        if (fileRelativePath && version) {
-            const cacheKey = getModuleEntryCacheKey(specifier, version);
-            moduleEntry = this.moduleEntryVersionCache.get(cacheKey);
+        if (fileRelativePath) {
+            moduleEntry = this.getCachedModuleEntry(specifier, version, importer);
         }
         // Nothing from cache, let's try to resolve it first from lwc then from npm
         if (!moduleEntry) {
@@ -198,7 +191,6 @@ export default class LwcModuleProvider {
                         baseSpecifier,
                         importer,
                         rootDir: this.rootDir,
-                        modules: this.modules,
                     },
                 });
                 const registryEntry = resolveModuleSpecifier(baseSpecifier, importer || this.rootDir, this.modules, this.packageVersionCache);
@@ -250,13 +242,28 @@ export default class LwcModuleProvider {
         const cacheKey = getModuleEntryCacheKey(specifier, moduleEntry.version);
         const finalModuleEntry = { ...moduleEntry, id: cacheKey };
         this.moduleEntryVersionCache.set(cacheKey, finalModuleEntry);
-        if (!version && importer) {
+        if (!version) {
             // if this module is being resolved via importer rather than version,
             // then use the importer as part of the cache key to avoid future cache misses
-            const importerCacheKey = getModuleEntryCacheKey(specifier, importer);
-            this.moduleEntryVersionCache.set(importerCacheKey, finalModuleEntry);
+            const importerCacheKey = getModuleEntryCacheKey(specifier, importer || this.rootDir);
+            this.importerMappingCache.set(importerCacheKey, cacheKey);
         }
         return finalModuleEntry;
     }
+    getCachedModuleEntry(specifier, version, importer) {
+        let moduleEntry;
+        if (version) {
+            const cacheKey = getModuleEntryCacheKey(specifier, version);
+            moduleEntry = this.moduleEntryVersionCache.get(cacheKey);
+        }
+        if (!moduleEntry) {
+            const importerKey = getModuleEntryCacheKey(specifier, importer || this.rootDir);
+            const cacheKey = this.importerMappingCache.get(importerKey);
+            if (cacheKey) {
+                moduleEntry = this.moduleEntryVersionCache.get(cacheKey);
+            }
+        }
+        return moduleEntry;
+    }
 }
 //# sourceMappingURL=index.js.map

package/build/es/utils.js

@@ -9,7 +9,7 @@ export function resolveModuleSpecifier(specifier, importer, modules = [], packag
     logger.debug({
         label: `lwc-module-provider`,
         message: 'resolveModuleSpecifier',
-        additionalInfo: { specifier, importer, modules },
+        additionalInfo: { specifier, importer },
     });
     let resolvedModule;
     try {

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.12.0-alpha.2",
+    "version": "0.12.0-alpha.3",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -31,12 +31,13 @@
     ],
     "dependencies": {
         "@babel/preset-typescript": "^7.23.3",
-        "@lwrjs/diagnostics": "0.12.0-alpha.2",
-        "@lwrjs/fs-watch": "0.12.0-alpha.2",
-        "@lwrjs/shared-utils": "0.12.0-alpha.2"
+        "@lwrjs/diagnostics": "0.12.0-alpha.3",
+        "@lwrjs/fs-watch": "0.12.0-alpha.3",
+        "@lwrjs/shared-utils": "0.12.0-alpha.3",
+        "fs-extra": "^11.1.1"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.12.0-alpha.2",
+        "@lwrjs/types": "0.12.0-alpha.3",
         "typescript": "^4.9.5"
     },
     "peerDependencies": {
@@ -46,5 +47,5 @@
     "engines": {
         "node": ">=18.0.0"
     },
-    "gitHead": "586a2aa659882483af9249dc3db7fe07bc842a25"
+    "gitHead": "48f97b40cbacce6cd6a6faee9206a465832c6774"
 }