eslint-plugin-pet-peeves 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joona Kettunen
+
+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,43 @@
+# eslint-plugin-pet-peeves
+
+A small ESLint plugin for opinionated readability rules.
+
+## Installation
+
+```sh
+npm install --save-dev eslint-plugin-pet-peeves
+```
+
+Add the plugin and whichever rules you want to an ESLint flat configuration:
+
+```js
+import petPeeves from "eslint-plugin-pet-peeves";
+
+export default [
+  {
+    plugins: {
+      "pet-peeves": petPeeves,
+    },
+    rules: {
+      "pet-peeves/max-operands": ["error", { max: 8 }],
+      "pet-peeves/max-same-operator-operands": ["error", { max: 4 }],
+    },
+  },
+];
+```
+
+## Rules
+
+- [`max-operands`](docs/rules/max-operands.md) limits all operands in a connected logical expression.
+- [`max-same-operator-operands`](docs/rules/max-same-operator-operands.md) limits operands in each same-operator logical chain.
+
+Both rules support `&&`, `||`, and `??`.
+
+## Development
+
+```sh
+npm install
+npm test
+```
+
+`npm run build` compiles the TypeScript source to JavaScript and declarations in `dist`.

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export declare const rules: {
+    "max-operands": import("eslint").Rule.RuleModule;
+    "max-same-operator-operands": import("eslint").Rule.RuleModule;
+};
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        "max-operands": import("eslint").Rule.RuleModule;
+        "max-same-operator-operands": import("eslint").Rule.RuleModule;
+    };
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;CAGjB,CAAC;AAEF,QAAA,MAAM,MAAM;;;;;;;;;CAMX,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+import maxOperands from "./rules/max-operands.js";
+import maxSameOperatorOperands from "./rules/max-same-operator-operands.js";
+export const rules = {
+    "max-operands": maxOperands,
+    "max-same-operator-operands": maxSameOperatorOperands,
+};
+const plugin = {
+    meta: {
+        name: "eslint-plugin-pet-peeves",
+        version: "0.1.0",
+    },
+    rules,
+};
+export default plugin;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,yBAAyB,CAAC;AAClD,OAAO,uBAAuB,MAAM,uCAAuC,CAAC;AAE5E,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,cAAc,EAAE,WAAW;IAC3B,4BAA4B,EAAE,uBAAuB;CACtD,CAAC;AAEF,MAAM,MAAM,GAAG;IACb,IAAI,EAAE;QACJ,IAAI,EAAE,0BAA0B;QAChC,OAAO,EAAE,OAAO;KACjB;IACD,KAAK;CACN,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/rules/max-operands.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=max-operands.d.ts.map

package/dist/rules/max-operands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-operands.d.ts","sourceRoot":"","sources":["../../src/rules/max-operands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiBnC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UAqChB,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/rules/max-operands.js

