eslint-plugin-n 17.17.0 → 17.19.0

package/README.md

@@ -156,6 +156,7 @@ For [Shareable Configs](https://eslint.org/docs/latest/developer-guide/shareable
 | [no-restricted-import](docs/rules/no-restricted-import.md)                                   | disallow specified modules when loaded by `import` declarations             |      |    |    |
 | [no-restricted-require](docs/rules/no-restricted-require.md)                                 | disallow specified modules when loaded by `require`                         |      |    |    |
 | [no-sync](docs/rules/no-sync.md)                                                             | disallow synchronous methods                                                |      |    |    |
+| [no-top-level-await](docs/rules/no-top-level-await.md)                                       | disallow top-level `await` in published modules                             |      |    |    |
 | [no-unpublished-bin](docs/rules/no-unpublished-bin.md)                                       | disallow `bin` files that npm ignores                                       | 🟢 ✅ |    |    |
 | [no-unpublished-import](docs/rules/no-unpublished-import.md)                                 | disallow `import` declarations which import private modules                 | 🟢 ✅ |    |    |
 | [no-unpublished-require](docs/rules/no-unpublished-require.md)                               | disallow `require()` expressions which import private modules               | 🟢 ✅ |    |    |

package/lib/index.js

@@ -34,6 +34,7 @@ const base = {
         "no-restricted-import": require("./rules/no-restricted-import"),
         "no-restricted-require": require("./rules/no-restricted-require"),
         "no-sync": require("./rules/no-sync"),
+        "no-top-level-await": require("./rules/no-top-level-await"),
         "no-unpublished-bin": require("./rules/no-unpublished-bin"),
         "no-unpublished-import": require("./rules/no-unpublished-import"),
         "no-unpublished-require": require("./rules/no-unpublished-require"),

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

@@ -16,6 +16,9 @@ const getSemverRange = require("../util/get-semver-range")
 const extendTrackmapWithNodePrefix = require("../util/extend-trackmap-with-node-prefix")
 const unprefixNodeColon = require("../util/unprefix-node-colon")
 const { getScope } = require("../util/eslint-compat")
+const {
+    iterateProcessGetBuiltinModuleReferences,
+} = require("../util/iterate-process-get-builtin-module-references")
 
 /** @typedef {import('../unsupported-features/types.js').DeprecatedInfo} DeprecatedInfo */
 /**
@@ -842,6 +845,10 @@ module.exports = {
                 }
                 for (const report of [
                     ...tracker.iterateCjsReferences(modules),
+                    ...iterateProcessGetBuiltinModuleReferences(
+                        tracker,
+                        modules
+                    ),
                     ...tracker.iterateEsmReferences(modules),
                 ]) {
                     const { node, path, type, info } = report

package/lib/rules/no-sync.js

@@ -4,6 +4,22 @@
  */
 "use strict"
 
+let typeMatchesSpecifier =
+    /** @type {import('ts-declaration-location').default | undefined} */
+    (undefined)
+
+try {
+    typeMatchesSpecifier =
+        /** @type {import('ts-declaration-location').default} */ (
+            /** @type {unknown} */ (require("ts-declaration-location"))
+        )
+
+    // eslint-disable-next-line no-empty -- Deliberately left empty.
+} catch {}
+const getTypeOfNode = require("../util/get-type-of-node")
+const getParserServices = require("../util/get-parser-services")
+const getFullTypeName = require("../util/get-full-type-name")
+
 const selectors = [
     // fs.readFileSync()
     // readFileSync.call(null, 'path')
@@ -16,7 +32,7 @@ const selectors = [
  * @typedef {[
  *   {
  *     allowAtRootLevel?: boolean
- *     ignores?: string[]
+ *     ignores?: (string | { from: "file"; path?: string; name?: string[]; } | { from: "package"; package?: string; name?: string[]; } | { from: "lib"; name?: string[]; })[]
  *   }?
  * ]} RuleOptions
  */
@@ -40,7 +56,56 @@ module.exports = {
                     },
                     ignores: {
                         type: "array",
-                        items: { type: "string" },
+                        items: {
+                            oneOf: [
+                                { type: "string" },
+                                {
+                                    type: "object",
+                                    properties: {
+                                        from: { const: "file" },
+                                        path: {
+                                            type: "string",
+                                        },
+                                        name: {
+                                            type: "array",
+                                            items: {
+                                                type: "string",
+                                            },
+                                        },
+                                    },
+                                    additionalProperties: false,
+                                },
+                                {
+                                    type: "object",
+                                    properties: {
+                                        from: { const: "lib" },
+                                        name: {
+                                            type: "array",
+                                            items: {
+                                                type: "string",
+                                            },
+                                        },
+                                    },
+                                    additionalProperties: false,
+                                },
+                                {
+                                    type: "object",
+                                    properties: {
+                                        from: { const: "package" },
+                                        package: {
+                                            type: "string",
+                                        },
+                                        name: {
+                                            type: "array",
+                                            items: {
+                                                type: "string",
+                                            },
+                                        },
+                                    },
+                                    additionalProperties: false,
+                                },
+                            ],
+                        },
                         default: [],
                     },
                 },
@@ -65,15 +130,70 @@ module.exports = {
              * @returns {void}
              */
             [selector.join(",")](node) {
-                if (ignores.includes(node.name)) {
-                    return
+                const parserServices = getParserServices(context)
+
+                /**
+                 * @type {import('typescript').Type | undefined | null}
+                 */
+                let type = undefined
+
+                /**
+                 * @type {string | undefined | null}
+                 */
+                let fullName = undefined
+
+                for (const ignore of ignores) {
+                    if (typeof ignore === "string") {
+                        if (ignore === node.name) {
+                            return
+                        }
+
+                        continue
+                    }
+
+                    if (
+                        parserServices === null ||
+                        parserServices.program === null
+                    ) {
+                        throw new Error(
+                            'TypeScript parser services not available. Rule "n/no-sync" is configured to use "ignores" option with a non-string value. This requires TypeScript parser services to be available.'
+                        )
+                    }
+
+                    if (typeMatchesSpecifier === undefined) {
+                        throw new Error(
+                            'ts-declaration-location not available. Rule "n/no-sync" is configured to use "ignores" option with a non-string value. This requires ts-declaration-location to be available.'
+                        )
+                    }
+
+                    type =
+                        type === undefined
+                            ? getTypeOfNode(node, parserServices)
+                            : type
+
+                    fullName =
+                        fullName === undefined
+                            ? getFullTypeName(type)
+                            : fullName
+
+                    if (
+                        typeMatchesSpecifier(
+                            parserServices.program,
+                            ignore,
+                            type
+                        ) &&
+                        (ignore.name === undefined ||
+                            ignore.name.includes(fullName ?? node.name))
+                    ) {
+                        return
+                    }
                 }
 
                 context.report({
                     node: node.parent,
                     messageId: "noSync",
                     data: {
-                        propertyName: node.name,
+                        propertyName: fullName ?? node.name,
                     },
                 })
             },

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

@@ -0,0 +1,132 @@
+/**
+ * @author Yosuke Ota <https://github.com/ota-meshi>
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const path = require("path")
+const { getSourceCode } = require("../util/eslint-compat")
+const getConvertPath = require("../util/get-convert-path")
+const { getPackageJson } = require("../util/get-package-json")
+const { isBinFile } = require("../util/is-bin-file")
+const getNpmignore = require("../util/get-npmignore")
+
+const HASHBANG_ENV = "#!/usr/bin/env"
+
+/**
+ * @typedef {[
+ *   {
+ *     ignoreBin?:boolean
+ *     convertPath?: import('../util/get-convert-path').ConvertPath;
+ *   }?
+ * ]} RuleOptions
+ */
+
+/**
+ * Checks whether the code has a hashbang comment or not.
+ * @param {import('./rule-module').PluginRuleContext<{RuleOptions: RuleOptions}>} context
+ */
+function hasHashbang(context) {
+    const sourceCode = getSourceCode(context)
+    return Boolean(sourceCode.text.startsWith(HASHBANG_ENV))
+}
+
+/** @param {import('./rule-module').PluginRuleContext<{RuleOptions: RuleOptions}>} context */
+function ignore(context) {
+    const options = context.options[0] || {}
+    const ignoreBin = options.ignoreBin ?? false
+    if (ignoreBin && hasHashbang(context)) {
+        // If the code has a hashbang comment, it is considered an executable file.
+        return true
+    }
+
+    const filePath = context.filename ?? context.getFilename()
+    if (filePath === "<input>") {
+        // The file path is "<input>" (not specified), so it will be ignored.
+        return true
+    }
+    const originalAbsolutePath = path.resolve(filePath)
+
+    // Find package.json
+    const packageJson = getPackageJson(originalAbsolutePath)
+    if (typeof packageJson?.filePath !== "string") {
+        // The file is not in a package, so it will be ignored.
+        return true
+    }
+
+    // Convert by convertPath option
+    const packageDirectory = path.dirname(packageJson.filePath)
+    const convertedRelativePath = getConvertPath(context)(
+        path
+            .relative(packageDirectory, originalAbsolutePath)
+            .replace(/\\/gu, "/")
+    )
+    const convertedAbsolutePath = path.resolve(
+        packageDirectory,
+        convertedRelativePath
+    )
+
+    if (
+        ignoreBin &&
+        isBinFile(convertedAbsolutePath, packageJson.bin, packageDirectory)
+    ) {
+        // The file is defined in the `bin` field of `package.json`
+        return true
+    }
+
+    // Check ignored or not
+    const npmignore = getNpmignore(convertedAbsolutePath)
+    if (npmignore.match(convertedRelativePath)) {
+        // The file is unpublished file, so it will be ignored.
+        return true
+    }
+
+    return false
+}
+
+/** @type {import('./rule-module').RuleModule<{RuleOptions: RuleOptions}>} */
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow top-level `await` in published modules",
+            recommended: false,
+            url: "https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-top-level-await.md",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "Top-level `await` is forbidden in published modules.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    ignoreBin: { type: "boolean" },
+                    convertPath: getConvertPath.schema,
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        if (ignore(context)) {
+            return {}
+        }
+        let functionDepth = 0
+        return {
+            ":function"() {
+                functionDepth++
+            },
+            ":function:exit"() {
+                functionDepth--
+            },
+            "AwaitExpression, ForOfStatement[await=true]"(node) {
+                if (functionDepth > 0) {
+                    // not top-level
+                    return
+                }
+                context.report({ node, messageId: "forbidden" })
+            },
+        }
+    },
+}

package/lib/rules/no-unpublished-import.js

@@ -9,6 +9,7 @@ const getAllowModules = require("../util/get-allow-modules")
 const getConvertPath = require("../util/get-convert-path")
 const getResolvePaths = require("../util/get-resolve-paths")
 const getResolverConfig = require("../util/get-resolver-config")
+const getTryExtensions = require("../util/get-try-extensions")
 const visitImport = require("../util/visit-import")
 
 /**
@@ -18,6 +19,7 @@ const visitImport = require("../util/visit-import")
  *     convertPath?: import('../util/get-convert-path').ConvertPath;
  *     resolvePaths?: import('../util/get-resolve-paths').ResolvePaths;
  *     resolverConfig?: import('../util/get-resolver-config').ResolverConfig;
+ *     tryExtensions?: import('../util/get-try-extensions').TryExtensions;
  *     ignoreTypeImport?: boolean;
  *     ignorePrivate?: boolean;
  *   }?
@@ -42,6 +44,7 @@ module.exports = {
                     convertPath: getConvertPath.schema,
                     resolvePaths: getResolvePaths.schema,
                     resolverConfig: getResolverConfig.schema,
+                    tryExtensions: getTryExtensions.schema,
                     ignoreTypeImport: { type: "boolean", default: false },
                     ignorePrivate: { type: "boolean", default: true },
                 },

package/lib/rules/prefer-node-protocol.js

@@ -4,7 +4,10 @@
  */
 "use strict"
 
-const { getStringIfConstant } = require("@eslint-community/eslint-utils")
+const {
+    getStringIfConstant,
+    getPropertyName,
+} = require("@eslint-community/eslint-utils")
 
 const { Range } = require("semver")
 
@@ -15,6 +18,10 @@ const {
     NodeBuiltinModules,
 } = require("../unsupported-features/node-builtins.js")
 
+/**
+ * @typedef { 'import' | 'require' | 'getBuiltinModule' } ModuleStyle
+ */
+
 /**
  * @param {string} name The name of the node module
  * @returns {boolean}
@@ -38,10 +45,15 @@ function isStringLiteral(node) {
 
 /**
  * @param {import('eslint').Rule.RuleContext} context
- * @param {import('../util/import-target.js').ModuleStyle} moduleStyle
+ * @param {ModuleStyle} moduleStyle
  * @returns {boolean}
  */
 function isEnablingThisRule(context, moduleStyle) {
+    // The availability of `process.getBuiltinModule()` means that `node:` protocol is supported.
+    if (moduleStyle === "getBuiltinModule") {
+        return true
+    }
+
     const version = getConfiguredNodeVersion(context)
 
     // Only check Node.js version because this rule is meaningless if configured Node.js version doesn't match semver range.
@@ -81,7 +93,7 @@ function isValidRequireArgument(node) {
 /**
  * @param {import('estree').Node | null | undefined} node
  * @param {import('eslint').Rule.RuleContext} context
- * @param {import('../util/import-target.js').ModuleStyle} moduleStyle
+ * @param {ModuleStyle} moduleStyle
  */
 function validate(node, context, moduleStyle) {
     if (node == null) {
@@ -96,7 +108,10 @@ function validate(node, context, moduleStyle) {
         return
     }
 
-    if (moduleStyle === "require" && !isValidRequireArgument(node)) {
+    if (
+        (moduleStyle === "require" || moduleStyle === "getBuiltinModule") &&
+        !isValidRequireArgument(node)
+    ) {
         return
     }
 
@@ -126,6 +141,25 @@ function validate(node, context, moduleStyle) {
     })
 }
 
+/**
+ * @param {import('estree').Expression | import('estree').Super} node
+ */
+function isProcess(node) {
+    if (node.type === "Identifier" && node.name === "process") {
+        return true
+    }
+    if (node.type === "MemberExpression") {
+        if (getPropertyName(node) !== "process") {
+            return false
+        }
+        return (
+            node.object.type === "Identifier" &&
+            node.object.name === "globalThis"
+        )
+    }
+    return false
+}
+
 /** @type {import('./rule-module').RuleModule} */
 module.exports = {
     meta: {
@@ -158,15 +192,25 @@ module.exports = {
                 }
 
                 if (
-                    node.optional ||
-                    node.arguments.length !== 1 ||
-                    node.callee.type !== "Identifier" ||
-                    node.callee.name !== "require"
+                    !node.optional &&
+                    node.arguments.length === 1 &&
+                    node.callee.type === "Identifier" &&
+                    node.callee.name === "require"
                 ) {
-                    return
+                    return validate(node.arguments[0], context, "require")
+                }
+                if (
+                    node.arguments.length >= 1 &&
+                    node.callee.type === "MemberExpression" &&
+                    isProcess(node.callee.object) &&
+                    getPropertyName(node.callee) === "getBuiltinModule"
+                ) {
+                    return validate(
+                        node.arguments[0],
+                        context,
+                        "getBuiltinModule"
+                    )
                 }
-
-                return validate(node.arguments[0], context, "require")
             },
 
             ExportAllDeclaration(node) {

package/lib/rules/prefer-promises/dns.js

@@ -10,6 +10,9 @@ const {
     ReferenceTracker,
 } = require("@eslint-community/eslint-utils")
 const { getScope } = require("../../util/eslint-compat")
+const {
+    iterateProcessGetBuiltinModuleReferences,
+} = require("../../util/iterate-process-get-builtin-module-references")
 
 /** @type {import('@eslint-community/eslint-utils').TraceMap<boolean>} */
 const dns = {
@@ -63,6 +66,10 @@ module.exports = {
                 const tracker = new ReferenceTracker(scope, { mode: "legacy" })
                 const references = [
                     ...tracker.iterateCjsReferences(traceMap),
+                    ...iterateProcessGetBuiltinModuleReferences(
+                        tracker,
+                        traceMap
+                    ),
                     ...tracker.iterateEsmReferences(traceMap),
                 ]
 

package/lib/rules/prefer-promises/fs.js

@@ -6,6 +6,9 @@
 
 const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils")
 const { getScope } = require("../../util/eslint-compat")
+const {
+    iterateProcessGetBuiltinModuleReferences,
+} = require("../../util/iterate-process-get-builtin-module-references")
 
 /** @type {import('@eslint-community/eslint-utils').TraceMap<boolean>} */
 const traceMap = {
@@ -61,6 +64,10 @@ module.exports = {
                 const tracker = new ReferenceTracker(scope, { mode: "legacy" })
                 const references = [
                     ...tracker.iterateCjsReferences(traceMap),
+                    ...iterateProcessGetBuiltinModuleReferences(
+                        tracker,
+                        traceMap
+                    ),
                     ...tracker.iterateEsmReferences(traceMap),
                 ]
 

package/lib/unsupported-features/node-builtins-modules/https.js

@@ -5,7 +5,7 @@ const { READ } = require("@eslint-community/eslint-utils")
 /**
  * @satisfies {import('../types.js').SupportVersionTraceMap}
  */
-const http = {
+const https = {
     globalAgent: { [READ]: { supported: ["0.5.9"] } },
     createServer: { [READ]: { supported: ["0.3.4"] } },
     get: { [READ]: { supported: ["0.3.6"] } },
@@ -18,12 +18,12 @@ const http = {
  * @satisfies {import('../types.js').SupportVersionTraceMap}
  */
 module.exports = {
-    http: {
+    https: {
         [READ]: { supported: ["0.3.4"] },
-        ...http,
+        ...https,
     },
-    "node:http": {
+    "node:https": {
         [READ]: { supported: ["14.13.1", "12.20.0"] },
-        ...http,
+        ...https,
     },
 }

package/lib/unsupported-features/node-builtins.js

@@ -37,6 +37,7 @@ const NodeBuiltinModules = {
     ...require("./node-builtins-modules/sea.js"),
     ...require("./node-builtins-modules/stream.js"),
     ...require("./node-builtins-modules/string_decoder.js"),
+    ...require("./node-builtins-modules/sqlite.js"),
     ...require("./node-builtins-modules/test.js"),
     ...require("./node-builtins-modules/timers.js"),
     ...require("./node-builtins-modules/tls.js"),

package/lib/util/check-prefer-global.js

@@ -6,6 +6,9 @@
 
 const { ReferenceTracker } = require("@eslint-community/eslint-utils")
 const { getScope } = require("../util/eslint-compat")
+const {
+    iterateProcessGetBuiltinModuleReferences,
+} = require("../util/iterate-process-get-builtin-module-references")
 /**
  * @typedef TraceMap
  * @property {import('@eslint-community/eslint-utils').TraceMap<boolean>} globals
@@ -43,6 +46,10 @@ class Verifier {
 
         for (const { node } of [
             ...tracker.iterateCjsReferences(traceMap.modules),
+            ...iterateProcessGetBuiltinModuleReferences(
+                tracker,
+                traceMap.modules
+            ),
             ...tracker.iterateEsmReferences(traceMap.modules),
         ]) {
             context.report({ node, messageId: "preferGlobal" })

package/lib/util/check-unsupported-builtins.js

@@ -11,6 +11,9 @@ const getSemverRange = require("./get-semver-range")
 const unprefixNodeColon = require("./unprefix-node-colon")
 const semverRangeSubset = require("semver/ranges/subset")
 const { getScope } = require("../util/eslint-compat")
+const {
+    iterateProcessGetBuiltinModuleReferences,
+} = require("./iterate-process-get-builtin-module-references")
 
 /**
  * Parses the options.
@@ -158,6 +161,10 @@ module.exports.checkUnsupportedBuiltins = function checkUnsupportedBuiltins(
     const tracker = new ReferenceTracker(scope, { mode: "legacy" })
     const references = [
         ...tracker.iterateCjsReferences(traceMap.modules ?? {}),
+        ...iterateProcessGetBuiltinModuleReferences(
+            tracker,
+            traceMap.modules ?? {}
+        ),
         ...tracker.iterateEsmReferences(traceMap.modules ?? {}),
         ...tracker.iterateGlobalReferences(traceMap.globals ?? {}),
     ]

package/lib/util/get-full-type-name.js

@@ -0,0 +1,47 @@
+"use strict"
+
+const ts = (() => {
+    try {
+        // eslint-disable-next-line n/no-unpublished-require
+        return require("typescript")
+    } catch {
+        return null
+    }
+})()
+
+/**
+ * @param {import('typescript').Type | null} type
+ * @returns {string | null}
+ */
+module.exports = function getFullTypeName(type) {
+    if (ts === null || type === null) {
+        return null
+    }
+
+    /**
+     * @type {string[]}
+     */
+    let nameParts = []
+    let currentSymbol = type.getSymbol()
+    while (currentSymbol !== undefined) {
+        if (
+            currentSymbol.valueDeclaration?.kind === ts.SyntaxKind.SourceFile ||
+            currentSymbol.valueDeclaration?.kind ===
+                ts.SyntaxKind.ModuleDeclaration
+        ) {
+            break
+        }
+
+        nameParts.unshift(currentSymbol.getName())
+        currentSymbol =
+            /** @type {import('typescript').Symbol & {parent: import('typescript').Symbol | undefined}} */ (
+                currentSymbol
+            ).parent
+    }
+
+    if (nameParts.length === 0) {
+        return null
+    }
+
+    return nameParts.join(".")
+}

package/lib/util/get-parser-services.js

@@ -0,0 +1,24 @@
+"use strict"
+
+const {
+    getParserServices: getParserServicesFromTsEslint,
+} = require("@typescript-eslint/utils/eslint-utils")
+
+/**
+ * Get the TypeScript parser services.
+ * If TypeScript isn't present, returns `null`.
+ *
+ * @param {import('eslint').Rule.RuleContext} context - rule context
+ * @returns {import('@typescript-eslint/parser').ParserServices | null}
+ */
+module.exports = function getParserServices(context) {
+    // Not using tseslint parser?
+    if (
+        context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null ||
+        context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null
+    ) {
+        return null
+    }
+
+    return getParserServicesFromTsEslint(/** @type {any} */ (context), true)
+}

package/lib/util/get-type-of-node.js

@@ -0,0 +1,21 @@
+"use strict"
+
+/**
+ * Get the type of a node.
+ * If TypeScript isn't present, returns `null`.
+ *
+ * @param {import('estree').Node} node - A node
+ * @param {import('@typescript-eslint/parser').ParserServices} parserServices - A parserServices
+ * @returns {import('typescript').Type | null}
+ */
+module.exports = function getTypeOfNode(node, parserServices) {
+    const { esTreeNodeToTSNodeMap, program } = parserServices
+    if (program === null) {
+        return null
+    }
+    const tsNode = esTreeNodeToTSNodeMap.get(/** @type {any} */ (node))
+    const checker = program.getTypeChecker()
+    const nodeType = checker.getTypeAtLocation(tsNode)
+    const constrained = checker.getBaseConstraintOfType(nodeType)
+    return constrained ?? nodeType
+}

package/lib/util/iterate-process-get-builtin-module-references.js

@@ -0,0 +1,56 @@
+"use strict"
+const {
+    CALL,
+    getStringIfConstant,
+    READ,
+} = require("@eslint-community/eslint-utils")
+const processGetBuiltinModuleCall = {
+    process: {
+        getBuiltinModule: {
+            [CALL]: true,
+        },
+    },
+}
+/**
+ * Iterate the references of process.getBuiltinModule() modules.
+ * @template Info
+ * @param {import("@eslint-community/eslint-utils").ReferenceTracker} tracker The reference tracker.
+ * @param {import("@eslint-community/eslint-utils").TraceMap<Info>} traceMap The trace map.
+ * @returns {IterableIterator<import("@eslint-community/eslint-utils").Reference<Info>>} The iterator.
+ */
+function* iterateProcessGetBuiltinModuleReferences(tracker, traceMap) {
+    for (const { node } of tracker.iterateGlobalReferences(
+        processGetBuiltinModuleCall
+    )) {
+        if (node.type !== "CallExpression") continue
+        const key = node.arguments[0] && getStringIfConstant(node.arguments[0])
+        if (key == null) {
+            continue
+        }
+        const nextTraceMap = Object.hasOwn(traceMap, key) && traceMap[key]
+        if (!nextTraceMap) {
+            continue
+        }
+
+        if (nextTraceMap[READ]) {
+            yield {
+                node,
+                path: [key],
+                type: READ,
+                info: nextTraceMap[READ],
+            }
+        }
+
+        for (const ref of tracker.iteratePropertyReferences(
+            node,
+            nextTraceMap
+        )) {
+            yield {
+                ...ref,
+                path: [key, ...ref.path],
+            }
+        }
+    }
+}
+
+module.exports = { iterateProcessGetBuiltinModuleReferences }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-n",
-    "version": "17.17.0",
+    "version": "17.19.0",
     "description": "Additional ESLint's rules for Node.js",
     "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -18,21 +18,23 @@
     },
     "dependencies": {
         "@eslint-community/eslint-utils": "^4.5.0",
+        "@typescript-eslint/utils": "^8.26.1",
         "enhanced-resolve": "^5.17.1",
         "eslint-plugin-es-x": "^7.8.0",
         "get-tsconfig": "^4.8.1",
         "globals": "^15.11.0",
         "ignore": "^5.3.2",
         "minimatch": "^9.0.5",
-        "semver": "^7.6.3"
+        "semver": "^7.6.3",
+        "ts-declaration-location": "^1.0.6"
     },
     "devDependencies": {
         "@eslint/js": "^9.14.0",
         "@types/eslint": "^9.6.1",
         "@types/estree": "^1.0.6",
         "@types/node": "^20.17.5",
-        "@typescript-eslint/parser": "^8.12.2",
-        "@typescript-eslint/typescript-estree": "^8.12.2",
+        "@typescript-eslint/parser": "^8.26.1",
+        "@typescript-eslint/typescript-estree": "^8.26.1",
         "eslint": "^9.14.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-doc-generator": "^1.7.1",
@@ -120,4 +122,4 @@
     "imports": {
         "#test-helpers": "./tests/test-helpers.js"
     }
-}
+}