eslint-plugin-react-web-api 5.2.5-next.1 → 5.3.0-next.0

package/dist/index.js

@@ -4,10 +4,10 @@ import * as core from "@eslint-react/core";
 import { merge } from "@eslint-react/eslint";
 import { isAssignmentTargetEqual, isValueEqual, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { P, isMatching, match } from "ts-pattern";
 import birecord from "birecord";
 import { ESLintUtils } from "@typescript-eslint/utils";
+import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -28,7 +28,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-react-web-api";
-var version = "5.2.5-next.1";
+var version = "5.3.0-next.0";
 
 //#endregion
 //#region src/types/component-phase.ts
@@ -46,46 +46,33 @@ const createRule = ESLintUtils.RuleCreator(getDocsUrl);
 
 //#endregion
 //#region src/rules/no-leaked-event-listener/lib.ts
-function findProperty(of, named) {
+function findProperty$1(of, named) {
 	for (const property of of) {
 		if (property.type === AST_NODE_TYPES.Property && Extract.getPropertyName(property.key) === named) return property;
 		if (property.type === AST_NODE_TYPES.SpreadElement && property.argument.type === AST_NODE_TYPES.ObjectExpression) {
-			const found = findProperty(property.argument.properties, named);
+			const found = findProperty$1(property.argument.properties, named);
 			if (found != null) return found;
 		}
 	}
 	return null;
 }
-
-//#endregion
-//#region src/rules/no-leaked-event-listener/no-leaked-event-listener.ts
-const RULE_NAME$3 = "no-leaked-event-listener";
-const defaultOptions = {
-	capture: false,
-	signal: null
-};
-function getCallKind$3(node) {
-	switch (true) {
-		case node.callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("addEventListener", "removeEventListener", "abort"))(node.callee.name): return node.callee.name;
-		case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && isMatching(P.union("addEventListener", "removeEventListener", "abort"))(node.callee.property.name): return node.callee.property.name;
-		default: return "other";
-	}
-}
-function getFunctionKind$1(node) {
-	return getPhaseKindOfFunction(node) ?? "other";
-}
 function getSignalValueExpression(context, node) {
 	if (node == null) return null;
 	switch (node.type) {
 		case AST_NODE_TYPES.Identifier: {
 			const resolved = resolve(context, node);
-			if (resolved != null && Check.isFunction(resolved)) return node;
-			return getSignalValueExpression(context, resolved);
+			const unwrapped = resolved == null ? null : Extract.unwrap(resolved);
+			if (unwrapped != null && Check.isFunction(unwrapped)) return node;
+			return getSignalValueExpression(context, unwrapped);
 		}
 		case AST_NODE_TYPES.MemberExpression: return node;
 		default: return null;
 	}
 }
+const defaultOptions = {
+	capture: false,
+	signal: null
+};
 function getOptions(context, node) {
 	const initialScope = context.sourceCode.getScope(node);
 	function getOpts(node) {
@@ -100,14 +87,14 @@ function getOptions(context, node) {
 				capture: Boolean(node.value)
 			};
 			case AST_NODE_TYPES.ObjectExpression: {
-				const vCapture = match(findProperty(node.properties, "capture")).with(P.nullish, () => false).with({ type: AST_NODE_TYPES.Property }, (prop) => {
+				const vCapture = match(findProperty$1(node.properties, "capture")).with(P.nullish, () => false).with({ type: AST_NODE_TYPES.Property }, (prop) => {
 					const value = prop.value;
 					switch (value.type) {
 						case AST_NODE_TYPES.Literal: return Boolean(value.value);
 						default: return Boolean(getStaticValue(value, initialScope)?.value);
 					}
 				}).otherwise(() => false);
-				const pSignal = findProperty(node.properties, "signal");
+				const pSignal = findProperty$1(node.properties, "signal");
 				return {
 					capture: vCapture,
 					signal: pSignal?.type === AST_NODE_TYPES.Property ? getSignalValueExpression(context, pSignal.value) : null
@@ -118,6 +105,20 @@ function getOptions(context, node) {
 	}
 	return getOpts(node);
 }
+
+//#endregion
+//#region src/rules/no-leaked-event-listener/no-leaked-event-listener.ts
+const RULE_NAME$4 = "no-leaked-event-listener";
+function getCallKind$4(node) {
+	switch (true) {
+		case node.callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("addEventListener", "removeEventListener", "abort"))(node.callee.name): return node.callee.name;
+		case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && isMatching(P.union("addEventListener", "removeEventListener", "abort"))(node.callee.property.name): return node.callee.property.name;
+		default: return "other";
+	}
+}
+function getFunctionKind$1(node) {
+	return getPhaseKindOfFunction(node) ?? "other";
+}
 var no_leaked_event_listener_default = createRule({
 	meta: {
 		type: "problem",
@@ -128,11 +129,11 @@ var no_leaked_event_listener_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$3,
-	create: create$3,
+	name: RULE_NAME$4,
+	create: create$4,
 	defaultOptions: []
 });
-function create$3(context) {
+function create$4(context) {
 	if (!context.sourceCode.text.includes("addEventListener")) return {};
 	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const fEntries = [];
@@ -176,7 +177,7 @@ function create$3(context) {
 			const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
 			if (fKind == null) return;
 			if (!ComponentPhaseRelevance.has(fKind)) return;
-			match(getCallKind$3(node)).with("addEventListener", (callKind) => {
+			match(getCallKind$4(node)).with("addEventListener", (callKind) => {
 				if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && core.isAPIFromReactNative(node.callee.object.name, context.sourceCode.getScope(node))) return;
 				const [type, listener, options] = node.arguments;
 				if (type == null || listener == null) return;
@@ -230,6 +231,174 @@ function create$3(context) {
 	});
 }
 
+//#endregion
+//#region src/rules/no-leaked-fetch/lib.ts
+function findProperty(of, named) {
+	for (const property of of) {
+		if (property.type === AST_NODE_TYPES.Property && Extract.getPropertyName(property.key) === named) return property;
+		if (property.type === AST_NODE_TYPES.SpreadElement && property.argument.type === AST_NODE_TYPES.ObjectExpression) {
+			const found = findProperty(property.argument.properties, named);
+			if (found != null) return found;
+		}
+	}
+	return null;
+}
+function resolveToObjectExpression(context, node) {
+	node = Extract.unwrap(node);
+	switch (node.type) {
+		case AST_NODE_TYPES.ObjectExpression: return node;
+		case AST_NODE_TYPES.Identifier: {
+			let resolved = resolve(context, node);
+			resolved = resolved == null ? null : Extract.unwrap(resolved);
+			if (resolved?.type === AST_NODE_TYPES.ObjectExpression) return resolved;
+			return null;
+		}
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/rules/no-leaked-fetch/no-leaked-fetch.ts
+const RULE_NAME$3 = "no-leaked-fetch";
+function getCallKind$3(node) {
+	switch (true) {
+		case node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "fetch": return "fetch";
+		case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "fetch": return "fetch";
+		case node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "abort": return "abort";
+		case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "abort": return "abort";
+		default: return "other";
+	}
+}
+function getControllerFromSignal(context, node) {
+	node = Extract.unwrap(node);
+	switch (node.type) {
+		case AST_NODE_TYPES.MemberExpression: return {
+			controller: node.object,
+			isParamSignal: false
+		};
+		case AST_NODE_TYPES.Identifier: {
+			const resolved = resolve(context, node);
+			const resolvedUnwrapped = resolved == null ? null : Extract.unwrap(resolved);
+			if (resolvedUnwrapped?.type === AST_NODE_TYPES.MemberExpression) return {
+				controller: resolvedUnwrapped.object,
+				isParamSignal: false
+			};
+			if (resolved != null && Check.isFunction(resolved)) return {
+				controller: node,
+				isParamSignal: true
+			};
+			return {
+				controller: null,
+				isParamSignal: false
+			};
+		}
+		default: return {
+			controller: null,
+			isParamSignal: false
+		};
+	}
+}
+function getFetchController(context, node) {
+	const [, optionsArg] = node.arguments;
+	if (optionsArg == null) return {
+		controller: null,
+		isParamSignal: false
+	};
+	const options = resolveToObjectExpression(context, optionsArg);
+	if (options == null) return {
+		controller: null,
+		isParamSignal: false
+	};
+	const signalProp = findProperty(options.properties, "signal");
+	if (signalProp?.type !== AST_NODE_TYPES.Property) return {
+		controller: null,
+		isParamSignal: false
+	};
+	return getControllerFromSignal(context, signalProp.value);
+}
+function getAbortController(node) {
+	if (node.callee.type === AST_NODE_TYPES.MemberExpression) return node.callee.object;
+	return null;
+}
+var no_leaked_fetch_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Enforces that every 'fetch' in a component or custom hook has a corresponding 'AbortController' abort in the cleanup function." },
+		messages: {
+			expectedAbortController: "A 'fetch' must be provided with an 'AbortController' for proper cleanup.",
+			expectedAbortInCleanup: "A 'fetch' started in effect must be aborted with 'AbortController.abort' in the cleanup function."
+		},
+		schema: []
+	},
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: []
+});
+function create$3(context) {
+	if (!context.sourceCode.text.includes("fetch")) return {};
+	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+	const fEntries = [];
+	const fetchEntries = [];
+	const abortEntries = [];
+	return merge({
+		[":function"](node) {
+			const kind = getPhaseKindOfFunction(node) ?? "other";
+			fEntries.push({
+				kind,
+				node
+			});
+		},
+		[":function:exit"]() {
+			fEntries.pop();
+		},
+		["CallExpression"](node) {
+			const fEntry = fEntries.at(-1);
+			if (fEntry == null || !ComponentPhaseRelevance.has(fEntry.kind)) return;
+			switch (getCallKind$3(node)) {
+				case "fetch": {
+					if (fEntry.kind !== "setup") return;
+					const { controller, isParamSignal } = getFetchController(context, node);
+					fetchEntries.push({
+						controller,
+						isParamSignal,
+						node,
+						phase: fEntry.kind
+					});
+					break;
+				}
+				case "abort": {
+					if (fEntry.kind !== "cleanup") return;
+					const controller = getAbortController(node);
+					if (controller == null) break;
+					abortEntries.push({
+						controller,
+						node,
+						phase: fEntry.kind
+					});
+					break;
+				}
+			}
+		},
+		["Program:exit"]() {
+			for (const fEntry of fetchEntries) {
+				const controller = fEntry.controller;
+				if (controller == null) {
+					context.report({
+						messageId: "expectedAbortController",
+						node: fEntry.node
+					});
+					continue;
+				}
+				if (fEntry.isParamSignal) continue;
+				if (!abortEntries.some((aEntry) => isAssignmentTargetEqual(context, aEntry.controller, controller))) context.report({
+					messageId: "expectedAbortInCleanup",
+					node: fEntry.node
+				});
+			}
+		}
+	});
+}
+
 //#endregion
 //#region src/rules/no-leaked-interval/no-leaked-interval.ts
 const RULE_NAME$2 = "no-leaked-interval";
@@ -482,20 +651,23 @@ const isConditional = isOneOf([
 	AST_NODE_TYPES.LogicalExpression,
 	AST_NODE_TYPES.ConditionalExpression
 ]);
-
-//#endregion
-//#region src/rules/no-leaked-resize-observer/no-leaked-resize-observer.ts
-const RULE_NAME$1 = "no-leaked-resize-observer";
 function isNewResizeObserver(node) {
 	return node?.type === AST_NODE_TYPES.NewExpression && node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === "ResizeObserver";
 }
 function isFromObserver(context, node) {
 	switch (true) {
-		case node.type === AST_NODE_TYPES.Identifier: return isNewResizeObserver(resolve(context, node));
+		case node.type === AST_NODE_TYPES.Identifier: {
+			const initNode = resolve(context, node);
+			return isNewResizeObserver(initNode == null ? null : Extract.unwrap(initNode));
+		}
 		case node.type === AST_NODE_TYPES.MemberExpression: return isFromObserver(context, node.object);
 		default: return false;
 	}
 }
+
+//#endregion
+//#region src/rules/no-leaked-resize-observer/no-leaked-resize-observer.ts
+const RULE_NAME$1 = "no-leaked-resize-observer";
 function getCallKind$1(context, node) {
 	switch (true) {
 		case node.callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("observe", "unobserve", "disconnect"))(node.callee.name) && isFromObserver(context, node.callee): return node.callee.name;
@@ -731,6 +903,7 @@ const plugin = {
 	},
 	rules: {
 		"no-leaked-event-listener": no_leaked_event_listener_default,
+		"no-leaked-fetch": no_leaked_fetch_default,
 		"no-leaked-interval": no_leaked_interval_default,
 		"no-leaked-resize-observer": no_leaked_resize_observer_default,
 		"no-leaked-timeout": no_leaked_timeout_default
@@ -748,6 +921,7 @@ var recommended_exports = /* @__PURE__ */ __exportAll({
 const name = "react-web-api/recommended";
 const rules = {
 	"react-web-api/no-leaked-event-listener": "warn",
+	"react-web-api/no-leaked-fetch": "warn",
 	"react-web-api/no-leaked-interval": "warn",
 	"react-web-api/no-leaked-resize-observer": "warn",
 	"react-web-api/no-leaked-timeout": "warn"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-web-api",
-  "version": "5.2.5-next.1",
+  "version": "5.3.0-next.0",
   "description": "ESLint React's ESLint plugin for interacting with Web APIs",
   "keywords": [
     "react",
@@ -43,22 +43,22 @@
     "@typescript-eslint/utils": "^8.58.2",
     "birecord": "^0.1.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.2.5-next.1",
-    "@eslint-react/eslint": "5.2.5-next.1",
-    "@eslint-react/core": "5.2.5-next.1",
-    "@eslint-react/shared": "5.2.5-next.1",
-    "@eslint-react/var": "5.2.5-next.1"
+    "@eslint-react/ast": "5.3.0-next.0",
+    "@eslint-react/core": "5.3.0-next.0",
+    "@eslint-react/shared": "5.3.0-next.0",
+    "@eslint-react/var": "5.3.0-next.0",
+    "@eslint-react/eslint": "5.3.0-next.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "eslint": "^10.2.0",
+    "eslint": "^10.2.1",
     "tsdown": "^0.21.9",
     "@local/eff": "3.0.0-beta.72",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^10.2.0",
+    "eslint": "^10.2.1",
     "typescript": "*"
   },
   "engines": {