feat(resolve): implements import-x/resolver-next

Author: SukkaW

src/types.ts

@@ -7,6 +7,8 @@ import type { ImportType as ImportType_, PluginName } from './utils'
 import type { LegacyImportResolver, LegacyResolver } from './utils/legacy-resolver-settings'
 
 export type {
+  LegacyResolver,
+
   LegacyResolverName,
   LegacyResolverName as ResolverName,
 
@@ -47,6 +49,20 @@ export type TsResolverOptions = {
   extensions?: string[]
 } & Omit<ResolveOptions, 'fileSystem' | 'useSyncFileSystemCalls'>
 
+// TODO: remove prefix New in the next major version
+export type NewResolverResolve = (
+  modulePath: string,
+  sourceFile: string,
+) => ResolvedResult
+
+// TODO: remove prefix New in the next major version
+export type NewResolver = {
+  interfaceVersion: 3,
+  /** optional name for the resolver, this is used in logs/debug output */
+  name?: string,
+  resolve: NewResolverResolve,
+}
+
 export type FileExtension = `.${string}`
 
 export type DocStyle = 'jsdoc' | 'tomdoc'
@@ -63,7 +79,7 @@ export type ResultFound = {
   path: string | null
 }
 
-export type Resolver = LegacyResolver
+export type Resolver = LegacyResolver | NewResolver
 
 export type ResolvedResult = ResultNotFound | ResultFound
 
@@ -80,6 +96,7 @@ export type ImportSettings = {
   parsers?: Record<string, readonly FileExtension[]>
   resolve?: NodeResolverOptions
   resolver?: LegacyImportResolver
+  'resolver-next'?: NewResolver[]
 }
 
 export type WithPluginName<T extends string | object> = T extends string

src/utils/legacy-resolver-settings.ts

@@ -64,6 +64,29 @@ export type LegacyImportResolver =
   | LegacyResolverRecord[]
   | LegacyResolverObject[];
 
+export function resolveWithLegacyResolver(resolver: LegacyResolver, config: unknown, modulePath: string, sourceFile: string): ResolvedResult {
+  if (resolver.interfaceVersion === 2) {
+    return resolver.resolve(modulePath, sourceFile, config)
+  }
+
+  try {
+    const resolved = resolver.resolveImport(modulePath, sourceFile, config)
+    if (resolved === undefined) {
+      return {
+        found: false,
+      }
+    }
+    return {
+      found: true,
+      path: resolved,
+    }
+  } catch {
+    return {
+      found: false,
+    }
+  }
+}
+
 export function normalizeConfigResolvers(
   resolvers: LegacyImportResolver,
   sourceFile: string,

src/utils/resolve.ts

@@ -8,11 +8,12 @@ import type {
   PluginSettings,
   RuleContext,
   Resolver,
+  LegacyResolver,
   ResolvedResult,
 } from '../types'
 
 import { ModuleCache } from './module-cache'
-import { normalizeConfigResolvers } from './legacy-resolver-settings'
+import { normalizeConfigResolvers, resolveWithLegacyResolver } from './legacy-resolver-settings'
 
 export const CASE_SENSITIVE_FS = !fs.existsSync(
   path.resolve(
@@ -98,49 +99,38 @@ function fullResolve(
     return { found: true, path: cachedPath }
   }
 
-  function withResolver(resolver: Resolver, config: unknown): ResolvedResult {
-    if (resolver.interfaceVersion === 2) {
-      return resolver.resolve(modulePath, sourceFile, config)
-    }
+  if (Object.prototype.hasOwnProperty.call(settings, 'import-x/resolver-next') && settings['import-x/resolver-next']) {
+    const configResolvers = settings['import-x/resolver-next']
 
-    try {
-      const resolved = resolver.resolveImport(modulePath, sourceFile, config)
-      if (resolved === undefined) {
-        return {
-          found: false,
-        }
-      }
-      return {
-        found: true,
-        path: resolved,
-      }
-    } catch {
-      return {
-        found: false,
+    for (const resolver of configResolvers) {
+      const resolved = resolver.resolve(modulePath, sourceFile)
+      if (!resolved.found) {
+        continue
       }
-    }
-  }
-
-  const configResolvers = settings['import-x/resolver'] || {
-    node: settings['import-x/resolve'],
-  } // backward compatibility
 
-  const resolvers = normalizeConfigResolvers(configResolvers, sourceFile)
-
-  for (const { enable, options, resolver } of resolvers) {
-    if (!enable) {
-      continue
+      // else, counts
+      fileExistsCache.set(cacheKey, resolved.path as string | null)
+      return resolved
     }
+  } else {
+    const configResolvers = settings['import-x/resolver'] || {
+      node: settings['import-x/resolve'],
+    } // backward compatibility
+
+    for (const { enable, options, resolver } of normalizeConfigResolvers(configResolvers, sourceFile)) {
+      if (!enable) {
+        continue
+      }
 
-    const resolved = withResolver(resolver, options)
+      const resolved = resolveWithLegacyResolver(resolver, options, modulePath, sourceFile)
+      if (!resolved.found) {
+        continue
+      }
 
-    if (!resolved.found) {
-      continue
+      // else, counts
+      fileExistsCache.set(cacheKey, resolved.path as string | null)
+      return resolved
     }
-
-    // else, counts
-    fileExistsCache.set(cacheKey, resolved.path as string | null)
-    return resolved
   }
 
   // failed