eslint-plugin-react-hooks-extra 1.5.28 → 1.5.29-beta.0

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";
+var version = "1.5.29-beta.0";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -246,7 +246,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
   },
   name: RULE_NAME2,
   create(context) {
-    const alias = shared.getESLintReactSettings(context.settings).additionalHooks?.useCallback ?? [];
+    const alias = shared.parseESLintSettings(context.settings)["react-x"]?.additionalHooks?.useCallback ?? [];
     return {
       CallExpression(node) {
         if (!core.isReactHookCall(node)) return;
@@ -269,7 +269,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           $(deps).with({ type: ast.NodeType.ArrayExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
             return tools.F.pipe(
               _var.findVariable(n2.name, initialScope),
-              tools.O.flatMap(_var.getVariableInit(0)),
+              tools.O.flatMap(_var.getVariableNode(0)),
               tools.O.filter(ast.is(ast.NodeType.ArrayExpression))
             );
           }).otherwise(tools.O.none),
@@ -292,7 +292,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           }).with({ type: ast.NodeType.FunctionExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
             return tools.F.pipe(
               _var.findVariable(n2.name, initialScope),
-              tools.O.flatMap(_var.getVariableInit(0)),
+              tools.O.flatMap(_var.getVariableNode(0)),
               tools.O.filter(ast.isFunction)
             );
           }).otherwise(tools.O.none),
@@ -324,7 +324,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
   },
   name: RULE_NAME3,
   create(context) {
-    const alias = shared.getESLintReactSettings(context.settings).additionalHooks?.useMemo ?? [];
+    const alias = shared.parseESLintSettings(context.settings)["react-x"]?.additionalHooks?.useMemo ?? [];
     return {
       CallExpression(node) {
         if (!core.isReactHookCall(node)) return;
@@ -347,7 +347,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           $(deps).with({ type: ast.NodeType.ArrayExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
             return tools.F.pipe(
               _var.findVariable(n2.name, initialScope),
-              tools.O.flatMap(_var.getVariableInit(0)),
+              tools.O.flatMap(_var.getVariableNode(0)),
               tools.O.filter(ast.is(ast.NodeType.ArrayExpression))
             );
           }).otherwise(tools.O.none),
@@ -370,7 +370,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           }).with({ type: ast.NodeType.FunctionExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
             return tools.F.pipe(
               _var.findVariable(n2.name, initialScope),
-              tools.O.flatMap(_var.getVariableInit(0)),
+              tools.O.flatMap(_var.getVariableNode(0)),
               tools.O.filter(ast.isFunction)
             );
           }).otherwise(tools.O.none),
@@ -402,8 +402,8 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   name: RULE_NAME4,
   create(context) {
-    const settings = shared.getESLintReactSettings(context.settings);
-    const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
+    const settings = shared.parseESLintSettings(context.settings)["react-x"];
+    const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings?.additionalHooks ?? {};
     function isUseEffectCallWithAlias(node) {
       return core.isUseEffectCall(node, context) || useEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
     }
@@ -422,7 +422,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
           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.flatMap(_var.getVariableNode(0)),
         tools.O.filter(ast.is(ast.NodeType.CallExpression)),
         tools.O.exists(isUseStateCallWithAlias)
       );
@@ -466,24 +466,27 @@ var no_direct_set_state_in_use_effect_default = createRule({
     function getFunctionKind(node) {
       return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
     }
-    const useEffectCallRef = tools.MutRef.make(null);
     const functionStack = tools.MutList.make();
     const effectFunctionRef = tools.MutRef.make(null);
-    const cleanUpFunctionRef = tools.MutRef.make(null);
+    const effectFunctionIdentifiers = tools.MutRef.make(tools.Chunk.empty());
     const indirectFunctionCalls = tools.MutRef.make(tools.Chunk.empty());
-    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
+    const onEffectFunctionEnter = (node) => {
+      tools.MutRef.set(effectFunctionRef, node);
+    };
+    const onEffectFunctionExit = (node) => {
+      tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    };
     return {
       ":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);
+          onEffectFunctionEnter(node);
         }).otherwise(tools.F.constVoid);
       },
       ":function:exit"(node) {
-        tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+        onEffectFunctionExit(node);
         tools.MutList.pop(functionStack);
       },
       CallExpression(node) {
@@ -503,35 +506,43 @@ var no_direct_set_state_in_use_effect_default = createRule({
             node
           });
         }).with("useEffect", () => {
-          tools.MutRef.set(useEffectCallRef, node);
+          if (node.arguments.every(ast.isFunction)) return;
+          const identifiers = ast.getNestedIdentifiers(node);
+          tools.MutRef.update(effectFunctionIdentifiers, tools.Chunk.appendAll(tools.Chunk.unsafeFromArray(identifiers)));
         }).with("other", () => {
           const isInEffectFunction = effectFn === parentFn;
           if (!isInEffectFunction) return;
           tools.MutRef.update(indirectFunctionCalls, tools.Chunk.append(node));
         }).otherwise(tools.F.constVoid);
       },
