eslint-plugin-remeda 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Andrea Pontrandolfo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# 🚧 UNDER CONSTRUCTION 🚧
+
+This library is still under construction. Don't use this in production yet. If you want to contribute, look at the open issues.
+
+# ESLint Plugin Remeda
+
+ESLint plugin for [Remeda](https://github.com/remeda/remeda).
+
+## Installation
+
+First, you'll first need to install [ESLint](https://eslint.org/):
+
+```sh
+npm add eslint -D
+```
+
+Next, install `eslint-plugin-remeda`:
+
+```sh
+npm add eslint-plugin-remeda -D
+```
+
+## 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 `map` and `flatten`.
+- [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.
+
+## Contributing
+
+Contributions are always welcome! For more info, read our [contribution guide](.github/CONTRIBUTING.md).

package/docs/rules/collection-method-value.md

@@ -0,0 +1,27 @@
+# Collection Method Value
+
+When using a Remeda collection method, the expression should be used (e.g. assigning to a variable or check in a condition), unless it's a method meant for side effects (e.g. `forEach` or `forOwn`) which should NOT be used.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+x = R.forEach(arr, g);
+
+R.map(arr, f);
+```
+
+The following patterns are not considered warnings:
+
+```js
+x = R.map(arr, f);
+
+R.forEach(arr, g);
+
+if (R.some(arr, h)) {
+  i();
+}
+```

package/docs/rules/collection-return.md

@@ -0,0 +1,29 @@
+# Collection Return Statement
+
+When using a Remeda collection method that isn't forEach, the iteratee should return a value, otherwise it could result in either unclear code or unexpected results.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+
+R.map(arr, function(x) { console.log(x); });
+
+R.some(arr, function(x) { if (x.a) {f(x); });
+
+R.every(collection, x => { f(x); });
+
+```
+
+The following patterns are not considered warnings:
+
+```js
+R.map((x) => x + 1);
+
+R.forEach(arr, function (a) {
+  console.log(a);
+});
+```

package/docs/rules/prefer-constant.md

@@ -0,0 +1,53 @@
+# Prefer constant
+
+When you want a function that always returns the same value, it can be more concise to use `R.constant`.
+
+## Rule Details
+
+This rule takes two arguments:
+
+- whether or not to check arrow functions
+- whether or not to check function declarations (named functions)
+
+The following patterns are considered warnings:
+
+```js
+var three = function () {
+  return 3;
+};
+//Including arrow functions:
+/*eslint remeda/prefer-constant: [2, true]*/
+var pi = () => 3.1415;
+
+//Including function declarations
+/*eslint remeda/prefer-constant: [2, true, true]*/
+function one() {
+  return 1;
+}
+```
+
+The following patterns are not considered warnings:
+
+```js
+var identity = function (x) {
+  return x;
+};
+
+var getObj = function () {
+  return { a: 1 };
+};
+```
+
+The last example is not a warning because it is not equivalent to `R.constant({a:1})`, which always returns the same instance.
+Consider:
+
+```js
+var getObj = R.constant({ a: 1 });
+x = getObj();
+x.a = 2;
+console.log(getObj()); // ==> {a:2}
+```
+
+## When Not To Use It
+
+If you do not want to enforce using `R.constant`, you should not use this rule.

package/docs/rules/prefer-do-nothing.md

@@ -0,0 +1,29 @@
+# Prefer noop
+
+When defining an empty function (e.g. for callbacks) it can be more readable to use `R.doNothing()` or `R.constant(undefined)` instead. Use `R.doNothing()` if you need to return void, otherwise use `R.constant(undefined)`.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+functionWithCallback(function () {});
+
+const emptyFunction = () => {};
+```
+
+The following patterns are not considered warnings:
+
+```js
+functionWithCallback(function (x) {
+  return x + 1;
+});
+
+const sqr = (x) => x * x;
+```
+
+## When Not To Use It
+
+If you do not want to enforce using `R.doNothing`, you should not use this rule.

package/docs/rules/prefer-filter.md

@@ -0,0 +1,25 @@
+# Prefer filter
+
+When using R.forEach with a single `if` statement, you should probably use `R.filter` or `R.some` instead.
+
+## Rule Details
+
+This rule takes one argument, maximum path length (default is 3).
+
+The following patterns are considered warnings:
+
+```js
+R.forEach(users, function (user) {
+  if (user.name.givenName === "Bob") {
+    // ...
+  }
+});
+```
+
+The following patterns are not considered warnings:
+
+```js
+const x = R.filter(users, function (user) {
+  return !user.active && user.name.givenName === "Bob";
+});
+```

package/docs/rules/prefer-find.md

@@ -0,0 +1,39 @@
+# Prefer find
+
+When using R.filter and accessing the first or last result, you should probably use `R.find` or `R.findLast`, respectively.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+const x = R.filter(a, f)[0];
+```
+
+```js
+const x = R.head(R.filter(a, f));
+```
+
+```js
+const x = R.last(R.filter(a, f));
+```
+
+```js
+const x = R.head(R.reject(a, f));
+```
+
+The following patterns are not considered warnings:
+
+```js
+const x = R.filter(a, f);
+```
+
+```js
+const x = R.filter(a, f)[3];
+```
+
+```js
+const x = R.find(a, f);
+```

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

@@ -0,0 +1,25 @@
+# Prefer [`R.flatMap`] over consecutive [`R.map`] and [`R.flatten`]
+
+When using [`R.map`] and [`R.flatten`], it can be more concise to use [`R.flatMap`] instead.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+t = R.flatten(R.map(a, f));
+```
+
+The following patterns are not considered warnings:
+
+```js
+t = R.map(a, f);
+
+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.

package/docs/rules/prefer-is-empty.md

@@ -0,0 +1,39 @@
+# Prefer R.isEmpty
+
+When checking if a collection is empty or no, it is more concise to use R.isEmpty instead.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+const myLengthEqualZero = myVar.length === 0;
+
+const myLengthEqualZero = myVar.length > 0;
+
+const myLengthEqualZero = myVar.length > 0 ? "first" : "second";
+
+const myLengthEqualZero = myVar.myProp.mySecondProp.length === 0;
+
+const myLengthEqualZero = myVar.myProp.mySecondProp.length > 0;
+```
+
+The following patterns are not considered warnings:
+
+```js
+const myLengthEqualZero = !isEmpty(myVar);
+
+const myLengthEqualZero = isEmpty(myVar);
+
+const myLengthEqualZero = myVar.length == 0;
+
+const myLengthEqualZero = myVar.length;
+
+const myLengthEqualZero = myVar;
+```
+
+## When Not To Use It
+
+If you do not want to enforce using `R.isEmpty`, and prefer using native checks instead.

package/docs/rules/prefer-is-nil.md

@@ -0,0 +1,27 @@
+# Prefer R.isNil
+
+When checking that a value is undefined or null (but not false or ''), it is more concise to use R.isNil instead.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+var t = !R.isNull(x) && !R.isUndefined(x);
+
+var t = x === undefined || x === null;
+```
+
+The following patterns are not considered warnings:
+
+```js
+var t = R.isNil(x);
+
+var t = R.isUndefined(x) || R.isNull(y);
+```
+
+## When Not To Use It
+
+If you do not want to enforce using `R.isNil`, and prefer using specific checks instead.

package/docs/rules/prefer-map.md

@@ -0,0 +1,29 @@
+# Prefer map
+
+When using `R.forEach` that pushes into an array, it could improve readability to use `R.map` instead.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+R.forEach(arr, function (x) {
+  newArr.push(f(x));
+});
+```
+
+The following patterns are not considered warnings:
+
+```js
+R.forEach(arr, function (x) {
+  if (x.a) {
+    a.push(x);
+  }
+});
+```
+
+## When Not To Use It
+
+If you do not want to enforce using `map`, you should not use this rule.

package/docs/rules/prefer-nullish-coalescing.md

@@ -0,0 +1,25 @@
+# Prefer nullish coalescing over checking a ternary with !isNil.
+
+When checking if a variable is not nil as a test for a ternary equation, it's more coincise to just use the nullish coalescing operator.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+const myExpression = !isNil(myVar) ? myVar : myOtherVar;
+```
+
+The following patterns are not considered warnings:
+
+```js
+const myExpression = !isNil(myVar) ? mySecondVar : myThirdVar;
+
+const myExpression = myVar ?? myOtherVar;
+```
+
+
+## When Not To Use It
+If you do not want to enforce using nullish coalescing.

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

@@ -0,0 +1,36 @@
+# Prefer Lodash 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
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+
+if (typeof a === 'number') {
+  // ...
+}
+
+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; 
+
+```
+
+
+## When Not To Use It
+
+If you do not want to enforce using Lodash methods for type checks, you should not use this rule.

package/docs/rules/prefer-some.md

@@ -0,0 +1,29 @@
+# Prefer R.some
+
+When comparing the index of an item with an `findIndex` method, it can be more expressive to use `R.some`, when only the sole existence of a matching item is taken into account.
+
+## Rule Details
+
+The following patterns are considered warnings:
+
+```js
+var a = R.findIndex(b, f) === -1;
+
+var a = R.findIndex(b, f) >= 0;
+```
+
+The following patterns are not considered warnings:
+
+```js
+x = R.findIndex(a, f);
+
+R.findIndex(a, f) === 2;
+
+if (R.some(a, f)) {
+  // ...
+}
+```
+
+## When Not To Use It
+
+If you do not want to enforce using `R.findIndex`, you should not use this rule.

package/docs/rules/prefer-times.md

@@ -0,0 +1,36 @@
+# Prefer R.times
+
+When using `R.map` in which the iteratee does not have any arguments, it's better to use `R.times`.
+
+## Rule Details
+
+This rule takes no arguments.
+
+The following patterns are considered warnings:
+
+```js
+R.map(arr, function () {
+  return 7;
+});
+
+R.map(Array(10), function () {
+  return f(y);
+});
+
+import f from "remeda/map";
+f(arr, () => 0);
+```
+
+The following patterns are not considered warnings:
+
+```js
+R.times(arr.length, R.constant(7));
+
+R.map(arr, function (x) {
+  return x * x;
+});
+```
+
+## When Not To Use It
+
+If you do not want to enforce always using `times` when not using the arguments, you should not use this rule.

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "eslint-plugin-remeda",
+  "version": "1.0.0",
+  "author": "Andrea Pontrandolfo <andrea.pontra@gmail.com>",
+  "description": "ESLint plugin for Remeda library.",
+  "type": "commonjs",
+  "main": "src/index.js",
+  "scripts": {
+    "coveralls": "nyc report --reporter=text-lcov | coveralls",
+    "knip": "knip",
+    "publint": "publint",
+    "test": "npm run unit-test",
+    "unit-test": "cross-env nyc mocha \"tests/**/*.js\" --reporter=dot",
+    "semantic-release": "semantic-release"
+  },
+  "files": [
+    "README.md",
+    "src",
+    "docs"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda"
+  },
+  "homepage": "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda",
+  "bugs": "https://github.com/AndreaPontrandolfo/eslint-plugin-remeda/issues",
+  "peerDependencies": {
+    "eslint": ">=2"
+  },
+  "devDependencies": {
+    "@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",
+    "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",
+    "prettier": "^3.3.2",
+    "publint": "^0.2.8",
+    "semantic-release": "^24.0.0",
+    "typescript": "^5.5.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "remeda"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "lodash": "^4.17.21"
+  }
+}

package/src/index.js

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