eslint-plugin-react-web-api 5.8.18 → 5.9.0

package/README.md

@@ -45,7 +45,6 @@ export default defineConfig(
 | `no-leaked-idle-callback`               | Prevents leaked `requestIdleCallback`         |
 | `no-leaked-animation-frame`             | Prevents leaked `requestAnimationFrame`       |
 | `no-leaked-event-source`                | Prevents leaked `EventSource`                 |
-| `no-leaked-intersection-observer`       | Prevents leaked `IntersectionObserver`        |
 | `no-leaked-mutation-observer`           | Prevents leaked `MutationObserver`            |
 | `no-leaked-performance-observer`        | Prevents leaked `PerformanceObserver`         |
 | `no-leaked-websocket`                   | Prevents leaked `WebSocket`                   |

package/dist/index.js

@@ -28,7 +28,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-react-web-api";
-var version = "5.8.18";
+var version = "5.9.0";
 
 //#endregion
 //#region src/types/component-phase.ts
@@ -108,8 +108,8 @@ function getOptions(context, 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) {
+const RULE_NAME$5 = "no-leaked-event-listener";
+function getCallKind$5(node) {
 	const callee = Extract.unwrap(node.callee);
 	switch (true) {
 		case callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("addEventListener", "removeEventListener", "abort"))(callee.name): return callee.name;
@@ -117,7 +117,7 @@ function getCallKind$4(node) {
 		default: return "other";
 	}
 }
-function getFunctionKind$1(node) {
+function getFunctionKind$2(node) {
 	return getPhaseKindOfFunction(node) ?? "other";
 }
 var no_leaked_event_listener_default = createRule({
@@ -130,11 +130,11 @@ var no_leaked_event_listener_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$4,
-	create: create$4,
+	name: RULE_NAME$5,
+	create: create$5,
 	defaultOptions: []
 });
-function create$4(context) {
+function create$5(context) {
 	if (!context.sourceCode.text.includes("addEventListener")) return {};
 	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const fEntries = [];
@@ -165,7 +165,7 @@ function create$4(context) {
 	}
 	return {
 		[":function"](node) {
-			const kind = getFunctionKind$1(node);
+			const kind = getFunctionKind$2(node);
 			fEntries.push({
 				kind,
 				node
@@ -179,7 +179,7 @@ function create$4(context) {
 			if (fKind == null) return;
 			if (!ComponentPhaseRelevance.has(fKind)) return;
 			const unwrappedCallee = Extract.unwrap(node.callee);
-			match(getCallKind$4(node)).with("addEventListener", (callKind) => {
+			match(getCallKind$5(node)).with("addEventListener", (callKind) => {
 				if (unwrappedCallee.type === AST_NODE_TYPES.MemberExpression && unwrappedCallee.object.type === AST_NODE_TYPES.Identifier && core.isAPIFromReactNative(unwrappedCallee.object.name, context.sourceCode.getScope(node))) return;
 				const [type, listener, options] = node.arguments;
 				if (type == null || listener == null) return;
@@ -261,8 +261,8 @@ function resolveToObjectExpression(context, node) {
 
 //#endregion
 //#region src/rules/no-leaked-fetch/no-leaked-fetch.ts
-const RULE_NAME$3 = "no-leaked-fetch";
-function getCallKind$3(node) {
+const RULE_NAME$4 = "no-leaked-fetch";
+function getCallKind$4(node) {
 	const callee = Extract.unwrap(node.callee);
 	switch (true) {
 		case callee.type === AST_NODE_TYPES.Identifier && callee.name === "fetch": return "fetch";
@@ -334,11 +334,11 @@ var no_leaked_fetch_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("fetch")) return {};
 	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const fEntries = [];
@@ -358,7 +358,7 @@ function create$3(context) {
 		["CallExpression"](node) {
 			const fEntry = fEntries.at(-1);
 			if (fEntry == null || !ComponentPhaseRelevance.has(fEntry.kind)) return;
-			switch (getCallKind$3(node)) {
+			switch (getCallKind$4(node)) {
 				case "fetch": {
 					if (fEntry.kind !== "setup") return;
 					const { controller, isParamSignal } = getFetchController(context, node);
@@ -403,108 +403,6 @@ function create$3(context) {
 	};
 }
 
-//#endregion
-//#region src/rules/no-leaked-interval/no-leaked-interval.ts
-const RULE_NAME$2 = "no-leaked-interval";
-function getCallKind$2(node) {
-	const callee = Extract.unwrap(node.callee);
-	switch (true) {
-		case callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("setInterval", "clearInterval"))(callee.name): return callee.name;
-		case callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && isMatching(P.union("setInterval", "clearInterval"))(callee.property.name): return callee.property.name;
-		default: return "other";
-	}
-}
-var no_leaked_interval_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Enforces that every 'setInterval' in a component or custom hook has a corresponding 'clearInterval'." },
-		messages: {
-			expectedClearIntervalInCleanup: "A 'setInterval' created in '{{ kind }}' must be cleared with 'clearInterval' in the cleanup function.",
-			expectedIntervalId: "A 'setInterval' must be assigned to a variable for proper cleanup."
-		},
-		schema: []
-	},
-	name: RULE_NAME$2,
-	create: create$2,
-	defaultOptions: []
-});
-function create$2(context) {
-	if (!context.sourceCode.text.includes("setInterval")) return {};
-	const fEntries = [];
-	const sEntries = [];
-	const cEntries = [];
-	function isInverseEntry(a, b) {
-		return isAssignmentTargetEqual(context, a.timerId, b.timerId);
-	}
-	return {
-		[":function"](node) {
-			const kind = getPhaseKindOfFunction(node) ?? "other";
-			fEntries.push({
-				kind,
-				node
-			});
-		},
-		[":function:exit"]() {
-			fEntries.pop();
-		},
-		["CallExpression"](node) {
-			switch (getCallKind$2(node)) {
-				case "setInterval": {
-					const fEntry = fEntries.findLast((x) => x.kind !== "other");
-					if (fEntry == null) break;
-					if (!ComponentPhaseRelevance.has(fEntry.kind)) break;
-					const intervalIdNode = resolveEnclosingAssignmentTarget(node);
-					if (intervalIdNode == null) {
-						context.report({
-							messageId: "expectedIntervalId",
-							node
-						});
-						break;
-					}
-					sEntries.push({
-						kind: "interval",
-						callee: node.callee,
-						node,
-						phase: fEntry.kind,
-						timerId: intervalIdNode
-					});
-					break;
-				}
-				case "clearInterval": {
-					const fEntry = fEntries.findLast((x) => x.kind !== "other");
-					if (fEntry == null) break;
-					if (!ComponentPhaseRelevance.has(fEntry.kind)) break;
-					const [intervalIdNode] = node.arguments;
-					if (intervalIdNode == null) break;
-					cEntries.push({
-						kind: "interval",
-						callee: node.callee,
-						node,
-						phase: fEntry.kind,
-						timerId: intervalIdNode
-					});
-					break;
-				}
-			}
-		},
-		["Program:exit"]() {
-			for (const sEntry of sEntries) {
-				if (cEntries.some((cEntry) => isInverseEntry(sEntry, cEntry))) continue;
-				switch (sEntry.phase) {
-					case "setup":
-					case "cleanup":
-						context.report({
-							data: { kind: "useEffect" },
-							messageId: "expectedClearIntervalInCleanup",
-							node: sEntry.node
-						});
-						continue;
-				}
-			}
-		}
-	};
-}
-
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
 function or(a, b) {
@@ -627,19 +525,278 @@ const dual = function(arity, body) {
 const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 
 //#endregion
-//#region src/rules/no-leaked-resize-observer/lib.ts
+//#region src/rules/no-leaked-intersection-observer/lib.ts
 /**
-* Check if a node is a loop statement
+* Check if a node is a conditional expression or control flow statement
 * @param node The node to check
-* @returns True if the node is a loop
+* @returns True if the node is conditional
 */
-const isLoop = isOneOf([
+const isConditional$1 = isOneOf([
 	AST_NODE_TYPES.DoWhileStatement,
 	AST_NODE_TYPES.ForInStatement,
 	AST_NODE_TYPES.ForOfStatement,
 	AST_NODE_TYPES.ForStatement,
-	AST_NODE_TYPES.WhileStatement
+	AST_NODE_TYPES.WhileStatement,
+	AST_NODE_TYPES.IfStatement,
+	AST_NODE_TYPES.SwitchStatement,
+	AST_NODE_TYPES.LogicalExpression,
+	AST_NODE_TYPES.ConditionalExpression
 ]);
+function isNewIntersectionObserver(node) {
+	if (node?.type !== AST_NODE_TYPES.NewExpression) return false;
+	const callee = Extract.unwrap(node.callee);
+	return callee.type === AST_NODE_TYPES.Identifier && callee.name === "IntersectionObserver";
+}
+function isFromObserver$1(context, node) {
+	switch (true) {
+		case node.type === AST_NODE_TYPES.Identifier: {
+			const initNode = resolve(context, node);
+			return isNewIntersectionObserver(initNode == null ? null : Extract.unwrap(initNode));
+		}
+		case node.type === AST_NODE_TYPES.MemberExpression: return isFromObserver$1(context, node.object);
+		default: return false;
+	}
+}
+
+//#endregion
+//#region src/rules/no-leaked-intersection-observer/no-leaked-intersection-observer.ts
+const RULE_NAME$3 = "no-leaked-intersection-observer";
+function getCallKind$3(context, node) {
+	const callee = Extract.unwrap(node.callee);
+	switch (true) {
+		case callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("observe", "unobserve", "disconnect"))(callee.name) && isFromObserver$1(context, callee): return callee.name;
+		case callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && isMatching(P.union("observe", "unobserve", "disconnect"))(callee.property.name) && isFromObserver$1(context, callee): return callee.property.name;
+		default: return "other";
+	}
+}
+function getFunctionKind$1(node) {
+	return getPhaseKindOfFunction(node) ?? "other";
+}
+var no_leaked_intersection_observer_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Enforces that every 'IntersectionObserver' created in a component or custom hook has a corresponding 'IntersectionObserver.disconnect()'." },
+		messages: {
+			expectedDisconnectInControlFlow: "Dynamically added 'IntersectionObserver.observe' should be cleared all at once using 'IntersectionObserver.disconnect' in the cleanup function.",
+			expectedDisconnectOrUnobserveInCleanup: "An 'IntersectionObserver' instance created in 'useEffect' must be disconnected in the cleanup function.",
+			unexpectedFloatingInstance: "An 'IntersectionObserver' instance created in component or custom hook must be assigned to a variable for proper cleanup."
+		},
+		schema: []
+	},
+	name: RULE_NAME$3,
+	create: create$3,
+	defaultOptions: []
+});
+function create$3(context) {
+	if (!context.sourceCode.text.includes("IntersectionObserver")) return {};
+	const fEntries = [];
+	const observers = [];
+	const oEntries = [];
+	const uEntries = [];
+	const dEntries = [];
+	return {
+		[":function"](node) {
+			const kind = getFunctionKind$1(node);
+			fEntries.push({
+				kind,
+				node
+			});
+		},
+		[":function:exit"]() {
+			fEntries.pop();
+		},
+		["CallExpression"](node) {
+			const unwrappedCallee = Extract.unwrap(node.callee);
+			if (unwrappedCallee.type !== AST_NODE_TYPES.MemberExpression) return;
+			const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
+			if (fKind == null || !ComponentPhaseRelevance.has(fKind)) return;
+			const { object } = unwrappedCallee;
+			match(getCallKind$3(context, node)).with("disconnect", () => {
+				dEntries.push({
+					kind: "IntersectionObserver",
+					callee: node.callee,
+					method: "disconnect",
+					node,
+					observer: object,
+					phase: fKind
+				});
+			}).with("observe", () => {
+				const [element] = node.arguments;
+				if (element == null) return;
+				oEntries.push({
+					kind: "IntersectionObserver",
+					callee: node.callee,
+					element,
+					method: "observe",
+					node,
+					observer: object,
+					phase: fKind
+				});
+			}).with("unobserve", () => {
+				const [element] = node.arguments;
+				if (element == null) return;
+				uEntries.push({
+					kind: "IntersectionObserver",
+					callee: node.callee,
+					element,
+					method: "unobserve",
+					node,
+					observer: object,
+					phase: fKind
+				});
+			}).otherwise(() => null);
+		},
+		["NewExpression"](node) {
+			const fEntry = fEntries.findLast((x) => x.kind !== "other");
+			if (fEntry == null) return;
+			if (!ComponentPhaseRelevance.has(fEntry.kind)) return;
+			if (!isNewIntersectionObserver(node)) return;
+			const id = resolveEnclosingAssignmentTarget(node);
+			if (id == null) {
+				context.report({
+					messageId: "unexpectedFloatingInstance",
+					node
+				});
+				return;
+			}
+			observers.push({
+				id,
+				node,
+				phase: fEntry.kind,
+				phaseNode: fEntry.node
+			});
+		},
+		["Program:exit"]() {
+			for (const { id, node, phaseNode } of observers) {
+				const isInsideObserverCallback = (e) => Traverse.findParent(e.node, (n) => n === node) != null;
+				if (dEntries.some((e) => !isInsideObserverCallback(e) && isAssignmentTargetEqual(context, e.observer, id))) continue;
+				const oentries = oEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
+				const uentries = uEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
+				const isDynamic = (node) => node?.type === AST_NODE_TYPES.CallExpression || isConditional$1(node);
+				const isPhaseNode = (node) => node === phaseNode;
+				if (oentries.some((e) => !isPhaseNode(Traverse.findParent(e.node, or(isDynamic, isPhaseNode))))) {
+					context.report({
+						messageId: "expectedDisconnectInControlFlow",
+						node
+					});
+					continue;
+				}
+				for (const oEntry of oentries) {
+					if (uentries.some((uEntry) => isAssignmentTargetEqual(context, uEntry.element, oEntry.element))) continue;
+					context.report({
+						messageId: "expectedDisconnectOrUnobserveInCleanup",
+						node: oEntry.node
+					});
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/no-leaked-interval/no-leaked-interval.ts
+const RULE_NAME$2 = "no-leaked-interval";
+function getCallKind$2(node) {
+	const callee = Extract.unwrap(node.callee);
+	switch (true) {
+		case callee.type === AST_NODE_TYPES.Identifier && isMatching(P.union("setInterval", "clearInterval"))(callee.name): return callee.name;
+		case callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && isMatching(P.union("setInterval", "clearInterval"))(callee.property.name): return callee.property.name;
+		default: return "other";
+	}
+}
+var no_leaked_interval_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Enforces that every 'setInterval' in a component or custom hook has a corresponding 'clearInterval'." },
+		messages: {
+			expectedClearIntervalInCleanup: "A 'setInterval' created in '{{ kind }}' must be cleared with 'clearInterval' in the cleanup function.",
+			expectedIntervalId: "A 'setInterval' must be assigned to a variable for proper cleanup."
+		},
+		schema: []
+	},
+	name: RULE_NAME$2,
+	create: create$2,
+	defaultOptions: []
+});
+function create$2(context) {
+	if (!context.sourceCode.text.includes("setInterval")) return {};
+	const fEntries = [];
+	const sEntries = [];
+	const cEntries = [];
+	function isInverseEntry(a, b) {
+		return isAssignmentTargetEqual(context, a.timerId, b.timerId);
+	}
+	return {
+		[":function"](node) {
+			const kind = getPhaseKindOfFunction(node) ?? "other";
+			fEntries.push({
+				kind,
+				node
+			});
+		},
+		[":function:exit"]() {
+			fEntries.pop();
+		},
+		["CallExpression"](node) {
+			switch (getCallKind$2(node)) {
+				case "setInterval": {
+					const fEntry = fEntries.findLast((x) => x.kind !== "other");
+					if (fEntry == null) break;
+					if (!ComponentPhaseRelevance.has(fEntry.kind)) break;
+					const intervalIdNode = resolveEnclosingAssignmentTarget(node);
+					if (intervalIdNode == null) {
+						context.report({
+							messageId: "expectedIntervalId",
+							node
+						});
+						break;
+					}
+					sEntries.push({
+						kind: "interval",
+						callee: node.callee,
+						node,
+						phase: fEntry.kind,
+						timerId: intervalIdNode
+					});
+					break;
+				}
+				case "clearInterval": {
+					const fEntry = fEntries.findLast((x) => x.kind !== "other");
+					if (fEntry == null) break;
+					if (!ComponentPhaseRelevance.has(fEntry.kind)) break;
+					const [intervalIdNode] = node.arguments;
+					if (intervalIdNode == null) break;
+					cEntries.push({
+						kind: "interval",
+						callee: node.callee,
+						node,
+						phase: fEntry.kind,
+						timerId: intervalIdNode
+					});
+					break;
+				}
+			}
+		},
+		["Program:exit"]() {
+			for (const sEntry of sEntries) {
+				if (cEntries.some((cEntry) => isInverseEntry(sEntry, cEntry))) continue;
+				switch (sEntry.phase) {
+					case "setup":
+					case "cleanup":
+						context.report({
+							data: { kind: "useEffect" },
+							messageId: "expectedClearIntervalInCleanup",
+							node: sEntry.node
+						});
+						continue;
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/no-leaked-resize-observer/lib.ts
 /**
 * Check if a node is a conditional expression or control flow statement
 * @param node The node to check
@@ -782,7 +939,8 @@ function create$1(context) {
 		},
 		["Program:exit"]() {
 			for (const { id, node, phaseNode } of observers) {
-				if (dEntries.some((e) => isAssignmentTargetEqual(context, e.observer, id))) continue;
+				const isInsideObserverCallback = (e) => Traverse.findParent(e.node, (n) => n === node) != null;
+				if (dEntries.some((e) => !isInsideObserverCallback(e) && isAssignmentTargetEqual(context, e.observer, id))) continue;
 				const oentries = oEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
 				const uentries = uEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
 				const isDynamic = (node) => node?.type === AST_NODE_TYPES.CallExpression || isConditional(node);
@@ -914,6 +1072,7 @@ const plugin = {
 	rules: {
 		"no-leaked-event-listener": no_leaked_event_listener_default,
 		"no-leaked-fetch": no_leaked_fetch_default,
+		"no-leaked-intersection-observer": no_leaked_intersection_observer_default,
 		"no-leaked-interval": no_leaked_interval_default,
 		"no-leaked-resize-observer": no_leaked_resize_observer_default,
 		"no-leaked-timeout": no_leaked_timeout_default
@@ -932,6 +1091,7 @@ 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-intersection-observer": "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.8.18",
+  "version": "5.9.0",
   "description": "ESLint React's ESLint plugin for interacting with Web APIs",
   "keywords": [
     "react",
@@ -41,11 +41,11 @@
     "@typescript-eslint/utils": "^8.61.0",
     "birecord": "^0.1.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.8.18",
-    "@eslint-react/eslint": "5.8.18",
-    "@eslint-react/shared": "5.8.18",
-    "@eslint-react/core": "5.8.18",
-    "@eslint-react/var": "5.8.18"
+    "@eslint-react/core": "5.9.0",
+    "@eslint-react/ast": "5.9.0",
+    "@eslint-react/eslint": "5.9.0",
+    "@eslint-react/var": "5.9.0",
+    "@eslint-react/shared": "5.9.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
@@ -54,8 +54,8 @@
     "eslint": "^10.4.1",
     "tsdown": "^0.22.2",
     "typescript": "6.0.3",
-    "@local/configs": "0.0.0",
-    "@local/eff": "0.0.0"
+    "@local/eff": "0.0.0",
+    "@local/configs": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "*",