eslint-plugin-react-hooks-extra 2.0.0-beta.20 → 2.0.0-beta.200

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

@@ -1,45 +1,20 @@
-import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
-import { RulePreset } from '@eslint-react/kit';
+import * as _eslint_react_kit0 from "@eslint-react/kit";
 
+//#region src/index.d.ts
 declare const _default: {
-    configs: {
-        recommended: {
-            plugins: {
-                "react-hooks-extra": {
-                    readonly meta: {
-                        readonly name: string;
-                        readonly version: string;
-                    };
-                    readonly rules: {
-                        readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseLayoutEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-unnecessary-use-callback": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseCallback", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-unnecessary-use-memo": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseMemo", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-unnecessary-use-prefix": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUsePrefix", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseStateLazyInitialization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                    };
-                };
-            };
-            name: string;
-            rules: RulePreset;
-        };
-        "recommended-legacy": {
-            plugins: string[];
-            rules: RulePreset;
-        };
-    };
-    meta: {
-        readonly name: string;
-        readonly version: string;
-    };
-    rules: {
-        readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseLayoutEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-unnecessary-use-callback": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseCallback", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-unnecessary-use-memo": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseMemo", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-unnecessary-use-prefix": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUsePrefix", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseStateLazyInitialization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+  configs: {
+    recommended: {
+      plugins: {};
+      name?: string;
+      rules?: Record<string, _eslint_react_kit0.RuleConfig>;
+      settings?: _eslint_react_kit0.SettingsConfig;
     };
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: Record<string, _eslint_react_kit0.CompatibleRule>;
 };
-
-export { _default as default };
+//#endregion
+export { _default as default };

package/dist/index.js

@@ -1,815 +1,266 @@
-import * as AST from '@eslint-react/ast';
-import * as ER from '@eslint-react/core';
-import { identity, getOrElseUpdate, constVoid, not } from '@eslint-react/eff';
-import { getDocsUrl, getSettingsFromContext } from '@eslint-react/shared';
-import * as VAR from '@eslint-react/var';
-import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import { match } from 'ts-pattern';
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { getConfigAdapters, getDocsUrl } from "@eslint-react/shared";
+import * as AST from "@eslint-react/ast";
+import * as ER from "@eslint-react/core";
+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) => {
-  for (var name3 in all)
-    __defProp(target, name3, { get: all[name3], enumerable: true });
+var __export = (all) => {
+	let target = {};
+	for (var name$2 in all) __defProp(target, name$2, {
+		get: all[name$2],
+		enumerable: true
+	});
+	return target;
 };
 
-// src/configs/recommended.ts
-var recommended_exports = {};
-__export(recommended_exports, {
-  name: () => name,
-  rules: () => rules
+//#endregion
+//#region src/configs/recommended.ts
+var recommended_exports = /* @__PURE__ */ __export({
+	name: () => name$1,
+	rules: () => rules
 });
-var name = "react-hooks-extra/recommended";
-var rules = {
-  "react-hooks-extra/no-direct-set-state-in-use-effect": "warn"
-};
+const name$1 = "react-hooks-extra/recommended";
+const rules = { "react-hooks-extra/no-direct-set-state-in-use-effect": "warn" };
 
-// package.json
-var name2 = "eslint-plugin-react-hooks-extra";
-var version = "2.0.0-beta.20";
-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);
-  const functionEntries = [];
-  const setupFunctionRef = { current: null };
-  const setupFunctionIdentifiers = [];
-  const indFunctionCalls = [];
-  const indSetStateCalls = /* @__PURE__ */ new WeakMap();
-  const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new WeakMap();
-  const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
-  const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
-  const onSetupFunctionEnter = (node) => {
-    setupFunctionRef.current = node;
-  };
-  const onSetupFunctionExit = (node) => {
-    if (setupFunctionRef.current === node) {
-      setupFunctionRef.current = null;
-    }
-  };
-  function isFunctionOfUseEffectSetup(node) {
-    return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && 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");
-  }
-  function getFunctionKind(node) {
-    const parent = AST.findParentNode(node, not(AST.isTypeExpression)) ?? node.parent;
-    switch (true) {
-      case node.async:
-      case (parent.type === AST_NODE_TYPES.CallExpression && AST.isThenCall(parent)):
-        return "deferred";
-      case (node.type !== AST_NODE_TYPES.FunctionDeclaration && parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node):
-        return "immediate";
-      case isFunctionOfUseEffectSetup(node):
-        return "setup";
-      default:
-        return "other";
-    }
-  }
-  function isIdFromUseStateCall(topLevelId, at) {
-    const variable = VAR.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR.getVariableInitNode(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;
-    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;
-  }
-  function isSetStateCall(node) {
-    switch (node.callee.type) {
-      // const data = useState();
-      // data.at(1)();
-      case AST_NODE_TYPES.CallExpression: {
-        const { callee } = node.callee;
-        if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-          return false;
-        }
-        if (!("name" in callee.object)) {
-          return false;
-        }
-        const isAt = callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "at";
-        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);
-      }
-      // const [data, setData] = useState();
-      // setData();
-      case AST_NODE_TYPES.Identifier: {
-        return isIdFromUseStateCall(node.callee, 1);
-      }
-      // const data = useState();
-      // data[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);
-      }
-      default: {
-        return false;
-      }
-    }
-  }
-  return {
-    ":function"(node) {
-      const kind = getFunctionKind(node);
-      functionEntries.push({ kind, node });
-      if (kind === "setup") {
-        onSetupFunctionEnter(node);
-      }
-    },
-    ":function:exit"(node) {
-      const { kind } = functionEntries.at(-1) ?? {};
-      if (kind === "setup") {
-        onSetupFunctionExit(node);
-      }
-      functionEntries.pop();
-    },
-    CallExpression(node) {
-      const setupFunction = setupFunctionRef.current;
-      const pEntry = functionEntries.at(-1);
-      if (pEntry == null || pEntry.node.async) {
-        return;
-      }
-      match(getCallKind(node)).with("setState", () => {
-        switch (true) {
-          case pEntry.kind === "deferred":
-          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)
-            });
-            return;
-          }
-          default: {
-            const vd = AST.findParentNode(node, isVariableDeclaratorFromHookCall);
-            if (vd == null) getOrElseUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
-            else getOrElseUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
-          }
-        }
-      }).with(useEffectKind, () => {
-        if (AST.isFunction(node.arguments.at(0))) return;
-        setupFunctionIdentifiers.push(...AST.getNestedIdentifiers(node));
-      }).with("other", () => {
-        if (pEntry.node !== setupFunction) return;
-        indFunctionCalls.push(node);
-      }).otherwise(constVoid);
-    },
-    Identifier(node) {
-      if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
-        return;
-      }
-      if (!isIdFromUseStateCall(node, 1)) {
-        return;
-      }
-      switch (node.parent.type) {
-        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(indSetStateCallsInUseEffectArg0, vd.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(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-            }
-            break;
-          }
-          if (isUseEffectLikeCall(node.parent)) {
-            getOrElseUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
-          }
-        }
-      }
-    },
-    "Program:exit"() {
-      const getSetStateCalls = (id, initialScope) => {
-        const node = VAR.getVariableInitNode(VAR.findVariable(id, initialScope), 0);
-        switch (node?.type) {
-          case AST_NODE_TYPES.ArrowFunctionExpression:
-          case AST_NODE_TYPES.FunctionDeclaration:
-          case AST_NODE_TYPES.FunctionExpression:
-            return indSetStateCalls.get(node) ?? [];
-          case AST_NODE_TYPES.CallExpression:
-            return indSetStateCallsInUseMemoOrCallback.get(node) ?? indSetStateCallsInUseEffectArg0.get(node) ?? [];
-        }
-        return [];
-      };
-      for (const [, calls] of indSetStateCallsInUseEffectSetup) {
-        for (const call of calls) {
-          onViolation(context, call, { name: call.name });
-        }
-      }
-      for (const { callee } of indFunctionCalls) {
-        if (!("name" in callee)) {
-          continue;
-        }
-        const { name: name3 } = callee;
-        const setStateCalls = getSetStateCalls(name3, context.sourceCode.getScope(callee));
-        for (const setStateCall of setStateCalls) {
-          onViolation(context, setStateCall, {
-            name: getCallName(setStateCall)
-          });
-        }
-      }
-      for (const id of setupFunctionIdentifiers) {
-        const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-        for (const setStateCall of setStateCalls) {
-          onViolation(context, setStateCall, {
-            name: getCallName(setStateCall)
-          });
-        }
-      }
-    }
-  };
-}
+//#endregion
+//#region package.json
+var name = "eslint-plugin-react-hooks-extra";
+var version = "2.0.0-beta.200";
+
+//#endregion
+//#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;
-  }
+	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);
+	if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+	if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
+	return isInitFromHookCall(node.init);
 }
