eslint-plugin-react-web-api 4.2.4-beta.0 → 5.0.0-beta.0

package/README.md

@@ -36,7 +36,7 @@ export default defineConfig(
 
 ## Rules
 
-<https://eslint-react.xyz/docs/rules/overview#web-api-rules>
+<https://eslint-react.xyz/docs/rules#web-api-rules>
 
 ## Rules to be implemented
 

package/dist/index.js

@@ -26,138 +26,13 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-react-web-api";
-var version = "4.2.4-beta.0";
-
-//#endregion
-//#region ../../../.pkgs/eff/dist/index.js
-function or(a, b) {
-	return (data) => a(data) || b(data);
-}
-/**
-* Creates a function that can be used in a data-last (aka `pipe`able) or
-* data-first style.
-*
-* The first parameter to `dual` is either the arity of the uncurried function
-* or a predicate that determines if the function is being used in a data-first
-* or data-last style.
-*
-* Using the arity is the most common use case, but there are some cases where
-* you may want to use a predicate. For example, if you have a function that
-* takes an optional argument, you can use a predicate to determine if the
-* function is being used in a data-first or data-last style.
-*
-* You can pass either the arity of the uncurried function or a predicate
-* which determines if the function is being used in a data-first or
-* data-last style.
-*
-* **Example** (Using arity to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using call signatures to define the overloads)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using a predicate to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body - The function to be curried.
-* @since 1.0.0
-*/
-const dual = function(arity, body) {
-	if (typeof arity === "function") return function() {
-		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
-	};
-	switch (arity) {
-		case 0:
-		case 1: throw new RangeError(`Invalid arity ${arity}`);
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body(a, b);
-			return function(self) {
-				return body(self, a);
-			};
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body(a, b, c);
-			return function(self) {
-				return body(self, a, b);
-			};
-		};
-		default: return function() {
-			if (arguments.length >= arity) return body.apply(this, arguments);
-			const args = arguments;
-			return function(self) {
-				return body(self, ...args);
-			};
-		};
-	}
-};
-/**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
-*
-* @param self - The first function to apply (or the composed function in data-last style).
-* @param bc - The second function to apply.
-* @returns A composed function that applies both functions in sequence.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { compose } from "effect/Function"
-*
-* const increment = (n: number) => n + 1;
-* const square = (n: number) => n * n;
-*
-* assert.strictEqual(compose(increment, square)(2), 9);
-* ```
-*
-* @since 1.0.0
-*/
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+var version = "5.0.0-beta.0";
 
 //#endregion
 //#region src/types/component-phase.ts
-const ComponentPhaseRelevance = birecord({
-	mount: "unmount",
-	setup: "cleanup"
-});
-const isInversePhase = dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
+const ComponentPhaseRelevance = birecord({ setup: "cleanup" });
 function getPhaseKindOfFunction(node) {
-	return match(node).when(core.isUseEffectSetupCallback, () => "setup").when(core.isUseEffectCleanupCallback, () => "cleanup").when(core.isComponentDidMountCallback, () => "mount").when(core.isComponentWillUnmountCallback, () => "unmount").otherwise(() => null);
+	return match(node).when(core.isUseEffectSetupCallback, () => "setup").when(core.isUseEffectCleanupCallback, () => "cleanup").otherwise(() => null);
 }
 
 //#endregion
@@ -234,7 +109,6 @@ var no_leaked_event_listener_default = createRule({
 		docs: { description: "Enforces that every 'addEventListener' in a component or custom hook has a corresponding 'removeEventListener'." },
 		messages: {
 			expectedRemoveEventListenerInCleanup: "An 'addEventListener' in '{{effectMethodKind}}' should have a corresponding 'removeEventListener' in its cleanup function.",
-			expectedRemoveEventListenerInUnmount: "An 'addEventListener' in 'componentDidMount' should have a corresponding 'removeEventListener' in 'componentWillUnmount' method.",
 			unexpectedInlineFunction: "A/an '{{eventMethodKind}}' should not have an inline listener function."
 		},
 		schema: []
@@ -245,7 +119,7 @@ var no_leaked_event_listener_default = createRule({
 });
 function create$3(context) {
 	if (!context.sourceCode.text.includes("addEventListener")) return {};
-	if (!/use\w*Effect|componentDidMount|componentWillUnmount/u.test(context.sourceCode.text)) return {};
+	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const fEntries = [];
 	const aEntries = [];
 	const rEntries = [];
@@ -259,7 +133,7 @@ function create$3(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 (!isInversePhase(aPhase, rPhase)) return false;
+		if (ComponentPhaseRelevance.get(aPhase) !== rPhase) return false;
 		return isSameObject(aCallee, rCallee) && ast.isNodeEqual(aListener, rListener) && isValueEqual(context, aType, rType) && aCapture === rCapture;
 	}
 	function checkInlineFunction(node, callKind, options) {
@@ -288,7 +162,7 @@ function create$3(context) {
 			if (fKind == null) return;
 			if (!ComponentPhaseRelevance.has(fKind)) return;
 			match(getCallKind$3(node)).with("addEventListener", (callKind) => {
-				if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.object.type === AST_NODE_TYPES.Identifier && core.isInitializedFromReactNative(node.callee.object.name, context.sourceCode.getScope(node))) return;
+				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;
 				const opts = options == null ? defaultOptions : getOptions(context, options);
@@ -335,13 +209,6 @@ function create$3(context) {
 							node: aEntry.node
 						});
 						continue;
-					case "mount":
-					case "unmount":
-						context.report({
-							messageId: "expectedRemoveEventListenerInUnmount",
-							node: aEntry.node
-						});
-						continue;
 				}
 			}
 		}
@@ -364,7 +231,6 @@ var no_leaked_interval_default = createRule({
 		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.",
-			expectedClearIntervalInUnmount: "A 'setInterval' created in '{{ kind }}' must be cleared with 'clearInterval' in the 'componentWillUnmount' method.",
 			expectedIntervalId: "A 'setInterval' must be assigned to a variable for proper cleanup."
 		},
 		schema: []
@@ -444,20 +310,133 @@ function create$2(context) {
 							node: sEntry.node
 						});
 						continue;
-					case "mount":
-					case "unmount":
-						context.report({
-							data: { kind: "componentDidMount" },
-							messageId: "expectedClearIntervalInUnmount",
-							node: sEntry.node
-						});
-						continue;
 				}
 			}
 		}
 	});
 }
 
