eslint-plugin-remeda 1.0.0 → 1.2.0

package/docs/rules/prefer-flat-map.md

@@ -1,6 +1,6 @@
-# Prefer [`R.flatMap`] over consecutive [`R.map`] and [`R.flatten`]
+# Prefer [`R.flatMap`] over consecutive [`R.map`] and [`R.flat`]
 
-When using [`R.map`] and [`R.flatten`], it can be more concise to use [`R.flatMap`] instead.
+When using [`R.map`] and [`R.flat`], it can be more concise to use [`R.flatMap`] instead.
 
 ## Rule Details
 
@@ -9,7 +9,7 @@ This rule takes no arguments.
 The following patterns are considered warnings:
 
 ```js
-t = R.flatten(R.map(a, f));
+t = R.flat(R.map(a, f));
 ```
 
 The following patterns are not considered warnings:
@@ -22,4 +22,4 @@ t = R.flatMap(a, f);
 
 ## When Not To Use It
 
-If you do not want to enforce using [`R.flatMap`], and prefer [`R.map`] and [`R.flatten`] instead, you should not use this rule.
+If you do not want to enforce using [`R.flatMap`], and prefer [`R.map`] and [`R.flat`] instead, you should not use this rule.

package/docs/rules/prefer-remeda-typecheck.md

@@ -1,6 +1,6 @@
-# Prefer Lodash typecheck
+# Prefer Remeda typecheck
 
-Getting the specific type of a variable or expression can be done with `typeof` or `instanceof`. However, it's often more expressive to use the Lodash equivalent function
+Getting the specific type of a variable or expression can be done with `typeof` or `instanceof`. However, it's often more expressive to use the Remeda equivalent function
 
 ## Rule Details
 
@@ -9,28 +9,23 @@ This rule takes no arguments.
 The following patterns are considered warnings:
 
 ```js
-
-if (typeof a === 'number') {
+if (typeof a === "number") {
   // ...
 }
 
-var isNotString = typeof b !== 'string';
+var isNotString = typeof b !== "string";
 
 var isArray = a instanceof Array;
-
 ```
 
 The following patterns are not considered warnings:
 
 ```js
-
 var areSameType = typeof a === typeof b;
- 
-var isCar = truck instanceof Car; 
 
+var isCar = truck instanceof Car;
 ```
 
-
 ## When Not To Use It
 
-If you do not want to enforce using Lodash methods for type checks, you should not use this rule.
+If you do not want to enforce using Remeda methods for type checks, you should not use this rule.

package/package.json

@@ -1,59 +1,74 @@
 {
   "name": "eslint-plugin-remeda",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "author": "Andrea Pontrandolfo <andrea.pontra@gmail.com>",
   "description": "ESLint plugin for Remeda library.",
-  "type": "commonjs",
-  "main": "src/index.js",
+  "type": "module",
+  "main": "dist/index.js",
   "scripts": {
-    "coveralls": "nyc report --reporter=text-lcov | coveralls",
+    "build": "tsup",
+    "typecheck": "tsc",
     "knip": "knip",
     "publint": "publint",
-    "test": "npm run unit-test",
-    "unit-test": "cross-env nyc mocha \"tests/**/*.js\" --reporter=dot",
-    "semantic-release": "semantic-release"
+    "test:watch": "vitest --ui",
+    "test": "vitest run",
+    "attw": "attw --pack .",
+    "qa": "pnpm typecheck && pnpm test && pnpm knip && pnpm publint && attw",
+    "semantic-release": "pnpm build && semantic-release"
   },
   "files": [
     "README.md",
-    "src",
+    "dist",
     "docs"
   ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js",
+      "default": "./dist/index.cjs"
+    }
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda"
+    "url": "git+https://github.com/AndreaPontrandolfo/eslint-plugin-remeda.git"
   },
   "homepage": "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda",
   "bugs": "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda/issues",
   "peerDependencies": {
-    "eslint": ">=2"
+    "eslint": ">=9.0.0"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.4",
+    "@types/lodash": "^4.17.7",
     "@types/node": "^20.14.9",
-    "auto-changelog": "^2.4.0",
-    "coveralls": "^3.1.1",
-    "cross-env": "^7.0.3",
-    "eslint": "^8.16.0",
-    "eslint-config-wix-editor": "^8.4.2",
-    "eslint-import-resolver-node": "^0.3.6",
+    "@vitest/coverage-v8": "^2.0.3",
+    "@vitest/ui": "^2.0.3",
+    "eslint": "^9.7.0",
     "eslint-plugin-eslint-plugin": "^4.2.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-traverser": "^1.5.2",
-    "knip": "^5.23.2",
-    "mocha": "^9.2.2",
-    "nyc": "^15.1.0",
+    "eslint-vitest-rule-tester": "^0.3.3",
+    "knip": "^5.29.1",
     "prettier": "^3.3.2",
-    "publint": "^0.2.8",
+    "publint": "^0.2.10",
     "semantic-release": "^24.0.0",
-    "typescript": "^5.5.2"
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.2",
+    "vitest": "^2.0.3"
   },
   "engines": {
     "node": ">=20"
   },
