@antithrow/eslint-plugin 1.2.0 → 1.2.1

package/README.md

@@ -6,6 +6,7 @@
 
 ![NPM Version](https://img.shields.io/npm/v/@antithrow/eslint-plugin)
 ![NPM License](https://img.shields.io/npm/l/@antithrow/eslint-plugin)
+
 </div>
 
 ## Installation
@@ -50,8 +51,8 @@ export default [
 
 ## Rules
 
-| Rule | Description | Recommended |
-| --- | --- | --- |
-| [`no-throwing-call`](./docs/rules/no-throwing-call.md) | Disallow calls to throwing built-in APIs with `@antithrow/std` replacements | `warn` |
-| [`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/antithrow/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/rules/no-throwing-call.js

@@ -5,7 +5,7 @@ import { createRule } from "../create-rule.js";
 export const MessageId = {
     THROWING_CALL: "throwingCall",
 };
-const GLOBAL_FUNCTIONS = new Set([
+const BANNED_GLOBAL_CALLS = new Set([
     "fetch",
     "atob",
     "btoa",
@@ -14,8 +14,9 @@ const GLOBAL_FUNCTIONS = new Set([
     "decodeURIComponent",
     "encodeURI",
     "encodeURIComponent",
+    "JSON.parse",
+    "JSON.stringify",
 ]);
-const JSON_METHODS = new Set(["parse", "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;
@@ -53,8 +54,63 @@ function isImplicitGlobal(name, scope) {
     }
     return true;
 }
-function isImplicitGlobalObject(node, scope) {
-    return GLOBAL_OBJECTS.has(node.name) && isImplicitGlobal(node.name, scope);
+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()) {
@@ -97,66 +153,30 @@ export const noThrowingCall = createRule({
             : null;
         return {
             CallExpression(node) {
-                const callee = node.callee;
-                // fetch(), atob(), etc.
-                if (callee.type === "Identifier" && GLOBAL_FUNCTIONS.has(callee.name)) {
-                    const scope = context.sourceCode.getScope(callee);
-                    if (isImplicitGlobal(callee.name, scope)) {
-                        context.report({
-                            node,
-                            messageId: MessageId.THROWING_CALL,
-                            data: { api: callee.name },
-                        });
-                    }
-                    return;
-                }
-                if (callee.type !== "MemberExpression") {
+                const calleePath = getStaticCalleePath(node.callee);
+                if (!calleePath) {
                     return;
                 }
-                const methodName = getStaticMemberName(callee);
-                if (!methodName) {
-                    return;
-                }
-                // globalThis.fetch(), window.atob(), self.structuredClone(), etc.
-                if (GLOBAL_FUNCTIONS.has(methodName) &&
-                    callee.object.type === "Identifier" &&
-                    isImplicitGlobalObject(callee.object, context.sourceCode.getScope(callee.object))) {
-                    context.report({
-                        node,
-                        messageId: MessageId.THROWING_CALL,
-                        data: { api: methodName },
-                    });
-                    return;
-                }
-                // JSON.parse(), JSON.stringify()
-                if (JSON_METHODS.has(methodName) &&
-                    callee.object.type === "Identifier" &&
-                    callee.object.name === "JSON") {
-                    const scope = context.sourceCode.getScope(callee.object);
-                    if (isImplicitGlobal("JSON", scope)) {
+                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: `JSON.${methodName}` },
+                            data: { api },
                         });
+                        return;
                     }
-                    return;
-                }
-                // globalThis.JSON.parse(), window.JSON.stringify(), etc.
-                if (JSON_METHODS.has(methodName) &&
-                    callee.object.type === "MemberExpression" &&
-                    getStaticMemberName(callee.object) === "JSON" &&
-                    callee.object.object.type === "Identifier" &&
-                    isImplicitGlobalObject(callee.object.object, context.sourceCode.getScope(callee.object.object))) {
-                    context.report({
-                        node,
-                        messageId: MessageId.THROWING_CALL,
-                        data: { api: `JSON.${methodName}` },
-                    });
-                    return;
                 }
-                if (RESPONSE_BODY_METHODS.has(methodName) && globalResponseType) {
-                    const tsNode = services.esTreeNodeToTSNodeMap.get(callee.object);
+                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({

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,6 +1,6 @@
 {
 	"name": "@antithrow/eslint-plugin",
-	"version": "1.2.0",
+	"version": "1.2.1",
 	"description": "ESLint plugin for antithrow Result types",
 	"license": "MIT",
 	"author": "Jack Weilage",
@@ -9,13 +9,20 @@
 		"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"
 	},