eslint-plugin-n 17.23.2 → 18.0.0

package/lib/eslint-utils.d.ts

@@ -1,81 +1,146 @@
-declare module "eslint-plugin-es-x" {
-    export const rules: NonNullable<import('eslint').ESLint.Plugin["rules"]>;
-}
+declare module "eslint-plugin-es-x" {}
 
 declare module "@eslint-community/eslint-utils" {
-    import * as estree from 'estree';
-    import * as eslint from 'eslint';
+    import * as estree from "estree"
+    import * as eslint from "eslint"
 
-    type Node = estree.Node | estree.Expression;
+    type Node = estree.Node | estree.Expression
 
-    export const READ: unique symbol;
-    export const CALL: unique symbol;
-    export const CONSTRUCT: unique symbol;
-    export const ESM: unique symbol;
+    export const READ: unique symbol
+    export const CALL: unique symbol
+    export const CONSTRUCT: unique symbol
+    export const ESM: unique symbol
     export class ReferenceTracker {
-        constructor(globalScope: eslint.Scope.Scope, { mode, globalObjectNames, }?: {
-            mode?: "legacy" | "strict" | undefined;
-            globalObjectNames?: string[] | undefined;
-        } | undefined);
-        variableStack: eslint.Scope.Variable[];
-        globalScope: eslint.Scope.Scope;
-        mode: "legacy" | "strict";
-        globalObjectNames: string[];
-        iterateGlobalReferences<Info extends unknown>(traceMap: TraceMap<Info>): IterableIterator<Reference<Info>>;
-        iterateCjsReferences<Info extends unknown>(traceMap: TraceMap<Info>): IterableIterator<Reference<Info>>;
-        iterateEsmReferences<Info extends unknown>(traceMap: TraceMap<Info>): IterableIterator<Reference<Info>>;
-        iteratePropertyReferences<Info extends unknown>(node: estree.Expression, traceMap: TraceMap<Info>): IterableIterator<Reference<Info>>;
+        constructor(
+            globalScope: eslint.Scope.Scope,
+            {
+                mode,
+                globalObjectNames,
+            }?:
+                | {
+                      mode?: "legacy" | "strict" | undefined
+                      globalObjectNames?: string[] | undefined
+                  }
+                | undefined
+        )
+        variableStack: eslint.Scope.Variable[]
+        globalScope: eslint.Scope.Scope
+        mode: "legacy" | "strict"
+        globalObjectNames: string[]
+        iterateGlobalReferences<Info extends unknown>(
+            traceMap: TraceMap<Info>
+        ): IterableIterator<Reference<Info>>
+        iterateCjsReferences<Info extends unknown>(
+            traceMap: TraceMap<Info>
+        ): IterableIterator<Reference<Info>>
+        iterateEsmReferences<Info extends unknown>(
+            traceMap: TraceMap<Info>
+        ): IterableIterator<Reference<Info>>
+        iteratePropertyReferences<Info extends unknown>(
+            node: estree.Expression,
+            traceMap: TraceMap<Info>
+        ): IterableIterator<Reference<Info>>
     }
     export namespace ReferenceTracker {
-        export { READ };
-        export { CALL };
-        export { CONSTRUCT };
-        export { ESM };
+        export { READ }
+        export { CALL }
+        export { CONSTRUCT }
+        export { ESM }
     }
-    type ReferenceType = typeof READ | typeof CALL | typeof CONSTRUCT;
+    type ReferenceType = typeof READ | typeof CALL | typeof CONSTRUCT
     type TraceMap<Info extends unknown> = {
-        [READ]?: Info;
-        [CALL]?: Info;
-        [CONSTRUCT]?: Info;
-        [key: string]: TraceMap<Info> | undefined;
+        [READ]?: Info
+        [CALL]?: Info
+        [CONSTRUCT]?: Info
+        [key: string]: TraceMap<Info> | undefined
     }
-    type RichNode = eslint.Rule.Node | Node;
+    type RichNode = eslint.Rule.Node | Node
     type Reference<Info extends unknown> = {
-        node: RichNode;
-        path: string[];
-        type: ReferenceType;
-        info: Info;
-    };
+        node: RichNode
+        path: string[]
+        type: ReferenceType
+        info: Info
+    }
 
