@croct/eslint-plugin 0.2.2 → 0.3.0

package/configs/index.d.ts

@@ -74,6 +74,12 @@ export declare const configs: {
                 };
             })[];
         };
+        overrides: {
+            files: string[];
+            rules: {
+                'sort-keys-fix/sort-keys-fix': string;
+            };
+        }[];
     };
     typescript: {
         extends: string[];
@@ -142,6 +148,10 @@ export declare const configs: {
                     };
                 })[];
                 'no-undef': string;
+                '@typescript-eslint/no-namespace': string;
+                '@typescript-eslint/no-redeclare': (string | {
+                    ignoreDeclarationMerge: boolean;
+                })[];
                 'no-new-object'?: undefined;
             };
             plugins?: undefined;
@@ -178,6 +188,8 @@ export declare const configs: {
                 '@typescript-eslint/object-curly-spacing'?: undefined;
                 '@typescript-eslint/member-delimiter-style'?: undefined;
                 'no-undef'?: undefined;
+                '@typescript-eslint/no-namespace'?: undefined;
+                '@typescript-eslint/no-redeclare'?: undefined;
             };
             env: {
                 jest: boolean;
@@ -193,6 +205,11 @@ export declare const configs: {
             '@croct/complex-expression-spacing': string;
             '@croct/newline-per-chained-call': string;
             '@croct/min-chained-call-depth': string;
+            '@croct/parameter-destructuring': string;
+            'eslint-comments/disable-enable-pair': (string | {
+                allowWholeFile: boolean;
+            })[];
+            'eslint-comments/require-description': string;
             'newline-per-chained-call': string;
             'no-plusplus': string;
             'array-bracket-newline': string[];
@@ -281,6 +298,10 @@ export declare const configs: {
                 prev: string[];
                 next: string;
             })[];
+            'no-useless-escape': string;
+            'newline-destructuring/newline': (string | {
+                maxLength: number;
+            })[];
         };
         overrides: {
             files: string[];

package/configs/javascript.d.ts

@@ -6,6 +6,11 @@ export declare const javascript: {
         '@croct/complex-expression-spacing': string;
         '@croct/newline-per-chained-call': string;
         '@croct/min-chained-call-depth': string;
+        '@croct/parameter-destructuring': string;
+        'eslint-comments/disable-enable-pair': (string | {
+            allowWholeFile: boolean;
+        })[];
+        'eslint-comments/require-description': string;
         'newline-per-chained-call': string;
         'no-plusplus': string;
         'array-bracket-newline': string[];
@@ -94,6 +99,10 @@ export declare const javascript: {
             prev: string[];
             next: string;
         })[];
+        'no-useless-escape': string;
+        'newline-destructuring/newline': (string | {
+            maxLength: number;
+        })[];
     };
     overrides: {
         files: string[];

package/configs/javascript.js

@@ -5,12 +5,14 @@ exports.javascript = {
     extends: [
         'plugin:jest/recommended',
         'airbnb-base',
+        'plugin:eslint-comments/recommended',
     ],
     plugins: [
         'jest',
         'import',
         'no-smart-quotes',
         'import-newlines',
+        'newline-destructuring',
         '@croct',
     ],
     rules: {
@@ -18,6 +20,14 @@ exports.javascript = {
         '@croct/complex-expression-spacing': 'error',
         '@croct/newline-per-chained-call': 'error',
         '@croct/min-chained-call-depth': 'error',
+        '@croct/parameter-destructuring': 'error',
+        'eslint-comments/disable-enable-pair': [
+            'error',
+            {
+                allowWholeFile: true,
+            },
+        ],
+        'eslint-comments/require-description': 'error',
         'newline-per-chained-call': 'off',
         'no-plusplus': 'off',
         'array-bracket-newline': [
@@ -205,6 +215,10 @@ exports.javascript = {
                 ],
             },
         ],
+        'no-useless-escape': 'error',
+        'newline-destructuring/newline': ['error', {
+                maxLength: 100,
+            }],
     },
     overrides: [
         {

package/configs/react.d.ts

@@ -60,4 +60,10 @@ export declare const react: {
             };
         })[];
     };
+    overrides: {
+        files: string[];
+        rules: {
+            'sort-keys-fix/sort-keys-fix': string;
+        };
+    }[];
 };

package/configs/react.js

@@ -17,6 +17,7 @@ exports.react = {
         'testing-library',
         'jest-dom',
         '@croct',
+        'sort-keys-fix',
     ],
     rules: {
         '@croct/jsx-attribute-spacing': 'error',
@@ -120,4 +121,12 @@ exports.react = {
             },
         ],
     },