+  "packageManager": "pnpm@9.7.1",
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "eslint",
     "eslint-plugin",
+    "eslint plugin",
     "eslintplugin",
-    "remeda"
+    "remeda",
+    "functional",
+    "fp"
   ],
   "license": "MIT",
   "dependencies": {

package/src/index.js

@@ -1,35 +0,0 @@
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const _ = require("lodash");
-const rules = fs
-  .readdirSync(path.resolve(__dirname, "rules"))
-  .map((f) => f.replace(/\.js$/, ""));
-const recommended = {
-  plugins: ["remeda"],
-  rules: {
-    "remeda/prefer-is-empty": 2,
-    "remeda/prefer-is-nil": 2,
-    "remeda/prefer-times": 2,
-    "remeda/prefer-constant": 2,
-    "remeda/prefer-remeda-typecheck": 2,
-    "remeda/prefer-nullish-coalescing": 2,
-    "remeda/prefer-filter": [2, 3],
-    "remeda/collection-method-value": 2,
-    "remeda/collection-return": 2,
-    "remeda/prefer-map": 2,
-    "remeda/prefer-find": 2,
-    "remeda/prefer-some": 2,
-    "remeda/prefer-flat-map": 2,
-    "remeda/prefer-do-nothing": 2,
-  },
-};
-module.exports = {
-  rules: _.zipObject(
-    rules,
-    rules.map((rule) => require(`./rules/${rule}`)),
-  ),
-  configs: {
-    recommended,
-  },
-};

package/src/rules/collection-method-value.js

@@ -1,82 +0,0 @@
-/**
- * @fileoverview Rule to enforce usage of collection method values
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("collection-method-value"),
-    },
-  },
-
-  create(context) {
-    const {
-      isChainBreaker,
-      getRemedaMethodVisitors,
-      isCallToMethod,
-    } = require("../util/lodashUtil");
-    const { getMethodName } = require("../util/astUtil");
-    const {
-      isCollectionMethod,
-      isAliasOfMethod,
-      getSideEffectIterationMethods,
-    } = require("../util/methodDataUtil");
-    const includes = require("lodash/includes");
-
-    function parentUsesValue(node, callType) {
-      const isBeforeChainBreaker =
-        callType === "chained" && isChainBreaker(node.parent.parent);
-      return (
-        (isBeforeChainBreaker ? node.parent.parent : node).parent.type !==
-        "ExpressionStatement"
-      );
-    }
-
-    function isPureRemedaCollectionMethod(method) {
-      return isCollectionMethod(method) && !isAliasOfMethod("remove", method);
-    }
-
-    function isSideEffectIterationMethod(method) {
-      return includes(getSideEffectIterationMethods(), method);
-    }
-
-    function isParentCommit(node, callType) {
-      return (
-        callType === "chained" && isCallToMethod(node.parent.parent, "commit")
-      );
-    }
-
-    return getRemedaMethodVisitors(
-      context,
-      (node, iteratee, { method, callType }) => {
-        if (
-          isPureRemedaCollectionMethod(method) &&
-          !parentUsesValue(node, callType)
-        ) {
-          context.report({
-            node,
-            message: `Use value returned from R.${method}`,
-          });
-        } else if (
-          isSideEffectIterationMethod(method) &&
-          parentUsesValue(node, callType) &&
-          !isParentCommit(node, callType)
-        ) {
-          context.report({
-            node,
-            message: `Do not use value returned from R.${getMethodName(node)}`,
-          });
-        }
-      },
-    );
-  },
-};

package/src/rules/collection-return.js

@@ -1,71 +0,0 @@
-/**
- * @fileoverview Rule to check that iteratees for all collection functions except forEach return a value;
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("collection-return"),
-    },
-  },
-
-  create(context) {
-    const {
-      getRemedaMethodCallExpVisitor,
-      getLodashContext,
-    } = require("../util/lodashUtil");
-    const { isCollectionMethod } = require("../util/methodDataUtil");
-    const { isFunctionDefinitionWithBlock } = require("../util/astUtil");
-    const assign = require("lodash/assign");
-    const funcInfos = new Map();
-    let currFuncInfo = {};
-    const lodashContext = getLodashContext(context);
-    return assign(
-      {
-        "CallExpression:exit": getRemedaMethodCallExpVisitor(
-          lodashContext,
-          (node, iteratee, { method }) => {
-            if (isCollectionMethod(method) && funcInfos.has(iteratee)) {
-              const { hasReturn } = funcInfos.get(iteratee);
-              if (
-                isFunctionDefinitionWithBlock(iteratee) &&
-                !hasReturn &&
-                !iteratee.async &&
-                !iteratee.generator
-              ) {
-                context.report({
-                  node,
-                  message: `Do not use R.${method} without returning a value`,
-                });
-              }
-            }
-          },
-        ),
-        ReturnStatement() {
-          currFuncInfo.hasReturn = true;
-        },
-        onCodePathStart(codePath, node) {
-          currFuncInfo = {
-            upper: currFuncInfo,
-            codePath,
-            hasReturn: false,
-          };
-          funcInfos.set(node, currFuncInfo);
-        },
-        onCodePathEnd() {
-          currFuncInfo = currFuncInfo.upper;
-        },
-      },
-      lodashContext.getImportVisitors(),
-    );
-  },
-};

package/src/rules/prefer-constant.js

@@ -1,87 +0,0 @@
-/**
- * @fileoverview Rule to check if the expression could be better expressed as a R.constant
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      url: getDocsUrl("prefer-constant"),
-    },
-    schema: [
-      {
-        type: "boolean",
-      },
-      {
-        type: "boolean",
-      },
-    ],
-  },
-
-  create(context) {
-    const { getValueReturnedInFirstStatement } = require("../util/astUtil");
-    const shouldCheckArrowFunctions =
-      context.options[0] !== undefined ? context.options[0] : true;
-    const shouldCheckFunctionDeclarations =
-      context.options[1] !== undefined ? context.options[1] : false;
-
-    function isCompletelyLiteral(node) {
-      switch (node.type) {
-        case "Literal":
-          return true;
-        case "BinaryExpression":
-          return (
-            isCompletelyLiteral(node.left) && isCompletelyLiteral(node.right)
-          );
-        case "UnaryExpression":
-          return isCompletelyLiteral(node.argument);
-        case "ConditionalExpression":
-          return (
-            isCompletelyLiteral(node.test) &&
-            isCompletelyLiteral(node.consequent) &&
-            isCompletelyLiteral(node.alternate)
-          );
-        default:
-          return false;
-      }
-    }
-
-    function reportIfLikeConstant(func, node) {
-      const valueReturnedInFirstLine = func(node);
-      if (
-        valueReturnedInFirstLine &&
-        isCompletelyLiteral(valueReturnedInFirstLine)
-      ) {
-        context.report({
-          node,
-          message: "Prefer R.constant over a function returning a literal",
-        });
-      }
-    }
-
-    function handleFunctionDefinition(node) {
-      reportIfLikeConstant(getValueReturnedInFirstStatement, node);
-    }
-
-    return {
-      FunctionExpression: handleFunctionDefinition,
-      FunctionDeclaration(node) {
-        if (shouldCheckFunctionDeclarations) {
-          handleFunctionDefinition(node);
-        }
-      },
-      ArrowFunctionExpression(node) {
-        if (shouldCheckArrowFunctions) {
-          handleFunctionDefinition(node);
-        }
-      },
-    };
-  },
-};

package/src/rules/prefer-do-nothing.js

@@ -1,44 +0,0 @@
-/**
- * @fileoverview Rule to prefer R.doNothing() or R.constant(undefined) over an empty function
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-do-nothing"),
-    },
-  },
-
-  create(context) {
-    const { getFirstFunctionLine } = require("../util/astUtil");
-
-    function reportIfEmptyFunction(node) {
-      if (
-        !getFirstFunctionLine(node) &&
-        node.parent.type !== "MethodDefinition" &&
-        !node.generator &&
-        !node.async
-      ) {
-        context.report({
-          node,
-          message:
-            "Prefer R.doNothing() or R.constant(undefined) over an empty function",
-        });
-      }
-    }
-
-    return {
-      FunctionExpression: reportIfEmptyFunction,
-      ArrowFunctionExpression: reportIfEmptyFunction,
-    };
-  },
-};

package/src/rules/prefer-filter.js

@@ -1,82 +0,0 @@
-/**
- * @fileoverview Rule to check if a call to R.forEach should be a call to R.filter
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      url: getDocsUrl("prefer-filter"),
-    },
-    schema: [
-      {
-        type: "integer",
-      },
-    ],
-  },
-
-  create(context) {
-    const { getRemedaMethodVisitors } = require("../util/lodashUtil");
-    const {
-      isIdentifierWithName,
-      isMemberExpOf,
-      isNegationOfMemberOf,
-      isEqEqEqToMemberOf,
-      isNotEqEqToMemberOf,
-      getFirstFunctionLine,
-      hasOnlyOneStatement,
-      getFirstParamName,
-    } = require("../util/astUtil");
-    const { isAliasOfMethod } = require("../util/methodDataUtil");
-    const DEFAULT_MAX_PROPERTY_PATH_LENGTH = 3;
-    const maxLength =
-      parseInt(context.options[0], 10) || DEFAULT_MAX_PROPERTY_PATH_LENGTH;
-
-    function isIfWithoutElse(statement) {
-      return (
-        statement && statement.type === "IfStatement" && !statement.alternate
-      );
-    }
-
-    function canBeShorthand(exp, paramName) {
-      return (
-        isIdentifierWithName(exp, paramName) ||
-        isMemberExpOf(exp, paramName, { maxLength }) ||
-        isNegationOfMemberOf(exp, paramName, { maxLength }) ||
-        isEqEqEqToMemberOf(exp, paramName, { maxLength }) ||
-        isNotEqEqToMemberOf(exp, paramName, { maxLength })
-      );
-    }
-
-    function onlyHasSimplifiableIf(func) {
-      const firstLine = getFirstFunctionLine(func);
-      return (
-        func &&
-        hasOnlyOneStatement(func) &&
-        func.params.length === 1 &&
-        isIfWithoutElse(firstLine) &&
-        canBeShorthand(firstLine.test, getFirstParamName(func))
-      );
-    }
-
-    return getRemedaMethodVisitors(context, (node, iteratee, { method }) => {
-      if (
-        isAliasOfMethod("forEach", method) &&
-        onlyHasSimplifiableIf(iteratee)
-      ) {
-        context.report({
-          node,
-          message:
-            "Prefer R.filter or R.some over an if statement inside a R.forEach",
-        });
-      }
-    });
-  },
-};

package/src/rules/prefer-find.js

@@ -1,68 +0,0 @@
-/**
- * @fileoverview Rule to check if a call to `R.filter` should be a call to `R.find`.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-find"),
-    },
-  },
-
-  create(context) {
-    const {
-      getRemedaMethodVisitors,
-      isCallToMethod,
-      isCallToLodashMethod,
-    } = require("../util/lodashUtil");
-    const { isAliasOfMethod } = require("../util/methodDataUtil");
-
-    function isZeroIndexAccess(node) {
-      return node.type === "MemberExpression" && node.property.value === 0;
-    }
-
-    function isChainedBeforeMethod(callType, node, method) {
-      return (
-        callType === "chained" && isCallToMethod(node.parent.parent, method)
-      );
-    }
-
-    return getRemedaMethodVisitors(
-      context,
-      (node, iteratee, { method, callType, lodashContext }) => {
-        if (isAliasOfMethod("filter", method)) {
-          if (
-            isZeroIndexAccess(node.parent) ||
-            isCallToLodashMethod(node.parent, "first", lodashContext) ||
-            isChainedBeforeMethod(callType, node, "first")
-          ) {
-            context.report({
-              node,
-              message:
-                "Prefer using `R.find` over selecting the first item of a filtered result",
-            });
-          }
-          if (
-            isCallToLodashMethod(node.parent, "last", lodashContext) ||
-            isChainedBeforeMethod(callType, node, "last")
-          ) {
-            context.report({
-              node,
-              message:
-                "Prefer using `R.findLast` over selecting the last item of a filtered result",
-            });
-          }
-        }
-      },
-    );
-  },
-};

package/src/rules/prefer-flat-map.js

@@ -1,50 +0,0 @@
-/**
- * @fileoverview Rule to check if a call to map and flatten should be a call to R.flatMap
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const getDocsUrl = require("../util/getDocsUrl");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    schema: [],
-    docs: {
-      url: getDocsUrl("prefer-flat-map"),
-    },
-  },
-
-  create(context) {
-    const {
-      getRemedaMethodVisitors,
-      isCallToMethod,
-      isCallToLodashMethod,
-    } = require("../util/lodashUtil");
-    const { getCaller } = require("../util/astUtil");
-    const { isAliasOfMethod } = require("../util/methodDataUtil");
-
-    function isChainedMapFlatten(callType, node) {
-      return callType === "chained" && isCallToMethod(getCaller(node), "map");
-    }
-
-    return getRemedaMethodVisitors(
-      context,
-      (node, iteratee, { method, callType, lodashContext }) => {
-        if (
-          isAliasOfMethod("flatten", method) &&
-          (isChainedMapFlatten(callType, node) ||
-            isCallToLodashMethod(node.arguments[0], "map", lodashContext))
-        ) {
-          context.report({
-            node,
-            message: "Prefer R.flatMap over consecutive map and flatten.",
-          });
-        }
-      },
-    );
-  },
-};