eslint-plugin-th-rules 3.4.3 → 3.5.0

package/README.md

@@ -166,18 +166,20 @@ Do not edit below this line.
 🎲 Set in the `recommendedTypescriptReact` configuration.\
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
 
-| Name                                                                 | Description                                                                                                                                                                                        | 💼         | 🔧 |
-| :------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- | :- |
-| [no-boolean-coercion](docs/rules/no-boolean-coercion.md)             | Disallow Boolean(value) or !!value. Enforce explicit checks: !_.isNil(value) for scalars and !_.isEmpty(value) for strings, arrays, and objects. If the value is already boolean, remove coercion. | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [no-comments](docs/rules/no-comments.md)                             | Disallow comments except for specified allowed patterns.                                                                                                                                           | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [no-default-export](docs/rules/no-default-export.md)                 | Convert unnamed default exports to named default exports based on the file name.                                                                                                                   | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [no-destructuring](docs/rules/no-destructuring.md)                   | Disallow destructuring that does not meet certain conditions.                                                                                                                                      | ✅ ⚛️ 🟦 🎲 |    |
-| [no-explicit-nil-compare](docs/rules/no-explicit-nil-compare.md)     | Disallow direct comparisons to null or undefined. Use _.isNull(x) / _.isUndefined(x) instead.                                                                                                      | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [prefer-explicit-nil-check](docs/rules/prefer-explicit-nil-check.md) | Disallow implicit truthy/falsy checks in boolean-test positions. Prefer explicit _.isNil(value) or _.isEmpty(value) (depending on the value type).                                                 | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [prefer-is-empty](docs/rules/prefer-is-empty.md)                     | Require _.isEmpty instead of length comparisons or boolean checks on .length.                                                                                                                      | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [schemas-in-schemas-file](docs/rules/schemas-in-schemas-file.md)     | Require Zod schema declarations to be placed in a .schemas.ts file.                                                                                                                                | ✅ ⚛️ 🟦 🎲 |    |
-| [top-level-functions](docs/rules/top-level-functions.md)             | Require all top-level functions to be named regular functions.                                                                                                                                     | ✅ ⚛️ 🟦 🎲 | 🔧 |
-| [types-in-dts](docs/rules/types-in-dts.md)                           | Require TypeScript type declarations (type/interface/enum) to be placed in .d.ts files.                                                                                                            | ✅ ⚛️ 🟦 🎲 |    |
+| Name                                                                               | Description                                                                                                                                                                                                                | 💼         | 🔧 |
+| :--------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- | :- |
+| [no-boolean-coercion](docs/rules/no-boolean-coercion.md)                           | Disallow Boolean(value) or !!value. Enforce explicit checks: !_.isNil(value) for scalars and !_.isEmpty(value) for strings, arrays, and objects. If the value is already boolean, remove coercion.                         | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-comments](docs/rules/no-comments.md)                                           | Disallow comments except for specified allowed patterns.                                                                                                                                                                   | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-default-export](docs/rules/no-default-export.md)                               | Convert unnamed default exports to named default exports based on the file name.                                                                                                                                           | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-destructuring](docs/rules/no-destructuring.md)                                 | Disallow destructuring that does not meet certain conditions.                                                                                                                                                              | ✅ ⚛️ 🟦 🎲 |    |
+| [no-explicit-nil-compare](docs/rules/no-explicit-nil-compare.md)                   | Disallow direct comparisons to null or undefined. Use _.isNull(x) / _.isUndefined(x) instead.                                                                                                                              | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [no-isnil-isempty-on-boolean](docs/rules/no-isnil-isempty-on-boolean.md)           | Disallow _.isNil(...) / _.isEmpty(...) when the argument type is boolean or a union containing boolean (e.g., boolean \| undefined, boolean \| X).                                                                         | ✅ ⚛️ 🟦 🎲 |    |
+| [prefer-explicit-nil-check](docs/rules/prefer-explicit-nil-check.md)               | Disallow implicit truthy/falsy checks in boolean-test positions. Prefer explicit _.isNil(value) or _.isEmpty(value) (depending on the value type).                                                                         | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [prefer-is-empty](docs/rules/prefer-is-empty.md)                                   | Require _.isEmpty instead of length comparisons or boolean checks on .length.                                                                                                                                              | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [prefer-lodash-iteratee-shorthand](docs/rules/prefer-lodash-iteratee-shorthand.md) | Prefer Lodash iteratee shorthands. Example: _.find(collection, (x) => x.Y === z) -> _.find(collection, {Y: z}). Also prefers property shorthands like _.map(collection, (x) => _.get(x, path)) -> _.map(collection, path). | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [schemas-in-schemas-file](docs/rules/schemas-in-schemas-file.md)                   | Require Zod schema declarations to be placed in a .schemas.ts file.                                                                                                                                                        | ✅ ⚛️ 🟦 🎲 |    |
+| [top-level-functions](docs/rules/top-level-functions.md)                           | Require all top-level functions to be named regular functions.                                                                                                                                                             | ✅ ⚛️ 🟦 🎲 | 🔧 |
+| [types-in-dts](docs/rules/types-in-dts.md)                                         | Require TypeScript type declarations (type/interface/enum) to be placed in .d.ts files.                                                                                                                                    | ✅ ⚛️ 🟦 🎲 |    |
 
 <!-- end auto-generated rules list -->
 