+    overrides: [
+        {
+            files: ['**/styles.ts'],
+            rules: {
+                'sort-keys-fix/sort-keys-fix': 'error',
+            },
+        },
+    ],
 };

package/configs/typescript.d.ts

@@ -65,6 +65,10 @@ export declare const typescript: {
                 };
             })[];
             'no-undef': string;
+            '@typescript-eslint/no-namespace': string;
+            '@typescript-eslint/no-redeclare': (string | {
+                ignoreDeclarationMerge: boolean;
+            })[];
             'no-new-object'?: undefined;
         };
         plugins?: undefined;
@@ -101,6 +105,8 @@ export declare const typescript: {
             '@typescript-eslint/object-curly-spacing'?: undefined;
             '@typescript-eslint/member-delimiter-style'?: undefined;
             'no-undef'?: undefined;
+            '@typescript-eslint/no-namespace'?: undefined;
+            '@typescript-eslint/no-redeclare'?: undefined;
         };
         env: {
             jest: boolean;

package/configs/typescript.js

@@ -77,6 +77,10 @@ exports.typescript = {
                         },
                     }],
                 'no-undef': 'off',
+                '@typescript-eslint/no-namespace': 'off',
+                '@typescript-eslint/no-redeclare': ['error', {
+                        ignoreDeclarationMerge: true,
+                    }],
             },
         },
         {

package/index.d.ts

@@ -1,26 +1,30 @@
 declare const configuration: {
     rules: {
         'argument-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
-            CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
-            NewExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
+            CallExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression | import("@typescript-eslint/types/dist/generated/ast-spec").NewExpression) => void;
+            NewExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression | import("@typescript-eslint/types/dist/generated/ast-spec").NewExpression) => void;
         }>;
         'jsx-attribute-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
-            JSXAttribute: (node: import("@typescript-eslint/types/dist/ast-spec").JSXAttribute) => void;
+            JSXAttribute: (node: import("@typescript-eslint/types/dist/generated/ast-spec").JSXAttribute) => void;
         }>;
         'complex-expression-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
-            ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/ast-spec").ArrowFunctionExpression) => void;
-            IfStatement: (node: import("@typescript-eslint/types/dist/ast-spec").IfStatement) => void;
+            ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").ArrowFunctionExpression) => void;
+            IfStatement: (node: import("@typescript-eslint/types/dist/generated/ast-spec").IfStatement) => void;
         }>;
         'newline-per-chained-call': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"expectedLineBreak", {
             ignoreChainWithDepth: number;
         }[], {
-            CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
-            MemberExpression: (node: import("@typescript-eslint/types/dist/ast-spec").MemberExpression) => void;
+            CallExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression) => void;
+            MemberExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").MemberExpression) => void;
         }>;
         'min-chained-call-depth': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedLineBreak", {
             maxLineLength: number;
         }[], {
-            CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
+            CallExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression) => void;
+            MemberExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").MemberExpression) => void;
+        }>;
+        'parameter-destructuring': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedDestructuring", never[], {
+            ObjectPattern: (node: import("@typescript-eslint/types/dist/generated/ast-spec").ObjectPattern) => void;
         }>;
     };
     configs: {
@@ -99,6 +103,12 @@ declare const configuration: {
                     };
                 })[];
             };
+            overrides: {
+                files: string[];
+                rules: {
+                    'sort-keys-fix/sort-keys-fix': string;
+                };
+            }[];
         };
         typescript: {
             extends: string[];
@@ -167,6 +177,10 @@ declare const configuration: {
                         };
                     })[];
                     'no-undef': string;
+                    '@typescript-eslint/no-namespace': string;
+                    '@typescript-eslint/no-redeclare': (string | {
+                        ignoreDeclarationMerge: boolean;
+                    })[];
                     'no-new-object'?: undefined;
                 };
                 plugins?: undefined;
