eslint-plugin-big-o 1.0.0

package/README.md

@@ -0,0 +1,143 @@
+# eslint-plugin-big-o
+
+[![npm version](https://img.shields.io/npm/v/eslint-plugin-big-o.svg)](https://www.npmjs.com/package/eslint-plugin-big-o)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
+
+ESLint rules that catch accidental O(n²) patterns before they reach production.
+
+## Requirements
+
+- ESLint ≥ 9.0.0 (flat config)
+- Node.js ≥ 24.0.0
+
+## Installation
+
+```sh
+pnpm add -D eslint-plugin-big-o
+```
+
+## Usage
+
+Add to your `eslint.config.js` (or `.ts`):
+
+```js
+import bigO from 'eslint-plugin-big-o'
+
+export default [
+  bigO.configs.recommended,
+]
+```
+
+Or configure rules individually:
+
+```js
+import bigO from 'eslint-plugin-big-o'
+
+export default [
+  {
+    plugins: { 'big-o': bigO },
+    rules: {
+      'big-o/no-array-lookup-in-loop': 'warn',
+      'big-o/no-quadratic-dedup': 'warn',
+      'big-o/no-nested-array-spread': 'warn',
+    },
+  },
+]
+```
+
+## Rules
+
+| Rule | Description | Complexity |
+|------|-------------|------------|
+| [`no-array-lookup-in-loop`](#no-array-lookup-in-loop) | Disallow linear search inside iteration callbacks | O(n) → O(1) |
+| [`no-quadratic-dedup`](#no-quadratic-dedup) | Disallow filter+findIndex deduplication pattern | O(n²) → O(n) |
+| [`no-nested-array-spread`](#no-nested-array-spread) | Disallow spreading recursive results inside reduce | O(n²) → O(n) |
+
+---
+
+### `no-array-lookup-in-loop`
+
+Warns when `.find()`, `.findIndex()`, `.includes()`, or `.indexOf()` is called inside an iteration callback (`.map()`, `.filter()`, `.reduce()`, `.forEach()`, `.flatMap()`, `.some()`, `.every()`). Each outer iteration triggers a full inner scan — O(n²) total.
+
+**Bad**
+
+```js
+const result = items.map(item =>
+  other.find(o => o.id === item.id) // O(n²)
+)
+```
+
+**Good**
+
+```js
+const otherMap = new Map(other.map(o => [o.id, o]))
+const result = items.map(item => otherMap.get(item.id)) // O(n)
+```
+
+---
+
+### `no-quadratic-dedup`
+
+Warns on the common but quadratic deduplication idiom:  
+`arr.filter((item, i) => arr.findIndex(x => ...) === i)`
+
+Each `.filter` iteration calls `.findIndex`, which scans from the start — O(n²).
+
+**Bad**
+
+```js
+const unique = arr.filter((item, i) =>
+  arr.findIndex(x => x.id === item.id) === i // O(n²)
+)
+```
+
+**Good**
+
+```js
+const seen = new Set()
+const unique = arr.filter(item => {
+  if (seen.has(item.id)) return false
+  seen.add(item.id)
+  return true
+}) // O(n)
+
+// or simply:
+const unique = [...new Map(arr.map(x => [x.id, x])).values()] // O(n)
+```
+
+---
+
+### `no-nested-array-spread`
+
+Warns when a recursive function call is spread inside a `.reduce()` callback. Each recursive call creates a new array copy — O(n²) total allocations.
+
+**Bad**
+
+```js
+function flatten(arr) {
+  return arr.reduce((acc, item) =>
+    Array.isArray(item)
+      ? [...acc, ...flatten(item)] // O(n²) — new array each iteration
+      : [...acc, item],
+    []
+  )
+}
+```
+
+**Good**
+
+```js
+function flatten(arr) {
+  return arr.reduce((acc, item) => {
+    if (Array.isArray(item)) acc.push(...flatten(item))
+    else acc.push(item)
+    return acc // mutate in-place — O(n)
+  }, [])
+}
+```
+
+---
+
+## License
+
+[ISC](LICENSE) © Adrian Elton-Browning

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from 'eslint';
+type Plugin = {
+    meta: {
+        name: string;
+    };
+    rules: Record<string, Rule.RuleModule>;
+    configs: Record<string, unknown>;
+};
+declare const plugin: Plugin;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,25 @@
+import noArrayLookupInLoop from "./rules/no-array-lookup-in-loop.js";
+import noQuadraticDedup from "./rules/no-quadratic-dedup.js";
+import noNestedArraySpread from "./rules/no-nested-array-spread.js";
+const plugin = {
+    meta: {
+        name: 'eslint-plugin-big-o',
+    },
+    rules: {
+        'no-array-lookup-in-loop': noArrayLookupInLoop,
+        'no-quadratic-dedup': noQuadraticDedup,
+        'no-nested-array-spread': noNestedArraySpread,
+    },
+    configs: {},
+};
+plugin.configs = {
+    recommended: {
+        plugins: { 'big-o': plugin },
+        rules: {
+            'big-o/no-array-lookup-in-loop': 'warn',
+            'big-o/no-quadratic-dedup': 'warn',
+            'big-o/no-nested-array-spread': 'warn',
+        },
+    },
+};
+export default plugin;

package/dist/rules/no-array-lookup-in-loop.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/rules/no-array-lookup-in-loop.js

@@ -0,0 +1,53 @@
+const LOOP_METHODS = new Set(['map', 'filter', 'reduce', 'forEach', 'flatMap', 'some', 'every']);
+const LOOKUP_METHODS = new Set(['find', 'findIndex', 'includes', 'indexOf']);
+const rule = {
+    meta: {
+        type: 'suggestion',
+        schema: [],
+        messages: {
+            arrayLookupInLoop: 'O(n²): .{{method}}() inside .{{outer}}() callback. Use a Map or Set for O(1) lookup.',
+        },
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'MemberExpression' ||
+                    node.callee.property.type !== 'Identifier' ||
+                    !LOOKUP_METHODS.has(node.callee.property.name))
+                    return;
+                const method = node.callee.property.name;
+                const ancestors = context.sourceCode.getAncestors(node);
+                for (let i = ancestors.length - 1; i >= 0; i--) {
+                    const ancestor = ancestors[i];
+                    if (!ancestor)
+                        continue;
+                    if (ancestor.type === 'CallExpression' &&
+                        ancestor.callee.type === 'MemberExpression' &&
+                        ancestor.callee.property.type === 'Identifier' &&
+                        LOOP_METHODS.has(ancestor.callee.property.name)) {
+                        const loopMethod = ancestor.callee.property.name;
+                        const callback = ancestor.arguments[0];
+                        if (callback && isDescendant(node, callback)) {
+                            context.report({
+                                node,
+                                messageId: 'arrayLookupInLoop',
+                                data: { method, outer: loopMethod },
+                            });
+                            return;
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+function isDescendant(node, ancestor) {
+    let current = node;
+    while (current) {
+        if (current === ancestor)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}

package/dist/rules/no-nested-array-spread.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/rules/no-nested-array-spread.js

@@ -0,0 +1,74 @@
+const rule = {
+    meta: {
+        type: 'suggestion',
+        schema: [],
+        messages: {
+            nestedArraySpread: 'O(n²): spreading a recursive call result inside reduce creates quadratic copies. Pass accumulator by reference instead.',
+        },
+    },
+    create(context) {
+        return {
+            SpreadElement(node) {
+                if (node.argument.type !== 'CallExpression')
+                    return;
+                const call = node.argument;
+                const calleeName = getCalleeName(call);
+                if (!calleeName)
+                    return;
+                if (!isInsideReduceCallback(node))
+                    return;
+                if (isRecursiveCall(node, calleeName)) {
+                    context.report({ node, messageId: 'nestedArraySpread' });
+                }
+            },
+        };
+    },
+};
+export default rule;
+function getCalleeName(call) {
+    if (call.callee.type === 'Identifier')
+        return call.callee.name;
+    return null;
+}
+function isInsideReduceCallback(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === 'CallExpression' &&
+            current.callee.type === 'MemberExpression' &&
+            current.callee.property.type === 'Identifier' &&
+            current.callee.property.name === 'reduce') {
+            const callback = current.arguments[0];
+            if (callback && isAncestor(callback, node))
+                return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isAncestor(ancestor, node) {
+    let current = node;
+    while (current) {
+        if (current === ancestor)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function isRecursiveCall(node, calleeName) {
+    let current = node.parent;
+    while (current) {
+        if ((current.type === 'FunctionDeclaration' || current.type === 'FunctionExpression') &&
+            current.id?.name === calleeName) {
+            return true;
+        }
+        // arrow function: const name = (...) => ...
+        if (current.type === 'ArrowFunctionExpression' &&
+            current.parent?.type === 'VariableDeclarator' &&
+            current.parent.id?.type === 'Identifier' &&
+            current.parent.id.name === calleeName) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}

package/dist/rules/no-quadratic-dedup.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/rules/no-quadratic-dedup.js

@@ -0,0 +1,71 @@
+const rule = {
+    meta: {
+        type: 'suggestion',
+        schema: [],
+        messages: {
+            quadraticDedup: 'O(n²): arr.filter((item, i) => arr.findIndex(...) === i) is quadratic. Use a Map or Set for O(n) dedup.',
+        },
+    },
+    create(context) {
+        return {
+            'CallExpression[callee.property.name="filter"]'(node) {
+                const callback = node.arguments[0];
+                if (!callback)
+                    return;
+                const params = 'params' in callback ? callback.params : [];
+                if (!params || params.length < 2)
+                    return;
+                const indexParam = params[1];
+                if (!indexParam || indexParam.type !== 'Identifier')
+                    return;
+                const indexName = indexParam.name;
+                const body = ('body' in callback ? callback.body : null);
+                findInNode(body, (n) => {
+                    if (n.type === 'BinaryExpression' &&
+                        n.operator === '===' &&
+                        ((isFindIndexCall(n.left) && isIdent(n.right, indexName)) ||
+                            (isFindIndexCall(n.right) && isIdent(n.left, indexName)))) {
+                        context.report({ node, messageId: 'quadraticDedup' });
+                        return true;
+                    }
+                    return false;
+                });
+            },
+        };
+    },
+};
+export default rule;
+function isFindIndexCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name === 'findIndex');
+}
+function isIdent(node, name) {
+    return node.type === 'Identifier' && node.name === name;
+}
+function findInNode(node, visitor) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            if (findInNode(child, visitor))
+                return true;
+        }
+        return false;
+    }
+    if (!('type' in node))
+        return false;
+    if (visitor(node))
+        return true;
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const child = node[key];
+        if (child && typeof child === 'object') {
+            if (findInNode(child, visitor))
+                return true;
+        }
+    }
+    return false;
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "eslint-plugin-big-o",
+  "version": "1.0.0",
+  "description": "ESLint rules for detecting algorithmic complexity issues (Big-O)",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "big-o",
+    "complexity",
+    "performance"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adrianbrowning/eslint-plugin-big-o.git"
+  },
+  "bugs": {
+    "url": "https://github.com/adrianbrowning/eslint-plugin-big-o/issues"
+  },
+  "homepage": "https://github.com/adrianbrowning/eslint-plugin-big-o#readme",
+  "author": "Adrian Elton-Browning",
+  "license": "ISC",
+  "type": "module",
+  "zshy": {
+    "exports": {
+      ".": "./index.ts"
+    },
+    "cjs": false
+  },
+  "scripts": {
+    "build": "zshy",
+    "test": "vitest run",
+    "lint:ts": "tsc --noEmit",
+    "lint:esl": "eslint --config eslint.config.ts . --cache --max-warnings=0",
+    "lint:s": "eslint --config eslint.config.style.ts . --cache --max-warnings=0",
+    "lint:fix": "pnpm lint:s --fix",
+    "lint:knip": "knip",
+    "lint:jscpd": "jscpd .",
+    "lint": "pnpm lint:ts && pnpm lint:fix",
+    "lint:e18e": "pnpm dlx @e18e/cli analyze"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "packageManager": "pnpm@10.33.4",
+  "devDependencies": {
+    "@commitlint/cli": "20.0.0",
+    "@commitlint/config-conventional": "20.0.0",
+    "@gingacodemonkey/config": "^0.0.32",
+    "@types/eslint": "^9.6.1",
+    "@types/estree": "^1.0.9",
+    "@types/node": "^24.13.2",
+    "eslint": "^9.39.4",
+    "husky": "9.0.6",
+    "jscpd": "^4.2.5",
+    "knip": "5.70.1",
+    "lint-staged": "15.2.10",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8",
+    "zshy": "latest"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320
+  },
+  "engines": {
+    "node": ">=24.0.0",
+    "pnpm": ">=10.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  }
+}