eslint-plugin-th-rules 3.5.0 → 3.6.1

package/dist/plugin.d.ts

@@ -11,9 +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", [{
-        maximumDestructuredVariables: number;
-        maximumLineLength: number;
+    'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong" | "tooManyCumulative", [{
+        maximumDestructuredVariables?: number;
+        maximumLineLength?: number;
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
@@ -63,9 +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", [{
-            maximumDestructuredVariables: number;
-            maximumLineLength: number;
+        'no-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong" | "tooManyCumulative", [{
+            maximumDestructuredVariables?: number;
+            maximumLineLength?: number;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

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

@@ -1,8 +1,12 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-declare const noDestructuring: ESLintUtils.RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
-    maximumDestructuredVariables: number;
-    maximumLineLength: number;
-}], unknown, ESLintUtils.RuleListener> & {
+type Options = [
+    {
+        maximumDestructuredVariables?: number;
+        maximumLineLength?: number;
+    }
+];
+type MessageIds = 'tooDeep' | 'tooMany' | 'tooLong' | 'tooManyCumulative';
+declare const noDestructuring: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
     name: string;
 };
 export default noDestructuring;

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,QAAA,MAAM,eAAe;;;;;CAyInB,CAAC;AACH,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

@@ -24,6 +24,7 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
             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: 'Destructuring of more than {{max}} variables from "{{source}}" in the same scope is not allowed; found {{total}}.',
         },
     },
     defaultOptions: [
@@ -33,24 +34,62 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
         },
     ],
     create(context, [options]) {
-        const MAX_VARIABLES = options.maximumDestructuredVariables ?? 2;
-        const MAX_LINE_LENGTH = options.maximumLineLength ?? 100;
+        const maxVariables = options.maximumDestructuredVariables ?? 2;
+        const maxLineLength = options.maximumLineLength ?? 100;
+        /**
+         * 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 getMaxSpannedLineLength(startLine, endLine) {
+            let max = 0;
+            for (let i = startLine; i <= endLine; i++) {
+                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--) {
+                const a = ancestors[i];
+                if (a.type === AST_NODE_TYPES.Program ||
+                    a.type === AST_NODE_TYPES.FunctionDeclaration ||
+                    a.type === AST_NODE_TYPES.FunctionExpression ||
+                    a.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                    a.type === AST_NODE_TYPES.TSDeclareFunction) {
+                    return a;
+                }
+            }
+            return context.sourceCode.ast;
+        }
+        function getScopeMap(scopeNode) {
+            const existing = totalsByScope.get(scopeNode);
+            if (!_.isNil(existing)) {
+                return existing;
+            }
+            const created = new Map();
+            totalsByScope.set(scopeNode, created);
+            return created;
+        }
         function reportIfNeeded(patternNode, reportNode = patternNode) {
             if (patternNode?.type !== AST_NODE_TYPES.ObjectPattern || _.isNil(patternNode.loc)) {
                 return;
             }
             const startLine = patternNode.loc.start.line;
             const endLine = patternNode.loc.end.line;
-            const lineText = context.sourceCode.lines[startLine - 1] ?? '';
-            const indentCount = lineText.search(/\S|$/);
+            const indentCount = getIndentCountForLine(startLine);
             const propertyCount = patternNode.properties?.length ?? 0;
-            let maxSpannedLineLength = 0;
-            for (let i = startLine; i <= endLine; i++) {
-                const t = context.sourceCode.lines[i - 1] ?? '';
-                if (t.length > maxSpannedLineLength) {
-                    maxSpannedLineLength = t.length;
-                }
-            }
+            const maxSpannedLineLength = getMaxSpannedLineLength(startLine, endLine);
             if (indentCount > MAX_TAB_COUNT) {
                 context.report({
                     node: reportNode,
@@ -61,21 +100,21 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                     },
                 });
             }
-            if (propertyCount > MAX_VARIABLES) {
+            if (propertyCount > maxVariables) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooMany',
                     data: {
-                        max: MAX_VARIABLES,
+                        max: maxVariables,
                     },
                 });
             }
-            if (maxSpannedLineLength > MAX_LINE_LENGTH) {
+            if (maxSpannedLineLength > maxLineLength) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooLong',
                     data: {
-                        max: MAX_LINE_LENGTH,
+                        max: maxLineLength,
                     },
                 });
             }
@@ -92,9 +131,39 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                 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);
+                checkCumulativeVariableDeclarator(node);
             },
             FunctionDeclaration(node) {
                 checkParameters(node.params);

package/dist/rules/prefer-lodash-iteratee-shorthand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-lodash-iteratee-shorthand.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-lodash-iteratee-shorthand.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,WAAW,EAAgC,MAAM,0BAA0B,CAAC;AAYrG,eAAO,MAAM,sBAAsB,6KAezB,CAAC;AAEX,eAAO,MAAM,qBAAqB,wPAsBxB,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;CAUhC,CAAC;AAUX,QAAA,MAAM,6BAA6B;;CAwpBjC,CAAC;AAEH,eAAe,6BAA6B,CAAC"}
+{"version":3,"file":"prefer-lodash-iteratee-shorthand.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-lodash-iteratee-shorthand.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,WAAW,EAAgC,MAAM,0BAA0B,CAAC;AAYrG,eAAO,MAAM,sBAAsB,6KAezB,CAAC;AAEX,eAAO,MAAM,qBAAqB,wPAsBxB,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;CAUhC,CAAC;AAUX,QAAA,MAAM,6BAA6B;;CAmsBjC,CAAC;AAEH,eAAe,6BAA6B,CAAC"}

package/dist/rules/prefer-lodash-iteratee-shorthand.js

@@ -100,6 +100,9 @@ const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://git
         function isStringLiteral(node) {
             return !_.isNil(node) && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string';
         }
+        function isNumberLiteral(node) {
+            return !_.isNil(node) && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'number';
+        }
         function isTemplateLiteralWithoutExpressions(node) {
             return !_.isNil(node) && node.type === AST_NODE_TYPES.TemplateLiteral && _.isEmpty(node.expressions) && node.quasis.length === 1;
         }
@@ -154,57 +157,6 @@ const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://git
         function isFunctionLike(node) {
             return !_.isNil(node) && (node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression);
         }
-        function isGetCallOnParameter(expr, parameterName) {
-            const unwrapped = unwrapChain(expr);
-            if (_.isNil(unwrapped) || unwrapped.type !== AST_NODE_TYPES.CallExpression)
-                return null;
-            const callee = unwrapChain(unwrapped.callee);
-            if (!isLodashMember(callee, 'get'))
-                return null;
-            if (unwrapped.arguments.length < 2)
-                return null;
-            const arg0 = unwrapped.arguments[0];
-            const arg1 = unwrapped.arguments[1];
-            if (_.isNil(arg0) || arg0.type === AST_NODE_TYPES.SpreadElement)
-                return null;
-            if (_.isNil(arg1) || arg1.type === AST_NODE_TYPES.SpreadElement)
-                return null;
-            const object = unwrapChain(arg0);
-            if (_.isNil(object) || object.type !== AST_NODE_TYPES.Identifier || object.name !== parameterName)
-                return null;
-            if (isStringLiteral(arg1)) {
-                return { kind: 'get', pathText: sourceCode.getText(arg1), pathIsStaticString: true };
-            }
-            if (isTemplateLiteralWithoutExpressions(arg1)) {
-                return { kind: 'get', pathText: sourceCode.getText(arg1), pathIsStaticString: true };
-            }
-            if (arg1.type === AST_NODE_TYPES.Identifier) {
-                return { kind: 'get', pathText: arg1.name, pathIsStaticString: false };
-            }
-            return null;
-        }
-        function isMemberAccessOnParameter(expr, parameterName) {
-            const unwrapped = unwrapChain(expr);
-            if (_.isNil(unwrapped) || unwrapped.type !== AST_NODE_TYPES.MemberExpression)
-                return null;
-            const object = unwrapChain(unwrapped.object);
-            if (_.isNil(object) || object.type !== AST_NODE_TYPES.Identifier || object.name !== parameterName)
-                return null;
-            if (!unwrapped.computed && unwrapped.property.type === AST_NODE_TYPES.Identifier) {
-                const key = unwrapped.property.name;
-                return { kind: 'member', keyText: key, keyIsIdentifier: true };
-            }
-            if (unwrapped.computed && unwrapped.property.type === AST_NODE_TYPES.Literal && typeof unwrapped.property.value === 'string') {
-                return { kind: 'member', keyText: sourceCode.getText(unwrapped.property), keyIsIdentifier: false };
-            }
-            if (unwrapped.computed && unwrapped.property.type === AST_NODE_TYPES.Identifier) {
-                return { kind: 'member', keyText: unwrapped.property.name, keyIsIdentifier: false };
-            }
-            return null;
-        }
-        function extractPathFromExpression(expr, parameterName) {
-            return isMemberAccessOnParameter(expr, parameterName) ?? isGetCallOnParameter(expr, parameterName);
-        }
         function normalizeStaticPathText(pathText) {
             const trimmed = pathText.trim();
             if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
@@ -222,6 +174,27 @@ const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://git
             const escaped = value.replaceAll('\\', '\\\\').replaceAll("'", String.raw `\'`);
             return `'${escaped}'`;
         }
+        function toDoubleQuotedRaw(value) {
+            return value.replaceAll('\\', '\\\\').replaceAll('"', String.raw `\"`);
+        }
+        function buildLodashPathStringFromSegments(segments) {
+            if (_.isEmpty(segments))
+                return null;
+            let out = '';
+            for (const seg of segments) {
+                if (typeof seg === 'number') {
+                    out += `[${seg}]`;
+                    continue;
+                }
+                if (isValidIdentifierName(seg)) {
+                    out += _.isEmpty(out) ? seg : `.${seg}`;
+                    continue;
+                }
+                const inner = toDoubleQuotedRaw(seg);
+                out += `["${inner}"]`;
+            }
+            return out;
+        }
         function containsIdentifier(node, name) {
             const { visitorKeys } = sourceCode;
             const seen = new Set();
@@ -353,6 +326,80 @@ const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://git
                 return '{}';
             return `{${props.join(', ')}}`;
         }
+        function isGetCallOnParameter(expr, parameterName) {
+            const unwrapped = unwrapChain(expr);
+            if (_.isNil(unwrapped) || unwrapped.type !== AST_NODE_TYPES.CallExpression)
+                return null;
+            const callee = unwrapChain(unwrapped.callee);
+            if (!isLodashMember(callee, 'get'))
+                return null;
+            if (unwrapped.arguments.length < 2)
+                return null;
+            const arg0 = unwrapped.arguments[0];
+            const arg1 = unwrapped.arguments[1];
+            if (_.isNil(arg0) || arg0.type === AST_NODE_TYPES.SpreadElement)
+                return null;
+            if (_.isNil(arg1) || arg1.type === AST_NODE_TYPES.SpreadElement)
+                return null;
+            const object = unwrapChain(arg0);
+            if (_.isNil(object) || object.type !== AST_NODE_TYPES.Identifier || object.name !== parameterName)
+                return null;
+            if (isStringLiteral(arg1)) {
+                return { kind: 'get', pathText: sourceCode.getText(arg1), pathIsStaticString: true };
+            }
+            if (isTemplateLiteralWithoutExpressions(arg1)) {
+                return { kind: 'get', pathText: sourceCode.getText(arg1), pathIsStaticString: true };
+            }
+            if (arg1.type === AST_NODE_TYPES.Identifier) {
+                return { kind: 'get', pathText: arg1.name, pathIsStaticString: false };
+            }
+            return null;
+        }
+        function extractMemberPathSegments(expr, parameterName) {
+            const unwrapped = unwrapChainExpr(expr) ?? expr;
+            const segments = [];
+            let current = unwrapped;
+            while (current.type === AST_NODE_TYPES.MemberExpression) {
+                if (current.computed) {
+                    const prop = unwrapChain(current.property);
+                    if (!_.isNil(prop) && prop.type === AST_NODE_TYPES.Identifier)
+                        return null;
+                    if (isStringLiteral(prop)) {
+                        segments.unshift(prop.value);
+                    }
+                    else if (isNumberLiteral(prop)) {
+                        segments.unshift(prop.value);
+                    }
+                    else if (isTemplateLiteralWithoutExpressions(prop)) {
+                        const cooked = prop.quasis[0]?.value.cooked ?? prop.quasis[0]?.value.raw ?? '';
+                        segments.unshift(cooked);
+                    }
+                    else {
+                        return null;
+                    }
+                }
+                else {
+                    if (current.property.type !== AST_NODE_TYPES.Identifier)
+                        return null;
+                    segments.unshift(current.property.name);
+                }
+                const object = unwrapChain(current.object);
+                if (_.isNil(object))
+                    return null;
+                current = object;
+            }
+            if (current.type !== AST_NODE_TYPES.Identifier || current.name !== parameterName)
+                return null;
+            if (_.isEmpty(segments))
+                return null;
+            return segments;
+        }
+        function extractPathFromExpression(expr, parameterName) {
+            const memberSegments = extractMemberPathSegments(expr, parameterName);
+            if (!_.isNil(memberSegments))
+                return { kind: 'memberPath', segments: memberSegments };
+            return isGetCallOnParameter(expr, parameterName);
+        }
         function extractPredicateClausesFromExpression(expr, parameterName) {
             const unwrapped = unwrapChainExpr(expr);
             if (_.isNil(unwrapped))
@@ -392,21 +439,15 @@ const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://git
             }
             return clauses;
         }
-        function buildObjectKeyTextForMemberPath(path) {
-            if (path.keyIsIdentifier) {
-                return path.keyText;
-            }
-            return null;
-        }
         function buildMatchesObjectFromClauses(clauses) {
             const literals = [];
             for (const clause of clauses) {
                 const valueText = sourceCode.getText(clause.valueExpr);
-                if (clause.path.kind === 'member') {
-                    const keyText = buildObjectKeyTextForMemberPath(clause.path);
-                    if (_.isNil(keyText))
+                if (clause.path.kind === 'memberPath') {
+                    const nested = buildNestedLiteralFromSegments(clause.path.segments, valueText);
+                    if (_.isNil(nested))
                         return null;
-                    literals.push(`{${keyText}: ${valueText}}`);
+                    literals.push(nested);
                     continue;
                 }
                 if (!clause.path.pathIsStaticString) {
@@ -430,19 +471,24 @@ const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://git
             const expr = getReturnedExpression(fn);
             if (_.isNil(expr))
                 return null;
+            const memberSegments = extractMemberPathSegments(expr, parameterName);
+            if (!_.isNil(memberSegments)) {
+                const raw = buildLodashPathStringFromSegments(memberSegments);
+                if (_.isNil(raw))
+                    return null;
+                return toSingleQuotedStringLiteral(raw);
+            }
             const unwrapped = unwrapChainExpr(expr) ?? expr;
-            const member = isMemberAccessOnParameter(unwrapped, parameterName);
-            if (!_.isNil(member) && member.kind === 'member') {
-                if (!member.keyIsIdentifier && isValidIdentifierName(member.keyText)) {
-                    return member.keyText;
-                }
-                if (member.keyIsIdentifier) {
-                    return toSingleQuotedStringLiteral(member.keyText);
+            if (unwrapped.type === AST_NODE_TYPES.MemberExpression) {
+                const object = unwrapChain(unwrapped.object);
+                if (!_.isNil(object) && object.type === AST_NODE_TYPES.Identifier && object.name === parameterName && unwrapped.computed) {
+                    const prop = unwrapChain(unwrapped.property);
+                    if (!_.isNil(prop) && prop.type === AST_NODE_TYPES.Identifier) {
+                        return prop.name;
+                    }
                 }
-                const normalized = normalizeStaticPathText(member.keyText);
-                return toSingleQuotedStringLiteral(normalized);
             }
-            const get = isGetCallOnParameter(unwrapped, parameterName);
+            const get = isGetCallOnParameter(expr, parameterName);
             if (!_.isNil(get) && get.kind === 'get') {
                 return get.pathText;
             }

package/package.json

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