-var createRule = ESLintUtils.RuleCreator(getDocsUrl("hooks-extra"));
 
-// src/rules/no-direct-set-state-in-use-effect.ts
-var RULE_NAME = "no-direct-set-state-in-use-effect";
-var RULE_FEATURES = [
-  "EXP"
-];
+//#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: []
+	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 {};
-  return useNoDirectSetStateInUseEffect(context, {
-    onViolation(ctx, node, data) {
-      ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
-    },
-    useEffectKind: "useEffect"
-  });
+	if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+	const functionEntries = [];
+	const setupFnRef = { current: null };
+	const setupFnIds = [];
+	const trackedFnCalls = [];
+	const setStateCallsByFn = /* @__PURE__ */ new WeakMap();
+	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;
+	};
+	const onSetupFunctionExit = (node) => {
+		if (setupFnRef.current === node) setupFnRef.current = null;
+	};
+	function isFunctionOfUseEffectSetup(node) {
+		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(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;
+		switch (true) {
+			case node.async:
+			case parent.type === AST_NODE_TYPES.CallExpression && AST.isThenCall(parent): return "deferred";
+			case node.type !== AST_NODE_TYPES.FunctionDeclaration && parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node: return "immediate";
+			case isFunctionOfUseEffectSetup(node): return "setup";
+			default: return "other";
+		}
+	}
+	function isIdFromUseStateCall(topLevelId, at) {
+		const variable = VAR.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+		const variableNode = VAR.getVariableDefinitionNode(variable, 0);
+		if (variableNode == null) return false;
+		if (variableNode.type !== AST_NODE_TYPES.CallExpression) 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;
+	}
+	function isSetStateCall(node) {
+		switch (node.callee.type) {
+			case AST_NODE_TYPES.CallExpression: {
+				const { callee } = node.callee;
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+				if (!("name" in callee.object)) return false;
+				const isAt = callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "at";
+				const [index] = node.callee.arguments;
+				if (!isAt || index == null) return false;
+				const indexScope = context.sourceCode.getScope(node);
+				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);
+				return getStaticValue(property, propertyScope)?.value === 1 && isIdFromUseStateCall(node.callee.object, 1);
+			}
+			default: return false;
+		}
+	}
+	return {
+		":function"(node) {
+			const kind = getFunctionKind(node);
+			functionEntries.push({
+				kind,
+				node
+			});
+			if (kind === "setup") onSetupFunctionEnter(node);
+		},
+		":function:exit"(node) {
+			const { kind } = functionEntries.at(-1) ?? {};
+			if (kind === "setup") onSetupFunctionExit(node);
+			functionEntries.pop();
+		},
+		CallExpression(node) {
+			const setupFunction = setupFnRef.current;
+			const pEntry = functionEntries.at(-1);
+			if (pEntry == null || pEntry.node.async) return;
+			match(getCallKind(node)).with("setState", () => {
+				switch (true) {
+					case pEntry.kind === "deferred":
+					case pEntry.node.async: break;
+					case pEntry.node === setupFunction:
+					case pEntry.kind === "immediate" && AST.findParentNode(pEntry.node, AST.isFunction) === setupFunction:
+						context.report({
+							messageId: "noDirectSetStateInUseEffect",
+							node,
+							data: { name: context.sourceCode.getText(node.callee) }
+						});
+						return;
+					default: {
+						const init = AST.findParentNode(node, isVariableDeclaratorFromHookCall)?.init;
+						if (init == null) getOrElseUpdate(setStateCallsByFn, pEntry.node, () => []).push(node);
+						else getOrElseUpdate(setStateInHookCallbacks, init, () => []).push(node);
+					}
+				}
+			}).with("useEffect", () => {
+				if (AST.isFunction(node.arguments.at(0))) return;
+				setupFnIds.push(...AST.getNestedIdentifiers(node));
+			}).with("other", () => {
+				if (pEntry.node !== setupFunction) return;
+				trackedFnCalls.push(node);
+			}).otherwise(constVoid);
+		},
+		Identifier(node) {
+			if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) return;
+			if (!isIdFromUseStateCall(node, 1)) return;
+			switch (node.parent.type) {
+				case AST_NODE_TYPES.ArrowFunctionExpression: {
+					const parent = node.parent.parent;
+					if (parent.type !== AST_NODE_TYPES.CallExpression) break;
+					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 (ER.isUseCallbackCall(node.parent)) {
+						const init = AST.findParentNode(node.parent, isVariableDeclaratorFromHookCall)?.init;
+						if (init != null) getOrElseUpdate(setStateInEffectArg, init, () => []).push(node);
+						break;
+					}
+					if (ER.isUseEffectLikeCall(node.parent)) getOrElseUpdate(setStateInEffectSetup, node.parent, () => []).push(node);
+			}
+		},
+		"Program:exit"() {
+			const getSetStateCalls = (id, initialScope) => {
+				const node = VAR.getVariableDefinitionNode(VAR.findVariable(id, initialScope), 0);
+				switch (node?.type) {
+					case AST_NODE_TYPES.ArrowFunctionExpression:
+					case AST_NODE_TYPES.FunctionDeclaration:
+					case AST_NODE_TYPES.FunctionExpression: return setStateCallsByFn.get(node) ?? [];
+					case AST_NODE_TYPES.CallExpression: return setStateInHookCallbacks.get(node) ?? setStateInEffectArg.get(node) ?? [];
+				}
+				return [];
+			};
+			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) 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) context.report({
+					messageId: "noDirectSetStateInUseEffect",
+					node: setStateCall,
+					data: { name: getCallName(setStateCall) }
+				});
+			}
+		}
+	};
 }
 
