fix: Add cache for matchers by digets of options, not cwd path

Author: romanlex

.gitignore

@@ -3,3 +3,4 @@
 dist
 node_modules
 *.log
+.vscode

src/index.ts

@@ -4,17 +4,18 @@ import { CachedInputFileSystem, ResolverFactory } from 'enhanced-resolve'
 
 import { defaultConditionNames, defaultExtensionAlias, defaultExtensions, defaultMainFields } from './default'
 import { digestHashObject } from './helpers'
+import { init } from './init'
 import { logger } from './logger'
 import { resolveImport } from './resolveImport'
 
-import type { InternalResolverOptions, ResolvedResult, ResolverOptions } from './types'
+import type { InternalResolverOptions, Matcher, ResolvedResult, ResolverOptions } from './types'
 import type { Resolver } from 'enhanced-resolve'
 
 const times = []
 
 let cachedOptions: InternalResolverOptions
-let previousOptionsHash: ReturnType<typeof digestHashObject>
-let optionsHash: ReturnType<typeof digestHashObject>
+let previousOptionsHash: ReturnType<typeof digestHashObject> | undefined
+let optionsHash: ReturnType<typeof digestHashObject> | undefined
 let resolverCachedOptions: InternalResolverOptions
 let resolver: Resolver | undefined
 
@@ -25,7 +26,7 @@ export const interfaceVersion = 2
  * @param file the importing file's full path; i.e. '/usr/local/bin/file.js'
  * @param options
  */
