eslint 9.13.0 → 9.15.0

package/lib/rules/complexity.js

@@ -17,11 +17,15 @@ const { upperCaseFirst } = require("../shared/string-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+const THRESHOLD_DEFAULT = 20;
+
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [THRESHOLD_DEFAULT],
+
         docs: {
             description: "Enforce a maximum cyclomatic complexity allowed in a program",
             recommended: false,
@@ -63,19 +67,19 @@ module.exports = {
 
     create(context) {
         const option = context.options[0];
-        let THRESHOLD = 20;
+        let threshold = THRESHOLD_DEFAULT;
         let VARIANT = "classic";
 
         if (typeof option === "object") {
             if (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) {
-                THRESHOLD = option.maximum || option.max;
+                threshold = option.maximum || option.max;
             }
 
             if (Object.hasOwn(option, "variant")) {
                 VARIANT = option.variant;
             }
         } else if (typeof option === "number") {
-            THRESHOLD = option;
+            threshold = option;
         }
 
         const IS_MODIFIED_COMPLEXITY = VARIANT === "modified";
@@ -160,7 +164,7 @@ module.exports = {
                     return;
                 }
 
-                if (complexity > THRESHOLD) {
+                if (complexity > threshold) {
                     let name;
 
                     if (codePath.origin === "class-field-initializer") {
@@ -177,7 +181,7 @@ module.exports = {
                         data: {
                             name: upperCaseFirst(name),
                             complexity,
-                            max: THRESHOLD
+                            max: threshold
                         }
                     });
                 }

package/lib/rules/consistent-return.js

@@ -62,13 +62,14 @@ module.exports = {
             type: "object",
             properties: {
                 treatUndefinedAsUnspecified: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 }
             },
             additionalProperties: false
         }],
 
+        defaultOptions: [{ treatUndefinedAsUnspecified: false }],
+
         messages: {
             missingReturn: "Expected to return a value at the end of {{name}}.",
             missingReturnValue: "{{name}} expected a return value.",
@@ -77,8 +78,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const treatUndefinedAsUnspecified = options.treatUndefinedAsUnspecified === true;
+        const [{ treatUndefinedAsUnspecified }] = context.options;
         let funcInfo = null;
 
         /**

package/lib/rules/consistent-this.js

@@ -28,6 +28,8 @@ module.exports = {
             uniqueItems: true
         },
 
+        defaultOptions: ["that"],
+
         messages: {
             aliasNotAssignedToThis: "Designated alias '{{name}}' is not assigned to 'this'.",
             unexpectedAlias: "Unexpected alias '{{name}}' for 'this'."
@@ -35,15 +37,9 @@ module.exports = {
     },
 
     create(context) {
-        let aliases = [];
+        const aliases = context.options;
         const sourceCode = context.sourceCode;
 
-        if (context.options.length === 0) {
-            aliases.push("that");
-        } else {
-            aliases = context.options;
-        }
-
         /**
          * Reports that a variable declarator or assignment expression is assigning
          * a non-'this' value to the specified alias.

package/lib/rules/curly.js

@@ -53,6 +53,8 @@ module.exports = {
             ]
         },
 
+        defaultOptions: ["all"],
+
         fixable: "code",
 
         messages: {
@@ -64,7 +66,6 @@ module.exports = {
     },
 
     create(context) {
-
         const multiOnly = (context.options[0] === "multi");
         const multiLine = (context.options[0] === "multi-line");
         const multiOrNest = (context.options[0] === "multi-or-nest");
@@ -108,40 +109,6 @@ module.exports = {
             return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
         }
 
-        /**
-         * Determines if the given node is a lexical declaration (let, const, function, or class)
-         * @param {ASTNode} node The node to check
-         * @returns {boolean} True if the node is a lexical declaration
-         * @private
-         */
-        function isLexicalDeclaration(node) {
-            if (node.type === "VariableDeclaration") {
-                return node.kind === "const" || node.kind === "let";
-            }
-
-            return node.type === "FunctionDeclaration" || node.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} node The node to check.
-         * @returns {boolean} `true` if the node is followed by an `else` keyword token.
-         */
-        function isFollowedByElseKeyword(node) {
-            const nextToken = sourceCode.getTokenAfter(node);
-
-            return Boolean(nextToken) && isElseKeywordToken(nextToken);
-        }
-
         /**
          * Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.
          * @param {Token} closingBracket The } token
@@ -196,110 +163,6 @@ module.exports = {
             return false;
         }
 
-        /**
-         * 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} node 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(node) {
-            switch (node.type) {
-                case "IfStatement":
-                    if (!node.alternate) {
-                        return true;
-                    }
-                    return hasUnsafeIf(node.alternate);
-                case "ForStatement":
-                case "ForInStatement":
-                case "ForOfStatement":
-                case "LabeledStatement":
-                case "WithStatement":
-                case "WhileStatement":
-                    return hasUnsafeIf(node.body);
-                default:
-                    return false;
-            }
-        }
-
-        /**
-         * 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.
-         * @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.
-         */
-        function areBracesNecessary(node) {
-            const statement = node.body[0];
-
-            return isLexicalDeclaration(statement) ||
-                hasUnsafeIf(statement) && isFollowedByElseKeyword(node);
-        }
-
         /**
          * Prepares to check the body of a node to see if it's a block statement.
          * @param {ASTNode} node The node to report if there's a problem.
@@ -318,7 +181,7 @@ module.exports = {
             const hasBlock = (body.type === "BlockStatement");
             let expected = null;
 
-            if (hasBlock && (body.body.length !== 1 || areBracesNecessary(body))) {
+            if (hasBlock && (body.body.length !== 1 || astUtils.areBracesNecessary(body, sourceCode))) {
                 expected = true;
             } else if (multiOnly) {
                 expected = false;

package/lib/rules/default-case.js

@@ -15,6 +15,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Require `default` cases in `switch` statements",
             recommended: false,
@@ -37,7 +39,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
+        const [options] = context.options;
         const commentPattern = options.commentPattern
             ? new RegExp(options.commentPattern, "u")
             : DEFAULT_COMMENT_PATTERN;

package/lib/rules/dot-notation.js

@@ -25,6 +25,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allowKeywords: true,
+            allowPattern: ""
+        }],
+
         docs: {
             description: "Enforce dot notation whenever possible",
             recommended: false,
@@ -36,12 +41,10 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowKeywords: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     },
                     allowPattern: {
-                        type: "string",
-                        default: ""
+                        type: "string"
                     }
                 },
                 additionalProperties: false
@@ -57,8 +60,8 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const allowKeywords = options.allowKeywords === void 0 || options.allowKeywords;
+        const [options] = context.options;
+        const allowKeywords = options.allowKeywords;
         const sourceCode = context.sourceCode;
 
         let allowPattern;

package/lib/rules/func-names.js

@@ -29,6 +29,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["always", {}],
+
         docs: {
             description: "Require or disallow named `function` expressions",
             recommended: false,
@@ -68,7 +70,6 @@ module.exports = {
     },
 
     create(context) {
-
         const sourceCode = context.sourceCode;
 
         /**
@@ -79,13 +80,12 @@ module.exports = {
         function getConfigForNode(node) {
             if (
                 node.generator &&
-                context.options.length > 1 &&
                 context.options[1].generators
             ) {
                 return context.options[1].generators;
             }
 
-            return context.options[0] || "always";
+            return context.options[0];
         }
 
         /**

package/lib/rules/func-style.js

@@ -13,6 +13,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["expression", {
+            allowArrowFunctions: false,
+            overrides: {}
+        }],
+
         docs: {
             description: "Enforce the consistent use of either `function` declarations or expressions assigned to variables",
             recommended: false,
@@ -27,8 +32,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowArrowFunctions: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     overrides: {
                         type: "object",
@@ -51,12 +55,10 @@ module.exports = {
     },
 
     create(context) {
-
-        const style = context.options[0],
-            allowArrowFunctions = context.options[1] && context.options[1].allowArrowFunctions,
-            enforceDeclarations = (style === "declaration"),
-            exportFunctionStyle = context.options[1] && context.options[1].overrides && context.options[1].overrides.namedExports,
-            stack = [];
+        const [style, { allowArrowFunctions, overrides }] = context.options;
+        const enforceDeclarations = (style === "declaration");
+        const { namedExports: exportFunctionStyle } = overrides;
+        const stack = [];
 
         const nodesToCheck = {
             FunctionDeclaration(node) {

package/lib/rules/getter-return.js

@@ -42,6 +42,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Enforce `return` statements in getters",
             recommended: true,
@@ -55,8 +57,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowImplicit: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -70,8 +71,7 @@ module.exports = {
     },
 
     create(context) {
-
-        const options = context.options[0] || { allowImplicit: false };
+        const [{ allowImplicit }] = context.options;
         const sourceCode = context.sourceCode;
 
         let funcInfo = {
@@ -184,7 +184,7 @@ module.exports = {
                     funcInfo.hasReturn = true;
 
                     // if allowImplicit: false, should also check node.argument
-                    if (!options.allowImplicit && !node.argument) {
+                    if (!allowImplicit && !node.argument) {
                         context.report({
                             node,
                             messageId: "expected",

package/lib/rules/grouped-accessor-pairs.js

@@ -95,6 +95,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["anyOrder"],
+
         docs: {
             description: "Require grouped accessor pairs in object literals and classes",
             recommended: false,
@@ -114,7 +116,7 @@ module.exports = {
     },
 
     create(context) {
-        const order = context.options[0] || "anyOrder";
+        const [order] = context.options;
         const sourceCode = context.sourceCode;
 
         /**

package/lib/rules/id-denylist.js

@@ -6,6 +6,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -98,6 +104,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [],
+
         docs: {
             description: "Disallow specified identifiers",
             recommended: false,
@@ -118,7 +126,6 @@ module.exports = {
     },
 
     create(context) {
-
         const denyList = new Set(context.options);
         const reportedNodes = new Set();
         const sourceCode = context.sourceCode;
@@ -154,6 +161,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
@@ -22,6 +22,12 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            exceptionPatterns: [],
+            exceptions: [],
+            min: 2
+        }],
+
         docs: {
             description: "Enforce minimum and maximum identifier lengths",
             recommended: false,
@@ -33,8 +39,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     min: {
-                        type: "integer",
-                        default: 2
+                        type: "integer"
                     },
                     max: {
                         type: "integer"
@@ -69,12 +74,11 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const minLength = typeof options.min !== "undefined" ? options.min : 2;
-        const maxLength = typeof options.max !== "undefined" ? options.max : Infinity;
+        const [options] = context.options;
+        const { max: maxLength = Infinity, min: minLength } = options;
         const properties = options.properties !== "never";
         const exceptions = new Set(options.exceptions);
-        const exceptionPatterns = (options.exceptionPatterns || []).map(pattern => new RegExp(pattern, "u"));
+        const exceptionPatterns = options.exceptionPatterns.map(pattern => new RegExp(pattern, "u"));
         const reportedNodes = new Set();
 
         /**
@@ -115,7 +119,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
 //------------------------------------------------------------------------------
@@ -14,6 +20,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["^.+$", {}],
+
         docs: {
             description: "Require identifiers to match a specified regular expression",
             recommended: false,
@@ -28,20 +36,16 @@ module.exports = {
                 type: "object",
                 properties: {
                     properties: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     classFields: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     onlyDeclarations: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     ignoreDestructuring: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -58,14 +62,13 @@ module.exports = {
         //--------------------------------------------------------------------------
         // Options
         //--------------------------------------------------------------------------
-        const pattern = context.options[0] || "^.+$",
-            regexp = new RegExp(pattern, "u");
-
-        const options = context.options[1] || {},
-            checkProperties = !!options.properties,
-            checkClassFields = !!options.classFields,
-            onlyDeclarations = !!options.onlyDeclarations,
-            ignoreDestructuring = !!options.ignoreDestructuring;
+        const [pattern, {
+            classFields: checkClassFields,
+            ignoreDestructuring,
+            onlyDeclarations,
+            properties: checkProperties
+        }] = context.options;
+        const regexp = new RegExp(pattern, "u");
 
         const sourceCode = context.sourceCode;
         let globalScope;
@@ -180,7 +183,7 @@ module.exports = {
                     parent = node.parent,
                     effectiveParent = (parent.type === "MemberExpression") ? parent.parent : parent;
 
-                if (isReferenceToGlobalVariable(node)) {
+                if (isReferenceToGlobalVariable(node) || astUtils.isImportAttributeKey(node)) {
                     return;
                 }