eslint 9.14.0 → 9.16.0

package/lib/rules/no-underscore-dangle.js

@@ -14,6 +14,18 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allow: [],
+            allowAfterSuper: false,
+            allowAfterThis: false,
+            allowAfterThisConstructor: false,
+            allowFunctionParams: true,
+            allowInArrayDestructuring: true,
+            allowInObjectDestructuring: true,
+            enforceInClassFields: false,
+            enforceInMethodNames: false
+        }],
+
         docs: {
             description: "Disallow dangling underscores in identifiers",
             recommended: false,
@@ -31,36 +43,28 @@ module.exports = {
                         }
                     },
                     allowAfterThis: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowAfterSuper: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowAfterThisConstructor: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     enforceInMethodNames: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowFunctionParams: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     },
                     enforceInClassFields: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowInArrayDestructuring: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     },
                     allowInObjectDestructuring: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -73,17 +77,17 @@ module.exports = {
     },
 
     create(context) {
-
-        const options = context.options[0] || {};
-        const ALLOWED_VARIABLES = options.allow ? options.allow : [];
-        const allowAfterThis = typeof options.allowAfterThis !== "undefined" ? options.allowAfterThis : false;
-        const allowAfterSuper = typeof options.allowAfterSuper !== "undefined" ? options.allowAfterSuper : false;
-        const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== "undefined" ? options.allowAfterThisConstructor : false;
-        const enforceInMethodNames = typeof options.enforceInMethodNames !== "undefined" ? options.enforceInMethodNames : false;
-        const enforceInClassFields = typeof options.enforceInClassFields !== "undefined" ? options.enforceInClassFields : false;
-        const allowFunctionParams = typeof options.allowFunctionParams !== "undefined" ? options.allowFunctionParams : true;
-        const allowInArrayDestructuring = typeof options.allowInArrayDestructuring !== "undefined" ? options.allowInArrayDestructuring : true;
-        const allowInObjectDestructuring = typeof options.allowInObjectDestructuring !== "undefined" ? options.allowInObjectDestructuring : true;
+        const [{
+            allow,
+            allowAfterSuper,
+            allowAfterThis,
+            allowAfterThisConstructor,
+            allowFunctionParams,
+            allowInArrayDestructuring,
+            allowInObjectDestructuring,
+            enforceInClassFields,
+            enforceInMethodNames
+        }] = context.options;
         const sourceCode = context.sourceCode;
 
         //-------------------------------------------------------------------------
@@ -97,7 +101,7 @@ module.exports = {
          * @private
          */
         function isAllowed(identifier) {
-            return ALLOWED_VARIABLES.includes(identifier);
+            return allow.includes(identifier);
         }
 
         /**

package/lib/rules/no-unneeded-ternary.js

@@ -28,6 +28,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{ defaultAssignment: true }],
+
         docs: {
             description: "Disallow ternary operators when simpler alternatives exist",
             recommended: false,
@@ -39,8 +41,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     defaultAssignment: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -56,8 +57,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const defaultAssignment = options.defaultAssignment !== false;
+        const [{ defaultAssignment }] = context.options;
         const sourceCode = context.sourceCode;
 
         /**

package/lib/rules/no-unreachable-loop.js

@@ -74,6 +74,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{ ignore: [] }],
+
         docs: {
             description: "Disallow loops with a body that allows only one iteration",
             recommended: false,
@@ -100,8 +102,8 @@ module.exports = {
     },
 
     create(context) {
-        const ignoredLoopTypes = context.options[0] && context.options[0].ignore || [],
-            loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
+        const [{ ignore: ignoredLoopTypes }] = context.options;
+        const loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
             loopSelector = loopTypesToCheck.join(","),
             loopsByTargetSegments = new Map(),
             loopsToReport = new Set();

package/lib/rules/no-unsafe-negation.js

@@ -51,6 +51,10 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{
+            enforceForOrderingRelations: false
+        }],
+
         docs: {
             description: "Disallow negating the left operand of relational operators",
             recommended: true,
@@ -64,8 +68,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     enforceForOrderingRelations: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -83,8 +86,7 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.sourceCode;
-        const options = context.options[0] || {};
-        const enforceForOrderingRelations = options.enforceForOrderingRelations === true;
+        const [{ enforceForOrderingRelations }] = context.options;
 
         return {
             BinaryExpression(node) {

package/lib/rules/no-unsafe-optional-chaining.js

@@ -23,6 +23,10 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{
+            disallowArithmeticOperators: false
+        }],
+
         docs: {
             description: "Disallow use of optional chaining in contexts where the `undefined` value is not allowed",
             recommended: true,
@@ -32,8 +36,7 @@ module.exports = {
             type: "object",
             properties: {
                 disallowArithmeticOperators: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -46,8 +49,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const disallowArithmeticOperators = (options.disallowArithmeticOperators) || false;
+        const [{ disallowArithmeticOperators }] = context.options;
 
         /**
          * Reports unsafe usage of optional chaining

package/lib/rules/no-unused-expressions.js

@@ -42,37 +42,41 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowShortCircuit: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowTernary: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowTaggedTemplates: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     enforceForJSX: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
             }
         ],
 
+        defaultOptions: [{
+            allowShortCircuit: false,
+            allowTernary: false,
+            allowTaggedTemplates: false,
+            enforceForJSX: false
+        }],
+
         messages: {
             unusedExpression: "Expected an assignment or function call and instead saw an expression."
         }
     },
 
     create(context) {
-        const config = context.options[0] || {},
-            allowShortCircuit = config.allowShortCircuit || false,
-            allowTernary = config.allowTernary || false,
-            allowTaggedTemplates = config.allowTaggedTemplates || false,
-            enforceForJSX = config.enforceForJSX || false;
+        const [{
+            allowShortCircuit,
+            allowTernary,
+            allowTaggedTemplates,
+            enforceForJSX
+        }] = context.options;
 
         /**
          * Has AST suggesting a directive.

package/lib/rules/no-use-before-define.js

@@ -18,21 +18,16 @@ const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
  * @returns {Object} The parsed options.
  */
 function parseOptions(options) {
-    let functions = true;
-    let classes = true;
-    let variables = true;
-    let allowNamedExports = false;
-
-    if (typeof options === "string") {
-        functions = (options !== "nofunc");
-    } else if (typeof options === "object" && options !== null) {
-        functions = options.functions !== false;
-        classes = options.classes !== false;
-        variables = options.variables !== false;
-        allowNamedExports = !!options.allowNamedExports;
+    if (typeof options === "object" && options !== null) {
+        return options;
     }
 
-    return { functions, classes, variables, allowNamedExports };
+    const functions =
+        typeof options === "string"
+            ? options !== "nofunc"
+            : true;
+
+    return { functions, classes: true, variables: true, allowNamedExports: false };
 }
 
 /**
@@ -251,6 +246,13 @@ module.exports = {
             }
         ],
 
+        defaultOptions: [{
+            classes: true,
+            functions: true,
+            variables: true,
+            allowNamedExports: false
+        }],
+
         messages: {
             usedBeforeDefined: "'{{name}}' was used before it was defined."
         }

package/lib/rules/no-useless-computed-key.js

@@ -58,7 +58,10 @@ function hasUselessComputedKey(node) {
 
     switch (node.type) {
         case "Property":
-            return value !== "__proto__";
+            if (node.parent.type === "ObjectExpression") {
+                return value !== "__proto__";
+            }
+            return true;
 
         case "PropertyDefinition":
             if (node.static) {
@@ -90,6 +93,10 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            enforceForClassMembers: true
+        }],
+
         docs: {
             description: "Disallow unnecessary computed property keys in objects and classes",
             recommended: false,
@@ -100,8 +107,7 @@ module.exports = {
             type: "object",
             properties: {
                 enforceForClassMembers: {
-                    type: "boolean",
-                    default: true
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -114,7 +120,7 @@ module.exports = {
     },
     create(context) {
         const sourceCode = context.sourceCode;
-        const enforceForClassMembers = context.options[0]?.enforceForClassMembers ?? true;
+        const [{ enforceForClassMembers }] = context.options;
 
         /**
          * Reports a given node if it violated this rule.

package/lib/rules/no-useless-rename.js

@@ -20,6 +20,12 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            ignoreDestructuring: false,
+            ignoreImport: false,
+            ignoreExport: false
+        }],
+
         docs: {
             description: "Disallow renaming import, export, and destructured assignments to the same name",
             recommended: false,
@@ -32,9 +38,9 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    ignoreDestructuring: { type: "boolean", default: false },
-                    ignoreImport: { type: "boolean", default: false },
-                    ignoreExport: { type: "boolean", default: false }
+                    ignoreDestructuring: { type: "boolean" },
+                    ignoreImport: { type: "boolean" },
+                    ignoreExport: { type: "boolean" }
                 },
                 additionalProperties: false
             }
@@ -46,11 +52,8 @@ module.exports = {
     },
 
     create(context) {
-        const sourceCode = context.sourceCode,
-            options = context.options[0] || {},
-            ignoreDestructuring = options.ignoreDestructuring === true,
-            ignoreImport = options.ignoreImport === true,
-            ignoreExport = options.ignoreExport === true;
+        const sourceCode = context.sourceCode;
+        const [{ ignoreDestructuring, ignoreImport, ignoreExport }] = context.options;
 
         //--------------------------------------------------------------------------
         // Helpers

package/lib/rules/no-void.js

@@ -13,6 +13,10 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allowAsStatement: false
+        }],
+
         docs: {
             description: "Disallow `void` operators",
             recommended: false,
@@ -28,8 +32,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowAsStatement: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -38,8 +41,7 @@ module.exports = {
     },
 
     create(context) {
-        const allowAsStatement =
-            context.options[0] && context.options[0].allowAsStatement;
+        const [{ allowAsStatement }] = context.options;
 
         //--------------------------------------------------------------------------
         // Public

package/lib/rules/no-warning-comments.js

@@ -19,6 +19,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            location: "start",
+            terms: ["todo", "fixme", "xxx"]
+        }],
+
         docs: {
             description: "Disallow specified warning terms in comments",
             recommended: false,
@@ -58,12 +63,10 @@ module.exports = {
     },
 
     create(context) {
-        const sourceCode = context.sourceCode,
-            configuration = context.options[0] || {},
-            warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
-            location = configuration.location || "start",
-            decoration = [...configuration.decoration || []].join(""),
-            selfConfigRegEx = /\bno-warning-comments\b/u;
+        const sourceCode = context.sourceCode;
+        const [{ decoration, location, terms: warningTerms }] = context.options;
+        const escapedDecoration = escapeRegExp(decoration ? decoration.join("") : "");
+        const selfConfigRegEx = /\bno-warning-comments\b/u;
 
         /**
          * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
@@ -74,7 +77,6 @@ module.exports = {
          */
         function convertToRegExp(term) {
             const escaped = escapeRegExp(term);
-            const escapedDecoration = escapeRegExp(decoration);
 
             /*
              * When matching at the start, ignore leading whitespace, and

package/lib/rules/operator-assignment.js

@@ -62,6 +62,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["always"],
+
         docs: {
             description: "Require or disallow assignment operator shorthand where possible",
             recommended: false,
@@ -82,7 +84,7 @@ module.exports = {
     },
 
     create(context) {
-
+        const never = context.options[0] === "never";
         const sourceCode = context.sourceCode;
 
         /**
@@ -202,7 +204,7 @@ module.exports = {
         }
 
         return {
-            AssignmentExpression: context.options[0] !== "never" ? verify : prohibit
+            AssignmentExpression: !never ? verify : prohibit
         };
 
     }

package/lib/rules/prefer-arrow-callback.js

@@ -150,6 +150,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{ allowNamedFunctions: false, allowUnboundThis: true }],
+
         docs: {
             description: "Require using arrow functions for callbacks",
             recommended: false,
@@ -161,12 +163,10 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowNamedFunctions: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowUnboundThis: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -181,10 +181,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-
-        const allowUnboundThis = options.allowUnboundThis !== false; // default to true
-        const allowNamedFunctions = options.allowNamedFunctions;
+        const [{ allowNamedFunctions, allowUnboundThis }] = context.options;
         const sourceCode = context.sourceCode;
 
         /*

package/lib/rules/prefer-const.js

@@ -331,6 +331,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            destructuring: "any",
+            ignoreReadBeforeAssign: false
+        }],
+
         docs: {
             description: "Require `const` declarations for variables that are never reassigned after declared",
             recommended: false,
@@ -343,8 +348,8 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    destructuring: { enum: ["any", "all"], default: "any" },
-                    ignoreReadBeforeAssign: { type: "boolean", default: false }
+                    destructuring: { enum: ["any", "all"] },
+                    ignoreReadBeforeAssign: { type: "boolean" }
                 },
                 additionalProperties: false
             }
@@ -355,10 +360,9 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
+        const [{ destructuring, ignoreReadBeforeAssign }] = context.options;
+        const shouldMatchAnyDestructuredVariable = destructuring !== "all";
         const sourceCode = context.sourceCode;
-        const shouldMatchAnyDestructuredVariable = options.destructuring !== "all";
-        const ignoreReadBeforeAssign = options.ignoreReadBeforeAssign === true;
         const variables = [];
         let reportCount = 0;
         let checkedId = null;

package/lib/rules/prefer-promise-reject-errors.js

@@ -15,6 +15,10 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allowEmptyReject: false
+        }],
+
         docs: {
             description: "Require using Error objects as Promise rejection reasons",
             recommended: false,
@@ -27,7 +31,7 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    allowEmptyReject: { type: "boolean", default: false }
+                    allowEmptyReject: { type: "boolean" }
                 },
                 additionalProperties: false
             }
@@ -40,7 +44,7 @@ module.exports = {
 
     create(context) {
 
-        const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;
+        const [{ allowEmptyReject }] = context.options;
         const sourceCode = context.sourceCode;
 
         //----------------------------------------------------------------------
@@ -53,7 +57,7 @@ module.exports = {
          * @returns {void}
          */
         function checkRejectCall(callExpression) {
-            if (!callExpression.arguments.length && ALLOW_EMPTY_REJECT) {
+            if (!callExpression.arguments.length && allowEmptyReject) {
                 return;
             }
             if (

package/lib/rules/prefer-regex-literals.js

@@ -112,6 +112,10 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            disallowRedundantWrapping: false
+        }],
+
         docs: {
             description: "Disallow use of the `RegExp` constructor in favor of regular expression literals",
             recommended: false,
@@ -125,8 +129,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     disallowRedundantWrapping: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -144,7 +147,7 @@ module.exports = {
     },
 
     create(context) {
-        const [{ disallowRedundantWrapping = false } = {}] = context.options;
+        const [{ disallowRedundantWrapping }] = context.options;
         const sourceCode = context.sourceCode;
 
         /**

package/lib/rules/radix.js

@@ -79,6 +79,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [MODE_ALWAYS],
+
         docs: {
             description: "Enforce the consistent use of the radix argument when using `parseInt()`",
             recommended: false,
@@ -103,7 +105,7 @@ module.exports = {
     },
 
     create(context) {
-        const mode = context.options[0] || MODE_ALWAYS;
+        const [mode] = context.options;
         const sourceCode = context.sourceCode;
 
         /**