-export function resolve(specifier: string, file: string, options?: ResolverOptions | undefined | null): ResolvedResult {
+export function resolve(specifier: string, file: string, options?: ResolverOptions): ResolvedResult {
   let t0: DOMHighResTimeStamp = 0
 
   if (options?.performanceToLog) t0 = performance.now()
@@ -43,12 +44,14 @@ export function resolve(specifier: string, file: string, options?: ResolverOptio
     }
   }
 
+  const matchers: Matcher[] = init(options ?? {}, optionsHash ?? digestHashObject(options))
+
   if (!resolver || resolverCachedOptions !== cachedOptions) {
     resolver = ResolverFactory.createResolver(cachedOptions)
     resolverCachedOptions = cachedOptions
   }
 
-  const result = resolveImport(specifier, file, cachedOptions, resolver)
+  const result = resolveImport(matchers, specifier, file, cachedOptions, resolver)
 
   if (options?.performanceToLog) {
     const t1 = performance.now()
@@ -60,15 +63,21 @@ export function resolve(specifier: string, file: string, options?: ResolverOptio
 }
 
 export function createImportResolver(options: ResolverOptions) {
-  const resolver = ResolverFactory.createResolver({
-    ...options,
-    conditionNames: options?.conditionNames ?? defaultConditionNames,
-    extensions: options?.extensions ?? defaultExtensions,
-    extensionAlias: options?.extensionAlias ?? defaultExtensionAlias,
-    mainFields: options?.mainFields ?? defaultMainFields,
-    fileSystem: new CachedInputFileSystem(fs, 5 * 1000),
-    useSyncFileSystemCalls: true,
-  })
+  if (!cachedOptions || previousOptionsHash !== (optionsHash = digestHashObject(options))) {
+    previousOptionsHash = optionsHash
+    cachedOptions = {
+      ...options,
+      conditionNames: options?.conditionNames ?? defaultConditionNames,
+      extensions: options?.extensions ?? defaultExtensions,
+      extensionAlias: options?.extensionAlias ?? defaultExtensionAlias,
+      mainFields: options?.mainFields ?? defaultMainFields,
+      fileSystem: new CachedInputFileSystem(fs, 5 * 1000),
+      useSyncFileSystemCalls: true,
+    }
+  }
+
+  const matchers: Matcher[] = init(options, optionsHash ?? digestHashObject(options))
+  const resolver = ResolverFactory.createResolver(cachedOptions)
 
   return {
     name: 'eslint-import-resolver-x',
@@ -78,7 +87,7 @@ export function createImportResolver(options: ResolverOptions) {
 
       if (options?.performanceToLog) t0 = performance.now()
 
-      const result = resolveImport(modulePath, source, cachedOptions, resolver)
+      const result = resolveImport(matchers, modulePath, source, cachedOptions, resolver)
 
       if (options?.performanceToLog) {
         const t1 = performance.now()

src/init.ts

@@ -7,24 +7,26 @@ import isGlob from 'is-glob'
 import { isFile } from './helpers'
 import { logger } from './logger'
 
-import type { InternalResolverOptions, Matcher } from './types'
+import type { ResolverOptions, Matcher } from './types'
 
-// Vscode change cwd
-const cwdMappersMap: Map<string, Matcher[]> = new Map()
+const matchersMap: Map<string, Matcher[]> = new Map()
 
 /**
  * Initialize the resolver with the given options
  * @param options internal resolver options
- * @returns matchers for current cwd
+ * @returns matchers for options
  */
-export function init(options: InternalResolverOptions): Matcher[] {
-  let matchers: Matcher[] | undefined = cwdMappersMap.get(process.cwd())
+export function init(options: ResolverOptions, digestOfOptions: string): Matcher[] {
+  const matchersByDigets: Matcher[] | undefined = matchersMap.get(digestOfOptions)
 
-  if (matchers) {
-    return matchers
+  logger('[INIT] Digest of options: ', digestOfOptions)
+
+  if (matchersByDigets) {
+    logger('[INIT] Use matchers from cache by digest')
+    return matchersByDigets
   }
 
-  logger('[MAPPER] Init mapper for current cwd', process.cwd())
+  logger('[INIT] Create matchers for current options: ', options)
 
   const configPaths =
     typeof options.project === 'string'
@@ -35,8 +37,6 @@ export function init(options: InternalResolverOptions): Matcher[] {
 
   const ignore = ['!**/node_modules/**']
 
-  logger('[MAPPER] options.project:', configPaths)
-
   // turn glob patterns into paths
   const projectPaths = [
     ...new Set([
@@ -47,9 +47,9 @@ export function init(options: InternalResolverOptions): Matcher[] {
     ]),
   ]
 
-  logger('[MAPPER] config paths of projects:', projectPaths)
+  const matchers: Matcher[] = []
 
-  matchers = []
+  logger('[INIT] config paths of projects:', projectPaths)
 
   for (let i = 0; i < projectPaths.length; i++) {
     let tsconfigResult = null
@@ -71,9 +71,9 @@ export function init(options: InternalResolverOptions): Matcher[] {
     }
   }
 
-  logger('[MAPPER] created matchers:', matchers)
+  logger('[INIT] created matchers:', matchers)
 
-  cwdMappersMap.set(process.cwd(), matchers)
+  matchersMap.set(digestOfOptions, matchers)
 
   return matchers
 }

src/resolveImport.ts

@@ -8,7 +8,6 @@ import { isBunModule } from 'is-bun-module'
 import { JS_EXT_PATTERN, RELATIVE_PATH_PATTERN } from './constants'
 import { defaultExtensions } from './default'
 import { isFile, isModule, removeQuerystring } from './helpers'
-import { init } from './init'
 import { logger } from './logger'
 
 import type { InternalResolverOptions, Matcher, ResolvedResult } from './types'
@@ -21,13 +20,15 @@ const possiblePathsBySpecifier: Map<string, { paths: string[]; path: TsConfigRes
 
 /**
  * Resolve an import specifier to a path
+ * @param {Matcher[]} matchers matchers by digest of options
  * @param {string} specifier specifier of import to resolve
  * @param {string} file path of the file importing the specifier
  * @param {InternalResolverOptions} options options for the resolver
  * @param {Resolver} resolver resolver to use for resolving
  * @returns {ResolvedResult} whether the import was found and the resolved path
  */
 export function resolveImport(
+  matchers: Matcher[],
   specifier: string,
   file: string,
   options: InternalResolverOptions,
@@ -46,9 +47,7 @@ export function resolveImport(
     }
   }
 
-  const currentMatchersOfCwd = init(options)
-
-  const mappedPath = getMappedPath(currentMatchersOfCwd, specifier, file, options.extensions)
+  const mappedPath = getMappedPath(matchers, specifier, file, options.extensions)
 
   if (mappedPath) {
     logger('matched ts path:', mappedPath)
@@ -70,7 +69,13 @@ export function resolveImport(
     !path.isAbsolute(specifier) &&
     !specifier.startsWith('.')
   ) {
-    const definitelyTyped = resolveImport('@types' + path.sep + mangleScopedPackage(specifier), file, options, resolver)
+    const definitelyTyped = resolveImport(
+      matchers,
+      '@types' + path.sep + mangleScopedPackage(specifier),
+      file,
+      options,
+      resolver
+    )
     if (definitelyTyped.found) {
       return definitelyTyped
     }
@@ -109,13 +114,14 @@ function mangleScopedPackage(moduleName: string): string {
 
 /**
  * Get the mapped path for a given import specifier
+ * @param {Matcher[]} matchers matchers by digest of options
  * @param {string} specifier specifier of import to resolve
  * @param {string} file path of the file importing the specifier
  * @param {string[]} extensions extensions to try
  * @returns mapped path if found, undefined otherwise
  */
 function getMappedPath(
-  currentMatchersOfCwd: Matcher[],
+  matchers: Matcher[],
   specifier: string,
   file: string,
   extensions = defaultExtensions
@@ -146,17 +152,17 @@ function getMappedPath(
     logger('project config by file path:', projectConfig?.path)
   }
 
-  const closestMapper = currentMatchersOfCwd?.find((mapper) => {
-    return mapper.path === projectConfig?.path
+  const closestMatcher = matchers?.find((matcher) => {
+    return matcher.path === projectConfig?.path
   })
 
-  if (closestMapper) {
-    logger('found closest mapper by config path:', closestMapper.path)
+  if (closestMatcher) {
+    logger('found closest matcher by config path:', closestMatcher.path)
   }
 
-  const matcherResult = closestMapper
-    ? closestMapper.matcher(specifier)
-    : currentMatchersOfCwd.map((mapper) => mapper?.matcher(specifier)).flat()
+  const matcherResult = closestMatcher
+    ? closestMatcher.matcher(specifier)
+    : matchers.map((mapper) => mapper?.matcher(specifier)).flat()
 
   const matcherPaths = matcherResult
     .map((item) => [
@@ -169,7 +175,7 @@ function getMappedPath(
 
   const possiblePaths = possiblePathsBySpecifier.get(specifier)
 
-  if (possiblePaths && possiblePaths.path === closestMapper?.path) {
+  if (possiblePaths && possiblePaths.path === closestMatcher?.path) {
     logger(
       `found matching paths from cache by specifier ${specifier} and config ${possiblePaths.path} path:`,
       possiblePaths.paths
@@ -192,8 +198,8 @@ function getMappedPath(
     return false
   })
 
-  if (closestMapper) {
-    possiblePathsBySpecifier.set(specifier, { paths, path: closestMapper.path })
+  if (closestMatcher) {
+    possiblePathsBySpecifier.set(specifier, { paths, path: closestMatcher.path })
   }
 
   if (paths.length > 1) {