eslint-plugin-ocavue 0.0.1 → 0.2.0

package/README.md

@@ -2,43 +2,71 @@
 
 [![NPM version](https://img.shields.io/npm/v/eslint-plugin-ocavue?color=a1b858&label=)](https://www.npmjs.com/package/eslint-plugin-ocavue)
 
-A minimal [TypeScript](https://www.typescriptlang.org/) library starter with bundling, testing, linting, formatting, and automated npm releases, all preconfigured.
+Custom [ESLint](https://eslint.org/) rules from [ocavue](https://github.com/ocavue).
 
-> **Using this template?** Click [Use this template](https://github.com/ocavue/starter-ts/generate), rename the package in `package.json`, and write your code in `src/index.ts`.
+## Usage
 
-## Project structure
+Requires ESLint 10 with flat config.
 
-- `src/`: source code, with co-located [Vitest](https://vitest.dev/) tests (`*.test.ts`)
-- `dist/`: bundled output (ESM + type declarations), built by [tsdown](https://tsdown.dev/)
+```sh
+pnpm add -D eslint-plugin-ocavue
+```
 
-## Scripts
+```js
+// eslint.config.js
+import ocavue from 'eslint-plugin-ocavue'
 
-Local development needs [Node.js](https://nodejs.org/) v22+ and [pnpm](https://pnpm.io/).
+export default [
+  {
+    plugins: { ocavue },
+    rules: {
+      'ocavue/no-implicit-arrow-linebreak': 'error',
+      'ocavue/prefer-while-true': 'error',
+    },
+  },
+]
+```
 
-| Command          | Description                                                                                                                |
-| ---------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| `pnpm dev`       | Rebuild on change (`tsdown --watch`)                                                                                       |
-| `pnpm build`     | Bundle the library to `dist/`                                                                                              |
-| `pnpm test`      | Run tests with [Vitest](https://vitest.dev/)                                                                               |
-| `pnpm lint`      | Lint with [ESLint](https://eslint.org/), [oxfmt](https://oxc.rs/docs/guide/usage/formatter), and [knip](https://knip.dev/) |
-| `pnpm fix`       | Auto-fix formatting and lint issues                                                                                        |
-| `pnpm typecheck` | Type-check with `tsc`                                                                                                      |
+## Rules
 
-## Publishing
+### `no-implicit-arrow-linebreak`
 
-Releases are automated with [release-please](https://github.com/googleapis/release-please) and npm [trusted publishing](https://docs.npmjs.com/trusted-publishers/) (OIDC). No tokens to manage.
+Disallow a linebreak between `=>` and an implicit arrow function body. Unlike [`@stylistic/implicit-arrow-linebreak`](https://eslint.style/rules/implicit-arrow-linebreak), whose fixer joins the two lines into one (which Prettier then breaks again whenever the joined line exceeds `printWidth`, so `eslint --fix` and the formatter never converge), this rule's fixer converts the body to a block body with `return`. A block body is a stable shape for Prettier and oxfmt, so one round of `eslint --fix` plus the formatter converges.
 
-1. **First release (manual).** OIDC can't create a brand-new package, so publish the first version by hand:
+```js
+// Incorrect
+const items = Array.from({ length: count }, (_, index) =>
+  createItem(index === 0 ? 'first item label' : `item number ${index}`),
+)
 
-   ```bash
-   pnpm login
-   pnpm build
-   pnpm publish
-   ```
+// Correct
+const short = (index) => createItem(`item number ${index}`)
 
-2. **Enable OIDC.** On [npmjs.com](https://www.npmjs.com/), open the package → **Settings → Trusted Publisher → GitHub Actions**, and set the workflow filename to `release.yml`.
+// Correct (what the fixer produces, after formatting)
+const items = Array.from({ length: count }, (_, index) => {
+  return createItem(index === 0 ? 'first item label' : `item number ${index}`)
+})
+```
 
-3. **Future releases (automatic).** Push [Conventional Commits](https://www.conventionalcommits.org/) (`fix:`, `feat:`, …) to your default branch (usually `master` or `main`); [release-please](https://github.com/googleapis/release-please) opens a release PR that bumps the version, updates the changelog, and publishes on merge.
+When a comment sits between `=>` and the body, the rule reports without autofixing so the fix never drops a comment.
+
+### `prefer-while-true`
+
+Enforce `while (true)` instead of `for (;;)` for infinite loops. Rules such as [`no-constant-condition`](https://eslint.org/docs/latest/rules/no-constant-condition) (with `checkLoops: "all"`) and [`@typescript-eslint/no-unnecessary-condition`](https://typescript-eslint.io/rules/no-unnecessary-condition) report `while (true)` but not `for (;;)`, so people often rewrite the loop as `for (;;)` to silence them. That only hides the infinite loop from the linter: the code still loops forever. This rule removes that workaround. `while (true)` also reads more clearly than `for (;;)`.
+
+```js
+// Incorrect
+for (;;) {
+  step()
+}
+
+// Correct (what the fixer produces)
+while (true) {
+  step()
+}
+```
+
+When a comment sits inside the loop head, the rule reports without autofixing so the fix never drops a comment.
 
 ## Sponsors
 

package/dist/index.d.ts

@@ -1,6 +1,14 @@
 //#region src/index.d.ts
-declare const one = 1;
-declare const two = 2;
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    'no-implicit-arrow-linebreak': import("eslint").Rule.RuleModule;
+    'prefer-while-true': import("eslint").Rule.RuleModule;
+  };
+};
 //#endregion
-export { one, two };
+export { plugin as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";cAAa;cACA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";cAOM"}

package/dist/index.js

@@ -1,7 +1,80 @@
+//#endregion
 //#region src/index.ts
-const one = 1;
-const two = 2;
+const plugin = {
+	meta: {
+		name: "eslint-plugin-ocavue",
+		version: "0.2.0"
+	},
+	rules: {
+		"no-implicit-arrow-linebreak": {
+			meta: {
+				type: "layout",
+				fixable: "code",
+				docs: {
+					description: "disallow a linebreak between `=>` and an implicit arrow function body, fixing it to a block body with `return`",
+					url: "https://github.com/ocavue/eslint-plugin-ocavue#no-implicit-arrow-linebreak"
+				},
+				messages: { linebreak: "Implicit arrow body must not start on a new line. Use a block body with `return` instead." },
+				schema: []
+			},
+			create(context) {
+				const sourceCode = context.sourceCode;
+				return { ArrowFunctionExpression(node) {
+					if (node.body.type === "BlockStatement") return;
+					const arrowToken = sourceCode.getTokenBefore(node.body, { filter: (token) => token.type === "Punctuator" && token.value === "=>" });
+					if (!arrowToken) return;
+					const firstBodyToken = sourceCode.getTokenAfter(arrowToken);
+					const lastToken = sourceCode.getLastToken(node);
+					if (!firstBodyToken || !lastToken) return;
+					if (arrowToken.loc.end.line === firstBodyToken.loc.start.line) return;
+					const canFix = !sourceCode.commentsExistBetween(arrowToken, firstBodyToken);
+					context.report({
+						node: node.body,
+						messageId: "linebreak",
+						fix: canFix ? (fixer) => {
+							const bodyText = sourceCode.text.slice(firstBodyToken.range[0], lastToken.range[1]);
+							return fixer.replaceTextRange([arrowToken.range[1], lastToken.range[1]], ` { return ${bodyText} }`);
+						} : void 0
+					});
+				} };
+			}
+		},
+		"prefer-while-true": {
+			meta: {
+				type: "suggestion",
+				fixable: "code",
+				docs: {
+					description: "enforce `while (true)` instead of `for (;;)` for infinite loops",
+					url: "https://github.com/ocavue/eslint-plugin-ocavue#prefer-while-true"
+				},
+				messages: { preferWhileTrue: "Use `while (true)` instead of `for (;;)`." },
+				schema: []
+			},
+			create(context) {
+				const sourceCode = context.sourceCode;
+				return { ForStatement(node) {
+					if (node.init || node.test || node.update) return;
+					const forToken = sourceCode.getFirstToken(node);
+					const closingParen = sourceCode.getTokenBefore(node.body);
+					if (!forToken || !closingParen) return;
+					const canFix = !sourceCode.commentsExistBetween(forToken, closingParen);
+					context.report({
+						node,
+						loc: {
+							start: forToken.loc.start,
+							end: closingParen.loc.end
+						},
+						messageId: "preferWhileTrue",
+						fix: canFix ? (fixer) => {
+							return fixer.replaceTextRange([forToken.range[0], closingParen.range[1]], "while (true)");
+						} : void 0
+					});
+				} };
+			}
+		}
+	}
+};
 //#endregion
-export { one, two };
+export { plugin as default };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export const one = 1\nexport const two = 2\n"],"mappings":";AAAA,MAAa,MAAM;AACnB,MAAa,MAAM"}
+{"version":3,"file":"index.js","names":["rule","noImplicitArrowLinebreak","preferWhileTrue"],"sources":["../package.json","../src/rules/no-implicit-arrow-linebreak.ts","../src/rules/prefer-while-true.ts","../src/index.ts"],"sourcesContent":["","import type { Rule } from 'eslint'\n\nconst rule: Rule.RuleModule = {\n  meta: {\n    type: 'layout',\n    fixable: 'code',\n    docs: {\n      description:\n        'disallow a linebreak between `=>` and an implicit arrow function body, fixing it to a block body with `return`',\n      url: 'https://github.com/ocavue/eslint-plugin-ocavue#no-implicit-arrow-linebreak',\n    },\n    messages: {\n      linebreak:\n        'Implicit arrow body must not start on a new line. Use a block body with `return` instead.',\n    },\n    schema: [],\n  },\n  create(context) {\n    const sourceCode = context.sourceCode\n    return {\n      ArrowFunctionExpression(node) {\n        if (node.body.type === 'BlockStatement') {\n          return\n        }\n\n        const arrowToken = sourceCode.getTokenBefore(node.body, {\n          filter: (token) => token.type === 'Punctuator' && token.value === '=>',\n        })\n        if (!arrowToken) {\n          return\n        }\n        const firstBodyToken = sourceCode.getTokenAfter(arrowToken)\n        // The last token of the arrow function. When the body is wrapped in\n        // parentheses, this is the closing `)`, so the fix keeps the parens.\n        const lastToken = sourceCode.getLastToken(node)\n        if (!firstBodyToken || !lastToken) {\n          return\n        }\n        if (arrowToken.loc.end.line === firstBodyToken.loc.start.line) {\n          return\n        }\n\n        // The fix rewrites the region between `=>` and the body, so bail out\n        // of fixing (but still report) if that region contains comments.\n        const canFix = !sourceCode.commentsExistBetween(arrowToken, firstBodyToken)\n\n        context.report({\n          node: node.body,\n          messageId: 'linebreak',\n          fix: canFix\n            ? (fixer) => {\n                const bodyText = sourceCode.text.slice(firstBodyToken.range[0], lastToken.range[1])\n                return fixer.replaceTextRange(\n                  [arrowToken.range[1], lastToken.range[1]],\n                  ` { return ${bodyText} }`,\n                )\n              }\n            : undefined,\n        })\n      },\n    }\n  },\n}\n\nexport default rule\n","import type { Rule } from 'eslint'\n\nconst rule: Rule.RuleModule = {\n  meta: {\n    type: 'suggestion',\n    fixable: 'code',\n    docs: {\n      description: 'enforce `while (true)` instead of `for (;;)` for infinite loops',\n      url: 'https://github.com/ocavue/eslint-plugin-ocavue#prefer-while-true',\n    },\n    messages: {\n      preferWhileTrue: 'Use `while (true)` instead of `for (;;)`.',\n    },\n    schema: [],\n  },\n  create(context) {\n    const sourceCode = context.sourceCode\n    return {\n      ForStatement(node) {\n        if (node.init || node.test || node.update) {\n          return\n        }\n\n        const forToken = sourceCode.getFirstToken(node)\n        const closingParen = sourceCode.getTokenBefore(node.body)\n        if (!forToken || !closingParen) {\n          return\n        }\n\n        // Bail out of fixing (but still report) if the loop head contains\n        // comments, so the fix never drops a comment.\n        const canFix = !sourceCode.commentsExistBetween(forToken, closingParen)\n\n        context.report({\n          node,\n          loc: { start: forToken.loc.start, end: closingParen.loc.end },\n          messageId: 'preferWhileTrue',\n          fix: canFix\n            ? (fixer) => {\n                return fixer.replaceTextRange(\n                  [forToken.range[0], closingParen.range[1]],\n                  'while (true)',\n                )\n              }\n            : undefined,\n        })\n      },\n    }\n  },\n}\n\nexport default rule\n","import type { ESLint } from 'eslint'\n\nimport { version } from '../package.json'\n\nimport noImplicitArrowLinebreak from './rules/no-implicit-arrow-linebreak'\nimport preferWhileTrue from './rules/prefer-while-true'\n\nconst plugin = {\n  meta: {\n    name: 'eslint-plugin-ocavue',\n    version,\n  },\n  rules: {\n    'no-implicit-arrow-linebreak': noImplicitArrowLinebreak,\n    'prefer-while-true': preferWhileTrue,\n  },\n} satisfies ESLint.Plugin\n\nexport default plugin\n"],"mappings":";;AGOA,MAAM,SAAS;CACb,MAAM;EACJ,MAAM;EACN;CACF;CACA,OAAO;EACL,+BAA+BC;GFVjC,MAAM;IACJ,MAAM;IACN,SAAS;IACT,MAAM;KACJ,aACE;KACF,KAAK;IACP;IACA,UAAU,EACR,WACE,4FACJ;IACA,QAAQ,CAAC;GACX;GACA,OAAO,SAAS;IACd,MAAM,aAAa,QAAQ;IAC3B,OAAO,EACL,wBAAwB,MAAM;KAC5B,IAAI,KAAK,KAAK,SAAS,kBACrB;KAGF,MAAM,aAAa,WAAW,eAAe,KAAK,MAAM,EACtD,SAAS,UAAU,MAAM,SAAS,gBAAgB,MAAM,UAAU,KACpE,CAAC;KACD,IAAI,CAAC,YACH;KAEF,MAAM,iBAAiB,WAAW,cAAc,UAAU;KAG1D,MAAM,YAAY,WAAW,aAAa,IAAI;KAC9C,IAAI,CAAC,kBAAkB,CAAC,WACtB;KAEF,IAAI,WAAW,IAAI,IAAI,SAAS,eAAe,IAAI,MAAM,MACvD;KAKF,MAAM,SAAS,CAAC,WAAW,qBAAqB,YAAY,cAAc;KAE1E,QAAQ,OAAO;MACb,MAAM,KAAK;MACX,WAAW;MACX,KAAK,UACA,UAAU;OACT,MAAM,WAAW,WAAW,KAAK,MAAM,eAAe,MAAM,IAAI,UAAU,MAAM,EAAE;OAClF,OAAO,MAAM,iBACX,CAAC,WAAW,MAAM,IAAI,UAAU,MAAM,EAAE,GACxC,aAAa,SAAS,GACxB;MACF,IACA,KAAA;KACN,CAAC;IACH,EACF;GACF;EEhDiCA;EAC/B,qBAAqBC;GDXvB,MAAM;IACJ,MAAM;IACN,SAAS;IACT,MAAM;KACJ,aAAa;KACb,KAAK;IACP;IACA,UAAU,EACR,iBAAiB,4CACnB;IACA,QAAQ,CAAC;GACX;GACA,OAAO,SAAS;IACd,MAAM,aAAa,QAAQ;IAC3B,OAAO,EACL,aAAa,MAAM;KACjB,IAAI,KAAK,QAAQ,KAAK,QAAQ,KAAK,QACjC;KAGF,MAAM,WAAW,WAAW,cAAc,IAAI;KAC9C,MAAM,eAAe,WAAW,eAAe,KAAK,IAAI;KACxD,IAAI,CAAC,YAAY,CAAC,cAChB;KAKF,MAAM,SAAS,CAAC,WAAW,qBAAqB,UAAU,YAAY;KAEtE,QAAQ,OAAO;MACb;MACA,KAAK;OAAE,OAAO,SAAS,IAAI;OAAO,KAAK,aAAa,IAAI;MAAI;MAC5D,WAAW;MACX,KAAK,UACA,UAAU;OACT,OAAO,MAAM,iBACX,CAAC,SAAS,MAAM,IAAI,aAAa,MAAM,EAAE,GACzC,cACF;MACF,IACA,KAAA;KACN,CAAC;IACH,EACF;GACF;EClCuBA;CACvB;AACF"}

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "eslint-plugin-ocavue",
   "type": "module",
-  "version": "0.0.1",
-  "description": "TypeScript starter kit",
+  "version": "0.2.0",
+  "description": "Custom ESLint rules from ocavue",
   "author": "ocavue <ocavue@gmail.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/ocavue",
-  "homepage": "https://github.com/ocavue/starter-ts#readme",
+  "homepage": "https://github.com/ocavue/eslint-plugin-ocavue#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ocavue/starter-ts.git"
+    "url": "https://github.com/ocavue/eslint-plugin-ocavue.git"
   },
-  "bugs": "https://github.com/ocavue/starter-ts/issues",
-  "keywords": [],
+  "bugs": "https://github.com/ocavue/eslint-plugin-ocavue/issues",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -27,17 +31,19 @@
     "dist",
     "src"
   ],
+  "peerDependencies": {
+    "eslint": "^10.0.0"
+  },
   "devDependencies": {
-    "@ocavue/eslint-config": "^4.13.5",
+    "@ocavue/eslint-config": "^4.22.0",
     "@ocavue/tsconfig": "^0.7.1",
     "@types/node": "^24.0.0",
-    "eslint": "^10.9.1",
-    "knip": "^6.33.0",
-    "oxfmt": "^0.65.0",
-    "tsdown": "^0.22.14",
+    "eslint": "^10.14.0",
+    "knip": "^6.41.0",
+    "oxfmt": "^0.73.0",
+    "tsdown": "^0.23.1",
     "typescript": "^6.0.3",
-    "vite": "^8.2.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.5"
   },
   "scripts": {
     "build": "tsdown",

package/src/index.ts

@@ -1,2 +1,19 @@
-export const one = 1
-export const two = 2
+import type { ESLint } from 'eslint'
+
+import { version } from '../package.json'
+
+import noImplicitArrowLinebreak from './rules/no-implicit-arrow-linebreak'
+import preferWhileTrue from './rules/prefer-while-true'
+
+const plugin = {
+  meta: {
+    name: 'eslint-plugin-ocavue',
+    version,
+  },
+  rules: {
+    'no-implicit-arrow-linebreak': noImplicitArrowLinebreak,
+    'prefer-while-true': preferWhileTrue,
+  },
+} satisfies ESLint.Plugin
+
+export default plugin

package/src/rules/no-implicit-arrow-linebreak.test.ts

@@ -0,0 +1,53 @@
+import { RuleTester } from 'eslint'
+import { test } from 'vitest'
+
+import rule from './no-implicit-arrow-linebreak'
+
+test('no-implicit-arrow-linebreak', () => {
+  const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  })
+
+  tester.run('no-implicit-arrow-linebreak', rule, {
+    valid: [
+      'const f = () => fn(123)',
+      'const f = () => {\n  return fn(123)\n}',
+      'const f = () => (\n  fn(123)\n)',
+      'const f = async () => fn(123)',
+      'const f = (a) => (b) => a + b',
+    ],
+    invalid: [
+      {
+        code: 'const f = () =>\n  fn(123)',
+        output: 'const f = () => { return fn(123) }',
+        errors: [{ messageId: 'linebreak' }],
+      },
+      {
+        code: 'const f = () =>\n  (fn(123))',
+        output: 'const f = () => { return (fn(123)) }',
+        errors: [{ messageId: 'linebreak' }],
+      },
+      {
+        code: 'const f = (a, b) =>\n  a + b',
+        output: 'const f = (a, b) => { return a + b }',
+        errors: [{ messageId: 'linebreak' }],
+      },
+      {
+        code: 'const f = async (a) =>\n  await fn(a)',
+        output: 'const f = async (a) => { return await fn(a) }',
+        errors: [{ messageId: 'linebreak' }],
+      },
+      {
+        code: 'const f = (a) => (b) =>\n  a + b',
+        output: 'const f = (a) => (b) => { return a + b }',
+        errors: [{ messageId: 'linebreak' }],
+      },
+      {
+        // No autofix when a comment sits between `=>` and the body.
+        code: 'const f = () => // note\n  fn(123)',
+        output: null,
+        errors: [{ messageId: 'linebreak' }],
+      },
+    ],
+  })
+})

package/src/rules/no-implicit-arrow-linebreak.ts

@@ -0,0 +1,65 @@
+import type { Rule } from 'eslint'
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'layout',
+    fixable: 'code',
+    docs: {
+      description:
+        'disallow a linebreak between `=>` and an implicit arrow function body, fixing it to a block body with `return`',
+      url: 'https://github.com/ocavue/eslint-plugin-ocavue#no-implicit-arrow-linebreak',
+    },
+    messages: {
+      linebreak:
+        'Implicit arrow body must not start on a new line. Use a block body with `return` instead.',
+    },
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode
+    return {
+      ArrowFunctionExpression(node) {
+        if (node.body.type === 'BlockStatement') {
+          return
+        }
+
+        const arrowToken = sourceCode.getTokenBefore(node.body, {
+          filter: (token) => token.type === 'Punctuator' && token.value === '=>',
+        })
+        if (!arrowToken) {
+          return
+        }
+        const firstBodyToken = sourceCode.getTokenAfter(arrowToken)
+        // The last token of the arrow function. When the body is wrapped in
+        // parentheses, this is the closing `)`, so the fix keeps the parens.
+        const lastToken = sourceCode.getLastToken(node)
+        if (!firstBodyToken || !lastToken) {
+          return
+        }
+        if (arrowToken.loc.end.line === firstBodyToken.loc.start.line) {
+          return
+        }
+
+        // The fix rewrites the region between `=>` and the body, so bail out
+        // of fixing (but still report) if that region contains comments.
+        const canFix = !sourceCode.commentsExistBetween(arrowToken, firstBodyToken)
+
+        context.report({
+          node: node.body,
+          messageId: 'linebreak',
+          fix: canFix
+            ? (fixer) => {
+                const bodyText = sourceCode.text.slice(firstBodyToken.range[0], lastToken.range[1])
+                return fixer.replaceTextRange(
+                  [arrowToken.range[1], lastToken.range[1]],
+                  ` { return ${bodyText} }`,
+                )
+              }
+            : undefined,
+        })
+      },
+    }
+  },
+}
+
+export default rule

package/src/rules/prefer-while-true.test.ts

@@ -0,0 +1,43 @@
+import { RuleTester } from 'eslint'
+import { test } from 'vitest'
+
+import rule from './prefer-while-true'
+
+test('prefer-while-true', () => {
+  const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  })
+
+  tester.run('prefer-while-true', rule, {
+    valid: [
+      'while (true) {}',
+      'for (let i = 0; i < 10; i++) {}',
+      'for (; i < 10; ) {}',
+      'for (let i = 0; ; i++) {}',
+      'for (const x of xs) {}',
+    ],
+    invalid: [
+      {
+        code: 'for (;;) {\n  fn()\n}',
+        output: 'while (true) {\n  fn()\n}',
+        errors: [{ messageId: 'preferWhileTrue' }],
+      },
+      {
+        code: 'for ( ; ; ) fn()',
+        output: 'while (true) fn()',
+        errors: [{ messageId: 'preferWhileTrue' }],
+      },
+      {
+        code: 'outer: for (;;) {\n  for (;;) break outer\n}',
+        output: 'outer: while (true) {\n  while (true) break outer\n}',
+        errors: [{ messageId: 'preferWhileTrue' }, { messageId: 'preferWhileTrue' }],
+      },
+      {
+        // No autofix when a comment sits inside the loop head.
+        code: 'for (; /* forever */ ;) {}',
+        output: null,
+        errors: [{ messageId: 'preferWhileTrue' }],
+      },
+    ],
+  })
+})

package/src/rules/prefer-while-true.ts

@@ -0,0 +1,52 @@
+import type { Rule } from 'eslint'
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description: 'enforce `while (true)` instead of `for (;;)` for infinite loops',
+      url: 'https://github.com/ocavue/eslint-plugin-ocavue#prefer-while-true',
+    },
+    messages: {
+      preferWhileTrue: 'Use `while (true)` instead of `for (;;)`.',
+    },
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode
+    return {
+      ForStatement(node) {
+        if (node.init || node.test || node.update) {
+          return
+        }
+
+        const forToken = sourceCode.getFirstToken(node)
+        const closingParen = sourceCode.getTokenBefore(node.body)
+        if (!forToken || !closingParen) {
+          return
+        }
+
+        // Bail out of fixing (but still report) if the loop head contains
+        // comments, so the fix never drops a comment.
+        const canFix = !sourceCode.commentsExistBetween(forToken, closingParen)
+
+        context.report({
+          node,
+          loc: { start: forToken.loc.start, end: closingParen.loc.end },
+          messageId: 'preferWhileTrue',
+          fix: canFix
+            ? (fixer) => {
+                return fixer.replaceTextRange(
+                  [forToken.range[0], closingParen.range[1]],
+                  'while (true)',
+                )
+              }
+            : undefined,
+        })
+      },
+    }
+  },
+}
+
+export default rule

package/src/index.test.ts

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-describe('should', () => {
-  it('exported', () => {
-    expect(1).toEqual(1)
-  })
-})