eslint-plugin-th-rules 3.6.0 → 3.6.1

package/dist/plugin.d.ts

@@ -11,10 +11,9 @@ export declare const rules: {
     'no-default-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong" | "tooManyCumulative" | "directAccessRequired", [{
+    'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong" | "tooManyCumulative", [{
         maximumDestructuredVariables?: number;
         maximumLineLength?: number;
-        directAccessIdentifiers?: string[];
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
@@ -64,10 +63,9 @@ declare const plugin: {
         'no-default-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong" | "tooManyCumulative" | "directAccessRequired", [{
+        'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong" | "tooManyCumulative", [{
             maximumDestructuredVariables?: number;
             maximumLineLength?: number;
-            directAccessIdentifiers?: string[];
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC;AACzB,eAAe,MAAM,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC;AACzB,eAAe,MAAM,CAAC"}

package/dist/rules/no-destructuring.d.ts

@@ -3,10 +3,9 @@ type Options = [
     {
         maximumDestructuredVariables?: number;
         maximumLineLength?: number;
-        directAccessIdentifiers?: string[];
     }
 ];
-type MessageIds = 'tooDeep' | 'tooMany' | 'tooLong' | 'tooManyCumulative' | 'directAccessRequired';
+type MessageIds = 'tooDeep' | 'tooMany' | 'tooLong' | 'tooManyCumulative';
 declare const noDestructuring: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
     name: string;
 };

package/dist/rules/no-destructuring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-destructuring.d.ts","sourceRoot":"","sources":["../../src/rules/no-destructuring.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItF,KAAK,OAAO,GAAG;IACd;QACC,4BAA4B,CAAC,EAAE,MAAM,CAAC;QACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;KACnC;CACD,CAAC;AAEF,KAAK,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,mBAAmB,GAAG,sBAAsB,CAAC;AAEnG,QAAA,MAAM,eAAe;;CA0NnB,CAAC;AAEH,eAAe,eAAe,CAAC"}
+{"version":3,"file":"no-destructuring.d.ts","sourceRoot":"","sources":["../../src/rules/no-destructuring.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAItF,KAAK,OAAO,GAAG;IACd;QACC,4BAA4B,CAAC,EAAE,MAAM,CAAC;QACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC3B;CACD,CAAC;AAEF,KAAK,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,mBAAmB,CAAC;AAE1E,QAAA,MAAM,eAAe;;CA+NnB,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/dist/rules/no-destructuring.js

@@ -1,7 +1,8 @@
 /* eslint-disable new-cap */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import _ from 'lodash';
 import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-const MAX_INDENT_SPACES = 3;
+const MAX_TAB_COUNT = 3;
 const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-destructuring.md')({
     name: 'no-destructuring',
     meta: {
@@ -15,51 +16,48 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                 properties: {
                     maximumDestructuredVariables: { type: 'integer', minimum: 0 },
                     maximumLineLength: { type: 'integer', minimum: 0 },
-                    directAccessIdentifiers: {
-                        type: 'array',
-                        items: { type: 'string', minLength: 1 },
-                    },
                 },
                 additionalProperties: false,
             },
         ],
         messages: {
-            tooDeep: 'Destructuring at an indentation above {{max}} is not allowed; found {{actual}}.',
+            tooDeep: 'Destructuring at a nesting level above {{max}} is not allowed; found {{actual}} levels of nesting.',
             tooMany: 'Destructuring of more than {{max}} variables is not allowed.',
             tooLong: 'Destructuring spanning a line exceeding {{max}} characters is not allowed.',
-            tooManyCumulative: 'Too many destructured variables from "{{source}}" in the same scope. Max is {{max}}, total is {{total}}.',
-            directAccessRequired: 'Do not destructure from "{{identifier}}". Use direct member access, for example {{identifier}}.onChangeText.',
+            tooManyCumulative: 'Destructuring of more than {{max}} variables from "{{source}}" in the same scope is not allowed; found {{total}}.',
         },
     },
     defaultOptions: [
         {
             maximumDestructuredVariables: 2,
             maximumLineLength: 100,
-            directAccessIdentifiers: ['properties'],
         },
     ],
     create(context, [options]) {
         const maxVariables = options.maximumDestructuredVariables ?? 2;
         const maxLineLength = options.maximumLineLength ?? 100;
-        const directAccessIdentifiers = new Set(options.directAccessIdentifiers ?? ['properties']);
-        const sourceTotalsByScope = new WeakMap();
+        /**
+         * Tracks total destructured properties per initializer expression text per scope node.
+         * WeakMap is used so scopes can be GC'ed and we do not leak memory across files.
+         */
+        const totalsByScope = new WeakMap();
         function getLineText(lineNumber) {
             return context.sourceCode.lines[lineNumber - 1] ?? '';
         }
-        function getIndentSpacesForLine(lineNumber) {
-            const lineText = getLineText(lineNumber);
-            return lineText.search(/\S|$/);
-        }
         function getMaxSpannedLineLength(startLine, endLine) {
             let max = 0;
             for (let i = startLine; i <= endLine; i++) {
-                const text = getLineText(i);
-                if (text.length > max) {
-                    max = text.length;
+                const line = getLineText(i);
+                if (line.length > max) {
+                    max = line.length;
                 }
             }
             return max;
         }
+        function getIndentCountForLine(lineNumber) {
+            const lineText = getLineText(lineNumber);
+            return lineText.search(/\S|$/);
+        }
         function getScopeNode(node) {
             const ancestors = context.sourceCode.getAncestors(node);
             for (let i = ancestors.length - 1; i >= 0; i--) {
@@ -74,78 +72,52 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
             }
             return context.sourceCode.ast;
         }
-        function getOrCreateScopeMap(scope) {
-            const existing = sourceTotalsByScope.get(scope);
+        function getScopeMap(scopeNode) {
+            const existing = totalsByScope.get(scopeNode);
             if (!_.isNil(existing)) {
                 return existing;
             }
             const created = new Map();
-            sourceTotalsByScope.set(scope, created);
+            totalsByScope.set(scopeNode, created);
             return created;
         }
-        function isDirectAccessForbiddenInitializer(init) {
-            if (_.isNil(init)) {
-                return false;
-            }
-            return init.type === AST_NODE_TYPES.Identifier && directAccessIdentifiers.has(init.name);
-        }
-        function reportIfNeeded(patternNode, reportNode, initExpression) {
+        function reportIfNeeded(patternNode, reportNode = patternNode) {
             if (patternNode?.type !== AST_NODE_TYPES.ObjectPattern || _.isNil(patternNode.loc)) {
                 return;
             }
-            if (isDirectAccessForbiddenInitializer(initExpression)) {
-                context.report({
-                    node: reportNode,
-                    messageId: 'directAccessRequired',
-                    data: { identifier: initExpression.name },
-                });
-                return;
-            }
             const startLine = patternNode.loc.start.line;
             const endLine = patternNode.loc.end.line;
-            const indentSpaces = getIndentSpacesForLine(startLine);
+            const indentCount = getIndentCountForLine(startLine);
             const propertyCount = patternNode.properties?.length ?? 0;
             const maxSpannedLineLength = getMaxSpannedLineLength(startLine, endLine);
-            if (indentSpaces > MAX_INDENT_SPACES) {
+            if (indentCount > MAX_TAB_COUNT) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooDeep',
-                    data: { max: MAX_INDENT_SPACES, actual: indentSpaces },
+                    data: {
+                        max: MAX_TAB_COUNT,
+                        actual: indentCount,
+                    },
                 });
             }
             if (propertyCount > maxVariables) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooMany',
-                    data: { max: maxVariables },
+                    data: {
+                        max: maxVariables,
+                    },
                 });
             }
             if (maxSpannedLineLength > maxLineLength) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooLong',
-                    data: { max: maxLineLength },
+                    data: {
+                        max: maxLineLength,
+                    },
                 });
             }
