eslint-plugin-react-hooks-extra 2.0.0-next.4 → 2.0.0-next.44

package/dist/index.js

@@ -1,8 +1,8 @@
-import * as AST from '@eslint-react/ast';
-import * as ER7 from '@eslint-react/core';
-import { identity, getOrElseUpdate, constVoid, constTrue } from '@eslint-react/eff';
+import * as AST5 from '@eslint-react/ast';
+import * as ER5 from '@eslint-react/core';
+import { identity, getOrElseUpdate, constVoid, not } from '@eslint-react/eff';
 import { getDocsUrl, getSettingsFromContext } from '@eslint-react/shared';
-import * as VAR4 from '@eslint-react/var';
+import * as VAR3 from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { match } from 'ts-pattern';
 import { ESLintUtils } from '@typescript-eslint/utils';
@@ -22,296 +22,55 @@ __export(recommended_exports, {
 var name = "react-hooks-extra/recommended";
 var rules = {
   "react-hooks-extra/no-direct-set-state-in-use-effect": "warn",
-  "react-hooks-extra/no-unnecessary-use-prefix": "warn",
-  "react-hooks-extra/prefer-use-state-lazy-initialization": "warn"
+  "react-hooks-extra/no-unnecessary-use-prefix": "warn"
 };
 
 // package.json
 var name2 = "eslint-plugin-react-hooks-extra";
-var version = "2.0.0-next.4";
+var version = "2.0.0-next.44";
 var createRule = ESLintUtils.RuleCreator(getDocsUrl("hooks-extra"));
-function isFromHookCall(context, name3, settings, predicate = constTrue) {
-  const hookAlias = settings.additionalHooks[name3] ?? [];
-  return (topLevelId) => {
-    const variable = VAR4.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR4.getVariableInitNode(variable, 0);
-    if (variableNode == null) return false;
-    if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
-    if (!ER7.isReactHookCallWithNameAlias(context, name3, hookAlias)(variableNode)) return false;
-    return predicate(topLevelId, variableNode);
-  };
-}
-function isFromUseStateCall(context, settings) {
-  const predicate = (topLevelId, call) => {
-    const { parent } = call;
-    if (!("id" in parent) || parent.id?.type !== AST_NODE_TYPES.ArrayPattern) {
-      return true;
-    }
-    return parent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === 1;
-  };
-  return isFromHookCall(context, "useState", settings, predicate);
-}
-function isFunctionOfImmediatelyInvoked(node) {
-  return node.type !== AST_NODE_TYPES.FunctionDeclaration && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node;
-}
-function isSetFunctionCall(context, settings) {
-  const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-  return (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 = VAR4.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);
-      }
-      // 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 = VAR4.toStaticValue({
-          kind: "lazy",
-          node: property,
-          initialScope: propertyScope
-        }).value;
-        return propertyValue === 1 && isIdFromUseStateCall(node.callee.object);
-      }
-      default: {
-        return false;
-      }
-    }
-  };
-}
-function isThenCall(node) {
-  return node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "then";
-}
-function isVariableDeclaratorFromHookCall(node) {
-  if (node.type !== AST_NODE_TYPES.VariableDeclarator) {
-    return false;
-  }
-  if (node.id.type !== AST_NODE_TYPES.Identifier) {
-    return false;
-  }
-  if (node.init?.type !== AST_NODE_TYPES.CallExpression) {
-    return false;
-  }
-  switch (node.init.callee.type) {
-    case AST_NODE_TYPES.Identifier:
-      return ER7.isReactHookName(node.init.callee.name);
-    case AST_NODE_TYPES.MemberExpression:
-      return node.init.callee.property.type === AST_NODE_TYPES.Identifier && ER7.isReactHookName(node.init.callee.property.name);
-    default:
-      return false;
-  }
-}
-
-// src/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 = ER7.isReactHookCallWithNameAlias(context, useEffectKind, hooks[useEffectKind]);
-  const isUseStateCall = ER7.isReactHookCallWithNameAlias(context, "useState", hooks.useState);
-  const isUseMemoCall = ER7.isReactHookCallWithNameAlias(context, "useMemo", hooks.useMemo);
-  const isUseCallbackCall = ER7.isReactHookCallWithNameAlias(context, "useCallback", hooks.useCallback);
-  const isSetStateCall = isSetFunctionCall(context, settings);
-  const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-  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.toString(node.callee, getText);
-    }
-    return AST.toString(node, getText);
-  }
-  function getCallKind(node) {
-    return match(node).when(isUseStateCall, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
-  }
-  function getFunctionKind(node) {
-    return match(node).when(isFunctionOfUseEffectSetup, () => "setup").when(isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
-  }
-  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.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)) {
-        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 = VAR4.getVariableInitNode(VAR4.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)
-          });
-        }
-      }
-    }
-  };
-}
 