-    export function findVariable(initialScope: eslint.Scope.Scope, nameOrNode: string | Node): eslint.Scope.Variable | null;
+    export function findVariable(
+        initialScope: eslint.Scope.Scope,
+        nameOrNode: string | Node
+    ): eslint.Scope.Variable | null
 
-    export function getFunctionHeadLocation(node: Extract<eslint.Rule.Node, {
-        type: 'FunctionDeclaration' | 'FunctionExpression' | 'ArrowFunctionExpression';
-    }>, sourceCode: eslint.SourceCode): eslint.AST.SourceLocation | null;
+    export function getFunctionHeadLocation(
+        node: Extract<
+            eslint.Rule.Node,
+            {
+                type:
+                    | "FunctionDeclaration"
+                    | "FunctionExpression"
+                    | "ArrowFunctionExpression"
+            }
+        >,
+        sourceCode: eslint.SourceCode
+    ): eslint.AST.SourceLocation | null
 
-    export function getFunctionNameWithKind(node: Extract<eslint.Rule.Node, {
-        type: 'FunctionDeclaration' | 'FunctionExpression' | 'ArrowFunctionExpression';
-    }>, sourceCode?: eslint.SourceCode | undefined): string;
+    export function getFunctionNameWithKind(
+        node: Extract<
+            eslint.Rule.Node,
+            {
+                type:
+                    | "FunctionDeclaration"
+                    | "FunctionExpression"
+                    | "ArrowFunctionExpression"
+            }
+        >,
+        sourceCode?: eslint.SourceCode | undefined
+    ): string
 
-    export function getInnermostScope(initialScope: eslint.Scope.Scope, node: Node): eslint.Scope.Scope;
+    export function getInnermostScope(
+        initialScope: eslint.Scope.Scope,
+        node: Node
+    ): eslint.Scope.Scope
 
-    export function getPropertyName(node: Extract<Node, {
-        type: 'MemberExpression' | 'Property' | 'MethodDefinition' | 'PropertyDefinition';
-    }>, initialScope?: eslint.Scope.Scope | undefined): string | null;
+    export function getPropertyName(
+        node: Extract<
+            Node,
+            {
+                type:
+                    | "MemberExpression"
+                    | "Property"
+                    | "MethodDefinition"
+                    | "PropertyDefinition"
+            }
+        >,
+        initialScope?: eslint.Scope.Scope | undefined
+    ): string | null
 
-    export function getStaticValue(node: Node, initialScope?: eslint.Scope.Scope | null | undefined): {
-        value: unknown;
-        optional?: never;
-    } | {
-        value: undefined;
-        optional?: true;
-    } | null;
+    export function getStaticValue(
+        node: Node,
+        initialScope?: eslint.Scope.Scope | null | undefined
+    ):
+        | {
+              value: unknown
+              optional?: never
+          }
+        | {
+              value: undefined
+              optional?: true
+          }
+        | null
 
-    export function getStringIfConstant(node: Node, initialScope?: eslint.Scope.Scope | null | undefined): string | null;
+    export function getStringIfConstant(
+        node: Node,
+        initialScope?: eslint.Scope.Scope | null | undefined
+    ): string | null
 
-    export function hasSideEffect(node: eslint.Rule.Node, sourceCode: eslint.SourceCode, { considerGetters, considerImplicitTypeConversion }?: VisitOptions | undefined): boolean;
+    export function hasSideEffect(
+        node: eslint.Rule.Node,
+        sourceCode: eslint.SourceCode,
+        {
+            considerGetters,
+            considerImplicitTypeConversion,
+        }?: VisitOptions | undefined
+    ): boolean
     type VisitOptions = {
-        considerGetters?: boolean | undefined;
-        considerImplicitTypeConversion?: boolean | undefined;
-    };
+        considerGetters?: boolean | undefined
+        considerImplicitTypeConversion?: boolean | undefined
+    }
 }

package/lib/index.js

