eslint-plugin-remeda 1.3.1 → 1.5.0

package/README.md

@@ -2,42 +2,52 @@
 
 ESLint plugin for [Remeda](https://github.com/remeda/remeda).
 
+## Preamble
+
+This plugin was originally derived from [eslint-plugin-lodash-f](https://github.com/AndreaPontrandolfo/eslint-plugin-lodash) (fork of [eslint-plugin-lodash](https://github.com/wix-incubator/eslint-plugin-lodash)) and used that as a base to build upon.
+
 ## Installation
 
 First, you'll first need to install [ESLint](https://eslint.org/):
 
 ```sh
-npm add eslint -D
+pnpm add -D eslint
 ```
 
 Next, install `eslint-plugin-remeda`:
 
 ```sh
-npm add eslint-plugin-remeda -D
+pnpm add -D eslint-plugin-remeda
 ```
 
-## Preamble
-
-This plugin was originally derived from [eslint-plugin-lodash-f](https://github.com/AndreaPontrandolfo/eslint-plugin-lodash) (fork of [eslint-plugin-lodash](https://github.com/wix-incubator/eslint-plugin-lodash)) and used that as a base to build upon.
-
 ## Rules
 
 Enable all of the rules that you would like to use. All rules are off by default, unless you use one of the plugin's configurations which turn all relevant rules on.
 
-- [collection-method-value](docs/rules/collection-method-value.md): Use value returned from collection methods properly.
-- [collection-return](docs/rules/collection-return.md): Always return a value in iteratees of Remeda collection methods that aren't `forEach`.
-- [prefer-filter](docs/rules/prefer-filter.md): Prefer `R.filter` over `R.forEach` with an `if` statement inside.
-- [prefer-find](docs/rules/prefer-find.md): Prefer `R.find` over `R.filter` followed by selecting the first result.
-- [prefer-flat-map](docs/rules/prefer-flat-map.md): Prefer `R.flatMap` over consecutive `R.map` and `R.flat`.
-- [prefer-map](docs/rules/prefer-map.md): Prefer `R.map` over `R.forEach` with a `push` inside.
-- [prefer-nullish-coalescing](docs/rules/prefer-nullish-coalescing.md): Prefer `??` when doing a comparison with a non-nullish value as test.
-- [prefer-constant](docs/rules/prefer-constant.md): Prefer `R.constant` over functions returning literals.
-- [prefer-is-empty](docs/rules/prefer-is-empty.md): Prefer `R.isEmpty` over manual checking for length value.
-- [prefer-is-nil](docs/rules/prefer-is-nil.md): Prefer `R.isNil` over checks for both null and undefined.
-- [prefer-remeda-typecheck](docs/rules/prefer-remeda-typecheck.md): Prefer using `R.is*` methods over `typeof` and `instanceof` checks when applicable.
-- [prefer-do-nothing](docs/rules/prefer-do-nothing.md): Prefer `R.doNothing` over empty functions.
-- [prefer-some](docs/rules/prefer-some.md): Prefer using `R.some` over comparing `findIndex` to -1.
-- [prefer-times](docs/rules/prefer-times.md): Prefer `R.times` over `R.map` without using the iteratee's arguments.
+<!-- begin auto-generated rules list -->
+
+💼 Configurations enabled in.\
+✅ Set in the `recommended` configuration.\
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
+
+| Name                                                                 | 💼  | 🔧  |
+| :------------------------------------------------------------------- | :-- | :-- |
+| [collection-method-value](docs/rules/collection-method-value.md)     | ✅  |     |
+| [collection-return](docs/rules/collection-return.md)                 | ✅  |     |
+| [prefer-constant](docs/rules/prefer-constant.md)                     | ✅  |     |
+| [prefer-do-nothing](docs/rules/prefer-do-nothing.md)                 | ✅  |     |
+| [prefer-filter](docs/rules/prefer-filter.md)                         | ✅  |     |
+| [prefer-find](docs/rules/prefer-find.md)                             | ✅  |     |
+| [prefer-flat-map](docs/rules/prefer-flat-map.md)                     | ✅  |     |
+| [prefer-is-empty](docs/rules/prefer-is-empty.md)                     | ✅  | 🔧  |
+| [prefer-is-nullish](docs/rules/prefer-is-nullish.md)                 | ✅  |     |
+| [prefer-map](docs/rules/prefer-map.md)                               | ✅  |     |
+| [prefer-nullish-coalescing](docs/rules/prefer-nullish-coalescing.md) | ✅  | 🔧  |
+| [prefer-remeda-typecheck](docs/rules/prefer-remeda-typecheck.md)     | ✅  |     |
+| [prefer-some](docs/rules/prefer-some.md)                             | ✅  |     |
+| [prefer-times](docs/rules/prefer-times.md)                           | ✅  |     |
+
+<!-- end auto-generated rules list -->
 
 ## Contributing
 

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -33,7 +23,7 @@ __export(src_exports, {
   default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-var import_lodash12 = require("lodash");
+var import_lodash_es12 = require("lodash-es");
 
 // package.json
 var version = "0.0.0-development";
@@ -55,6 +45,8 @@ var package_default = {
     attw: "attw --pack .",
     qa: "pnpm typecheck && pnpm test && pnpm knip && pnpm publint && attw",
     nuke: "rm -rf node_modules pnpm-lock.yaml",
+    "update:eslint-docs": "eslint-doc-generator",
+    "lint:eslint-docs": "pnpm update:eslint-docs -- --check",
     "semantic-release": "pnpm build && semantic-release"
   },
   files: [
@@ -80,14 +72,15 @@ var package_default = {
   },
   devDependencies: {
     "@arethetypeswrong/cli": "^0.15.4",
-    "@types/lodash": "^4.17.7",
+    "@types/lodash-es": "^4.17.12",
     "@types/node": "^20.14.9",
     "@vitest/coverage-v8": "^2.0.3",
     "@vitest/ui": "^2.0.3",
     eslint: "9.10.0",
     "eslint-config-sheriff": "^21.2.0",
     "eslint-define-config": "^2.1.0",
-    "eslint-plugin-eslint-plugin": "^6.2.0",
+    "eslint-doc-generator": "^2.1.2",
+    "eslint-plugin-eslint-plugin": "^6.4.0",
     "eslint-vitest-rule-tester": "^0.3.3",
     knip: "^5.29.1",
     prettier: "^3.3.2",
@@ -115,39 +108,39 @@ var package_default = {
   ],
   license: "MIT",
   dependencies: {
-    lodash: "^4.17.21"
+    "lodash-es": "^4.17.21"
   }
 };
 
 // src/rules/collection-method-value.ts
-var import_lodash6 = require("lodash");
+var import_lodash_es6 = require("lodash-es");
 
 // src/util/astUtil.ts
-var import_lodash = require("lodash");
-var getCaller = (0, import_lodash.property)(["callee", "object"]);
-var getMethodName = (0, import_lodash.property)(["callee", "property", "name"]);
-var isMethodCall = (0, import_lodash.matches)({
+var import_lodash_es = require("lodash-es");
+var getCaller = (0, import_lodash_es.property)(["callee", "object"]);
+var getMethodName = (0, import_lodash_es.property)(["callee", "property", "name"]);
+var isMethodCall = (0, import_lodash_es.matches)({
   type: "CallExpression",
   callee: { type: "MemberExpression" }
 });
-var isFunctionExpression = (0, import_lodash.overSome)(
-  (0, import_lodash.matchesProperty)("type", "FunctionExpression"),
-  (0, import_lodash.matchesProperty)("type", "FunctionDeclaration")
+var isFunctionExpression = (0, import_lodash_es.overSome)(
+  (0, import_lodash_es.matchesProperty)("type", "FunctionExpression"),
+  (0, import_lodash_es.matchesProperty)("type", "FunctionDeclaration")
 );
-var isFunctionDefinitionWithBlock = (0, import_lodash.overSome)(
+var isFunctionDefinitionWithBlock = (0, import_lodash_es.overSome)(
   isFunctionExpression,
-  (0, import_lodash.matches)({
+  (0, import_lodash_es.matches)({
     type: "ArrowFunctionExpression",
     body: { type: "BlockStatement" }
   })
 );
-var getFirstFunctionLine = (0, import_lodash.cond)([
-  [isFunctionDefinitionWithBlock, (0, import_lodash.property)(["body", "body", 0])],
-  [(0, import_lodash.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash.property)("body")]
+var getFirstFunctionLine = (0, import_lodash_es.cond)([
+  [isFunctionDefinitionWithBlock, (0, import_lodash_es.property)(["body", "body", 0])],
+  [(0, import_lodash_es.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash_es.property)("body")]
 ]);
-var isPropAccess = (0, import_lodash.overSome)(
-  (0, import_lodash.matches)({ computed: false }),
-  (0, import_lodash.matchesProperty)(["property", "type"], "Literal")
+var isPropAccess = (0, import_lodash_es.overSome)(
+  (0, import_lodash_es.matches)({ computed: false }),
+  (0, import_lodash_es.matchesProperty)(["property", "type"], "Literal")
 );
 function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowComputed } = {}) {
   if (objectName) {
@@ -166,18 +159,18 @@ function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowCo
     }
   }
 }
-var getFirstParamName = (0, import_lodash.property)(["params", 0, "name"]);
-var isReturnStatement = (0, import_lodash.matchesProperty)("type", "ReturnStatement");
+var getFirstParamName = (0, import_lodash_es.property)(["params", 0, "name"]);
+var isReturnStatement = (0, import_lodash_es.matchesProperty)("type", "ReturnStatement");
 function hasOnlyOneStatement(func) {
   if (isFunctionDefinitionWithBlock(func)) {
-    return (0, import_lodash.get)(func, "body.body.length") === 1;
+    return (0, import_lodash_es.get)(func, "body.body.length") === 1;
   }
   if (func.type === "ArrowFunctionExpression") {
-    return !(0, import_lodash.get)(func, "body.body");
+    return !(0, import_lodash_es.get)(func, "body.body");
   }
 }
 function isObjectOfMethodCall(node) {
-  return (0, import_lodash.get)(node, "parent.object") === node && (0, import_lodash.get)(node, "parent.parent.type") === "CallExpression";
+  return (0, import_lodash_es.get)(node, "parent.object") === node && (0, import_lodash_es.get)(node, "parent.parent.type") === "CallExpression";
 }
 function isLiteral(node) {
   return node.type === "Literal";
@@ -187,7 +180,7 @@ function isBinaryExpWithMemberOf(operator, exp, objectName, {
   allowComputed,
   onlyLiterals
 } = {}) {
-  if (!(0, import_lodash.isMatch)(exp, { type: "BinaryExpression", operator })) {
+  if (!(0, import_lodash_es.isMatch)(exp, { type: "BinaryExpression", operator })) {
     return false;
   }
   const [left, right] = [exp.left, exp.right].map(
@@ -195,7 +188,7 @@ function isBinaryExpWithMemberOf(operator, exp, objectName, {
   );
   return left === !right && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right));
 }
-var isNegationExpression = (0, import_lodash.matches)({
+var isNegationExpression = (0, import_lodash_es.matches)({
   type: "UnaryExpression",
   operator: "!"
 });
@@ -217,14 +210,14 @@ function getValueReturnedInFirstStatement(func) {
   }
 }
 function isCallFromObject(node, objName) {
-  return node && objName && node.type === "CallExpression" && (0, import_lodash.get)(node, "callee.object.name") === objName;
+  return node && objName && node.type === "CallExpression" && (0, import_lodash_es.get)(node, "callee.object.name") === objName;
 }
 function isComputed(node) {
-  return (0, import_lodash.get)(node, "computed") && node.property.type !== "Literal";
+  return (0, import_lodash_es.get)(node, "computed") && node.property.type !== "Literal";
 }
 function isEquivalentMemberExp(a, b) {
-  return (0, import_lodash.isEqualWith)(a, b, (left, right, key) => {
-    if ((0, import_lodash.includes)(["loc", "range", "computed", "start", "end", "parent"], key)) {
+  return (0, import_lodash_es.isEqualWith)(a, b, (left, right, key) => {
+    if ((0, import_lodash_es.includes)(["loc", "range", "computed", "start", "end", "parent"], key)) {
       return true;
     }
     if (isComputed(left) || isComputed(right)) {
@@ -237,7 +230,7 @@ function isEquivalentMemberExp(a, b) {
     }
   });
 }
-var isEqEqEq = (0, import_lodash.matches)({ type: "BinaryExpression", operator: "===" });
+var isEqEqEq = (0, import_lodash_es.matches)({ type: "BinaryExpression", operator: "===" });
 var isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
 var comparisonType = {
   exact: 0,
@@ -247,11 +240,11 @@ var comparisonType = {
 };
 var comparisonOperators = ["==", "!=", "===", "!=="];
 function getIsValue(value2) {
-  return value2 < 0 ? (0, import_lodash.overEvery)(isMinus, (0, import_lodash.matches)({ argument: { value: -value2 } })) : (0, import_lodash.matches)({ value: value2 });
+  return value2 < 0 ? (0, import_lodash_es.overEvery)(isMinus, (0, import_lodash_es.matches)({ argument: { value: -value2 } })) : (0, import_lodash_es.matches)({ value: value2 });
 }
 function getExpressionComparedToInt(node, value2, checkOver) {
   const isValue = getIsValue(value2);
-  if ((0, import_lodash.includes)(comparisonOperators, node.operator)) {
+  if ((0, import_lodash_es.includes)(comparisonOperators, node.operator)) {
     if (isValue(node.right)) {
       return node.left;
     }
@@ -283,13 +276,13 @@ function collectParameterValues(node) {
       return [node.name];
     }
     case "ObjectPattern": {
-      return (0, import_lodash.flatMap)(
+      return (0, import_lodash_es.flatMap)(
         node.properties,
         (prop) => collectParameterValues(prop.value)
       );
     }
     case "ArrayPattern": {
-      return (0, import_lodash.flatMap)(node.elements, collectParameterValues);
+      return (0, import_lodash_es.flatMap)(node.elements, collectParameterValues);
     }
     default: {
       return [];
@@ -331,7 +324,7 @@ function getDocsUrl(ruleName) {
 }
 
 // src/util/methodDataUtil.ts
-var import_lodash2 = require("lodash");
+var import_lodash_es2 = require("lodash-es");
 
 // src/util/methodData.ts
 var methodData_exports = {};
@@ -460,8 +453,8 @@ __export(methodData_exports, {
   isMatchWith: () => isMatchWith,
   isNaN: () => isNaN,
   isNative: () => isNative,
-  isNil: () => isNil,
   isNull: () => isNull,
+  isNullish: () => isNullish,
   isNumber: () => isNumber,
   isObject: () => isObject,
   isObjectLike: () => isObjectLike,
@@ -1488,7 +1481,7 @@ var isNative = {
   iteratee: false,
   args: 1
 };
-var isNil = {
+var isNullish = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -2755,16 +2748,16 @@ var zipWith = {
 
 // src/util/methodDataUtil.ts
 function isCollectionMethod(method2) {
-  return methodSupportsShorthand(method2) || (0, import_lodash2.includes)(["reduce", "reduceRight"], method2);
+  return methodSupportsShorthand(method2) || (0, import_lodash_es2.includes)(["reduce", "reduceRight"], method2);
 }
 function methodSupportsShorthand(method2, shorthandType) {
-  const methodShorthandData = (0, import_lodash2.get)(methodData_exports, `${method2}.shorthand`);
-  return (0, import_lodash2.isObject)(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
+  const methodShorthandData = (0, import_lodash_es2.get)(methodData_exports, `${method2}.shorthand`);
+  return (0, import_lodash_es2.isObject)(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
 }
 function getIterateeIndex(method2) {
   const methodData = methodData_exports[method2];
   if (methodData) {
-    if ((0, import_lodash2.has)(methodData, "iterateeIndex")) {
+    if ((0, import_lodash_es2.has)(methodData, "iterateeIndex")) {
       return methodData.iterateeIndex;
     }
     if (methodData.iteratee) {
@@ -2786,20 +2779,20 @@ function getSideEffectIterationMethods() {
 }
 
 // src/util/remedaUtil.ts
-var import_lodash5 = require("lodash");
+var import_lodash_es5 = require("lodash-es");
 
 // src/util/settingsUtil.ts
-var import_lodash3 = require("lodash");
+var import_lodash_es3 = require("lodash-es");
 function getSettings(context) {
-  return (0, import_lodash3.chain)(context).get(["settings", "remeda"]).clone().defaults({
+  return (0, import_lodash_es3.chain)(context).get(["settings", "remeda"]).clone().defaults({
     version: 4
   }).value();
 }
 
 // src/util/importUtil.ts
-var import_lodash4 = require("lodash");
+var import_lodash_es4 = require("lodash-es");
 function getNameFromCjsRequire(init) {
-  if ((0, import_lodash4.get)(init, "callee.name") === "require" && (0, import_lodash4.get)(init, "arguments.length") === 1 && init.arguments[0].type === "Literal") {
+  if ((0, import_lodash_es4.get)(init, "callee.name") === "require" && (0, import_lodash_es4.get)(init, "arguments.length") === 1 && init.arguments[0].type === "Literal") {
     return init.arguments[0].value;
   }
 }
@@ -2943,7 +2936,7 @@ function getIsTypeMethod(name) {
     "Error"
     // "Element",
   ];
-  return (0, import_lodash5.includes)(types, name) ? `is${(0, import_lodash5.capitalize)(name)}` : null;
+  return (0, import_lodash_es5.includes)(types, name) ? `is${(0, import_lodash_es5.capitalize)(name)}` : null;
 }
 function getRemedaMethodCallExpVisitor(remedaContext, reporter) {
   return function(node) {
@@ -2997,6 +2990,7 @@ var meta = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Use value returned from collection methods properly",
     url: getDocsUrl("collection-method-value")
   }
 };
@@ -3005,7 +2999,7 @@ function create2(context) {
     return node.parent.type !== "ExpressionStatement";
   }
   function isSideEffectIterationMethod(method2) {
-    return (0, import_lodash6.includes)(getSideEffectIterationMethods(), method2);
+    return (0, import_lodash_es6.includes)(getSideEffectIterationMethods(), method2);
   }
   function isParentCommit(node, callType) {
     return callType === "chained" && isCallToMethod(node.parent.parent, "commit");
@@ -3035,11 +3029,12 @@ var RULE_NAME = "collection-method-value";
 var collection_method_value_default = rule;
 
 // src/rules/collection-return.ts
-var import_lodash7 = require("lodash");
+var import_lodash_es7 = require("lodash-es");
 var meta2 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Always return a value in iteratees of Remeda collection methods that aren't `forEach`",
     url: getDocsUrl("collection-return")
   }
 };
@@ -3047,7 +3042,7 @@ function create3(context) {
   const funcInfos = /* @__PURE__ */ new Map();
   let currFuncInfo;
   const remedaContext = getRemedaContext(context);
-  return (0, import_lodash7.assign)(
+  return (0, import_lodash_es7.assign)(
     {
       "CallExpression:exit": getRemedaMethodCallExpVisitor(
         remedaContext,
@@ -3093,6 +3088,7 @@ var { getValueReturnedInFirstStatement: getValueReturnedInFirstStatement2 } = as
 var meta3 = {
   type: "problem",
   docs: {
+    description: "Prefer R.constant over functions returning literals",
     url: getDocsUrl("prefer-constant")
   },
   schema: [
@@ -3165,6 +3161,7 @@ var meta4 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer R.doNothing() or R.constant(undefined) over an empty function",
     url: getDocsUrl("prefer-do-nothing")
   }
 };
@@ -3203,6 +3200,7 @@ var {
 var meta5 = {
   type: "problem",
   docs: {
+    description: "Prefer R.filter or R.some over an if statement inside a R.forEach",
     url: getDocsUrl("prefer-filter")
   },
   schema: [
@@ -3245,6 +3243,7 @@ var meta6 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer using `R.find` over selecting the first item of a filtered result",
     url: getDocsUrl("prefer-find")
   }
 };
@@ -3288,6 +3287,7 @@ var meta7 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer R.flatMap over consecutive R.map and R.flat.",
     url: getDocsUrl("prefer-flat-map")
   }
 };
@@ -3319,6 +3319,7 @@ var meta8 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer R.isEmpty over manually checking for length value.",
     url: getDocsUrl("prefer-is-empty")
   },
   fixable: "code"
@@ -3419,28 +3420,29 @@ var rule8 = {
 var RULE_NAME8 = "prefer-is-empty";
 var prefer_is_empty_default = rule8;
 
-// src/rules/prefer-is-nil.ts
-var import_lodash8 = __toESM(require("lodash"), 1);
+// src/rules/prefer-is-nullish.ts
+var import_lodash_es8 = require("lodash-es");
 var { isNegationExpression: isNegationExpression2, isEquivalentMemberExp: isEquivalentMemberExp2 } = astUtil_default;
 var meta9 = {
   type: "problem",
   schema: [],
   docs: {
-    url: getDocsUrl("prefer-is-nil")
+    description: "Prefer R.isNullish over checks for both null and undefined.",
+    url: getDocsUrl("prefer-is-nullish")
   }
 };
 function create10(context) {
   const remedaContext = getRemedaContext(context);
   const nilChecks = {
     null: {
-      isValue: (0, import_lodash8.matches)({ type: "Literal", value: null }),
+      isValue: (0, import_lodash_es8.matches)({ type: "Literal", value: null }),
       expressionChecks: [
         getRemedaTypeCheckedBy("isNull"),
         getValueComparedTo("null")
       ]
     },
     undefined: {
-      isValue: (0, import_lodash8.matches)({ type: "Identifier", name: "undefined" }),
+      isValue: (0, import_lodash_es8.matches)({ type: "Identifier", name: "undefined" }),
       expressionChecks: [
         getRemedaTypeCheckedBy("isUndefined"),
         getValueComparedTo("undefined"),
@@ -3458,13 +3460,13 @@ function create10(context) {
       return node.type === "BinaryExpression" && node.operator === operator && (nilChecks[nil].isValue(node.right) && node.left || nilChecks[nil].isValue(node.left) && node.right);
     };
   }
-  const getTypeofArgument = (0, import_lodash8.cond)([
+  const getTypeofArgument = (0, import_lodash_es8.cond)([
     [
-      (0, import_lodash8.matches)({ type: "UnaryExpression", operator: "typeof" }),
-      (0, import_lodash8.property)("argument")
+      (0, import_lodash_es8.matches)({ type: "UnaryExpression", operator: "typeof" }),
+      (0, import_lodash_es8.property)("argument")
     ]
   ]);
-  const isUndefinedString = (0, import_lodash8.matches)({
+  const isUndefinedString = (0, import_lodash_es8.matches)({
     type: "Literal",
     value: "undefined"
   });
@@ -3472,7 +3474,11 @@ function create10(context) {
     return node.type === "BinaryExpression" && node.operator === operator && (isUndefinedString(node.right) && getTypeofArgument(node.left) || isUndefinedString(node.left) && getTypeofArgument(node.right));
   }
   function checkExpression(nil, operator, node) {
-    return (0, import_lodash8.default)(nilChecks[nil].expressionChecks).map((check) => check(node, operator)).find();
+    const mappedValues = (0, import_lodash_es8.map)(
+      nilChecks[nil].expressionChecks,
+      (check) => check(node, operator)
+    );
+    return (0, import_lodash_es8.find)(mappedValues);
   }
   function checkNegatedExpression(nil, node) {
     return isNegationExpression2(node) && checkExpression(nil, "===", node.argument) || checkExpression(nil, "!==", node);
@@ -3497,13 +3503,13 @@ function create10(context) {
       if (isEquivalentExistingExpression(node, "undefined", "null") || isEquivalentExistingExpression(node, "null", "undefined")) {
         context.report({
           node,
-          message: "Prefer isNil over checking for undefined or null."
+          message: "Prefer isNullish over checking for undefined or null."
         });
       }
     } else if (isEquivalentExistingNegation(node, "undefined", "null") || isEquivalentExistingNegation(node, "null", "undefined")) {
       context.report({
         node,
-        message: "Prefer isNil over checking for undefined or null."
+        message: "Prefer isNullish over checking for undefined or null."
       });
     }
   };
@@ -3513,11 +3519,11 @@ var rule9 = {
   create: create10,
   meta: meta9
 };
-var RULE_NAME9 = "prefer-is-nil";
-var prefer_is_nil_default = rule9;
+var RULE_NAME9 = "prefer-is-nullish";
+var prefer_is_nullish_default = rule9;
 
 // src/rules/prefer-map.ts
-var import_lodash9 = require("lodash");
+var import_lodash_es9 = require("lodash-es");
 var {
   getFirstFunctionLine: getFirstFunctionLine4,
   hasOnlyOneStatement: hasOnlyOneStatement3,
@@ -3529,20 +3535,21 @@ var meta10 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer R.map over a R.forEach with a push to an array inside",
     url: getDocsUrl("prefer-map")
   }
 };
 function create11(context) {
   function onlyHasPush(func) {
     const firstLine = getFirstFunctionLine4(func);
-    const firstParam = (0, import_lodash9.get)(func, "params[0]");
+    const firstParam = (0, import_lodash_es9.get)(func, "params[0]");
     const exp = func && !isFunctionDefinitionWithBlock2(func) ? firstLine : (
       //@ts-expect-error
       firstLine?.expression
     );
-    return func && hasOnlyOneStatement3(func) && getMethodName3(exp) === "push" && !(0, import_lodash9.includes)(
+    return func && hasOnlyOneStatement3(func) && getMethodName3(exp) === "push" && !(0, import_lodash_es9.includes)(
       collectParameterValues2(firstParam),
-      (0, import_lodash9.get)(exp, "callee.object.name")
+      (0, import_lodash_es9.get)(exp, "callee.object.name")
     );
   }
   return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
@@ -3566,6 +3573,7 @@ var meta11 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer nullish coalescing over checking a ternary with !isNullish.",
     url: getDocsUrl("prefer-nullish-coalescing")
   },
   fixable: "code"
@@ -3584,7 +3592,7 @@ function create12(context) {
   visitors.ConditionalExpression = function(node) {
     const statement = node.test;
     if (statement.operator === "!") {
-      if (statement.argument && statement.argument.callee && statement.argument.callee.name && statement.argument.callee.name === "isNullish") {
+      if (statement.argument?.callee?.name && statement.argument.callee.name === "isNullish") {
         const argument = getTextOfNode(statement.argument.arguments[0]);
         const consequent = getTextOfNode(node.consequent);
         const alternate = getTextOfNode(node.alternate);
@@ -3610,11 +3618,12 @@ var RULE_NAME11 = "prefer-nullish-coalescing";
 var prefer_nullish_coalescing_default = rule11;
 
 // src/rules/prefer-remeda-typecheck.ts
-var import_lodash10 = require("lodash");
+var import_lodash_es10 = require("lodash-es");
 var meta12 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer using `R.is*` methods over `typeof` and `instanceof` checks when applicable.",
     url: getDocsUrl("prefer-remeda-typecheck")
   }
 };
@@ -3633,7 +3642,7 @@ function create13(context) {
     const sourceCode = context.sourceCode ?? context.getSourceCode();
     const scope = sourceCode?.getScope?.(node);
     const definedVariables = scope.variables;
-    return (0, import_lodash10.some)(definedVariables, { name: node.name });
+    return (0, import_lodash_es10.some)(definedVariables, { name: node.name });
   }
   function getValueForSide(node, side) {
     const otherSide = otherSides[side];
@@ -3687,6 +3696,7 @@ var { getExpressionComparedToInt: getExpressionComparedToInt2 } = astUtil_defaul
 var meta13 = {
   type: "problem",
   docs: {
+    description: "Prefer R.some over findIndex comparison to -1",
     url: getDocsUrl("prefer-some")
   },
   schema: []
@@ -3713,17 +3723,18 @@ var RULE_NAME13 = "prefer-some";
 var prefer_some_default = rule13;
 
 // src/rules/prefer-times.ts
-var import_lodash11 = require("lodash");
+var import_lodash_es11 = require("lodash-es");
 var meta14 = {
   type: "problem",
   schema: [],
   docs: {
+    description: "Prefer R.times over R.map without using arguments",
     url: getDocsUrl("prefer-times")
   }
 };
 function create15(context) {
   return getRemedaMethodVisitors(context, (node, iteratee2, { method: method2 }) => {
-    if (method2 === "map" && (0, import_lodash11.get)(iteratee2, "params.length") === 0) {
+    if (method2 === "map" && (0, import_lodash_es11.get)(iteratee2, "params.length") === 0) {
       context.report({
         node,
         message: "Prefer R.times over R.map without using arguments"
@@ -3748,7 +3759,7 @@ var rules = {
   [RULE_NAME6]: prefer_find_default,
   [RULE_NAME7]: prefer_flat_map_default,
   [RULE_NAME8]: prefer_is_empty_default,
-  [RULE_NAME9]: prefer_is_nil_default,
+  [RULE_NAME9]: prefer_is_nullish_default,
   [RULE_NAME10]: prefer_map_default,
   [RULE_NAME11]: prefer_nullish_coalescing_default,
   [RULE_NAME12]: prefer_remeda_typecheck_default,
@@ -3764,7 +3775,7 @@ var plugin = {
   configs: {},
   processors: {}
 };
-var pluginShortName = (0, import_lodash12.last)(plugin.meta.name.split("-"));
+var pluginShortName = (0, import_lodash_es12.last)(plugin.meta.name.split("-"));
 Object.assign(plugin.configs, {
   recommended: {
     plugins: {
@@ -3772,7 +3783,7 @@ Object.assign(plugin.configs, {
     },
     rules: {
       [`${pluginShortName}/prefer-is-empty`]: 2,
-      [`${pluginShortName}/prefer-is-nil`]: 2,
+      [`${pluginShortName}/prefer-is-nullish`]: 2,
       [`${pluginShortName}/prefer-times`]: 2,
       [`${pluginShortName}/prefer-constant`]: 2,
       [`${pluginShortName}/prefer-remeda-typecheck`]: 2,