eslint-plugin-react-hooks-extra 2.0.0-next.61 → 2.0.0

package/README.md

@@ -17,26 +17,30 @@ npm install --save-dev eslint-plugin-react-hooks-extra
 // @ts-check
 import js from "@eslint/js";
 import reactHooksExtra from "eslint-plugin-react-hooks-extra";
+import { defineConfig } from "eslint/config";
 import tseslint from "typescript-eslint";
 
-export default tseslint.config({
-  files: ["**/*.ts", "**/*.tsx"],
-  extends: [
-    js.configs.recommended,
-    tseslint.configs.recommended,
-    reactHooksExtra.configs.recommended,
-  ],
-  languageOptions: {
-    parser: tseslint.parser,
-    parserOptions: {
-      projectService: true,
-      tsconfigRootDir: import.meta.dirname,
+export default defineConfig([
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooksExtra.configs.recommended,
+    ],
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      // Put rules you want to override here
+      "react-hooks-extra/no-direct-set-state-in-use-effect": "warn",
     },
   },
-  rules: {
-    // Put rules you want to override here
-  },
-});
+]);
 ```
 
 ## Rules

package/dist/index.d.ts

@@ -9,10 +9,6 @@ declare const _default: {
       rules?: Record<string, _eslint_react_kit0.RuleConfig>;
       settings?: _eslint_react_kit0.SettingsConfig;
     };
-    "recommended-legacy": {
-      plugins: string[];
-      rules: Record<string, _eslint_react_kit0.RuleConfig<unknown[]>> | undefined;
-    };
   };
   meta: {
     name: string;

package/dist/index.js

@@ -1,25 +1,27 @@
-import { getConfigAdapters, getDocsUrl, getSettingsFromContext } from "@eslint-react/shared";
+import { getConfigAdapters, getDocsUrl } from "@eslint-react/shared";
 import * as AST from "@eslint-react/ast";
 import * as ER from "@eslint-react/core";
-import { constVoid, getOrElseUpdate, identity, not } from "@eslint-react/eff";
+import { constVoid, getOrElseUpdate, not } from "@eslint-react/eff";
 import * as VAR from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { match } from "ts-pattern";
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
-var __export = (target, all) => {
+var __export = (all) => {
+	let target = {};
 	for (var name$2 in all) __defProp(target, name$2, {
 		get: all[name$2],
 		enumerable: true
 	});
+	return target;
 };
 
 //#endregion
 //#region src/configs/recommended.ts
-var recommended_exports = {};
-__export(recommended_exports, {
+var recommended_exports = /* @__PURE__ */ __export({
 	name: () => name$1,
 	rules: () => rules
 });
@@ -29,19 +31,48 @@ const rules = { "react-hooks-extra/no-direct-set-state-in-use-effect": "warn" };
 //#endregion
 //#region package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "2.0.0-next.61";
+var version = "2.0.0";
 
 //#endregion
-//#region src/rules-hooks/use-no-direct-set-state-in-use-effect.ts
-function useNoDirectSetStateInUseEffect(context, options) {
-	const { onViolation, useEffectKind } = options;
-	const settings = getSettingsFromContext(context);
-	const hooks = settings.additionalHooks;
-	const getText = (n) => context.sourceCode.getText(n);
-	const isUseEffectLikeCall = ER.isReactHookCallWithNameAlias(context, useEffectKind, hooks[useEffectKind]);
-	const isUseStateCall = ER.isReactHookCallWithNameAlias(context, "useState", hooks.useState);
-	const isUseMemoCall = ER.isReactHookCallWithNameAlias(context, "useMemo", hooks.useMemo);
-	const isUseCallbackCall = ER.isReactHookCallWithNameAlias(context, "useCallback", hooks.useCallback);
+//#region src/utils/create-rule.ts
+const createRule = ESLintUtils.RuleCreator(getDocsUrl("hooks-extra"));
+
+//#endregion
+//#region src/utils/is-variable-declarator-from-hook-call.ts
+function isInitFromHookCall(init) {
+	if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
+	switch (init.callee.type) {
+		case AST_NODE_TYPES.Identifier: return ER.isReactHookName(init.callee.name);
+		case AST_NODE_TYPES.MemberExpression: return init.callee.property.type === AST_NODE_TYPES.Identifier && ER.isReactHookName(init.callee.property.name);
+		default: return false;
+	}
+}
+function isVariableDeclaratorFromHookCall(node) {
+	if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+	if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
+	return isInitFromHookCall(node.init);
+}
+
+//#endregion
+//#region src/rules/no-direct-set-state-in-use-effect.ts
+const RULE_NAME = "no-direct-set-state-in-use-effect";
+const RULE_FEATURES = ["EXP"];
+var no_direct_set_state_in_use_effect_default = createRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
+			[Symbol.for("rule_features")]: RULE_FEATURES
+		},
+		messages: { noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'." },
+		schema: []
+	},
+	name: RULE_NAME,
+	create,
+	defaultOptions: []
+});
+function create(context) {
+	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
 	const functionEntries = [];
 	const setupFnRef = { current: null };
 	const setupFnIds = [];
@@ -50,6 +81,7 @@ function useNoDirectSetStateInUseEffect(context, options) {
 	const setStateInEffectArg = /* @__PURE__ */ new WeakMap();
 	const setStateInEffectSetup = /* @__PURE__ */ new Map();
 	const setStateInHookCallbacks = /* @__PURE__ */ new WeakMap();
+	const getText = (n) => context.sourceCode.getText(n);
 	const onSetupFunctionEnter = (node) => {
 		setupFnRef.current = node;
 	};
@@ -57,14 +89,14 @@ function useNoDirectSetStateInUseEffect(context, options) {
 		if (setupFnRef.current === node) setupFnRef.current = null;
 	};
 	function isFunctionOfUseEffectSetup(node) {
-		return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
+		return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && ER.isUseEffectLikeCall(node.parent);
 	}
 	function getCallName(node) {
 		if (node.type === AST_NODE_TYPES.CallExpression) return AST.toStringFormat(node.callee, getText);
 		return AST.toStringFormat(node, getText);
 	}
 	function getCallKind(node) {
-		return match(node).when(isUseStateCall, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(AST.isThenCall, () => "then").otherwise(() => "other");
+		return match(node).when(ER.isUseStateCall, () => "useState").when(ER.isUseEffectLikeCall, () => "useEffect").when(isSetStateCall, () => "setState").when(AST.isThenCall, () => "then").otherwise(() => "other");
 	}
 	function getFunctionKind(node) {
 		const parent = AST.findParentNode(node, not(AST.isTypeExpression)) ?? node.parent;
@@ -81,7 +113,7 @@ function useNoDirectSetStateInUseEffect(context, options) {
 		const variableNode = VAR.getVariableDefinitionNode(variable, 0);
 		if (variableNode == null) return false;
 		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
-		if (!ER.isReactHookCallWithNameAlias(context, "useState", hooks.useState)(variableNode)) return false;
+		if (!ER.isUseStateCall(variableNode)) return false;
 		const variableNodeParent = variableNode.parent;
 		if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
 		return variableNodeParent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === at;
@@ -96,24 +128,14 @@ function useNoDirectSetStateInUseEffect(context, options) {
 				const [index] = node.callee.arguments;
 				if (!isAt || index == null) return false;
 				const indexScope = context.sourceCode.getScope(node);
-				const indexValue = VAR.toStaticValue({
-					kind: "lazy",
-					node: index,
-					initialScope: indexScope
-				}).value;
-				return indexValue === 1 && isIdFromUseStateCall(callee.object);
+				return getStaticValue(index, indexScope)?.value === 1 && isIdFromUseStateCall(callee.object);
 			}
 			case AST_NODE_TYPES.Identifier: return isIdFromUseStateCall(node.callee, 1);
 			case AST_NODE_TYPES.MemberExpression: {
 				if (!("name" in node.callee.object)) return false;
 				const property = node.callee.property;
 				const propertyScope = context.sourceCode.getScope(node);
-				const propertyValue = VAR.toStaticValue({
-					kind: "lazy",
-					node: property,
-					initialScope: propertyScope
-				}).value;
-				return propertyValue === 1 && isIdFromUseStateCall(node.callee.object, 1);
+				return getStaticValue(property, propertyScope)?.value === 1 && isIdFromUseStateCall(node.callee.object, 1);
 			}
 			default: return false;
 		}
@@ -142,15 +164,19 @@ function useNoDirectSetStateInUseEffect(context, options) {
 					case pEntry.node.async: break;
 					case pEntry.node === setupFunction:
 					case pEntry.kind === "immediate" && AST.findParentNode(pEntry.node, AST.isFunction) === setupFunction:
-						onViolation(context, node, { name: context.sourceCode.getText(node.callee) });
+						context.report({
+							messageId: "noDirectSetStateInUseEffect",
+							node,
+							data: { name: context.sourceCode.getText(node.callee) }
+						});
 						return;
 					default: {
-						const vd = AST.findParentNode(node, isVariableDeclaratorFromHookCall);
-						if (vd == null) getOrElseUpdate(setStateCallsByFn, pEntry.node, () => []).push(node);
-						else getOrElseUpdate(setStateInHookCallbacks, vd.init, () => []).push(node);
+						const init = AST.findParentNode(node, isVariableDeclaratorFromHookCall)?.init;
+						if (init == null) getOrElseUpdate(setStateCallsByFn, pEntry.node, () => []).push(node);
+						else getOrElseUpdate(setStateInHookCallbacks, init, () => []).push(node);
 					}
 				}
-			}).with(useEffectKind, () => {
+			}).with("useEffect", () => {
 				if (AST.isFunction(node.arguments.at(0))) return;
 				setupFnIds.push(...AST.getNestedIdentifiers(node));
 			}).with("other", () => {
@@ -165,19 +191,19 @@ function useNoDirectSetStateInUseEffect(context, options) {
 				case AST_NODE_TYPES.ArrowFunctionExpression: {
 					const parent = node.parent.parent;
 					if (parent.type !== AST_NODE_TYPES.CallExpression) break;
-					if (!isUseMemoCall(parent)) break;
-					const vd = AST.findParentNode(parent, isVariableDeclaratorFromHookCall);
-					if (vd != null) getOrElseUpdate(setStateInEffectArg, vd.init, () => []).push(node);
+					if (!ER.isUseMemoCall(parent)) break;
+					const init = AST.findParentNode(parent, isVariableDeclaratorFromHookCall)?.init;
+					if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
 					break;
 				}
 				case AST_NODE_TYPES.CallExpression:
 					if (node !== node.parent.arguments.at(0)) break;
-					if (isUseCallbackCall(node.parent)) {
-						const vd = AST.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
-						if (vd != null) getOrElseUpdate(setStateInEffectArg, vd.init, () => []).push(node);
+					if (ER.isUseCallbackCall(node.parent)) {
+						const init = AST.findParentNode(node.parent, isVariableDeclaratorFromHookCall)?.init;
+						if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
 						break;
 					}
-					if (isUseEffectLikeCall(node.parent)) getOrElseUpdate(setStateInEffectSetup, node.parent, () => []).push(node);
+					if (ER.isUseEffectLikeCall(node.parent)) getOrElseUpdate(setStateInEffectSetup, node.parent, () => []).push(node);
 			}
 		},
 		"Program:exit"() {
@@ -191,433 +217,32 @@ function useNoDirectSetStateInUseEffect(context, options) {
 				}
 				return [];
 			};
-			for (const [, calls] of setStateInEffectSetup) for (const call of calls) onViolation(context, call, { name: call.name });
+			for (const [, calls] of setStateInEffectSetup) for (const call of calls) context.report({
+				messageId: "noDirectSetStateInUseEffect",
+				node: call,
+				data: { name: call.name }
+			});
 			for (const { callee } of trackedFnCalls) {
 				if (!("name" in callee)) continue;
 				const { name: name$2 } = callee;
 				const setStateCalls = getSetStateCalls(name$2, context.sourceCode.getScope(callee));
-				for (const setStateCall of setStateCalls) onViolation(context, setStateCall, { name: getCallName(setStateCall) });
+				for (const setStateCall of setStateCalls) context.report({
+					messageId: "noDirectSetStateInUseEffect",
+					node: setStateCall,
+					data: { name: getCallName(setStateCall) }
+				});
 			}
 			for (const id of setupFnIds) {
 				const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-				for (const setStateCall of setStateCalls) onViolation(context, setStateCall, { name: getCallName(setStateCall) });
-			}
-		}
-	};
-}
-function isInitFromHookCall(init) {
-	if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
-	switch (init.callee.type) {
-		case AST_NODE_TYPES.Identifier: return ER.isReactHookName(init.callee.name);
-		case AST_NODE_TYPES.MemberExpression: return init.callee.property.type === AST_NODE_TYPES.Identifier && ER.isReactHookName(init.callee.property.name);
-		default: return false;
-	}
-}
-function isVariableDeclaratorFromHookCall(node) {
-	if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
-	if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
-	return isInitFromHookCall(node.init);
-}
-
-//#endregion
-//#region src/utils/create-rule.ts
-const createRule = ESLintUtils.RuleCreator(getDocsUrl("hooks-extra"));
-
-//#endregion
-//#region src/rules/no-direct-set-state-in-use-effect.ts
-const RULE_NAME$5 = "no-direct-set-state-in-use-effect";
-const RULE_FEATURES$5 = ["EXP"];
-var no_direct_set_state_in_use_effect_default = createRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$5
-		},
-		messages: { noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'." },
-		schema: []
-	},
-	name: RULE_NAME$5,
-	create: create$5,
-	defaultOptions: []
-});
-function create$5(context) {
-	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-	return useNoDirectSetStateInUseEffect(context, {
-		onViolation(ctx, node, data) {
-			ctx.report({
-				messageId: "noDirectSetStateInUseEffect",
-				node,
-				data
-			});
-		},
-		useEffectKind: "useEffect"
-	});
-}
-
-//#endregion
-//#region src/rules/no-direct-set-state-in-use-layout-effect.ts
-const RULE_NAME$4 = "no-direct-set-state-in-use-layout-effect";
-const RULE_FEATURES$4 = ["EXP"];
-var no_direct_set_state_in_use_layout_effect_default = createRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow direct calls to the `set` function of `useState` in `useLayoutEffect`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$4
-		},
-		messages: { noDirectSetStateInUseLayoutEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useLayoutEffect'." },
-		schema: []
-	},
-	name: RULE_NAME$4,
-	create: create$4,
-	defaultOptions: []
-});
-function create$4(context) {
-	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-	return useNoDirectSetStateInUseEffect(context, {
-		onViolation(ctx, node, data) {
-			ctx.report({
-				messageId: "noDirectSetStateInUseLayoutEffect",
-				node,
-				data
-			});
-		},
-		useEffectKind: "useLayoutEffect"
-	});
-}
-
-//#endregion
-//#region src/rules-removed/no-unnecessary-use-callback.ts
-const RULE_NAME$3 = "no-unnecessary-use-callback";
-const RULE_FEATURES$3 = ["EXP"];
-var no_unnecessary_use_callback_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: {
-			deprecatedSince: "2.0.0",
-			replacedBy: [{
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "eslint-plugin-react-x",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x"
-				},
-				rule: {
-					name: "no-unnecessary-use-callback",
-					url: "https://eslint-react.xyz/docs/rules/no-unnecessary-use-callback"
-				}
-			}, {
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "@eslint-react/eslint-plugin",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin"
-				},
-				rule: {
-					name: "no-unnecessary-use-callback",
-					url: "https://eslint-react.xyz/docs/rules/no-unnecessary-use-callback"
-				}
-			}]
-		},
-		docs: {
-			description: "Disallow unnecessary usage of `useCallback`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$3
-		},
-		messages: { noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary." },
-		schema: []
-	},
-	name: RULE_NAME$3,
-	create: create$3,
-	defaultOptions: []
-});
-function create$3(context) {
-	if (!context.sourceCode.text.includes("use")) return {};
-	const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-	const isUseCallbackCall = ER.isReactHookCallWithNameAlias(context, "useCallback", alias);
-	return { CallExpression(node) {
-		if (!ER.isReactHookCall(node)) return;
-		const initialScope = context.sourceCode.getScope(node);
-		if (!isUseCallbackCall(node)) return;
-		const scope = context.sourceCode.getScope(node);
-		const component = scope.block;
-		if (!AST.isFunction(component)) return;
-		const [arg0, arg1] = node.arguments;
-		if (arg0 == null || arg1 == null) return;
-		const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variable = VAR.findVariable(n.name, initialScope);
-			const variableNode = VAR.getVariableDefinitionNode(variable, 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
-			return variableNode.elements.length === 0;
-		}).otherwise(() => false);
-		if (!hasEmptyDeps) return;
-		const arg0Node = match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-			if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) return n.body;
-			return n;
-		}).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variable = VAR.findVariable(n.name, initialScope);
-			const variableNode = VAR.getVariableDefinitionNode(variable, 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) return null;
-			return variableNode;
-		}).otherwise(() => null);
-		if (arg0Node == null) return;
-		const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-		const arg0NodeReferences = VAR.getChildScopes(arg0NodeScope).flatMap((x) => x.references);
-		const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-		if (!isReferencedToComponentScope) context.report({
-			messageId: "noUnnecessaryUseCallback",
-			node
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/no-unnecessary-use-memo.ts
-const RULE_NAME$2 = "no-unnecessary-use-memo";
-const RULE_FEATURES$2 = ["EXP"];
-var no_unnecessary_use_memo_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: {
-			deprecatedSince: "2.0.0",
-			replacedBy: [{
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "eslint-plugin-react-x",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x"
-				},
-				rule: {
-					name: "no-unnecessary-use-memo",
-					url: "https://eslint-react.xyz/docs/rules/no-unnecessary-use-memo"
-				}
-			}, {
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "@eslint-react/eslint-plugin",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin"
-				},
-				rule: {
-					name: "no-unnecessary-use-memo",
-					url: "https://eslint-react.xyz/docs/rules/no-unnecessary-use-memo"
-				}
-			}]
-		},
-		docs: {
-			description: "Disallow unnecessary usage of `useMemo`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$2
-		},
-		messages: { noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary." },
-		schema: []
-	},
-	name: RULE_NAME$2,
-	create: create$2,
-	defaultOptions: []
-});
-function create$2(context) {
-	if (!context.sourceCode.text.includes("use")) return {};
-	const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
-	const isUseMemoCall = ER.isReactHookCallWithNameAlias(context, "useMemo", alias);
-	return { CallExpression(node) {
-		if (!ER.isReactHookCall(node)) return;
-		const initialScope = context.sourceCode.getScope(node);
-		if (!isUseMemoCall(node)) return;
-		const scope = context.sourceCode.getScope(node);
-		const component = scope.block;
-		if (!AST.isFunction(component)) return;
-		const [arg0, arg1] = node.arguments;
-		if (arg0 == null || arg1 == null) return;
-		const hasCallInArg0 = AST.isFunction(arg0) && [...AST.getNestedCallExpressions(arg0.body), ...AST.getNestedNewExpressions(arg0.body)].length > 0;
-		if (hasCallInArg0) return;
-		const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variable = VAR.findVariable(n.name, initialScope);
-			const variableNode = VAR.getVariableDefinitionNode(variable, 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
-			return variableNode.elements.length === 0;
-		}).otherwise(() => false);
-		if (!hasEmptyDeps) return;
-		const arg0Node = match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-			if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) return n.body;
-			return n;
-		}).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variable = VAR.findVariable(n.name, initialScope);
-			const variableNode = VAR.getVariableDefinitionNode(variable, 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) return null;
-			return variableNode;
-		}).otherwise(() => null);
-		if (arg0Node == null) return;
-		const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-		const arg0NodeReferences = VAR.getChildScopes(arg0NodeScope).flatMap((x) => x.references);
-		const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-		if (!isReferencedToComponentScope) context.report({
-			messageId: "noUnnecessaryUseMemo",
-			node
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/no-unnecessary-use-prefix.ts
-const RULE_NAME$1 = "no-unnecessary-use-prefix";
-const RULE_FEATURES$1 = [];
-const WELL_KNOWN_HOOKS = ["useMDXComponents"];
-function containsUseComments(context, node) {
-	return context.sourceCode.getCommentsInside(node).some(({ value }) => /use\([\s\S]*?\)/u.test(value) || /use[A-Z0-9]\w*\([\s\S]*?\)/u.test(value));
-}
-var no_unnecessary_use_prefix_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: {
-			deprecatedSince: "2.0.0",
-			replacedBy: [{
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "eslint-plugin-react-x",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x"
-				},
-				rule: {
-					name: "no-unnecessary-use-prefix",
-					url: "https://eslint-react.xyz/docs/rules/no-unnecessary-use-prefix"
-				}
-			}, {
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "@eslint-react/eslint-plugin",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin"
-				},
-				rule: {
-					name: "no-unnecessary-use-prefix",
-					url: "https://eslint-react.xyz/docs/rules/no-unnecessary-use-prefix"
-				}
-			}]
-		},
-		docs: {
-			description: "Enforces that a function with the `use` prefix should use at least one Hook inside of it.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$1
-		},
-		messages: { noUnnecessaryUsePrefix: "If your function doesn't call any Hooks, avoid the 'use' prefix. Instead, write it as a regular function without the 'use' prefix." },
-		schema: []
-	},
-	name: RULE_NAME$1,
-	create: create$1,
-	defaultOptions: []
-});
-function create$1(context) {
-	const { ctx, listeners } = ER.useHookCollector();
-	return {
-		...listeners,
-		"Program:exit"(program) {
-			const allHooks = ctx.getAllHooks(program);
-			for (const { id, name: name$2, node, hookCalls } of allHooks.values()) {
-				if (WELL_KNOWN_HOOKS.includes(name$2)) continue;
-				if (AST.isFunctionEmpty(node)) continue;
-				if (hookCalls.length > 0) continue;
-				if (containsUseComments(context, node)) continue;
-				if (id != null) {
-					context.report({
-						messageId: "noUnnecessaryUsePrefix",
-						data: { name: name$2 },
-						loc: getPreferredLoc(context, id)
-					});
-					continue;
-				}
-				context.report({
-					messageId: "noUnnecessaryUsePrefix",
-					node,
-					data: { name: name$2 }
+				for (const setStateCall of setStateCalls) context.report({
+					messageId: "noDirectSetStateInUseEffect",
+					node: setStateCall,
+					data: { name: getCallName(setStateCall) }
 				});
 			}
 		}
 	};
 }
-function getPreferredLoc(context, id) {
-	if (AST.isMultiLine(id)) return id.loc;
-	if (!context.sourceCode.getText(id).startsWith("use")) return id.loc;
-	return {
-		end: {
-			column: id.loc.start.column + 3,
-			line: id.loc.start.line
-		},
-		start: {
-			column: id.loc.start.column,
-			line: id.loc.start.line
-		}
-	};
-}
-
-//#endregion
-//#region src/rules-removed/prefer-use-state-lazy-initialization.ts
-const RULE_NAME = "prefer-use-state-lazy-initialization";
-const RULE_FEATURES = ["EXP"];
-const ALLOW_LIST = [
-	"Boolean",
-	"String",
-	"Number"
-];
-var prefer_use_state_lazy_initialization_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: {
-			deprecatedSince: "2.0.0",
-			replacedBy: [{
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "eslint-plugin-react-x",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x"
-				},
-				rule: {
-					name: "prefer-use-state-lazy-initialization",
-					url: "https://eslint-react.xyz/docs/rules/prefer-use-state-lazy-initialization"
-				}
-			}, {
-				message: "Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.",
-				plugin: {
-					name: "@eslint-react/eslint-plugin",
-					url: "https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin"
-				},
-				rule: {
-					name: "prefer-use-state-lazy-initialization",
-					url: "https://eslint-react.xyz/docs/rules/prefer-use-state-lazy-initialization"
-				}
-			}]
-		},
-		docs: {
-			description: "Enforces function calls made inside `useState` to be wrapped in an `initializer function`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES
-		},
-		messages: { preferUseStateLazyInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'." },
-		schema: []
-	},
-	name: RULE_NAME,
-	create,
-	defaultOptions: []
-});
-function create(context) {
-	const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-	const isUseStateCall = ER.isReactHookCallWithNameAlias(context, "useState", alias);
-	return { CallExpression(node) {
-		if (!ER.isReactHookCall(node)) return;
-		if (!isUseStateCall(node)) return;
-		const [useStateInput] = node.arguments;
-		if (useStateInput == null) return;
-		for (const expr of AST.getNestedNewExpressions(useStateInput)) {
-			if (!("name" in expr.callee)) continue;
-			if (ALLOW_LIST.includes(expr.callee.name)) continue;
-			if (AST.findParentNode(expr, (n) => ER.isUseCall(context, n)) != null) continue;
-			context.report({
-				messageId: "preferUseStateLazyInitialization",
-				node: expr
-			});
-		}
-		for (const expr of AST.getNestedCallExpressions(useStateInput)) {
-			if (!("name" in expr.callee)) continue;
-			if (ER.isReactHookName(expr.callee.name)) continue;
-			if (ALLOW_LIST.includes(expr.callee.name)) continue;
-			if (AST.findParentNode(expr, (n) => ER.isUseCall(context, n)) != null) continue;
-			context.report({
-				messageId: "preferUseStateLazyInitialization",
-				node: expr
-			});
-		}
-	} };
-}
 
 //#endregion
 //#region src/plugin.ts
@@ -626,25 +251,15 @@ const plugin = {
 		name,
 		version
 	},
-	rules: {
-		"no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
-		"no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_effect_default,
-		"no-unnecessary-use-callback": no_unnecessary_use_callback_default,
-		"no-unnecessary-use-memo": no_unnecessary_use_memo_default,
-		"no-unnecessary-use-prefix": no_unnecessary_use_prefix_default,
-		"prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
-	}
+	rules: { "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default }
 };
 
 //#endregion
 //#region src/index.ts
-const { toFlatConfig, toLegacyConfig } = getConfigAdapters("react-hooks-extra", plugin);
+const { toFlatConfig } = getConfigAdapters("react-hooks-extra", plugin);
 var src_default = {
 	...plugin,
-	configs: {
-		["recommended"]: toFlatConfig(recommended_exports),
-		["recommended-legacy"]: toLegacyConfig(recommended_exports)
-	}
+	configs: { ["recommended"]: toFlatConfig(recommended_exports) }
 };
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "2.0.0-next.61",
+  "version": "2.0.0",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "react",
@@ -36,39 +36,31 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.41.0",
-    "@typescript-eslint/type-utils": "^8.41.0",
-    "@typescript-eslint/types": "^8.41.0",
-    "@typescript-eslint/utils": "^8.41.0",
+    "@typescript-eslint/scope-manager": "^8.44.1",
+    "@typescript-eslint/type-utils": "^8.44.1",
+    "@typescript-eslint/types": "^8.44.1",
+    "@typescript-eslint/utils": "^8.44.1",
     "string-ts": "^2.2.1",
     "ts-pattern": "^5.8.0",
-    "@eslint-react/ast": "2.0.0-next.61",
-    "@eslint-react/core": "2.0.0-next.61",
-    "@eslint-react/kit": "2.0.0-next.61",
-    "@eslint-react/eff": "2.0.0-next.61",
-    "@eslint-react/shared": "2.0.0-next.61",
-    "@eslint-react/var": "2.0.0-next.61"
+    "@eslint-react/ast": "2.0.0",
+    "@eslint-react/core": "2.0.0",
+    "@eslint-react/kit": "2.0.0",
+    "@eslint-react/shared": "2.0.0",
+    "@eslint-react/eff": "2.0.0",
+    "@eslint-react/var": "2.0.0"
   },
   "devDependencies": {
-    "@types/react": "^19.1.12",
+    "@types/react": "^19.1.13",
     "@types/react-dom": "^19.1.9",
-    "tsdown": "^0.14.2",
+    "tsdown": "^0.15.4",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^8.57.0 || ^9.0.0",
-    "typescript": "^4.9.5 || ^5.3.3"
-  },
-  "peerDependenciesMeta": {
-    "eslint": {
-      "optional": false
-    },
-    "typescript": {
-      "optional": true
-    }
+    "eslint": "^9.36.0",
+    "typescript": "^5.9.2"
   },
   "engines": {
-    "node": ">=18.18.0"
+    "node": ">=20.0.0"
   },
   "publishConfig": {
     "access": "public"