@@ -1,11 +1,9 @@
-"use strict"
-
-const pkg = require("../package.json")
-const esmConfig = require("./configs/recommended-module")
-const cjsConfig = require("./configs/recommended-script")
-const recommendedConfig = require("./configs/recommended")
-const allRulesConfig = require("./configs/all")
-const allRules = require("./all-rules")
+import pkg from "../package.json" with { type: "json" }
+import * as esmConfig from "./configs/recommended-module.js"
+import * as cjsConfig from "./configs/recommended-script.js"
+import * as recommendedConfig from "./configs/recommended.js"
+import { flat as allRulesFlatConfig } from "./configs/all.js"
+import allRules from "./all-rules.js"
 
 /** @import { ESLint, Linter } from 'eslint' */
 
@@ -43,8 +41,8 @@ const configs = {
         { files: ["**/*.mjs"], plugins: { n: base }, ...esmConfig.flat },
         { files: ["**/*.cjs"], plugins: { n: base }, ...cjsConfig.flat },
     ],
-    "flat/all": { plugins: { n: base }, ...allRulesConfig.flat },
+    "flat/all": { plugins: { n: base }, ...allRulesFlatConfig },
 }
 
 /** @type {ESLint.Plugin & { configs: Configs }} */
-module.exports = Object.assign(base, { configs })
+export default Object.assign(base, { configs })

package/lib/rules/callback-return.js

@@ -2,14 +2,12 @@
  * @author Jamund Ferguson
  * See LICENSE file in root directory for full license.
  */
-"use strict"
-const { getSourceCode } = require("../util/eslint-compat")
 
 /**
  * @typedef {[string[]?]} RuleOptions
  */
