eslint-plugin-remeda 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -47,12 +47,14 @@ var package_default = {
   scripts: {
     build: "tsup",
     typecheck: "tsc",
+    lint: "eslint",
     knip: "knip",
     publint: "publint",
     "test:watch": "vitest --ui",
     test: "vitest run",
     attw: "attw --pack .",
     qa: "pnpm typecheck && pnpm test && pnpm knip && pnpm publint && attw",
+    nuke: "rm -rf node_modules pnpm-lock.yaml",
     "semantic-release": "pnpm build && semantic-release"
   },
   files: [
@@ -82,8 +84,10 @@ var package_default = {
     "@types/node": "^20.14.9",
     "@vitest/coverage-v8": "^2.0.3",
     "@vitest/ui": "^2.0.3",
-    eslint: "^9.7.0",
-    "eslint-plugin-eslint-plugin": "^4.2.0",
+    eslint: "9.10.0",
+    "eslint-config-sheriff": "^21.2.0",
+    "eslint-define-config": "^2.1.0",
+    "eslint-plugin-eslint-plugin": "^6.2.0",
     "eslint-vitest-rule-tester": "^0.3.3",
     knip: "^5.29.1",
     prettier: "^3.3.2",
@@ -96,7 +100,7 @@ var package_default = {
   engines: {
     node: ">=20"
   },
-  packageManager: "pnpm@9.7.1",
+  packageManager: "pnpm@9.9.0",
   publishConfig: {
     access: "public"
   },
@@ -115,17 +119,219 @@ var package_default = {
   }
 };
 
+// src/rules/collection-method-value.ts
+var import_includes = __toESM(require("lodash/includes"), 1);
+
+// 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)({
+  type: "CallExpression",
+  callee: { type: "MemberExpression" }
+});
+var isFunctionExpression = (0, import_lodash.overSome)(
+  (0, import_lodash.matchesProperty)("type", "FunctionExpression"),
+  (0, import_lodash.matchesProperty)("type", "FunctionDeclaration")
+);
+var isFunctionDefinitionWithBlock = (0, import_lodash.overSome)(
+  isFunctionExpression,
+  (0, import_lodash.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 isPropAccess = (0, import_lodash.overSome)(
+  (0, import_lodash.matches)({ computed: false }),
+  (0, import_lodash.matchesProperty)(["property", "type"], "Literal")
+);
+function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowComputed } = {}) {
+  if (objectName) {
+    let curr = node;
+    let depth = maxLength;
+    while (curr && depth) {
+      if (allowComputed || isPropAccess(curr)) {
+        if (curr.type === "MemberExpression" && curr.object.name === objectName) {
+          return true;
+        }
+        curr = curr.object;
+        depth--;
+      } else {
+        return false;
+      }
+    }
+  }
+}
+var getFirstParamName = (0, import_lodash.property)(["params", 0, "name"]);
+var isReturnStatement = (0, import_lodash.matchesProperty)("type", "ReturnStatement");
+function hasOnlyOneStatement(func) {
+  if (isFunctionDefinitionWithBlock(func)) {
+    return (0, import_lodash.get)(func, "body.body.length") === 1;
+  }
+  if (func.type === "ArrowFunctionExpression") {
+    return !(0, import_lodash.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";
+}
+function isLiteral(node) {
+  return node.type === "Literal";
+}
+function isBinaryExpWithMemberOf(operator, exp, objectName, {
+  maxLength,
+  allowComputed,
+  onlyLiterals
+} = {}) {
+  if (!(0, import_lodash.isMatch)(exp, { type: "BinaryExpression", operator })) {
+    return false;
+  }
+  const [left, right] = [exp.left, exp.right].map(
+    (side) => isMemberExpOf(side, objectName, { maxLength, allowComputed })
+  );
+  return left === !right && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right));
+}
+var isNegationExpression = (0, import_lodash.matches)({
+  type: "UnaryExpression",
+  operator: "!"
+});
+function isNegationOfMemberOf(exp, objectName, { maxLength } = {}) {
+  return isNegationExpression(exp) && isMemberExpOf(exp.argument, objectName, { maxLength, allowComputed: false });
+}
+function isIdentifierWithName(exp, paramName) {
+  return exp && paramName && exp.type === "Identifier" && exp.name === paramName;
+}
+function getValueReturnedInFirstStatement(func) {
+  const firstLine = getFirstFunctionLine(func);
+  if (func) {
+    if (isFunctionDefinitionWithBlock(func)) {
+      return isReturnStatement(firstLine) ? firstLine.argument : void 0;
+    }
+    if (func.type === "ArrowFunctionExpression") {
+      return firstLine;
+    }
+  }
+}
+function isCallFromObject(node, objName) {
+  return node && objName && node.type === "CallExpression" && (0, import_lodash.get)(node, "callee.object.name") === objName;
+}
+function isComputed(node) {
+  return (0, import_lodash.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 true;
+    }
+    if (isComputed(left) || isComputed(right)) {
+      return false;
+    }
+    if (key === "property") {
+      const leftValue = left.name || left.value;
+      const rightValue = right.name || right.value;
+      return leftValue === rightValue;
+    }
+  });
+}
+var isEqEqEq = (0, import_lodash.matches)({ type: "BinaryExpression", operator: "===" });
+var isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
+var comparisonType = {
+  exact: 0,
+  over: 1,
+  under: 2,
+  any: 3
+};
+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 });
+}
+function getExpressionComparedToInt(node, value2, checkOver) {
+  const isValue = getIsValue(value2);
+  if ((0, import_lodash.includes)(comparisonOperators, node.operator)) {
+    if (isValue(node.right)) {
+      return node.left;
+    }
+    if (isValue(node.left)) {
+      return node.right;
+    }
+  }
+  if (checkOver) {
+    if (node.operator === ">" && isValue(node.right)) {
+      return node.left;
+    }
+    if (node.operator === "<" && isValue(node.left)) {
+      return node.right;
+    }
+    const isNext = getIsValue(value2 + 1);
+    if ((node.operator === ">=" || node.operator === "<") && isNext(node.right)) {
+      return node.left;
+    }
+    if ((node.operator === "<=" || node.operator === ">") && isNext(node.left)) {
+      return node.right;
+    }
+  }
+}
+var isIndexOfCall = (node) => isMethodCall(node) && getMethodName(node) === "indexOf";
+var isFindIndexCall = (node) => isMethodCall(node) && getMethodName(node) === "findIndex";
+function collectParameterValues(node) {
+  switch (node && node.type) {
+    case "Identifier": {
+      return [node.name];
+    }
+    case "ObjectPattern": {
+      return (0, import_lodash.flatMap)(
+        node.properties,
+        (prop) => collectParameterValues(prop.value)
+      );
+    }
+    case "ArrayPattern": {
+      return (0, import_lodash.flatMap)(node.elements, collectParameterValues);
+    }
+    default: {
+      return [];
+    }
+  }
+}
+var astUtil_default = {
+  getCaller,
+  getMethodName,
+  isMethodCall,
+  getFirstFunctionLine,
+  isMemberExpOf,
+  getFirstParamName,
+  hasOnlyOneStatement,
+  isObjectOfMethodCall,
+  isEqEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "==="),
+  isNotEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "!=="),
+  isNegationOfMemberOf,
+  isIdentifierWithName,
+  isNegationExpression,
+  getValueReturnedInFirstStatement,
+  isCallFromObject,
+  isComputed,
+  isEquivalentMemberExp,
+  isEqEqEq,
+  comparisonType,
+  getExpressionComparedToInt,
+  isIndexOfCall,
+  isFindIndexCall,
+  isFunctionExpression,
+  isFunctionDefinitionWithBlock,
+  collectParameterValues
+};
+
 // src/util/getDocsUrl.ts
 var REPO_URL = "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda";
 function getDocsUrl(ruleName) {
   return `${REPO_URL}/blob/v${version}/docs/rules/${ruleName}.md`;
 }
 
