eslint-plugin-react-hooks-extra 1.5.28-beta.7 → 1.5.28-next.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.7";
+var version = "1.5.28-next.2";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -467,26 +467,29 @@ var no_direct_set_state_in_use_effect_default = createRule({
       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 = tools.MutRef.make(tools.Chunk.empty());
+    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 {
-      ":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(tools.F.constVoid);
-      },
-      ":function:exit"(node) {
-        tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
-        tools.MutList.pop(functionStack);
+      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) {
+        tools.MutList.append(callStack, node);
         const effectFn = tools.MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = tools.MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
@@ -494,29 +497,47 @@ var no_direct_set_state_in_use_effect_default = createRule({
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
-            const calls = indirectSetStateCalls.get(parentFn) ?? tools.Chunk.empty();
-            indirectSetStateCalls.set(parentFn, tools.Chunk.append(calls, node));
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
             return;
           }
           context.report({
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
-            node
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT"
           });
         }).with("useEffect", () => {
-          tools.MutRef.set(useEffectCallRef, node);
+          onUseEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
-          tools.MutRef.update(indirectFunctionCalls, tools.Chunk.append(node));
-        }).otherwise(tools.F.constVoid);
+          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 tools.Chunk.toReadonlyArray(tools.MutRef.get(indirectFunctionCalls))) {
+        for (const call of indirectFunctionCalls) {
           if (!("name" in call.callee)) continue;
           const { name: name2 } = call.callee;
           const setStateCalls = tools.F.pipe(
@@ -524,7 +545,6 @@ var no_direct_set_state_in_use_effect_default = createRule({
             tools.O.flatMap(_var.getVariableInit(0)),
             tools.O.filter(ast.isFunction),
             tools.O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
-            tools.O.map(tools.Chunk.toReadonlyArray),
             tools.O.getOrElse(() => [])
           );
           for (const setStateCall of setStateCalls) {
@@ -621,26 +641,29 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
       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 = tools.MutRef.make(tools.Chunk.empty());
+    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 {
-      ":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(tools.F.constVoid);
-      },
-      ":function:exit"(node) {
-        tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
-        tools.MutList.pop(functionStack);
+      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) {
+        tools.MutList.append(callStack, node);
         const effectFn = tools.MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = tools.MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
@@ -648,29 +671,47 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
-            const calls = indirectSetStateCalls.get(parentFn) ?? tools.Chunk.empty();
-            indirectSetStateCalls.set(parentFn, tools.Chunk.append(calls, node));
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
             return;
           }
           context.report({
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
-            node
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT"
           });
         }).with("useLayoutEffect", () => {
-          tools.MutRef.set(useLayoutEffectCallRef, node);
+          onUseLayoutEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
-          tools.MutRef.update(indirectFunctionCalls, tools.Chunk.append(node));
-        }).otherwise(tools.F.constVoid);
+          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 tools.Chunk.toReadonlyArray(tools.MutRef.get(indirectFunctionCalls))) {
+        for (const call of indirectFunctionCalls) {
           if (!("name" in call.callee)) continue;
           const { name: name2 } = call.callee;
           const setStateCalls = tools.F.pipe(
@@ -678,7 +719,6 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             tools.O.flatMap(_var.getVariableInit(0)),
             tools.O.filter(ast.isFunction),
             tools.O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
-            tools.O.map(tools.Chunk.toReadonlyArray),
             tools.O.getOrElse(() => [])
           );
           for (const setStateCall of setStateCalls) {

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 { 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.7";
+var version = "1.5.28-next.2";
 var createRule = createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -465,26 +465,29 @@ var no_direct_set_state_in_use_effect_default = createRule({
       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 = MutRef.make(Chunk.empty());
+    const indirectFunctionCalls = [];
     const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const onUseEffectCallEnter = (node) => void MutRef.set(useEffectCallRef, node);
+    const onUseEffectCallExit = () => void MutRef.set(useEffectCallRef, null);
     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);
-        }).otherwise(F.constVoid);
-      },
-      ":function:exit"(node) {
-        MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
-        MutList.pop(functionStack);
+      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) {
+        MutList.append(callStack, node);
         const effectFn = MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
@@ -492,29 +495,47 @@ var no_direct_set_state_in_use_effect_default = createRule({
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
-            const calls = indirectSetStateCalls.get(parentFn) ?? Chunk.empty();
-            indirectSetStateCalls.set(parentFn, Chunk.append(calls, node));
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
             return;
           }
           context.report({
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
-            node
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT"
           });
         }).with("useEffect", () => {
-          MutRef.set(useEffectCallRef, node);
+          onUseEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
-          MutRef.update(indirectFunctionCalls, Chunk.append(node));
-        }).otherwise(F.constVoid);
+          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 Chunk.toReadonlyArray(MutRef.get(indirectFunctionCalls))) {
+        for (const call of indirectFunctionCalls) {
           if (!("name" in call.callee)) continue;
           const { name: name2 } = call.callee;
           const setStateCalls = F.pipe(
@@ -522,7 +543,6 @@ var no_direct_set_state_in_use_effect_default = createRule({
             O.flatMap(getVariableInit(0)),
             O.filter(isFunction),
             O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
-            O.map(Chunk.toReadonlyArray),
             O.getOrElse(() => [])
           );
           for (const setStateCall of setStateCalls) {
@@ -619,26 +639,29 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
       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 = MutRef.make(Chunk.empty());
+    const indirectFunctionCalls = [];
     const indirectSetStateCalls = /* @__PURE__ */ new Map();
+    const onUseLayoutEffectCallEnter = (node) => void MutRef.set(useLayoutEffectCallRef, node);
+    const onUseLayoutEffectCallExit = () => void MutRef.set(useLayoutEffectCallRef, null);
     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);
-        }).otherwise(F.constVoid);
-      },
-      ":function:exit"(node) {
-        MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
-        MutList.pop(functionStack);
+      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) {
+        MutList.append(callStack, node);
         const effectFn = MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
@@ -646,29 +669,47 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
-            const calls = indirectSetStateCalls.get(parentFn) ?? Chunk.empty();
-            indirectSetStateCalls.set(parentFn, Chunk.append(calls, node));
+            indirectSetStateCalls.set(parentFn, [...indirectSetStateCalls.get(parentFn) ?? [], node]);
             return;
           }
           context.report({
-            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
-            node
+            node,
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT"
           });
         }).with("useLayoutEffect", () => {
-          MutRef.set(useLayoutEffectCallRef, node);
+          onUseLayoutEffectCallEnter(node);
+        }).with("useState", () => {
+        }).with("then", () => {
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
-          MutRef.update(indirectFunctionCalls, Chunk.append(node));
-        }).otherwise(F.constVoid);
+          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 Chunk.toReadonlyArray(MutRef.get(indirectFunctionCalls))) {
+        for (const call of indirectFunctionCalls) {
           if (!("name" in call.callee)) continue;
           const { name: name2 } = call.callee;
           const setStateCalls = F.pipe(
@@ -676,7 +717,6 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             O.flatMap(getVariableInit(0)),
             O.filter(isFunction),
             O.flatMapNullable((init) => indirectSetStateCalls.get(init)),
-            O.map(Chunk.toReadonlyArray),
             O.getOrElse(() => [])
           );
           for (const setStateCall of setStateCalls) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.5.28-beta.7",
+  "version": "1.5.28-next.2",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "homepage": "https://github.com/rel1cx/eslint-react",
   "bugs": {
@@ -39,13 +39,13 @@
     "@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.7",
-    "@eslint-react/core": "1.5.28-beta.7",
-    "@eslint-react/jsx": "1.5.28-beta.7",
-    "@eslint-react/shared": "1.5.28-beta.7",
-    "@eslint-react/tools": "1.5.28-beta.7",
-    "@eslint-react/types": "1.5.28-beta.7",
-    "@eslint-react/var": "1.5.28-beta.7"
+    "@eslint-react/ast": "1.5.28-next.2",
+    "@eslint-react/core": "1.5.28-next.2",
+    "@eslint-react/shared": "1.5.28-next.2",
+    "@eslint-react/types": "1.5.28-next.2",
+    "@eslint-react/var": "1.5.28-next.2",
+    "@eslint-react/jsx": "1.5.28-next.2",
+    "@eslint-react/tools": "1.5.28-next.2"
   },
   "devDependencies": {
     "string-ts": "2.2.0",