eslint-plugin-react-web-api 5.20.3 → 5.20.4

package/dist/index.js

@@ -1,12 +1,11 @@
 import { DEFAULT_ESLINT_REACT_SETTINGS } from "@eslint-react/shared";
-import * as core from "@eslint-react/core";
-import birecord from "birecord";
-import { P, isMatching, match } from "ts-pattern";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import { Check, Compare, Extract, Traverse } from "@eslint-react/ast";
+import { isUseEffectCleanupCallback, isUseEffectSetupCallback } from "@eslint-react/core";
 import "@eslint-react/eslint";
 import { isAssignmentTargetEqual, isInitializedFromReactNative, isValueEqual, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { P, isMatching, match } from "ts-pattern";
 import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
 
 //#region \0rolldown/runtime.js
@@ -28,14 +27,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-react-web-api";
-var version = "5.20.3";
-
-//#endregion
-//#region src/types/component-phase.ts
-const ComponentPhaseRelevance = birecord({ setup: "cleanup" });
-function getPhaseKindOfFunction(node) {
-	return match(node).when(core.isUseEffectSetupCallback, () => "setup").when(core.isUseEffectCleanupCallback, () => "cleanup").otherwise(() => null);
-}
+var version = "5.20.4";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -101,11 +93,13 @@ function getOptions(context, node) {
 const RULE_NAME$5 = "no-leaked-event-listener";
 function getCallKind$5(node) {
 	const name = Extract.getCalleeName(node);
-	if (name != null && isMatching(P.union("addEventListener", "removeEventListener", "abort"))(name)) return name;
+	if (name != null && isMatching(P.union("addEventListener", "removeEventListener"))(name)) return name;
 	return "other";
 }
-function getFunctionKind$2(node) {
-	return getPhaseKindOfFunction(node) ?? "other";
+function getFunctionKind$5(node) {
+	if (isUseEffectSetupCallback(node)) return "setup";
+	if (isUseEffectCleanupCallback(node)) return "cleanup";
+	return "other";
 }
 var no_leaked_event_listener_default = createRule({
 	meta: {
@@ -127,7 +121,6 @@ function create$5(context) {
 	const fEntries = [];
 	const aEntries = [];
 	const rEntries = [];
-	const abortedSignals = [];
 	function isSameObject(a, b) {
 		switch (true) {
 			case a.type === AST_NODE_TYPES.MemberExpression && b.type === AST_NODE_TYPES.MemberExpression: return Compare.isEqual(a.object, b.object);
@@ -137,10 +130,10 @@ function create$5(context) {
 	function isInverseEntry(aEntry, rEntry) {
 		const { type: aType, callee: aCallee, capture: aCapture, listener: aListener, phase: aPhase } = aEntry;
 		const { type: rType, callee: rCallee, capture: rCapture, listener: rListener, phase: rPhase } = rEntry;
-		if (ComponentPhaseRelevance.get(aPhase) !== rPhase) return false;
+		if (aPhase !== "setup" || rPhase !== "cleanup") return false;
 		return isSameObject(aCallee, rCallee) && Compare.isEqual(aListener, rListener) && isValueEqual(context, aType, rType) && aCapture === rCapture;
 	}
-	function checkInlineFunction(node, callKind, options) {
+	function visitInlineFunction(node, callKind, options) {
 		const listener = node.arguments.at(1);
 		if (!Check.isFunction(listener)) return;
 		if (options.signal != null) return;
@@ -152,26 +145,21 @@ function create$5(context) {
 	}
 	return {
 		[":function"](node) {
-			const kind = getFunctionKind$2(node);
-			fEntries.push({
-				kind,
-				node
-			});
+			fEntries.push(getFunctionKind$5(node));
 		},
 		[":function:exit"]() {
 			fEntries.pop();
 		},
 		["CallExpression"](node) {
-			const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
+			const fKind = fEntries.findLast((kind) => kind !== "other");
 			if (fKind == null) return;
-			if (!ComponentPhaseRelevance.has(fKind)) return;
 			const callee = Extract.unwrap(node.callee);
 			match(getCallKind$5(node)).with("addEventListener", (callKind) => {
 				if (callee.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(callee.object) && isInitializedFromReactNative(callee.object.name, context.sourceCode.getScope(node))) return;
 				const [type, listener, options] = node.arguments;
 				if (type == null || listener == null) return;
 				const opts = options == null ? defaultOptions : getOptions(context, options);
-				checkInlineFunction(node, callKind, opts);
+				visitInlineFunction(node, callKind, opts);
 				aEntries.push({
 					...opts,
 					type,
@@ -185,34 +173,27 @@ function create$5(context) {
 				const [type, listener, options] = node.arguments;
 				if (type == null || listener == null) return;
 				const opts = options == null ? defaultOptions : getOptions(context, options);
-				checkInlineFunction(node, callKind, opts);
+				visitInlineFunction(node, callKind, opts);
 				rEntries.push({
-					...opts,
 					type,
 					callee,
+					capture: opts.capture,
 					listener,
 					method: "removeEventListener",
 					node,
 					phase: fKind
 				});
-			}).with("abort", () => {
-				abortedSignals.push(node.callee);
 			}).otherwise(() => null);
 		},
 		["Program:exit"]() {
 			for (const aEntry of aEntries) {
 				if (aEntry.signal != null) continue;
 				if (rEntries.some((rEntry) => isInverseEntry(aEntry, rEntry))) continue;
-				switch (aEntry.phase) {
-					case "setup":
-					case "cleanup":
-						context.report({
-							data: { effectMethodKind: "useEffect" },
-							messageId: "expectedRemoveEventListenerInCleanup",
-							node: aEntry.node
-						});
-						continue;
-				}
+				context.report({
+					data: { effectMethodKind: "useEffect" },
+					messageId: "expectedRemoveEventListenerInCleanup",
+					node: aEntry.node
+				});
 			}
 		}
 	};
@@ -220,16 +201,6 @@ function create$5(context) {
 
 //#endregion
 //#region src/rules/no-leaked-fetch/lib.ts
-function findProperty(node, name) {
-	for (const property of node) {
-		if (property.type === AST_NODE_TYPES.Property && !property.computed && Check.isIdentifier(property.key, name)) return property;
-		if (property.type === AST_NODE_TYPES.SpreadElement && property.argument.type === AST_NODE_TYPES.ObjectExpression) {
-			const found = findProperty(property.argument.properties, name);
-			if (found != null) return found;
-		}
-	}
-	return null;
-}
 function resolveToObjectExpression(context, node) {
 	node = Extract.unwrap(node);
 	switch (node.type) {
@@ -248,11 +219,14 @@ function resolveToObjectExpression(context, node) {
 //#region src/rules/no-leaked-fetch/no-leaked-fetch.ts
 const RULE_NAME$4 = "no-leaked-fetch";
 function getCallKind$4(node) {
-	switch (Extract.getCalleeName(node)) {
-		case "fetch": return "fetch";
-		case "abort": return "abort";
-		default: return "other";
-	}
+	const name = Extract.getCalleeName(node);
+	if (name != null && isMatching(P.union("fetch", "abort"))(name)) return name;
+	return "other";
+}
+function getFunctionKind$4(node) {
+	if (isUseEffectSetupCallback(node)) return "setup";
+	if (isUseEffectCleanupCallback(node)) return "cleanup";
+	return "other";
 }
 function getControllerFromSignal(context, node) {
 	node = Extract.unwrap(node);
@@ -294,7 +268,7 @@ function getFetchController(context, node) {
 		controller: null,
 		isParamSignal: false
 	};
-	const signalProp = findProperty(options.properties, "signal");
+	const signalProp = Extract.findProperty(options.properties, "signal");
 	if (signalProp?.type !== AST_NODE_TYPES.Property) return {
 		controller: null,
 		isParamSignal: false
@@ -328,42 +302,31 @@ function create$4(context) {
 	const abortEntries = [];
 	return {
 		[":function"](node) {
-			const kind = getPhaseKindOfFunction(node) ?? "other";
-			fEntries.push({
-				kind,
-				node
-			});
+			fEntries.push(getFunctionKind$4(node));
 		},
 		[":function:exit"]() {
 			fEntries.pop();
 		},
 		["CallExpression"](node) {
-			const fEntry = fEntries.at(-1);
-			if (fEntry == null || !ComponentPhaseRelevance.has(fEntry.kind)) return;
-			switch (getCallKind$4(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;
-				}
-			}
+			const fKind = fEntries.at(-1);
+			if (fKind == null || fKind === "other") return;
+			match(getCallKind$4(node)).with("fetch", () => {
+				if (fKind !== "setup") return;
+				const { controller, isParamSignal } = getFetchController(context, node);
+				fetchEntries.push({
+					controller,
+					isParamSignal,
+					node
+				});
+			}).with("abort", () => {
+				if (fKind !== "cleanup") return;
+				const controller = getAbortController(node);
+				if (controller == null) return;
+				abortEntries.push({
+					controller,
+					node
+				});
+			}).otherwise(() => null);
 		},
 		["Program:exit"]() {
 			for (const fEntry of fetchEntries) {
@@ -864,18 +827,18 @@ const takeWhile = dual(2, (xs, pred) => {
 
 //#endregion
 //#region src/rules/no-leaked-intersection-observer/lib.ts
-function isNewIntersectionObserver(node) {
+function isNewObserver$1(node, name) {
 	if (node?.type !== AST_NODE_TYPES.NewExpression) return false;
 	const callee = Extract.unwrap(node.callee);
-	return Check.isIdentifier(callee, "IntersectionObserver");
+	return Check.isIdentifier(callee, name);
 }
-function isFromObserver$1(context, node) {
+function isFromObserver$1(context, node, name) {
 	switch (true) {
 		case Check.isIdentifier(node): {
 			const initNode = resolve(context, node);
-			return isNewIntersectionObserver(initNode == null ? null : Extract.unwrap(initNode));
+			return isNewObserver$1(initNode == null ? null : Extract.unwrap(initNode), name);
 		}
-		case node.type === AST_NODE_TYPES.MemberExpression: return isFromObserver$1(context, node.object);
+		case node.type === AST_NODE_TYPES.MemberExpression: return isFromObserver$1(context, node.object, name);
 		default: return false;
 	}
 }
@@ -885,13 +848,15 @@ function isFromObserver$1(context, node) {
 const RULE_NAME$3 = "no-leaked-intersection-observer";
 function getCallKind$3(context, node) {
 	const callee = Extract.unwrap(node.callee);
-	if (callee.type !== AST_NODE_TYPES.Identifier && callee.type !== AST_NODE_TYPES.MemberExpression) return "other";
+	if (callee.type !== AST_NODE_TYPES.MemberExpression) return "other";
 	const name = Extract.getCalleeName(node);
-	if (name != null && isMatching(P.union("observe", "unobserve", "disconnect"))(name) && isFromObserver$1(context, callee)) return name;
+	if (name != null && isMatching(P.union("observe", "unobserve", "disconnect"))(name) && isFromObserver$1(context, callee, "IntersectionObserver")) return name;
 	return "other";
 }
-function getFunctionKind$1(node) {
-	return getPhaseKindOfFunction(node) ?? "other";
+function getFunctionKind$3(node) {
+	if (isUseEffectSetupCallback(node)) return "setup";
+	if (isUseEffectCleanupCallback(node)) return "cleanup";
+	return "other";
 }
 var no_leaked_intersection_observer_default = createRule({
 	meta: {
@@ -917,7 +882,7 @@ function create$3(context) {
 	const dEntries = [];
 	return {
 		[":function"](node) {
-			const kind = getFunctionKind$1(node);
+			const kind = getFunctionKind$3(node);
 			fEntries.push({
 				kind,
 				node
@@ -927,51 +892,40 @@ function create$3(context) {
 			fEntries.pop();
 		},
 		["CallExpression"](node) {
+			if (fEntries.findLast((x) => x.kind !== "other")?.kind == null) return;
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
-			if (fKind == null || !ComponentPhaseRelevance.has(fKind)) return;
 			const { object } = callee;
 			match(getCallKind$3(context, node)).with("disconnect", () => {
 				dEntries.push({
-					kind: "IntersectionObserver",
-					callee,
 					method: "disconnect",
 					node,
-					observer: object,
-					phase: fKind
+					observer: object
 				});
 			}).with("observe", () => {
 				const [element] = node.arguments;
 				if (element == null) return;
 				oEntries.push({
-					kind: "IntersectionObserver",
-					callee,
 					element,
 					method: "observe",
 					node,
-					observer: object,
-					phase: fKind
+					observer: object
 				});
 			}).with("unobserve", () => {
 				const [element] = node.arguments;
 				if (element == null) return;
 				uEntries.push({
-					kind: "IntersectionObserver",
-					callee,
 					element,
 					method: "unobserve",
 					node,
-					observer: object,
-					phase: fKind
+					observer: object
 				});
 			}).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;
+			if (!isNewObserver$1(node, "IntersectionObserver")) return;
 			const id = resolveEnclosingAssignmentTarget(node);
 			if (id == null) {
 				context.report({
@@ -983,7 +937,6 @@ function create$3(context) {
 			observers.push({
 				id,
 				node,
-				phase: fEntry.kind,
 				phaseNode: fEntry.node
 			});
 		},
@@ -991,19 +944,19 @@ function create$3(context) {
 			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 matchedOEntries = oEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
+				const matchedUEntries = uEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
 				const isDynamic = (node) => node?.type === AST_NODE_TYPES.CallExpression || Check.isConditional(node);
 				const isPhaseNode = (node) => node === phaseNode;
-				if (oentries.some((e) => !isPhaseNode(Traverse.findParent(e.node, or(isDynamic, isPhaseNode))))) {
+				if (matchedOEntries.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;
+				for (const oEntry of matchedOEntries) {
+					if (matchedUEntries.some((uEntry) => isAssignmentTargetEqual(context, uEntry.element, oEntry.element))) continue;
 					context.report({
 						messageId: "expectedDisconnectOrUnobserveInCleanup",
 						node: oEntry.node
@@ -1022,6 +975,11 @@ function getCallKind$2(node) {
 	if (name != null && isMatching(P.union("setInterval", "clearInterval"))(name)) return name;
 	return "other";
 }
+function getFunctionKind$2(node) {
+	if (isUseEffectSetupCallback(node)) return "setup";
+	if (isUseEffectCleanupCallback(node)) return "cleanup";
+	return "other";
+}
 var no_leaked_interval_default = createRule({
 	meta: {
 		type: "problem",
@@ -1046,68 +1004,43 @@ function create$2(context) {
 	}
 	return {
 		[":function"](node) {
-			const kind = getPhaseKindOfFunction(node) ?? "other";
-			fEntries.push({
-				kind,
-				node
-			});
+			fEntries.push(getFunctionKind$2(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
+			if (fEntries.findLast((kind) => kind !== "other") == null) return;
+			match(getCallKind$2(node)).with("setInterval", () => {
+				const intervalIdNode = resolveEnclosingAssignmentTarget(node);
+				if (intervalIdNode == null) {
+					context.report({
+						messageId: "expectedIntervalId",
+						node
 					});
-					break;
+					return;
 				}
-			}
+				sEntries.push({
+					node,
+					timerId: intervalIdNode
+				});
+			}).with("clearInterval", () => {
+				const [intervalIdNode] = node.arguments;
+				if (intervalIdNode == null) return;
+				cEntries.push({
+					node,
+					timerId: intervalIdNode
+				});
+			}).otherwise(() => null);
 		},
 		["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;
-				}
+				context.report({
+					data: { kind: "useEffect" },
+					messageId: "expectedClearIntervalInCleanup",
+					node: sEntry.node
+				});
 			}
 		}
 	};
@@ -1115,18 +1048,18 @@ function create$2(context) {
 
 //#endregion
 //#region src/rules/no-leaked-resize-observer/lib.ts
-function isNewResizeObserver(node) {
+function isNewObserver(node, name) {
 	if (node?.type !== AST_NODE_TYPES.NewExpression) return false;
 	const callee = Extract.unwrap(node.callee);
-	return Check.isIdentifier(callee, "ResizeObserver");
+	return Check.isIdentifier(callee, name);
 }
-function isFromObserver(context, node) {
+function isFromObserver(context, node, name) {
 	switch (true) {
 		case Check.isIdentifier(node): {
 			const initNode = resolve(context, node);
-			return isNewResizeObserver(initNode == null ? null : Extract.unwrap(initNode));
+			return isNewObserver(initNode == null ? null : Extract.unwrap(initNode), name);
 		}
-		case node.type === AST_NODE_TYPES.MemberExpression: return isFromObserver(context, node.object);
+		case node.type === AST_NODE_TYPES.MemberExpression: return isFromObserver(context, node.object, name);
 		default: return false;
 	}
 }
@@ -1136,13 +1069,15 @@ function isFromObserver(context, node) {
 const RULE_NAME$1 = "no-leaked-resize-observer";
 function getCallKind$1(context, node) {
 	const callee = Extract.unwrap(node.callee);
-	if (callee.type !== AST_NODE_TYPES.Identifier && callee.type !== AST_NODE_TYPES.MemberExpression) return "other";
+	if (callee.type !== AST_NODE_TYPES.MemberExpression) return "other";
 	const name = Extract.getCalleeName(node);
-	if (name != null && isMatching(P.union("observe", "unobserve", "disconnect"))(name) && isFromObserver(context, callee)) return name;
+	if (name != null && isMatching(P.union("observe", "unobserve", "disconnect"))(name) && isFromObserver(context, callee, "ResizeObserver")) return name;
 	return "other";
 }
-function getFunctionKind(node) {
-	return getPhaseKindOfFunction(node) ?? "other";
+function getFunctionKind$1(node) {
+	if (isUseEffectSetupCallback(node)) return "setup";
+	if (isUseEffectCleanupCallback(node)) return "cleanup";
+	return "other";
 }
 var no_leaked_resize_observer_default = createRule({
 	meta: {
@@ -1168,7 +1103,7 @@ function create$1(context) {
 	const dEntries = [];
 	return {
 		[":function"](node) {
-			const kind = getFunctionKind(node);
+			const kind = getFunctionKind$1(node);
 			fEntries.push({
 				kind,
 				node
@@ -1178,51 +1113,40 @@ function create$1(context) {
 			fEntries.pop();
 		},
 		["CallExpression"](node) {
+			if (fEntries.findLast((x) => x.kind !== "other")?.kind == null) return;
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
-			if (fKind == null || !ComponentPhaseRelevance.has(fKind)) return;
 			const { object } = callee;
 			match(getCallKind$1(context, node)).with("disconnect", () => {
 				dEntries.push({
-					kind: "ResizeObserver",
-					callee,
 					method: "disconnect",
 					node,
-					observer: object,
-					phase: fKind
+					observer: object
 				});
 			}).with("observe", () => {
 				const [element] = node.arguments;
 				if (element == null) return;
 				oEntries.push({
-					kind: "ResizeObserver",
-					callee,
 					element,
 					method: "observe",
 					node,
-					observer: object,
-					phase: fKind
+					observer: object
 				});
 			}).with("unobserve", () => {
 				const [element] = node.arguments;
 				if (element == null) return;
 				uEntries.push({
-					kind: "ResizeObserver",
-					callee,
 					element,
 					method: "unobserve",
 					node,
-					observer: object,
-					phase: fKind
+					observer: object
 				});
 			}).otherwise(() => null);
 		},
 		["NewExpression"](node) {
 			const fEntry = fEntries.findLast((x) => x.kind !== "other");
 			if (fEntry == null) return;
-			if (!ComponentPhaseRelevance.has(fEntry.kind)) return;
-			if (!isNewResizeObserver(node)) return;
+			if (!isNewObserver(node, "ResizeObserver")) return;
 			const id = resolveEnclosingAssignmentTarget(node);
 			if (id == null) {
 				context.report({
@@ -1234,7 +1158,6 @@ function create$1(context) {
 			observers.push({
 				id,
 				node,
-				phase: fEntry.kind,
 				phaseNode: fEntry.node
 			});
 		},
@@ -1242,19 +1165,19 @@ function create$1(context) {
 			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 matchedOEntries = oEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
+				const matchedUEntries = uEntries.filter((e) => isAssignmentTargetEqual(context, e.observer, id));
 				const isDynamic = (node) => node?.type === AST_NODE_TYPES.CallExpression || Check.isConditional(node);
 				const isPhaseNode = (node) => node === phaseNode;
-				if (oentries.some((e) => !isPhaseNode(Traverse.findParent(e.node, or(isDynamic, isPhaseNode))))) {
+				if (matchedOEntries.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;
+				for (const oEntry of matchedOEntries) {
+					if (matchedUEntries.some((uEntry) => isAssignmentTargetEqual(context, uEntry.element, oEntry.element))) continue;
 					context.report({
 						messageId: "expectedDisconnectOrUnobserveInCleanup",
 						node: oEntry.node
@@ -1273,6 +1196,11 @@ function getCallKind(node) {
 	if (name != null && isMatching(P.union("setTimeout", "clearTimeout"))(name)) return name;
 	return "other";
 }
+function getFunctionKind(node) {
+	if (isUseEffectSetupCallback(node)) return "setup";
+	if (isUseEffectCleanupCallback(node)) return "cleanup";
+	return "other";
+}
 var no_leaked_timeout_default = createRule({
 	meta: {
 		type: "problem",
@@ -1291,70 +1219,49 @@ function create(context) {
 	if (!context.sourceCode.text.includes("setTimeout")) return {};
 	const fEntries = [];
 	const sEntries = [];
-	const rEntries = [];
+	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
-			});
+			fEntries.push(getFunctionKind(node));
 		},
 		[":function:exit"]() {
 			fEntries.pop();
 		},
 		["CallExpression"](node) {
-			const fEntry = fEntries.findLast((f) => f.kind !== "other");
-			if (!ComponentPhaseRelevance.has(fEntry?.kind)) return;
-			switch (getCallKind(node)) {
-				case "setTimeout": {
-					const timeoutIdNode = resolveEnclosingAssignmentTarget(node);
-					if (timeoutIdNode == null) {
-						context.report({
-							messageId: "expectedTimeoutId",
-							node
-						});
-						break;
-					}
-					sEntries.push({
-						kind: "timeout",
-						callee: node.callee,
-						node,
-						phase: fEntry.kind,
-						timerId: timeoutIdNode
-					});
-					break;
-				}
-				case "clearTimeout": {
-					const [timeoutIdNode] = node.arguments;
-					if (timeoutIdNode == null) break;
-					rEntries.push({
-						kind: "timeout",
-						callee: node.callee,
-						node,
-						phase: fEntry.kind,
-						timerId: timeoutIdNode
+			if (fEntries.findLast((kind) => kind !== "other") == null) return;
+			match(getCallKind(node)).with("setTimeout", () => {
+				const timeoutIdNode = resolveEnclosingAssignmentTarget(node);
+				if (timeoutIdNode == null) {
+					context.report({
+						messageId: "expectedTimeoutId",
+						node
 					});
-					break;
+					return;
 				}
-			}
+				sEntries.push({
+					node,
+					timerId: timeoutIdNode
+				});
+			}).with("clearTimeout", () => {
+				const [timeoutIdNode] = node.arguments;
+				if (timeoutIdNode == null) return;
+				cEntries.push({
+					node,
+					timerId: timeoutIdNode
+				});
+			}).otherwise(() => null);
 		},
 		["Program:exit"]() {
 			for (const sEntry of sEntries) {
-				if (rEntries.some((rEntry) => isInverseEntry(sEntry, rEntry))) continue;
-				switch (sEntry.phase) {
-					case "setup":
-					case "cleanup":
-						context.report({
-							data: { kind: "useEffect" },
-							messageId: "expectedClearTimeoutInCleanup",
-							node: sEntry.node
-						});
-						continue;
-				}
+				if (cEntries.some((cEntry) => isInverseEntry(sEntry, cEntry))) continue;
+				context.report({
+					data: { kind: "useEffect" },
+					messageId: "expectedClearTimeoutInCleanup",
+					node: sEntry.node
+				});
 			}
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-web-api",
-  "version": "5.20.3",
+  "version": "5.20.4",
   "description": "ESLint React's ESLint plugin for interacting with Web APIs",
   "keywords": [
     "react",
@@ -37,14 +37,13 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.20.3",
-    "@eslint-react/core": "5.20.3",
-    "@eslint-react/eslint": "5.20.3",
-    "@eslint-react/shared": "5.20.3",
-    "@eslint-react/var": "5.20.3",
+    "@eslint-react/ast": "5.20.4",
+    "@eslint-react/core": "5.20.4",
+    "@eslint-react/eslint": "5.20.4",
+    "@eslint-react/shared": "5.20.4",
+    "@eslint-react/var": "5.20.4",
     "@typescript-eslint/types": "^8.70.0",
     "@typescript-eslint/utils": "^8.70.0",
-    "birecord": "^0.1.2",
     "ts-pattern": "^5.9.0"
   },
   "devDependencies": {