package/dist/plugin.d.ts

@@ -45,6 +45,9 @@ export declare const rules: {
     'no-isnil-isempty-on-boolean': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBoolean", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'prefer-lodash-iteratee-shorthand': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useMatchesObject" | "usePropertyShorthand" | "useLodashMethod", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
 };
 declare const plugin: {
     rules: {
@@ -94,6 +97,9 @@ declare const plugin: {
         'no-isnil-isempty-on-boolean': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noBoolean", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'prefer-lodash-iteratee-shorthand': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useMatchesObject" | "usePropertyShorthand" | "useLodashMethod", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
     };
 };
 export default plugin;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjB,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/plugin.js

@@ -9,6 +9,7 @@ import schemasInSchemasFile from './rules/schemas-in-schemas-file.js';
 import topLevelFunctions from './rules/top-level-functions.js';
 import typesInDts from './rules/types-in-dts.js';
 import noIsNilOrIsEmptyOnBoolean from './rules/no-isnil-isempty-on-boolean.js';
+import preferLodashIterateeShorthand from './rules/prefer-lodash-iteratee-shorthand.js';
 export const rules = {
     'no-boolean-coercion': noBooleanCoercion,
     'no-comments': noComments,
@@ -21,6 +22,7 @@ export const rules = {
     'top-level-functions': topLevelFunctions,
     'types-in-dts': typesInDts,
     'no-isnil-isempty-on-boolean': noIsNilOrIsEmptyOnBoolean,
+    'prefer-lodash-iteratee-shorthand': preferLodashIterateeShorthand,
 };
 const plugin = { rules };
 export default plugin;

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

@@ -0,0 +1,19 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const PREDICATE_METHOD_NAMES: readonly ["find", "findLast", "findIndex", "findLastIndex", "filter", "reject", "some", "every", "partition", "dropWhile", "takeWhile", "remove", "findKey", "findLastKey"];
+export declare const ITERATEE_METHOD_NAMES: readonly ["map", "flatMap", "flatMapDeep", "flatMapDepth", "forEach", "each", "groupBy", "keyBy", "countBy", "sortBy", "orderBy", "minBy", "maxBy", "sumBy", "meanBy", "uniqBy", "differenceBy", "intersectionBy", "unionBy", "xorBy", "sortedUniqBy"];
+export declare const NATIVE_TO_LODASH_METHOD_NAMES: {
+    readonly find: "find";
+    readonly findLast: "findLast";
+    readonly findIndex: "findIndex";
+    readonly findLastIndex: "findLastIndex";
+    readonly filter: "filter";
+    readonly some: "some";
+    readonly every: "every";
+    readonly map: "map";
+    readonly flatMap: "flatMap";
+};
+declare const preferLodashIterateeShorthand: ESLintUtils.RuleModule<"useMatchesObject" | "usePropertyShorthand" | "useLodashMethod", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default preferLodashIterateeShorthand;
+//# sourceMappingURL=prefer-lodash-iteratee-shorthand.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,644 @@
+/* eslint-disable th-rules/types-in-dts */
+/* eslint-disable new-cap */
+/* eslint-disable complexity */
+import _ from 'lodash';
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+const RULE_NAME = 'prefer-lodash-iteratee-shorthand';
+export const PREDICATE_METHOD_NAMES = [
+    'find',
+    'findLast',
+    'findIndex',
+    'findLastIndex',
+    'filter',
+    'reject',
+    'some',
+    'every',
+    'partition',
+    'dropWhile',
+    'takeWhile',
+    'remove',
+    'findKey',
+    'findLastKey',
+];
+export const ITERATEE_METHOD_NAMES = [
+    'map',
+    'flatMap',
+    'flatMapDeep',
+    'flatMapDepth',
+    'forEach',
+    'each',
+    'groupBy',
+    'keyBy',
+    'countBy',
+    'sortBy',
+    'orderBy',
+    'minBy',
+    'maxBy',
+    'sumBy',
+    'meanBy',
+    'uniqBy',
+    'differenceBy',
+    'intersectionBy',
+    'unionBy',
+    'xorBy',
+    'sortedUniqBy',
+];
+export const NATIVE_TO_LODASH_METHOD_NAMES = {
+    find: 'find',
+    findLast: 'findLast',
+    findIndex: 'findIndex',
+    findLastIndex: 'findLastIndex',
+    filter: 'filter',
+    some: 'some',
+    every: 'every',
+    map: 'map',
+    flatMap: 'flatMap',
+};
+function typedKeys(object) {
+    return Object.keys(object);
+}
+const preferLodashIterateeShorthand = ESLintUtils.RuleCreator(() => `https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/${RULE_NAME}.md`)({
+    name: RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Lodash iteratee shorthands. Example: _.find(collection, (x) => x.Y === z) -> _.find(collection, {Y: z}). Also prefers property shorthands like _.map(collection, (x) => _.get(x, path)) -> _.map(collection, path).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useMatchesObject: 'Prefer Lodash iteratee shorthand. Use {{replacement}}.',
+            usePropertyShorthand: 'Prefer Lodash iteratee shorthand. Use {{replacement}}.',
+            useLodashMethod: 'Prefer Lodash iteratee shorthand. Use {{replacement}}.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = context;
+        const PREDICATE_METHODS = new Set(PREDICATE_METHOD_NAMES);
+        const ITERATEE_METHODS = new Set(ITERATEE_METHOD_NAMES);
+        const nativeMethodNames = typedKeys(NATIVE_TO_LODASH_METHOD_NAMES);
+        const NATIVE_METHODS = new Set(nativeMethodNames);
+        function ensureLodashImport(fixer) {
+            const imports = sourceCode.ast.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration);
+            const hasLodash = imports.some((imp) => imp.source.value === 'lodash' && imp.specifiers.some((s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier || s.type === AST_NODE_TYPES.ImportNamespaceSpecifier));
+            if (hasLodash)
+                return null;
+            const firstImport = imports[0];
+            return _.isNil(firstImport) ? fixer.insertTextBeforeRange([0, 0], `import _ from 'lodash';\n`) : fixer.insertTextBefore(firstImport, `import _ from 'lodash';\n`);
+        }
+        function unwrapChain(node) {
+            return node?.type === AST_NODE_TYPES.ChainExpression ? node.expression : node;
+        }
+        function unwrapChainExpr(node) {
+            const unwrapped = unwrapChain(node);
+            return !_.isNil(unwrapped) && !_.isEmpty(unwrapped.type) ? unwrapped : undefined;
+        }
+        function isIdentifier(node, name) {
+            return !_.isNil(node) && node.type === AST_NODE_TYPES.Identifier && node.name === name;
+        }
+        function isStringLiteral(node) {
+            return !_.isNil(node) && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string';
+        }
+        function isTemplateLiteralWithoutExpressions(node) {
+            return !_.isNil(node) && node.type === AST_NODE_TYPES.TemplateLiteral && _.isEmpty(node.expressions) && node.quasis.length === 1;
+        }
+        function isLodashIdentifier(node) {
+            return isIdentifier(node, '_');
+        }
+        function isLodashMember(node, methodName) {
+            const unwrapped = unwrapChain(node);
+            return (!_.isNil(unwrapped) &&
+                unwrapped.type === AST_NODE_TYPES.MemberExpression &&
+                !unwrapped.computed &&
+                unwrapped.property.type === AST_NODE_TYPES.Identifier &&
+                unwrapped.property.name === methodName &&
+                isLodashIdentifier(unwrapped.object));
+        }
+        function isLodashStaticCall(node, methodName) {
+            return isLodashMember(node.callee, methodName);
+        }
+        function isLodashWrapperCallExpression(node) {
+            const unwrapped = unwrapChain(node);
+            return !_.isNil(unwrapped) && unwrapped.type === AST_NODE_TYPES.CallExpression && unwrapped.callee.type === AST_NODE_TYPES.Identifier && unwrapped.callee.name === '_';
+        }
+        function isLodashWrapperMethodCall(node, methodName) {
+            const callee = unwrapChain(node.callee);
+            if (_.isNil(callee) || callee.type !== AST_NODE_TYPES.MemberExpression)
+                return false;
+            if (callee.computed)
+                return false;
+            if (callee.property.type !== AST_NODE_TYPES.Identifier)
+                return false;
+            if (callee.property.name !== methodName)
+                return false;
+            return isLodashWrapperCallExpression(callee.object);
+        }
+        function getFunctionParameterName(fn) {
+            if (fn.params.length !== 1)
+                return null;
+            const parameter = fn.params[0];
+            return parameter.type === AST_NODE_TYPES.Identifier ? parameter.name : null;
+        }
+        function getReturnedExpression(fn) {
+            if (fn.body.type === AST_NODE_TYPES.BlockStatement) {
+                if (fn.body.body.length !== 1)
+                    return null;
+                const only = fn.body.body[0];
+                if (only.type !== AST_NODE_TYPES.ReturnStatement)
+                    return null;
+                return only.argument ?? null;
+            }
+            return fn.body;
+        }
+        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('"'))) {
+                return trimmed.slice(1, -1);
+            }
+            if (trimmed.startsWith('`') && trimmed.endsWith('`')) {
+                return trimmed.slice(1, -1);
+            }
+            return trimmed;
+        }
+        function isValidIdentifierName(name) {
+            return /^[A-Za-z_$][\w$]*$/.test(name);
+        }
+        function toSingleQuotedStringLiteral(value) {
+            const escaped = value.replaceAll('\\', '\\\\').replaceAll("'", String.raw `\'`);
+            return `'${escaped}'`;
+        }
+        function containsIdentifier(node, name) {
+            const { visitorKeys } = sourceCode;
+            const seen = new Set();
+            const stack = [node];
+            while (!_.isEmpty(stack)) {
+                const current = stack.pop();
+                if (_.isNil(current))
+                    continue;
+                if (seen.has(current))
+                    continue;
+                seen.add(current);
+                if (current.type === AST_NODE_TYPES.Identifier && current.name === name)
+                    return true;
+                const keys = visitorKeys[current.type] ?? [];
+                for (const key of keys) {
+                    const value = current[key];
+                    if (_.isNil(value))
+                        continue;
+                    if (Array.isArray(value)) {
+                        for (const item of value) {
+                            if (!item || typeof item !== 'object')
+                                continue;
+                            stack.push(item);
+                        }
+                        continue;
+                    }
+                    if (typeof value === 'object') {
+                        stack.push(value);
+                    }
+                }
+            }
+            return false;
+        }
+        function parseLodashPathSegments(path) {
+            const segments = [];
+            let i = 0;
+            const { length } = path;
+            const skipDot = () => {
+                if (path[i] === '.')
+                    i += 1;
+            };
+            const readIdent = () => {
+                const start = i;
+                if (start >= length)
+                    return null;
+                const first = path[start];
+                if (_.isEmpty(first) || !/[A-Za-z_$]/.test(first))
+                    return null;
+                i += 1;
+                while (i < length && /[\w$]/.test(path[i] ?? ''))
+                    i += 1;
+                return path.slice(start, i);
+            };
+            const readBracketIndex = () => {
+                if (path[i] !== '[')
+                    return null;
+                i += 1;
+                const start = i;
+                while (i < length && /\d/.test(path[i] ?? ''))
+                    i += 1;
+                if (start === i)
+                    return null;
+                if (path[i] !== ']')
+                    return null;
+                const number_ = Number(path.slice(start, i));
+                i += 1;
+                return Number.isFinite(number_) ? number_ : null;
+            };
+            while (i < length) {
+                skipDot();
+                if (i >= length)
+                    break;
+                if (path[i] === '[') {
+                    const idx = readBracketIndex();
+                    if (_.isNil(idx))
+                        return null;
+                    segments.push(idx);
+                    skipDot();
+                    continue;
+                }
+                const ident = readIdent();
+                if (_.isNil(ident))
+                    return null;
+                segments.push(ident);
+                skipDot();
+            }
+            return segments;
+        }
+        function buildNestedLiteralFromSegments(segments, valueText) {
+            if (_.isEmpty(segments))
+                return null;
+            const build = (idx) => {
+                const seg = segments[idx];
+                if (_.isNil(seg))
+                    return null;
+                const tail = idx === segments.length - 1 ? valueText : build(idx + 1);
+                if (_.isNil(tail))
+                    return null;
+                if (typeof seg === 'number') {
+                    const holes = new Array(seg).fill('').join(',');
+                    const prefix = seg === 0 ? '' : holes;
+                    const comma = seg === 0 ? '' : ',';
+                    return `[${prefix}${comma}${tail}]`;
+                }
+                const key = isValidIdentifierName(seg) ? seg : toSingleQuotedStringLiteral(seg);
+                return `{${key}: ${tail}}`;
+            };
+            return build(0);
+        }
+        function mergeObjectLiteralsIntoOne(literals) {
+            const trimmed = literals.map((s) => s.trim());
+            const allArrays = trimmed.every((s) => s.startsWith('['));
+            const anyArrays = trimmed.some((s) => s.startsWith('['));
+            if (anyArrays && !allArrays)
+                return null;
+            if (allArrays) {
+                return trimmed.length === 1 ? trimmed[0] : null;
+            }
+            const props = [];
+            for (const lit of trimmed) {
+                if (!lit.startsWith('{') || !lit.endsWith('}'))
+                    return null;
+                const inner = lit.slice(1, -1).trim();
+                if (_.isEmpty(inner))
+                    continue;
+                props.push(inner);
+            }
+            if (_.isEmpty(props))
+                return '{}';
+            return `{${props.join(', ')}}`;
+        }
+        function extractPredicateClausesFromExpression(expr, parameterName) {
+            const unwrapped = unwrapChainExpr(expr);
+            if (_.isNil(unwrapped))
+                return null;
+            const flattenAnd = (e) => {
+                const u = unwrapChainExpr(e) ?? e;
+                if (u.type === AST_NODE_TYPES.LogicalExpression && u.operator === '&&') {
+                    return [...flattenAnd(u.left), ...flattenAnd(u.right)];
+                }
+                return [u];
+            };
+            const parts = flattenAnd(unwrapped);
+            const clauses = [];
+            for (const part of parts) {
+                const u = unwrapChainExpr(part) ?? part;
+                if (u.type !== AST_NODE_TYPES.BinaryExpression)
+                    return null;
+                if (u.operator !== '===' && u.operator !== '==')
+                    return null;
+                const left = unwrapChainExpr(u.left) ?? u.left;
+                const right = unwrapChainExpr(u.right) ?? u.right;
+                const leftPath = extractPathFromExpression(left, parameterName);
+                const rightPath = extractPathFromExpression(right, parameterName);
+                if (!_.isNil(leftPath) && _.isNil(rightPath)) {
+                    if (containsIdentifier(right, parameterName))
+                        return null;
+                    clauses.push({ path: leftPath, valueExpr: right });
+                    continue;
+                }
+                if (_.isNil(leftPath) && !_.isNil(rightPath)) {
+                    if (containsIdentifier(left, parameterName))
+                        return null;
+                    clauses.push({ path: rightPath, valueExpr: left });
+                    continue;
+                }
+                return null;
+            }
+            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))
+                        return null;
+                    literals.push(`{${keyText}: ${valueText}}`);
+                    continue;
+                }
+                if (!clause.path.pathIsStaticString) {
+                    return null;
+                }
+                const rawPath = normalizeStaticPathText(clause.path.pathText);
+                const segments = parseLodashPathSegments(rawPath);
+                if (_.isNil(segments))
+                    return null;
+                const nested = buildNestedLiteralFromSegments(segments, valueText);
+                if (_.isNil(nested))
+                    return null;
+                literals.push(nested);
+            }
+            return mergeObjectLiteralsIntoOne(literals);
+        }
+        function extractPropertyIterateeRewrite(fn) {
+            const parameterName = getFunctionParameterName(fn);
+            if (_.isNil(parameterName))
+                return null;
+            const expr = getReturnedExpression(fn);
+            if (_.isNil(expr))
+                return null;
+            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);
+                }
+                const normalized = normalizeStaticPathText(member.keyText);
+                return toSingleQuotedStringLiteral(normalized);
+            }
+            const get = isGetCallOnParameter(unwrapped, parameterName);
+            if (!_.isNil(get) && get.kind === 'get') {
+                return get.pathText;
+            }
+            return null;
+        }
+        function getMethodNameFromMemberCallee(callee) {
+            const unwrapped = unwrapChain(callee);
+            if (_.isNil(unwrapped) || unwrapped.type !== AST_NODE_TYPES.MemberExpression)
+                return null;
+            if (unwrapped.computed)
+                return null;
+            if (unwrapped.property.type !== AST_NODE_TYPES.Identifier)
+                return null;
+            return unwrapped.property.name;
+        }
+        function isNativeArrayMethodCall(node) {
+            const callee = unwrapChain(node.callee);
+            if (_.isNil(callee) || callee.type !== AST_NODE_TYPES.MemberExpression)
+                return null;
+            const method = getMethodNameFromMemberCallee(callee);
+            if (_.isNil(method) || !NATIVE_METHODS.has(method))
+                return null;
+            if (isLodashIdentifier(callee.object))
+                return null;
+            if (isLodashWrapperCallExpression(callee.object))
+                return null;
+            const collectionText = sourceCode.getText(callee.object);
+            return { methodName: method, collectionText };
+        }
+        function isLodashMethodCall(node) {
+            const method = getMethodNameFromMemberCallee(node.callee);
+            if (_.isNil(method))
+                return null;
+            if (isLodashStaticCall(node, method))
+                return { mode: 'static', methodName: method };
+            if (isLodashWrapperMethodCall(node, method))
+                return { mode: 'wrapper', methodName: method };
+            return null;
+        }
+        function reportAndFixReplaceCallWithLodash(callNode, methodName, collectionText, iterateeText, fixer) {
+            const replacement = `_.${methodName}(${collectionText}, ${iterateeText})`;
+            const target = callNode.parent?.type === AST_NODE_TYPES.ChainExpression ? callNode.parent : callNode;
+            const fixes = [fixer.replaceText(target, replacement)];
+            const importFix = ensureLodashImport(fixer);
+            if (!_.isNil(importFix))
+                fixes.push(importFix);
+            return fixes;
+        }
+        function reportAndFixReplaceArgument(nodeToFix, replacementText, fixer) {
+            const fixes = [fixer.replaceText(nodeToFix, replacementText)];
+            const importFix = ensureLodashImport(fixer);
+            if (!_.isNil(importFix))
+                fixes.push(importFix);
+            return fixes;
+        }
+        function getNativeIterateeKind(methodName) {
+            const lodashMethod = NATIVE_TO_LODASH_METHOD_NAMES[methodName];
+            if (PREDICATE_METHODS.has(lodashMethod))
+                return 'predicate';
+            if (ITERATEE_METHODS.has(lodashMethod))
+                return 'iteratee';
+            return null;
+        }
+        return {
+            CallExpression(node) {
+                const nativeCall = isNativeArrayMethodCall(node);
+                if (!_.isNil(nativeCall)) {
+                    const arg0 = node.arguments[0];
+                    if (_.isNil(arg0) || arg0.type === AST_NODE_TYPES.SpreadElement)
+                        return;
+                    if (!isFunctionLike(arg0))
+                        return;
+                    const lodashMethod = NATIVE_TO_LODASH_METHOD_NAMES[nativeCall.methodName];
+                    const kind = getNativeIterateeKind(nativeCall.methodName);
+                    if (_.isNil(kind))
+                        return;
+                    if (kind === 'predicate') {
+                        const expr = getReturnedExpression(arg0);
+                        if (_.isNil(expr))
+                            return;
+                        const parameterName = getFunctionParameterName(arg0);
+                        if (_.isNil(parameterName))
+                            return;
+                        const clauses = extractPredicateClausesFromExpression(expr, parameterName);
+                        if (_.isNil(clauses) || _.isEmpty(clauses))
+                            return;
+                        const matchesObject = buildMatchesObjectFromClauses(clauses);
+                        if (_.isNil(matchesObject))
+                            return;
+                        const replacement = `_.${lodashMethod}(${nativeCall.collectionText}, ${matchesObject})`;
+                        context.report({
+                            node,
+                            messageId: 'useLodashMethod',
+                            data: { replacement },
+                            fix(fixer) {
+                                return reportAndFixReplaceCallWithLodash(node, lodashMethod, nativeCall.collectionText, matchesObject, fixer);
+                            },
+                        });
+                        return;
+                    }
+                    if (kind === 'iteratee') {
+                        const replacementIteratee = extractPropertyIterateeRewrite(arg0);
+                        if (_.isNil(replacementIteratee))
+                            return;
+                        const replacement = `_.${lodashMethod}(${nativeCall.collectionText}, ${replacementIteratee})`;
+                        context.report({
+                            node,
+                            messageId: 'useLodashMethod',
+                            data: { replacement },
+                            fix(fixer) {
+                                return reportAndFixReplaceCallWithLodash(node, lodashMethod, nativeCall.collectionText, replacementIteratee, fixer);
+                            },
+                        });
+                        return;
+                    }
+                }
+                const lodashCall = isLodashMethodCall(node);
+                if (_.isNil(lodashCall))
+                    return;
+                if (PREDICATE_METHODS.has(lodashCall.methodName)) {
+                    const predicateIndex = lodashCall.mode === 'static' ? 1 : 0;
+                    const predicateArg = node.arguments[predicateIndex];
+                    if (_.isNil(predicateArg) || predicateArg.type === AST_NODE_TYPES.SpreadElement)
+                        return;
+                    if (isFunctionLike(predicateArg)) {
+                        const expr = getReturnedExpression(predicateArg);
+                        if (_.isNil(expr))
+                            return;
+                        const parameterName = getFunctionParameterName(predicateArg);
+                        if (_.isNil(parameterName))
+                            return;
+                        const clauses = extractPredicateClausesFromExpression(expr, parameterName);
+                        if (_.isNil(clauses) || _.isEmpty(clauses))
+                            return;
+                        const matchesObject = buildMatchesObjectFromClauses(clauses);
+                        if (_.isNil(matchesObject))
+                            return;
+                        context.report({
+                            node: predicateArg,
+                            messageId: 'useMatchesObject',
+                            data: { replacement: matchesObject },
+                            fix(fixer) {
+                                return reportAndFixReplaceArgument(predicateArg, matchesObject, fixer);
+                            },
+                        });
+                        return;
+                    }
+                }
+                if (ITERATEE_METHODS.has(lodashCall.methodName)) {
+                    const iterateeIndex = lodashCall.mode === 'static' ? 1 : 0;
+                    const iterateeArg = node.arguments[iterateeIndex];
+                    if (_.isNil(iterateeArg) || iterateeArg.type === AST_NODE_TYPES.SpreadElement)
+                        return;
+                    if (iterateeArg.type === AST_NODE_TYPES.ArrayExpression && (lodashCall.methodName === 'sortBy' || lodashCall.methodName === 'orderBy')) {
+                        const rewrites = [];
+                        for (const element of iterateeArg.elements) {
+                            if (_.isNil(element) || element.type === AST_NODE_TYPES.SpreadElement)
+                                continue;
+                            if (!isFunctionLike(element))
+                                continue;
+                            const replacement = extractPropertyIterateeRewrite(element);
+                            if (!_.isNil(replacement))
+                                rewrites.push({ element, replacement });
+                        }
+                        if (_.isEmpty(rewrites))
+                            return;
+                        context.report({
+                            node: iterateeArg,
+                            messageId: 'usePropertyShorthand',
+                            data: { replacement: sourceCode.getText(iterateeArg) },
+                            fix(fixer) {
+                                const fixes = rewrites.map(({ element, replacement }) => fixer.replaceText(element, replacement));
+                                const importFix = ensureLodashImport(fixer);
+                                if (!_.isNil(importFix))
+                                    fixes.push(importFix);
+                                return fixes;
+                            },
+                        });
+                        return;
+                    }
+                    if (isFunctionLike(iterateeArg)) {
+                        const replacement = extractPropertyIterateeRewrite(iterateeArg);
+                        if (_.isNil(replacement))
+                            return;
+                        context.report({
+                            node: iterateeArg,
+                            messageId: 'usePropertyShorthand',
+                            data: { replacement },
+                            fix(fixer) {
+                                return reportAndFixReplaceArgument(iterateeArg, replacement, fixer);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+export default preferLodashIterateeShorthand;

package/package.json

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