eslint-plugin-n 17.11.0 → 17.12.0

package/lib/configs/_commons.js

@@ -1,6 +1,9 @@
 "use strict"
 
-module.exports.commonRules = /** @type {const} */ ({
+/**
+ * @type {import('eslint').Linter.RulesRecord}
+ */
+module.exports.commonRules = {
     "n/no-deprecated-api": "error",
     "n/no-extraneous-import": "error",
     "n/no-extraneous-require": "error",
@@ -16,4 +19,4 @@ module.exports.commonRules = /** @type {const} */ ({
     "n/no-unsupported-features/node-builtins": "error",
     "n/process-exit-as-throw": "error",
     "n/hashbang": "error",
-})
+}

package/lib/eslint-utils.d.ts

@@ -1,12 +1,9 @@
 declare module "eslint-plugin-es-x" {
-    // @ts-ignore
     export const rules: NonNullable<import('eslint').ESLint.Plugin["rules"]>;
 }
 
 declare module "@eslint-community/eslint-utils" {
-    // @ts-ignore
     import * as estree from 'estree';
-    // @ts-ignore
     import * as eslint from 'eslint';
 
     type Node = estree.Node | estree.Expression;
@@ -39,7 +36,7 @@ declare module "@eslint-community/eslint-utils" {
         [READ]?: Info;
         [CALL]?: Info;
         [CONSTRUCT]?: Info;
-        [key: string]: TraceMap<Info>;
+        [key: string]: TraceMap<Info> | undefined;
     }
     type RichNode = eslint.Rule.Node | Node;
     type Reference<Info extends unknown> = {

package/lib/index.js

@@ -5,25 +5,15 @@ const esmConfig = require("./configs/recommended-module")
 const cjsConfig = require("./configs/recommended-script")
 const recommendedConfig = require("./configs/recommended")
 
-/**
- * @typedef {{
-     'recommended-module': import('eslint').ESLint.ConfigData;
-     'recommended-script': import('eslint').ESLint.ConfigData;
-     'recommended': import('eslint').ESLint.ConfigData;
-     'flat/recommended-module': import('eslint').Linter.FlatConfig;
-     'flat/recommended-script': import('eslint').Linter.FlatConfig;
-     'flat/recommended': import('eslint').Linter.FlatConfig;
-     'flat/mixed-esm-and-cjs': import('eslint').Linter.FlatConfig[];
- }} Configs
- */
+/** @import { ESLint, Linter } from 'eslint' */
 
-/** @type {import('eslint').ESLint.Plugin & { configs: Configs }} */
-const plugin = {
+/** @type {ESLint.Plugin} */
+const base = {
     meta: {
         name: pkg.name,
         version: pkg.version,
     },
-    rules: /** @type {Record<string, import('eslint').Rule.RuleModule>} */ ({
+    rules: {
         "callback-return": require("./rules/callback-return"),
         "exports-style": require("./rules/exports-style"),
         "file-extension-in-import": require("./rules/file-extension-in-import"),
@@ -66,28 +56,38 @@ const plugin = {
         // Deprecated rules.
         "no-hide-core-modules": require("./rules/no-hide-core-modules"),
         shebang: require("./rules/shebang"),
-    }),
-    configs: {
-        "recommended-module": { plugins: ["n"], ...esmConfig.eslintrc },
-        "recommended-script": { plugins: ["n"], ...cjsConfig.eslintrc },
-        recommended: { plugins: ["n"], ...recommendedConfig.eslintrc },
-        "flat/recommended-module": { ...esmConfig.flat },
-        "flat/recommended-script": { ...cjsConfig.flat },
-        "flat/recommended": { ...recommendedConfig.flat },
-        "flat/mixed-esm-and-cjs": [
-            { files: ["**/*.js"], ...recommendedConfig.flat },
-            { files: ["**/*.mjs"], ...esmConfig.flat },
-            { files: ["**/*.cjs"], ...cjsConfig.flat },
-        ],
     },
 }
+/**
+ * @typedef {{
+ *     'recommended-module': ESLint.ConfigData;
+ *     'recommended-script': ESLint.ConfigData;
+ *     'recommended': ESLint.ConfigData;
+ *     'flat/recommended-module': Linter.Config;
+ *     'flat/recommended-script': Linter.Config;
+ *     'flat/recommended': Linter.Config;
+ *     'flat/mixed-esm-and-cjs': Linter.Config[];
+ * }} Configs
+ */
 
-plugin.configs["flat/recommended-module"].plugins = { n: plugin }
-plugin.configs["flat/recommended-script"].plugins = { n: plugin }
-plugin.configs["flat/recommended"].plugins = { n: plugin }
-
-for (const config of plugin.configs["flat/mixed-esm-and-cjs"]) {
-    config.plugins = { n: plugin }
+/** @type {Configs} */
+const configs = {
+    "recommended-module": { plugins: ["n"], ...esmConfig.eslintrc },
+    "recommended-script": { plugins: ["n"], ...cjsConfig.eslintrc },
+    recommended: { plugins: ["n"], ...recommendedConfig.eslintrc },
+    "flat/recommended-module": { plugins: { n: base }, ...esmConfig.flat },
+    "flat/recommended-script": { plugins: { n: base }, ...cjsConfig.flat },
+    "flat/recommended": { plugins: { n: base }, ...recommendedConfig.flat },
+    "flat/mixed-esm-and-cjs": [
+        { files: ["**/*.js"], plugins: { n: base }, ...recommendedConfig.flat },
+        { files: ["**/*.mjs"], plugins: { n: base }, ...esmConfig.flat },
+        { files: ["**/*.cjs"], plugins: { n: base }, ...cjsConfig.flat },
+    ],
 }
 
-module.exports = plugin
+/** @type {ESLint.Plugin & { configs: Configs }} */
+module.exports = {
+    meta: base.meta,
+    rules: base.rules,
+    configs: configs,
+}

package/lib/rules/callback-return.js

@@ -82,7 +82,7 @@ module.exports = {
         /**
          * Determines whether or not the callback is part of a callback expression.
          * @param {import('eslint').Rule.Node} node The callback node
-         * @param {import('estree').Statement} parentNode The expression node
+         * @param {import('estree').Statement} [parentNode] The expression node
          * @returns {boolean} Whether or not this is part of a callback expression
          */
         function isCallbackExpression(node, parentNode) {
@@ -136,8 +136,7 @@ module.exports = {
                 // block statements are part of functions and most if statements
                 if (closestBlock?.type === "BlockStatement") {
                     // find the last item in the block
-                    const lastItem =
-                        closestBlock.body[closestBlock.body.length - 1]
+                    const lastItem = closestBlock.body.at(-1)
 
                     // if the callback is the last thing in a block that might be ok
                     if (isCallbackExpression(node, lastItem)) {
@@ -154,13 +153,10 @@ module.exports = {
                     }
 
                     // ending a block with a return is also ok
-                    if (lastItem.type === "ReturnStatement") {
+                    if (lastItem?.type === "ReturnStatement") {
                         // but only if the callback is immediately before
                         if (
-                            isCallbackExpression(
-                                node,
-                                closestBlock.body[closestBlock.body.length - 2]
-                            )
+                            isCallbackExpression(node, closestBlock.body.at(-2))
                         ) {
                             return
                         }

package/lib/rules/exports-style.js

@@ -4,15 +4,13 @@
  */
 "use strict"
 
-/**
- * @typedef {import('estree').Node & { parent?: Node }} Node
- */
+const { hasParentNode } = require("../util/has-parent-node.js")
 
 /*istanbul ignore next */
 /**
  * This function is copied from https://github.com/eslint/eslint/blob/2355f8d0de1d6732605420d15ddd4f1eee3c37b6/lib/ast-utils.js#L648-L684
  *
- * @param {Node} node - The node to get.
+ * @param {import('estree').Node} node - The node to get.
  * @returns {string | null | undefined} The property name if static. Otherwise, null.
  * @private
  */
@@ -39,17 +37,12 @@ function getStaticPropertyName(node) {
 
         case "TemplateLiteral":
             if (prop.expressions.length === 0 && prop.quasis.length === 1) {
-                return prop.quasis[0].value.cooked
+                return prop.quasis[0]?.value.cooked
             }
             break
 
         case "Identifier":
-            if (
-                !(
-                    /** @type {import('estree').MemberExpression} */ (node)
-                        .computed
-                )
-            ) {
+            if (node.type === "MemberExpression" && node.computed === false) {
                 return prop.name
             }
             break
@@ -63,11 +56,12 @@ function getStaticPropertyName(node) {
 /**
  * Checks whether the given node is assignee or not.
  *
- * @param {Node} node - The node to check.
+ * @param {import('estree').Node} node - The node to check.
  * @returns {boolean} `true` if the node is assignee.
  */
 function isAssignee(node) {
     return (
+        hasParentNode(node) &&
         node.parent?.type === "AssignmentExpression" &&
         node.parent.left === node
     )
@@ -79,15 +73,16 @@ function isAssignee(node) {
  * This is used to distinguish 2 assignees belong to the same assignment.
  * If the node is not an assignee, this returns null.
  *
- * @param {Node} leafNode - The node to get.
- * @returns {Node|null} The top assignment expression node, or null.
+ * @param {import('estree').Node} leafNode - The node to get.
+ * @returns {import('estree').Node | null} The top assignment expression node, or null.
  */
 function getTopAssignment(leafNode) {
     let node = leafNode
 
     // Skip MemberExpressions.
     while (
-        node.parent?.type === "MemberExpression" &&
+        hasParentNode(node) &&
+        node.parent.type === "MemberExpression" &&
         node.parent.object === node
     ) {
         node = node.parent
@@ -99,7 +94,7 @@ function getTopAssignment(leafNode) {
     }
 
     // Find the top.
-    while (node.parent?.type === "AssignmentExpression") {
+    while (hasParentNode(node) && node.parent.type === "AssignmentExpression") {
         node = node.parent
     }
 
@@ -109,35 +104,41 @@ function getTopAssignment(leafNode) {
 /**
  * Gets top assignment nodes of the given node list.
  *
- * @param {Node[]} nodes - The node list to get.
- * @returns {Node[]} Gotten top assignment nodes.
+ * @param {import('estree').Node[]} nodes - The node list to get.
+ * @returns {import('estree').Node[]} Gotten top assignment nodes.
  */
 function createAssignmentList(nodes) {
-    return /** @type {Node[]} */ (nodes.map(getTopAssignment).filter(Boolean))
+    return nodes.map(getTopAssignment).filter(input => input != null)
 }
 
 /**
  * Gets the reference of `module.exports` from the given scope.
  *
  * @param {import('eslint').Scope.Scope} scope - The scope to get.
- * @returns {Node[]} Gotten MemberExpression node list.
+ * @returns {import('estree').Node[]} Gotten MemberExpression node list.
  */
 function getModuleExportsNodes(scope) {
     const variable = scope.set.get("module")
     if (variable == null) {
         return []
     }
-    return variable.references
-        .map(
-            reference =>
-                /** @type {Node & { parent: Node }} */ (reference.identifier)
-                    .parent
-        )
-        .filter(
-            node =>
-                node?.type === "MemberExpression" &&
-                getStaticPropertyName(node) === "exports"
-        )
+
+    /** @type {import('estree').Node[]} */
+    const nodes = []
+
+    for (const reference of variable.references) {
+        if (hasParentNode(reference.identifier) === false) {
+            continue
+        }
+        const node = reference.identifier.parent
+        if (
+            node.type === "MemberExpression" &&
+            getStaticPropertyName(node) === "exports"
+        ) {
+            nodes.push(node)
+        }
+    }
+    return nodes
 }
 
 /**
@@ -156,7 +157,7 @@ function getExportsNodes(scope) {
 }
 
 /**
- * @param {Node} property
+ * @param {import('estree').Node} property
  * @param {import('eslint').SourceCode} sourceCode
  * @returns {string | null}
  */
@@ -210,13 +211,16 @@ function getReplacementForProperty(property, sourceCode) {
 
 /**
  * Check for a top level module.exports = { ... }
- * @param {Node} node
+ * @param {import('estree').Node} node
  * @returns {node is {parent: import('estree').AssignmentExpression & {parent: import('estree').ExpressionStatement, right: import('estree').ObjectExpression}}}
  */
 function isModuleExportsObjectAssignment(node) {
     return (
+        hasParentNode(node) &&
         node.parent?.type === "AssignmentExpression" &&
+        hasParentNode(node.parent) &&
         node.parent?.parent?.type === "ExpressionStatement" &&
+        hasParentNode(node.parent.parent) &&
         node.parent.parent.parent?.type === "Program" &&
         node.parent.right.type === "ObjectExpression"
     )
@@ -224,17 +228,19 @@ function isModuleExportsObjectAssignment(node) {
 
 /**
  * Check for module.exports.foo or module.exports.bar reference or assignment
- * @param {Node} node
+ * @param {import('estree').Node} node
  * @returns {node is import('estree').MemberExpression}
  */
 function isModuleExportsReference(node) {
     return (
-        node.parent?.type === "MemberExpression" && node.parent.object === node
+        hasParentNode(node) &&
+        node.parent?.type === "MemberExpression" &&
+        node.parent.object === node
     )
 }
 
 /**
- * @param {Node} node
+ * @param {import('estree').Node} node
  * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.RuleFixer} fixer
  * @returns {import('eslint').Rule.Fix | null}
@@ -307,16 +313,17 @@ module.exports = {
          * module.exports = foo
          * ^^^^^^^^^^^^^^^^
          *
-         * @param {Node} node - The node of `exports`/`module.exports`.
-         * @returns {import('estree').SourceLocation} The location info of reports.
+         * @param {import('estree').Node} node - The node of `exports`/`module.exports`.
+         * @returns {import('estree').SourceLocation | undefined} The location info of reports.
          */
         function getLocation(node) {
             const token = sourceCode.getTokenAfter(node)
+            if (node.loc?.start == null || token?.loc?.end == null) {
+                return
+            }
             return {
-                start: /** @type {import('estree').SourceLocation} */ (node.loc)
-                    .start,
-                end: /** @type {import('estree').SourceLocation} */ (token?.loc)
-                    ?.end,
+                start: node.loc?.start,
+                end: token?.loc?.end,
             }
         }
 

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

@@ -95,8 +95,11 @@ module.exports = {
                     messageId: "requireExt",
                     data: { ext: expectedExt },
                     fix(fixer) {
-                        const index =
-                            /** @type {[number, number]} */ (node.range)[1] - 1
+                        if (node.range == null) {
+                            return null
+                        }
+
+                        const index = node.range[1] - 1
                         return fixer.insertTextBeforeRange(
                             [index, index],
                             expectedExt
@@ -112,26 +115,27 @@ module.exports = {
                 currentExt === expectedExt
             ) {
                 const otherExtensions = getExistingExtensions(filePath)
-
-                context.report({
+                /** @type {import('eslint').Rule.ReportDescriptor} */
+                const descriptor = {
                     node,
                     messageId: "forbidExt",
                     data: { ext: currentExt },
-                    fix:
-                        otherExtensions.length > 1
-                            ? undefined
-                            : fixer => {
-                                  const index = name.lastIndexOf(currentExt)
-                                  const start =
-                                      /** @type {[number, number]} */ (
-                                          node.range
-                                      )[0] +
-                                      1 +
-                                      index
-                                  const end = start + currentExt.length
-                                  return fixer.removeRange([start, end])
-                              },
-                })
+                }
+
+                if (otherExtensions.length === 1) {
+                    descriptor.fix = fixer => {
+                        if (node.range == null) {
+                            return null
+                        }
+
+                        const index = name.lastIndexOf(currentExt)
+                        const start = node.range[0] + 1 + index
+                        const end = start + currentExt.length
+                        return fixer.removeRange([start, end])
+                    }
+                }
+
+                context.report(descriptor)
             }
         }
 

package/lib/rules/global-require.js

@@ -67,8 +67,8 @@ module.exports = {
                     sourceCode.getScope?.(node) ?? context.getScope() //TODO: remove context.getScope() when dropping support for ESLint < v9
 
                 if (
-                    /** @type {import('estree').Identifier} */ (node.callee)
-                        .name === "require" &&
+                    node.callee.type === "Identifier" &&
+                    node.callee.name === "require" &&
                     !isShadowed(currentScope, node.callee)
                 ) {
                     const isGoodRequire = (

package/lib/rules/no-callback-literal.js

@@ -28,14 +28,12 @@ module.exports = {
         return {
             CallExpression(node) {
                 const errorArg = node.arguments[0]
-                const calleeName = /** @type {import('estree').Identifier} */ (
-                    node.callee
-                ).name
 
                 if (
                     errorArg &&
                     !couldBeError(errorArg) &&
-                    callbackNames.includes(calleeName)
+                    node.callee.type === "Identifier" &&
+                    callbackNames.includes(node.callee.name)
                 ) {
                     context.report({
                         node,
@@ -49,11 +47,11 @@ module.exports = {
 
 /**
  * Determine if a node has a possiblity to be an Error object
- * @param  {import('estree').Node}  node  ASTNode to check
+ * @param  {import('estree').Node}  [node]  ASTNode to check
  * @returns {boolean}       True if there is a chance it contains an Error obj
  */
 function couldBeError(node) {
-    switch (node.type) {
+    switch (node?.type) {
         case "Identifier":
         case "CallExpression":
         case "NewExpression":

package/lib/rules/no-deprecated-api.js

@@ -23,7 +23,7 @@ const unprefixNodeColon = require("../util/unprefix-node-colon")
  * @property {Set<string>} ignoredGlobalItems
  * @property {Set<string>} ignoredModuleItems
  */
-/** @type {import('@eslint-community/eslint-utils').TraceMap<DeprecatedInfo>} */
+/** @type {import('../unsupported-features/types.js').DeprecatedInfoTraceMap} */
 const rawModules = {
     _linklist: {
         [READ]: { since: "5.0.0", replacedBy: null },
@@ -330,12 +330,6 @@ const rawModules = {
                 },
             },
         },
-        nextTick: {
-            [READ]: {
-                since: "22.7.0",
-                replacedBy: "'queueMicrotask()'",
-            },
-        },
     },
     punycode: {
         [READ]: {
@@ -631,6 +625,7 @@ const rawModules = {
 }
 const modules = extendTrackmapWithNodePrefix(rawModules)
 
+/** @type {import('../unsupported-features/types.js').DeprecatedInfoTraceMap} */
 const globals = {
     Buffer: {
         [CONSTRUCT]: {
@@ -706,14 +701,14 @@ function toReplaceMessage(replacedBy, version) {
 
     if (Array.isArray(replacedBy)) {
         message = replacedBy
-            .filter(
-                ({ supported }) =>
-                    !version.intersects(
-                        /** @type {import('semver').Range} */ (
-                            getSemverRange(`<${supported}`)
-                        )
-                    )
-            )
+            .filter(({ supported }) => {
+                const range = getSemverRange(`<${supported}`)
+                if (range == null) {
+                    return false
+                }
+
+                return !version.intersects(range)
+            })
             .map(({ name }) => name)
             .join(" or ")
     }
@@ -820,9 +815,6 @@ module.exports = {
 
             context.report({
                 node,
-                loc: /** @type {NonNullable<import('estree').Node["loc"]>} */ (
-                    node.loc
-                ),
                 messageId,
                 data,
             })

package/lib/rules/no-hide-core-modules.js

@@ -137,9 +137,6 @@ module.exports = {
 
                         context.report({
                             node: target.node,
-                            loc: /** @type {NonNullable<import('estree').Node["loc"]>} */ (
-                                target.node.loc
-                            ),
                             messageId: "unexpectedImport",
                             data: {
                                 name: path

package/lib/rules/no-mixed-requires.js

@@ -172,19 +172,18 @@ module.exports = {
                 return inferModuleType(initExpression.object)
             }
 
-            if (
-                /** @type {import('estree').CallExpression} */ (initExpression)
-                    .arguments.length === 0
-            ) {
+            if (initExpression.type !== "CallExpression") {
+                return REQ_MODULE
+            }
+
+            if (initExpression.arguments.length === 0) {
                 // "var x = require();"
                 return REQ_COMPUTED
             }
 
-            const arg = /** @type {import('estree').CallExpression} */ (
-                initExpression
-            ).arguments[0]
+            const arg = initExpression.arguments[0]
 
-            if (arg.type !== "Literal" || typeof arg.value !== "string") {
+            if (arg?.type !== "Literal" || typeof arg.value !== "string") {
                 // "var x = require(42);"
                 return REQ_COMPUTED
             }
@@ -235,14 +234,11 @@ module.exports = {
             const found = {}
 
             for (const declaration of declarations) {
-                if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
-                    found[
-                        inferModuleType(
-                            /** @type {import('estree').Expression} */ (
-                                declaration.init
-                            )
-                        )
-                    ] = true
+                if (
+                    declaration.init != null &&
+                    getDeclarationType(declaration.init) === DECL_REQUIRE
+                ) {
+                    found[inferModuleType(declaration.init)] = true
                 }
             }