-      "CallExpression:exit"(node) {
-        if (tools.MutRef.get(useEffectCallRef) === node) {
-          tools.MutRef.set(useEffectCallRef, null);
-        }
-      },
       "Program:exit"() {
-        for (const call of tools.Chunk.toReadonlyArray(tools.MutRef.get(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)),
+        const getSetStateCalls = (id, initialScope) => {
+          return tools.F.pipe(
+            _var.findVariable(id, initialScope),
+            tools.O.flatMap(_var.getVariableNode(0)),
             tools.O.filter(ast.isFunction),
-            tools.O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            tools.O.flatMapNullable((fn) => indirectSetStateCalls.get(fn)),
             tools.O.map(tools.Chunk.toReadonlyArray),
             tools.O.getOrElse(() => [])
           );
+        };
+        for (const { callee } of tools.Chunk.toReadonlyArray(tools.MutRef.get(indirectFunctionCalls))) {
+          if (!("name" in callee)) continue;
+          const { name: name2 } = callee;
+          const setStateCalls = getSetStateCalls(name2, context.sourceCode.getScope(callee));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: { name: name2 },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
+        for (const id of tools.Chunk.toReadonlyArray(tools.MutRef.get(effectFunctionIdentifiers))) {
+          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({
-              data: {
-                name: name2
-              },
+              data: { name: id.name },
               messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
               node: setStateCall
             });
@@ -556,7 +567,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   },
   name: RULE_NAME5,
   create(context) {
-    const settings = shared.getESLintReactSettings(context.settings);
+    const settings = shared.parseESLintSettings(context.settings)["react-x"] ?? {};
     const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
     function isUseLayoutEffectCallWithAlias(node) {
       return core.isUseLayoutEffectCall(node, context) || useLayoutEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
@@ -576,7 +587,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
           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.flatMap(_var.getVariableNode(0)),
         tools.O.filter(ast.is(ast.NodeType.CallExpression)),
         tools.O.exists(isUseStateCallWithAlias)
       );
@@ -620,24 +631,27 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     function getFunctionKind(node) {
       return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
     }
-    const useLayoutEffectCallRef = tools.MutRef.make(null);
     const functionStack = tools.MutList.make();
     const effectFunctionRef = tools.MutRef.make(null);
-    const cleanUpFunctionRef = tools.MutRef.make(null);
+    const effectFunctionIdentifiers = tools.MutRef.make(tools.Chunk.empty());
     const indirectFunctionCalls = tools.MutRef.make(tools.Chunk.empty());
-    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
+    const onEffectFunctionEnter = (node) => {
+      tools.MutRef.set(effectFunctionRef, node);
+    };
+    const onEffectFunctionExit = (node) => {
+      tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    };
     return {
       ":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);
+          onEffectFunctionEnter(node);
         }).otherwise(tools.F.constVoid);
       },
       ":function:exit"(node) {
-        tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+        onEffectFunctionExit(node);
         tools.MutList.pop(functionStack);
       },
       CallExpression(node) {
@@ -657,35 +671,43 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             node
           });
         }).with("useLayoutEffect", () => {
-          tools.MutRef.set(useLayoutEffectCallRef, node);
+          if (node.arguments.every(ast.isFunction)) return;
+          const identifiers = ast.getNestedIdentifiers(node);
+          tools.MutRef.update(effectFunctionIdentifiers, tools.Chunk.appendAll(tools.Chunk.unsafeFromArray(identifiers)));
         }).with("other", () => {
           const isInEffectFunction = effectFn === parentFn;
           if (!isInEffectFunction) return;
           tools.MutRef.update(indirectFunctionCalls, tools.Chunk.append(node));
         }).otherwise(tools.F.constVoid);
       },
