eslint 9.13.0 → 9.15.0

package/lib/rules/no-invalid-regexp.js

@@ -22,6 +22,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Disallow invalid regular expression strings in `RegExp` constructors",
             recommended: true,
@@ -47,12 +49,11 @@ module.exports = {
     },
 
     create(context) {
-
-        const options = context.options[0];
+        const [{ allowConstructorFlags }] = context.options;
         let allowedFlags = [];
 
-        if (options && options.allowConstructorFlags) {
-            const temp = options.allowConstructorFlags.join("").replace(new RegExp(`[${validFlags}]`, "gu"), "");
+        if (allowConstructorFlags) {
+            const temp = allowConstructorFlags.join("").replace(new RegExp(`[${validFlags}]`, "gu"), "");
 
             if (temp) {
                 allowedFlags = [...new Set(temp)];

package/lib/rules/no-invalid-this.js

@@ -35,6 +35,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{ capIsConstructor: true }],
+
         docs: {
             description: "Disallow use of `this` in contexts where the value of `this` is `undefined`",
             recommended: false,
@@ -46,8 +48,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     capIsConstructor: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -60,8 +61,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const capIsConstructor = options.capIsConstructor !== false;
+        const [{ capIsConstructor }] = context.options;
         const stack = [],
             sourceCode = context.sourceCode;
 

package/lib/rules/no-irregular-whitespace.js

@@ -30,6 +30,14 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{
+            skipComments: false,
+            skipJSXText: false,
+            skipRegExps: false,
+            skipStrings: true,
+            skipTemplates: false
+        }],
+
         docs: {
             description: "Disallow irregular whitespace",
             recommended: true,
@@ -41,24 +49,19 @@ module.exports = {
                 type: "object",
                 properties: {
                     skipComments: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     skipStrings: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     },
                     skipTemplates: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     skipRegExps: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     skipJSXText: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -71,21 +74,20 @@ module.exports = {
     },
 
     create(context) {
-
-        // Module store of errors that we have found
-        let errors = [];
-
-        // Lookup the `skipComments` option, which defaults to `false`.
-        const options = context.options[0] || {};
-        const skipComments = !!options.skipComments;
-        const skipStrings = options.skipStrings !== false;
-        const skipRegExps = !!options.skipRegExps;
-        const skipTemplates = !!options.skipTemplates;
-        const skipJSXText = !!options.skipJSXText;
+        const [{
+            skipComments,
+            skipStrings,
+            skipRegExps,
+            skipTemplates,
+            skipJSXText
+        }] = context.options;
 
         const sourceCode = context.sourceCode;
         const commentNodes = sourceCode.getAllComments();
 
+        // Module store of errors that we have found
+        let errors = [];
+
         /**
          * Removes errors that occur inside the given node
          * @param {ASTNode} node to check for matching errors.
@@ -233,7 +235,7 @@ module.exports = {
          * @returns {void}
          * @private
          */
-        function noop() {}
+        function noop() { }
 
         const nodes = {};
 

package/lib/rules/no-labels.js

@@ -19,6 +19,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allowLoop: false,
+            allowSwitch: false
+        }],
+
         docs: {
             description: "Disallow labeled statements",
             recommended: false,
@@ -30,12 +35,10 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowLoop: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowSwitch: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -50,9 +53,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0];
-        const allowLoop = options && options.allowLoop;
-        const allowSwitch = options && options.allowSwitch;
+        const [{ allowLoop, allowSwitch }] = context.options;
         let scopeInfo = null;
 
         /**

package/lib/rules/no-lonely-if.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -36,8 +42,8 @@ module.exports = {
                     grandparent = parent.parent;
 
                 if (parent && parent.type === "BlockStatement" &&
-                        parent.body.length === 1 && grandparent &&
-                        grandparent.type === "IfStatement" &&
+                        parent.body.length === 1 && !astUtils.areBracesNecessary(parent, sourceCode) &&
+                        grandparent && grandparent.type === "IfStatement" &&
                         parent === grandparent.alternate) {
                     context.report({
                         node,

package/lib/rules/no-multi-assign.js

@@ -15,6 +15,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Disallow use of chained assignment expressions",
             recommended: false,
@@ -25,8 +27,7 @@ module.exports = {
             type: "object",
             properties: {
                 ignoreNonDeclaration: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -38,19 +39,13 @@ module.exports = {
     },
 
     create(context) {
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-        const options = context.options[0] || {
-            ignoreNonDeclaration: false
-        };
+        const [{ ignoreNonDeclaration }] = context.options;
         const selectors = [
             "VariableDeclarator > AssignmentExpression.init",
             "PropertyDefinition > AssignmentExpression.value"
         ];
 
-        if (!options.ignoreNonDeclaration) {
+        if (!ignoreNonDeclaration) {
             selectors.push("AssignmentExpression > AssignmentExpression.right");
         }
 

package/lib/rules/no-plusplus.js

@@ -50,6 +50,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Disallow the unary operators `++` and `--`",
             recommended: false,
@@ -61,8 +63,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowForLoopAfterthoughts: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -75,13 +76,7 @@ module.exports = {
     },
 
     create(context) {
-
-        const config = context.options[0];
-        let allowForLoopAfterthoughts = false;
-
-        if (typeof config === "object") {
-            allowForLoopAfterthoughts = config.allowForLoopAfterthoughts === true;
-        }
+        const [{ allowForLoopAfterthoughts }] = context.options;
 
         return {
 

package/lib/rules/no-promise-executor-return.js

@@ -141,6 +141,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Disallow returning values from Promise executor functions",
             recommended: false,
@@ -153,8 +155,7 @@ module.exports = {
             type: "object",
             properties: {
                 allowVoid: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -172,12 +173,9 @@ module.exports = {
     },
 
     create(context) {
-
         let funcInfo = null;
         const sourceCode = context.sourceCode;
-        const {
-            allowVoid = false
-        } = context.options[0] || {};
+        const [{ allowVoid }] = context.options;
 
         return {
 

package/lib/rules/no-redeclare.js

@@ -20,6 +20,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{ builtinGlobals: true }],
+
         docs: {
             description: "Disallow variable redeclaration",
             recommended: true,
@@ -36,7 +38,7 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    builtinGlobals: { type: "boolean", default: true }
+                    builtinGlobals: { type: "boolean" }
                 },
                 additionalProperties: false
             }
@@ -44,12 +46,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = {
-            builtinGlobals: Boolean(
-                context.options.length === 0 ||
-                context.options[0].builtinGlobals
-            )
-        };
+        const [{ builtinGlobals }] = context.options;
         const sourceCode = context.sourceCode;
 
         /**
@@ -58,7 +55,7 @@ module.exports = {
          * @returns {IterableIterator<{type:string,node:ASTNode,loc:SourceLocation}>} The declarations.
          */
         function *iterateDeclarations(variable) {
-            if (options.builtinGlobals && (
+            if (builtinGlobals && (
                 variable.eslintImplicitGlobalSetting === "readonly" ||
                 variable.eslintImplicitGlobalSetting === "writable"
             )) {

package/lib/rules/no-return-assign.js

@@ -25,6 +25,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["except-parens"],
+
         docs: {
             description: "Disallow assignment operators in `return` statements",
             recommended: false,
@@ -44,7 +46,7 @@ module.exports = {
     },
 
     create(context) {
-        const always = (context.options[0] || "except-parens") !== "except-parens";
+        const always = context.options[0] !== "except-parens";
         const sourceCode = context.sourceCode;
 
         return {

package/lib/rules/no-self-assign.js

@@ -129,6 +129,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{ props: true }],
+
         docs: {
             description: "Disallow assignments where both sides are exactly the same",
             recommended: true,
@@ -140,8 +142,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     props: {
-                        type: "boolean",
-                        default: true
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -155,7 +156,7 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.sourceCode;
-        const [{ props = true } = {}] = context.options;
+        const [{ props }] = context.options;
 
         /**
          * Reports a given node as self assignments.

package/lib/rules/no-sequences.js

@@ -15,9 +15,6 @@ const astUtils = require("./utils/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const DEFAULT_OPTIONS = {
-    allowInParentheses: true
-};
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -38,20 +35,23 @@ module.exports = {
             type: "object",
             properties: {
                 allowInParentheses: {
-                    type: "boolean",
-                    default: true
+                    type: "boolean"
                 }
             },
             additionalProperties: false
         }],
 
+        defaultOptions: [{
+            allowInParentheses: true
+        }],
+
         messages: {
             unexpectedCommaExpression: "Unexpected use of comma operator."
         }
     },
 
     create(context) {
-        const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0]);
+        const [{ allowInParentheses }] = context.options;
         const sourceCode = context.sourceCode;
 
         /**
@@ -117,7 +117,7 @@ module.exports = {
                 }
 
                 // Wrapping a sequence in extra parens indicates intent
-                if (options.allowInParentheses) {
+                if (allowInParentheses) {
                     if (requiresExtraParens(node)) {
                         if (isParenthesisedTwice(node)) {
                             return;

package/lib/rules/no-shadow.js

@@ -29,6 +29,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allow: [],
+            hoist: "functions"
+        }],
+
         docs: {
             description: "Disallow variable declarations from shadowing variables declared in the outer scope",
             recommended: false,
@@ -39,7 +44,7 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    builtinGlobals: { type: "boolean", default: false },
+                    builtinGlobals: { type: "boolean" },
                     hoist: { enum: ["all", "functions", "never"], default: "functions" },
                     allow: {
                         type: "array",
@@ -47,7 +52,7 @@ module.exports = {
                             type: "string"
                         }
                     },
-                    ignoreOnInitialization: { type: "boolean", default: false }
+                    ignoreOnInitialization: { type: "boolean" }
                 },
                 additionalProperties: false
             }
@@ -60,13 +65,12 @@ module.exports = {
     },
 
     create(context) {
-
-        const options = {
-            builtinGlobals: context.options[0] && context.options[0].builtinGlobals,
-            hoist: (context.options[0] && context.options[0].hoist) || "functions",
-            allow: (context.options[0] && context.options[0].allow) || [],
-            ignoreOnInitialization: context.options[0] && context.options[0].ignoreOnInitialization
-        };
+        const [{
+            builtinGlobals,
+            hoist,
+            allow,
+            ignoreOnInitialization
+        }] = context.options;
         const sourceCode = context.sourceCode;
 
         /**
@@ -174,7 +178,7 @@ module.exports = {
          * @returns {boolean} Whether or not the variable name is allowed.
          */
         function isAllowed(variable) {
-            return options.allow.includes(variable.name);
+            return allow.includes(variable.name);
         }
 
         /**
@@ -269,7 +273,7 @@ module.exports = {
                  inner[1] < outer[0] &&
 
                  // Excepts FunctionDeclaration if is {"hoist":"function"}.
-                 (options.hoist !== "functions" || !outerDef || outerDef.node.type !== "FunctionDeclaration")
+                 (hoist !== "functions" || !outerDef || outerDef.node.type !== "FunctionDeclaration")
             );
         }
 
@@ -296,10 +300,10 @@ module.exports = {
                 const shadowed = astUtils.getVariableByName(scope.upper, variable.name);
 
                 if (shadowed &&
-                      (shadowed.identifiers.length > 0 || (options.builtinGlobals && "writeable" in shadowed)) &&
+                      (shadowed.identifiers.length > 0 || (builtinGlobals && "writeable" in shadowed)) &&
                       !isOnInitializer(variable, shadowed) &&
-                      !(options.ignoreOnInitialization && isInitPatternNode(variable, shadowed)) &&
-                      !(options.hoist !== "all" && isInTdz(variable, shadowed))
+                      !(ignoreOnInitialization && isInitPatternNode(variable, shadowed)) &&
+                      !(hoist !== "all" && isInTdz(variable, shadowed))
                 ) {
                     const location = getDeclaredLocation(shadowed);
                     const messageId = location.global ? "noShadowGlobal" : "noShadow";

package/lib/rules/no-undef.js

@@ -28,6 +28,8 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{}],
+
         docs: {
             description: "Disallow the use of undeclared variables unless mentioned in `/*global */` comments",
             recommended: true,
@@ -39,8 +41,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     typeof: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -52,8 +53,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0];
-        const considerTypeOf = options && options.typeof === true || false;
+        const [{ typeof: considerTypeOf }] = context.options;
         const sourceCode = context.sourceCode;
 
         return {

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

@@ -14,6 +14,17 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allow: [],
+            allowAfterSuper: false,
+            allowAfterThis: false,
+            allowAfterThisConstructor: false,
+            allowFunctionParams: true,
+            allowInArrayDestructuring: true,
+            allowInObjectDestructuring: true,
+            enforceInMethodNames: false
+        }],
+
         docs: {
             description: "Disallow dangling underscores in identifiers",
             recommended: false,
@@ -31,36 +42,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 +76,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 +100,7 @@ module.exports = {
          * @private
          */
         function isAllowed(identifier) {
-            return ALLOWED_VARIABLES.includes(identifier);
+            return allow.includes(identifier);
         }
 
         /**