eslint 9.12.0 → 9.14.0

package/lib/eslint/eslint-helpers.js

@@ -421,20 +421,19 @@ async function globMultiSearch({ searches, configLoader, errorOnUnmatchedPattern
         )
     );
 
-    const filePaths = [];
-
+    /*
+     * The first loop handles errors from the glob searches. Since we can't
+     * use `await` inside `flatMap`, we process errors separately in this loop.
+     * This results in two iterations over `results`, but since the length is
+     * less than or equal to the number of globs and directories passed on the
+     * command line, the performance impact should be minimal.
+     */
     for (let i = 0; i < results.length; i++) {
 
         const result = results[i];
         const currentSearch = normalizedSearches[i];
 
         if (result.status === "fulfilled") {
-
-            // if the search was successful just add the results
-            if (result.value.length > 0) {
-                filePaths.push(...result.value);
-            }
-
             continue;
         }
 
@@ -457,7 +456,8 @@ async function globMultiSearch({ searches, configLoader, errorOnUnmatchedPattern
 
     }
 
-    return filePaths;
+    // second loop for `fulfulled` results
+    return results.flatMap(result => result.value);
 
 }
 

package/lib/eslint/eslint.js

@@ -15,6 +15,7 @@ const path = require("node:path");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
+const { defaultConfig } = require("../config/default-config");
 const {
     Legacy: {
         ConfigOps: {
@@ -52,6 +53,7 @@ const { ConfigLoader, LegacyConfigLoader } = require("../config/config-loader");
 //------------------------------------------------------------------------------
 
 // For VSCode IntelliSense
+/** @typedef {import("../cli-engine/cli-engine").ConfigArray} ConfigArray */
 /** @typedef {import("../shared/types").ConfigData} ConfigData */
 /** @typedef {import("../shared/types").DeprecatedRuleInfo} DeprecatedRuleInfo */
 /** @typedef {import("../shared/types").LintMessage} LintMessage */
@@ -522,6 +524,15 @@ class ESLint {
         return version;
     }
 
+    /**
+     * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint.
+     * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present.
+     * @type {ConfigArray}
+     */
+    static get defaultConfig() {
+        return defaultConfig;
+    }
+
     /**
      * Outputs fixes from the given results to files.
      * @param {LintResult[]} results The lint results.
@@ -735,7 +746,7 @@ class ESLint {
         });
         const controller = new AbortController();
         const retryCodes = new Set(["ENFILE", "EMFILE"]);
-        const retrier = new Retrier(error => retryCodes.has(error.code));
+        const retrier = new Retrier(error => retryCodes.has(error.code), { concurrency: 100 });
 
         debug(`${filePaths.length} files found in: ${Date.now() - startTime}ms`);
 
@@ -819,7 +830,7 @@ class ESLint {
                         }
 
                         return result;
-                    }))
+                    }), { signal: controller.signal })
                     .catch(error => {
                         controller.abort(error);
                         throw error;

package/lib/languages/js/index.js

@@ -12,6 +12,7 @@
 const { SourceCode } = require("./source-code");
 const createDebug = require("debug");
 const astUtils = require("../../shared/ast-utils");
+const espree = require("espree");
 const eslintScope = require("eslint-scope");
 const evk = require("eslint-visitor-keys");
 const { validateLanguageOptions } = require("./validate-language-options");
@@ -69,6 +70,13 @@ module.exports = {
     nodeTypeKey: "type",
     visitorKeys: evk.KEYS,
 
+    defaultLanguageOptions: {
+        sourceType: "module",
+        ecmaVersion: "latest",
+        parser: espree,
+        parserOptions: {}
+    },
+
     validateLanguageOptions,
 
     /**

package/lib/linter/linter.js

@@ -1643,29 +1643,26 @@ class Linter {
         const options = normalizeVerifyOptions(providedOptions, config);
         const languageOptions = config.languageOptions;
 
-        languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
-            languageOptions.ecmaVersion
-        );
-
-        // double check that there is a parser to avoid mysterious error messages
-        if (!languageOptions.parser) {
-            throw new TypeError(`No parser specified for ${options.filename}`);
-        }
+        if (config.language === jslang) {
+            languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
+                languageOptions.ecmaVersion
+            );
 
-        // Espree expects this information to be passed in
-        if (isEspree(languageOptions.parser)) {
-            const parserOptions = languageOptions.parserOptions;
+            // Espree expects this information to be passed in
+            if (isEspree(languageOptions.parser)) {
+                const parserOptions = languageOptions.parserOptions;
 
-            if (languageOptions.sourceType) {
+                if (languageOptions.sourceType) {
 
-                parserOptions.sourceType = languageOptions.sourceType;
+                    parserOptions.sourceType = languageOptions.sourceType;
 
-                if (
-                    parserOptions.sourceType === "module" &&
-                    parserOptions.ecmaFeatures &&
-                    parserOptions.ecmaFeatures.globalReturn
-                ) {
-                    parserOptions.ecmaFeatures.globalReturn = false;
+                    if (
+                        parserOptions.sourceType === "module" &&
+                        parserOptions.ecmaFeatures &&
+                        parserOptions.ecmaFeatures.globalReturn
+                    ) {
+                        parserOptions.ecmaFeatures.globalReturn = false;
+                    }
                 }
             }
         }

package/lib/rule-tester/rule-tester.js

@@ -30,6 +30,7 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { ConfigArraySymbol } = require("@eslint/config-array");
 const { isSerializable } = require("../shared/serialization");
 
+const jslang = require("../languages/js");
 const { SourceCode } = require("../languages/js/source-code");
 
 //------------------------------------------------------------------------------
@@ -619,10 +620,7 @@ class RuleTester {
                         }
                     }
                 },
-                language: defaultConfig[0].language,
-                languageOptions: {
-                    ...defaultConfig[0].languageOptions
-                }
+                language: defaultConfig[0].language
             },
             ...defaultConfig.slice(1)
         ];
@@ -673,7 +671,10 @@ class RuleTester {
                 const calculatedConfig = proto[ConfigArraySymbol.finalizeConfig].apply(this, args);
 
                 // wrap the parser to catch start/end property access
-                calculatedConfig.languageOptions.parser = wrapParser(calculatedConfig.languageOptions.parser);
+                if (calculatedConfig.language === jslang) {
+                    calculatedConfig.languageOptions.parser = wrapParser(calculatedConfig.languageOptions.parser);
+                }
+
                 return calculatedConfig;
             };
 
@@ -694,17 +695,6 @@ class RuleTester {
                     delete itemConfig[parameter];
                 }
 
-                // wrap any parsers
-                if (itemConfig.languageOptions && itemConfig.languageOptions.parser) {
-
-                    const parser = itemConfig.languageOptions.parser;
-
-                    if (parser && typeof parser !== "object") {
-                        throw new Error("Parser must be an object with a parse() or parseForESLint() method.");
-                    }
-
-                }
-
                 /*
                  * Create the config object from the tester config and this item
                  * specific configurations.

package/lib/rules/camelcase.js

@@ -238,6 +238,13 @@ module.exports = {
                 return;
             }
 
+            /*
+             * Import attribute keys are always ignored
+             */
+            if (astUtils.isImportAttributeKey(node)) {
+                return;
+            }
+
             report(node);
         }
 
@@ -272,7 +279,7 @@ module.exports = {
                 for (const reference of scope.through) {
                     const id = reference.identifier;
 
-                    if (isGoodName(id.name)) {
+                    if (isGoodName(id.name) || astUtils.isImportAttributeKey(id)) {
                         continue;
                     }
 
@@ -326,7 +333,7 @@ module.exports = {
                 "MethodDefinition > PrivateIdentifier.key",
                 "PropertyDefinition > PrivateIdentifier.key"
             ]](node) {
-                if (properties === "never" || isGoodName(node.name)) {
+                if (properties === "never" || astUtils.isImportAttributeKey(node) || isGoodName(node.name)) {
                     return;
                 }
                 report(node);

package/lib/rules/id-denylist.js

@@ -6,6 +6,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -154,6 +160,12 @@ module.exports = {
          * @returns {boolean} `true` if the node should be checked.
          */
         function shouldCheck(node) {
+
+            // Import attributes are defined by environments, so naming conventions shouldn't apply to them
+            if (astUtils.isImportAttributeKey(node)) {
+                return false;
+            }
+
             const parent = node.parent;
 
             /*

package/lib/rules/id-length.js

@@ -11,7 +11,7 @@
 //------------------------------------------------------------------------------
 
 const { getGraphemeCount } = require("../shared/string-utils");
-const { getModuleExportName } = require("./utils/ast-utils");
+const { getModuleExportName, isImportAttributeKey } = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -115,7 +115,7 @@ module.exports = {
                         isKeyAndValueSame && parent.key === node && properties
                     );
                 }
-                return properties && !parent.computed && parent.key.name === node.name;
+                return properties && !isImportAttributeKey(node) && !parent.computed && parent.key.name === node.name;
             },
             ImportSpecifier(parent, node) {
                 return (

package/lib/rules/id-match.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -180,7 +186,7 @@ module.exports = {
                     parent = node.parent,
                     effectiveParent = (parent.type === "MemberExpression") ? parent.parent : parent;
 
-                if (isReferenceToGlobalVariable(node)) {
+                if (isReferenceToGlobalVariable(node) || astUtils.isImportAttributeKey(node)) {
                     return;
                 }
 

package/lib/rules/utils/ast-utils.js

@@ -1054,7 +1054,7 @@ let needsPrecedingSemicolon;
 {
     const BREAK_OR_CONTINUE = new Set(["BreakStatement", "ContinueStatement"]);
 
-    // Declaration types that must contain a string Literal node at the end.
+    // Declaration types that cannot be continued by a punctuator when ending with a string Literal that is a direct child.
     const DECLARATIONS = new Set(["ExportAllDeclaration", "ExportNamedDeclaration", "ImportDeclaration"]);
 
     const IDENTIFIER_OR_KEYWORD = new Set(["Identifier", "Keyword"]);
@@ -1132,6 +1132,48 @@ let needsPrecedingSemicolon;
     };
 }
 
+/**
+ * Checks if a node is used as an import attribute key, either in a static or dynamic import.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} Whether the node is used as an import attribute key.
+ */
+function isImportAttributeKey(node) {
+    const { parent } = node;
+
+    // static import/re-export
+    if (parent.type === "ImportAttribute" && parent.key === node) {
+        return true;
+    }
+
+    // dynamic import
+    if (
+        parent.type === "Property" &&
+        !parent.computed &&
+        (parent.key === node || parent.value === node && parent.shorthand && !parent.method) &&
+        parent.parent.type === "ObjectExpression"
+    ) {
+        const objectExpression = parent.parent;
+        const objectExpressionParent = objectExpression.parent;
+
+        if (
+            objectExpressionParent.type === "ImportExpression" &&
+            objectExpressionParent.options === objectExpression
+        ) {
+            return true;
+        }
+
+        // nested key
+        if (
+            objectExpressionParent.type === "Property" &&
+            objectExpressionParent.value === objectExpression
+        ) {
+            return isImportAttributeKey(objectExpressionParent.key);
+        }
+    }
+
+    return false;
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -2288,5 +2330,6 @@ module.exports = {
     isTopLevelExpressionStatement,
     isDirective,
     isStartOfExpressionStatement,
-    needsPrecedingSemicolon
+    needsPrecedingSemicolon,
+    isImportAttributeKey
 };

package/lib/types/index.d.ts

@@ -1179,6 +1179,9 @@ export namespace Linter {
         ruleId: string | null;
         message: string;
         messageId?: string | undefined;
+        /**
+         * @deprecated `nodeType` is deprecated and will be removed in the next major version.
+         */
         nodeType?: string | undefined;
         fatal?: true | undefined;
         severity: Exclude<Severity, 0>;
@@ -1396,6 +1399,12 @@ export class ESLint {
 
     static readonly version: string;
 
+    /**
+     * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint.
+     * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present.
+     */
+    static readonly defaultConfig: Linter.Config[];
+
     static outputFixes(results: ESLint.LintResult[]): Promise<void>;
 
     static getErrorResults(results: ESLint.LintResult[]): ESLint.LintResult[];
@@ -1655,6 +1664,9 @@ export namespace RuleTester {
     interface TestCaseError {
         message?: string | RegExp;
         messageId?: string;
+        /**
+         * @deprecated `type` is deprecated and will be removed in the next major version.
+         */
         type?: string | undefined;
         data?: any;
         line?: number | undefined;

package/lib/types/rules/best-practices.d.ts

@@ -118,6 +118,11 @@ export interface BestPractices extends Linter.RulesRecord {
                  * @default 20
                  */
                 maximum: number;
+                /**
+                 * @default "classic"
+                 * @since 9.12.0
+                 */
+                variant: "classic" | "modified";
             }>
             | number,
         ]
@@ -185,6 +190,7 @@ export interface BestPractices extends Linter.RulesRecord {
      * Rule to enforce consistent newlines before and after dots.
      *
      * @since 0.21.0
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/dot-location) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/dot-location
      */
     "dot-location": Linter.RuleEntry<["object" | "property"]>;
@@ -417,6 +423,10 @@ export interface BestPractices extends Linter.RulesRecord {
                  * @default false
                  */
                 allowEmptyCase: boolean;
+                /**
+                 * @default false
+                 */
+                reportUnusedFallthroughComment: boolean;
             }>,
         ]
     >;
@@ -425,6 +435,7 @@ export interface BestPractices extends Linter.RulesRecord {
      * Rule to disallow leading or trailing decimal points in numeric literals.
      *
      * @since 0.0.6
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/no-floating-decimal) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/no-floating-decimal
      */
     "no-floating-decimal": Linter.RuleEntry<[]>;
@@ -601,6 +612,7 @@ export interface BestPractices extends Linter.RulesRecord {
      * Rule to disallow multiple spaces.
      *
      * @since 0.9.0
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/no-multi-spaces) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/no-multi-spaces
      */
     "no-multi-spaces": Linter.RuleEntry<
@@ -872,6 +884,15 @@ export interface BestPractices extends Linter.RulesRecord {
      */
     "no-unused-labels": Linter.RuleEntry<[]>;
 
+    /**
+     * Disallow variable assignments when the value is not used
+     *
+     *
+     * @since 9.0.0-alpha.1
+     * @see https://eslint.org/docs/latest/rules/no-useless-assignment
+     */
+    "no-useless-assignment": Linter.RuleEntry<[]>;
+
     /**
      * Disallow useless backreferences in regular expressions
      *
@@ -1045,12 +1066,21 @@ export interface BestPractices extends Linter.RulesRecord {
     "require-await": Linter.RuleEntry<[]>;
 
     /**
-     * Rule to enforce the use of `u` flag on RegExp.
+     * Enforce the use of `u` or `v` flag on RegExp
      *
      * @since 5.3.0
      * @see https://eslint.org/docs/rules/require-unicode-regexp
      */
-    "require-unicode-regexp": Linter.RuleEntry<[]>;
+    "require-unicode-regexp": Linter.RuleEntry<
+        [
+            Partial<{
+                /**
+                 * @default false
+                 */
+                requireFlag: "u" | "v";
+            }>,
+        ]
+    >;
 
     /**
      * Rule to require `var` declarations be placed at the top of their containing scope.
@@ -1064,6 +1094,7 @@ export interface BestPractices extends Linter.RulesRecord {
      * Rule to require parentheses around immediate `function` invocations.
      *
      * @since 0.0.9
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/wrap-iife) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/wrap-iife
      */
     "wrap-iife": Linter.RuleEntry<

package/lib/types/rules/deprecated.d.ts

@@ -191,6 +191,24 @@ export interface Deprecated extends Linter.RulesRecord {
      */
     "no-negated-in-lhs": Linter.RuleEntry<[]>;
 
+    /**
+     * Rule to disallow `Object` constructors.
+     *
+     * @since 0.0.9
+     * @deprecated since 8.50.0, use [`no-object-constructor`](https://eslint.org/docs/rules/no-object-constructor) instead.
+     * @see https://eslint.org/docs/rules/no-object-constructor
+     */
+    "no-new-object": Linter.RuleEntry<[]>;
+
+    /**
+     * Rule to disallow `new` operators with the `Symbol` object.
+     *
+     * @since 2.0.0-beta.1
+     * @deprecated since 8.27.0, use [`no-new-native-nonconstructor`](https://eslint.org/docs/rules/no-new-native-nonconstructor) instead.
+     * @see https://eslint.org/docs/rules/no-new-symbol
+     */
+    "no-new-symbol": Linter.RuleEntry<[]>;
+
     /**
      * Rule to disallow spacing between function identifiers and their applications.
      *
@@ -214,81 +232,4 @@ export interface Deprecated extends Linter.RulesRecord {
             }>,
         ]
     >;
-
-    /**
-     * Rule to require JSDoc comments.
-     *
-     * @since 1.4.0
-     * @deprecated since 5.10.0
-     * @see https://eslint.org/docs/rules/require-jsdoc
-     */
-    "require-jsdoc": Linter.RuleEntry<
-        [
-            Partial<{
-                require: Partial<{
-                    /**
-                     * @default true
-                     */
-                    FunctionDeclaration: boolean;
-                    /**
-                     * @default false
-                     */
-                    MethodDefinition: boolean;
-                    /**
-                     * @default false
-                     */
-                    ClassDeclaration: boolean;
-                    /**
-                     * @default false
-                     */
-                    ArrowFunctionExpression: boolean;
-                    /**
-                     * @default false
-                     */
-                    FunctionExpression: boolean;
-                }>;
-            }>,
-        ]
-    >;
-
-    /**
-     * Rule to enforce valid JSDoc comments.
-     *
-     * @since 0.4.0
-     * @deprecated since 5.10.0
-     * @see https://eslint.org/docs/rules/valid-jsdoc
-     */
-    "valid-jsdoc": Linter.RuleEntry<
-        [
-            Partial<{
-                prefer: Record<string, string>;
-                preferType: Record<string, string>;
-                /**
-                 * @default true
-                 */
-                requireReturn: boolean;
-                /**
-                 * @default true
-                 */
-                requireReturnType: boolean;
-                /**
-                 * @remarks
-                 * Also accept for regular expression pattern
-                 */
-                matchDescription: string;
-                /**
-                 * @default true
-                 */
-                requireParamDescription: boolean;
-                /**
-                 * @default true
-                 */
-                requireReturnDescription: boolean;
-                /**
-                 * @default true
-                 */
-                requireParamType: boolean;
-            }>,
-        ]
-    >;
 }