es-toolkit-eslint-plugin 0.1.0 → 0.1.2

package/dist/rules/prefer-compact.js

@@ -1,20 +1,46 @@
 import { createRule } from '../utils/create-rule.js';
 const filterBoolean = 'CallExpression[callee.property.name="filter"][arguments.length=1][arguments.0.name="Boolean"]';
+// `.filter(x => …)` with a single single-parameter arrow predicate; its body is checked below.
+const filterArrow = 'CallExpression[callee.property.name="filter"][arguments.length=1][arguments.0.type="ArrowFunctionExpression"][arguments.0.params.length=1][arguments.0.params.0.type="Identifier"]';
+const isParam = (node, param) => node.type === 'Identifier' && node.name === param;
 export const preferCompact = createRule({
     name: 'prefer-compact',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer `compact` from es-toolkit over `.filter(Boolean)`.',
+            description: 'Prefer `compact` from es-toolkit over a truthiness filter.',
         },
         schema: [],
         messages: {
-            preferCompact: 'Prefer `compact` from es-toolkit instead of `.filter(Boolean)`.',
+            preferCompact: 'Prefer `compact` from es-toolkit instead of filtering by truthiness.',
         },
     },
     create(context) {
+        const report = (node) => context.report({ node, messageId: 'preferCompact' });
         return {
-            [filterBoolean]: (node) => context.report({ node, messageId: 'preferCompact' }),
+            [filterBoolean]: report,
+            [filterArrow](node) {
+                const arrow = node.arguments[0];
+                if (arrow.type !== 'ArrowFunctionExpression')
+                    return;
+                const [param] = arrow.params;
+                if (param.type !== 'Identifier')
+                    return;
+                const { body } = arrow;
+                // The predicate keeps only truthy values: `x => !!x` or `x => Boolean(x)`.
+                const isDoubleBang = body.type === 'UnaryExpression'
+                    && body.operator === '!'
+                    && body.argument.type === 'UnaryExpression'
+                    && body.argument.operator === '!'
+                    && isParam(body.argument.argument, param.name);
+                const isBooleanCall = body.type === 'CallExpression'
+                    && body.callee.type === 'Identifier'
+                    && body.callee.name === 'Boolean'
+                    && body.arguments.length === 1
+                    && isParam(body.arguments[0], param.name);
+                if (isDoubleBang || isBooleanCall)
+                    report(node);
+            },
         };
     },
 });

package/dist/rules/prefer-delay.js

@@ -1,7 +1,10 @@
 import { createRule } from '../utils/create-rule.js';
 // `new Promise(resolve => setTimeout(resolve, ms))` — a single-param executor whose
 // expression body is a two-argument `setTimeout` whose first argument is an identifier.
