eslint 9.14.0 → 9.16.0

package/lib/rules/require-atomic-updates.js

@@ -170,6 +170,10 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{
+            allowProperties: false
+        }],
+
         docs: {
             description: "Disallow assignments that can lead to race conditions due to usage of `await` or `yield`",
             recommended: false,
@@ -182,8 +186,7 @@ module.exports = {
             type: "object",
             properties: {
                 allowProperties: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -196,7 +199,7 @@ module.exports = {
     },
 
     create(context) {
-        const allowProperties = !!context.options[0] && context.options[0].allowProperties;
+        const [{ allowProperties }] = context.options;
 
         const sourceCode = context.sourceCode;
         const assignmentReferences = new Map();

package/lib/rules/sort-imports.js

@@ -14,6 +14,14 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allowSeparatedGroups: false,
+            ignoreCase: false,
+            ignoreDeclarationSort: false,
+            ignoreMemberSort: false,
+            memberSyntaxSortOrder: ["none", "all", "multiple", "single"]
+        }],
+
         docs: {
             description: "Enforce sorted import declarations within modules",
             recommended: false,
@@ -25,8 +33,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     ignoreCase: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     memberSyntaxSortOrder: {
                         type: "array",
@@ -38,16 +45,13 @@ module.exports = {
                         maxItems: 4
                     },
                     ignoreDeclarationSort: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     ignoreMemberSort: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowSeparatedGroups: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -64,14 +68,14 @@ module.exports = {
     },
 
     create(context) {
-
-        const configuration = context.options[0] || {},
-            ignoreCase = configuration.ignoreCase || false,
-            ignoreDeclarationSort = configuration.ignoreDeclarationSort || false,
-            ignoreMemberSort = configuration.ignoreMemberSort || false,
-            memberSyntaxSortOrder = configuration.memberSyntaxSortOrder || ["none", "all", "multiple", "single"],
-            allowSeparatedGroups = configuration.allowSeparatedGroups || false,
-            sourceCode = context.sourceCode;
+        const [{
+            ignoreCase,
+            ignoreDeclarationSort,
+            ignoreMemberSort,
+            memberSyntaxSortOrder,
+            allowSeparatedGroups
+        }] = context.options;
+        const sourceCode = context.sourceCode;
         let previousDeclaration = null;
 
         /**

package/lib/rules/sort-keys.js

@@ -80,6 +80,14 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["asc", {
+            allowLineSeparatedGroups: false,
+            caseSensitive: true,
+            ignoreComputedKeys: false,
+            minKeys: 2,
+            natural: false
+        }],
+
         docs: {
             description: "Require object keys to be sorted",
             recommended: false,
@@ -94,21 +102,20 @@ module.exports = {
                 type: "object",
                 properties: {
                     caseSensitive: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     },
                     natural: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     minKeys: {
                         type: "integer",
-                        minimum: 2,
-                        default: 2
+                        minimum: 2
                     },
                     allowLineSeparatedGroups: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
+                    },
+                    ignoreComputedKeys: {
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -121,14 +128,8 @@ module.exports = {
     },
 
     create(context) {
-
-        // Parse options.
-        const order = context.options[0] || "asc";
-        const options = context.options[1];
-        const insensitive = options && options.caseSensitive === false;
-        const natural = options && options.natural;
-        const minKeys = options && options.minKeys;
-        const allowLineSeparatedGroups = options && options.allowLineSeparatedGroups || false;
+        const [order, { caseSensitive, natural, minKeys, allowLineSeparatedGroups, ignoreComputedKeys }] = context.options;
+        const insensitive = !caseSensitive;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natural ? "N" : "")
         ];
@@ -163,6 +164,11 @@ module.exports = {
                     return;
                 }
 
+                if (ignoreComputedKeys && node.computed) {
+                    stack.prevName = null; // reset sort
+                    return;
+                }
+
                 const prevName = stack.prevName;
                 const numKeys = stack.numKeys;
                 const thisName = getPropertyName(node);

package/lib/rules/sort-vars.js

@@ -14,6 +14,10 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            ignoreCase: false
+        }],
+
         docs: {
             description: "Require variables within the same declaration block to be sorted",
             recommended: false,
@@ -25,8 +29,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     ignoreCase: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -41,10 +44,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.",
@@ -81,8 +84,7 @@ module.exports = {
 
     create(context) {
 
-        const enforceForSwitchCase = !context.options[0] || context.options[0].enforceForSwitchCase;
-        const enforceForIndexOf = context.options[0] && context.options[0].enforceForIndexOf;
+        const [{ enforceForIndexOf, enforceForSwitchCase }] = context.options;
         const sourceCode = context.sourceCode;
 
         const fixableOperators = new Set(["==", "===", "!=", "!=="]);

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

@@ -2311,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,

package/lib/rules/valid-typeof.js

@@ -19,6 +19,10 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{
+            requireStringLiterals: false
+        }],
+
         docs: {
             description: "Enforce comparing `typeof` expressions against valid strings",
             recommended: true,
@@ -32,8 +36,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     requireStringLiterals: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -47,11 +50,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. */