eslint-plugin-n 16.6.2 → 17.0.0-0

package/lib/util/import-target.js

@@ -4,98 +4,57 @@
  */
 "use strict"
 
-const path = require("path")
-const { pathToFileURL, fileURLToPath } = require("url")
+require("util").inspect.defaultOptions.depth = null
+
+const { resolve } = require("path")
 const isBuiltin = require("is-builtin-module")
-const resolve = require("resolve")
-const {
-    defaultResolve: importResolve,
-} = require("../converted-esm/import-meta-resolve")
+const resolver = require("enhanced-resolve")
 
-/**
- * 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.
- */
-function getFilePath(isModule, id, options, moduleType) {
-    if (moduleType === "import") {
-        const paths =
-            options.paths && options.paths.length > 0
-                ? options.paths.map(p => path.resolve(process.cwd(), p))
-                : [options.basedir]
-        for (const aPath of paths) {
-            try {
-                const { url } = importResolve(id, {
-                    parentURL: pathToFileURL(path.join(aPath, "dummy-file.mjs"))
-                        .href,
-                    conditions: ["node", "import", "require"],
-                })
-
-                if (url) {
-                    return fileURLToPath(url)
-                }
-            } catch (e) {
-                continue
-            }
-        }
+const isTypescript = require("./is-typescript")
+const { getTSConfigForContext } = require("./get-tsconfig.js")
+const getTypescriptExtensionMap = require("./get-typescript-extension-map")
 
-        if (isModule) {
-            return null
-        }
-        return path.resolve(
-            (options.paths && options.paths[0]) || options.basedir,
-            id
-        )
-    } else {
-        try {
-            return resolve.sync(id, options)
-        } catch (_err) {
-            try {
-                const { url } = importResolve(id, {
-                    parentURL: pathToFileURL(
-                        path.join(options.basedir, "dummy-file.js")
-                    ).href,
-                    conditions: ["node", "require"],
-                })
-
-                return fileURLToPath(url)
-            } catch (err) {
-                if (isModule) {
-                    return null
-                }
-                return path.resolve(options.basedir, id)
-            }
-        }
+function removeTrailWildcard(input) {
+    if (Array.isArray(input)) {
+        return [...input].map(removeTrailWildcard)
     }
+
+    return input.replace(/[/\\*]+$/, "")
 }
 
-function isNodeModule(name, options) {
-    try {
-        return require.resolve(name, options).startsWith(path.sep)
-    } catch {
-        return false
+/**
+ * Initialize this instance.
+ * @param {import('eslint').Rule.RuleContext} context - The context for the import origin.
+ * @returns {import('enhanced-resolve').ResolveOptions['alias'] | undefined}
+ */
+function getTSConfigAliases(context) {
+    const tsConfig = getTSConfigForContext(context)
+
+    const paths = tsConfig?.config?.compilerOptions?.paths
+
+    if (paths == null) {
+        return
     }
+
+    return Object.entries(paths).map(([name, alias]) => ({
+        name: removeTrailWildcard(name),
+        alias: removeTrailWildcard(alias),
+    }))
 }
 
 /**
- * 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.
+ * @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
  */
-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)
 }
 
 /**
@@ -104,17 +63,22 @@ 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.RuleContext} context - The context for the import origin.
+     * @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 `enhanced-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)
+    constructor(context, node, name, options, moduleType) {
+        /**
+         * The context for the import origin
+         * @type {import('eslint').Rule.Node}
+         */
+        this.context = context
 
         /**
          * The node of a `require()` or a module declaraiton.
-         * @type {ASTNode}
+         * @type {import('eslint').Rule.Node}
          */
         this.node = node
 
@@ -125,35 +89,197 @@ 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.filePath = getFilePath(isModule, name, options, moduleType)
+        this.moduleType = this.getModuleType()
+
+        /**
+         * What import style are we using
+         * @type {ModuleStyle}
+         */
+        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 = 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.moduleName = isModule ? getModuleName(name) : null
+        this.filePath = this.getFilePath()
+    }
+
+    /**
+     * 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, "/")
+        }
+    }
+
+    getPaths() {
+        if (Array.isArray(this.options.paths)) {
+            return [...this.options.paths, this.options.basedir]
+        }
+
+        return [this.options.basedir]
+    }
+
+    /**
+     * Resolve the given id to file paths.
+     * @returns {string | null} The resolved path.
+     */
+    getFilePath() {
+        const conditionNames = ["node", "require"]
+        const { extensions } = this.options
+        const mainFields = []
+        const mainFiles = []
+
+        if (this.moduleStyle === "import") {
+            conditionNames.push("import")
+        }
+
+        if (this.moduleStyle === "type") {
+            conditionNames.push("import", "types")
+        }
+
+        if (
+            this.moduleStyle === "require" ||
+            this.moduleType === "npm" ||
+            this.moduleType === "node"
+        ) {
+            mainFields.push("main")
+            mainFiles.push("index")
+        }
+
+        let alias = undefined
+        let extensionAlias = undefined
+
+        if (isTypescript(this.context)) {
+            alias = getTSConfigAliases(this.context)
+            extensionAlias = getTypescriptExtensionMap(this.context).backward
+        }
+
+        const requireResolve = resolver.create.sync({
+            conditionNames,
+            extensions,
+            mainFields,
+            mainFiles,
+
+            extensionAlias,
+            alias,
+        })
+
+        const cwd = this.context.settings?.cwd ?? process.cwd()
+        for (const directory of this.getPaths()) {
+            try {
+                const baseDir = resolve(cwd, directory)
+                return requireResolve(baseDir, this.name)
+            } catch {
+                continue
+            }
+        }
+
+        if (this.moduleType === "absolute" || this.moduleType === "relative") {
+            return resolve(this.options.basedir, this.name)
+        }
+
+        return null
     }
 }