-// src/rules/no-direct-set-state-in-use-effect.ts
-var RULE_NAME = "no-direct-set-state-in-use-effect";
+// src/rules-removed/no-unnecessary-use-callback.ts
+var RULE_NAME = "no-unnecessary-use-callback";
 var RULE_FEATURES = [
   "EXP"
 ];
-var no_direct_set_state_in_use_effect_default = createRule({
+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://next.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://next.eslint-react.xyz/docs/rules/no-unnecessary-use-callback"
+          }
+        }
+      ]
+    },
     docs: {
-      description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
+      description: "Disallow unnecessary usage of `useCallback`.",
       [Symbol.for("rule_features")]: RULE_FEATURES
     },
     messages: {
-      noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'."
+      noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
     },
     schema: []
   },
@@ -320,90 +79,140 @@ var no_direct_set_state_in_use_effect_default = createRule({
   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"
-  });
-}
-
-// 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"
-  });
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
+  const isUseCallbackCall = ER5.isReactHookCallWithNameAlias(context, "useCallback", alias);
+  return {
+    CallExpression(node) {
+      if (!ER5.isReactHookCall(node)) {
+        return;
+      }
+      const initialScope = context.sourceCode.getScope(node);
+      if (!isUseCallbackCall(node)) {
+        return;
+      }
+      const scope = context.sourceCode.getScope(node);
+      const component = scope.block;
+      if (!AST5.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 = VAR3.findVariable(n.name, initialScope);
+        const variableNode = VAR3.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 = VAR3.findVariable(n.name, initialScope);
+        const variableNode = VAR3.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 = VAR3.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_NAME3 = "no-unnecessary-use-callback";
-var RULE_FEATURES3 = [
+var RULE_NAME2 = "no-unnecessary-use-memo";
+var RULE_FEATURES2 = [
   "EXP"
 ];
-var no_unnecessary_use_callback_default = createRule({
+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://next.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://next.eslint-react.xyz/docs/rules/no-unnecessary-use-memo"
+          }
+        }
+      ]
+    },
     docs: {
-      description: "Disallow unnecessary usage of `useCallback`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES3
+      description: "Disallow unnecessary usage of `useMemo`.",
+      [Symbol.for("rule_features")]: RULE_FEATURES2
     },
     messages: {
-      noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
+      noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
     },
     schema: []
   },
-  name: RULE_NAME3,
-  create: create3,
+  name: RULE_NAME2,
+  create: create2,
   defaultOptions: []
 });
