eslint-plugin-react-hooks-extra 1.5.28-beta.1 → 1.5.28-beta.2

package/dist/index.js

@@ -9,7 +9,7 @@ var astUtils = require('@typescript-eslint/utils/ast-utils');
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.5.28-beta.1";
+var version = "1.5.28-beta.2";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -63,32 +63,45 @@ var o = (n2, s2, c2) => {
     if (!r(s2)) return false;
     if (Array.isArray(n2)) {
       if (!Array.isArray(s2)) return false;
-      let t2 = [], r2 = [], a = [];
+      let t2 = [], r2 = [], a2 = [];
       for (const o2 of n2.keys()) {
         const s3 = n2[o2];
-        i(s3) && s3[e] ? a.push(s3) : a.length ? r2.push(s3) : t2.push(s3);
+        i(s3) && s3[e] ? a2.push(s3) : a2.length ? r2.push(s3) : t2.push(s3);
       }
-      if (a.length) {
-        if (a.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+      if (a2.length) {
+        if (a2.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
         if (s2.length < t2.length + r2.length) return false;
         const e2 = s2.slice(0, t2.length), n3 = 0 === r2.length ? [] : s2.slice(-r2.length), i2 = s2.slice(t2.length, 0 === r2.length ? Infinity : -r2.length);
-        return t2.every((t3, n4) => o(t3, e2[n4], c2)) && r2.every((t3, e3) => o(t3, n3[e3], c2)) && (0 === a.length || o(a[0], i2, c2));
+        return t2.every((t3, n4) => o(t3, e2[n4], c2)) && r2.every((t3, e3) => o(t3, n3[e3], c2)) && (0 === a2.length || o(a2[0], i2, c2));
       }
       return n2.length === s2.length && n2.every((t3, e2) => o(t3, s2[e2], c2));
     }
     return Object.keys(n2).every((e2) => {
       const r2 = n2[e2];
-      return (e2 in s2 || i(a = r2) && "optional" === a[t]().matcherType) && o(r2, s2[e2], c2);
-      var a;
+      return (e2 in s2 || i(a2 = r2) && "optional" === a2[t]().matcherType) && o(r2, s2[e2], c2);
+      var a2;
     });
   }
   return Object.is(s2, n2);
 };
 var s = (e2) => {
-  var n2, o2, a;
-  return r(e2) ? i(e2) ? null != (n2 = null == (o2 = (a = e2[t]()).getSelectionKeys) ? void 0 : o2.call(a)) ? n2 : [] : Array.isArray(e2) ? c(e2, s) : c(Object.values(e2), s) : [];
+  var n2, o2, a2;
+  return r(e2) ? i(e2) ? null != (n2 = null == (o2 = (a2 = e2[t]()).getSelectionKeys) ? void 0 : o2.call(a2)) ? n2 : [] : Array.isArray(e2) ? c(e2, s) : c(Object.values(e2), s) : [];
 };
 var c = (t2, e2) => t2.reduce((t3, n2) => t3.concat(e2(n2)), []);
+function a(...t2) {
+  if (1 === t2.length) {
+    const [e2] = t2;
+    return (t3) => o(e2, t3, () => {
+    });
+  }
+  if (2 === t2.length) {
+    const [e2, n2] = t2;
+    return o(e2, n2, () => {
+    });
+  }
+  throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t2.length}.`);
+}
 function u(t2) {
   return Object.assign(t2, { optional: () => l(t2), and: (e2) => m(t2, e2), or: (e2) => d(t2, e2), select: (e2) => void 0 === e2 ? p(t2) : p(e2, t2) });
 }
@@ -187,9 +200,9 @@ var z = class _z {
     let i2;
     3 === t2.length && "function" == typeof t2[1] ? i2 = t2[1] : t2.length > 2 && r2.push(...t2.slice(1, t2.length - 1));
     let s2 = false, c2 = {};
-    const a = (t3, e3) => {
+    const a2 = (t3, e3) => {
       s2 = true, c2[t3] = e3;
-    }, u2 = !r2.some((t3) => o(t3, this.input, a)) || i2 && !Boolean(i2(this.input)) ? W : { matched: true, value: e2(s2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
+    }, u2 = !r2.some((t3) => o(t3, this.input, a2)) || i2 && !Boolean(i2(this.input)) ? W : { matched: true, value: e2(s2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
     return new _z(this.input, u2);
   }
   when(t2, e2) {
@@ -391,64 +404,159 @@ var no_direct_set_state_in_use_effect_default = createRule({
   create(context) {
     const settings = shared.getESLintReactSettings(context.settings);
     const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseEffectCallWithAlias(node, context2) {
-      return core.isUseEffectCall(node, context2) || useEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    function isUseEffectCallWithAlias(node) {
+      return core.isUseEffectCall(node, context) || useEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
     }
-    function isUseStateCallWithAlias(node, context2) {
-      return core.isUseStateCall(node, context2) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    function isUseStateCallWithAlias(node) {
+      return core.isUseStateCall(node, context) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
     }
     function isEffectFunction(node) {
-      return node.parent?.type === ast.NodeType.CallExpression && isUseEffectCallWithAlias(node.parent, context);
+      return node.parent?.type === ast.NodeType.CallExpression && node.parent.callee !== node && isUseEffectCallWithAlias(node.parent);
+    }
+    function isCleanUpFunction(_2) {
     }
+    function isFromUseStateCall(id) {
+      return tools.F.pipe(
+        $(id).with({ type: ast.NodeType.Identifier }, (n2) => tools.O.some(n2.name)).with({
+          type: ast.NodeType.MemberExpression,
+          object: { type: ast.NodeType.Identifier }
+        }, (n2) => tools.O.some(n2.object.name)).otherwise(tools.O.none),
+        tools.O.flatMap(_var.findVariable(context.sourceCode.getScope(id))),
+        tools.O.flatMap(_var.getVariableInit(0)),
+        tools.O.filter(ast.is(ast.NodeType.CallExpression)),
+        tools.O.exists(isUseStateCallWithAlias)
+      );
+    }
+    function isSetStateCall(node) {
+      const id = $(node.callee).with({ type: ast.NodeType.Identifier }, tools.O.some).with({ type: ast.NodeType.MemberExpression }, (n2) => {
+        if (!("name" in n2.object)) return tools.O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const property = astUtils.getStaticValue(n2.property, initialScope);
+        if (property?.value === 1) return tools.O.fromNullable(n2.object);
+        return tools.O.none();
+      }).with({ type: ast.NodeType.CallExpression }, (n2) => {
+        if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
+        if (!("name" in n2.callee.object)) return tools.O.none();
+        const isAt = a({
+          type: ast.NodeType.MemberExpression,
+          property: {
+            type: ast.NodeType.Identifier,
+            name: "at"
+          }
+        }, n2.callee);
+        const [index] = n2.arguments;
+        if (!isAt || !index) return tools.O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const value = astUtils.getStaticValue(index, initialScope);
+        if (value?.value === 1) return tools.O.fromNullable(n2.callee.object);
+        return tools.O.none();
+      }).otherwise(tools.O.none);
+      return tools.O.exists(id, isFromUseStateCall);
+    }
+    function isThenCall(node) {
+      if (node.callee.type !== ast.NodeType.MemberExpression) return false;
+      return a({
+        type: ast.NodeType.Identifier,
+        name: "then"
+      }, node.callee.property);
+    }
+    function getCallKind(node) {
+      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseEffectCallWithAlias, () => "useEffect").otherwise(() => "other");
+    }
+    function getFunctionKind(node) {
+      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
+    }
+    const useEffectCallRef = tools.MutRef.make(null);
+    const callStack = tools.MutList.make();
+    const functionStack = tools.MutList.make();
+    const effectFunctionRef = tools.MutRef.make(null);
+    const cleanUpFunctionRef = tools.MutRef.make(null);
+    const indirectFunctionCalls = [];
+    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const onUseEffectCallEnter = (node) => void tools.MutRef.set(useEffectCallRef, node);
+    const onUseEffectCallExit = () => void tools.MutRef.set(useEffectCallRef, null);
     return {
+      Identifier(node) {
+        const isInUseEffectCall = tools.MutRef.get(useEffectCallRef) !== null;
+        const parentFn = tools.MutList.tail(functionStack)?.[0];
+        const useEffectCall = tools.MutRef.get(useEffectCallRef);
+        const isEffectFunction2 = useEffectCall && tools.O.isSome(ast.traverseUp(useEffectCall, (n2) => n2 === parentFn));
+        if (isFromUseStateCall(node) && isInUseEffectCall && isEffectFunction2) {
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT"
+          });
+        }
+      },
       CallExpression(node) {
-        const effectFunction = ast.traverseUp(node, isEffectFunction);
-        const parentFunction = ast.traverseUp(node, ast.isFunction);
-        if (tools.O.isNone(effectFunction) || tools.O.isNone(parentFunction)) return;
-        if (parentFunction.value !== effectFunction.value) return;
-        const callScope = context.sourceCode.getScope(node);
-        const name2 = $(node.callee).with({ type: ast.NodeType.Identifier }, (n2) => tools.O.some(n2.name)).with({ type: ast.NodeType.MemberExpression }, (n2) => {
-          if (!("name" in n2.object)) return tools.O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const property = astUtils.getStaticValue(n2.property, initialScope);
-          if (property?.value === 1) return tools.O.fromNullable(n2.object.name);
-          return tools.O.none();
-        }).with({ type: ast.NodeType.CallExpression }, (n2) => {
-          if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
-          if (!("name" in n2.callee.object)) return tools.O.none();
-          const isAt = $(n2.callee).with(
-            {
-              type: ast.NodeType.MemberExpression,
-              property: {
-                type: ast.NodeType.Identifier,
-                name: "at"
-              }
-            },
-            tools.F.constTrue
-          ).otherwise(tools.F.constFalse);
-          if (!isAt) return tools.O.none();
-          const [index] = n2.arguments;
-          if (!index) return tools.O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const value = astUtils.getStaticValue(index, initialScope);
-          if (value?.value === 1) return tools.O.fromNullable(n2.callee.object.name);
-          return tools.O.none();
-        }).otherwise(tools.O.none);
-        tools.F.pipe(
-          name2,
-          tools.O.flatMap(_var.findVariable(callScope)),
-          tools.O.flatMap(_var.getVariableInit(0)),
-          tools.O.filter(ast.is(ast.NodeType.CallExpression)),
-          tools.O.filter((name3) => isUseStateCallWithAlias(name3, context)),
-          tools.O.map((name3) => ({
-            data: {
-              setState: name3
-            },
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
-            node
-          })),
-          tools.O.map(context.report)
-        );
+        tools.MutList.append(callStack, node);
+        const effectFn = tools.MutRef.get(effectFunctionRef);
+        const [parentFn, parentFnKind] = tools.MutList.tail(functionStack) ?? [];
+        if (parentFn?.async) return;
+        const callKind = getCallKind(node);
+        $(callKind).with("setState", () => {
+          if (!parentFn) return;
+          if (parentFn !== effectFn && parentFnKind !== "immediate") {
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
+            return;
+          }
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT"
+          });
+        }).with("useEffect", () => {
+          onUseEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
+        }).with("other", () => {
+          indirectFunctionCalls.push(node);
+        }).exhaustive();
+      },
+      ":function"(node) {
+        const functionKind = getFunctionKind(node);
+        tools.MutList.append(functionStack, [node, functionKind]);
+        $(functionKind).with("effect", () => {
+          tools.MutRef.set(effectFunctionRef, node);
+        }).with("cleanup", () => {
+          tools.MutRef.set(cleanUpFunctionRef, node);
+        }).otherwise(() => {
+        });
+      },
+      ":function:exit"(node) {
+        const effectFn = tools.MutRef.get(effectFunctionRef);
+        if (effectFn === node) {
+          tools.MutRef.set(effectFunctionRef, null);
+        }
+        tools.MutList.pop(functionStack);
+      },
+      "CallExpression:exit"(node) {
+        tools.MutList.pop(callStack);
+        if (tools.MutRef.get(useEffectCallRef) === node) {
+          onUseEffectCallExit();
+          tools.MutRef.set(useEffectCallRef, null);
+        }
+      },
+      "Program:exit"() {
+        for (const call of indirectFunctionCalls) {
+          if (!("name" in call.callee)) continue;
+          const { name: name2 } = call.callee;
+          const setStateCalls = tools.F.pipe(
+            _var.findVariable(name2, context.sourceCode.getScope(call)),
+            tools.O.flatMap(_var.getVariableInit(0)),
+            tools.O.filter(ast.isFunction),
+            tools.O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            tools.O.getOrElse(() => [])
+          );
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: {
+                name: name2
+              },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
       }
     };
   },
@@ -470,64 +578,159 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   create(context) {
     const settings = shared.getESLintReactSettings(context.settings);
     const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseLayoutEffectCallWithAlias(node, context2) {
-      return core.isUseLayoutEffectCall(node, context2) || useLayoutEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    function isUseLayoutEffectCallWithAlias(node) {
+      return core.isUseLayoutEffectCall(node, context) || useLayoutEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
     }
-    function isUseStateCallWithAlias(node, context2) {
-      return core.isUseStateCall(node, context2) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    function isUseStateCallWithAlias(node) {
+      return core.isUseStateCall(node, context) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
     }
     function isEffectFunction(node) {
-      return node.parent?.type === ast.NodeType.CallExpression && isUseLayoutEffectCallWithAlias(node.parent, context);
+      return node.parent?.type === ast.NodeType.CallExpression && node.parent.callee !== node && isUseLayoutEffectCallWithAlias(node.parent);
+    }
+    function isCleanUpFunction(_2) {
+    }
+    function isFromUseStateCall(id) {
+      return tools.F.pipe(
+        $(id).with({ type: ast.NodeType.Identifier }, (n2) => tools.O.some(n2.name)).with({
+          type: ast.NodeType.MemberExpression,
+          object: { type: ast.NodeType.Identifier }
+        }, (n2) => tools.O.some(n2.object.name)).otherwise(tools.O.none),
+        tools.O.flatMap(_var.findVariable(context.sourceCode.getScope(id))),
+        tools.O.flatMap(_var.getVariableInit(0)),
+        tools.O.filter(ast.is(ast.NodeType.CallExpression)),
+        tools.O.exists(isUseStateCallWithAlias)
+      );
+    }
+    function isSetStateCall(node) {
+      const id = $(node.callee).with({ type: ast.NodeType.Identifier }, tools.O.some).with({ type: ast.NodeType.MemberExpression }, (n2) => {
+        if (!("name" in n2.object)) return tools.O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const property = astUtils.getStaticValue(n2.property, initialScope);
+        if (property?.value === 1) return tools.O.fromNullable(n2.object);
+        return tools.O.none();
+      }).with({ type: ast.NodeType.CallExpression }, (n2) => {
+        if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
+        if (!("name" in n2.callee.object)) return tools.O.none();
+        const isAt = a({
+          type: ast.NodeType.MemberExpression,
+          property: {
+            type: ast.NodeType.Identifier,
+            name: "at"
+          }
+        }, n2.callee);
+        const [index] = n2.arguments;
+        if (!isAt || !index) return tools.O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const value = astUtils.getStaticValue(index, initialScope);
+        if (value?.value === 1) return tools.O.fromNullable(n2.callee.object);
+        return tools.O.none();
+      }).otherwise(tools.O.none);
+      return tools.O.exists(id, isFromUseStateCall);
+    }
+    function isThenCall(node) {
+      if (node.callee.type !== ast.NodeType.MemberExpression) return false;
+      return a({
+        type: ast.NodeType.Identifier,
+        name: "then"
+      }, node.callee.property);
     }
+    function getCallKind(node) {
+      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseLayoutEffectCallWithAlias, () => "useLayoutEffect").otherwise(() => "other");
+    }
+    function getFunctionKind(node) {
+      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
+    }
+    const useLayoutEffectCallRef = tools.MutRef.make(null);
+    const callStack = tools.MutList.make();
+    const functionStack = tools.MutList.make();
+    const effectFunctionRef = tools.MutRef.make(null);
+    const cleanUpFunctionRef = tools.MutRef.make(null);
+    const indirectFunctionCalls = [];
+    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const onUseLayoutEffectCallEnter = (node) => void tools.MutRef.set(useLayoutEffectCallRef, node);
+    const onUseLayoutEffectCallExit = () => void tools.MutRef.set(useLayoutEffectCallRef, null);
     return {
+      Identifier(node) {
+        const isInUseLayoutEffectCall = tools.MutRef.get(useLayoutEffectCallRef) !== null;
+        const parentFn = tools.MutList.tail(functionStack)?.[0];
+        const useLayoutEffectCall = tools.MutRef.get(useLayoutEffectCallRef);
+        const isEffectFunction2 = useLayoutEffectCall && tools.O.isSome(ast.traverseUp(useLayoutEffectCall, (n2) => n2 === parentFn));
+        if (isFromUseStateCall(node) && isInUseLayoutEffectCall && isEffectFunction2) {
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT"
+          });
+        }
+      },
       CallExpression(node) {
-        const effectFunction = ast.traverseUp(node, isEffectFunction);
-        const parentFunction = ast.traverseUp(node, ast.isFunction);
-        if (tools.O.isNone(effectFunction) || tools.O.isNone(parentFunction)) return;
-        if (parentFunction.value !== effectFunction.value) return;
-        const callScope = context.sourceCode.getScope(node);
-        const name2 = $(node.callee).with({ type: ast.NodeType.Identifier }, (n2) => tools.O.some(n2.name)).with({ type: ast.NodeType.MemberExpression }, (n2) => {
-          if (!("name" in n2.object)) return tools.O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const property = astUtils.getStaticValue(n2.property, initialScope);
-          if (property?.value === 1) return tools.O.fromNullable(n2.object.name);
-          return tools.O.none();
-        }).with({ type: ast.NodeType.CallExpression }, (n2) => {
-          if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
-          if (!("name" in n2.callee.object)) return tools.O.none();
-          const isAt = $(n2.callee).with(
-            {
-              type: ast.NodeType.MemberExpression,
-              property: {
-                type: ast.NodeType.Identifier,
-                name: "at"
-              }
-            },
-            tools.F.constTrue
-          ).otherwise(tools.F.constFalse);
-          if (!isAt) return tools.O.none();
-          const [index] = n2.arguments;
-          if (!index) return tools.O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const value = astUtils.getStaticValue(index, initialScope);
-          if (value?.value === 1) return tools.O.fromNullable(n2.callee.object.name);
-          return tools.O.none();
-        }).otherwise(tools.O.none);
-        tools.F.pipe(
-          name2,
-          tools.O.flatMap(_var.findVariable(callScope)),
-          tools.O.flatMap(_var.getVariableInit(0)),
-          tools.O.filter(ast.is(ast.NodeType.CallExpression)),
-          tools.O.filter((name3) => isUseStateCallWithAlias(name3, context)),
-          tools.O.map((name3) => ({
-            data: {
-              setState: name3
-            },
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
-            node
-          })),
-          tools.O.map(context.report)
-        );
+        tools.MutList.append(callStack, node);
+        const effectFn = tools.MutRef.get(effectFunctionRef);
+        const [parentFn, parentFnKind] = tools.MutList.tail(functionStack) ?? [];
+        if (parentFn?.async) return;
+        const callKind = getCallKind(node);
+        $(callKind).with("setState", () => {
+          if (!parentFn) return;
+          if (parentFn !== effectFn && parentFnKind !== "immediate") {
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
+            return;
+          }
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT"
+          });
+        }).with("useLayoutEffect", () => {
+          onUseLayoutEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
+        }).with("other", () => {
+          indirectFunctionCalls.push(node);
+        }).exhaustive();
+      },
+      ":function"(node) {
+        const functionKind = getFunctionKind(node);
+        tools.MutList.append(functionStack, [node, functionKind]);
+        $(functionKind).with("effect", () => {
+          tools.MutRef.set(effectFunctionRef, node);
+        }).with("cleanup", () => {
+          tools.MutRef.set(cleanUpFunctionRef, node);
+        }).otherwise(() => {
+        });
+      },
+      ":function:exit"(node) {
+        const effectFn = tools.MutRef.get(effectFunctionRef);
+        if (effectFn === node) {
+          tools.MutRef.set(effectFunctionRef, null);
+        }
+        tools.MutList.pop(functionStack);
+      },
+      "CallExpression:exit"(node) {
+        tools.MutList.pop(callStack);
+        if (tools.MutRef.get(useLayoutEffectCallRef) === node) {
+          onUseLayoutEffectCallExit();
+          tools.MutRef.set(useLayoutEffectCallRef, null);
+        }
+      },
+      "Program:exit"() {
+        for (const call of indirectFunctionCalls) {
+          if (!("name" in call.callee)) continue;
+          const { name: name2 } = call.callee;
+          const setStateCalls = tools.F.pipe(
+            _var.findVariable(name2, context.sourceCode.getScope(call)),
+            tools.O.flatMap(_var.getVariableInit(0)),
+            tools.O.filter(ast.isFunction),
+            tools.O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            tools.O.getOrElse(() => [])
+          );
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: {
+                name: name2
+              },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
       }
     };
   },

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall, isUseEffectCall, isUseLayoutEffectCall } from '@eslint-react/core';
 import { createRuleForPlugin, getESLintReactSettings } from '@eslint-react/shared';
-import { isFunction, NodeType, is, traverseUp, getNestedCallExpressions } from '@eslint-react/ast';
-import { F, O } from '@eslint-react/tools';
+import { isFunction, NodeType, is, traverseUp, getNestedCallExpressions, isIIFE } from '@eslint-react/ast';
+import { F, O, MutRef, MutList } from '@eslint-react/tools';
 import { findVariable, getVariableInit } from '@eslint-react/var';
 import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.5.28-beta.1";
+var version = "1.5.28-beta.2";
 var createRule = createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -61,32 +61,45 @@ var o = (n2, s2, c2) => {
     if (!r(s2)) return false;
     if (Array.isArray(n2)) {
       if (!Array.isArray(s2)) return false;
-      let t2 = [], r2 = [], a = [];
+      let t2 = [], r2 = [], a2 = [];
       for (const o2 of n2.keys()) {
         const s3 = n2[o2];
-        i(s3) && s3[e] ? a.push(s3) : a.length ? r2.push(s3) : t2.push(s3);
+        i(s3) && s3[e] ? a2.push(s3) : a2.length ? r2.push(s3) : t2.push(s3);
       }
-      if (a.length) {
-        if (a.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
+      if (a2.length) {
+        if (a2.length > 1) throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");
         if (s2.length < t2.length + r2.length) return false;
         const e2 = s2.slice(0, t2.length), n3 = 0 === r2.length ? [] : s2.slice(-r2.length), i2 = s2.slice(t2.length, 0 === r2.length ? Infinity : -r2.length);
-        return t2.every((t3, n4) => o(t3, e2[n4], c2)) && r2.every((t3, e3) => o(t3, n3[e3], c2)) && (0 === a.length || o(a[0], i2, c2));
+        return t2.every((t3, n4) => o(t3, e2[n4], c2)) && r2.every((t3, e3) => o(t3, n3[e3], c2)) && (0 === a2.length || o(a2[0], i2, c2));
       }
       return n2.length === s2.length && n2.every((t3, e2) => o(t3, s2[e2], c2));
     }
     return Object.keys(n2).every((e2) => {
       const r2 = n2[e2];
-      return (e2 in s2 || i(a = r2) && "optional" === a[t]().matcherType) && o(r2, s2[e2], c2);
-      var a;
+      return (e2 in s2 || i(a2 = r2) && "optional" === a2[t]().matcherType) && o(r2, s2[e2], c2);
+      var a2;
     });
   }
   return Object.is(s2, n2);
 };
 var s = (e2) => {
-  var n2, o2, a;
-  return r(e2) ? i(e2) ? null != (n2 = null == (o2 = (a = e2[t]()).getSelectionKeys) ? void 0 : o2.call(a)) ? n2 : [] : Array.isArray(e2) ? c(e2, s) : c(Object.values(e2), s) : [];
+  var n2, o2, a2;
+  return r(e2) ? i(e2) ? null != (n2 = null == (o2 = (a2 = e2[t]()).getSelectionKeys) ? void 0 : o2.call(a2)) ? n2 : [] : Array.isArray(e2) ? c(e2, s) : c(Object.values(e2), s) : [];
 };
 var c = (t2, e2) => t2.reduce((t3, n2) => t3.concat(e2(n2)), []);
+function a(...t2) {
+  if (1 === t2.length) {
+    const [e2] = t2;
+    return (t3) => o(e2, t3, () => {
+    });
+  }
+  if (2 === t2.length) {
+    const [e2, n2] = t2;
+    return o(e2, n2, () => {
+    });
+  }
+  throw new Error(`isMatching wasn't given the right number of arguments: expected 1 or 2, received ${t2.length}.`);
+}
 function u(t2) {
   return Object.assign(t2, { optional: () => l(t2), and: (e2) => m(t2, e2), or: (e2) => d(t2, e2), select: (e2) => void 0 === e2 ? p(t2) : p(e2, t2) });
 }
@@ -185,9 +198,9 @@ var z = class _z {
     let i2;
     3 === t2.length && "function" == typeof t2[1] ? i2 = t2[1] : t2.length > 2 && r2.push(...t2.slice(1, t2.length - 1));
     let s2 = false, c2 = {};
-    const a = (t3, e3) => {
+    const a2 = (t3, e3) => {
       s2 = true, c2[t3] = e3;
-    }, u2 = !r2.some((t3) => o(t3, this.input, a)) || i2 && !Boolean(i2(this.input)) ? W : { matched: true, value: e2(s2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
+    }, u2 = !r2.some((t3) => o(t3, this.input, a2)) || i2 && !Boolean(i2(this.input)) ? W : { matched: true, value: e2(s2 ? n in c2 ? c2[n] : c2 : this.input, this.input) };
     return new _z(this.input, u2);
   }
   when(t2, e2) {
@@ -389,64 +402,159 @@ var no_direct_set_state_in_use_effect_default = createRule({
   create(context) {
     const settings = getESLintReactSettings(context.settings);
     const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseEffectCallWithAlias(node, context2) {
-      return isUseEffectCall(node, context2) || useEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    function isUseEffectCallWithAlias(node) {
+      return isUseEffectCall(node, context) || useEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
     }
-    function isUseStateCallWithAlias(node, context2) {
-      return isUseStateCall(node, context2) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    function isUseStateCallWithAlias(node) {
+      return isUseStateCall(node, context) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
     }
     function isEffectFunction(node) {
-      return node.parent?.type === NodeType.CallExpression && isUseEffectCallWithAlias(node.parent, context);
+      return node.parent?.type === NodeType.CallExpression && node.parent.callee !== node && isUseEffectCallWithAlias(node.parent);
+    }
+    function isCleanUpFunction(_2) {
     }
+    function isFromUseStateCall(id) {
+      return F.pipe(
+        $(id).with({ type: NodeType.Identifier }, (n2) => O.some(n2.name)).with({
+          type: NodeType.MemberExpression,
+          object: { type: NodeType.Identifier }
+        }, (n2) => O.some(n2.object.name)).otherwise(O.none),
+        O.flatMap(findVariable(context.sourceCode.getScope(id))),
+        O.flatMap(getVariableInit(0)),
+        O.filter(is(NodeType.CallExpression)),
+        O.exists(isUseStateCallWithAlias)
+      );
+    }
+    function isSetStateCall(node) {
+      const id = $(node.callee).with({ type: NodeType.Identifier }, O.some).with({ type: NodeType.MemberExpression }, (n2) => {
+        if (!("name" in n2.object)) return O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const property = getStaticValue(n2.property, initialScope);
+        if (property?.value === 1) return O.fromNullable(n2.object);
+        return O.none();
+      }).with({ type: NodeType.CallExpression }, (n2) => {
+        if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
+        if (!("name" in n2.callee.object)) return O.none();
+        const isAt = a({
+          type: NodeType.MemberExpression,
+          property: {
+            type: NodeType.Identifier,
+            name: "at"
+          }
+        }, n2.callee);
+        const [index] = n2.arguments;
+        if (!isAt || !index) return O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const value = getStaticValue(index, initialScope);
+        if (value?.value === 1) return O.fromNullable(n2.callee.object);
+        return O.none();
+      }).otherwise(O.none);
+      return O.exists(id, isFromUseStateCall);
+    }
+    function isThenCall(node) {
+      if (node.callee.type !== NodeType.MemberExpression) return false;
+      return a({
+        type: NodeType.Identifier,
+        name: "then"
+      }, node.callee.property);
+    }
+    function getCallKind(node) {
+      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseEffectCallWithAlias, () => "useEffect").otherwise(() => "other");
+    }
+    function getFunctionKind(node) {
+      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(isIIFE, () => "immediate").otherwise(() => "other");
+    }
+    const useEffectCallRef = MutRef.make(null);
+    const callStack = MutList.make();
+    const functionStack = MutList.make();
+    const effectFunctionRef = MutRef.make(null);
+    const cleanUpFunctionRef = MutRef.make(null);
+    const indirectFunctionCalls = [];
+    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const onUseEffectCallEnter = (node) => void MutRef.set(useEffectCallRef, node);
+    const onUseEffectCallExit = () => void MutRef.set(useEffectCallRef, null);
     return {
+      Identifier(node) {
+        const isInUseEffectCall = MutRef.get(useEffectCallRef) !== null;
+        const parentFn = MutList.tail(functionStack)?.[0];
+        const useEffectCall = MutRef.get(useEffectCallRef);
+        const isEffectFunction2 = useEffectCall && O.isSome(traverseUp(useEffectCall, (n2) => n2 === parentFn));
+        if (isFromUseStateCall(node) && isInUseEffectCall && isEffectFunction2) {
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT"
+          });
+        }
+      },
       CallExpression(node) {
-        const effectFunction = traverseUp(node, isEffectFunction);
-        const parentFunction = traverseUp(node, isFunction);
-        if (O.isNone(effectFunction) || O.isNone(parentFunction)) return;
-        if (parentFunction.value !== effectFunction.value) return;
-        const callScope = context.sourceCode.getScope(node);
-        const name2 = $(node.callee).with({ type: NodeType.Identifier }, (n2) => O.some(n2.name)).with({ type: NodeType.MemberExpression }, (n2) => {
-          if (!("name" in n2.object)) return O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const property = getStaticValue(n2.property, initialScope);
-          if (property?.value === 1) return O.fromNullable(n2.object.name);
-          return O.none();
-        }).with({ type: NodeType.CallExpression }, (n2) => {
-          if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
-          if (!("name" in n2.callee.object)) return O.none();
-          const isAt = $(n2.callee).with(
-            {
-              type: NodeType.MemberExpression,
-              property: {
-                type: NodeType.Identifier,
-                name: "at"
-              }
-            },
-            F.constTrue
-          ).otherwise(F.constFalse);
-          if (!isAt) return O.none();
-          const [index] = n2.arguments;
-          if (!index) return O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const value = getStaticValue(index, initialScope);
-          if (value?.value === 1) return O.fromNullable(n2.callee.object.name);
-          return O.none();
-        }).otherwise(O.none);
-        F.pipe(
-          name2,
-          O.flatMap(findVariable(callScope)),
-          O.flatMap(getVariableInit(0)),
-          O.filter(is(NodeType.CallExpression)),
-          O.filter((name3) => isUseStateCallWithAlias(name3, context)),
-          O.map((name3) => ({
-            data: {
-              setState: name3
-            },
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
-            node
-          })),
-          O.map(context.report)
-        );
+        MutList.append(callStack, node);
+        const effectFn = MutRef.get(effectFunctionRef);
+        const [parentFn, parentFnKind] = MutList.tail(functionStack) ?? [];
+        if (parentFn?.async) return;
+        const callKind = getCallKind(node);
+        $(callKind).with("setState", () => {
+          if (!parentFn) return;
+          if (parentFn !== effectFn && parentFnKind !== "immediate") {
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
+            return;
+          }
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT"
+          });
+        }).with("useEffect", () => {
+          onUseEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
+        }).with("other", () => {
+          indirectFunctionCalls.push(node);
+        }).exhaustive();
+      },
+      ":function"(node) {
+        const functionKind = getFunctionKind(node);
+        MutList.append(functionStack, [node, functionKind]);
+        $(functionKind).with("effect", () => {
+          MutRef.set(effectFunctionRef, node);
+        }).with("cleanup", () => {
+          MutRef.set(cleanUpFunctionRef, node);
+        }).otherwise(() => {
+        });
+      },
+      ":function:exit"(node) {
+        const effectFn = MutRef.get(effectFunctionRef);
+        if (effectFn === node) {
+          MutRef.set(effectFunctionRef, null);
+        }
+        MutList.pop(functionStack);
+      },
+      "CallExpression:exit"(node) {
+        MutList.pop(callStack);
+        if (MutRef.get(useEffectCallRef) === node) {
+          onUseEffectCallExit();
+          MutRef.set(useEffectCallRef, null);
+        }
+      },
+      "Program:exit"() {
+        for (const call of indirectFunctionCalls) {
+          if (!("name" in call.callee)) continue;
+          const { name: name2 } = call.callee;
+          const setStateCalls = F.pipe(
+            findVariable(name2, context.sourceCode.getScope(call)),
+            O.flatMap(getVariableInit(0)),
+            O.filter(isFunction),
+            O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            O.getOrElse(() => [])
+          );
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: {
+                name: name2
+              },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
       }
     };
   },
@@ -468,64 +576,159 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   create(context) {
     const settings = getESLintReactSettings(context.settings);
     const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseLayoutEffectCallWithAlias(node, context2) {
-      return isUseLayoutEffectCall(node, context2) || useLayoutEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    function isUseLayoutEffectCallWithAlias(node) {
+      return isUseLayoutEffectCall(node, context) || useLayoutEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
     }
-    function isUseStateCallWithAlias(node, context2) {
-      return isUseStateCall(node, context2) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    function isUseStateCallWithAlias(node) {
+      return isUseStateCall(node, context) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
     }
     function isEffectFunction(node) {
-      return node.parent?.type === NodeType.CallExpression && isUseLayoutEffectCallWithAlias(node.parent, context);
+      return node.parent?.type === NodeType.CallExpression && node.parent.callee !== node && isUseLayoutEffectCallWithAlias(node.parent);
+    }
+    function isCleanUpFunction(_2) {
+    }
+    function isFromUseStateCall(id) {
+      return F.pipe(
+        $(id).with({ type: NodeType.Identifier }, (n2) => O.some(n2.name)).with({
+          type: NodeType.MemberExpression,
+          object: { type: NodeType.Identifier }
+        }, (n2) => O.some(n2.object.name)).otherwise(O.none),
+        O.flatMap(findVariable(context.sourceCode.getScope(id))),
+        O.flatMap(getVariableInit(0)),
+        O.filter(is(NodeType.CallExpression)),
+        O.exists(isUseStateCallWithAlias)
+      );
+    }
+    function isSetStateCall(node) {
+      const id = $(node.callee).with({ type: NodeType.Identifier }, O.some).with({ type: NodeType.MemberExpression }, (n2) => {
+        if (!("name" in n2.object)) return O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const property = getStaticValue(n2.property, initialScope);
+        if (property?.value === 1) return O.fromNullable(n2.object);
+        return O.none();
+      }).with({ type: NodeType.CallExpression }, (n2) => {
+        if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
+        if (!("name" in n2.callee.object)) return O.none();
+        const isAt = a({
+          type: NodeType.MemberExpression,
+          property: {
+            type: NodeType.Identifier,
+            name: "at"
+          }
+        }, n2.callee);
+        const [index] = n2.arguments;
+        if (!isAt || !index) return O.none();
+        const initialScope = context.sourceCode.getScope(n2);
+        const value = getStaticValue(index, initialScope);
+        if (value?.value === 1) return O.fromNullable(n2.callee.object);
+        return O.none();
+      }).otherwise(O.none);
+      return O.exists(id, isFromUseStateCall);
+    }
+    function isThenCall(node) {
+      if (node.callee.type !== NodeType.MemberExpression) return false;
+      return a({
+        type: NodeType.Identifier,
+        name: "then"
+      }, node.callee.property);
     }
+    function getCallKind(node) {
+      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseLayoutEffectCallWithAlias, () => "useLayoutEffect").otherwise(() => "other");
+    }
+    function getFunctionKind(node) {
+      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(isIIFE, () => "immediate").otherwise(() => "other");
+    }
+    const useLayoutEffectCallRef = MutRef.make(null);
+    const callStack = MutList.make();
+    const functionStack = MutList.make();
+    const effectFunctionRef = MutRef.make(null);
+    const cleanUpFunctionRef = MutRef.make(null);
+    const indirectFunctionCalls = [];
+    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const onUseLayoutEffectCallEnter = (node) => void MutRef.set(useLayoutEffectCallRef, node);
+    const onUseLayoutEffectCallExit = () => void MutRef.set(useLayoutEffectCallRef, null);
     return {
+      Identifier(node) {
+        const isInUseLayoutEffectCall = MutRef.get(useLayoutEffectCallRef) !== null;
+        const parentFn = MutList.tail(functionStack)?.[0];
+        const useLayoutEffectCall = MutRef.get(useLayoutEffectCallRef);
+        const isEffectFunction2 = useLayoutEffectCall && O.isSome(traverseUp(useLayoutEffectCall, (n2) => n2 === parentFn));
+        if (isFromUseStateCall(node) && isInUseLayoutEffectCall && isEffectFunction2) {
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT"
+          });
+        }
+      },
       CallExpression(node) {
-        const effectFunction = traverseUp(node, isEffectFunction);
-        const parentFunction = traverseUp(node, isFunction);
-        if (O.isNone(effectFunction) || O.isNone(parentFunction)) return;
-        if (parentFunction.value !== effectFunction.value) return;
-        const callScope = context.sourceCode.getScope(node);
-        const name2 = $(node.callee).with({ type: NodeType.Identifier }, (n2) => O.some(n2.name)).with({ type: NodeType.MemberExpression }, (n2) => {
-          if (!("name" in n2.object)) return O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const property = getStaticValue(n2.property, initialScope);
-          if (property?.value === 1) return O.fromNullable(n2.object.name);
-          return O.none();
-        }).with({ type: NodeType.CallExpression }, (n2) => {
-          if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
-          if (!("name" in n2.callee.object)) return O.none();
-          const isAt = $(n2.callee).with(
-            {
-              type: NodeType.MemberExpression,
-              property: {
-                type: NodeType.Identifier,
-                name: "at"
-              }
-            },
-            F.constTrue
-          ).otherwise(F.constFalse);
-          if (!isAt) return O.none();
-          const [index] = n2.arguments;
-          if (!index) return O.none();
-          const initialScope = context.sourceCode.getScope(n2);
-          const value = getStaticValue(index, initialScope);
-          if (value?.value === 1) return O.fromNullable(n2.callee.object.name);
-          return O.none();
-        }).otherwise(O.none);
-        F.pipe(
-          name2,
-          O.flatMap(findVariable(callScope)),
-          O.flatMap(getVariableInit(0)),
-          O.filter(is(NodeType.CallExpression)),
-          O.filter((name3) => isUseStateCallWithAlias(name3, context)),
-          O.map((name3) => ({
-            data: {
-              setState: name3
-            },
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
-            node
-          })),
-          O.map(context.report)
-        );
+        MutList.append(callStack, node);
+        const effectFn = MutRef.get(effectFunctionRef);
+        const [parentFn, parentFnKind] = MutList.tail(functionStack) ?? [];
+        if (parentFn?.async) return;
+        const callKind = getCallKind(node);
+        $(callKind).with("setState", () => {
+          if (!parentFn) return;
+          if (parentFn !== effectFn && parentFnKind !== "immediate") {
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
+            return;
+          }
+          context.report({
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT"
+          });
+        }).with("useLayoutEffect", () => {
+          onUseLayoutEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
+        }).with("other", () => {
+          indirectFunctionCalls.push(node);
+        }).exhaustive();
+      },
+      ":function"(node) {
+        const functionKind = getFunctionKind(node);
+        MutList.append(functionStack, [node, functionKind]);
+        $(functionKind).with("effect", () => {
+          MutRef.set(effectFunctionRef, node);
+        }).with("cleanup", () => {
+          MutRef.set(cleanUpFunctionRef, node);
+        }).otherwise(() => {
+        });
+      },
+      ":function:exit"(node) {
+        const effectFn = MutRef.get(effectFunctionRef);
+        if (effectFn === node) {
+          MutRef.set(effectFunctionRef, null);
+        }
+        MutList.pop(functionStack);
+      },
+      "CallExpression:exit"(node) {
+        MutList.pop(callStack);
+        if (MutRef.get(useLayoutEffectCallRef) === node) {
+          onUseLayoutEffectCallExit();
+          MutRef.set(useLayoutEffectCallRef, null);
+        }
+      },
+      "Program:exit"() {
+        for (const call of indirectFunctionCalls) {
+          if (!("name" in call.callee)) continue;
+          const { name: name2 } = call.callee;
+          const setStateCalls = F.pipe(
+            findVariable(name2, context.sourceCode.getScope(call)),
+            O.flatMap(getVariableInit(0)),
+            O.filter(isFunction),
+            O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            O.getOrElse(() => [])
+          );
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: {
+                name: name2
+              },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
       }
     };
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.5.28-beta.1",
+  "version": "1.5.28-beta.2",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "homepage": "https://github.com/rel1cx/eslint-react",
   "bugs": {
@@ -39,17 +39,17 @@
     "@typescript-eslint/type-utils": "^7.16.1",
     "@typescript-eslint/types": "^7.16.1",
     "@typescript-eslint/utils": "^7.16.1",
-    "@eslint-react/ast": "1.5.28-beta.1",
-    "@eslint-react/core": "1.5.28-beta.1",
-    "@eslint-react/jsx": "1.5.28-beta.1",
-    "@eslint-react/shared": "1.5.28-beta.1",
-    "@eslint-react/tools": "1.5.28-beta.1",
-    "@eslint-react/var": "1.5.28-beta.1",
-    "@eslint-react/types": "1.5.28-beta.1"
+    "@eslint-react/ast": "1.5.28-beta.2",
+    "@eslint-react/core": "1.5.28-beta.2",
+    "@eslint-react/tools": "1.5.28-beta.2",
+    "@eslint-react/shared": "1.5.28-beta.2",
+    "@eslint-react/types": "1.5.28-beta.2",
+    "@eslint-react/var": "1.5.28-beta.2",
+    "@eslint-react/jsx": "1.5.28-beta.2"
   },
   "devDependencies": {
     "string-ts": "2.2.0",
-    "tsup": "8.1.1"
+    "tsup": "8.2.0"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",