package/lib/util/visit-import.js

@@ -68,7 +68,13 @@ module.exports = function visitImport(
             // Note: "999" arbitrary to check current/future Node.js version
             if (name && (includeCore || !isCoreModule(name, "999"))) {
                 targets.push(
-                    new ImportTarget(sourceNode, name, options, "import")
+                    new ImportTarget(
+                        context,
+                        sourceNode,
+                        name,
+                        options,
+                        "import"
+                    )
                 )
             }
         },

package/lib/util/visit-require.js

@@ -60,7 +60,13 @@ module.exports = function visitRequire(
                 // Note: "999" arbitrary to check current/future Node.js version
                 if (name && (includeCore || !isCoreModule(name, "999"))) {
                     targets.push(
-                        new ImportTarget(targetNode, name, options, "require")
+                        new ImportTarget(
+                            context,
+                            targetNode,
+                            name,
+                            options,
+                            "require"
+                        )
                     )
                 }
             }

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "eslint-plugin-n",
-    "version": "16.6.2",
+    "version": "17.0.0-0",
     "description": "Additional ESLint's rules for Node.js",
     "engines": {
-        "node": ">=16.0.0"
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
     },
     "main": "lib/index.js",
     "files": [
@@ -11,11 +11,11 @@
         "configs/"
     ],
     "peerDependencies": {
-        "eslint": ">=7.0.0"
+        "eslint": ">=8.23.0"
     },
     "dependencies": {
         "@eslint-community/eslint-utils": "^4.4.0",
-        "builtins": "^5.0.1",
+        "enhanced-resolve": "^5.15.0",
         "eslint-plugin-es-x": "^7.5.0",
         "get-tsconfig": "^4.7.0",
         "globals": "^13.24.0",
@@ -23,22 +23,19 @@
         "is-builtin-module": "^3.2.1",
         "is-core-module": "^2.12.1",
         "minimatch": "^3.1.2",
-        "resolve": "^1.22.2",
         "semver": "^7.5.3"
     },
     "devDependencies": {
         "@eslint/js": "^8.43.0",
         "@types/eslint": "^8.44.6",
         "@typescript-eslint/parser": "^5.60.0",
-        "esbuild": "^0.18.7",
-        "eslint": "^8.56.0",
+        "eslint": "^8",
         "eslint-config-prettier": "^8.8.0",
         "eslint-doc-generator": "^1.6.1",
         "eslint-plugin-eslint-plugin": "^5.2.1",
         "eslint-plugin-n": "file:.",
         "fast-glob": "^3.2.12",
         "husky": "^8.0.3",
-        "import-meta-resolve": "^3.0.0",
         "lint-staged": "^13.2.2",
         "markdownlint-cli": "^0.35.0",
         "mocha": "^10.2.0",
@@ -111,5 +108,8 @@
     "lint-staged": {
         "*.js": "eslint --cache --fix",
         "*.{json,js}": "prettier --write --ignore-path .eslintignore"
+    },
+    "imports": {
+        "#eslint-rule-tester": "./tests/eslint-rule-tester.js"
     }
 }