-function create3(context) {
+function create2(context) {
   if (!context.sourceCode.text.includes("use")) return {};
-  const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-  const isUseCallbackCall = ER7.isReactHookCallWithNameAlias(context, "useCallback", alias);
+  const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
+  const isUseMemoCall = ER5.isReactHookCallWithNameAlias(context, "useMemo", alias);
   return {
     CallExpression(node) {
-      if (!ER7.isReactHookCall(node)) {
+      if (!ER5.isReactHookCall(node)) {
         return;
       }
       const initialScope = context.sourceCode.getScope(node);
-      if (!isUseCallbackCall(node)) {
+      if (!isUseMemoCall(node)) {
         return;
       }
       const scope = context.sourceCode.getScope(node);
       const component = scope.block;
-      if (!AST.isFunction(component)) {
+      if (!AST5.isFunction(component)) {
         return;
       }
       const [arg0, arg1] = node.arguments;
       if (arg0 == null || arg1 == null) {
         return;
       }
+      const hasCallInArg0 = AST5.isFunction(arg0) && [...AST5.getNestedCallExpressions(arg0.body), ...AST5.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 = VAR4.findVariable(n.name, initialScope);
-        const variableNode = VAR4.getVariableInitNode(variable, 0);
+        const variable = VAR3.findVariable(n.name, initialScope);
+        const variableNode = VAR3.getVariableInitNode(variable, 0);
         if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
           return false;
         }
@@ -418,8 +227,8 @@ function create3(context) {
         }
         return n;
       }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR4.findVariable(n.name, initialScope);
-        const variableNode = VAR4.getVariableInitNode(variable, 0);
+        const variable = VAR3.findVariable(n.name, initialScope);
+        const variableNode = VAR3.getVariableInitNode(variable, 0);
         if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
           return null;
         }
@@ -427,117 +236,482 @@ function create3(context) {
       }).otherwise(() => null);
       if (arg0Node == null) return;
       const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-      const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const arg0NodeReferences = VAR3.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
       const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
       if (!isReferencedToComponentScope) {
         context.report({
-          messageId: "noUnnecessaryUseCallback",
+          messageId: "noUnnecessaryUseMemo",
           node
         });
       }
     }
   };
 }
-var RULE_NAME4 = "no-unnecessary-use-memo";
+var RULE_NAME3 = "no-unnecessary-use-prefix";
+var RULE_FEATURES3 = [];
+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://next.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://next.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_FEATURES3
+    },
+    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_NAME3,
+  create: create3,
+  defaultOptions: []
+});
+function create3(context) {
+  const { ctx, listeners } = ER5.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 (AST5.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 (AST5.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_NAME4 = "prefer-use-state-lazy-initialization";
 var RULE_FEATURES4 = [
   "EXP"
 ];
-var no_unnecessary_use_memo_default = createRule({
+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://next.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://next.eslint-react.xyz/docs/rules/prefer-use-state-lazy-initialization"
+          }
+        }
+      ]
+    },
     docs: {
-      description: "Disallow unnecessary usage of `useMemo`.",
+      description: "Enforces function calls made inside `useState` to be wrapped in an `initializer function`.",
       [Symbol.for("rule_features")]: RULE_FEATURES4
     },
     messages: {
-      noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
+      preferUseStateLazyInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'."
+    },
+    schema: []
+  },
+  name: RULE_NAME4,
+  create: create4,
+  defaultOptions: []
+});
+function create4(context) {
+  const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
+  const isUseStateCall = ER5.isReactHookCallWithNameAlias(context, "useState", alias);
+  return {
+    CallExpression(node) {
+      if (!ER5.isReactHookCall(node)) {
+        return;
+      }
+      if (!isUseStateCall(node)) {
+        return;
+      }
+      const [useStateInput] = node.arguments;
+      if (useStateInput == null) {
+        return;
+      }
+      for (const expr of AST5.getNestedNewExpressions(useStateInput)) {
+        if (!("name" in expr.callee)) continue;
+        if (ALLOW_LIST.includes(expr.callee.name)) continue;
+        if (AST5.findParentNode(expr, (n) => ER5.isUseCall(context, n)) != null) continue;
+        context.report({
+          messageId: "preferUseStateLazyInitialization",
+          node: expr
+        });
+      }
+      for (const expr of AST5.getNestedCallExpressions(useStateInput)) {
+        if (!("name" in expr.callee)) continue;
+        if (ER5.isReactHookName(expr.callee.name)) continue;
+        if (ALLOW_LIST.includes(expr.callee.name)) continue;
+        if (AST5.findParentNode(expr, (n) => ER5.isUseCall(context, n)) != null) continue;
+        context.report({
+          messageId: "preferUseStateLazyInitialization",
+          node: expr
+        });
+      }
+    }
+  };
+}
+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 = ER5.isReactHookCallWithNameAlias(context, useEffectKind, hooks[useEffectKind]);
+  const isUseStateCall = ER5.isReactHookCallWithNameAlias(context, "useState", hooks.useState);
+  const isUseMemoCall = ER5.isReactHookCallWithNameAlias(context, "useMemo", hooks.useMemo);
+  const isUseCallbackCall = ER5.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 AST5.toStringFormat(node.callee, getText);
+    }
+    return AST5.toStringFormat(node, getText);
+  }
+  function getCallKind(node) {
+    return match(node).when(isUseStateCall, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(AST5.isThenCall, () => "then").otherwise(() => "other");
+  }
+  function getFunctionKind(node) {
+    const parent = AST5.findParentNode(node, not(AST5.isTypeExpression)) ?? node.parent;
+    switch (true) {
+      case node.async:
+      case (parent.type === AST_NODE_TYPES.CallExpression && AST5.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 = VAR3.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+    const variableNode = VAR3.getVariableInitNode(variable, 0);
+    if (variableNode == null) return false;
+    if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
+    if (!ER5.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 = VAR3.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 = VAR3.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();
     },
-    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 = ER7.isReactHookCallWithNameAlias(context, "useMemo", alias);
-  return {
     CallExpression(node) {
-      if (!ER7.isReactHookCall(node)) {
-        return;
-      }
-      const initialScope = context.sourceCode.getScope(node);
-      if (!isUseMemoCall(node)) {
+      const setupFunction = setupFunctionRef.current;
+      const pEntry = functionEntries.at(-1);
+      if (pEntry == null || pEntry.node.async) {
         return;
       }
-      const scope = context.sourceCode.getScope(node);
-      const component = scope.block;
-      if (!AST.isFunction(component)) {
+      match(getCallKind(node)).with("setState", () => {
+        switch (true) {
+          case pEntry.kind === "deferred":
+          case pEntry.node.async:
+            break;
+          case pEntry.node === setupFunction:
+          case (pEntry.kind === "immediate" && AST5.findParentNode(pEntry.node, AST5.isFunction) === setupFunction): {
+            onViolation(context, node, {
+              name: context.sourceCode.getText(node.callee)
+            });
+            return;
+          }
+          default: {
+            const vd = AST5.findParentNode(node, isVariableDeclaratorFromHookCall);
+            if (vd == null) getOrElseUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
+            else getOrElseUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
+          }
+        }
+      }).with(useEffectKind, () => {
+        if (AST5.isFunction(node.arguments.at(0))) return;
+        setupFunctionIdentifiers.push(...AST5.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;
       }
-      const [arg0, arg1] = node.arguments;
-      if (arg0 == null || arg1 == null) {
+      if (!isIdFromUseStateCall(node, 1)) {
         return;
       }
-      const hasCallInArg0 = AST.isFunction(arg0) && [...AST.getNestedCallExpressions(arg0.body), ...AST.getNestedNewExpressions(arg0.body)].length > 0;
-      if (hasCallInArg0) {
-        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 = AST5.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 = AST5.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
+            if (vd != null) {
+              getOrElseUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
+            }
+            break;
+          }
+          if (isUseEffectLikeCall(node.parent)) {
+            getOrElseUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
+          }
+        }
       }
-      const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR4.findVariable(n.name, initialScope);
-        const variableNode = VAR4.getVariableInitNode(variable, 0);
-        if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
-          return false;
+    },
+    "Program:exit"() {
+      const getSetStateCalls = (id, initialScope) => {
+        const node = VAR3.getVariableInitNode(VAR3.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 });
         }
-        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;
+      for (const { callee } of indFunctionCalls) {
+        if (!("name" in callee)) {
+          continue;
         }
-        return n;
-      }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR4.findVariable(n.name, initialScope);
-        const variableNode = VAR4.getVariableInitNode(variable, 0);
-        if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
-          return null;
+        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)
+          });
         }
-        return variableNode;
-      }).otherwise(() => null);
-      if (arg0Node == null) return;
-      const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-      const arg0NodeReferences = VAR4.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));
+function isInitFromHookCall(init) {
+  if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
+  switch (init.callee.type) {
+    case AST_NODE_TYPES.Identifier:
+      return ER5.isReactHookName(init.callee.name);
+    case AST_NODE_TYPES.MemberExpression:
+      return init.callee.property.type === AST_NODE_TYPES.Identifier && ER5.isReactHookName(init.callee.property.name);
+    default:
+      return false;
+  }
 }
