feat(import-target): Add resolution error reason (#264)

Author: aladdin-add

lib/util/check-existence.js

@@ -4,11 +4,7 @@
  */
 "use strict"
 
-const path = require("path")
-const exists = require("./exists")
 const getAllowModules = require("./get-allow-modules")
-const isTypescript = require("./is-typescript")
-const { convertJsExtensionToTs } = require("../util/map-typescript-extension")
 
 /**
  * Reports a missing file from ImportTarget
@@ -17,13 +13,16 @@ const { convertJsExtensionToTs } = require("../util/map-typescript-extension")
  * @returns {void}
  */
 function markMissing(context, target) {
+    // This should never happen... this is just a fallback for typescript
+    target.resolveError ??= `"${target.name}" is not found`
+
     context.report({
         node: target.node,
         loc: /** @type {import('eslint').AST.SourceLocation} */ (
             target.node.loc
         ),
         messageId: "notFound",
-        data: /** @type {Record<string, *>} */ (target),
+        data: { resolveError: target.resolveError },
     })
 }
 
@@ -38,52 +37,20 @@ function markMissing(context, target) {
  * @returns {void}
  */
 exports.checkExistence = function checkExistence(context, targets) {
+    /** @type {Set<string | undefined>} */
     const allowed = new Set(getAllowModules(context))
 
-    target: for (const target of targets) {
-        if (
-            target.moduleName != null &&
-            !allowed.has(target.moduleName) &&
-            target.filePath == null
-        ) {
-            markMissing(context, target)
-            continue
-        }
-
-        if (
-            target.moduleName != null ||
-            target.filePath == null ||
-            exists(target.filePath)
-        ) {
+    for (const target of targets) {
+        if (allowed.has(target.moduleName)) {
             continue
         }
 
-        if (isTypescript(context) === false) {
+        if (target.resolveError != null) {
             markMissing(context, target)
-            continue
         }
-
-        const parsed = path.parse(target.filePath)
-        const pathWithoutExt = path.resolve(parsed.dir, parsed.name)
-
-        const reversedExtensions = convertJsExtensionToTs(
-            context,
-            target.filePath,
-            parsed.ext
-        )
-
-        for (const reversedExtension of reversedExtensions) {
-            const reversedPath = pathWithoutExt + reversedExtension
-
-            if (exists(reversedPath)) {
-                continue target
-            }
-        }
-
-        markMissing(context, target)
     }
 }
 
 exports.messages = {
-    notFound: '"{{name}}" is not found.',
+    notFound: "{{resolveError}}",
 }

lib/util/import-target.js

@@ -131,6 +131,12 @@ module.exports = class ImportTarget {
          */
         this.moduleName = this.getModuleName()
 
+        /**
+         * This is the full resolution failure reasons
+         * @type {string | null}
+         */
+        this.resolveError = null
+
         /**
          * The full path of this import target.
          * If the target is a module and it does not exist then this is `null`.
@@ -239,6 +245,19 @@ module.exports = class ImportTarget {
         return [this.options.basedir]
     }
 
+    /**
+     * @param {string} baseDir
+     * @param {unknown} error
+     * @returns {void}
+     */
+    handleResolutionError(baseDir, error) {
+        if (error instanceof Error === false) {
+            throw error
+        }
+
+        this.resolveError = error.message
+    }
+
     /**
      * Resolve the given id to file paths.
      * @returns {string | null} The resolved path.
@@ -274,24 +293,28 @@ module.exports = class ImportTarget {
             extensionAlias = getTypescriptExtensionMap(this.context).backward
         }
 
-        const requireResolve = resolver.create.sync({
+        /** @type {import('enhanced-resolve').ResolveOptionsOptionalFS} */
+        this.resolverConfig = {
             conditionNames,
             extensions,
             mainFields,
             mainFiles,
 
             extensionAlias,
             alias,
-        })
+        }
+
+        const requireResolve = resolver.create.sync(this.resolverConfig)
 
         const cwd = this.context.settings?.cwd ?? process.cwd()
         for (const directory of this.getPaths()) {
+            const baseDir = resolve(cwd, directory)
+
             try {
-                const baseDir = resolve(cwd, directory)
                 const resolved = requireResolve(baseDir, this.name)
                 if (typeof resolved === "string") return resolved
-            } catch {
-                continue
+            } catch (error) {
+                this.handleResolutionError(baseDir, error)
             }
         }