-      "CallExpression:exit"(node) {
-        if (tools.MutRef.get(useLayoutEffectCallRef) === node) {
-          tools.MutRef.set(useLayoutEffectCallRef, null);
-        }
-      },
       "Program:exit"() {
-        for (const call of tools.Chunk.toReadonlyArray(tools.MutRef.get(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)),
+        const getSetStateCalls = (id, initialScope) => {
+          return tools.F.pipe(
+            _var.findVariable(id, initialScope),
+            tools.O.flatMap(_var.getVariableNode(0)),
             tools.O.filter(ast.isFunction),
-            tools.O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            tools.O.flatMapNullable((fn) => indirectSetStateCalls.get(fn)),
             tools.O.map(tools.Chunk.toReadonlyArray),
             tools.O.getOrElse(() => [])
           );
+        };
+        for (const { callee } of tools.Chunk.toReadonlyArray(tools.MutRef.get(indirectFunctionCalls))) {
+          if (!("name" in callee)) continue;
+          const { name: name2 } = callee;
+          const setStateCalls = getSetStateCalls(name2, context.sourceCode.getScope(callee));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: { name: name2 },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
+        for (const id of tools.Chunk.toReadonlyArray(tools.MutRef.get(effectFunctionIdentifiers))) {
+          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({
-              data: {
-                name: name2
-              },
+              data: { name: id.name },
               messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
               node: setStateCall
             });
@@ -711,7 +733,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
   },
   name: RULE_NAME6,
   create(context) {
-    const alias = shared.getESLintReactSettings(context.settings).additionalHooks?.useState ?? [];
+    const alias = shared.parseESLintSettings(context.settings)["react-x"]?.additionalHooks?.useState ?? [];
     return {
       CallExpression(node) {
         if (!core.isReactHookCall(node)) return;

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, getNestedCallExpressions, isIIFE } from '@eslint-react/ast';
-import { F, O, MutRef, MutList, Chunk } from '@eslint-react/tools';
-import { findVariable, getVariableInit } from '@eslint-react/var';
+import { createRuleForPlugin, parseESLintSettings } from '@eslint-react/shared';
+import { isFunction, NodeType, is, getNestedIdentifiers, getNestedCallExpressions, isIIFE } from '@eslint-react/ast';
+import { F, O, MutList, MutRef, Chunk } from '@eslint-react/tools';
+import { findVariable, getVariableNode } 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";
+var version = "1.5.29-beta.0";
 var createRule = createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -244,7 +244,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
   },
   name: RULE_NAME2,
   create(context) {
-    const alias = getESLintReactSettings(context.settings).additionalHooks?.useCallback ?? [];
+    const alias = parseESLintSettings(context.settings)["react-x"]?.additionalHooks?.useCallback ?? [];
     return {
       CallExpression(node) {
         if (!isReactHookCall(node)) return;
@@ -267,7 +267,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           $(deps).with({ type: NodeType.ArrayExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
             return F.pipe(
               findVariable(n2.name, initialScope),
-              O.flatMap(getVariableInit(0)),
+              O.flatMap(getVariableNode(0)),
               O.filter(is(NodeType.ArrayExpression))
             );
           }).otherwise(O.none),
@@ -290,7 +290,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           }).with({ type: NodeType.FunctionExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
             return F.pipe(
               findVariable(n2.name, initialScope),
-              O.flatMap(getVariableInit(0)),
+              O.flatMap(getVariableNode(0)),
               O.filter(isFunction)
             );
           }).otherwise(O.none),
@@ -322,7 +322,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
   },
   name: RULE_NAME3,
   create(context) {
-    const alias = getESLintReactSettings(context.settings).additionalHooks?.useMemo ?? [];
+    const alias = parseESLintSettings(context.settings)["react-x"]?.additionalHooks?.useMemo ?? [];
     return {
       CallExpression(node) {
         if (!isReactHookCall(node)) return;
@@ -345,7 +345,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           $(deps).with({ type: NodeType.ArrayExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
             return F.pipe(
               findVariable(n2.name, initialScope),
-              O.flatMap(getVariableInit(0)),
+              O.flatMap(getVariableNode(0)),
               O.filter(is(NodeType.ArrayExpression))
             );
           }).otherwise(O.none),
@@ -368,7 +368,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           }).with({ type: NodeType.FunctionExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
             return F.pipe(
               findVariable(n2.name, initialScope),
-              O.flatMap(getVariableInit(0)),
+              O.flatMap(getVariableNode(0)),
               O.filter(isFunction)
             );
           }).otherwise(O.none),
@@ -400,8 +400,8 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   name: RULE_NAME4,
   create(context) {
-    const settings = getESLintReactSettings(context.settings);
-    const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
+    const settings = parseESLintSettings(context.settings)["react-x"];
+    const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings?.additionalHooks ?? {};
     function isUseEffectCallWithAlias(node) {
       return isUseEffectCall(node, context) || useEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
     }
@@ -420,7 +420,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
           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.flatMap(getVariableNode(0)),
         O.filter(is(NodeType.CallExpression)),
         O.exists(isUseStateCallWithAlias)
       );
@@ -464,24 +464,27 @@ var no_direct_set_state_in_use_effect_default = createRule({
     function getFunctionKind(node) {
       return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(isIIFE, () => "immediate").otherwise(() => "other");
     }
-    const useEffectCallRef = MutRef.make(null);
     const functionStack = MutList.make();
     const effectFunctionRef = MutRef.make(null);
-    const cleanUpFunctionRef = MutRef.make(null);
+    const effectFunctionIdentifiers = MutRef.make(Chunk.empty());
     const indirectFunctionCalls = MutRef.make(Chunk.empty());
-    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
+    const onEffectFunctionEnter = (node) => {
+      MutRef.set(effectFunctionRef, node);
+    };
+    const onEffectFunctionExit = (node) => {
+      MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    };
     return {
       ":function"(node) {
         const functionKind = getFunctionKind(node);
         MutList.append(functionStack, [node, functionKind]);
         $(functionKind).with("effect", () => {
-          MutRef.set(effectFunctionRef, node);
-        }).with("cleanup", () => {
-          MutRef.set(cleanUpFunctionRef, node);
+          onEffectFunctionEnter(node);
         }).otherwise(F.constVoid);
       },
       ":function:exit"(node) {
-        MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+        onEffectFunctionExit(node);
         MutList.pop(functionStack);
       },
       CallExpression(node) {
@@ -501,35 +504,43 @@ var no_direct_set_state_in_use_effect_default = createRule({
             node
           });
         }).with("useEffect", () => {
-          MutRef.set(useEffectCallRef, node);
+          if (node.arguments.every(isFunction)) return;
+          const identifiers = getNestedIdentifiers(node);
+          MutRef.update(effectFunctionIdentifiers, Chunk.appendAll(Chunk.unsafeFromArray(identifiers)));
         }).with("other", () => {
           const isInEffectFunction = effectFn === parentFn;
           if (!isInEffectFunction) return;
           MutRef.update(indirectFunctionCalls, Chunk.append(node));
         }).otherwise(F.constVoid);
       },
-      "CallExpression:exit"(node) {
-        if (MutRef.get(useEffectCallRef) === node) {
-          MutRef.set(useEffectCallRef, null);
-        }
-      },
       "Program:exit"() {
-        for (const call of Chunk.toReadonlyArray(MutRef.get(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)),
+        const getSetStateCalls = (id, initialScope) => {
+          return F.pipe(
+            findVariable(id, initialScope),
+            O.flatMap(getVariableNode(0)),
             O.filter(isFunction),
-            O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            O.flatMapNullable((fn) => indirectSetStateCalls.get(fn)),
             O.map(Chunk.toReadonlyArray),
             O.getOrElse(() => [])
           );
+        };
+        for (const { callee } of Chunk.toReadonlyArray(MutRef.get(indirectFunctionCalls))) {
+          if (!("name" in callee)) continue;
+          const { name: name2 } = callee;
+          const setStateCalls = getSetStateCalls(name2, context.sourceCode.getScope(callee));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: { name: name2 },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
+        for (const id of Chunk.toReadonlyArray(MutRef.get(effectFunctionIdentifiers))) {
+          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({
-              data: {
-                name: name2
-              },
+              data: { name: id.name },
               messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
               node: setStateCall
             });
@@ -554,7 +565,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   },
   name: RULE_NAME5,
   create(context) {
-    const settings = getESLintReactSettings(context.settings);
+    const settings = parseESLintSettings(context.settings)["react-x"] ?? {};
     const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
     function isUseLayoutEffectCallWithAlias(node) {
       return isUseLayoutEffectCall(node, context) || useLayoutEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
@@ -574,7 +585,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
           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.flatMap(getVariableNode(0)),
         O.filter(is(NodeType.CallExpression)),
         O.exists(isUseStateCallWithAlias)
       );
@@ -618,24 +629,27 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     function getFunctionKind(node) {
       return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(isIIFE, () => "immediate").otherwise(() => "other");
     }
-    const useLayoutEffectCallRef = MutRef.make(null);
     const functionStack = MutList.make();
     const effectFunctionRef = MutRef.make(null);
-    const cleanUpFunctionRef = MutRef.make(null);
+    const effectFunctionIdentifiers = MutRef.make(Chunk.empty());
     const indirectFunctionCalls = MutRef.make(Chunk.empty());
-    const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
+    const onEffectFunctionEnter = (node) => {
+      MutRef.set(effectFunctionRef, node);
+    };
+    const onEffectFunctionExit = (node) => {
+      MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    };
     return {
       ":function"(node) {
         const functionKind = getFunctionKind(node);
         MutList.append(functionStack, [node, functionKind]);
         $(functionKind).with("effect", () => {
-          MutRef.set(effectFunctionRef, node);
-        }).with("cleanup", () => {
-          MutRef.set(cleanUpFunctionRef, node);
+          onEffectFunctionEnter(node);
         }).otherwise(F.constVoid);
       },
       ":function:exit"(node) {
-        MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+        onEffectFunctionExit(node);
         MutList.pop(functionStack);
       },
       CallExpression(node) {
@@ -655,35 +669,43 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             node
           });
         }).with("useLayoutEffect", () => {
-          MutRef.set(useLayoutEffectCallRef, node);
+          if (node.arguments.every(isFunction)) return;
+          const identifiers = getNestedIdentifiers(node);
+          MutRef.update(effectFunctionIdentifiers, Chunk.appendAll(Chunk.unsafeFromArray(identifiers)));
         }).with("other", () => {
           const isInEffectFunction = effectFn === parentFn;
           if (!isInEffectFunction) return;
           MutRef.update(indirectFunctionCalls, Chunk.append(node));
         }).otherwise(F.constVoid);
       },
-      "CallExpression:exit"(node) {
-        if (MutRef.get(useLayoutEffectCallRef) === node) {
-          MutRef.set(useLayoutEffectCallRef, null);
-        }
-      },
       "Program:exit"() {
-        for (const call of Chunk.toReadonlyArray(MutRef.get(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)),
+        const getSetStateCalls = (id, initialScope) => {
+          return F.pipe(
+            findVariable(id, initialScope),
+            O.flatMap(getVariableNode(0)),
             O.filter(isFunction),
-            O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
+            O.flatMapNullable((fn) => indirectSetStateCalls.get(fn)),
             O.map(Chunk.toReadonlyArray),
             O.getOrElse(() => [])
           );
+        };
+        for (const { callee } of Chunk.toReadonlyArray(MutRef.get(indirectFunctionCalls))) {
+          if (!("name" in callee)) continue;
+          const { name: name2 } = callee;
+          const setStateCalls = getSetStateCalls(name2, context.sourceCode.getScope(callee));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              data: { name: name2 },
+              messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
+              node: setStateCall
+            });
+          }
+        }
+        for (const id of Chunk.toReadonlyArray(MutRef.get(effectFunctionIdentifiers))) {
+          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({
-              data: {
-                name: name2
-              },
+              data: { name: id.name },
               messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
               node: setStateCall
             });
@@ -709,7 +731,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
   },
   name: RULE_NAME6,
   create(context) {
-    const alias = getESLintReactSettings(context.settings).additionalHooks?.useState ?? [];
+    const alias = parseESLintSettings(context.settings)["react-x"]?.additionalHooks?.useState ?? [];
     return {
       CallExpression(node) {
         if (!isReactHookCall(node)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.5.28",
+  "version": "1.5.29-beta.0",
   "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/jsx": "1.5.28",
-    "@eslint-react/core": "1.5.28",
-    "@eslint-react/shared": "1.5.28",
-    "@eslint-react/types": "1.5.28",
-    "@eslint-react/ast": "1.5.28",
-    "@eslint-react/var": "1.5.28",
-    "@eslint-react/tools": "1.5.28"
+    "@eslint-react/ast": "1.5.29-beta.0",
+    "@eslint-react/core": "1.5.29-beta.0",
+    "@eslint-react/shared": "1.5.29-beta.0",
+    "@eslint-react/tools": "1.5.29-beta.0",
+    "@eslint-react/types": "1.5.29-beta.0",
+    "@eslint-react/var": "1.5.29-beta.0",
+    "@eslint-react/jsx": "1.5.29-beta.0"
   },
   "devDependencies": {
     "string-ts": "2.2.0",
-    "tsup": "8.2.0"
+    "tsup": "8.2.1"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",