-var no_unnecessary_use_prefix_default = createRule({
+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);
+}
+
+// src/rules/no-direct-set-state-in-use-effect.ts
+var RULE_NAME5 = "no-direct-set-state-in-use-effect";
+var RULE_FEATURES5 = [
+  "EXP"
+];
+var no_direct_set_state_in_use_effect_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Enforces that a function with the `use` prefix should use at least one Hook inside of it.",
+      description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
       [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."
+      noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'."
     },
     schema: []
   },
@@ -546,77 +720,29 @@ var no_unnecessary_use_prefix_default = createRule({
   defaultOptions: []
 });
 function create5(context) {
-  const { ctx, listeners } = ER7.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
+  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+  return useNoDirectSetStateInUseEffect(context, {
+    onViolation(ctx, node, data) {
+      ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
     },
-    start: {
-      column: id.loc.start.column,
-      line: id.loc.start.line
-    }
-  };
+    useEffectKind: "useEffect"
+  });
 }
-var RULE_NAME6 = "prefer-use-state-lazy-initialization";
+
+// src/rules/no-direct-set-state-in-use-layout-effect.ts
+var RULE_NAME6 = "no-direct-set-state-in-use-layout-effect";
 var RULE_FEATURES6 = [
   "EXP"
 ];
-var ALLOW_LIST = [
-  "Boolean",
-  "String",
-  "Number"
-];
-var prefer_use_state_lazy_initialization_default = createRule({
+var no_direct_set_state_in_use_layout_effect_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Enforces function calls made inside `useState` to be wrapped in an `initializer function`.",
+      description: "Disallow direct calls to the `set` function of `useState` in `useLayoutEffect`.",
       [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())'."
+      noDirectSetStateInUseLayoutEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useLayoutEffect'."
     },
     schema: []
   },
