eslint-plugin-n 17.23.1 → 17.24.0

package/README.md

@@ -165,9 +165,11 @@ For [Shareable Configs](https://eslint.org/docs/latest/developer-guide/shareable
 | [no-unsupported-features/node-builtins](docs/rules/no-unsupported-features/node-builtins.md) | disallow unsupported Node.js built-in APIs on the specified version         | 🟢 ✅ |    |    |
 | [prefer-global/buffer](docs/rules/prefer-global/buffer.md)                                   | enforce either `Buffer` or `require("buffer").Buffer`                       |      |    |    |
 | [prefer-global/console](docs/rules/prefer-global/console.md)                                 | enforce either `console` or `require("console")`                            |      |    |    |
+| [prefer-global/crypto](docs/rules/prefer-global/crypto.md)                                   | enforce either `crypto` or `require("crypto").webcrypto`                    |      |    |    |
 | [prefer-global/process](docs/rules/prefer-global/process.md)                                 | enforce either `process` or `require("process")`                            |      |    |    |
 | [prefer-global/text-decoder](docs/rules/prefer-global/text-decoder.md)                       | enforce either `TextDecoder` or `require("util").TextDecoder`               |      |    |    |
 | [prefer-global/text-encoder](docs/rules/prefer-global/text-encoder.md)                       | enforce either `TextEncoder` or `require("util").TextEncoder`               |      |    |    |
+| [prefer-global/timers](docs/rules/prefer-global/timers.md)                                   | enforce either global timer functions or `require("timers")`                |      |    |    |
 | [prefer-global/url](docs/rules/prefer-global/url.md)                                         | enforce either `URL` or `require("url").URL`                                |      |    |    |
 | [prefer-global/url-search-params](docs/rules/prefer-global/url-search-params.md)             | enforce either `URLSearchParams` or `require("url").URLSearchParams`        |      |    |    |
 | [prefer-node-protocol](docs/rules/prefer-node-protocol.md)                                   | enforce using the `node:` protocol when importing Node.js builtin modules.  |      | 🔧 |    |

package/lib/all-rules.js

@@ -38,11 +38,13 @@ module.exports = {
     "no-unsupported-features/node-builtins": require("./rules/no-unsupported-features/node-builtins"),
     "prefer-global/buffer": require("./rules/prefer-global/buffer"),
     "prefer-global/console": require("./rules/prefer-global/console"),
+    "prefer-global/crypto": require("./rules/prefer-global/crypto"),
     "prefer-global/process": require("./rules/prefer-global/process"),
     "prefer-global/text-decoder": require("./rules/prefer-global/text-decoder"),
     "prefer-global/text-encoder": require("./rules/prefer-global/text-encoder"),
     "prefer-global/url-search-params": require("./rules/prefer-global/url-search-params"),
     "prefer-global/url": require("./rules/prefer-global/url"),
+    "prefer-global/timers": require("./rules/prefer-global/timers"),
     "prefer-node-protocol": require("./rules/prefer-node-protocol"),
     "prefer-promises/dns": require("./rules/prefer-promises/dns"),
     "prefer-promises/fs": require("./rules/prefer-promises/fs"),

package/lib/rules/file-extension-in-import.js

@@ -7,17 +7,21 @@
 const path = require("path")
 const fs = require("fs")
 const { convertTsExtensionToJs } = require("../util/map-typescript-extension")
+const getTryExtensions = require("../util/get-try-extensions")
 const visitImport = require("../util/visit-import")
 
 /**
  * Get all file extensions of the files which have the same basename.
  * @param {string} filePath The path to the original file to check.
+ * @param {string} [basename] Optional basename to use instead of deriving from filePath.
  * @returns {string[]} File extensions.
  */
-function getExistingExtensions(filePath) {
+function getExistingExtensions(filePath, basename) {
     const directory = path.dirname(filePath)
-    const extension = path.extname(filePath)
-    const basename = path.basename(filePath, extension)
+    if (basename == null) {
+        const extension = path.extname(filePath)
+        basename = path.basename(filePath, extension)
+    }
 
     try {
         return fs
@@ -29,6 +33,34 @@ function getExistingExtensions(filePath) {
     }
 }
 
+/**
+ * Get the extension of an index file in the given directory.
+ * @param {string} directoryPath The directory path to check.
+ * @param {string[]} tryExtensions Ordered extension preferences.
+ * @returns {string | null} The index file extension or null if none.
+ */
+function getIndexExtension(directoryPath, tryExtensions) {
+    try {
+        if (fs.statSync(directoryPath).isDirectory() === false) {
+            return null
+        }
+    } catch {
+        return null
+    }
+
+    const existing = getExistingExtensions(path.join(directoryPath, "index"))
+    if (existing.length === 0) {
+        return null
+    }
+
+    const preferred = tryExtensions.find(ext => existing.includes(ext))
+    if (preferred) {
+        return preferred
+    }
+
+    return existing[0] || null
+}
+
 /**
  * @typedef {[
  *   ("always" | "never")?,
@@ -69,6 +101,7 @@ module.exports = {
         }
         const defaultStyle = context.options[0] || "always"
         const overrideStyle = context.options[1] || {}
+        const tryExtensions = getTryExtensions(context, 1)
 
         /**
          * @param {import("../util/import-target.js")} target
@@ -85,15 +118,74 @@ module.exports = {
 
             // Get extension.
             const currentExt = path.extname(name)
-            const actualExt = path.extname(filePath)
+            let actualExt = path.extname(filePath)
+            let actualFilePath = filePath
+
+            // If the file doesn't exist (or is a directory), the resolver may have returned
+            // a fallback path. In this case, path.extname may return a "fake" extension
+            // (e.g., ".client" for "utils.client" when the actual file is "utils.client.ts").
+            // We need to search for the actual file using the full basename from the import.
+            const fileExists =
+                fs.existsSync(filePath) && fs.statSync(filePath).isFile()
+            if (actualExt !== "" && !fileExists) {
+                // Use the full basename (e.g., "utils.client") since what path.extname
+                // thinks is an extension (e.g., ".client") may not be a real file extension
+                const importBasename = path.basename(name)
+                const extensions = getExistingExtensions(
+                    filePath,
+                    importBasename
+                )
+                // Find the preferred extension based on tryExtensions order
+                const preferred = tryExtensions.find(ext =>
+                    extensions.includes(ext)
+                )
+                const foundExt = preferred ?? extensions[0]
+                if (foundExt) {
+                    actualExt = foundExt
+                    actualFilePath = path.join(
+                        path.dirname(filePath),
+                        `${importBasename}${actualExt}`
+                    )
+                }
+            }
+
+            let isDirectoryImport = false
+
+            // Check for directory imports. This handles both:
+            // 1. Normal case: "./my-folder" -> "./my-folder/index.js"
+            // 2. Dot-in-name case: "./my-things.client" -> "./my-things.client/index.js"
+            //    where path.extname incorrectly sees ".client" as an extension
+            const isDirectory =
+                fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()
+            if (isDirectory) {
+                const indexExt = getIndexExtension(filePath, tryExtensions)
+                if (indexExt) {
+                    isDirectoryImport = true
+                    actualExt = indexExt
+                    actualFilePath = path.join(filePath, `index${indexExt}`)
+                }
+            }
+
             const style = overrideStyle[actualExt] || defaultStyle
 
-            const expectedExt = convertTsExtensionToJs(
+            let expectedExt = convertTsExtensionToJs(
                 context,
-                filePath,
+                actualFilePath,
                 actualExt
             )
 
+            if (currentExt === "" && actualExt === "" && !isDirectoryImport) {
+                const indexExt = getIndexExtension(filePath, tryExtensions)
+                if (indexExt) {
+                    isDirectoryImport = true
+                    expectedExt = convertTsExtensionToJs(
+                        context,
+                        path.join(filePath, `index${indexExt}`),
+                        indexExt
+                    )
+                }
+            }
+
             // Verify.
             if (style === "always" && currentExt !== expectedExt) {
                 context.report({
@@ -106,6 +198,13 @@ module.exports = {
                         }
 
                         const index = node.range[1] - 1
+                        if (isDirectoryImport) {
+                            const needsSlash = /[/\\]$/.test(name) ? "" : "/"
+                            return fixer.insertTextBeforeRange(
+                                [index, index],
+                                `${needsSlash}index${expectedExt}`
+                            )
+                        }
                         return fixer.insertTextBeforeRange(
                             [index, index],
                             expectedExt

package/lib/rules/no-top-level-await.js

@@ -120,6 +120,9 @@ module.exports = {
             ":function:exit"() {
                 functionDepth--
             },
+            /**
+             * @param {import('estree').AwaitExpression | import('estree').ForOfStatement | import('estree').VariableDeclaration} node
+             */
             "AwaitExpression, ForOfStatement[await=true], VariableDeclaration[kind='await using']"(
                 node
             ) {

package/lib/rules/prefer-global/crypto.js

@@ -0,0 +1,47 @@
+/**
+ * @author Pixel998
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { READ } = require("@eslint-community/eslint-utils")
+const checkForPreferGlobal = require("../../util/check-prefer-global")
+
+const traceMap = {
+    globals: {
+        crypto: { [READ]: true },
+    },
+    modules: {
+        crypto: { webcrypto: { [READ]: true } },
+        "node:crypto": { webcrypto: { [READ]: true } },
+    },
+}
+
+/** @type {import('../rule-module').RuleModule} */
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                'enforce either `crypto` or `require("crypto").webcrypto`',
+            recommended: false,
+            url: "https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/crypto.md",
+        },
+        type: "suggestion",
+        fixable: null,
+        schema: [{ enum: ["always", "never"] }],
+        messages: {
+            preferGlobal:
+                "Unexpected use of 'require(\"crypto\").webcrypto'. Use the global variable 'crypto' instead.",
+            preferModule:
+                "Unexpected use of the global variable 'crypto'. Use 'require(\"crypto\").webcrypto' instead.",
+        },
+    },
+
+    create(context) {
+        return {
+            "Program:exit"() {
+                checkForPreferGlobal(context, traceMap)
+            },
+        }
+    },
+}

package/lib/rules/prefer-global/timers.js

@@ -0,0 +1,66 @@
+/**
+ * @author Pixel998
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { READ } = require("@eslint-community/eslint-utils")
+const checkForPreferGlobal = require("../../util/check-prefer-global")
+
+const traceMap = {
+    globals: {
+        clearImmediate: { [READ]: true },
+        clearInterval: { [READ]: true },
+        clearTimeout: { [READ]: true },
+        setImmediate: { [READ]: true },
+        setInterval: { [READ]: true },
+        setTimeout: { [READ]: true },
+    },
+    modules: {
+        timers: {
+            clearImmediate: { [READ]: true },
+            clearInterval: { [READ]: true },
+            clearTimeout: { [READ]: true },
+            setImmediate: { [READ]: true },
+            setInterval: { [READ]: true },
+            setTimeout: { [READ]: true },
+        },
+        "node:timers": {
+            clearImmediate: { [READ]: true },
+            clearInterval: { [READ]: true },
+            clearTimeout: { [READ]: true },
+            setImmediate: { [READ]: true },
+            setInterval: { [READ]: true },
+            setTimeout: { [READ]: true },
+        },
+    },
+}
+
+/** @type {import('../rule-module').RuleModule} */
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                'enforce either global timer functions or `require("timers")`',
+            recommended: false,
+            url: "https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/timers.md",
+        },
+        type: "suggestion",
+        fixable: null,
+        schema: [{ enum: ["always", "never"] }],
+        messages: {
+            preferGlobal:
+                "Unexpected use of 'require(\"timers\").*'. Use the global variable instead.",
+            preferModule:
+                "Unexpected use of the global variable. Use 'require(\"timers\").*' instead.",
+        },
+    },
+
+    create(context) {
+        return {
+            "Program:exit"() {
+                checkForPreferGlobal(context, traceMap)
+            },
+        }
+    },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-n",
-    "version": "17.23.1",
+    "version": "17.24.0",
     "description": "Additional ESLint's rules for Node.js",
     "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"