@@ -203,6 +217,8 @@ declare const configuration: {
                     '@typescript-eslint/object-curly-spacing'?: undefined;
                     '@typescript-eslint/member-delimiter-style'?: undefined;
                     'no-undef'?: undefined;
+                    '@typescript-eslint/no-namespace'?: undefined;
+                    '@typescript-eslint/no-redeclare'?: undefined;
                 };
                 env: {
                     jest: boolean;
@@ -218,6 +234,11 @@ declare const configuration: {
                 '@croct/complex-expression-spacing': string;
                 '@croct/newline-per-chained-call': string;
                 '@croct/min-chained-call-depth': string;
+                '@croct/parameter-destructuring': string;
+                'eslint-comments/disable-enable-pair': (string | {
+                    allowWholeFile: boolean;
+                })[];
+                'eslint-comments/require-description': string;
                 'newline-per-chained-call': string;
                 'no-plusplus': string;
                 'array-bracket-newline': string[];
@@ -306,6 +327,10 @@ declare const configuration: {
                     prev: string[];
                     next: string;
                 })[];
+                'no-useless-escape': string;
+                'newline-destructuring/newline': (string | {
+                    maxLength: number;
+                })[];
             };
             overrides: {
                 files: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/eslint-plugin",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "ESLint rules and presets applied to all Croct JavaScript projects.",
   "license": "MIT",
   "author": {
@@ -42,11 +42,13 @@
     "eslint-config-airbnb": "^19.0",
     "eslint-config-airbnb-base": "^15.0",
     "eslint-plugin-cypress": "^2.12",
+    "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-import": "^2.25",
     "eslint-plugin-import-newlines": "^1.1",
     "eslint-plugin-jest": "^26.1",
     "eslint-plugin-jest-dom": "^4.0",
     "eslint-plugin-jsx-a11y": "^6.5",
+    "eslint-plugin-newline-destructuring": "^1.0.1",
     "eslint-plugin-no-smart-quotes": "^1.3",
     "eslint-plugin-react": "^7.28",
     "eslint-plugin-react-hooks": "^4.3",
@@ -61,6 +63,7 @@
     "eslint": "^8.8",
     "eslint-plugin-eslint-plugin": "^4.1.0",
     "eslint-plugin-self": "^1.2.1",
+    "eslint-plugin-sort-keys-fix": "^1.1.2",
     "jest": "^27.5",
     "ts-jest": "^27.1",
     "typescript": "^4.5"

package/rules/index.d.ts

@@ -1,24 +1,28 @@
 export declare const rules: {
     'argument-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
-        CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
-        NewExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
+        CallExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression | import("@typescript-eslint/types/dist/generated/ast-spec").NewExpression) => void;
+        NewExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression | import("@typescript-eslint/types/dist/generated/ast-spec").NewExpression) => void;
     }>;
     'jsx-attribute-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
-        JSXAttribute: (node: import("@typescript-eslint/types/dist/ast-spec").JSXAttribute) => void;
+        JSXAttribute: (node: import("@typescript-eslint/types/dist/generated/ast-spec").JSXAttribute) => void;
     }>;
     'complex-expression-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
-        ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/ast-spec").ArrowFunctionExpression) => void;
-        IfStatement: (node: import("@typescript-eslint/types/dist/ast-spec").IfStatement) => void;
+        ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").ArrowFunctionExpression) => void;
+        IfStatement: (node: import("@typescript-eslint/types/dist/generated/ast-spec").IfStatement) => void;
     }>;
     'newline-per-chained-call': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"expectedLineBreak", {
         ignoreChainWithDepth: number;
     }[], {
-        CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
-        MemberExpression: (node: import("@typescript-eslint/types/dist/ast-spec").MemberExpression) => void;
+        CallExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression) => void;
+        MemberExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").MemberExpression) => void;
     }>;
     'min-chained-call-depth': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedLineBreak", {
         maxLineLength: number;
     }[], {
-        CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
+        CallExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").CallExpression) => void;
+        MemberExpression: (node: import("@typescript-eslint/types/dist/generated/ast-spec").MemberExpression) => void;
+    }>;
+    'parameter-destructuring': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedDestructuring", never[], {
+        ObjectPattern: (node: import("@typescript-eslint/types/dist/generated/ast-spec").ObjectPattern) => void;
     }>;
 };

package/rules/index.js

@@ -6,10 +6,12 @@ const jsx_attribute_spacing_1 = require("./jsx-attribute-spacing");
 const complex_expression_spacing_1 = require("./complex-expression-spacing");
 const newline_per_chained_call_1 = require("./newline-per-chained-call");
 const min_chained_call_depth_1 = require("./min-chained-call-depth");
+const parameter_destructuring_1 = require("./parameter-destructuring");
 exports.rules = {
     'argument-spacing': argument_spacing_1.argumentSpacing,
     'jsx-attribute-spacing': jsx_attribute_spacing_1.jsxAttributeSpacing,
     'complex-expression-spacing': complex_expression_spacing_1.complexExpressionSpacing,
     'newline-per-chained-call': newline_per_chained_call_1.newlinePerChainedCall,
     'min-chained-call-depth': min_chained_call_depth_1.minChainedCallDepth,
+    'parameter-destructuring': parameter_destructuring_1.parameterDestructuring,
 };

