eslint 9.13.0 → 9.15.0

package/lib/rules/sort-vars.js

@@ -14,6 +14,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Require variables within the same declaration block to be sorted",
             recommended: false,
@@ -41,10 +43,8 @@ module.exports = {
     },
 
     create(context) {
-
-        const configuration = context.options[0] || {},
-            ignoreCase = configuration.ignoreCase || false,
-            sourceCode = context.sourceCode;
+        const [{ ignoreCase }] = context.options;
+        const sourceCode = context.sourceCode;
 
         return {
             VariableDeclaration(node) {

package/lib/rules/strict.js

@@ -68,6 +68,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["safe"],
+
         docs: {
             description: "Require or disallow strict mode directives",
             recommended: false,
@@ -96,11 +98,10 @@ module.exports = {
     },
 
     create(context) {
-
         const ecmaFeatures = context.parserOptions.ecmaFeatures || {},
             scopes = [],
             classScopes = [];
-        let mode = context.options[0] || "safe";
+        let [mode] = context.options;
 
         if (ecmaFeatures.impliedStrict) {
             mode = "implied";

package/lib/rules/unicode-bom.js

@@ -13,6 +13,8 @@ module.exports = {
     meta: {
         type: "layout",
 
+        defaultOptions: ["never"],
+
         docs: {
             description: "Require or disallow Unicode byte order mark (BOM)",
             recommended: false,
@@ -43,8 +45,8 @@ module.exports = {
             Program: function checkUnicodeBOM(node) {
 
                 const sourceCode = context.sourceCode,
-                    location = { column: 0, line: 1 },
-                    requireBOM = context.options[0] || "never";
+                    location = { column: 0, line: 1 };
+                const [requireBOM] = context.options;
 
                 if (!sourceCode.hasBOM && (requireBOM === "always")) {
                     context.report({

package/lib/rules/use-isnan.js

@@ -56,18 +56,21 @@ module.exports = {
                 type: "object",
                 properties: {
                     enforceForSwitchCase: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     },
                     enforceForIndexOf: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
             }
         ],
 
+        defaultOptions: [{
+            enforceForIndexOf: false,
+            enforceForSwitchCase: true
+        }],
+
         messages: {
             comparisonWithNaN: "Use the isNaN function to compare with NaN.",
             switchNaN: "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",

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
 //------------------------------------------------------------------------------
@@ -2269,6 +2311,147 @@ module.exports = {
         return node.type === "TemplateLiteral" && node.expressions.length === 0;
     },
 
+    /**
+     * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code.
+     * The braces, which make the given block body, are necessary in either of the following situations:
+     *
+     * 1. The statement is a lexical declaration.
+     * 2. Without the braces, an `if` within the statement would become associated with an `else` after the closing brace:
+     *
+     *     if (a) {
+     *         if (b)
+     *             foo();
+     *     }
+     *     else
+     *         bar();
+     *
+     *     if (a)
+     *         while (b)
+     *             while (c) {
+     *                 while (d)
+     *                     if (e)
+     *                         while(f)
+     *                             foo();
+     *            }
+     *     else
+     *         bar();
+     * @param {ASTNode} node `BlockStatement` body with exactly one statement directly inside. The statement can have its own nested statements.
+     * @param {SourceCode} sourceCode The source code
+     * @returns {boolean} `true` if the braces are necessary - removing them (replacing the given `BlockStatement` body with its single statement content)
+     * would change the semantics of the code or produce a syntax error.
+     */
+    areBracesNecessary(node, sourceCode) {
+
+        /**
+         * Determines if the given node is a lexical declaration (let, const, function, or class)
+         * @param {ASTNode} nodeToCheck The node to check
+         * @returns {boolean} True if the node is a lexical declaration
+         * @private
+         */
+        function isLexicalDeclaration(nodeToCheck) {
+            if (nodeToCheck.type === "VariableDeclaration") {
+                return nodeToCheck.kind === "const" || nodeToCheck.kind === "let";
+            }
+
+            return nodeToCheck.type === "FunctionDeclaration" || nodeToCheck.type === "ClassDeclaration";
+        }
+
+
+        /**
+         * Checks if the given token is an `else` token or not.
+         * @param {Token} token The token to check.
+         * @returns {boolean} `true` if the token is an `else` token.
+         */
+        function isElseKeywordToken(token) {
+            return token.value === "else" && token.type === "Keyword";
+        }
+
+        /**
+         * Determines whether the given node has an `else` keyword token as the first token after.
+         * @param {ASTNode} nodeToCheck The node to check.
+         * @returns {boolean} `true` if the node is followed by an `else` keyword token.
+         */
+        function isFollowedByElseKeyword(nodeToCheck) {
+            const nextToken = sourceCode.getTokenAfter(nodeToCheck);
+
+            return Boolean(nextToken) && isElseKeywordToken(nextToken);
+        }
+
+        /**
+         * Determines whether the code represented by the given node contains an `if` statement
+         * that would become associated with an `else` keyword directly appended to that code.
+         *
+         * Examples where it returns `true`:
+         *
+         *    if (a)
+         *        foo();
+         *
+         *    if (a) {
+         *        foo();
+         *    }
+         *
+         *    if (a)
+         *        foo();
+         *    else if (b)
+         *        bar();
+         *
+         *    while (a)
+         *        if (b)
+         *            if(c)
+         *                foo();
+         *            else
+         *                bar();
+         *
+         * Examples where it returns `false`:
+         *
+         *    if (a)
+         *        foo();
+         *    else
+         *        bar();
+         *
+         *    while (a) {
+         *        if (b)
+         *            if(c)
+         *                foo();
+         *            else
+         *                bar();
+         *    }
+         *
+         *    while (a)
+         *        if (b) {
+         *            if(c)
+         *                foo();
+         *        }
+         *        else
+         *            bar();
+         * @param {ASTNode} nodeToCheck Node representing the code to check.
+         * @returns {boolean} `true` if an `if` statement within the code would become associated with an `else` appended to that code.
+         */
+        function hasUnsafeIf(nodeToCheck) {
+            switch (nodeToCheck.type) {
+                case "IfStatement":
+                    if (!nodeToCheck.alternate) {
+                        return true;
+                    }
+                    return hasUnsafeIf(nodeToCheck.alternate);
+                case "ForStatement":
+                case "ForInStatement":
+                case "ForOfStatement":
+                case "LabeledStatement":
+                case "WithStatement":
+                case "WhileStatement":
+                    return hasUnsafeIf(nodeToCheck.body);
+                default:
+                    return false;
+            }
+        }
+
+        const statement = node.body[0];
+
+        return isLexicalDeclaration(statement) ||
+          hasUnsafeIf(statement) && isFollowedByElseKeyword(node);
+    },
+
     isReferenceToGlobalVariable,
     isLogicalExpression,
     isCoalesceExpression,
@@ -2288,5 +2471,6 @@ module.exports = {
     isTopLevelExpressionStatement,
     isDirective,
     isStartOfExpressionStatement,
-    needsPrecedingSemicolon
+    needsPrecedingSemicolon,
+    isImportAttributeKey
 };

package/lib/rules/valid-typeof.js

@@ -19,6 +19,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Enforce comparing `typeof` expressions against valid strings",
             recommended: true,
@@ -47,11 +49,10 @@ module.exports = {
     },
 
     create(context) {
-
         const VALID_TYPES = new Set(["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"]),
             OPERATORS = new Set(["==", "===", "!=", "!=="]);
         const sourceCode = context.sourceCode;
-        const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;
+        const [{ requireStringLiterals }] = context.options;
 
         let globalScope;
 

package/lib/rules/yoda.js

@@ -111,6 +111,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["never", {
+            exceptRange: false,
+            onlyEquality: false
+        }],
+
         docs: {
             description: 'Require or disallow "Yoda" conditions',
             recommended: false,
@@ -125,12 +130,10 @@ module.exports = {
                 type: "object",
                 properties: {
                     exceptRange: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     onlyEquality: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -145,14 +148,8 @@ module.exports = {
     },
 
     create(context) {
-
-        // Default to "never" (!always) if no option
-        const always = context.options[0] === "always";
-        const exceptRange =
-            context.options[1] && context.options[1].exceptRange;
-        const onlyEquality =
-            context.options[1] && context.options[1].onlyEquality;
-
+        const [when, { exceptRange, onlyEquality }] = context.options;
+        const always = when === "always";
         const sourceCode = context.sourceCode;
 
         /**

package/lib/shared/assert.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Assertion utilities equivalent to the Node.js node:asserts module.
+ * @author Josh Goldberg
+ */
+
+"use strict";
+
+/**
+ * Throws an error if the input is not truthy.
+ * @param {unknown} value The input that is checked for being truthy.
+ * @param {string} message Message to throw if the input is not truthy.
+ * @returns {void}
+ * @throws {Error} When the condition is not truthy.
+ */
+function ok(value, message = "Assertion failed.") {
+    if (!value) {
+        throw new Error(message);
+    }
+}
+
+
+module.exports = ok;

package/lib/shared/deep-merge-arrays.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Applies default rule options
+ * @author JoshuaKGoldberg
+ */
+
+"use strict";
+
+/**
+ * Check if the variable contains an object strictly rejecting arrays
+ * @param {unknown} value an object
+ * @returns {boolean} Whether value is an object
+ */
+function isObjectNotArray(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Deeply merges second on top of first, creating a new {} object if needed.
+ * @param {T} first Base, default value.
+ * @param {U} second User-specified value.
+ * @returns {T | U | (T & U)} Merged equivalent of second on top of first.
+ */
+function deepMergeObjects(first, second) {
+    if (second === void 0) {
+        return first;
+    }
+
+    if (!isObjectNotArray(first) || !isObjectNotArray(second)) {
+        return second;
+    }
+
+    const result = { ...first, ...second };
+
+    for (const key of Object.keys(second)) {
+        if (Object.prototype.propertyIsEnumerable.call(first, key)) {
+            result[key] = deepMergeObjects(first[key], second[key]);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Deeply merges second on top of first, creating a new [] array if needed.
+ * @param {T[]} first Base, default values.
+ * @param {U[]} second User-specified values.
+ * @returns {(T | U | (T & U))[]} Merged equivalent of second on top of first.
+ */
+function deepMergeArrays(first, second) {
+    if (!first || !second) {
+        return second || first || [];
+    }
+
+    return [
+        ...first.map((value, i) => deepMergeObjects(value, i < second.length ? second[i] : void 0)),
+        ...second.slice(first.length)
+    ];
+}
+
+module.exports = { deepMergeArrays };

package/lib/shared/text-table.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Optimized version of the `text-table` npm module to improve performance by replacing inefficient regex-based
+ * whitespace trimming with a modern built-in method.
+ *
+ * This modification addresses a performance issue reported in https://github.com/eslint/eslint/issues/18709
+ *
+ * The `text-table` module is published under the MIT License. For the original source, refer to:
+ * https://www.npmjs.com/package/text-table.
+ */
+
+/*
+ *
+ * This software is released under the MIT license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+"use strict";
+
+module.exports = function(rows_, opts) {
+    const hsep = "  ";
+    const align = opts.align;
+    const stringLength = opts.stringLength;
+
+    const sizes = rows_.reduce((acc, row) => {
+        row.forEach((c, ix) => {
+            const n = stringLength(c);
+
+            if (!acc[ix] || n > acc[ix]) {
+                acc[ix] = n;
+            }
+        });
+        return acc;
+    }, []);
+
+    return rows_
+        .map(row =>
+            row
+                .map((c, ix) => {
+                    const n = sizes[ix] - stringLength(c) || 0;
+                    const s = Array(Math.max(n + 1, 1)).join(" ");
+
+                    if (align[ix] === "r") {
+                        return s + c;
+                    }
+
+                    return c + s;
+                })
+                .join(hsep)
+                .trimEnd())
+        .join("\n");
+};

package/lib/shared/types.js

@@ -148,6 +148,7 @@ module.exports = {};
 /**
  * @typedef {Object} RuleMeta
  * @property {boolean} [deprecated] If `true` then the rule has been deprecated.
+ * @property {Array} [defaultOptions] Default options for the rule.
  * @property {RuleMetaDocs} docs The document information of the rule.
  * @property {"code"|"whitespace"} [fixable] The autofix type.
  * @property {boolean} [hasSuggestions] If `true` then the rule provides suggestions.

package/lib/types/index.d.ts

@@ -741,6 +741,9 @@ export namespace Rule {
          */
         schema?: JSONSchema4 | JSONSchema4[] | false | undefined;
 
+        /** Any default options to be recursively merged on top of any user-provided options. */
+        defaultOptions?: unknown[];
+
         /** Indicates whether the rule has been deprecated. Omit if not deprecated. */
         deprecated?: boolean | undefined;
         /** The name of the rule(s) this rule was replaced by, if it was deprecated. */

package/lib/types/rules/ecmascript-6.d.ts

@@ -27,6 +27,37 @@
 
 import { Linter } from "../index";
 
+export interface NoRestrictedImportPathCommonOptions {
+    name: string;
+    message?: string;
+}
+
+export type EitherImportNamesOrAllowImportName =
+  | { importNames?: string[]; allowImportNames?: never }
+  | { allowImportNames?: string[]; importNames?: never }
+
+export type ValidNoRestrictedImportPathOptions = NoRestrictedImportPathCommonOptions & EitherImportNamesOrAllowImportName;
+
+export interface NoRestrictedImportPatternCommonOptions {
+    message?: string;
+    caseSensitive?: boolean;
+}
+
+// Base type for group or regex constraint, ensuring mutual exclusivity
+export type EitherGroupOrRegEx =
+  | { group: string[]; regex?: never }
+  | { regex: string; group?: never };
+
+// Base type for import name specifiers, ensuring mutual exclusivity
+export type EitherNameSpecifiers = 
+    | { importNames: string[]; allowImportNames?: never; importNamePattern?: never; allowImportNamePattern?: never }
+    | { importNamePattern: string; allowImportNames?: never; importNames?: never; allowImportNamePattern?: never }
+    | { allowImportNames: string[]; importNames?: never; importNamePattern?: never; allowImportNamePattern?: never }
+    | { allowImportNamePattern: string; importNames?: never; allowImportNames?: never; importNamePattern?: never }
+
+// Adds oneOf and not constraints, ensuring group or regex are present and mutually exclusive sets for importNames, allowImportNames, etc., as per the schema.
+export type ValidNoRestrictedImportPatternOptions = NoRestrictedImportPatternCommonOptions & EitherGroupOrRegEx & EitherNameSpecifiers;
+
 export interface ECMAScript6 extends Linter.RulesRecord {
     /**
      * Rule to require braces around arrow function bodies.
@@ -291,23 +322,12 @@ export interface ECMAScript6 extends Linter.RulesRecord {
         [
             ...Array<
                 | string
-                | {
-                    name: string;
-                    importNames?: string[] | undefined;
-                    message?: string | undefined;
-                }
+                | ValidNoRestrictedImportPathOptions
                 | Partial<{
-                    paths: Array<
-                        | string
-                        | {
-                            name: string;
-                            importNames?: string[] | undefined;
-                            message?: string | undefined;
-                        }
-                    >;
-                    patterns: string[];
-                }>
-            >,
+                      paths: Array<string | ValidNoRestrictedImportPathOptions>;
+                      patterns: Array<string | ValidNoRestrictedImportPatternOptions>;
+                  }>
+            >
         ]
     >;
 

package/lib/types/rules/stylistic-issues.d.ts

@@ -493,6 +493,7 @@ export interface StylisticIssues extends Linter.RulesRecord {
      * Rule to enforce consistent indentation.
      *
      * @since 0.14.0
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/indent) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/indent
      */
     indent: Linter.RuleEntry<
@@ -1746,6 +1747,7 @@ export interface StylisticIssues extends Linter.RulesRecord {
      * Rule to enforce the consistent use of either backticks, double, or single quotes.
      *
      * @since 0.0.7
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/quotes) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/quotes
      */
     quotes: Linter.RuleEntry<
@@ -1768,6 +1770,7 @@ export interface StylisticIssues extends Linter.RulesRecord {
      * Rule to require or disallow semicolons instead of ASI.
      *
      * @since 0.0.6
+     * @deprecated since 8.53.0, please use the [corresponding rule](https://eslint.style/rules/js/semi) in `@stylistic/eslint-plugin-js`.
      * @see https://eslint.org/docs/rules/semi
      */
     semi: