eslint-plugin-react-hooks-extra 1.30.0 → 1.30.1-beta.0

package/dist/index.js

@@ -4,7 +4,7 @@ var AST = require('@eslint-react/ast');
 var core = require('@eslint-react/core');
 var eff = require('@eslint-react/eff');
 var shared = require('@eslint-react/shared');
-var VAR5 = require('@eslint-react/var');
+var VAR4 = require('@eslint-react/var');
 var types = require('@typescript-eslint/types');
 var tsPattern = require('ts-pattern');
 
@@ -27,7 +27,7 @@ function _interopNamespace(e) {
 }
 
 var AST__namespace = /*#__PURE__*/_interopNamespace(AST);
-var VAR5__namespace = /*#__PURE__*/_interopNamespace(VAR5);
+var VAR4__namespace = /*#__PURE__*/_interopNamespace(VAR4);
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -50,13 +50,13 @@ var rules = {
 
 // package.json
 var name2 = "eslint-plugin-react-hooks-extra";
-var version = "1.30.0";
+var version = "1.30.1-beta.0";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 function isFromHookCall(context, name3, settings, predicate = eff.constTrue) {
   const hookAlias = settings.additionalHooks[name3] ?? [];
   return (topLevelId) => {
-    const variable = VAR5__namespace.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+    const variable = VAR4__namespace.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+    const variableNode = VAR4__namespace.getVariableNode(variable, 0);
     if (variableNode == null) return false;
     if (variableNode.type !== types.AST_NODE_TYPES.CallExpression) return false;
     if (!core.isReactHookCallWithNameAlias(context, name3, hookAlias)(variableNode)) return false;
@@ -96,7 +96,7 @@ function isSetFunctionCall(context, settings) {
           return false;
         }
         const indexScope = context.sourceCode.getScope(node);
-        const indexValue = VAR5__namespace.toStaticValue({
+        const indexValue = VAR4__namespace.toStaticValue({
           kind: "lazy",
           node: index,
           initialScope: indexScope
@@ -116,7 +116,7 @@ function isSetFunctionCall(context, settings) {
         }
         const property = node.callee.property;
         const propertyScope = context.sourceCode.getScope(node);
-        const propertyValue = VAR5__namespace.toStaticValue({
+        const propertyValue = VAR4__namespace.toStaticValue({
           kind: "lazy",
           node: property,
           initialScope: propertyScope
@@ -152,6 +152,166 @@ function isVariableDeclaratorFromHookCall(node) {
   }
 }
 
+// src/hooks/use-no-direct-set-state-in-use-effect.ts
+function useNoDirectSetStateInUseEffect(context, options) {
+  const { onViolation, useEffectKind } = options;
+  const settings = shared.getSettingsFromContext(context);
+  const additionalHooks = settings.additionalHooks;
+  const isUseEffectLikeCall = core.isReactHookCallWithNameAlias(context, useEffectKind, additionalHooks[useEffectKind]);
+  const isUseStateCall2 = core.isReactHookCallWithNameAlias(context, "useState", additionalHooks.useState);
+  const isUseMemoCall2 = core.isReactHookCallWithNameAlias(context, "useMemo", additionalHooks.useMemo);
+  const isUseCallbackCall2 = core.isReactHookCallWithNameAlias(context, "useCallback", additionalHooks.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 Map();
+  const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new Map();
+  const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
+  const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new Map();
+  const onSetupFunctionEnter = (node) => {
+    setupFunctionRef.current = node;
+  };
+  const onSetupFunctionExit = (node) => {
+    if (setupFunctionRef.current === node) {
+      setupFunctionRef.current = null;
+    }
+  };
+  function isFunctionOfUseEffectSetup(node) {
+    return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
+  }
+  function getCallKind(node) {
+    return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
+  }
+  function getFunctionKind(node) {
+    return tsPattern.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;
+      }
+      tsPattern.match(getCallKind(node)).with("setState", () => {
+        switch (true) {
+          case (pEntry.node === setupFunction || pEntry.kind === "immediate"): {
+            onViolation(context, node, {
+              name: context.sourceCode.getText(node.callee)
+            });
+            return;
+          }
+          default: {
+            const vd = AST__namespace.findParentNode(node, isVariableDeclaratorFromHookCall);
+            if (vd == null) eff.getOrUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
+            else eff.getOrUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
+          }
+        }
+      }).with(useEffectKind, () => {
+        if (AST__namespace.isFunction(node.arguments.at(0))) return;
+        setupFunctionIdentifiers.push(...AST__namespace.getNestedIdentifiers(node));
+      }).with("other", () => {
+        if (pEntry.node !== setupFunction) return;
+        indFunctionCalls.push(node);
+      }).otherwise(() => eff._);
+    },
+    Identifier(node) {
+      if (node.parent.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
+        return;
+      }
+      if (!isIdFromUseStateCall(node)) {
+        return;
+      }
+      switch (node.parent.type) {
+        case types.AST_NODE_TYPES.ArrowFunctionExpression: {
+          const parent = node.parent.parent;
+          if (parent.type !== types.AST_NODE_TYPES.CallExpression) {
+            break;
+          }
+          if (!isUseMemoCall2(parent)) {
+            break;
+          }
+          const vd = AST__namespace.findParentNode(parent, isVariableDeclaratorFromHookCall);
+          if (vd != null) {
+            eff.getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
+          }
+          break;
+        }
+        case types.AST_NODE_TYPES.CallExpression: {
+          if (node !== node.parent.arguments.at(0)) {
+            break;
+          }
+          if (isUseCallbackCall2(node.parent)) {
+            const vd = AST__namespace.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
+            if (vd != null) {
+              eff.getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
+            }
+            break;
+          }
+          if (isUseEffectLikeCall(node.parent)) {
+            eff.getOrUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
+          }
+        }
+      }
+    },
+    "Program:exit"() {
+      const getSetStateCalls = (id, initialScope) => {
+        const node = VAR4__namespace.getVariableNode(VAR4__namespace.findVariable(id, initialScope), 0);
+        switch (node?.type) {
+          case types.AST_NODE_TYPES.ArrowFunctionExpression:
+          case types.AST_NODE_TYPES.FunctionDeclaration:
+          case types.AST_NODE_TYPES.FunctionExpression:
+            return indSetStateCalls.get(node) ?? [];
+          case types.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: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+          });
+        }
+      }
+      for (const id of setupFunctionIdentifiers) {
+        const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
+        for (const setStateCall of setStateCalls) {
+          onViolation(context, setStateCall, {
+            name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+          });
+        }
+      }
+    }
+  };
+}
+
 // src/rules/no-direct-set-state-in-use-effect.ts
 var RULE_NAME = "no-direct-set-state-in-use-effect";
 var RULE_FEATURES = [
@@ -171,183 +331,18 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   name: RULE_NAME,
   create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) {
-      return {};
-    }
-    const settings = shared.getSettingsFromContext(context);
-    const additionalHooks = settings.additionalHooks;
-    const isUseEffectLikeCall = core.isReactHookCallWithNameAlias(context, "useEffect", additionalHooks.useEffect ?? []);
-    const isUseStateCall2 = core.isReactHookCallWithNameAlias(context, "useState", additionalHooks.useState ?? []);
-    const isUseMemoCall2 = core.isReactHookCallWithNameAlias(context, "useMemo", additionalHooks.useMemo ?? []);
-    const isUseCallbackCall2 = core.isReactHookCallWithNameAlias(context, "useCallback", additionalHooks.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 Map();
-    const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new Map();
-    const onSetupFunctionEnter = (node) => {
-      setupFunctionRef.current = node;
-    };
-    const onSetupFunctionExit = (node) => {
-      if (setupFunctionRef.current === node) {
-        setupFunctionRef.current = null;
-      }
-    };
-    function isFunctionOfUseEffectSetup(node) {
-      return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
-    }
-    function getCallKind(node) {
-      return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
-    }
-    function getFunctionKind(node) {
-      return tsPattern.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();
+    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+    return useNoDirectSetStateInUseEffect(context, {
+      onViolation(ctx, node, data) {
+        ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
       },
-      CallExpression(node) {
-        const setupFunction = setupFunctionRef.current;
-        const pEntry = functionEntries.at(-1);
-        if (pEntry == null || pEntry.node.async) {
-          return;
-        }
-        tsPattern.match(getCallKind(node)).with("setState", () => {
-          switch (true) {
-            case (pEntry.node === setupFunction || pEntry.kind === "immediate"): {
-              context.report({
-                messageId: "noDirectSetStateInUseEffect",
-                node,
-                data: {
-                  name: context.sourceCode.getText(node.callee)
-                }
-              });
-              return;
-            }
-            default: {
-              const vd = AST__namespace.findParentNode(node, isVariableDeclaratorFromHookCall);
-              if (vd == null) eff.getOrUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
-              else eff.getOrUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
-            }
-          }
-        }).with("useEffect", () => {
-          if (AST__namespace.isFunction(node.arguments.at(0))) return;
-          setupFunctionIdentifiers.push(...AST__namespace.getNestedIdentifiers(node));
-        }).with("other", () => {
-          if (pEntry.node !== setupFunction) return;
-          indFunctionCalls.push(node);
-        }).otherwise(() => eff._);
-      },
-      Identifier(node) {
-        if (node.parent.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
-          return;
-        }
-        if (!isIdFromUseStateCall(node)) {
-          return;
-        }
-        switch (node.parent.type) {
-          case types.AST_NODE_TYPES.ArrowFunctionExpression: {
-            const parent = node.parent.parent;
-            if (parent.type !== types.AST_NODE_TYPES.CallExpression) {
-              break;
-            }
-            if (!isUseMemoCall2(parent)) {
-              break;
-            }
-            const vd = AST__namespace.findParentNode(parent, isVariableDeclaratorFromHookCall);
-            if (vd != null) {
-              eff.getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-            }
-            break;
-          }
-          case types.AST_NODE_TYPES.CallExpression: {
-            if (node !== node.parent.arguments.at(0)) {
-              break;
-            }
-            if (isUseCallbackCall2(node.parent)) {
-              const vd = AST__namespace.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
-              if (vd != null) {
-                eff.getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-              }
-              break;
-            }
-            if (isUseEffectLikeCall(node.parent)) {
-              eff.getOrUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
-            }
-          }
-        }
-      },
-      "Program:exit"() {
-        const getSetStateCalls = (id, initialScope) => {
-          const node = VAR5__namespace.getVariableNode(VAR5__namespace.findVariable(id, initialScope), 0);
-          switch (node?.type) {
-            case types.AST_NODE_TYPES.ArrowFunctionExpression:
-            case types.AST_NODE_TYPES.FunctionDeclaration:
-            case types.AST_NODE_TYPES.FunctionExpression:
-              return indSetStateCalls.get(node) ?? [];
-            case types.AST_NODE_TYPES.CallExpression:
-              return indSetStateCallsInUseMemoOrCallback.get(node) ?? indSetStateCallsInUseEffectArg0.get(node) ?? [];
-          }
-          return [];
-        };
-        for (const [, calls] of indSetStateCallsInUseEffectSetup) {
-          for (const call of calls) {
-            context.report({
-              messageId: "noDirectSetStateInUseEffect",
-              node: call,
-              data: { 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) {
-            context.report({
-              messageId: "noDirectSetStateInUseEffect",
-              node: setStateCall,
-              data: {
-                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-        for (const id of setupFunctionIdentifiers) {
-          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-          for (const setStateCall of setStateCalls) {
-            context.report({
-              messageId: "noDirectSetStateInUseEffect",
-              node: setStateCall,
-              data: {
-                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-      }
-    };
+      useEffectKind: "useEffect"
+    });
   },
   defaultOptions: []
 });
+
+// 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 = [
   "CHK"
@@ -366,184 +361,13 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   },
   name: RULE_NAME2,
   create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) {
-      return {};
-    }
-    const settings = shared.getSettingsFromContext(context);
-    const additionalHooks = settings.additionalHooks;
-    const isUseLayoutEffectLikeCall = core.isReactHookCallWithNameAlias(
-      context,
-      "useLayoutEffect",
-      additionalHooks.useLayoutEffect ?? []
-    );
-    const isUseStateCall2 = core.isReactHookCallWithNameAlias(context, "useState", additionalHooks.useState ?? []);
-    const isUseMemoCall2 = core.isReactHookCallWithNameAlias(context, "useMemo", additionalHooks.useMemo ?? []);
-    const isUseCallbackCall2 = core.isReactHookCallWithNameAlias(context, "useCallback", additionalHooks.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 Map();
-    const indSetStateCallsInUseLayoutEffectArg0 = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseLayoutEffectSetup = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new Map();
-    const onSetupFunctionEnter = (node) => {
-      setupFunctionRef.current = node;
-    };
-    const onSetupFunctionExit = (node) => {
-      if (setupFunctionRef.current === node) {
-        setupFunctionRef.current = null;
-      }
-    };
-    function isFunctionOfUseEffectSetup(node) {
-      return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseLayoutEffectLikeCall(node.parent);
-    }
-    function getCallKind(node) {
-      return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseLayoutEffectLikeCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
-    }
-    function getFunctionKind(node) {
-      return tsPattern.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;
-        }
-        tsPattern.match(getCallKind(node)).with("setState", () => {
-          switch (true) {
-            case (pEntry.node === setupFunction || pEntry.kind === "immediate"): {
-              context.report({
-                messageId: "noDirectSetStateInUseLayoutEffect",
-                node,
-                data: {
-                  name: context.sourceCode.getText(node.callee)
-                }
-              });
-              return;
-            }
-            default: {
-              const vd = AST__namespace.findParentNode(node, isVariableDeclaratorFromHookCall);
-              if (vd == null) eff.getOrUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
-              else eff.getOrUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
-            }
-          }
-        }).with("useLayoutEffect", () => {
-          if (AST__namespace.isFunction(node.arguments.at(0))) return;
-          setupFunctionIdentifiers.push(...AST__namespace.getNestedIdentifiers(node));
-        }).with("other", () => {
-          if (pEntry.node !== setupFunction) return;
-          indFunctionCalls.push(node);
-        }).otherwise(() => eff._);
-      },
-      Identifier(node) {
-        if (node.parent.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
-          return;
-        }
-        if (!isIdFromUseStateCall(node)) {
-          return;
-        }
-        switch (node.parent.type) {
-          case types.AST_NODE_TYPES.ArrowFunctionExpression: {
-            const parent = node.parent.parent;
-            if (parent.type !== types.AST_NODE_TYPES.CallExpression) {
-              break;
-            }
-            if (!isUseMemoCall2(parent)) {
-              break;
-            }
-            const vd = AST__namespace.findParentNode(parent, isVariableDeclaratorFromHookCall);
-            if (vd != null) {
-              eff.getOrUpdate(indSetStateCallsInUseLayoutEffectArg0, vd.init, () => []).push(node);
-            }
-            break;
-          }
-          case types.AST_NODE_TYPES.CallExpression: {
-            if (node !== node.parent.arguments.at(0)) {
-              break;
-            }
-            if (isUseCallbackCall2(node.parent)) {
-              const vd = AST__namespace.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
-              if (vd != null) {
-                eff.getOrUpdate(indSetStateCallsInUseLayoutEffectArg0, vd.init, () => []).push(node);
-              }
-              break;
-            }
-            if (isUseLayoutEffectLikeCall(node.parent)) {
-              eff.getOrUpdate(indSetStateCallsInUseLayoutEffectSetup, node.parent, () => []).push(node);
-            }
-          }
-        }
+    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+    return useNoDirectSetStateInUseEffect(context, {
+      onViolation(ctx, node, data) {
+        ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
       },
-      "Program:exit"() {
-        const getSetStateCalls = (id, initialScope) => {
-          const node = VAR5__namespace.getVariableNode(VAR5__namespace.findVariable(id, initialScope), 0);
-          switch (node?.type) {
-            case types.AST_NODE_TYPES.ArrowFunctionExpression:
-            case types.AST_NODE_TYPES.FunctionDeclaration:
-            case types.AST_NODE_TYPES.FunctionExpression:
-              return indSetStateCalls.get(node) ?? [];
-            case types.AST_NODE_TYPES.CallExpression:
-              return indSetStateCallsInUseMemoOrCallback.get(node) ?? indSetStateCallsInUseLayoutEffectArg0.get(node) ?? [];
-          }
-          return [];
-        };
-        for (const [, calls] of indSetStateCallsInUseLayoutEffectSetup) {
-          for (const call of calls) {
-            context.report({
-              messageId: "noDirectSetStateInUseLayoutEffect",
-              node: call,
-              data: { 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) {
-            context.report({
-              messageId: "noDirectSetStateInUseLayoutEffect",
-              node: setStateCall,
-              data: {
-                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-        for (const id of setupFunctionIdentifiers) {
-          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-          for (const setStateCall of setStateCalls) {
-            context.report({
-              messageId: "noDirectSetStateInUseLayoutEffect",
-              node: setStateCall,
-              data: {
-                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-      }
-    };
+      useEffectKind: "useLayoutEffect"
+    });
   },
   defaultOptions: []
 });
@@ -588,8 +412,8 @@ var no_unnecessary_use_callback_default = createRule({
           return;
         }
         const hasEmptyDeps = tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR5__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          const variable = VAR4__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR4__namespace.getVariableNode(variable, 0);
           if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
             return false;
           }
@@ -604,8 +428,8 @@ var no_unnecessary_use_callback_default = createRule({
           }
           return n;
         }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.identity).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR5__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          const variable = VAR4__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR4__namespace.getVariableNode(variable, 0);
           if (variableNode?.type !== types.AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== types.AST_NODE_TYPES.FunctionExpression) {
             return eff._;
           }
@@ -613,7 +437,7 @@ var no_unnecessary_use_callback_default = createRule({
         }).otherwise(() => eff._);
         if (arg0Node == null) return;
         const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR5__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const arg0NodeReferences = VAR4__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
         const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({
@@ -671,8 +495,8 @@ var no_unnecessary_use_memo_default = createRule({
           return;
         }
         const hasEmptyDeps = tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR5__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          const variable = VAR4__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR4__namespace.getVariableNode(variable, 0);
           if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
             return false;
           }
@@ -687,8 +511,8 @@ var no_unnecessary_use_memo_default = createRule({
           }
           return n;
         }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.identity).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR5__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          const variable = VAR4__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR4__namespace.getVariableNode(variable, 0);
           if (variableNode?.type !== types.AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== types.AST_NODE_TYPES.FunctionExpression) {
             return eff._;
           }
@@ -696,7 +520,7 @@ var no_unnecessary_use_memo_default = createRule({
         }).otherwise(() => eff._);
         if (arg0Node == null) return;
         const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR5__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const arg0NodeReferences = VAR4__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
         const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import * as AST from '@eslint-react/ast';
-import { isReactHookCallWithNameAlias, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, useHookCollector, isUseStateCall, isReactHookName } from '@eslint-react/core';
-import { getOrUpdate, _, identity, constTrue } from '@eslint-react/eff';
+import { isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, useHookCollector, isUseStateCall, isReactHookCallWithNameAlias, isReactHookName } from '@eslint-react/core';
+import { identity, _, getOrUpdate, constTrue } from '@eslint-react/eff';
 import { createRuleForPlugin, getSettingsFromContext } from '@eslint-react/shared';
-import * as VAR5 from '@eslint-react/var';
+import * as VAR4 from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { match } from 'ts-pattern';
 
@@ -27,13 +27,13 @@ var rules = {
 
 // package.json
 var name2 = "eslint-plugin-react-hooks-extra";
-var version = "1.30.0";
+var version = "1.30.1-beta.0";
 var createRule = createRuleForPlugin("hooks-extra");
 function isFromHookCall(context, name3, settings, predicate = constTrue) {
   const hookAlias = settings.additionalHooks[name3] ?? [];
   return (topLevelId) => {
-    const variable = VAR5.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR5.getVariableNode(variable, 0);
+    const variable = VAR4.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+    const variableNode = VAR4.getVariableNode(variable, 0);
     if (variableNode == null) return false;
     if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
     if (!isReactHookCallWithNameAlias(context, name3, hookAlias)(variableNode)) return false;
@@ -73,7 +73,7 @@ function isSetFunctionCall(context, settings) {
           return false;
         }
         const indexScope = context.sourceCode.getScope(node);
-        const indexValue = VAR5.toStaticValue({
+        const indexValue = VAR4.toStaticValue({
           kind: "lazy",
           node: index,
           initialScope: indexScope
@@ -93,7 +93,7 @@ function isSetFunctionCall(context, settings) {
         }
         const property = node.callee.property;
         const propertyScope = context.sourceCode.getScope(node);
-        const propertyValue = VAR5.toStaticValue({
+        const propertyValue = VAR4.toStaticValue({
           kind: "lazy",
           node: property,
           initialScope: propertyScope
@@ -129,6 +129,166 @@ function isVariableDeclaratorFromHookCall(node) {
   }
 }
 
+// src/hooks/use-no-direct-set-state-in-use-effect.ts
+function useNoDirectSetStateInUseEffect(context, options) {
+  const { onViolation, useEffectKind } = options;
+  const settings = getSettingsFromContext(context);
+  const additionalHooks = settings.additionalHooks;
+  const isUseEffectLikeCall = isReactHookCallWithNameAlias(context, useEffectKind, additionalHooks[useEffectKind]);
+  const isUseStateCall2 = isReactHookCallWithNameAlias(context, "useState", additionalHooks.useState);
+  const isUseMemoCall2 = isReactHookCallWithNameAlias(context, "useMemo", additionalHooks.useMemo);
+  const isUseCallbackCall2 = isReactHookCallWithNameAlias(context, "useCallback", additionalHooks.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 Map();
+  const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new Map();
+  const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
+  const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new Map();
+  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 getCallKind(node) {
+    return match(node).when(isUseStateCall2, () => "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 || pEntry.kind === "immediate"): {
+            onViolation(context, node, {
+              name: context.sourceCode.getText(node.callee)
+            });
+            return;
+          }
+          default: {
+            const vd = AST.findParentNode(node, isVariableDeclaratorFromHookCall);
+            if (vd == null) getOrUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
+            else getOrUpdate(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(() => _);
+    },
+    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 (!isUseMemoCall2(parent)) {
+            break;
+          }
+          const vd = AST.findParentNode(parent, isVariableDeclaratorFromHookCall);
+          if (vd != null) {
+            getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
+          }
+          break;
+        }
+        case AST_NODE_TYPES.CallExpression: {
+          if (node !== node.parent.arguments.at(0)) {
+            break;
+          }
+          if (isUseCallbackCall2(node.parent)) {
+            const vd = AST.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
+            if (vd != null) {
+              getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
+            }
+            break;
+          }
+          if (isUseEffectLikeCall(node.parent)) {
+            getOrUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
+          }
+        }
+      }
+    },
+    "Program:exit"() {
+      const getSetStateCalls = (id, initialScope) => {
+        const node = VAR4.getVariableNode(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: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+          });
+        }
+      }
+      for (const id of setupFunctionIdentifiers) {
+        const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
+        for (const setStateCall of setStateCalls) {
+          onViolation(context, setStateCall, {
+            name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+          });
+        }
+      }
+    }
+  };
+}
+
 // src/rules/no-direct-set-state-in-use-effect.ts
 var RULE_NAME = "no-direct-set-state-in-use-effect";
 var RULE_FEATURES = [
@@ -148,183 +308,18 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   name: RULE_NAME,
   create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) {
-      return {};
-    }
-    const settings = getSettingsFromContext(context);
-    const additionalHooks = settings.additionalHooks;
-    const isUseEffectLikeCall = isReactHookCallWithNameAlias(context, "useEffect", additionalHooks.useEffect ?? []);
-    const isUseStateCall2 = isReactHookCallWithNameAlias(context, "useState", additionalHooks.useState ?? []);
-    const isUseMemoCall2 = isReactHookCallWithNameAlias(context, "useMemo", additionalHooks.useMemo ?? []);
-    const isUseCallbackCall2 = isReactHookCallWithNameAlias(context, "useCallback", additionalHooks.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 Map();
-    const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new Map();
-    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 getCallKind(node) {
-      return match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => "useEffect").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);
-        }
+    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+    return useNoDirectSetStateInUseEffect(context, {
+      onViolation(ctx, node, data) {
+        ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
       },
-      ":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 || pEntry.kind === "immediate"): {
-              context.report({
-                messageId: "noDirectSetStateInUseEffect",
-                node,
-                data: {
-                  name: context.sourceCode.getText(node.callee)
-                }
-              });
-              return;
-            }
-            default: {
-              const vd = AST.findParentNode(node, isVariableDeclaratorFromHookCall);
-              if (vd == null) getOrUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
-              else getOrUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
-            }
-          }
-        }).with("useEffect", () => {
-          if (AST.isFunction(node.arguments.at(0))) return;
-          setupFunctionIdentifiers.push(...AST.getNestedIdentifiers(node));
-        }).with("other", () => {
-          if (pEntry.node !== setupFunction) return;
-          indFunctionCalls.push(node);
-        }).otherwise(() => _);
-      },
-      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 (!isUseMemoCall2(parent)) {
-              break;
-            }
-            const vd = AST.findParentNode(parent, isVariableDeclaratorFromHookCall);
-            if (vd != null) {
-              getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-            }
-            break;
-          }
-          case AST_NODE_TYPES.CallExpression: {
-            if (node !== node.parent.arguments.at(0)) {
-              break;
-            }
-            if (isUseCallbackCall2(node.parent)) {
-              const vd = AST.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
-              if (vd != null) {
-                getOrUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-              }
-              break;
-            }
-            if (isUseEffectLikeCall(node.parent)) {
-              getOrUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
-            }
-          }
-        }
-      },
-      "Program:exit"() {
-        const getSetStateCalls = (id, initialScope) => {
-          const node = VAR5.getVariableNode(VAR5.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) {
-            context.report({
-              messageId: "noDirectSetStateInUseEffect",
-              node: call,
-              data: { 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) {
-            context.report({
-              messageId: "noDirectSetStateInUseEffect",
-              node: setStateCall,
-              data: {
-                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-        for (const id of setupFunctionIdentifiers) {
-          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-          for (const setStateCall of setStateCalls) {
-            context.report({
-              messageId: "noDirectSetStateInUseEffect",
-              node: setStateCall,
-              data: {
-                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-      }
-    };
+      useEffectKind: "useEffect"
+    });
   },
   defaultOptions: []
 });
+
+// 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 = [
   "CHK"
@@ -343,184 +338,13 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   },
   name: RULE_NAME2,
   create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) {
-      return {};
-    }
-    const settings = getSettingsFromContext(context);
-    const additionalHooks = settings.additionalHooks;
-    const isUseLayoutEffectLikeCall = isReactHookCallWithNameAlias(
-      context,
-      "useLayoutEffect",
-      additionalHooks.useLayoutEffect ?? []
-    );
-    const isUseStateCall2 = isReactHookCallWithNameAlias(context, "useState", additionalHooks.useState ?? []);
-    const isUseMemoCall2 = isReactHookCallWithNameAlias(context, "useMemo", additionalHooks.useMemo ?? []);
-    const isUseCallbackCall2 = isReactHookCallWithNameAlias(context, "useCallback", additionalHooks.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 Map();
-    const indSetStateCallsInUseLayoutEffectArg0 = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseLayoutEffectSetup = /* @__PURE__ */ new Map();
-    const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new Map();
-    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 && isUseLayoutEffectLikeCall(node.parent);
-    }
-    function getCallKind(node) {
-      return match(node).when(isUseStateCall2, () => "useState").when(isUseLayoutEffectLikeCall, () => "useLayoutEffect").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();
+    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+    return useNoDirectSetStateInUseEffect(context, {
+      onViolation(ctx, node, data) {
+        ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
       },
-      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 || pEntry.kind === "immediate"): {
-              context.report({
-                messageId: "noDirectSetStateInUseLayoutEffect",
-                node,
-                data: {
-                  name: context.sourceCode.getText(node.callee)
-                }
-              });
-              return;
-            }
-            default: {
-              const vd = AST.findParentNode(node, isVariableDeclaratorFromHookCall);
-              if (vd == null) getOrUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
-              else getOrUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
-            }
-          }
-        }).with("useLayoutEffect", () => {
-          if (AST.isFunction(node.arguments.at(0))) return;
-          setupFunctionIdentifiers.push(...AST.getNestedIdentifiers(node));
-        }).with("other", () => {
-          if (pEntry.node !== setupFunction) return;
-          indFunctionCalls.push(node);
-        }).otherwise(() => _);
-      },
-      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 (!isUseMemoCall2(parent)) {
-              break;
-            }
-            const vd = AST.findParentNode(parent, isVariableDeclaratorFromHookCall);
-            if (vd != null) {
-              getOrUpdate(indSetStateCallsInUseLayoutEffectArg0, vd.init, () => []).push(node);
-            }
-            break;
-          }
-          case AST_NODE_TYPES.CallExpression: {
-            if (node !== node.parent.arguments.at(0)) {
-              break;
-            }
-            if (isUseCallbackCall2(node.parent)) {
-              const vd = AST.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
-              if (vd != null) {
-                getOrUpdate(indSetStateCallsInUseLayoutEffectArg0, vd.init, () => []).push(node);
-              }
-              break;
-            }
-            if (isUseLayoutEffectLikeCall(node.parent)) {
-              getOrUpdate(indSetStateCallsInUseLayoutEffectSetup, node.parent, () => []).push(node);
-            }
-          }
-        }
-      },
-      "Program:exit"() {
-        const getSetStateCalls = (id, initialScope) => {
-          const node = VAR5.getVariableNode(VAR5.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) ?? indSetStateCallsInUseLayoutEffectArg0.get(node) ?? [];
-          }
-          return [];
-        };
-        for (const [, calls] of indSetStateCallsInUseLayoutEffectSetup) {
-          for (const call of calls) {
-            context.report({
-              messageId: "noDirectSetStateInUseLayoutEffect",
-              node: call,
-              data: { 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) {
-            context.report({
-              messageId: "noDirectSetStateInUseLayoutEffect",
-              node: setStateCall,
-              data: {
-                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-        for (const id of setupFunctionIdentifiers) {
-          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-          for (const setStateCall of setStateCalls) {
-            context.report({
-              messageId: "noDirectSetStateInUseLayoutEffect",
-              node: setStateCall,
-              data: {
-                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
-              }
-            });
-          }
-        }
-      }
-    };
+      useEffectKind: "useLayoutEffect"
+    });
   },
   defaultOptions: []
 });
@@ -565,8 +389,8 @@ var no_unnecessary_use_callback_default = createRule({
           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 = VAR5.findVariable(n.name, initialScope);
-          const variableNode = VAR5.getVariableNode(variable, 0);
+          const variable = VAR4.findVariable(n.name, initialScope);
+          const variableNode = VAR4.getVariableNode(variable, 0);
           if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
             return false;
           }
@@ -581,8 +405,8 @@ var no_unnecessary_use_callback_default = createRule({
           }
           return n;
         }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR5.findVariable(n.name, initialScope);
-          const variableNode = VAR5.getVariableNode(variable, 0);
+          const variable = VAR4.findVariable(n.name, initialScope);
+          const variableNode = VAR4.getVariableNode(variable, 0);
           if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
             return _;
           }
@@ -590,7 +414,7 @@ var no_unnecessary_use_callback_default = createRule({
         }).otherwise(() => _);
         if (arg0Node == null) return;
         const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR5.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
         const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({
@@ -648,8 +472,8 @@ var no_unnecessary_use_memo_default = createRule({
           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 = VAR5.findVariable(n.name, initialScope);
-          const variableNode = VAR5.getVariableNode(variable, 0);
+          const variable = VAR4.findVariable(n.name, initialScope);
+          const variableNode = VAR4.getVariableNode(variable, 0);
           if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
             return false;
           }
@@ -664,8 +488,8 @@ var no_unnecessary_use_memo_default = createRule({
           }
           return n;
         }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR5.findVariable(n.name, initialScope);
-          const variableNode = VAR5.getVariableNode(variable, 0);
+          const variable = VAR4.findVariable(n.name, initialScope);
+          const variableNode = VAR4.getVariableNode(variable, 0);
           if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
             return _;
           }
@@ -673,7 +497,7 @@ var no_unnecessary_use_memo_default = createRule({
         }).otherwise(() => _);
         if (arg0Node == null) return;
         const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR5.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
         const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.30.0",
+  "version": "1.30.1-beta.0",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "react",
@@ -50,12 +50,12 @@
     "@typescript-eslint/utils": "^8.25.0",
     "string-ts": "^2.2.1",
     "ts-pattern": "^5.6.2",
-    "@eslint-react/ast": "1.30.0",
-    "@eslint-react/core": "1.30.0",
-    "@eslint-react/eff": "1.30.0",
-    "@eslint-react/jsx": "1.30.0",
-    "@eslint-react/shared": "1.30.0",
-    "@eslint-react/var": "1.30.0"
+    "@eslint-react/ast": "1.30.1-beta.0",
+    "@eslint-react/core": "1.30.1-beta.0",
+    "@eslint-react/eff": "1.30.1-beta.0",
+    "@eslint-react/shared": "1.30.1-beta.0",
+    "@eslint-react/jsx": "1.30.1-beta.0",
+    "@eslint-react/var": "1.30.1-beta.0"
   },
   "devDependencies": {
     "@types/react": "^19.0.10",