@@ -625,41 +751,13 @@ var prefer_use_state_lazy_initialization_default = createRule({
   defaultOptions: []
 });
 function create6(context) {
-  const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-  const isUseStateCall = ER7.isReactHookCallWithNameAlias(context, "useState", alias);
-  return {
-    CallExpression(node) {
-      if (!ER7.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) => ER7.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 (ER7.isReactHookName(expr.callee.name)) continue;
-        if (ALLOW_LIST.includes(expr.callee.name)) continue;
-        if (AST.findParentNode(expr, (n) => ER7.isUseCall(context, n)) != null) continue;
-        context.report({
-          messageId: "preferUseStateLazyInitialization",
-          node: expr
-        });
-      }
-    }
-  };
+  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"
+  });
 }
 
 // src/plugin.ts
@@ -671,9 +769,25 @@ var plugin = {
   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://next.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://next.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://next.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://next.eslint-react.xyz/docs/rules/prefer-use-state-lazy-initialization
+     */
     "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "2.0.0-next.4",
+  "version": "2.0.0-next.44",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "react",
@@ -36,28 +36,28 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.30.1",
-    "@typescript-eslint/type-utils": "^8.30.1",
-    "@typescript-eslint/types": "^8.30.1",
-    "@typescript-eslint/utils": "^8.30.1",
+    "@typescript-eslint/scope-manager": "^8.34.0",
+    "@typescript-eslint/type-utils": "^8.34.0",
+    "@typescript-eslint/types": "^8.34.0",
+    "@typescript-eslint/utils": "^8.34.0",
     "string-ts": "^2.2.1",
-    "ts-pattern": "^5.7.0",
-    "@eslint-react/ast": "2.0.0-next.4",
-    "@eslint-react/core": "2.0.0-next.4",
-    "@eslint-react/kit": "2.0.0-next.4",
-    "@eslint-react/shared": "2.0.0-next.4",
-    "@eslint-react/var": "2.0.0-next.4",
-    "@eslint-react/eff": "2.0.0-next.4"
+    "ts-pattern": "^5.7.1",
+    "@eslint-react/eff": "2.0.0-next.44",
+    "@eslint-react/kit": "2.0.0-next.44",
+    "@eslint-react/shared": "2.0.0-next.44",
+    "@eslint-react/ast": "2.0.0-next.44",
+    "@eslint-react/var": "2.0.0-next.44",
+    "@eslint-react/core": "2.0.0-next.44"
   },
   "devDependencies": {
-    "@types/react": "^19.1.2",
-    "@types/react-dom": "^19.1.2",
-    "tsup": "^8.4.0",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "tsup": "^8.5.0",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^9.24.0",
-    "typescript": "^4.9.5 || ^5.4.5"
+    "eslint": "^8.57.0 || ^9.0.0",
+    "typescript": "^4.9.5 || ^5.3.3"
   },
   "peerDependenciesMeta": {
     "eslint": {
@@ -69,7 +69,7 @@
   },
   "engines": {
     "bun": ">=1.0.15",
-    "node": ">=20.19.0"
+    "node": ">=18.18.0"
   },
   "publishConfig": {
     "access": "public"