eslint-plugin-react-web-api 5.24.0-beta.2 → 5.24.1

package/dist/index.js

@@ -27,7 +27,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-react-web-api";
-var version = "5.24.0-beta.2";
+var version = "5.24.1";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -38,19 +38,6 @@ const createRule = ESLintUtils.RuleCreator(getDocsUrl);
 
 //#endregion
 //#region ../../.pkgs/eff/dist/index.js
-function or(a, b) {
-	return (data) => a(data) || b(data);
-}
-/**
-* A function that checks if the passed parameter is a string and narrows its type accordingly.
-*
-* @param data - The variable to check.
-* @returns True if the passed input is a string, false otherwise.
-* @category guards
-*/
-function isString(data) {
-	return typeof data === "string";
-}
 /**
 * Applies a `pipe` method's variadic arguments to an initial value from left
 * to right.
@@ -83,7 +70,7 @@ function isString(data) {
 *   (n) => n + 2,
 *   (n) => n * 3
 * )
-* console.log(result) // 21
+* result // => 21
 * ```
 *
 * @category combinators
@@ -140,16 +127,6 @@ const Class = (function() {
 	return PipeableBase;
 })();
 /**
-* Provides small helpers for defining and reusing TypeScript functions.
-*
-* The main helpers are `pipe` and `flow` for left-to-right composition and
-* `dual` for APIs that support both direct and pipe-friendly call styles. The
-* module also contains small identity, constant, tuple, type-level, and
-* memoization helpers used across the library.
-*
-* @since 2.0.0
-*/
-/**
 * Creates a function that can be called in data-first style or data-last
 * (`pipe`-friendly) style.
 *
@@ -174,8 +151,8 @@ const Class = (function() {
 *   (self: number, that: number) => number
 * >(2, (self, that) => self + that)
 *
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
 * ```
 *
 * **Example** (Defining overloads with call signatures)
@@ -188,8 +165,8 @@ const Class = (function() {
 *   (self: number, that: number): number
 * } = Function.dual(2, (self: number, that: number): number => self + that)
 *
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
 * ```
 *
 * **Example** (Selecting data-first or data-last style with a predicate)
@@ -205,8 +182,8 @@ const Class = (function() {
 *   (self, that) => self + that
 * )
 *
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
+* sum(2, 3) // => 5
+* pipe(2, sum(3)) // => 5
 * ```
 *
 * @category combinators
@@ -251,9 +228,8 @@ const dual = function(arity, body) {
 *
 * ```ts
 * import { identity } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(identity(5), 5)
+* identity(5) // => 5
 * ```
 *
 * @category combinators
@@ -291,12 +267,11 @@ const cast = identity;
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
 * const constNull = Function.constant(null)
 *
-* assert.deepStrictEqual(constNull(), null)
-* assert.deepStrictEqual(constNull(), null)
+* constNull() // => null
+* constNull() // => null
 * ```
 *
 * @category constructors
@@ -314,9 +289,8 @@ const constant = (value) => () => value;
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constTrue(), true)
+* Function.constTrue() // => true
 * ```
 *
 * @category constants
@@ -334,9 +308,8 @@ const constTrue = constant(true);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constFalse(), false)
+* Function.constFalse() // => false
 * ```
 *
 * @category constants
@@ -354,9 +327,8 @@ const constFalse = constant(false);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constNull(), null)
+* Function.constNull() // => null
 * ```
 *
 * @category constants
@@ -374,9 +346,8 @@ const constNull = constant(null);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
-* assert.deepStrictEqual(Function.constUndefined(), undefined)
+* Function.constUndefined() // => undefined
 * ```
 *
 * @category constants
@@ -395,12 +366,11 @@ const constUndefined = constant(void 0);
 *
 * ```ts
 * import { Function } from "effect"
-* import * as assert from "node:assert"
 *
 * const increment = (n: number) => n + 1
 * const square = (n: number) => n * n
 *
-* assert.strictEqual(Function.compose(increment, square)(2), 9)
+* Function.compose(increment, square)(2) // => 9
 * ```
 *
 * @see {@link flow} for composing a left-to-right sequence of functions
@@ -463,13 +433,347 @@ const absurd = (_) => {
 *   name: hole<string>()
 * })
 *
-* console.log(typeof buildUser) // "function"
 * ```
 *
 * @category utility types
 * @since 2.0.0
 */
 const hole = cast(absurd);