-// src/util/remedaUtil.ts
-var import_lodash4 = require("lodash");
-
 // src/util/methodDataUtil.ts
-var import_lodash = require("lodash");
+var import_lodash2 = require("lodash");
 
 // src/util/methodData.ts
 var methodData_exports = {};
@@ -156,7 +362,7 @@ __export(methodData_exports, {
   cloneWith: () => cloneWith,
   commit: () => commit,
   concat: () => concat,
-  cond: () => cond,
+  cond: () => cond2,
   conforms: () => conforms,
   conformsTo: () => conformsTo,
   constant: () => constant,
@@ -193,7 +399,7 @@ __export(methodData_exports, {
   findLastIndex: () => findLastIndex,
   findLastKey: () => findLastKey,
   first: () => first,
-  flatMap: () => flatMap,
+  flatMap: () => flatMap2,
   flatMapDeep: () => flatMapDeep,
   flatMapDepth: () => flatMapDepth,
   flatten: () => flatten,
@@ -212,7 +418,7 @@ __export(methodData_exports, {
   fromPairs: () => fromPairs,
   functions: () => functions,
   functionsIn: () => functionsIn,
-  get: () => get,
+  get: () => get2,
   groupBy: () => groupBy,
   gt: () => gt,
   gte: () => gte,
@@ -221,7 +427,7 @@ __export(methodData_exports, {
   head: () => head,
   identity: () => identity,
   inRange: () => inRange,
-  includes: () => includes,
+  includes: () => includes2,
   indexBy: () => indexBy,
   indexOf: () => indexOf,
   initial: () => initial,
@@ -243,14 +449,14 @@ __export(methodData_exports, {
   isElement: () => isElement,
   isEmpty: () => isEmpty,
   isEqual: () => isEqual,
-  isEqualWith: () => isEqualWith,
+  isEqualWith: () => isEqualWith2,
   isError: () => isError,
   isFinite: () => isFinite,
   isFunction: () => isFunction,
   isInteger: () => isInteger,
   isLength: () => isLength,
   isMap: () => isMap,
-  isMatch: () => isMatch,
+  isMatch: () => isMatch2,
   isMatchWith: () => isMatchWith,
   isNaN: () => isNaN,
   isNative: () => isNative,
@@ -284,8 +490,8 @@ __export(methodData_exports, {
   map: () => map,
   mapKeys: () => mapKeys,
   mapValues: () => mapValues,
-  matches: () => matches,
-  matchesProperty: () => matchesProperty,
+  matches: () => matches2,
+  matchesProperty: () => matchesProperty2,
   max: () => max,
   maxBy: () => maxBy,
   mean: () => mean,
@@ -312,8 +518,8 @@ __export(methodData_exports, {
   orderBy: () => orderBy,
   over: () => over,
   overArgs: () => overArgs,
-  overEvery: () => overEvery,
-  overSome: () => overSome,
+  overEvery: () => overEvery2,
+  overSome: () => overSome2,
   pad: () => pad,
   padEnd: () => padEnd,
   padStart: () => padStart,
@@ -325,7 +531,7 @@ __export(methodData_exports, {
   pickBy: () => pickBy,
   plant: () => plant,
   pop: () => pop,
-  property: () => property,
+  property: () => property2,
   propertyOf: () => propertyOf,
   pull: () => pull,
   pullAll: () => pullAll,
@@ -611,7 +817,7 @@ var concat = {
   chainable: true,
   iteratee: false
 };
-var cond = {
+var cond2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -856,7 +1062,7 @@ var findLastKey = {
   iteratee: true,
   args: 2
 };
-var flatMap = {
+var flatMap2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
@@ -987,7 +1193,7 @@ var functionsIn = {
   iteratee: false,
   args: 1
 };
-var get = {
+var get2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1057,7 +1263,7 @@ var inRange = {
   iteratee: false,
   args: 3
 };
-var includes = {
+var includes2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1205,7 +1411,7 @@ var isEqual = {
   iteratee: false,
   args: 2
 };
-var isEqualWith = {
+var isEqualWith2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1254,7 +1460,7 @@ var isMap = {
   iteratee: false,
   args: 1
 };
-var isMatch = {
+var isMatch2 = {
   wrapper: false,
   shorthand: false,
   chainable: false,
@@ -1491,14 +1697,14 @@ var mapValues = {
   iteratee: true,
   args: 2
 };
-var matches = {
+var matches2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
   iteratee: false,
   args: 1
 };
-var matchesProperty = {
+var matchesProperty2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
@@ -1679,13 +1885,13 @@ var overArgs = {
   chainable: true,
   iteratee: false
 };
-var overEvery = {
+var overEvery2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
   iteratee: true
 };
-var overSome = {
+var overSome2 = {
   wrapper: false,
   shorthand: true,
   chainable: true,
@@ -1762,7 +1968,7 @@ var pop = {
   chainable: false,
   iteratee: false
 };
-var property = {
+var property2 = {
   wrapper: false,
   shorthand: false,
   chainable: true,
@@ -2549,18 +2755,18 @@ var zipWith = {
 
 // src/util/methodDataUtil.ts
 function isCollectionMethod(method2) {
-  return methodSupportsShorthand(method2) || (0, import_lodash.includes)(["reduce", "reduceRight"], method2);
+  return methodSupportsShorthand(method2) || (0, import_lodash2.includes)(["reduce", "reduceRight"], method2);
 }
 function methodSupportsShorthand(method2, shorthandType) {
-  const methodShorthandData = (0, import_lodash.get)(methodData_exports, [method2, "shorthand"]);
-  return (0, import_lodash.isObject)(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
+  const methodShorthandData = (0, import_lodash2.get)(methodData_exports, `${method2}.shorthand`);
+  return (0, import_lodash2.isObject)(methodShorthandData) ? Boolean(shorthandType && methodShorthandData[shorthandType]) : Boolean(methodShorthandData);
 }
 function getIterateeIndex(method2) {
   const methodData = methodData_exports[method2];
-  if ((0, import_lodash.has)(methodData, "iterateeIndex")) {
+  if ((0, import_lodash2.has)(methodData, "iterateeIndex")) {
     return methodData.iterateeIndex;
   }
-  if (methodData?.iteratee) {
+  if (methodData.iteratee) {
     return 1;
   }
   return -1;
@@ -2577,203 +2783,8 @@ function getSideEffectIterationMethods() {
   return sideEffectIterationMethods;
 }
 
-// src/util/astUtil.ts
-var import_lodash2 = require("lodash");
-var getCaller = (0, import_lodash2.property)(["callee", "object"]);
-var getMethodName = (0, import_lodash2.property)(["callee", "property", "name"]);
-var isMethodCall = (0, import_lodash2.matches)({
-  type: "CallExpression",
-  callee: { type: "MemberExpression" }
-});
-var isFunctionExpression = (0, import_lodash2.overSome)(
-  (0, import_lodash2.matchesProperty)("type", "FunctionExpression"),
-  (0, import_lodash2.matchesProperty)("type", "FunctionDeclaration")
-);
-var isFunctionDefinitionWithBlock = (0, import_lodash2.overSome)(
-  isFunctionExpression,
-  (0, import_lodash2.matches)({
-    type: "ArrowFunctionExpression",
-    body: { type: "BlockStatement" }
-  })
-);
-var getFirstFunctionLine = (0, import_lodash2.cond)([
-  [isFunctionDefinitionWithBlock, (0, import_lodash2.property)(["body", "body", 0])],
-  [(0, import_lodash2.matches)({ type: "ArrowFunctionExpression" }), (0, import_lodash2.property)("body")]
-]);
-var isPropAccess = (0, import_lodash2.overSome)(
-  (0, import_lodash2.matches)({ computed: false }),
-  (0, import_lodash2.matchesProperty)(["property", "type"], "Literal")
-);
-function isMemberExpOf(node, objectName, { maxLength = Number.MAX_VALUE, allowComputed } = {}) {
-  if (objectName) {
-    let curr = node;
-    let depth = maxLength;
-    while (curr && depth) {
-      if (allowComputed || isPropAccess(curr)) {
-        if (curr.type === "MemberExpression" && curr.object.name === objectName) {
-          return true;
-        }
-        curr = curr.object;
-        depth--;
-      } else {
-        return false;
-      }
-    }
-  }
-}
-var getFirstParamName = (0, import_lodash2.property)(["params", 0, "name"]);
-var isReturnStatement = (0, import_lodash2.matchesProperty)("type", "ReturnStatement");
-function hasOnlyOneStatement(func) {
-  if (isFunctionDefinitionWithBlock(func)) {
-    return (0, import_lodash2.get)(func, "body.body.length") === 1;
-  }
-  if (func.type === "ArrowFunctionExpression") {
-    return !(0, import_lodash2.get)(func, "body.body");
-  }
-}
-function isObjectOfMethodCall(node) {
-  return (0, import_lodash2.get)(node, "parent.object") === node && (0, import_lodash2.get)(node, "parent.parent.type") === "CallExpression";
-}
-function isLiteral(node) {
-  return node.type === "Literal";
-}
-function isBinaryExpWithMemberOf(operator, exp, objectName, {
-  maxLength,
-  allowComputed,
-  onlyLiterals
-} = {}) {
-  if (!(0, import_lodash2.isMatch)(exp, { type: "BinaryExpression", operator })) {
-    return false;
-  }
-  const [left, right] = [exp.left, exp.right].map(
-    (side) => isMemberExpOf(side, objectName, { maxLength, allowComputed })
-  );
-  return left === !right && (!onlyLiterals || isLiteral(exp.left) || isLiteral(exp.right));
-}
-var isNegationExpression = (0, import_lodash2.matches)({
-  type: "UnaryExpression",
-  operator: "!"
-});
-function isNegationOfMemberOf(exp, objectName, { maxLength } = {}) {
-  return isNegationExpression(exp) && isMemberExpOf(exp.argument, objectName, { maxLength, allowComputed: false });
-}
-function isIdentifierWithName(exp, paramName) {
-  return exp && paramName && exp.type === "Identifier" && exp.name === paramName;
-}
-function getValueReturnedInFirstStatement(func) {
-  const firstLine = getFirstFunctionLine(func);
-  if (func) {
-    if (isFunctionDefinitionWithBlock(func)) {
-      return isReturnStatement(firstLine) ? firstLine.argument : void 0;
-    }
-    if (func.type === "ArrowFunctionExpression") {
-      return firstLine;
-    }
-  }
-}
-function isCallFromObject(node, objName) {
-  return node && objName && node.type === "CallExpression" && (0, import_lodash2.get)(node, "callee.object.name") === objName;
-}
-function isComputed(node) {
-  return (0, import_lodash2.get)(node, "computed") && node.property.type !== "Literal";
-}
-function isEquivalentMemberExp(a, b) {
-  return (0, import_lodash2.isEqualWith)(a, b, (left, right, key) => {
-    if ((0, import_lodash2.includes)(["loc", "range", "computed", "start", "end", "parent"], key)) {
-      return true;
-    }
-    if (isComputed(left) || isComputed(right)) {
-      return false;
-    }
-    if (key === "property") {
-      const leftValue = left.name || left.value;
-      const rightValue = right.name || right.value;
-      return leftValue === rightValue;
-    }
-  });
-}
-var isEqEqEq = (0, import_lodash2.matches)({ type: "BinaryExpression", operator: "===" });
-var isMinus = (node) => node.type === "UnaryExpression" && node.operator === "-";
-var comparisonType = {
-  exact: 0,
-  over: 1,
-  under: 2,
-  any: 3
-};
-var comparisonOperators = ["==", "!=", "===", "!=="];
-function getIsValue(value2) {
-  return value2 < 0 ? (0, import_lodash2.overEvery)(isMinus, (0, import_lodash2.matches)({ argument: { value: -value2 } })) : (0, import_lodash2.matches)({ value: value2 });
-}
-function getExpressionComparedToInt(node, value2, checkOver) {
-  const isValue = getIsValue(value2);
-  if ((0, import_lodash2.includes)(comparisonOperators, node.operator)) {
-    if (isValue(node.right)) {
-      return node.left;
-    }
-    if (isValue(node.left)) {
-      return node.right;
-    }
-  }
-  if (checkOver) {
-    if (node.operator === ">" && isValue(node.right)) {
-      return node.left;
-    }
-    if (node.operator === "<" && isValue(node.left)) {
-      return node.right;
-    }
-    const isNext = getIsValue(value2 + 1);
-    if ((node.operator === ">=" || node.operator === "<") && isNext(node.right)) {
-      return node.left;
-    }
-    if ((node.operator === "<=" || node.operator === ">") && isNext(node.left)) {
-      return node.right;
-    }
-  }
-}
-var isIndexOfCall = (node) => isMethodCall(node) && getMethodName(node) === "indexOf";
-var isFindIndexCall = (node) => isMethodCall(node) && getMethodName(node) === "findIndex";
-function collectParameterValues(node) {
-  switch (node && node.type) {
-    case "Identifier":
-      return [node.name];
-    case "ObjectPattern":
-      return (0, import_lodash2.flatMap)(
-        node.properties,
-        (prop) => collectParameterValues(prop.value)
-      );
-    case "ArrayPattern":
-      return (0, import_lodash2.flatMap)(node.elements, collectParameterValues);
-    default:
-      return [];
-  }
-}
-var astUtil_default = {
-  getCaller,
-  getMethodName,
-  isMethodCall,
-  getFirstFunctionLine,
-  isMemberExpOf,
-  getFirstParamName,
-  hasOnlyOneStatement,
-  isObjectOfMethodCall,
-  isEqEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "==="),
-  isNotEqEqToMemberOf: isBinaryExpWithMemberOf.bind(null, "!=="),
-  isNegationOfMemberOf,
-  isIdentifierWithName,
-  isNegationExpression,
-  getValueReturnedInFirstStatement,
-  isCallFromObject,
-  isComputed,
-  isEquivalentMemberExp,
-  isEqEqEq,
-  comparisonType,
-  getExpressionComparedToInt,
-  isIndexOfCall,
-  isFindIndexCall,
-  isFunctionExpression,
-  isFunctionDefinitionWithBlock,
-  collectParameterValues
-};
+// src/util/remedaUtil.ts
+var import_lodash4 = require("lodash");
 
 // src/util/settingsUtil.ts
 var import_lodash3 = require("lodash");
@@ -2805,7 +2816,8 @@ var RemedaContext_default = class {
   _pragma;
   /**
    * Create a Remeda context wrapper from a file's RuleContext
-   * @param {RuleContext} context
+   *
+   * @param context
    */
   constructor(context) {
     this.context = context;
@@ -2814,7 +2826,8 @@ var RemedaContext_default = class {
   }
   /**
    * Gets visitors to collect Remeda declarations in the context
-   * @returns {Object} visitors for everywhere Remeda can be declared
+   *
+   * @returns visitors for everywhere Remeda can be declared
    */
   getImportVisitors() {
     const self = this;
@@ -2824,15 +2837,17 @@ var RemedaContext_default = class {
           specifiers.forEach((spec) => {
             switch (spec.type) {
               case "ImportNamespaceSpecifier":
-              case "ImportDefaultSpecifier":
+              case "ImportDefaultSpecifier": {
                 self.general[spec.local.name] = true;
                 break;
-              case "ImportSpecifier":
+              }
+              case "ImportSpecifier": {
                 self.methods[spec.local.name] = spec.imported.name;
                 if (spec.imported.name === "chain") {
                   self.general[spec.local.name] = true;
                 }
                 break;
+              }
             }
           });
         } else {
@@ -2866,8 +2881,9 @@ var RemedaContext_default = class {
   }
   /**
    * Returns whether the node is an imported Remeda in this context
+   *
    * @param node
-   * @returns {boolean|undefined}
+   * @returns
    */
   isImportedRemeda(node) {
     if (node && node.type === "Identifier") {
@@ -2876,8 +2892,9 @@ var RemedaContext_default = class {
   }
   /**
    * Returns the name of the Remeda method for this node, if any
+   *
    * @param node
-   * @returns {string|undefined}
+   * @returns
    */
   getImportedRemedaMethod(node) {
     if (node && node.type === "CallExpression" && !isMethodCall2(node)) {
@@ -2886,15 +2903,16 @@ var RemedaContext_default = class {
   }
   /**
    * Returns whether the node is a call from a Remeda object
+   *
    * @param node
-   * @returns {boolean|undefined}
+   * @returns
    */
   isRemedaCall(node) {
     return this.pragma && isCallFromObject2(node, this.pragma) || this.isImportedRemeda(getCaller2(node));
   }
   /**
    *
-   * @returns {string|undefined} the current Remeda pragma
+   * @returns the current Remeda pragma
    */
   get pragma() {
     if (!this._pragma) {
@@ -2972,7 +2990,6 @@ function getRemedaContext(context) {
 }
 
 // src/rules/collection-method-value.ts
-var import_includes = __toESM(require("lodash/includes"), 1);
 var { getMethodName: getMethodName2 } = astUtil_default;
 var meta = {
   type: "problem",
@@ -3090,16 +3107,21 @@ function create4(context) {
   const shouldCheckFunctionDeclarations = context.options[1] !== void 0 ? context.options[1] : false;
   function isCompletelyLiteral(node) {
     switch (node.type) {
-      case "Literal":
+      case "Literal": {
         return true;
-      case "BinaryExpression":
+      }
+      case "BinaryExpression": {
         return isCompletelyLiteral(node.left) && isCompletelyLiteral(node.right);
-      case "UnaryExpression":
+      }
+      case "UnaryExpression": {
         return isCompletelyLiteral(node.argument);
-      case "ConditionalExpression":
+      }
+      case "ConditionalExpression": {
         return isCompletelyLiteral(node.test) && isCompletelyLiteral(node.consequent) && isCompletelyLiteral(node.alternate);
-      default:
+      }
+      default: {
         return false;
+      }
     }
   }
   function reportIfLikeConstant(func, node) {