@@ -0,0 +1,41 @@
+import { getMax, isLogicalExpression, maxOptionSchema, } from "./shared.js";
+function countOperands(node) {
+    if (!isLogicalExpression(node)) {
+        return 1;
+    }
+    return countOperands(node.left) + countOperands(node.right);
+}
+const rule = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Limit the total number of operands in a logical expression.",
+            recommended: false,
+            url: "https://github.com/joonarafael/eslint-plugin-pet-peeves/blob/master/docs/rules/max-operands.md",
+        },
+        schema: maxOptionSchema,
+        messages: {
+            tooManyOperands: "This logical expression has {{count}} operands. The maximum allowed is {{max}}.",
+        },
+    },
+    create(context) {
+        const max = getMax(context.options);
+        return {
+            LogicalExpression(node) {
+                if (isLogicalExpression(node.parent)) {
+                    return;
+                }
+                const count = countOperands(node);
+                if (count > max) {
+                    context.report({
+                        node,
+                        messageId: "tooManyOperands",
+                        data: { count, max },
+                    });
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=max-operands.js.map

package/dist/rules/max-operands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-operands.js","sourceRoot":"","sources":["../../src/rules/max-operands.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,MAAM,EACN,mBAAmB,EACnB,eAAe,GAEhB,MAAM,aAAa,CAAC;AAErB,SAAS,aAAa,CAAC,IAAe;IACpC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC9D,CAAC;AAED,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EACT,6DAA6D;YAC/D,WAAW,EAAE,KAAK;YAClB,GAAG,EAAE,gGAAgG;SACtG;QACD,MAAM,EAAE,eAAe;QACvB,QAAQ,EAAE;YACR,eAAe,EACb,iFAAiF;SACpF;KACF;IAED,MAAM,CAAC,OAAO;QACZ,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,OAAkB,CAAC,CAAC;QAE/C,OAAO;YACL,iBAAiB,CAAC,IAAI;gBACpB,IAAI,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrC,OAAO;gBACT,CAAC;gBAED,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;gBAElC,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;oBAChB,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;wBACJ,SAAS,EAAE,iBAAiB;wBAC5B,IAAI,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;qBACrB,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/rules/max-same-operator-operands.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=max-same-operator-operands.d.ts.map

package/dist/rules/max-same-operator-operands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-same-operator-operands.d.ts","sourceRoot":"","sources":["../../src/rules/max-same-operator-operands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAwBnC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8ChB,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/rules/max-same-operator-operands.js

@@ -0,0 +1,45 @@
+import { getMax, isLogicalExpression, maxOptionSchema, } from "./shared.js";
+function countSameOperatorOperands(node, operator) {
+    if (!isLogicalExpression(node) || node.operator !== operator) {
+        return 1;
+    }
+    return (countSameOperatorOperands(node.left, operator) +
+        countSameOperatorOperands(node.right, operator));
+}
+const rule = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Limit the number of operands in a same-operator logical chain.",
+            recommended: false,
+            url: "https://github.com/joonarafael/eslint-plugin-pet-peeves/blob/master/docs/rules/max-same-operator-operands.md",
+        },
+        schema: maxOptionSchema,
+        messages: {
+            tooManyOperands: "This '{{operator}}' chain has {{count}} operands. The maximum allowed is {{max}}.",
+        },
+    },
+    create(context) {
+        const max = getMax(context.options);
+        return {
+            LogicalExpression(node) {
+                const expression = node;
+                const parent = expression.parent;
+                if (isLogicalExpression(parent) &&
+                    parent.operator === expression.operator) {
+                    return;
+                }
+                const count = countSameOperatorOperands(expression, expression.operator);
+                if (count > max) {
+                    context.report({
+                        node: expression,
+                        messageId: "tooManyOperands",
+                        data: { count, max, operator: expression.operator },
+                    });
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=max-same-operator-operands.js.map

package/dist/rules/max-same-operator-operands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-same-operator-operands.js","sourceRoot":"","sources":["../../src/rules/max-same-operator-operands.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,MAAM,EACN,mBAAmB,EACnB,eAAe,GAGhB,MAAM,aAAa,CAAC;AAErB,SAAS,yBAAyB,CAChC,IAAe,EACf,QAAuC;IAEvC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC7D,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,CACL,yBAAyB,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC;QAC9C,yBAAyB,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAChD,CAAC;AACJ,CAAC;AAED,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EACT,gEAAgE;YAClE,WAAW,EAAE,KAAK;YAClB,GAAG,EAAE,8GAA8G;SACpH;QACD,MAAM,EAAE,eAAe;QACvB,QAAQ,EAAE;YACR,eAAe,EACb,mFAAmF;SACtF;KACF;IAED,MAAM,CAAC,OAAO;QACZ,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,OAAkB,CAAC,CAAC;QAE/C,OAAO;YACL,iBAAiB,CAAC,IAAI;gBACpB,MAAM,UAAU,GAAG,IAAyB,CAAC;gBAC7C,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;gBAEjC,IACE,mBAAmB,CAAC,MAAM,CAAC;oBAC3B,MAAM,CAAC,QAAQ,KAAK,UAAU,CAAC,QAAQ,EACvC,CAAC;oBACD,OAAO;gBACT,CAAC;gBAED,MAAM,KAAK,GAAG,yBAAyB,CACrC,UAAU,EACV,UAAU,CAAC,QAAQ,CACpB,CAAC;gBAEF,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;oBAChB,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI,EAAE,UAAU;wBAChB,SAAS,EAAE,iBAAiB;wBAC5B,IAAI,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAE;qBACpD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/rules/shared.d.ts

@@ -0,0 +1,26 @@
+import type { Rule } from "eslint";
+export declare const DEFAULT_MAX = 4;
+export type Options = [{
+    max: number;
+}?];
+export type LogicalExpression = Rule.Node & {
+    type: "LogicalExpression";
+    operator: "&&" | "||" | "??";
+    left: Rule.Node;
+    right: Rule.Node;
+};
+export declare const maxOptionSchema: readonly [{
+    readonly type: "object";
+    readonly properties: {
+        readonly max: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly maximum: 100;
+        };
+    };
+    readonly required: readonly ["max"];
+    readonly additionalProperties: false;
+}];
+export declare function isLogicalExpression(node: Rule.Node | null | undefined): node is LogicalExpression;
+export declare function getMax(options: Options): number;
+//# sourceMappingURL=shared.d.ts.map

package/dist/rules/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/rules/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAEzC,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,GAAG;IAC1C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC7B,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAChB,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;EAalB,CAAC;AAEX,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GACjC,IAAI,IAAI,iBAAiB,CAE3B;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAE/C"}

package/dist/rules/shared.js

@@ -0,0 +1,22 @@
+export const DEFAULT_MAX = 4;
+export const maxOptionSchema = [
+    {
+        type: "object",
+        properties: {
+            max: {
+                type: "integer",
+                minimum: 0,
+                maximum: 100,
+            },
+        },
+        required: ["max"],
+        additionalProperties: false,
+    },
+];
+export function isLogicalExpression(node) {
+    return node?.type === "LogicalExpression";
+}
+export function getMax(options) {
+    return options[0]?.max ?? DEFAULT_MAX;
+}
+//# sourceMappingURL=shared.js.map

package/dist/rules/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/rules/shared.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAW7B,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B;QACE,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,GAAG,EAAE;gBACH,IAAI,EAAE,SAAS;gBACf,OAAO,EAAE,CAAC;gBACV,OAAO,EAAE,GAAG;aACb;SACF;QACD,QAAQ,EAAE,CAAC,KAAK,CAAC;QACjB,oBAAoB,EAAE,KAAK;KAC5B;CACO,CAAC;AAEX,MAAM,UAAU,mBAAmB,CACjC,IAAkC;IAElC,OAAO,IAAI,EAAE,IAAI,KAAK,mBAAmB,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,OAAgB;IACrC,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,WAAW,CAAC;AACxC,CAAC"}

package/docs/rules/max-operands.md

@@ -0,0 +1,33 @@
+# Limit total logical operands (`max-operands`)
+
+Limits the total number of operands in a connected logical expression. The rule counts operands joined by `&&`, `||`, and `??`, including expressions that mix those operators.
+
+Parentheses do not reset the count. Logical expressions nested inside a non-logical operand, such as a function call, are checked separately.
+
+## Options
+
+The rule accepts an object with a `max` property:
+
+```js
+{
+  "pet-peeves/max-operands": ["error", { max: 4 }]
+}
+```
+
+`max` must be an integer from `0` through `100`. It defaults to `4` when the option is omitted.
+
+With `{ max: 4 }`, these examples are valid:
+
+```js
+a && b && c && d;
+(a && b) || (c ?? d);
+```
+
+These examples are invalid:
+
+```js
+a && b && c && d && e;
+(a && b && c) || (d && e) || f;
+```
+
+The rule reports the complete offending logical expression and does not provide an automatic fix.

package/docs/rules/max-same-operator-operands.md

@@ -0,0 +1,40 @@
+# Limit same-operator logical operands (`max-same-operator-operands`)
+
+Limits the number of operands in each maximal `&&`, `||`, or `??` chain. Different logical operators begin separate chains, while the expression using them can still be an operand in the surrounding chain.
+
+For example, this expression has a three-operand `||` chain, a three-operand `&&` chain, and a two-operand `&&` chain:
+
+```js
+(a && b && c) || (d && e) || f;
+```
+
+Parentheses do not break a same-operator chain.
+
+## Options
+
+The rule accepts an object with a `max` property:
+
+```js
+{
+  "pet-peeves/max-same-operator-operands": ["error", { max: 4 }]
+}
+```
+
+`max` must be an integer from `0` through `100`. It defaults to `4` when the option is omitted.
+
+With `{ max: 3 }`, these examples are valid:
+
+```js
+a && b && c;
+(a && b) || (c && d);
+(a ?? b) || (c ?? d);
+```
+
+These examples are invalid:
+
+```js
+a && b && c && d;
+a || b || c || d;
+```
+
+The rule reports each complete offending chain and does not provide an automatic fix.

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "eslint-plugin-pet-peeves",
+  "version": "0.1.0",
+  "description": "Opinionated ESLint rules for keeping JavaScript expressions readable.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.tests.json",
+    "test": "npm run build && npm run typecheck && tsx --test tests/*.test.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepack": "npm test"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0 || ^10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "eslint": "10.10.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.6",
+    "prettier": "3.9.6",
+    "tsx": "4.23.13",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.69.0"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joonarafael/eslint-plugin-pet-peeves.git"
+  },
+  "bugs": {
+    "url": "https://github.com/joonarafael/eslint-plugin-pet-peeves/issues"
+  },
+  "homepage": "https://github.com/joonarafael/eslint-plugin-pet-peeves#readme",
+  "license": "MIT",
+  "allowScripts": {
+    "esbuild@0.28.2": true
+  }
+}