+//#endregion
+//#region ../../../.pkgs/eff/dist/index.js
+function or(a, b) {
+	return (data) => a(data) || b(data);
+}
+/**
+* Creates a function that can be used in a data-last (aka `pipe`able) or
+* data-first style.
+*
+* The first parameter to `dual` is either the arity of the uncurried function
+* or a predicate that determines if the function is being used in a data-first
+* or data-last style.
+*
+* Using the arity is the most common use case, but there are some cases where
+* you may want to use a predicate. For example, if you have a function that
+* takes an optional argument, you can use a predicate to determine if the
+* function is being used in a data-first or data-last style.
+*
+* You can pass either the arity of the uncurried function or a predicate
+* which determines if the function is being used in a data-first or
+* data-last style.
+*
+* **Example** (Using arity to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using call signatures to define the overloads)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using a predicate to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
+* @since 1.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { compose } from "effect/Function"
+*
+* const increment = (n: number) => n + 1;
+* const square = (n: number) => n * n;
+*
+* assert.strictEqual(compose(increment, square)(2), 9);
+* ```
+*
+* @since 1.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+
 //#endregion
 //#region src/rules/no-leaked-resize-observer/no-leaked-resize-observer.ts
 const RULE_NAME$1 = "no-leaked-resize-observer";
@@ -616,7 +595,6 @@ var no_leaked_timeout_default = createRule({
 		docs: { description: "Enforces that every 'setTimeout' in a component or custom hook has a corresponding 'clearTimeout'." },
 		messages: {
 			expectedClearTimeoutInCleanup: "A 'setTimeout' created in '{{ kind }}' must be cleared with 'clearTimeout' in the cleanup function.",
-			expectedClearTimeoutInUnmount: "A 'setTimeout' created in '{{ kind }}' must be cleared with 'clearTimeout' in the 'componentWillUnmount' method.",
 			expectedTimeoutId: "A 'setTimeout' must be assigned to a variable for proper cleanup."
 		},
 		schema: []
@@ -692,14 +670,6 @@ function create(context) {
 							node: sEntry.node
 						});
 						continue;
-					case "mount":
-					case "unmount":
-						context.report({
-							data: { kind: "componentDidMount" },
-							messageId: "expectedClearTimeoutInUnmount",
-							node: sEntry.node
-						});
-						continue;
 				}
 			}
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-web-api",
-  "version": "4.2.4-beta.0",
+  "version": "5.0.0-beta.0",
   "description": "ESLint React's ESLint plugin for interacting with Web APIs",
   "keywords": [
     "react",
@@ -43,15 +43,15 @@
     "@typescript-eslint/utils": "^8.58.0",
     "birecord": "^0.1.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "4.2.4-beta.0",
-    "@eslint-react/core": "4.2.4-beta.0",
-    "@eslint-react/shared": "4.2.4-beta.0",
-    "@eslint-react/var": "4.2.4-beta.0"
+    "@eslint-react/ast": "5.0.0-beta.0",
+    "@eslint-react/shared": "5.0.0-beta.0",
+    "@eslint-react/var": "5.0.0-beta.0",
+    "@eslint-react/core": "5.0.0-beta.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "eslint": "^10.1.0",
+    "eslint": "^10.2.0",
     "tsdown": "^0.21.7",
     "@local/configs": "0.0.0",
     "@local/eff": "3.0.0-beta.72"