-// src/rules/no-direct-set-state-in-use-layout-effect.ts
-var RULE_NAME2 = "no-direct-set-state-in-use-layout-effect";
-var RULE_FEATURES2 = [
-  "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_FEATURES2
-    },
-    messages: {
-      noDirectSetStateInUseLayoutEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useLayoutEffect'."
-    },
-    schema: []
-  },
-  name: RULE_NAME2,
-  create: create2,
-  defaultOptions: []
-});
-function create2(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"
-  });
-}
-var RULE_NAME3 = "no-unnecessary-use-callback";
-var RULE_FEATURES3 = [
-  "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_FEATURES3
-    },
-    messages: {
-      noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
-    },
-    schema: []
-  },
-  name: RULE_NAME3,
-  create: create3,
-  defaultOptions: []
-});
-function create3(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.getVariableInitNode(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.getVariableInitNode(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.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
-      const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-      if (!isReferencedToComponentScope) {
-        context.report({
-          messageId: "noUnnecessaryUseCallback",
-          node
-        });
-      }
-    }
-  };
-}
-var RULE_NAME4 = "no-unnecessary-use-memo";
-var RULE_FEATURES4 = [
-  "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_FEATURES4
-    },
-    messages: {
-      noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
-    },
-    schema: []
-  },
-  name: RULE_NAME4,
-  create: create4,
-  defaultOptions: []
-});
-function create4(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.getVariableInitNode(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.getVariableInitNode(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.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
-      const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-      if (!isReferencedToComponentScope) {
-        context.report({
-          messageId: "noUnnecessaryUseMemo",
-          node
-        });
-      }
-    }
-  };
-}
-var RULE_NAME5 = "no-unnecessary-use-prefix";
-var RULE_FEATURES5 = [];
-var 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_FEATURES5
-    },
-    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_NAME5,
-  create: create5,
-  defaultOptions: []
-});
-function create5(context) {
-  const { ctx, listeners } = ER.useHookCollector();
-  return {
-    ...listeners,
-    "Program:exit"(program) {
-      const allHooks = ctx.getAllHooks(program);
-      for (const { id, name: name3, node, hookCalls } of allHooks.values()) {
-        if (WELL_KNOWN_HOOKS.includes(name3)) {
-          continue;
-        }
-        if (AST.isEmptyFunction(node)) {
-          continue;
-        }
-        if (hookCalls.length > 0) {
-          continue;
-        }
-        if (containsUseComments(context, node)) {
-          continue;
-        }
-        if (id != null) {
-          context.report({
-            messageId: "noUnnecessaryUsePrefix",
-            data: {
-              name: name3
-            },
-            loc: getPreferredLoc(context, id)
-          });
-          continue;
-        }
-        context.report({
-          messageId: "noUnnecessaryUsePrefix",
-          node,
-          data: {
-            name: name3
-          }
-        });
-      }
-    }
-  };
-}
-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
-    }
-  };
-}
-var RULE_NAME6 = "prefer-use-state-lazy-initialization";
-var RULE_FEATURES6 = [
-  "EXP"
-];
-var 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_FEATURES6
-    },
-    messages: {
-      preferUseStateLazyInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'."
-    },
-    schema: []
-  },
-  name: RULE_NAME6,
-  create: create6,
-  defaultOptions: []
-});
-function create6(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
-        });
-      }
-    }
-  };
-}
-
-// src/plugin.ts
-var plugin = {
-  meta: {
-    name: name2,
-    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,
-    /**
-     * @deprecated Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.
-     * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-callback
-     */
-    "no-unnecessary-use-callback": no_unnecessary_use_callback_default,
-    /**
-     * @deprecated Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.
-     * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-memo
-     */
-    "no-unnecessary-use-memo": no_unnecessary_use_memo_default,
-    /**
-     * @deprecated Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.
-     * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-prefix
-     */
-    "no-unnecessary-use-prefix": no_unnecessary_use_prefix_default,
-    /**
-     * @deprecated Use the same rule from `eslint-plugin-react-x` or `@eslint-react/eslint-plugin` instead.
-     * @see https://eslint-react.xyz/docs/rules/prefer-use-state-lazy-initialization
-     */
-    "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
-  }
+//#endregion
+//#region src/plugin.ts
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules: { "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default }
 };
 
-// src/index.ts
-function makeConfig(config) {
-  return {
-    ...config,
-    plugins: {
-      "react-hooks-extra": plugin
-    }
-  };
-}
-function makeLegacyConfig({ rules: rules2 }) {
-  return {
-    plugins: ["react-hooks-extra"],
-    rules: rules2
-  };
-}
-var index_default = {
-  ...plugin,
-  configs: {
-    ["recommended"]: makeConfig(recommended_exports),
-    ["recommended-legacy"]: makeLegacyConfig(recommended_exports)
-  }
+//#endregion
+//#region src/index.ts
+const { toFlatConfig } = getConfigAdapters("react-hooks-extra", plugin);
+var src_default = {
+	...plugin,
+	configs: { ["recommended"]: toFlatConfig(recommended_exports) }
 };
 
-export { index_default as default };
+//#endregion
+export { src_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "2.0.0-beta.20",
+  "version": "2.0.0-beta.200",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "react",
@@ -36,45 +36,37 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.38.0",
-    "@typescript-eslint/type-utils": "^8.38.0",
-    "@typescript-eslint/types": "^8.38.0",
-    "@typescript-eslint/utils": "^8.38.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-beta.20",
-    "@eslint-react/core": "2.0.0-beta.20",
-    "@eslint-react/eff": "2.0.0-beta.20",
-    "@eslint-react/kit": "2.0.0-beta.20",
-    "@eslint-react/var": "2.0.0-beta.20",
-    "@eslint-react/shared": "2.0.0-beta.20"
+    "@eslint-react/ast": "2.0.0-beta.200",
+    "@eslint-react/core": "2.0.0-beta.200",
+    "@eslint-react/eff": "2.0.0-beta.200",
+    "@eslint-react/shared": "2.0.0-beta.200",
+    "@eslint-react/kit": "2.0.0-beta.200",
+    "@eslint-react/var": "2.0.0-beta.200"
   },
   "devDependencies": {
-    "@types/react": "^19.1.9",
-    "@types/react-dom": "^19.1.7",
-    "tsup": "^8.5.0",
+    "@types/react": "^19.1.13",
+    "@types/react-dom": "^19.1.9",
+    "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"
   },
   "scripts": {
-    "build": "tsup --dts-resolve",
+    "build": "tsdown",
     "lint:publish": "publint",
     "lint:ts": "tsc --noEmit"
   }