@antithrow/eslint-plugin 1.1.0 → 1.2.1

package/README.md

@@ -1,11 +1,12 @@
 <div align="center">
 	<h1>@antithrow/eslint-plugin</h1>
 	<p>
-		ESLint rules for <a href="https://github.com/jack-weilage/antithrow">antithrow</a> Result types
+		ESLint rules for <a href="https://github.com/antithrow/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
@@ -40,6 +41,7 @@ export default [
       "@antithrow": antithrow,
     },
     rules: {
+      "@antithrow/no-throwing-call": "warn",
       "@antithrow/no-unsafe-unwrap": "warn",
       "@antithrow/no-unused-result": "error",
     },
@@ -49,7 +51,8 @@ export default [
 
 ## Rules
 
-| Rule | Description | Recommended |
-| --- | --- | --- |
-| [`no-unsafe-unwrap`](./docs/rules/no-unsafe-unwrap.md) | Disallow `unwrap`/`expect` APIs on antithrow `Result` values | `warn` |
-| [`no-unused-result`](./docs/rules/no-unused-result.md) | Require `Result` and `ResultAsync` values to be used | `error` |
+| Rule                                                   | Description                                                                 | Recommended |
+| ------------------------------------------------------ | --------------------------------------------------------------------------- | ----------- |
+| [`no-throwing-call`](https://antithrow.dev/docs/api/eslint-plugin/no-throwing-call) | Disallow calls to throwing built-in APIs with `@antithrow/std` replacements | `warn`      |
+| [`no-unsafe-unwrap`](https://antithrow.dev/docs/api/eslint-plugin/no-unsafe-unwrap) | Disallow `unwrap`/`expect` APIs on antithrow `Result` values                | `warn`      |
+| [`no-unused-result`](https://antithrow.dev/docs/api/eslint-plugin/no-unused-result) | Require `Result` and `ResultAsync` values to be used                        | `error`     |

package/dist/create-rule.js

@@ -1,2 +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`);
+export const createRule = ESLintUtils.RuleCreator((name) => `https://antithrow.dev/docs/api/eslint-plugin/${name}`);

package/dist/index.js

@@ -1,11 +1,12 @@
 import packageJson from "../package.json" with { type: "json" };
-import { noUnsafeUnwrap, noUnusedResult } from "./rules/index.js";
+import { noThrowingCall, noUnsafeUnwrap, noUnusedResult } from "./rules/index.js";
 const plugin = {
     meta: {
         name: packageJson.name,
         version: packageJson.version,
     },
     rules: {
+        "no-throwing-call": noThrowingCall,
         "no-unsafe-unwrap": noUnsafeUnwrap,
         "no-unused-result": noUnusedResult,
     },
@@ -18,6 +19,7 @@ plugin.configs = {
             "@antithrow": plugin,
         },
         rules: {
+            "@antithrow/no-throwing-call": "warn",
             "@antithrow/no-unsafe-unwrap": "warn",
             "@antithrow/no-unused-result": "error",
         },

package/dist/rules/index.d.ts

@@ -1,2 +1,3 @@
+export { noThrowingCall } from "./no-throwing-call.js";
 export { noUnsafeUnwrap } from "./no-unsafe-unwrap.js";
 export { noUnusedResult } from "./no-unused-result.js";

package/dist/rules/index.js

@@ -1,2 +1,3 @@
+export { noThrowingCall } from "./no-throwing-call.js";
 export { noUnsafeUnwrap } from "./no-unsafe-unwrap.js";
 export { noUnusedResult } from "./no-unused-result.js";

package/dist/rules/no-throwing-call.d.ts

@@ -0,0 +1,9 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+/** @lintignore */
+export declare const MessageId: {
+    readonly THROWING_CALL: "throwingCall";
+};
+export type MessageId = (typeof MessageId)[keyof typeof MessageId];
+export declare const noThrowingCall: ESLintUtils.RuleModule<"throwingCall", [], import("../create-rule.js").AntithrowPluginDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-throwing-call.js

@@ -0,0 +1,192 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { createRule } from "../create-rule.js";
+/** @lintignore */
+export const MessageId = {
+    THROWING_CALL: "throwingCall",
+};
+const BANNED_GLOBAL_CALLS = new Set([
+    "fetch",
+    "atob",
+    "btoa",
+    "structuredClone",
+    "decodeURI",
+    "decodeURIComponent",
+    "encodeURI",
+    "encodeURIComponent",
+    "JSON.parse",
+    "JSON.stringify",
+]);
+const RESPONSE_BODY_METHODS = new Set(["json", "text", "arrayBuffer", "blob", "formData"]);
+const GLOBAL_OBJECTS = new Set(["globalThis", "window", "self"]);
+const NULLISH_TYPE_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+/**
+ * Extracts the property name from a `MemberExpression` when it can be
+ * statically determined. Handles `obj.prop`, `obj["prop"]`, and
+ * `` obj[`prop`] `` (template literals with no interpolations).
+ * Returns `null` for dynamic access like `obj[variable]`.
+ */
+function getStaticMemberName(node) {
+    if (!node.computed && node.property.type === "Identifier") {
+        return node.property.name;
+    }
+    if (node.computed &&
+        node.property.type === "Literal" &&
+        typeof node.property.value === "string") {
+        return node.property.value;
+    }
+    if (node.computed &&
+        node.property.type === "TemplateLiteral" &&
+        node.property.expressions.length === 0) {
+        const [quasi] = node.property.quasis;
+        return quasi?.value.cooked ?? null;
+    }
+    return null;
+}
+function isImplicitGlobal(name, scope) {
+    let current = scope;
+    while (current) {
+        const variable = current.set.get(name);
+        if (variable) {
+            return variable.defs.length === 0;
+        }
+        current = current.upper;
+    }
+    return true;
+}
+function collectStaticMemberPath(node) {
+    const propertyName = getStaticMemberName(node);
+    if (!propertyName) {
+        return null;
+    }
+    if (node.object.type === "Identifier") {
+        return {
+            segments: [node.object.name, propertyName],
+            rootIdentifier: node.object,
+        };
+    }
+    if (node.object.type !== "MemberExpression") {
+        return null;
+    }
+    const parentPath = collectStaticMemberPath(node.object);
+    if (!parentPath) {
+        return null;
+    }
+    return {
+        segments: [...parentPath.segments, propertyName],
+        rootIdentifier: parentPath.rootIdentifier,
+    };
+}
+function getStaticCalleePath(callee) {
+    if (callee.type === "Identifier") {
+        return {
+            segments: [callee.name],
+            rootIdentifier: callee,
+            memberExpression: null,
+        };
+    }
+    if (callee.type !== "MemberExpression") {
+        return null;
+    }
+    const memberPath = collectStaticMemberPath(callee);
+    if (!memberPath) {
+        return null;
+    }
+    return {
+        segments: memberPath.segments,
+        rootIdentifier: memberPath.rootIdentifier,
+        memberExpression: callee,
+    };
+}
+function normalizeGlobalPath(calleePath, scope) {
+    // Invariant: getStaticCalleePath always returns at least one segment.
+    const [root = "", ...rest] = calleePath.segments;
+    if (GLOBAL_OBJECTS.has(root)) {
+        if (!isImplicitGlobal(root, scope)) {
+            return null;
+        }
+        return rest.length > 0 ? rest : null;
+    }
+    if (!isImplicitGlobal(root, scope)) {
+        return null;
+    }
+    return calleePath.segments;
+}
+function containsGlobalResponseType(type, globalResponseType, checker) {
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((member) => containsGlobalResponseType(member, globalResponseType, checker));
+    }
+    const flags = type.getFlags();
+    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | NULLISH_TYPE_FLAGS)) {
+        return false;
+    }
+    if (checker.isTypeAssignableTo(type, globalResponseType)) {
+        return true;
+    }
+    const constraint = checker.getBaseConstraintOfType(type);
+    if (constraint && constraint !== type) {
+        return containsGlobalResponseType(constraint, globalResponseType, checker);
+    }
+    return false;
+}
+export const noThrowingCall = createRule({
+    name: "no-throwing-call",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow calls to known throwing built-in APIs that have @antithrow/std replacements.",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        messages: {
+            [MessageId.THROWING_CALL]: "`{{ api }}` can throw. A non-throwing wrapper is available from `@antithrow/std`.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        const globalResponseSymbol = checker.resolveName("Response", undefined, ts.SymbolFlags.Type, false);
+        const globalResponseType = globalResponseSymbol
+            ? checker.getDeclaredTypeOfSymbol(globalResponseSymbol)
+            : null;
+        return {
+            CallExpression(node) {
+                const calleePath = getStaticCalleePath(node.callee);
+                if (!calleePath) {
+                    return;
+                }
+                const rootScope = context.sourceCode.getScope(calleePath.rootIdentifier);
+                const normalizedGlobalPath = normalizeGlobalPath(calleePath, rootScope);
+                if (normalizedGlobalPath) {
+                    const api = normalizedGlobalPath.join(".");
+                    if (BANNED_GLOBAL_CALLS.has(api)) {
+                        context.report({
+                            node,
+                            messageId: MessageId.THROWING_CALL,
+                            data: { api },
+                        });
+                        return;
+                    }
+                }
+                const methodName = calleePath.segments[calleePath.segments.length - 1];
+                const { memberExpression } = calleePath;
+                if (methodName &&
+                    memberExpression &&
+                    RESPONSE_BODY_METHODS.has(methodName) &&
+                    globalResponseType) {
+                    const tsNode = services.esTreeNodeToTSNodeMap.get(memberExpression.object);
+                    const type = checker.getTypeAtLocation(tsNode);
+                    if (containsGlobalResponseType(type, globalResponseType, checker)) {
+                        context.report({
+                            node,
+                            messageId: MessageId.THROWING_CALL,
+                            data: { api: `response.${methodName}` },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-unsafe-unwrap.js

@@ -100,7 +100,7 @@ export const noUnsafeUnwrap = createRule({
         return {
             MemberExpression(node) {
                 const method = getStaticMemberName(node);
-                if (!method || !BANNED_METHOD_NAMES.has(method)) {
+                if (!(method && BANNED_METHOD_NAMES.has(method))) {
                     return;
                 }
                 const tsNode = services.esTreeNodeToTSNodeMap.get(node.object);
@@ -153,7 +153,7 @@ export const noUnsafeUnwrap = createRule({
                     return;
                 }
                 const method = getDestructuredPropertyName(node);
-                if (!method || !BANNED_METHOD_NAMES.has(method)) {
+                if (!(method && BANNED_METHOD_NAMES.has(method))) {
                     return;
                 }
                 // Resolve the node whose type represents the value being destructured.

package/dist/rules/utils/result-type.js

@@ -31,7 +31,7 @@ function collectResultTypes(type, collection) {
         return;
     }
     const symbol = type.getSymbol();
-    if (!symbol || !isAntithrowResultTypeSymbol(symbol)) {
+    if (!(symbol && isAntithrowResultTypeSymbol(symbol))) {
         collection.hasNonResultMembers = true;
         return;
     }

package/package.json

@@ -1,21 +1,28 @@
 {
 	"name": "@antithrow/eslint-plugin",
-	"version": "1.1.0",
+	"version": "1.2.1",
 	"description": "ESLint plugin for antithrow Result types",
 	"license": "MIT",
 	"author": "Jack Weilage",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/jack-weilage/antithrow.git",
+		"url": "git+https://github.com/antithrow/antithrow.git",
 		"directory": "packages/eslint-plugin"
 	},
+	"homepage": "https://antithrow.dev",
+	"bugs": {
+		"url": "https://github.com/antithrow/antithrow/issues"
+	},
 	"keywords": [
+		"antithrow",
 		"eslint",
 		"eslintplugin",
+		"eslint-plugin",
 		"result",
 		"error-handling",
 		"typescript"
 	],
+	"sideEffects": false,
 	"type": "module",
 	"exports": {
 		".": {
@@ -41,7 +48,7 @@
 	"devDependencies": {
 		"@typescript-eslint/parser": "8.54.0",
 		"@typescript-eslint/rule-tester": "8.54.0",
-		"antithrow": "workspace:*",
+		"antithrow": "workspace:^",
 		"eslint": "9.39.2",
 		"typescript": "5.9.3"
 	},