-            if (!_.isNil(initExpression)) {
-                const scopeNode = getScopeNode(reportNode);
-                const scopeMap = getOrCreateScopeMap(scopeNode);
-                const sourceText = context.sourceCode.getText(initExpression);
-                const previousTotal = scopeMap.get(sourceText) ?? 0;
-                const newTotal = previousTotal + propertyCount;
-                scopeMap.set(sourceText, newTotal);
-                if (newTotal > maxVariables) {
-                    context.report({
-                        node: reportNode,
-                        messageId: 'tooManyCumulative',
-                        data: {
-                            source: sourceText,
-                            max: maxVariables,
-                            total: newTotal,
-                        },
-                    });
-                }
-            }
         }
         function checkParameters(parameters) {
             for (const p of parameters || []) {
@@ -153,15 +125,45 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                     continue;
                 }
                 if (p.type === AST_NODE_TYPES.AssignmentPattern) {
-                    reportIfNeeded(p.left, p, undefined);
+                    reportIfNeeded(p.left, p);
                     continue;
                 }
-                reportIfNeeded(p, p, undefined);
+                reportIfNeeded(p, p);
+            }
+        }
+        function checkCumulativeVariableDeclarator(node) {
+            if (node.id.type !== AST_NODE_TYPES.ObjectPattern) {
+                return;
+            }
+            if (_.isNil(node.init)) {
+                return;
+            }
+            const propertyCount = node.id.properties?.length ?? 0;
+            if (propertyCount > maxVariables) {
+                return;
+            }
+            const scopeNode = getScopeNode(node);
+            const scopeMap = getScopeMap(scopeNode);
+            const sourceText = context.sourceCode.getText(node.init);
+            const previousTotal = scopeMap.get(sourceText) ?? 0;
+            const newTotal = previousTotal + propertyCount;
+            scopeMap.set(sourceText, newTotal);
+            if (previousTotal > 0 && newTotal > maxVariables) {
+                context.report({
+                    node,
+                    messageId: 'tooManyCumulative',
+                    data: {
+                        source: sourceText,
+                        max: maxVariables,
+                        total: newTotal,
+                    },
+                });
             }
         }
         return {
             VariableDeclarator(node) {
-                reportIfNeeded(node.id, node, node.init);
+                reportIfNeeded(node.id, node);
+                checkCumulativeVariableDeclarator(node);
             },
             FunctionDeclaration(node) {
                 checkParameters(node.params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-th-rules",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",