eslint-plugin-th-rules 3.4.3 → 3.6.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

@@ -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;
     };
@@ -45,6 +46,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: {
@@ -60,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;
         };
@@ -94,6 +99,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/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

@@ -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;;CAmsBjC,CAAC;AAEH,eAAe,6BAA6B,CAAC"}

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

@@ -0,0 +1,690 @@
+/* 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 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;
+        }
+        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 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 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();
+            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 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))
+                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 buildMatchesObjectFromClauses(clauses) {
+            const literals = [];
+            for (const clause of clauses) {
+                const valueText = sourceCode.getText(clause.valueExpr);
+                if (clause.path.kind === 'memberPath') {
+                    const nested = buildNestedLiteralFromSegments(clause.path.segments, valueText);
+                    if (_.isNil(nested))
+                        return null;
+                    literals.push(nested);
+                    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 memberSegments = extractMemberPathSegments(expr, parameterName);
+            if (!_.isNil(memberSegments)) {
+                const raw = buildLodashPathStringFromSegments(memberSegments);
+                if (_.isNil(raw))
+                    return null;
+                return toSingleQuotedStringLiteral(raw);
+            }
+            const unwrapped = unwrapChainExpr(expr) ?? expr;
+            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 get = isGetCallOnParameter(expr, 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.6.0",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",