-const promisifiedTimeout = 'NewExpression[callee.name="Promise"][arguments.length=1] > ArrowFunctionExpression[params.length=1][params.0.type="Identifier"][body.callee.name="setTimeout"][body.arguments.length=2][body.arguments.0.type="Identifier"]';
+const expressionExecutor = 'NewExpression[callee.name="Promise"][arguments.length=1] > ArrowFunctionExpression[params.length=1][params.0.type="Identifier"][body.callee.name="setTimeout"][body.arguments.length=2][body.arguments.0.type="Identifier"]';
+// The block-bodied form `new Promise(resolve => { setTimeout(resolve, ms); })` — a single
+// statement that is the same two-argument `setTimeout`.
+const blockExecutor = 'NewExpression[callee.name="Promise"][arguments.length=1] > ArrowFunctionExpression[params.length=1][params.0.type="Identifier"][body.type="BlockStatement"][body.body.length=1][body.body.0.type="ExpressionStatement"][body.body.0.expression.callee.name="setTimeout"][body.body.0.expression.arguments.length=2][body.body.0.expression.arguments.0.type="Identifier"]';
 export const preferDelay = createRule({
     name: 'prefer-delay',
     meta: {
@@ -15,18 +18,29 @@ export const preferDelay = createRule({
         },
     },
     create(context) {
+        // Confirm the timeout callback IS the promise's own `resolve` (a pure delay).
+        const isPureDelay = (param, timeout) => {
+            const [callback] = timeout.arguments;
+            return (param.type === 'Identifier'
+                && callback.type === 'Identifier'
+                && param.name === callback.name);
+        };
+        const reportPromise = (node) => context.report({ node: node.parent, messageId: 'preferDelay' });
         return {
-            [promisifiedTimeout](node) {
-                const [param] = node.params;
-                const { body } = node;
-                // Confirm the timeout callback IS the promise's own `resolve` (a pure delay).
-                if (body.type !== 'CallExpression')
+            [expressionExecutor](node) {
+                if (node.body.type === 'CallExpression'
+                    && isPureDelay(node.params[0], node.body)) {
+                    reportPromise(node);
+                }
+            },
+            [blockExecutor](node) {
+                if (node.body.type !== 'BlockStatement')
                     return;
-                const [callback] = body.arguments;
-                if (param.type === 'Identifier'
-                    && callback.type === 'Identifier'
-                    && param.name === callback.name) {
-                    context.report({ node: node.parent, messageId: 'preferDelay' });
+                const [statement] = node.body.body;
+                if (statement.type === 'ExpressionStatement'
+                    && statement.expression.type === 'CallExpression'
+                    && isPureDelay(node.params[0], statement.expression)) {
+                    reportPromise(node);
                 }
             },
         };

package/dist/rules/prefer-is-empty.js

@@ -1,7 +1,9 @@
 import { createRule } from '../utils/create-rule.js';
-const objectKeysLength = (side) => `[${side}.property.name="length"][${side}.object.callee.object.name="Object"][${side}.object.callee.property.name="keys"]`;
+const objectKeysLength = (path) => `[${path}.property.name="length"][${path}.object.callee.object.name="Object"][${path}.object.callee.property.name="keys"]`;
 // `Object.keys(obj).length === 0`, in either operand order.
 const keysLengthZero = (zero, keys) => `BinaryExpression[operator=/^===?$/][${zero}.value=0]${objectKeysLength(keys)}`;
+// `!Object.keys(obj).length` — a falsy length means no keys.
+const notKeysLength = `UnaryExpression[operator="!"]${objectKeysLength('argument')}`;
 export const preferIsEmpty = createRule({
     name: 'prefer-is-empty',
     meta: {
@@ -19,6 +21,7 @@ export const preferIsEmpty = createRule({
         return {
             [keysLengthZero('right', 'left')]: report,
             [keysLengthZero('left', 'right')]: report,
+            [notKeysLength]: report,
         };
     },
 });

package/dist/rules/prefer-random-int.js

@@ -1,22 +1,29 @@
 import { createRule } from '../utils/create-rule.js';
 const random = 'CallExpression[callee.object.name="Math"][callee.property.name="random"]';
-// `Math.floor(Math.random() * X)`. A `.length` multiplier is left to `prefer-sample`.
-const floorRandom = `CallExpression[callee.object.name="Math"][callee.property.name="floor"][arguments.length=1]:has(> BinaryExpression[operator="*"]:has(> ${random}):not(:has(> MemberExpression[property.name="length"])))`;
+// `Math.random() * X`. A `.length` multiplier is left to `prefer-sample`.
+const product = `BinaryExpression[operator="*"]:has(> ${random}):not(:has(> MemberExpression[property.name="length"]))`;
+// Each idiom truncates that product to an int: `Math.floor`/`Math.trunc`, `~~`, or `| 0`.
+const truncCall = `CallExpression[callee.object.name="Math"][callee.property.name=/^(floor|trunc)$/][arguments.length=1]:has(> ${product})`;
+const doubleTilde = `UnaryExpression[operator="~"]:has(> UnaryExpression[operator="~"]:has(> ${product}))`;
+const bitwiseOr = `BinaryExpression[operator="|"][right.value=0]:has(> ${product})`;
 export const preferRandomInt = createRule({
     name: 'prefer-random-int',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer `randomInt` from es-toolkit over `Math.floor(Math.random() * …)`.',
+            description: 'Prefer `randomInt` from es-toolkit over truncating `Math.random() * …` to an int.',
         },
         schema: [],
         messages: {
-            preferRandomInt: 'Prefer `randomInt` from es-toolkit instead of `Math.floor(Math.random() * …)`.',
+            preferRandomInt: 'Prefer `randomInt` from es-toolkit instead of truncating `Math.random() * …` to an int.',
         },
     },
     create(context) {
+        const report = (node) => context.report({ node, messageId: 'preferRandomInt' });
         return {
-            [floorRandom]: (node) => context.report({ node, messageId: 'preferRandomInt' }),
+            [truncCall]: report,
+            [doubleTilde]: report,
+            [bitwiseOr]: report,
         };
     },
 });

package/dist/rules/prefer-sample.js

@@ -1,6 +1,12 @@
 import { createRule } from '../utils/create-rule.js';
-// `arr[Math.floor(Math.random() * arr.length)]` — a random index into an array's length.
-const randomIndex = 'MemberExpression[computed=true][property.callee.object.name="Math"][property.callee.property.name="floor"]:has(CallExpression[callee.object.name="Math"][callee.property.name="random"]):has(MemberExpression[property.name="length"])';
+const random = 'CallExpression[callee.object.name="Math"][callee.property.name="random"]';
+const length = 'MemberExpression[property.name="length"]';
+// A computed access `arr[<index>]` whose index draws on `Math.random()` and an array `.length`.
+const randomIndexAccess = (index) => `MemberExpression[computed=true]${index}:has(${random}):has(${length})`;
+// The index truncates to an int via `Math.floor`/`Math.trunc`, `~~`, or `| 0`.
+const truncCall = '[property.callee.object.name="Math"][property.callee.property.name=/^(floor|trunc)$/]';
+const doubleTilde = '[property.type="UnaryExpression"][property.operator="~"][property.argument.type="UnaryExpression"][property.argument.operator="~"]';
+const bitwiseOr = '[property.type="BinaryExpression"][property.operator="|"][property.right.value=0]';
 export const preferSample = createRule({
     name: 'prefer-sample',
     meta: {
@@ -14,8 +20,11 @@ export const preferSample = createRule({
         },
     },
     create(context) {
+        const report = (node) => context.report({ node, messageId: 'preferSample' });
         return {
-            [randomIndex]: (node) => context.report({ node, messageId: 'preferSample' }),
+            [randomIndexAccess(truncCall)]: report,
+            [randomIndexAccess(doubleTilde)]: report,
+            [randomIndexAccess(bitwiseOr)]: report,
         };
     },
 });

package/docs/rules/prefer-compact.md

@@ -4,16 +4,19 @@ Prefer [`compact`](https://es-toolkit.dev/reference/array/compact.html) from es-
 over `.filter(Boolean)`.
 
 `compact(arr)` removes all falsy values (`false`, `null`, `0`, `''`, `undefined`, `NaN`) —
-exactly what `arr.filter(Boolean)` does, but named and (in TypeScript) better typed.
+exactly what a truthiness filter does, but named and (in TypeScript) better typed.
 
 ## Rule details
 
-This rule reports — it does **not** auto-fix — a single-argument `.filter(Boolean)` call.
+This rule reports — it does **not** auto-fix — a single-argument truthiness filter:
+`.filter(Boolean)`, `.filter(x => !!x)`, or `.filter(x => Boolean(x))`.
 
 ### ❌ Incorrect
 
 ```js
 arr.filter(Boolean);
+arr.filter(x => !!x);
+arr.filter(x => Boolean(x));
 items.filter(Boolean).map(x => x.id);
 ```
 
@@ -26,11 +29,16 @@ compact(arr);
 
 // Not a falsy filter — left untouched:
 arr.filter(x => x);
+arr.filter(x => !!y); // filters by a different value
+arr.filter(x => Boolean(x.foo)); // filters by a property, not the element
 arr.map(Boolean);
 ```
 
 ## Limitations
 
+- **Arrow predicate is identity-checked.** `x => !!x` and `x => Boolean(x)` are reported only
+  when the negated/wrapped value is the predicate's own parameter, so `x => !!y` and
+  `x => Boolean(x.foo)` are left alone.
 - **Syntactic match.** A shadowed local `Boolean` could produce a false positive. This is
   rare in practice.
 - **TypeScript bonus.** Beyond readability, `compact` narrows nullable element types, while

package/docs/rules/prefer-delay.md

@@ -9,12 +9,16 @@ hand-rolled `new Promise((resolve) => setTimeout(resolve, ms))` sleep idiom.
 ## Rule details
 
 This rule reports — it does **not** auto-fix — a `new Promise` whose single-parameter
-executor immediately calls `setTimeout` with that same parameter as the callback.
+executor immediately calls `setTimeout` with that same parameter as the callback, whether the
+executor has an expression body or a single-statement block body.
 
 ### ❌ Incorrect
 
 ```js
 new Promise(resolve => setTimeout(resolve, 1000));
+new Promise(resolve => {
+  setTimeout(resolve, ms);
+});
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 ```
 
@@ -28,15 +32,17 @@ await delay(1000);
 // Not a pure delay — left untouched:
 new Promise(resolve => setTimeout(doWork, 1000)); // runs work, not just a delay
 new Promise(resolve => {
-  setTimeout(resolve, ms); // block-bodied executor, see Limitations
+  doWork();
+  setTimeout(resolve, ms); // does more than wait, see Limitations
 });
 ```
 
 ## Limitations
 
-- **Expression-body executor only.** The block-bodied form
-  `new Promise((resolve) => { setTimeout(resolve, ms); })` and wrapped forms like
-  `setTimeout(() => resolve(), ms)` are not reported, to keep the rule precise.
+- **Single-statement executors only.** A block body that does more than the one `setTimeout`
+  (e.g. `new Promise((resolve) => { doWork(); setTimeout(resolve, ms); })`), arrow-only forms,
+  and wrapped forms like `setTimeout(() => resolve(), ms)` are not reported, to keep the rule
+  precise. Function-expression executors (`function (resolve) { … }`) are also not flagged.
 - **Identity-checked.** The rule reports only when `setTimeout`'s callback is the promise's
   own `resolve` parameter, so `setTimeout(doWork, ms)` inside a `new Promise` is left alone.
 - **No auto-fix by design.** The fix requires adding an `import { delay } from 'es-toolkit'`.

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

@@ -8,14 +8,15 @@ allocating an intermediate keys array.
 
 ## Rule details
 
-This rule reports — it does **not** auto-fix — an equality comparison of
-`Object.keys(...).length` against `0`, in either operand order.
+This rule reports — it does **not** auto-fix — a check that `Object.keys(...).length` is
+zero: an equality comparison against `0` in either operand order, or the `!`-negated length.
 
 ### ❌ Incorrect
 
 ```js
 Object.keys(obj).length === 0;
 0 === Object.keys(obj).length;
+!Object.keys(obj).length;
 ```
 
 ### ✅ Correct

package/docs/rules/prefer-random-int.md

@@ -8,14 +8,17 @@ formula; `randomInt` names the intent and removes the off-by-one foot-guns.
 
 ## Rule details
 
-This rule reports — it does **not** auto-fix — `Math.floor(...)` applied to a multiplication
-that contains `Math.random()`. A `.length` multiplier is left to
-[`prefer-sample`](./prefer-sample.md) instead.
+This rule reports — it does **not** auto-fix — a `Math.random() * …` product truncated to an
+integer, whether by `Math.floor(...)`, `Math.trunc(...)`, `~~(...)`, or `… | 0`. A `.length`
+multiplier is left to [`prefer-sample`](./prefer-sample.md) instead.
 
 ### ❌ Incorrect
 
 ```js
 Math.floor(Math.random() * 6);
+Math.trunc(Math.random() * 6);
+~~(Math.random() * 6);
+(Math.random() * 6) | 0;
 Math.floor(Math.random() * (max - min + 1)) + min;
 ```
 
@@ -28,7 +31,8 @@ randomInt(0, 6);
 
 // Not this rule's concern — left untouched:
 Math.random(); // a float in [0, 1)
-Math.round(Math.random() * n); // rounds, not floors
+Math.round(Math.random() * n); // rounds, not truncates
+Math.ceil(Math.random() * n); // changes the bounds
 arr[Math.floor(Math.random() * arr.length)]; // see prefer-sample
 ```
 
@@ -37,7 +41,8 @@ arr[Math.floor(Math.random() * arr.length)]; // see prefer-sample
 - **Bounds differ.** The inclusive idiom `Math.floor(Math.random() * (max - min + 1)) + min`
   yields `[min, max]`, whereas `randomInt(min, max)` yields `[min, max)`. Adjust the upper
   bound when rewriting.
-- **`floor` only.** The `Math.round(...)` variant is not reported (it has a non-uniform
-  distribution and is a different intent).
+- **Truncation only.** `Math.floor`, `Math.trunc`, `~~`, and `| 0` are reported (all truncate
+  toward zero for the non-negative `Math.random() * n` range). `Math.round(...)` and
+  `Math.ceil(...)` are **not** — they change the distribution or bounds.
 - **Syntactic match.** A shadowed local `Math` could produce a false positive.
 - **No auto-fix by design.** The fix requires adding an `import { randomInt } from 'es-toolkit'`.

package/docs/rules/prefer-sample.md

@@ -8,13 +8,17 @@ out the same idea by hand and repeats the array.
 
 ## Rule details
 
-This rule reports — it does **not** auto-fix — a computed access whose index is
-`Math.floor(Math.random() * …length)`.
+This rule reports — it does **not** auto-fix — a computed access whose index truncates
+`Math.random() * …length` to an integer, whether by `Math.floor`/`Math.trunc`, `~~`, or
+`… | 0`.
 
 ### ❌ Incorrect
 
 ```js
 arr[Math.floor(Math.random() * arr.length)];
+arr[Math.trunc(Math.random() * arr.length)];
+arr[~~(Math.random() * arr.length)];
+arr[(Math.random() * arr.length) | 0];
 items[Math.floor(Math.random() * items.length)];
 ```
 
@@ -35,5 +39,7 @@ arr[i];
 - **Object identity is not checked.** The selector matches `a[Math.floor(Math.random() *
 b.length)]`, so the rare case where the indexed array and the `.length` array differ would
   also be reported.
+- **Truncation only.** The index must truncate toward zero (`Math.floor`, `Math.trunc`, `~~`,
+  or `| 0`); `Math.round`/`Math.ceil` indices are not reported.
 - **Syntactic match.** A shadowed local `Math` could produce a false positive.
 - **No auto-fix by design.** The fix requires adding an `import { sample } from 'es-toolkit'`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit-eslint-plugin",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "ESLint plugin that suggests es-toolkit utilities in place of verbose JS/TS",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,20 +32,18 @@
     "url": "https://github.com/syxov/es-toolkit-eslint-plugin/issues"
   },
   "homepage": "https://github.com/syxov/es-toolkit-eslint-plugin#readme",
-  "dependencies": {
-    "@typescript-eslint/utils": "^8.61.1"
-  },
   "peerDependencies": {
+    "@typescript-eslint/utils": "^8.61.1",
     "eslint": ">=10"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
-    "@typescript-eslint/rule-tester": "^8.0.0",
-    "eslint": "^10.0.0",
+    "@types/node": "^26.0.0",
+    "@typescript-eslint/parser": "^8.61.1",
+    "@typescript-eslint/rule-tester": "^8.61.1",
+    "eslint": "^10.5.0",
     "prettier": "^3.8.4",
     "typescript": "^6.0.3",
-    "vitest": "^3.0.0"
+    "vitest": "^4.1.9"
   },
   "scripts": {
     "build": "tsc",