@antithrow/eslint-plugin 0.0.0

package/README.md

@@ -0,0 +1,53 @@
+<div align="center">
+	<h1>@antithrow/eslint-plugin</h1>
+	<p>
+		ESLint rules for <a href="https://github.com/jack-weilage/antithrow">antithrow</a> Result types
+	</p>
+
+![NPM Version](https://img.shields.io/npm/v/@antithrow/eslint-plugin)
+![NPM License](https://img.shields.io/npm/l/@antithrow/eslint-plugin)
+</div>
+
+## Installation
+
+```bash
+bun add -d @antithrow/eslint-plugin
+```
+
+This plugin requires [typed linting](https://typescript-eslint.io/getting-started/typed-linting/) to be configured.
+
+## Usage
+
+Add the recommended config to your `eslint.config.ts`:
+
+```ts
+import antithrow from "@antithrow/eslint-plugin";
+
+export default [
+	// ... your other configs
+	antithrow.configs.recommended,
+];
+```
+
+Or configure rules individually:
+
+```ts
+import antithrow from "@antithrow/eslint-plugin";
+
+export default [
+	{
+		plugins: {
+			"@antithrow": antithrow,
+		},
+		rules: {
+			"@antithrow/no-unused-result": "error",
+		},
+	},
+];
+```
+
+## Rules
+
+| Rule | Description | Recommended |
+| --- | --- | --- |
+| [`no-unused-result`](./docs/rules/no-unused-result.md) | Require `Result` and `ResultAsync` values to be used | `error` |

package/dist/create-rule.d.ts

@@ -0,0 +1,10 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+/** @lintignore */
+export interface AntithrowPluginDocs {
+    description: string;
+    recommended?: boolean;
+    requiresTypeChecking?: boolean;
+}
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, AntithrowPluginDocs>>) => ESLintUtils.RuleModule<MessageIds, Options, AntithrowPluginDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/create-rule.js

@@ -0,0 +1,2 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/jack-weilage/antithrow/blob/main/packages/eslint-plugin/docs/rules/${name}.md`);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+type Plugin = TSESLint.FlatConfig.Plugin & {
+    configs: Record<string, TSESLint.FlatConfig.Config>;
+};
+declare const plugin: Plugin;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,24 @@
+import packageJson from "../package.json" with { type: "json" };
+import { noUnusedResult } from "./rules/index.js";
+const plugin = {
+    meta: {
+        name: packageJson.name,
+        version: packageJson.version,
+    },
+    rules: {
+        "no-unused-result": noUnusedResult,
+    },
+    configs: {},
+};
+plugin.configs = {
+    ...plugin.configs,
+    recommended: {
+        plugins: {
+            "@antithrow": plugin,
+        },
+        rules: {
+            "@antithrow/no-unused-result": "error",
+        },
+    },
+};
+export default plugin;

package/dist/rules/index.d.ts

@@ -0,0 +1 @@
+export { noUnusedResult } from "./no-unused-result.js";

package/dist/rules/index.js

@@ -0,0 +1 @@
+export { noUnusedResult } from "./no-unused-result.js";

package/dist/rules/no-unused-result.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const noUnusedResult: ESLintUtils.RuleModule<"unusedResult", [], import("../create-rule.js").AntithrowPluginDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-unused-result.js

@@ -0,0 +1,85 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { createRule } from "../create-rule.js";
+const RESULT_TYPE_NAMES = new Set(["Ok", "Err", "ResultAsync"]);
+function isResultType(type) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isResultType(t));
+    }
+    const flags = type.getFlags();
+    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+        return false;
+    }
+    const symbol = type.getSymbol();
+    if (!symbol || !RESULT_TYPE_NAMES.has(symbol.getName())) {
+        return false;
+    }
+    const declarations = symbol.getDeclarations() ?? [];
+    return declarations.some((decl) => {
+        const sourceFile = decl.getSourceFile();
+        return sourceFile.fileName.includes("antithrow");
+    });
+}
+export const noUnusedResult = createRule({
+    name: "no-unused-result",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require Result and ResultAsync values to be used, preventing silently ignored errors.",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        messages: {
+            unusedResult: "This Result must be used. Handle the error case or explicitly discard it with `void`.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        function checkExpression(node) {
+            switch (node.type) {
+                case "UnaryExpression":
+                    if (node.operator === "void") {
+                        return;
+                    }
+                    break;
+                case "ConditionalExpression":
+                    checkExpression(node.consequent);
+                    checkExpression(node.alternate);
+                    return;
+                case "LogicalExpression":
+                    checkExpression(node.left);
+                    checkExpression(node.right);
+                    return;
+                case "SequenceExpression":
+                    for (const expr of node.expressions) {
+                        checkExpression(expr);
+                    }
+                    return;
+                case "TSAsExpression":
+                case "TSNonNullExpression":
+                    checkExpression(node.expression);
+                    return;
+                case "ChainExpression":
+                    checkExpression(node.expression);
+                    return;
+            }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            if (!isResultType(type)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "unusedResult",
+            });
+        }
+        return {
+            ExpressionStatement(node) {
+                checkExpression(node.expression);
+            },
+        };
+    },
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@antithrow/eslint-plugin",
+	"version": "0.0.0",
+	"description": "ESLint plugin for antithrow Result types",
+	"license": "MIT",
+	"author": "Jack Weilage",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/jack-weilage/antithrow.git",
+		"directory": "packages/eslint-plugin"
+	},
+	"keywords": [
+		"eslint",
+		"eslintplugin",
+		"result",
+		"error-handling",
+		"typescript"
+	],
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"clean": "rm -rf dist",
+		"lint": "bun run lint:publint && bun run lint:types",
+		"lint:publint": "publint",
+		"lint:types": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@typescript-eslint/utils": "8.54.0"
+	},
+	"devDependencies": {
+		"@typescript-eslint/parser": "8.54.0",
+		"@typescript-eslint/rule-tester": "8.54.0",
+		"antithrow": "workspace:*",
+		"eslint": "9.39.2",
+		"typescript": "5.9.3"
+	},
+	"peerDependencies": {
+		"eslint": "^9.0.0",
+		"typescript": ">=5.0.0"
+	}
+}