package/rules/min-chained-call-depth/index.d.ts

@@ -3,4 +3,5 @@ export declare const minChainedCallDepth: import("@typescript-eslint/utils/dist/
     maxLineLength: number;
 }[], {
     CallExpression: (node: TSESTree.CallExpression) => void;
+    MemberExpression: (node: TSESTree.MemberExpression) => void;
 }>;

package/rules/min-chained-call-depth/index.js

@@ -43,28 +43,51 @@ exports.minChainedCallDepth = (0, createRule_1.createRule)({
                 || currentNode.type === 'MemberExpression') {
                 if (currentNode.type === 'MemberExpression') {
                     currentNode = currentNode.object;
+                    depth += 1;
                 }
                 else if (currentNode.type === 'CallExpression') {
                     currentNode = currentNode.callee;
                 }
-                depth += 1;
             }
             return depth;
         }
         function check(node) {
-            var _a, _b, _c;
-            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression'
-                || ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.type) === 'CallExpression'
-                || node.callee.type !== 'MemberExpression'
-                || node.callee.computed
-                || node.callee.object.loc.end.line === node.callee.property.loc.start.line) {
+            var _a, _b;
+            // If the node is a member expression inside a call expression skip, this is to ensure
+            // that we consider the correct line length of the result.
+            //
+            // Example:
+            //     ```ts
+            //     foo
+            //        .bar();
+            //     ```
+            //     The replacement of this input should be `foo.bar();`, which has 10 character.
+            //     Without this check it would consider the length up to `r`, which is 7.
+            if (node.type === 'MemberExpression' && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === 'CallExpression') {
                 return;
             }
-            if (getDepth(node) > 3) {
+            // If the node is a call expression we need to validate it's callee as a member
+            // expression.
+            // If the node itself is already a member expression, like the
+            // `property` in `this.property.function()`, we validate the node directly.
+            const callee = node.type === 'CallExpression' ? node.callee : node;
+            if (
+            // If the callee is not a member expression, we can skip.
+            // For example, root level calls like `foo();`.
+            callee.type !== 'MemberExpression'
+                // If the callee is a computed member expression, like `foo[bar]()`, we can skip.
+                || callee.computed
+                // If the callee is already in the same line as it's object, we can skip.
+                || callee.object.loc.end.line === callee.property.loc.start.line) {
                 return;
             }
-            const { maxLineLength = 100 } = (_c = context.options[0]) !== null && _c !== void 0 ? _c : {};
-            const { property } = node.callee;
+            // We only inline the first level of chained calls.
+            // If the current call is nested inside another call, we can skip.
+            if (getDepth(callee) > 1) {
+                return;
+            }
+            const { maxLineLength = 100 } = (_b = context.options[0]) !== null && _b !== void 0 ? _b : {};
+            const { property } = callee;
             const lastToken = sourceCode.getLastToken(node, {
                 filter: token => token.loc.end.line === property.loc.start.line,
             });
@@ -73,14 +96,14 @@ exports.minChainedCallDepth = (0, createRule_1.createRule)({
                     && token.type === 'Punctuator'
                     && token.value === ';'),
             });
-            const lineLength = node.callee.object.loc.end.column
+            const lineLength = callee.object.loc.end.column
                 + lastToken.loc.end.column - property.loc.start.column
                 + 1
                 + (semicolon !== null ? 1 : 0);
             if (maxLineLength !== null && lineLength > maxLineLength) {
                 return;
             }
-            const punctuator = sourceCode.getTokenBefore(node.callee.property);
+            const punctuator = sourceCode.getTokenBefore(callee.property);
             const previousToken = sourceCode.getTokenBefore(punctuator, { includeComments: true });
             const nextToken = sourceCode.getTokenAfter(punctuator, { includeComments: true });
             if ((0, ast_utils_1.isCommentToken)(previousToken) || (0, ast_utils_1.isCommentToken)(nextToken)) {
@@ -89,8 +112,8 @@ exports.minChainedCallDepth = (0, createRule_1.createRule)({
             context.report({
                 node: node,
                 loc: {
-                    start: node.callee.object.loc.end,
-                    end: node.callee.property.loc.start,
+                    start: callee.object.loc.end,
+                    end: callee.property.loc.start,
                 },
                 messageId: 'unexpectedLineBreak',
                 fix: fixer => fixer.replaceTextRange([previousToken.range[1], nextToken.range[0]], punctuator.value),
@@ -100,6 +123,9 @@ exports.minChainedCallDepth = (0, createRule_1.createRule)({
             CallExpression: (node) => {
                 check(node);
             },
+            MemberExpression: (node) => {
+                check(node);
+            },
         };
     },
 });

package/rules/newline-per-chained-call/index.js

@@ -42,8 +42,7 @@ exports.newlinePerChainedCall = (0, createRule_1.createRule)({
         const sourceCode = context.getSourceCode();
         function getPropertyText(node) {
             const prefix = '.';
-            const lines = sourceCode.getText(node.property)
-                .split(LINEBREAK_MATCHER);
+            const lines = sourceCode.getText(node.property).split(LINEBREAK_MATCHER);
             return prefix + lines[0];
         }
         function hasObjectAndPropertyOnSameLine(node) {
@@ -53,7 +52,7 @@ exports.newlinePerChainedCall = (0, createRule_1.createRule)({
             return token.value !== ')' || token.type !== 'Punctuator';
         }
         function validateCallExpressionIgnoreDepth(node) {
-            var _a;
+            var _a, _b;
             let hasCallExpression = false;
             if (node.type === 'CallExpression') {
                 hasCallExpression = true;
@@ -85,7 +84,8 @@ exports.newlinePerChainedCall = (0, createRule_1.createRule)({
                         .filter(hasObjectAndPropertyOnSameLine);
                     const rootNode = expressionsOnSameLine[expressionsOnSameLine.length - 1];
                     if (rootNode.type === 'MemberExpression'
-                        && ((_a = rootNode.parent) === null || _a === void 0 ? void 0 : _a.type) === 'CallExpression'
+                        && (((_a = rootNode.parent) === null || _a === void 0 ? void 0 : _a.type) === 'CallExpression'
+                            || ((_b = rootNode.parent) === null || _b === void 0 ? void 0 : _b.type) === 'MemberExpression')
                         && (rootNode.object.type === 'ThisExpression'
                             || rootNode.object.type === 'Identifier')) {
                         expressionsOnSameLine.pop();

package/rules/parameter-destructuring/index.d.ts

@@ -0,0 +1,3 @@
+export declare const parameterDestructuring: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedDestructuring", never[], {
+    ObjectPattern: (node: import("@typescript-eslint/types/dist/generated/ast-spec").ObjectPattern) => void;
+}>;

package/rules/parameter-destructuring/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parameterDestructuring = void 0;
+/*
+ eslint-disable @typescript-eslint/no-non-null-assertion
+ --
+ Disable the rule to reduce the number of branches
+ */
+const types_1 = require("@typescript-eslint/types");
+const createRule_1 = require("../createRule");
+exports.parameterDestructuring = (0, createRule_1.createRule)({
+    name: 'parameter-destructuring',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Prevent noisy destructuring on parameters',
+            recommended: 'error',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            unexpectedDestructuring: ('Destructuring should not be done in the parameters. '
+                + 'Bind to a variable and destructure inside the function.'),
+        },
+    },
+    defaultOptions: [],
+    create: context => {
+        const sourceCode = context.getSourceCode();
+        return {
+            ObjectPattern: function checkObjectPattern(node) {
+                const { parent } = node;
+                // Skip for destructuring in contexts unrelated to function parameters
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) !== types_1.AST_NODE_TYPES.FunctionExpression
+                    && (parent === null || parent === void 0 ? void 0 : parent.type) !== types_1.AST_NODE_TYPES.FunctionDeclaration
+                    && (parent === null || parent === void 0 ? void 0 : parent.type) !== types_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return;
+                }
+                // Allow one-line destructuring
+                if (node.loc.start.line === node.loc.end.line) {
+                    return;
+                }
+                const { body } = parent;
+                context.report({
+                    node: node,
+                    messageId: 'unexpectedDestructuring',
+                    suggest: body.type === types_1.AST_NODE_TYPES.BlockStatement
+                        ? [
+                            {
+                                messageId: 'unexpectedDestructuring',
+                                fix: (fixer) => [
+                                    // Replace the destructuring with a variable declaration
+                                    fixer.replaceText(node, 'value'),
+                                    // Add the destructuring inside the body
+                                    fixer.insertTextAfter(
+                                    // Null safety: a block expression always have the `{` token
+                                    // opening the body of the function.
+                                    sourceCode.getFirstToken(body), `\nconst ${sourceCode.getText(node)} = value;\n`),
+                                ],
+                            },
+                        ]
+                        : null,
+                });
+            },
+        };
+    },
+});