eslint-plugin-th-rules 3.5.0 → 3.6.0

package/dist/plugin.d.ts

@@ -11,9 +11,10 @@ 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" | "directAccessRequired", [{
+        maximumDestructuredVariables?: number;
+        maximumLineLength?: number;
+        directAccessIdentifiers?: string[];
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
@@ -63,9 +64,10 @@ 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" | "directAccessRequired", [{
+            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

@@ -1,8 +1,13 @@
 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;
+        directAccessIdentifiers?: string[];
+    }
+];
+type MessageIds = 'tooDeep' | 'tooMany' | 'tooLong' | 'tooManyCumulative' | 'directAccessRequired';
+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;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"}

package/dist/rules/no-destructuring.js

@@ -1,8 +1,7 @@
 /* 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_TAB_COUNT = 3;
+const MAX_INDENT_SPACES = 3;
 const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-destructuring.md')({
     name: 'no-destructuring',
     meta: {
@@ -16,69 +15,137 @@ 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 a nesting level above {{max}} is not allowed; found {{actual}} levels of nesting.',
+            tooDeep: 'Destructuring at an indentation above {{max}} is not allowed; found {{actual}}.',
             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.',
         },
     },
     defaultOptions: [
         {
             maximumDestructuredVariables: 2,
             maximumLineLength: 100,
+            directAccessIdentifiers: ['properties'],
         },
     ],
     create(context, [options]) {
-        const MAX_VARIABLES = options.maximumDestructuredVariables ?? 2;
-        const MAX_LINE_LENGTH = options.maximumLineLength ?? 100;
-        function reportIfNeeded(patternNode, reportNode = patternNode) {
+        const maxVariables = options.maximumDestructuredVariables ?? 2;
+        const maxLineLength = options.maximumLineLength ?? 100;
+        const directAccessIdentifiers = new Set(options.directAccessIdentifiers ?? ['properties']);
+        const sourceTotalsByScope = 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;
+                }
+            }
+            return max;
+        }
+        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 getOrCreateScopeMap(scope) {
+            const existing = sourceTotalsByScope.get(scope);
+            if (!_.isNil(existing)) {
+                return existing;
+            }
+            const created = new Map();
+            sourceTotalsByScope.set(scope, 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) {
             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 lineText = context.sourceCode.lines[startLine - 1] ?? '';
-            const indentCount = lineText.search(/\S|$/);
+            const indentSpaces = getIndentSpacesForLine(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;
-                }
-            }
-            if (indentCount > MAX_TAB_COUNT) {
+            const maxSpannedLineLength = getMaxSpannedLineLength(startLine, endLine);
+            if (indentSpaces > MAX_INDENT_SPACES) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooDeep',
-                    data: {
-                        max: MAX_TAB_COUNT,
-                        actual: indentCount,
-                    },
+                    data: { max: MAX_INDENT_SPACES, actual: indentSpaces },
                 });
             }
-            if (propertyCount > MAX_VARIABLES) {
+            if (propertyCount > maxVariables) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooMany',
-                    data: {
-                        max: MAX_VARIABLES,
-                    },
+                    data: { max: maxVariables },
                 });
             }
-            if (maxSpannedLineLength > MAX_LINE_LENGTH) {
+            if (maxSpannedLineLength > maxLineLength) {
                 context.report({
                     node: reportNode,
                     messageId: 'tooLong',
-                    data: {
-                        max: MAX_LINE_LENGTH,
-                    },
+                    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 || []) {
@@ -86,15 +153,15 @@ const noDestructuring = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh
                     continue;
                 }
                 if (p.type === AST_NODE_TYPES.AssignmentPattern) {
-                    reportIfNeeded(p.left, p);
+                    reportIfNeeded(p.left, p, undefined);
                     continue;
                 }
-                reportIfNeeded(p, p);
+                reportIfNeeded(p, p, undefined);
             }
         }
         return {
             VariableDeclarator(node) {
-                reportIfNeeded(node.id, node);
+                reportIfNeeded(node.id, node, node.init);
             },
             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.0",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",