chore: Improve the metadata from "ImportTarget"

Author: scagood

lib/util/check-existence.js

@@ -17,7 +17,7 @@ const mapTypescriptExtension = require("../util/map-typescript-extension")
  * See Also: https://nodejs.org/api/modules.html
  *
  * @param {RuleContext} context - A context to report.
- * @param {ImportTarget[]} targets - A list of target information to check.
+ * @param {import('../util/import-target.js')[]} targets - A list of target information to check.
  * @returns {void}
  */
 exports.checkExistence = function checkExistence(context, targets) {

lib/util/check-publish.js

@@ -59,7 +59,7 @@ exports.checkPublish = function checkPublish(context, filePath, targets) {
                 if (target.moduleName != null) {
                     return false
                 }
-                const relativeTargetPath = toRelative(target.filePath)
+                const relativeTargetPath = toRelative(target.filePath ?? "")
                 return (
                     relativeTargetPath !== "" &&
                     npmignore.match(relativeTargetPath)
@@ -70,6 +70,7 @@ exports.checkPublish = function checkPublish(context, filePath, targets) {
                 devDependencies.has(target.moduleName) &&
                 !dependencies.has(target.moduleName) &&
                 !allowed.has(target.moduleName)
+
             if (isPrivateFile() || isDevPackage()) {
                 context.report({
                     node: target.node,

lib/util/exists.js

@@ -38,6 +38,10 @@ function existsCaseSensitive(filePath) {
  * @returns {boolean} `true` if the file of a given path exists.
  */
 module.exports = function exists(filePath) {
+    if (filePath == null) {
+        return false
+    }
+
     let result = cache.get(filePath)
     if (result == null) {
         try {

lib/util/import-target.js

@@ -4,30 +4,44 @@
  */
 "use strict"
 
-const { resolve, sep } = require("path")
+const { resolve } = require("path")
 const isBuiltin = require("is-builtin-module")
 const resolver = require("enhanced-resolve")
 
+/**
+ * @typedef {Object} Options
+ * @property {string[]} [extensions]
+ * @property {string[]} [paths]
+ * @property {string} basedir
+ */
+/**
+ * @typedef { 'unknown' | 'relative' | 'absolute' | 'node' | 'npm' | 'http' } ModuleType
+ * @typedef { 'import' | 'require' | 'type' } ModuleStyle
+ */
+
 /**
  * Resolve the given id to file paths.
- * @param {boolean} isModule The flag which indicates this id is a module.
  * @param {string} id The id to resolve.
- * @param {object} options The options of node-resolve module.
- * It requires `options.basedir`.
- * @param {'import' | 'require'} moduleType - whether the target was require-ed or imported
- * @returns {string|null} The resolved path.
+ * @param {Options} options The options of node-resolve module.
+ * @param {ModuleType} moduleType - whether the target was require-ed or imported
+ * @param {ModuleStyle} moduleStyle - whether the target was require-ed or imported
+ * @returns {string | null} The resolved path.
  */
-function getFilePath(isModule, id, options, moduleType) {
+function getFilePath(id, options, moduleType, moduleStyle) {
     const conditionNames = ["node", "require"]
     const { extensions } = options
     const mainFields = []
     const mainFiles = []
 
-    if (moduleType === "import") {
+    if (moduleStyle === "import") {
         conditionNames.push("import")
     }
 
-    if (moduleType === "require" || isModule === true) {
+    if (moduleStyle === "type") {
+        conditionNames.push("import", "types")
+    }
+
+    if (moduleStyle === "require" || moduleType === "npm") {
         mainFields.push("main")
         mainFiles.push("index")
     }
@@ -52,36 +66,15 @@ function getFilePath(isModule, id, options, moduleType) {
         }
     }
 
-    if (isModule) {
-        return null
+    if (moduleType === "absolute" || moduleType === "relative") {
+        return resolve(options.basedir, id)
     }
 
-    return resolve(options.basedir, id)
+    return null
 }
 
-function isNodeModule(name, options) {
-    try {
-        return require.resolve(name, options).startsWith(sep)
-    } catch {
-        return false
-    }
-}
-
-/**
- * Gets the module name of a given path.
- *
- * e.g. `eslint/lib/ast-utils` -> `eslint`
- *
- * @param {string} nameOrPath - A path to get.
- * @returns {string} The module name of the path.
- */
-function getModuleName(nameOrPath) {
-    let end = nameOrPath.indexOf("/")
-    if (end !== -1 && nameOrPath[0] === "@") {
-        end = nameOrPath.indexOf("/", 1 + end)
-    }
-
-    return end === -1 ? nameOrPath : nameOrPath.slice(0, end)
+function trimAfter(string, matcher, count = 1) {
+    return string.split(matcher).slice(0, count).join(matcher)
 }
 
 /**
@@ -90,17 +83,15 @@ function getModuleName(nameOrPath) {
 module.exports = class ImportTarget {
     /**
      * Initialize this instance.
-     * @param {ASTNode} node - The node of a `require()` or a module declaraiton.
+     * @param {import('eslint').Rule.Node} node - The node of a `require()` or a module declaraiton.
      * @param {string} name - The name of an import target.
-     * @param {object} options - The options of `node-resolve` module.
+     * @param {Options} options - The options of `node-resolve` module.
      * @param {'import' | 'require'} moduleType - whether the target was require-ed or imported
      */
     constructor(node, name, options, moduleType) {
-        const isModule = !/^(?:[./\\]|\w+:)/u.test(name)
-
         /**
          * The node of a `require()` or a module declaraiton.
-         * @type {ASTNode}
+         * @type {import('eslint').Rule.Node}
          */
         this.node = node
 
@@ -111,35 +102,132 @@ module.exports = class ImportTarget {
         this.name = name
 
         /**
-         * What type of module is this
-         * @type {'unknown'|'relative'|'absolute'|'node'|'npm'|'http'|void}
+         * The import target options.
+         * @type {Options}
          */
-        this.moduleType = "unknown"
-
-        if (name.startsWith("./") || name.startsWith(".\\")) {
-            this.moduleType = "relative"
-        } else if (name.startsWith("/") || name.startsWith("\\")) {
-            this.moduleType = "absolute"
-        } else if (isBuiltin(name)) {
-            this.moduleType = "node"
-        } else if (isNodeModule(name, options)) {
-            this.moduleType = "npm"
-        } else if (name.startsWith("http://") || name.startsWith("https://")) {
-            this.moduleType = "http"
-        }
+        this.options = options
 
         /**
-         * The full path of this import target.
-         * If the target is a module and it does not exist then this is `null`.
-         * @type {string|null}
+         * What type of module are we looking for?
+         * @type {ModuleType}
+         */
+        this.moduleType = this.getModuleType()
+
+        /**
+         * What import style are we using
+         * @type {ModuleStyle}
          */
-        this.filePath = getFilePath(isModule, name, options, moduleType)
+        this.moduleStyle = this.getModuleStyle(moduleType)
 
         /**
          * The module name of this import target.
          * If the target is a relative path then this is `null`.
-         * @type {string|null}
+         * @type {string | null}
          */
-        this.moduleName = isModule ? getModuleName(name) : null
+        this.moduleName = this.getModuleName()
+
+        /**
+         * The full path of this import target.
+         * If the target is a module and it does not exist then this is `null`.
+         * @type {string | null}
+         */
+        this.filePath = getFilePath(
+            name,
+            options,
+            this.moduleType,
+            this.moduleStyle
+        )
+    }
+
+    /**
+     * What type of module is this
+     * @returns {ModuleType}
+     */
+    getModuleType() {
+        if (/^\.{1,2}([\\/]|$)/.test(this.name)) {
+            return "relative"
+        }
+
+        if (/^[\\/]/.test(this.name)) {
+            return "absolute"
+        }
+
+        if (isBuiltin(this.name)) {
+            return "node"
+        }
+
+        if (/^(@[\w~-][\w.~-]*\/)?[\w~-][\w.~-]*/.test(this.name)) {
+            return "npm"
+        }
+
+        if (/^https?:\/\//.test(this.name)) {
+            return "http"
+        }
+
+        return "unknown"
+    }
+
+    /**
+     * What module import style is used
+     * @param {'import' | 'require'} fallback
+     * @returns {ModuleStyle}
+     */
+    getModuleStyle(fallback) {
+        /** @type {import('eslint').Rule.Node} */
+        let node = { parent: this.node }
+
+        do {
+            node = node.parent
+
+            // `const {} = require('')`
+            if (
+                node.type === "CallExpression" &&
+                node.callee.name === "require"
+            ) {
+                return "require"
+            }
+
+            // `import type {} from '';`
+            if (
+                node.type === "ImportDeclaration" &&
+                node.importKind === "type"
+            ) {
+                return "type"
+            }
+
+            // `import {} from '';`
+            if (
+                node.type === "ImportDeclaration" &&
+                node.importKind === "value"
+            ) {
+                return "import"
+            }
+        } while (node.parent)
+
+        return fallback
+    }
+
+    /**
+     * Get the node or npm module name
+     * @returns {string}
+     */
+    getModuleName() {
+        if (this.moduleType === "relative") return
+
+        if (this.moduleType === "npm") {
+            if (this.name.startsWith("@")) {
+                return trimAfter(this.name, "/", 2)
+            }
+
+            return trimAfter(this.name, "/")
+        }
+
+        if (this.moduleType === "node") {
+            if (this.name.startsWith("node:")) {
+                return trimAfter(this.name.slice(5), "/")
+            }
+
+            return trimAfter(this.name, "/")
+        }
     }
 }