+/**
+* Creates a predicate that returns `true` only if both predicates are `true`.
+*
+* **When to use**
+*
+* Use when you want to combine `Predicate`s with AND, accepting values that
+* satisfy multiple conditions, including refinements that narrow to an
+* intersection.
+*
+* **Details**
+*
+* Evaluation short-circuits on the first `false`. For refinements, the output
+* type is an intersection.
+*
+* **Example** (Checking both conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const hasAAndB = Predicate.and(
+*   Predicate.hasProperty("a"),
+*   Predicate.hasProperty("b")
+* )
+*
+* const input: unknown = JSON.parse(`{"a":1,"b":"ok"}`)
+* if (hasAAndB(input)) {
+*   // input has both properties at this point
+*   const a = input.a
+*   const b = input.b
+*
+*   const values = [a, b] // => [1, "ok"]
+* }
+* ```
+*
+* @see {@link or}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
+*/
+const and = dual(2, (a, b) => (data) => a(data) && b(data));
+/**
+* Creates a predicate that returns `true` if either predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine `Predicate`s with OR, accepting values that
+* satisfy at least one condition, including refinements that narrow to a union.
+*
+* **Details**
+*
+* Evaluation short-circuits on the first `true`. For refinements, the output
+* type is a union.
+*
+* **Example** (Checking either condition)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isStringOrNumber = Predicate.or(Predicate.isString, Predicate.isNumber)
+*
+* isStringOrNumber("a") // => true
+* ```
+*
+* @see {@link and}
+* @see {@link xor}
+* @category combinators
+* @since 2.0.0
+*/
+const or = dual(2, (a, b) => (data) => a(data) || b(data));
+/**
+* Creates a predicate that returns `true` if exactly one predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine two `Predicate`s with exclusive-or semantics.
+*
+* **Details**
+*
+* Returns `true` when results differ.
+*
+* **Example** (Checking exclusive-or conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isEven = (n: number) => n % 2 === 0
+* const isPositive = (n: number) => n > 0
+* const either = Predicate.xor(isEven, isPositive)
+*
+* either(-2) // => true
+* ```
+*
+* @see {@link or}
+* @see {@link and}
+* @category combinators
+* @since 2.0.0
+*/
+const xor = dual(2, (a, b) => (data) => a(data) !== b(data));
+/**
+* Creates a predicate that returns `true` when both predicates agree.
+*
+* **When to use**
+*
+* Use when you want to check equivalence of two `Predicate`s.
+*
+* **Details**
+*
+* Returns `true` when both results are equal.
+*
+* **Example** (Defining equivalence)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isEven = (n: number) => n % 2 === 0
+* const same = Predicate.eqv(isEven, isEven)
+*
+* same(3) // => true
+* ```
+*
+* @see {@link xor}
+* @category combinators
+* @since 2.0.0
+*/
+const eqv = dual(2, (a, b) => (data) => a(data) === b(data));
+/**
+* Creates a predicate representing logical implication: if `antecedent`, then `consequent`.
+*
+* **When to use**
+*
+* Use when you need to encode logical implication between `Predicate` rules,
+* where one rule only applies when a precondition holds.
+*
+* **Details**
+*
+* Models constraints like "if A then B" and returns `true` when the antecedent
+* is `false`.
+*
+* **Example** (Checking implication)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const isAdult = (age: number) => age >= 18
+* const canVote = (age: number) => age >= 18
+* const implies = Predicate.implies(isAdult, canVote)
+*
+* implies(16) // => true
+* ```
+*
+* @see {@link and}
+* @see {@link or}
+* @category combinators
+* @since 2.0.0
+*/
+const implies = dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
+/**
+* Creates a predicate that returns `true` when neither predicate is `true`.
+*
+* **When to use**
+*
+* Use when you want to combine two `Predicate`s with logical NOR semantics.
+*
+* **Details**
+*
+* Returns the negation of `or`.
+*
+* **Example** (Checking NOR conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const neither = Predicate.nor(Predicate.isString, Predicate.isNumber)
+*
+* neither(true) // => true
+* ```
+*
+* @see {@link or}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
+*/
+const nor = dual(2, (a, b) => (data) => !a(data) && !b(data));
+/**
+* Creates a predicate that returns `true` unless both predicates are `true`.
+*
+* **When to use**
+*
+* Use when you want to combine two `Predicate`s with logical NAND semantics.
+*
+* **Details**
+*
+* Returns the negation of `and`.
+*
+* **Example** (Checking NAND conditions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const notBoth = Predicate.nand(Predicate.isString, Predicate.isNumber)
+*
+* notBoth("a") // => true
+* ```
+*
+* @see {@link and}
+* @see {@link not}
+* @category combinators
+* @since 2.0.0
+*/
+const nand = dual(2, (a, b) => (data) => !a(data) || !b(data));
+/**
+* Checks whether a value is a `string`.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard to narrow an `unknown` value to a
+* string.
+*
+* **Details**
+*
+* Uses `typeof input === "string"`.
+*
+* **Example** (Guarding strings)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const data: unknown = "hi"
+*
+* if (Predicate.isString(data)) {
+*   data.toUpperCase() // => "HI"
+* }
+* ```
+*
+* @see {@link isNumber}
+* @see {@link isBoolean}
+* @see {@link Refinement}
+* @category guards
+* @since 2.0.0
+*/
+function isString(input) {
+	return typeof input === "string";
+}
+/**
+* Checks whether a value is a `function`.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard to narrow an `unknown` value to a
+* callable function.
+*
+* **Details**
+*
+* Uses `typeof input === "function"`.
+*
+* **Example** (Guarding functions)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const data: unknown = () => 1
+*
+* if (Predicate.isFunction(data)) {
+*   data() // => 1
+* }
+* ```
+*
+* @see {@link isObjectKeyword}
+* @category guards
+* @since 2.0.0
+*/
+function isFunction(input) {
+	return typeof input === "function";
+}
+/**
+* Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard that accepts arrays and functions as
+* well as objects.
+*
+* **Details**
+*
+* Returns `true` for arrays and functions, and `false` for `null`.
+*
+* **Example** (Checking object keywords)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* Predicate.isObjectKeyword(() => 1) // => true
+* Predicate.isObjectKeyword(null) // => false
+* ```
+*
+* @see {@link isObject}
+* @see {@link isObjectOrArray}
+* @category guards
+* @since 4.0.0
+*/
+function isObjectKeyword(input) {
+	return typeof input === "object" && input !== null || isFunction(input);
+}
+/**
+* Checks whether a value has a given property key.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` guard for property access on `unknown`
+* values with a simple structural object check.
+*
+* **Details**
+*
+* Uses the `in` operator and `isObjectKeyword`. This does not check property
+* value types.
+*
+* **Example** (Guarding object properties)
+*
+* ```ts
+* import { Predicate } from "effect"
+*
+* const hasName = Predicate.hasProperty("name")
+* const data: unknown = { name: "Ada" }
+*
+* if (hasName(data)) {
+*   data.name // => "Ada"
+* }
+* ```
+*
+* @see {@link isTagged}
+* @see {@link isObjectKeyword}
+* @category guards
+* @since 2.0.0
+*/
+const hasProperty = dual(2, (data, property) => isObjectKeyword(data) && property in data);
 function getOrInsertComputed(map, key, callback) {
 	if (map.has(key)) return map.get(key);
 	const value = callback(key);
@@ -477,56 +781,72 @@ function getOrInsertComputed(map, key, callback) {
 	return value;
 }
 /**
-* Drops the longest prefix of elements from an array that satisfy the given predicate.
+* Drops elements from the start while the predicate holds, returning the rest.
+*
+* **When to use**
 *
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
+* Use to remove a leading prefix of elements that satisfy a predicate.
 *
-* @param pred - The predicate to test each element with.
-* @returns A new array without the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { dropWhile, pipe } from "@local/eff"
+* **Details**
+*
+* The predicate receives `(element, index)`.
+*
+* **Example** (Dropping while condition holds)
 *
-* // data-first
-* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
+* ```ts
+* import { Array } from "effect"
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
+* Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4) // => [4, 5]
 * ```
-* @category array
+*
+* @see {@link takeWhile} — keep the matching prefix instead
+* @see {@link drop} — drop a fixed count
+*
+* @category getters
+* @since 2.0.0
 */
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const dropWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(idx);
 });
 /**
-* Takes the longest prefix of elements from an array that satisfy the given predicate.
+* Takes elements from the start while the predicate holds, stopping at the
+* first element that fails.
 *
-* Supports both data-first and data-last (`pipe`-friendly) call styles.
+* **When to use**
 *
-* @param pred - The predicate to test each element with.
-* @returns A new array containing only the matching prefix.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { pipe, takeWhile } from "@local/eff"
+* Use to keep the leading elements of an iterable while each element satisfies
+* a predicate, returning the retained prefix as an array.
+*
+* **Details**
+*
+* Supports refinements for type narrowing. The predicate receives
+* `(element, index)`.
 *
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+* **Example** (Taking while condition holds)
+*
+* ```ts
+* import { Array } from "effect"
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
+* Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
 * ```
-* @category array
+*
+* @see {@link take} for keeping a fixed number of leading elements
+* @see {@link dropWhile} for removing the matching prefix and keeping the rest
+* @see {@link span} for splitting the matching prefix from the remaining elements
+*
+* @category getters
+* @since 2.0.0
 */