-/** @type {import('./rule-module').RuleModule<{RuleOptions: RuleOptions}>} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule<{RuleOptions: RuleOptions}>} */
+export default {
     meta: {
         type: "suggestion",
         docs: {
@@ -23,15 +21,14 @@ module.exports = {
                 items: { type: "string" },
             },
         ],
-        fixable: null,
+        fixable: void 0,
         messages: {
             missingReturn: "Expected return with your callback function.",
         },
     },
-
     create(context) {
         const callbacks = context.options[0] || ["callback", "cb", "next"]
-        const sourceCode = getSourceCode(context)
+        const sourceCode = context.sourceCode
 
         /**
          * Find the closest parent matching a list of types.

package/lib/rules/exports-style.js

@@ -2,10 +2,8 @@
  * @author Toru Nagashima
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
-const { hasParentNode } = require("../util/has-parent-node.js")
-const { getSourceCode, getScope } = require("../util/eslint-compat")
+import { hasParentNode } from "../util/has-parent-node.js"
 
 /*istanbul ignore next */
 /**
@@ -128,7 +126,10 @@ function getModuleExportsNodes(scope) {
     const nodes = []
 
     for (const reference of variable.references) {
-        if (hasParentNode(reference.identifier) === false) {
+        if (
+            reference.identifier.type !== "Identifier" ||
+            hasParentNode(reference.identifier) === false
+        ) {
             continue
         }
         const node = reference.identifier.parent
@@ -154,7 +155,16 @@ function getExportsNodes(scope) {
         return []
     }
 
-    return variable.references.map(reference => reference.identifier)
+    /** @type {import('estree').Identifier[]} */
+    const nodes = []
+
+    for (const reference of variable.references) {
+        if (reference.identifier.type === "Identifier") {
+            nodes.push(reference.identifier)
+        }
+    }
+
+    return nodes
 }
 
 /**
@@ -273,8 +283,8 @@ function fixModuleExports(node, sourceCode, fixer) {
  *   {allowBatchAssign?: boolean}?
  * ]} RuleOptions
  */
-/** @type {import('./rule-module').RuleModule<{RuleOptions: RuleOptions}>} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule<{RuleOptions: RuleOptions}>} */
+export default {
     meta: {
         docs: {
             description: "enforce either `module.exports` or `exports`",
@@ -303,13 +313,12 @@ module.exports = {
                 "Unexpected assignment to 'exports'. Don't modify 'exports' itself.",
         },
     },
-
     create(context) {
         const mode = context.options[0] || "module.exports"
         const batchAssignAllowed = Boolean(
             context.options[1] != null && context.options[1].allowBatchAssign
         )
-        const sourceCode = getSourceCode(context)
+        const sourceCode = context.sourceCode
 
         /**
          * Gets the location info of reports.
@@ -434,7 +443,9 @@ module.exports = {
 
         return {
             "Program:exit"() {
-                const scope = getScope(context)
+                const scope = context.sourceCode.getScope(
+                    context.sourceCode.ast
+                )
 
                 switch (mode) {
                     case "module.exports":

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

@@ -2,13 +2,12 @@
  * @author Toru Nagashima
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
-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")
+import path from "node:path"
+import fs from "node:fs"
+import { convertTsExtensionToJs } from "../util/map-typescript-extension.js"
+import { getTryExtensions } from "../util/get-try-extensions.js"
+import { visitImport } from "../util/visit-import.js"
 
 /**
  * Get all file extensions of the files which have the same basename.
@@ -67,8 +66,8 @@ function getIndexExtension(directoryPath, tryExtensions) {
  *   {[ext in string]?: "always" | "never"}?
  * ]} RuleOptions
  */
-/** @type {import('./rule-module').RuleModule<{RuleOptions: RuleOptions}>} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule<{RuleOptions: RuleOptions}>} */
+export default {
     meta: {
         docs: {
             description:
@@ -96,7 +95,7 @@ module.exports = {
         type: "suggestion",
     },
     create(context) {
-        if ((context.filename ?? context.getFilename()).startsWith("<")) {
+        if (context.filename.startsWith("<")) {
             return {}
         }
         const defaultStyle = context.options[0] || "always"
@@ -104,7 +103,7 @@ module.exports = {
         const tryExtensions = getTryExtensions(context, 1)
 
         /**
-         * @param {import("../util/import-target.js")} target
+         * @param {import("../util/import-target.js").ImportTarget} target
          * @returns {void}
          */
         function verify({ filePath, name, node, moduleType }) {

package/lib/rules/global-require.js

@@ -2,9 +2,6 @@
  * @author Jamund Ferguson
  * See LICENSE file in root directory for full license.
  */
-"use strict"
-
-const { getScope, getAncestors } = require("../util/eslint-compat")
 
 const ACCEPTABLE_PARENTS = [
     "AssignmentExpression",
@@ -43,8 +40,8 @@ function isShadowed(scope, node) {
     return Boolean(reference?.resolved?.defs?.length)
 }
 
-/** @type {import('./rule-module').RuleModule} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule} */
+export default {
     meta: {
         type: "suggestion",
         docs: {
@@ -53,26 +50,28 @@ module.exports = {
             recommended: false,
             url: "https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/global-require.md",
         },
-        fixable: null,
+        fixable: void 0,
         schema: [],
         messages: {
             unexpected: "Unexpected require().",
         },
     },
-
     create(context) {
         return {
             CallExpression(node) {
-                const currentScope = getScope(context, node)
+                const currentScope = context.sourceCode.getScope(node)
 
                 if (
                     node.callee.type === "Identifier" &&
                     node.callee.name === "require" &&
                     !isShadowed(currentScope, node.callee)
                 ) {
-                    const isGoodRequire = getAncestors(context, node).every(
-                        parent => ACCEPTABLE_PARENTS.indexOf(parent.type) > -1
-                    )
+                    const isGoodRequire = context.sourceCode
+                        .getAncestors(node)
+                        .every(
+                            parent =>
+                                ACCEPTABLE_PARENTS.indexOf(parent.type) > -1
+                        )
 
                     if (!isGoodRequire) {
                         context.report({ node, messageId: "unexpected" })

package/lib/rules/handle-callback-err.js

@@ -2,15 +2,12 @@
  * @author Jamund Ferguson
  * See LICENSE file in root directory for full license.
  */
-"use strict"
-
-const { getScope } = require("../util/eslint-compat")
 
 /**
  * @typedef {[string?]} RuleOptions
  */
-/** @type {import('./rule-module').RuleModule<{RuleOptions: RuleOptions}>} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule<{RuleOptions: RuleOptions}>} */
+export default {
     meta: {
         type: "suggestion",
         docs: {
@@ -18,7 +15,7 @@ module.exports = {
             recommended: false,
             url: "https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/handle-callback-err.md",
         },
-        fixable: null,
+        fixable: void 0,
         schema: [
             {
                 type: "string",
@@ -28,7 +25,6 @@ module.exports = {
             expected: "Expected error to be handled.",
         },
     },
-
     create(context) {
         const errorArgument = context.options[0] || "err"
 
@@ -75,7 +71,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForError(node) {
-            const scope = getScope(context, node)
+            const scope = context.sourceCode.getScope(node)
             const parameters = getParameters(scope)
             const firstParameter = parameters[0]
 

package/lib/rules/hashbang.js

@@ -2,16 +2,17 @@
  * @author Toru Nagashima
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
-const path = require("path")
-const matcher = require("ignore").default
+import path from "node:path"
+import matcherModule from "ignore"
 
-const getConvertPath = require("../util/get-convert-path")
-const { getPackageJson } = require("../util/get-package-json")
-const getNpmignore = require("../util/get-npmignore")
-const { isBinFile } = require("../util/is-bin-file")
-const { getSourceCode } = require("../util/eslint-compat")
+import { getConvertPath, schema } from "../util/get-convert-path.js"
+import { getPackageJson } from "../util/get-package-json.js"
+import { getNpmignore } from "../util/get-npmignore.js"
+import { isBinFile } from "../util/is-bin-file.js"
+
+/** @type {typeof import('ignore').default} */
+const matcher = /** @type {any} */ (matcherModule)
 
 const ENV_SHEBANG = "#!/usr/bin/env"
 const NODE_SHEBANG = `${ENV_SHEBANG} {{executableName}}\n`
@@ -51,7 +52,7 @@ function isNodeShebang(shebang, executableName) {
  * @returns {string}
  */
 function getExpectedExecutableName(context) {
-    const extension = path.extname(context.filename ?? context.getFilename())
+    const extension = path.extname(context.filename)
     const { executableMap = {} } =
         /** @type {[{ executableMap: Record<string, string> }]} */
         (context.options)?.[0] ?? {}
@@ -81,15 +82,15 @@ function getShebangInfo(sourceCode) {
 /**
  * @typedef {[
  *   {
- *     convertPath?: import('../util/get-convert-path').ConvertPath;
+ *     convertPath?: import('../util/get-convert-path.js').ConvertPath;
  *     ignoreUnpublished?: boolean;
  *     additionalExecutables?: string[];
  *     executableMap?: Record<string, string>;
  *   }?
  * ]} RuleOptions
  */
-/** @type {import('./rule-module').RuleModule<{RuleOptions: RuleOptions}>} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule<{RuleOptions: RuleOptions}>} */
+export default {
     meta: {
         docs: {
             description: "require correct usage of hashbang",
@@ -102,7 +103,7 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    convertPath: getConvertPath.schema,
+                    convertPath: schema,
                     ignoreUnpublished: { type: "boolean" },
                     additionalExecutables: {
                         type: "array",
@@ -131,8 +132,8 @@ module.exports = {
         },
     },
     create(context) {
-        const sourceCode = getSourceCode(context)
-        const filePath = context.filename ?? context.getFilename()
+        const sourceCode = context.sourceCode
+        const filePath = context.filename
         if (filePath === "<input>") {
             return {}
         }

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

@@ -2,12 +2,11 @@
  * @author Jamund Ferguson
  * See LICENSE file in root directory for full license.
  */
-"use strict"
 
 const callbackNames = ["callback", "cb"]
 
-/** @type {import('./rule-module').RuleModule} */
-module.exports = {
+/** @type {import('./rule-module.js').RuleModule} */
+export default {
     meta: {
         docs: {
             description:
@@ -16,14 +15,13 @@ module.exports = {
             url: "https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-callback-literal.md",
         },
         type: "problem",
-        fixable: null,
+        fixable: void 0,
         schema: [],
         messages: {
             unexpectedLiteral:
                 "Unexpected literal in error position of callback.",
         },
     },
-
     create(context) {
         return {
             CallExpression(node) {