-const takeWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
+const takeWhile = dual(2, (self, predicate) => {
+	const input = Array.isArray(self) ? self : Array.from(self);
+	const len = input.length;
 	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(0, idx);
+	while (idx < len && predicate(input[idx], idx)) idx++;
+	return input.slice(0, idx);
 });
 
 //#endregion
@@ -584,6 +904,7 @@ function getOptions(context, node) {
 //#endregion
 //#region src/rules/no-leaked-event-listener/no-leaked-event-listener.ts
 const RULE_NAME$5 = "no-leaked-event-listener";
+const isUseEffectCallback$5 = or(isUseEffectSetupCallback, isUseEffectCleanupCallback);
 function getCallKind$5(node) {
 	const name = Extract.getCalleeName(node);
 	if (name != null && isMatching(P.union("addEventListener", "removeEventListener"))(name)) return name;
@@ -691,7 +1012,7 @@ function create$5(context) {
 	}
 	return {
 		["CallExpression"](node) {
-			const fn = Traverse.findParent(node, (n) => isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n));
+			const fn = Traverse.findParent(node, isUseEffectCallback$5);
 			if (fn == null) return;
 			const fKind = isUseEffectSetupCallback(fn) ? "setup" : "cleanup";
 			const setupFn = fKind === "setup" ? fn : Traverse.findParent(fn, Check.isFunction);
@@ -773,6 +1094,7 @@ function resolveToObjectExpression(context, node) {
 //#endregion
 //#region src/rules/no-leaked-fetch/no-leaked-fetch.ts
 const RULE_NAME$4 = "no-leaked-fetch";
+const isUseEffectCallback$4 = or(isUseEffectSetupCallback, isUseEffectCleanupCallback);
 function getCallKind$4(node) {
 	const name = Extract.getCalleeName(node);
 	if (name != null && isMatching(P.union("fetch", "abort"))(name)) return name;
@@ -861,7 +1183,7 @@ function create$4(context) {
 					node
 				});
 			}).with("abort", () => {
-				const fn = Traverse.findParent(node, (n) => isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n));
+				const fn = Traverse.findParent(node, isUseEffectCallback$4);
 				if (fn == null || !isUseEffectCleanupCallback(fn)) return;
 				const controller = getAbortController(node);
 				if (controller == null) return;
@@ -912,6 +1234,7 @@ function isFromObserver$1(context, node, name) {
 //#endregion
 //#region src/rules/no-leaked-intersection-observer/no-leaked-intersection-observer.ts
 const RULE_NAME$3 = "no-leaked-intersection-observer";
+const isUseEffectCallback$3 = or(isUseEffectSetupCallback, isUseEffectCleanupCallback);
 function getCallKind$3(context, node) {
 	const callee = Extract.unwrap(node.callee);
 	if (callee.type !== AST_NODE_TYPES.MemberExpression) return "other";
@@ -942,7 +1265,7 @@ function create$3(context) {
 	const dEntries = [];
 	return {
 		["CallExpression"](node) {
-			if (Traverse.findParent(node, (n) => isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n)) == null) return;
+			if (Traverse.findParent(node, isUseEffectCallback$3) == null) return;
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
 			const { object } = callee;
@@ -973,7 +1296,7 @@ function create$3(context) {
 			}).otherwise(() => null);
 		},
 		["NewExpression"](node) {
-			const fn = Traverse.findParent(node, (n) => Check.isFunction(n) && (isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n)));
+			const fn = Traverse.findParent(node, and(Check.isFunction, isUseEffectCallback$3));
 			if (fn == null) return;
 			if (!isNewObserver$1(node, "IntersectionObserver")) return;
 			const id = resolveEnclosingAssignmentTarget(node);
@@ -1020,6 +1343,7 @@ function create$3(context) {
 //#endregion
 //#region src/rules/no-leaked-interval/no-leaked-interval.ts
 const RULE_NAME$2 = "no-leaked-interval";
+const isUseEffectCallback$2 = or(isUseEffectSetupCallback, isUseEffectCleanupCallback);
 function getCallKind$2(node) {
 	const name = Extract.getCalleeName(node);
 	if (name != null && isMatching(P.union("setInterval", "clearInterval"))(name)) return name;
@@ -1048,7 +1372,7 @@ function create$2(context) {
 	}
 	return {
 		["CallExpression"](node) {
-			if (Traverse.findParent(node, (n) => isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n)) == null) return;
+			if (Traverse.findParent(node, isUseEffectCallback$2) == null) return;
 			match(getCallKind$2(node)).with("setInterval", () => {
 				const intervalIdNode = resolveEnclosingAssignmentTarget(node);
 				if (intervalIdNode == null) {
@@ -1105,6 +1429,7 @@ function isFromObserver(context, node, name) {
 //#endregion
 //#region src/rules/no-leaked-resize-observer/no-leaked-resize-observer.ts
 const RULE_NAME$1 = "no-leaked-resize-observer";
+const isUseEffectCallback$1 = or(isUseEffectSetupCallback, isUseEffectCleanupCallback);
 function getCallKind$1(context, node) {
 	const callee = Extract.unwrap(node.callee);
 	if (callee.type !== AST_NODE_TYPES.MemberExpression) return "other";
@@ -1135,7 +1460,7 @@ function create$1(context) {
 	const dEntries = [];
 	return {
 		["CallExpression"](node) {
-			if (Traverse.findParent(node, (n) => isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n)) == null) return;
+			if (Traverse.findParent(node, isUseEffectCallback$1) == null) return;
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
 			const { object } = callee;
@@ -1166,7 +1491,7 @@ function create$1(context) {
 			}).otherwise(() => null);
 		},
 		["NewExpression"](node) {
-			const fn = Traverse.findParent(node, (n) => Check.isFunction(n) && (isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n)));
+			const fn = Traverse.findParent(node, and(Check.isFunction, isUseEffectCallback$1));
 			if (fn == null) return;
 			if (!isNewObserver(node, "ResizeObserver")) return;
 			const id = resolveEnclosingAssignmentTarget(node);
@@ -1213,6 +1538,7 @@ function create$1(context) {
 //#endregion
 //#region src/rules/no-leaked-timeout/no-leaked-timeout.ts
 const RULE_NAME = "no-leaked-timeout";
+const isUseEffectCallback = or(isUseEffectSetupCallback, isUseEffectCleanupCallback);
 function getCallKind(node) {
 	const name = Extract.getCalleeName(node);
 	if (name != null && isMatching(P.union("setTimeout", "clearTimeout"))(name)) return name;
@@ -1241,7 +1567,7 @@ function create(context) {
 	}
 	return {
 		["CallExpression"](node) {
-			if (Traverse.findParent(node, (n) => isUseEffectSetupCallback(n) || isUseEffectCleanupCallback(n)) == null) return;
+			if (Traverse.findParent(node, isUseEffectCallback) == null) return;
 			match(getCallKind(node)).with("setTimeout", () => {
 				const timeoutIdNode = resolveEnclosingAssignmentTarget(node);
 				if (timeoutIdNode == null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-web-api",
-  "version": "5.24.0-beta.2",
+  "version": "5.24.1",
   "description": "ESLint React's ESLint plugin for interacting with Web APIs",
   "keywords": [
     "react",
@@ -37,11 +37,11 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.24.0-beta.2",
-    "@eslint-react/core": "5.24.0-beta.2",
-    "@eslint-react/eslint": "5.24.0-beta.2",
-    "@eslint-react/shared": "5.24.0-beta.2",
-    "@eslint-react/var": "5.24.0-beta.2",
+    "@eslint-react/ast": "5.24.1",
+    "@eslint-react/core": "5.24.1",
+    "@eslint-react/eslint": "5.24.1",
+    "@eslint-react/shared": "5.24.1",
+    "@eslint-react/var": "5.24.1",
     "@typescript-eslint/types": "^8.71.0",
     "@typescript-eslint/utils": "^8.71.0",
     "ts-pattern": "^5.9.0"
@@ -53,7 +53,7 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "dedent": "^1.7.2",
-    "eslint": "^10.11.0",
+    "eslint": "^10.12.0",
     "tsdown": "^0.23.0",
     "typescript": "6.0.3"
   },