eslint-plugin-react-hooks-extra 1.23.3-next.8 → 1.24.0-beta.0

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var AST2 = require('@eslint-react/ast');
+var AST = require('@eslint-react/ast');
 var core = require('@eslint-react/core');
 var eff = require('@eslint-react/eff');
 var shared = require('@eslint-react/shared');
@@ -26,22 +26,23 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var AST2__namespace = /*#__PURE__*/_interopNamespace(AST2);
+var AST__namespace = /*#__PURE__*/_interopNamespace(AST);
 var VAR5__namespace = /*#__PURE__*/_interopNamespace(VAR5);
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.23.3-next.8";
+var version = "1.24.0-beta.0";
 var createRule = shared.createRuleForPlugin("hooks-extra");
-function isFromHookCall(name2, context, settings, predicate = eff.F.constTrue) {
+function isFromHookCall(name2, context, settings, predicate = eff.returnTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
-  return (topLevelId) => eff.F.pipe(
-    VAR5__namespace.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-    eff.O.flatMap(VAR5__namespace.getVariableNode(0)),
-    eff.O.filter(AST2__namespace.is(types.AST_NODE_TYPES.CallExpression)),
-    eff.O.filter(core.isReactHookCallWithNameAlias(name2, context, hookAlias)),
-    eff.O.exists((call) => predicate(topLevelId, call))
-  );
+  return (topLevelId) => {
+    const variable = VAR5__namespace.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+    const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+    if (variableNode == null) return false;
+    if (variableNode.type !== types.AST_NODE_TYPES.CallExpression) return false;
+    if (!core.isReactHookCallWithNameAlias(name2, context, hookAlias)(variableNode)) return false;
+    return predicate(topLevelId, variableNode);
+  };
 }
 function isFromUseStateCall(context, settings) {
   const predicate = (topLevelId, call) => {
@@ -72,8 +73,13 @@ function isSetFunctionCall(context, settings) {
         if (!isAt || index == null) {
           return false;
         }
-        const initialScope = context.sourceCode.getScope(node);
-        return eff.O.exists(VAR5__namespace.getStaticValue(index, initialScope), (v) => v === 1) && isIdFromUseStateCall(callee.object);
+        const indexScope = context.sourceCode.getScope(node);
+        const indexValue = VAR5__namespace.toResolved({
+          kind: "lazy",
+          node: index,
+          initialScope: indexScope
+        }).value;
+        return indexValue === 1 && isIdFromUseStateCall(callee.object);
       }
       // const [data, setData] = useState();
       // setData();
@@ -86,8 +92,14 @@ function isSetFunctionCall(context, settings) {
         if (!("name" in node.callee.object)) {
           return false;
         }
-        const initialScope = context.sourceCode.getScope(node);
-        return eff.O.exists(VAR5__namespace.getStaticValue(node.callee.property, initialScope), (v) => v === 1) && isIdFromUseStateCall(node.callee.object);
+        const property = node.callee.property;
+        const propertyScope = context.sourceCode.getScope(node);
+        const propertyValue = VAR5__namespace.toResolved({
+          kind: "lazy",
+          node: property,
+          initialScope: propertyScope
+        }).value;
+        return propertyValue === 1 && isIdFromUseStateCall(node.callee.object);
       }
       default: {
         return false;
@@ -148,8 +160,8 @@ var no_direct_set_state_in_use_effect_default = createRule({
     const isUseCallbackCall2 = core.isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-    const functionStack = [];
-    const setupFunctionRef = { current: eff.O.none() };
+    const functionEntries = [];
+    const setupFunctionRef = { current: null };
     const setupFunctionIdentifiers = [];
     const indFunctionCalls = [];
     const indSetStateCalls = /* @__PURE__ */ new WeakMap();
@@ -157,10 +169,12 @@ var no_direct_set_state_in_use_effect_default = createRule({
     const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
     const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
     const onSetupFunctionEnter = (node) => {
-      setupFunctionRef.current = eff.O.some(node);
+      setupFunctionRef.current = node;
     };
     const onSetupFunctionExit = (node) => {
-      setupFunctionRef.current = eff.O.filter(setupFunctionRef.current, (current) => current !== node);
+      if (setupFunctionRef.current === node) {
+        setupFunctionRef.current = null;
+      }
     };
     function isSetupFunction(node) {
       return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
@@ -169,26 +183,26 @@ var no_direct_set_state_in_use_effect_default = createRule({
       return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(AST2__namespace.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(AST__namespace.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const kind = getFunctionKind(node);
-        functionStack.push({ kind, node });
+        functionEntries.push({ kind, node });
         if (kind === "setup") {
           onSetupFunctionEnter(node);
         }
       },
       ":function:exit"(node) {
-        const { kind } = functionStack.at(-1) ?? {};
+        const { kind } = functionEntries.at(-1) ?? {};
         if (kind === "setup") {
           onSetupFunctionExit(node);
         }
-        functionStack.pop();
+        functionEntries.pop();
       },
       CallExpression(node) {
-        const setupFunction = eff.O.getOrNull(setupFunctionRef.current);
-        const pEntry = functionStack.at(-1);
+        const setupFunction = setupFunctionRef.current;
+        const pEntry = functionEntries.at(-1);
         if (pEntry?.node.async) {
           return;
         }
@@ -208,28 +222,28 @@ var no_direct_set_state_in_use_effect_default = createRule({
               return;
             }
             default: {
-              const mbVariableDeclarator = AST2__namespace.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
-              if (eff.O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST__namespace.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator === eff._) {
                 const calls = indSetStateCalls.get(pEntry.node) ?? [];
                 indSetStateCalls.set(pEntry.node, [...calls, node]);
                 return;
               }
-              const vd = mbVariableDeclarator.value;
-              const prevs = indSetStateCallsInUseMemoOrCallback.get(vd.init) ?? [];
-              indSetStateCallsInUseMemoOrCallback.set(vd.init, [...prevs, node]);
+              const init = variableDeclarator.init;
+              const prevs = indSetStateCallsInUseMemoOrCallback.get(init) ?? [];
+              indSetStateCallsInUseMemoOrCallback.set(init, [...prevs, node]);
             }
           }
         }).with("useEffect", () => {
-          if (AST2__namespace.isFunction(node.arguments.at(0))) {
+          if (AST__namespace.isFunction(node.arguments.at(0))) {
             return;
           }
-          setupFunctionIdentifiers.push(...AST2__namespace.getNestedIdentifiers(node));
+          setupFunctionIdentifiers.push(...AST__namespace.getNestedIdentifiers(node));
         }).with("other", () => {
           if (pEntry?.node !== setupFunction) {
             return;
           }
           indFunctionCalls.push(node);
-        }).otherwise(eff.F.constVoid);
+        }).otherwise(() => eff._);
       },
       Identifier(node) {
         if (node.parent.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
@@ -247,11 +261,10 @@ var no_direct_set_state_in_use_effect_default = createRule({
             if (!isUseMemoCall2(parent)) {
               break;
             }
-            const mbVariableDeclarator = AST2__namespace.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
-            if (eff.O.isNone(mbVariableDeclarator)) {
+            const variableDeclarator = AST__namespace.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
+            if (variableDeclarator == null) {
               break;
             }
-            const variableDeclarator = mbVariableDeclarator.value;
             const calls = indSetStateCallsInUseEffectArg0.get(variableDeclarator.init) ?? [];
             indSetStateCallsInUseEffectArg0.set(variableDeclarator.init, [...calls, node]);
             break;
@@ -261,11 +274,10 @@ var no_direct_set_state_in_use_effect_default = createRule({
               break;
             }
             if (isUseCallbackCall2(node.parent)) {
-              const mbVariableDeclarator = AST2__namespace.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
-              if (eff.O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST__namespace.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator == null) {
                 break;
               }
-              const variableDeclarator = mbVariableDeclarator.value;
               const prevs = indSetStateCallsInUseEffectArg0.get(variableDeclarator.init) ?? [];
               indSetStateCallsInUseEffectArg0.set(variableDeclarator.init, [...prevs, node]);
             }
@@ -279,7 +291,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
       },
       "Program:exit"() {
         const getSetStateCalls = (id, initialScope) => {
-          const node = eff.O.flatMap(VAR5__namespace.findVariable(id, initialScope), VAR5__namespace.getVariableNode(0)).pipe(eff.O.getOrNull);
+          const node = VAR5__namespace.getVariableNode(VAR5__namespace.findVariable(id, initialScope), 0);
           switch (node?.type) {
             case types.AST_NODE_TYPES.ArrowFunctionExpression:
             case types.AST_NODE_TYPES.FunctionDeclaration:
@@ -290,7 +302,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
           }
           return [];
         };
-        for (const [_, calls] of indSetStateCallsInUseEffectSetup) {
+        for (const [, calls] of indSetStateCallsInUseEffectSetup) {
           for (const call of calls) {
             context.report({
               messageId: "noDirectSetStateInUseEffect",
@@ -310,7 +322,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
               messageId: "noDirectSetStateInUseEffect",
               node: setStateCall,
               data: {
-                name: AST2__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -322,7 +334,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
               messageId: "noDirectSetStateInUseEffect",
               node: setStateCall,
               data: {
-                name: AST2__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -365,8 +377,8 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     const isUseCallbackCall2 = core.isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-    const functionStack = [];
-    const setupFunctionRef = { current: eff.O.none() };
+    const functionEntries = [];
+    const setupFunctionRef = { current: null };
     const setupFunctionIdentifiers = [];
     const indFunctionCalls = [];
     const indSetStateCalls = /* @__PURE__ */ new WeakMap();
@@ -374,10 +386,12 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     const indSetStateCallsInUseLayoutEffectSetup = /* @__PURE__ */ new Map();
     const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
     const onSetupFunctionEnter = (node) => {
-      setupFunctionRef.current = eff.O.some(node);
+      setupFunctionRef.current = node;
     };
     const onSetupFunctionExit = (node) => {
-      setupFunctionRef.current = eff.O.filter(setupFunctionRef.current, (current) => current !== node);
+      if (setupFunctionRef.current === node) {
+        setupFunctionRef.current = null;
+      }
     };
     function isSetupFunction(node) {
       return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseLayoutEffectLikeCall(node.parent);
@@ -386,26 +400,26 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
       return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseLayoutEffectLikeCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(AST2__namespace.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(AST__namespace.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const kind = getFunctionKind(node);
-        functionStack.push({ kind, node });
+        functionEntries.push({ kind, node });
         if (kind === "setup") {
           onSetupFunctionEnter(node);
         }
       },
       ":function:exit"(node) {
-        const { kind } = functionStack.at(-1) ?? {};
+        const { kind } = functionEntries.at(-1) ?? {};
         if (kind === "setup") {
           onSetupFunctionExit(node);
         }
-        functionStack.pop();
+        functionEntries.pop();
       },
       CallExpression(node) {
-        const setupFunction = eff.O.getOrNull(setupFunctionRef.current);
-        const pEntry = functionStack.at(-1);
+        const setupFunction = setupFunctionRef.current;
+        const pEntry = functionEntries.at(-1);
         if (pEntry?.node.async) {
           return;
         }
@@ -425,28 +439,28 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               return;
             }
             default: {
-              const mbVariableDeclarator = AST2__namespace.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
-              if (eff.O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST__namespace.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator === eff._) {
                 const calls = indSetStateCalls.get(pEntry.node) ?? [];
                 indSetStateCalls.set(pEntry.node, [...calls, node]);
                 return;
               }
-              const vd = mbVariableDeclarator.value;
-              const prevs = indSetStateCallsInUseMemoOrCallback.get(vd.init) ?? [];
-              indSetStateCallsInUseMemoOrCallback.set(vd.init, [...prevs, node]);
+              const init = variableDeclarator.init;
+              const prevs = indSetStateCallsInUseMemoOrCallback.get(init) ?? [];
+              indSetStateCallsInUseMemoOrCallback.set(init, [...prevs, node]);
             }
           }
         }).with("useLayoutEffect", () => {
-          if (AST2__namespace.isFunction(node.arguments.at(0))) {
+          if (AST__namespace.isFunction(node.arguments.at(0))) {
             return;
           }
-          setupFunctionIdentifiers.push(...AST2__namespace.getNestedIdentifiers(node));
+          setupFunctionIdentifiers.push(...AST__namespace.getNestedIdentifiers(node));
         }).with("other", () => {
           if (pEntry?.node !== setupFunction) {
             return;
           }
           indFunctionCalls.push(node);
-        }).otherwise(eff.F.constVoid);
+        }).otherwise(() => eff._);
       },
       Identifier(node) {
         if (node.parent.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
@@ -464,11 +478,10 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             if (!isUseMemoCall2(parent)) {
               break;
             }
-            const mbVariableDeclarator = AST2__namespace.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
-            if (eff.O.isNone(mbVariableDeclarator)) {
+            const variableDeclarator = AST__namespace.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
+            if (variableDeclarator == null) {
               break;
             }
-            const variableDeclarator = mbVariableDeclarator.value;
             const calls = indSetStateCallsInUseLayoutEffectArg0.get(variableDeclarator.init) ?? [];
             indSetStateCallsInUseLayoutEffectArg0.set(variableDeclarator.init, [...calls, node]);
             break;
@@ -478,11 +491,10 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               break;
             }
             if (isUseCallbackCall2(node.parent)) {
-              const mbVariableDeclarator = AST2__namespace.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
-              if (eff.O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST__namespace.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator == null) {
                 break;
               }
-              const variableDeclarator = mbVariableDeclarator.value;
               const prevs = indSetStateCallsInUseLayoutEffectArg0.get(variableDeclarator.init) ?? [];
               indSetStateCallsInUseLayoutEffectArg0.set(variableDeclarator.init, [...prevs, node]);
             }
@@ -496,7 +508,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
       },
       "Program:exit"() {
         const getSetStateCalls = (id, initialScope) => {
-          const node = eff.O.flatMap(VAR5__namespace.findVariable(id, initialScope), VAR5__namespace.getVariableNode(0)).pipe(eff.O.getOrNull);
+          const node = VAR5__namespace.getVariableNode(VAR5__namespace.findVariable(id, initialScope), 0);
           switch (node?.type) {
             case types.AST_NODE_TYPES.ArrowFunctionExpression:
             case types.AST_NODE_TYPES.FunctionDeclaration:
@@ -507,7 +519,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
           }
           return [];
         };
-        for (const [_, calls] of indSetStateCallsInUseLayoutEffectSetup) {
+        for (const [, calls] of indSetStateCallsInUseLayoutEffectSetup) {
           for (const call of calls) {
             context.report({
               messageId: "noDirectSetStateInUseLayoutEffect",
@@ -527,7 +539,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               messageId: "noDirectSetStateInUseLayoutEffect",
               node: setStateCall,
               data: {
-                name: AST2__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -539,7 +551,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               messageId: "noDirectSetStateInUseLayoutEffect",
               node: setStateCall,
               data: {
-                name: AST2__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -582,43 +594,41 @@ var no_unnecessary_use_callback_default = createRule({
         }
         const scope = context.sourceCode.getScope(node);
         const component = scope.block;
-        if (!AST2__namespace.isFunction(component)) {
+        if (!AST__namespace.isFunction(component)) {
           return;
         }
         const [arg0, arg1] = node.arguments;
         if (arg0 == null || arg1 == null) {
           return;
         }
-        const hasEmptyDeps = eff.F.pipe(
-          tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, eff.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return eff.F.pipe(
-              VAR5__namespace.findVariable(n.name, initialScope),
-              eff.O.flatMap(VAR5__namespace.getVariableNode(0)),
-              eff.O.filter(AST2__namespace.is(types.AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(eff.O.none),
-          eff.O.exists((x) => x.elements.length === 0)
-        );
+        const hasEmptyDeps = tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
+            return false;
+          }
+          return variableNode.elements.length === 0;
+        }).otherwise(() => false);
         if (!hasEmptyDeps) {
           return;
         }
-        const isReferencedToComponentScope = eff.F.pipe(
-          tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-            if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
-              return eff.O.some(n.body);
-            }
-            return eff.O.some(n);
-          }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return eff.F.pipe(
-              VAR5__namespace.findVariable(n.name, initialScope),
-              eff.O.flatMap(VAR5__namespace.getVariableNode(0)),
-              eff.O.filter(AST2__namespace.isFunction)
-            );
-          }).otherwise(eff.O.none),
-          eff.O.map((n) => context.sourceCode.getScope(n)),
-          eff.O.map((s) => VAR5__namespace.getChidScopes(s).flatMap((x) => x.references)),
-          eff.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
+        const arg0Node = tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+          if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
+            return n.body;
+          }
+          return n;
+        }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.identity).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          if (variableNode?.type !== types.AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== types.AST_NODE_TYPES.FunctionExpression) {
+            return eff._;
+          }
+          return variableNode;
+        }).otherwise(() => eff._);
+        if (arg0Node === eff._) return;
+        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+        const arg0NodeReferences = VAR5__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({
             messageId: "noUnnecessaryUseCallback",
@@ -663,51 +673,45 @@ var no_unnecessary_use_memo_default = createRule({
         }
         const scope = context.sourceCode.getScope(node);
         const component = scope.block;
-        if (!AST2__namespace.isFunction(component)) {
+        if (!AST__namespace.isFunction(component)) {
           return;
         }
         const [arg0, arg1] = node.arguments;
         if (arg0 == null || arg1 == null) {
           return;
         }
-        const hasCallInArg0 = eff.F.pipe(
-          eff.O.some(arg0),
-          eff.O.filter((n) => AST2__namespace.isFunction(n)),
-          eff.O.exists((n) => [...AST2__namespace.getNestedCallExpressions(n.body), ...AST2__namespace.getNestedNewExpressions(n.body)].length > 0)
-        );
+        const hasCallInArg0 = AST__namespace.isFunction(arg0) && [...AST__namespace.getNestedCallExpressions(arg0.body), ...AST__namespace.getNestedNewExpressions(arg0.body)].length > 0;
         if (hasCallInArg0) {
           return;
         }
-        const hasEmptyDeps = eff.F.pipe(
-          tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, eff.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return eff.F.pipe(
-              VAR5__namespace.findVariable(n.name, initialScope),
-              eff.O.flatMap(VAR5__namespace.getVariableNode(0)),
-              eff.O.filter(AST2__namespace.is(types.AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(eff.O.none),
-          eff.O.exists((x) => x.elements.length === 0)
-        );
+        const hasEmptyDeps = tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
+            return false;
+          }
+          return variableNode.elements.length === 0;
+        }).otherwise(() => false);
         if (!hasEmptyDeps) {
           return;
         }
-        const isReferencedToComponentScope = eff.F.pipe(
-          tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-            if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
-              return eff.O.some(n.body);
-            }
-            return eff.O.some(n);
-          }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return eff.F.pipe(
-              VAR5__namespace.findVariable(n.name, initialScope),
-              eff.O.flatMap(VAR5__namespace.getVariableNode(0)),
-              eff.O.filter(AST2__namespace.isFunction)
-            );
-          }).otherwise(eff.O.none),
-          eff.O.map((n) => context.sourceCode.getScope(n)),
-          eff.O.map((s) => VAR5__namespace.getChidScopes(s).flatMap((x) => x.references)),
-          eff.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
+        const arg0Node = tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+          if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
+            return n.body;
+          }
+          return n;
+        }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.identity).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5__namespace.findVariable(n.name, initialScope);
+          const variableNode = VAR5__namespace.getVariableNode(variable, 0);
+          if (variableNode?.type !== types.AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== types.AST_NODE_TYPES.FunctionExpression) {
+            return eff._;
+          }
+          return variableNode;
+        }).otherwise(() => eff._);
+        if (arg0Node === eff._) return;
+        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+        const arg0NodeReferences = VAR5__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({
             messageId: "noUnnecessaryUseMemo",
@@ -746,7 +750,7 @@ var no_useless_custom_hooks_default = createRule({
       "Program:exit"(node) {
         const allHooks = ctx.getAllHooks(node);
         for (const { name: name2, node: node2, hookCalls } of allHooks.values()) {
-          if (AST2__namespace.isEmptyFunction(node2)) {
+          if (AST__namespace.isEmptyFunction(node2)) {
             continue;
           }
           if (hookCalls.length > 0) {
@@ -759,7 +763,7 @@ var no_useless_custom_hooks_default = createRule({
             messageId: "noUselessCustomHooks",
             node: node2,
             data: {
-              name: name2.value
+              name: name2
             }
           });
         }
@@ -803,11 +807,11 @@ var prefer_use_state_lazy_initialization_default = createRule({
         if (useStateInput == null) {
           return;
         }
-        const nestedCallExpressions = AST2__namespace.getNestedCallExpressions(useStateInput);
+        const nestedCallExpressions = AST__namespace.getNestedCallExpressions(useStateInput);
         const hasFunctionCall = nestedCallExpressions.some((n) => {
           return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
         });
-        const hasNewCall = AST2__namespace.getNestedNewExpressions(useStateInput).some((n) => {
+        const hasNewCall = AST__namespace.getNestedNewExpressions(useStateInput).some((n) => {
           return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
         });
         if (!hasFunctionCall && !hasNewCall) {

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import * as AST2 from '@eslint-react/ast';
+import * as AST from '@eslint-react/ast';
 import { isReactHookCallWithNameAlias, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, useHookCollector, isUseStateCall, isReactHookName } from '@eslint-react/core';
-import { O, F } from '@eslint-react/eff';
+import { _, identity, returnTrue } from '@eslint-react/eff';
 import { createRuleForPlugin, getSettingsFromContext } from '@eslint-react/shared';
 import * as VAR5 from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
@@ -8,17 +8,18 @@ import { match } from 'ts-pattern';
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.23.3-next.8";
+var version = "1.24.0-beta.0";
 var createRule = createRuleForPlugin("hooks-extra");
-function isFromHookCall(name2, context, settings, predicate = F.constTrue) {
+function isFromHookCall(name2, context, settings, predicate = returnTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
-  return (topLevelId) => F.pipe(
-    VAR5.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-    O.flatMap(VAR5.getVariableNode(0)),
-    O.filter(AST2.is(AST_NODE_TYPES.CallExpression)),
-    O.filter(isReactHookCallWithNameAlias(name2, context, hookAlias)),
-    O.exists((call) => predicate(topLevelId, call))
-  );
+  return (topLevelId) => {
+    const variable = VAR5.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+    const variableNode = VAR5.getVariableNode(variable, 0);
+    if (variableNode == null) return false;
+    if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
+    if (!isReactHookCallWithNameAlias(name2, context, hookAlias)(variableNode)) return false;
+    return predicate(topLevelId, variableNode);
+  };
 }
 function isFromUseStateCall(context, settings) {
   const predicate = (topLevelId, call) => {
@@ -49,8 +50,13 @@ function isSetFunctionCall(context, settings) {
         if (!isAt || index == null) {
           return false;
         }
-        const initialScope = context.sourceCode.getScope(node);
-        return O.exists(VAR5.getStaticValue(index, initialScope), (v) => v === 1) && isIdFromUseStateCall(callee.object);
+        const indexScope = context.sourceCode.getScope(node);
+        const indexValue = VAR5.toResolved({
+          kind: "lazy",
+          node: index,
+          initialScope: indexScope
+        }).value;
+        return indexValue === 1 && isIdFromUseStateCall(callee.object);
       }
       // const [data, setData] = useState();
       // setData();
@@ -63,8 +69,14 @@ function isSetFunctionCall(context, settings) {
         if (!("name" in node.callee.object)) {
           return false;
         }
-        const initialScope = context.sourceCode.getScope(node);
-        return O.exists(VAR5.getStaticValue(node.callee.property, initialScope), (v) => v === 1) && isIdFromUseStateCall(node.callee.object);
+        const property = node.callee.property;
+        const propertyScope = context.sourceCode.getScope(node);
+        const propertyValue = VAR5.toResolved({
+          kind: "lazy",
+          node: property,
+          initialScope: propertyScope
+        }).value;
+        return propertyValue === 1 && isIdFromUseStateCall(node.callee.object);
       }
       default: {
         return false;
@@ -125,8 +137,8 @@ var no_direct_set_state_in_use_effect_default = createRule({
     const isUseCallbackCall2 = isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-    const functionStack = [];
-    const setupFunctionRef = { current: O.none() };
+    const functionEntries = [];
+    const setupFunctionRef = { current: null };
     const setupFunctionIdentifiers = [];
     const indFunctionCalls = [];
     const indSetStateCalls = /* @__PURE__ */ new WeakMap();
@@ -134,10 +146,12 @@ var no_direct_set_state_in_use_effect_default = createRule({
     const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
     const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
     const onSetupFunctionEnter = (node) => {
-      setupFunctionRef.current = O.some(node);
+      setupFunctionRef.current = node;
     };
     const onSetupFunctionExit = (node) => {
-      setupFunctionRef.current = O.filter(setupFunctionRef.current, (current) => current !== node);
+      if (setupFunctionRef.current === node) {
+        setupFunctionRef.current = null;
+      }
     };
     function isSetupFunction(node) {
       return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
@@ -146,26 +160,26 @@ var no_direct_set_state_in_use_effect_default = createRule({
       return match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return match(node).when(isSetupFunction, () => "setup").when(AST2.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return match(node).when(isSetupFunction, () => "setup").when(AST.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const kind = getFunctionKind(node);
-        functionStack.push({ kind, node });
+        functionEntries.push({ kind, node });
         if (kind === "setup") {
           onSetupFunctionEnter(node);
         }
       },
       ":function:exit"(node) {
-        const { kind } = functionStack.at(-1) ?? {};
+        const { kind } = functionEntries.at(-1) ?? {};
         if (kind === "setup") {
           onSetupFunctionExit(node);
         }
-        functionStack.pop();
+        functionEntries.pop();
       },
       CallExpression(node) {
-        const setupFunction = O.getOrNull(setupFunctionRef.current);
-        const pEntry = functionStack.at(-1);
+        const setupFunction = setupFunctionRef.current;
+        const pEntry = functionEntries.at(-1);
         if (pEntry?.node.async) {
           return;
         }
@@ -185,28 +199,28 @@ var no_direct_set_state_in_use_effect_default = createRule({
               return;
             }
             default: {
-              const mbVariableDeclarator = AST2.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
-              if (O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator === _) {
                 const calls = indSetStateCalls.get(pEntry.node) ?? [];
                 indSetStateCalls.set(pEntry.node, [...calls, node]);
                 return;
               }
-              const vd = mbVariableDeclarator.value;
-              const prevs = indSetStateCallsInUseMemoOrCallback.get(vd.init) ?? [];
-              indSetStateCallsInUseMemoOrCallback.set(vd.init, [...prevs, node]);
+              const init = variableDeclarator.init;
+              const prevs = indSetStateCallsInUseMemoOrCallback.get(init) ?? [];
+              indSetStateCallsInUseMemoOrCallback.set(init, [...prevs, node]);
             }
           }
         }).with("useEffect", () => {
-          if (AST2.isFunction(node.arguments.at(0))) {
+          if (AST.isFunction(node.arguments.at(0))) {
             return;
           }
-          setupFunctionIdentifiers.push(...AST2.getNestedIdentifiers(node));
+          setupFunctionIdentifiers.push(...AST.getNestedIdentifiers(node));
         }).with("other", () => {
           if (pEntry?.node !== setupFunction) {
             return;
           }
           indFunctionCalls.push(node);
-        }).otherwise(F.constVoid);
+        }).otherwise(() => _);
       },
       Identifier(node) {
         if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
@@ -224,11 +238,10 @@ var no_direct_set_state_in_use_effect_default = createRule({
             if (!isUseMemoCall2(parent)) {
               break;
             }
-            const mbVariableDeclarator = AST2.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
-            if (O.isNone(mbVariableDeclarator)) {
+            const variableDeclarator = AST.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
+            if (variableDeclarator == null) {
               break;
             }
-            const variableDeclarator = mbVariableDeclarator.value;
             const calls = indSetStateCallsInUseEffectArg0.get(variableDeclarator.init) ?? [];
             indSetStateCallsInUseEffectArg0.set(variableDeclarator.init, [...calls, node]);
             break;
@@ -238,11 +251,10 @@ var no_direct_set_state_in_use_effect_default = createRule({
               break;
             }
             if (isUseCallbackCall2(node.parent)) {
-              const mbVariableDeclarator = AST2.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
-              if (O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator == null) {
                 break;
               }
-              const variableDeclarator = mbVariableDeclarator.value;
               const prevs = indSetStateCallsInUseEffectArg0.get(variableDeclarator.init) ?? [];
               indSetStateCallsInUseEffectArg0.set(variableDeclarator.init, [...prevs, node]);
             }
@@ -256,7 +268,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
       },
       "Program:exit"() {
         const getSetStateCalls = (id, initialScope) => {
-          const node = O.flatMap(VAR5.findVariable(id, initialScope), VAR5.getVariableNode(0)).pipe(O.getOrNull);
+          const node = VAR5.getVariableNode(VAR5.findVariable(id, initialScope), 0);
           switch (node?.type) {
             case AST_NODE_TYPES.ArrowFunctionExpression:
             case AST_NODE_TYPES.FunctionDeclaration:
@@ -267,7 +279,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
           }
           return [];
         };
-        for (const [_, calls] of indSetStateCallsInUseEffectSetup) {
+        for (const [, calls] of indSetStateCallsInUseEffectSetup) {
           for (const call of calls) {
             context.report({
               messageId: "noDirectSetStateInUseEffect",
@@ -287,7 +299,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
               messageId: "noDirectSetStateInUseEffect",
               node: setStateCall,
               data: {
-                name: AST2.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -299,7 +311,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
               messageId: "noDirectSetStateInUseEffect",
               node: setStateCall,
               data: {
-                name: AST2.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -342,8 +354,8 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     const isUseCallbackCall2 = isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-    const functionStack = [];
-    const setupFunctionRef = { current: O.none() };
+    const functionEntries = [];
+    const setupFunctionRef = { current: null };
     const setupFunctionIdentifiers = [];
     const indFunctionCalls = [];
     const indSetStateCalls = /* @__PURE__ */ new WeakMap();
@@ -351,10 +363,12 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     const indSetStateCallsInUseLayoutEffectSetup = /* @__PURE__ */ new Map();
     const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
     const onSetupFunctionEnter = (node) => {
-      setupFunctionRef.current = O.some(node);
+      setupFunctionRef.current = node;
     };
     const onSetupFunctionExit = (node) => {
-      setupFunctionRef.current = O.filter(setupFunctionRef.current, (current) => current !== node);
+      if (setupFunctionRef.current === node) {
+        setupFunctionRef.current = null;
+      }
     };
     function isSetupFunction(node) {
       return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseLayoutEffectLikeCall(node.parent);
@@ -363,26 +377,26 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
       return match(node).when(isUseStateCall2, () => "useState").when(isUseLayoutEffectLikeCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return match(node).when(isSetupFunction, () => "setup").when(AST2.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return match(node).when(isSetupFunction, () => "setup").when(AST.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const kind = getFunctionKind(node);
-        functionStack.push({ kind, node });
+        functionEntries.push({ kind, node });
         if (kind === "setup") {
           onSetupFunctionEnter(node);
         }
       },
       ":function:exit"(node) {
-        const { kind } = functionStack.at(-1) ?? {};
+        const { kind } = functionEntries.at(-1) ?? {};
         if (kind === "setup") {
           onSetupFunctionExit(node);
         }
-        functionStack.pop();
+        functionEntries.pop();
       },
       CallExpression(node) {
-        const setupFunction = O.getOrNull(setupFunctionRef.current);
-        const pEntry = functionStack.at(-1);
+        const setupFunction = setupFunctionRef.current;
+        const pEntry = functionEntries.at(-1);
         if (pEntry?.node.async) {
           return;
         }
@@ -402,28 +416,28 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               return;
             }
             default: {
-              const mbVariableDeclarator = AST2.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
-              if (O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST.findParentNodeGuard(node, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator === _) {
                 const calls = indSetStateCalls.get(pEntry.node) ?? [];
                 indSetStateCalls.set(pEntry.node, [...calls, node]);
                 return;
               }
-              const vd = mbVariableDeclarator.value;
-              const prevs = indSetStateCallsInUseMemoOrCallback.get(vd.init) ?? [];
-              indSetStateCallsInUseMemoOrCallback.set(vd.init, [...prevs, node]);
+              const init = variableDeclarator.init;
+              const prevs = indSetStateCallsInUseMemoOrCallback.get(init) ?? [];
+              indSetStateCallsInUseMemoOrCallback.set(init, [...prevs, node]);
             }
           }
         }).with("useLayoutEffect", () => {
-          if (AST2.isFunction(node.arguments.at(0))) {
+          if (AST.isFunction(node.arguments.at(0))) {
             return;
           }
-          setupFunctionIdentifiers.push(...AST2.getNestedIdentifiers(node));
+          setupFunctionIdentifiers.push(...AST.getNestedIdentifiers(node));
         }).with("other", () => {
           if (pEntry?.node !== setupFunction) {
             return;
           }
           indFunctionCalls.push(node);
-        }).otherwise(F.constVoid);
+        }).otherwise(() => _);
       },
       Identifier(node) {
         if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
@@ -441,11 +455,10 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             if (!isUseMemoCall2(parent)) {
               break;
             }
-            const mbVariableDeclarator = AST2.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
-            if (O.isNone(mbVariableDeclarator)) {
+            const variableDeclarator = AST.findParentNodeGuard(parent, isVariableDeclaratorFromHookCall);
+            if (variableDeclarator == null) {
               break;
             }
-            const variableDeclarator = mbVariableDeclarator.value;
             const calls = indSetStateCallsInUseLayoutEffectArg0.get(variableDeclarator.init) ?? [];
             indSetStateCallsInUseLayoutEffectArg0.set(variableDeclarator.init, [...calls, node]);
             break;
@@ -455,11 +468,10 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               break;
             }
             if (isUseCallbackCall2(node.parent)) {
-              const mbVariableDeclarator = AST2.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
-              if (O.isNone(mbVariableDeclarator)) {
+              const variableDeclarator = AST.findParentNodeGuard(node.parent, isVariableDeclaratorFromHookCall);
+              if (variableDeclarator == null) {
                 break;
               }
-              const variableDeclarator = mbVariableDeclarator.value;
               const prevs = indSetStateCallsInUseLayoutEffectArg0.get(variableDeclarator.init) ?? [];
               indSetStateCallsInUseLayoutEffectArg0.set(variableDeclarator.init, [...prevs, node]);
             }
@@ -473,7 +485,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
       },
       "Program:exit"() {
         const getSetStateCalls = (id, initialScope) => {
-          const node = O.flatMap(VAR5.findVariable(id, initialScope), VAR5.getVariableNode(0)).pipe(O.getOrNull);
+          const node = VAR5.getVariableNode(VAR5.findVariable(id, initialScope), 0);
           switch (node?.type) {
             case AST_NODE_TYPES.ArrowFunctionExpression:
             case AST_NODE_TYPES.FunctionDeclaration:
@@ -484,7 +496,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
           }
           return [];
         };
-        for (const [_, calls] of indSetStateCallsInUseLayoutEffectSetup) {
+        for (const [, calls] of indSetStateCallsInUseLayoutEffectSetup) {
           for (const call of calls) {
             context.report({
               messageId: "noDirectSetStateInUseLayoutEffect",
@@ -504,7 +516,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               messageId: "noDirectSetStateInUseLayoutEffect",
               node: setStateCall,
               data: {
-                name: AST2.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -516,7 +528,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
               messageId: "noDirectSetStateInUseLayoutEffect",
               node: setStateCall,
               data: {
-                name: AST2.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+                name: AST.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
               }
             });
           }
@@ -559,43 +571,41 @@ var no_unnecessary_use_callback_default = createRule({
         }
         const scope = context.sourceCode.getScope(node);
         const component = scope.block;
-        if (!AST2.isFunction(component)) {
+        if (!AST.isFunction(component)) {
           return;
         }
         const [arg0, arg1] = node.arguments;
         if (arg0 == null || arg1 == null) {
           return;
         }
-        const hasEmptyDeps = F.pipe(
-          match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-            return F.pipe(
-              VAR5.findVariable(n.name, initialScope),
-              O.flatMap(VAR5.getVariableNode(0)),
-              O.filter(AST2.is(AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(O.none),
-          O.exists((x) => x.elements.length === 0)
-        );
+        const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5.findVariable(n.name, initialScope);
+          const variableNode = VAR5.getVariableNode(variable, 0);
+          if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
+            return false;
+          }
+          return variableNode.elements.length === 0;
+        }).otherwise(() => false);
         if (!hasEmptyDeps) {
           return;
         }
-        const isReferencedToComponentScope = F.pipe(
-          match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-            if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) {
-              return O.some(n.body);
-            }
-            return O.some(n);
-          }).with({ type: AST_NODE_TYPES.FunctionExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-            return F.pipe(
-              VAR5.findVariable(n.name, initialScope),
-              O.flatMap(VAR5.getVariableNode(0)),
-              O.filter(AST2.isFunction)
-            );
-          }).otherwise(O.none),
-          O.map((n) => context.sourceCode.getScope(n)),
-          O.map((s) => VAR5.getChidScopes(s).flatMap((x) => x.references)),
-          O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
+        const arg0Node = match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+          if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+            return n.body;
+          }
+          return n;
+        }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5.findVariable(n.name, initialScope);
+          const variableNode = VAR5.getVariableNode(variable, 0);
+          if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
+            return _;
+          }
+          return variableNode;
+        }).otherwise(() => _);
+        if (arg0Node === _) return;
+        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+        const arg0NodeReferences = VAR5.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({
             messageId: "noUnnecessaryUseCallback",
@@ -640,51 +650,45 @@ var no_unnecessary_use_memo_default = createRule({
         }
         const scope = context.sourceCode.getScope(node);
         const component = scope.block;
-        if (!AST2.isFunction(component)) {
+        if (!AST.isFunction(component)) {
           return;
         }
         const [arg0, arg1] = node.arguments;
         if (arg0 == null || arg1 == null) {
           return;
         }
-        const hasCallInArg0 = F.pipe(
-          O.some(arg0),
-          O.filter((n) => AST2.isFunction(n)),
-          O.exists((n) => [...AST2.getNestedCallExpressions(n.body), ...AST2.getNestedNewExpressions(n.body)].length > 0)
-        );
+        const hasCallInArg0 = AST.isFunction(arg0) && [...AST.getNestedCallExpressions(arg0.body), ...AST.getNestedNewExpressions(arg0.body)].length > 0;
         if (hasCallInArg0) {
           return;
         }
-        const hasEmptyDeps = F.pipe(
-          match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-            return F.pipe(
-              VAR5.findVariable(n.name, initialScope),
-              O.flatMap(VAR5.getVariableNode(0)),
-              O.filter(AST2.is(AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(O.none),
-          O.exists((x) => x.elements.length === 0)
-        );
+        const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5.findVariable(n.name, initialScope);
+          const variableNode = VAR5.getVariableNode(variable, 0);
+          if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
+            return false;
+          }
+          return variableNode.elements.length === 0;
+        }).otherwise(() => false);
         if (!hasEmptyDeps) {
           return;
         }
-        const isReferencedToComponentScope = F.pipe(
-          match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-            if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) {
-              return O.some(n.body);
-            }
-            return O.some(n);
-          }).with({ type: AST_NODE_TYPES.FunctionExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-            return F.pipe(
-              VAR5.findVariable(n.name, initialScope),
-              O.flatMap(VAR5.getVariableNode(0)),
-              O.filter(AST2.isFunction)
-            );
-          }).otherwise(O.none),
-          O.map((n) => context.sourceCode.getScope(n)),
-          O.map((s) => VAR5.getChidScopes(s).flatMap((x) => x.references)),
-          O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
+        const arg0Node = match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+          if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+            return n.body;
+          }
+          return n;
+        }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+          const variable = VAR5.findVariable(n.name, initialScope);
+          const variableNode = VAR5.getVariableNode(variable, 0);
+          if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
+            return _;
+          }
+          return variableNode;
+        }).otherwise(() => _);
+        if (arg0Node === _) return;
+        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+        const arg0NodeReferences = VAR5.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
         if (!isReferencedToComponentScope) {
           context.report({
             messageId: "noUnnecessaryUseMemo",
@@ -723,7 +727,7 @@ var no_useless_custom_hooks_default = createRule({
       "Program:exit"(node) {
         const allHooks = ctx.getAllHooks(node);
         for (const { name: name2, node: node2, hookCalls } of allHooks.values()) {
-          if (AST2.isEmptyFunction(node2)) {
+          if (AST.isEmptyFunction(node2)) {
             continue;
           }
           if (hookCalls.length > 0) {
@@ -736,7 +740,7 @@ var no_useless_custom_hooks_default = createRule({
             messageId: "noUselessCustomHooks",
             node: node2,
             data: {
-              name: name2.value
+              name: name2
             }
           });
         }
@@ -780,11 +784,11 @@ var prefer_use_state_lazy_initialization_default = createRule({
         if (useStateInput == null) {
           return;
         }
-        const nestedCallExpressions = AST2.getNestedCallExpressions(useStateInput);
+        const nestedCallExpressions = AST.getNestedCallExpressions(useStateInput);
         const hasFunctionCall = nestedCallExpressions.some((n) => {
           return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
         });
-        const hasNewCall = AST2.getNestedNewExpressions(useStateInput).some((n) => {
+        const hasNewCall = AST.getNestedNewExpressions(useStateInput).some((n) => {
           return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
         });
         if (!hasFunctionCall && !hasNewCall) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.23.3-next.8",
+  "version": "1.24.0-beta.0",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "react",
@@ -11,13 +11,13 @@
     "eslint-plugin",
     "eslint-plugin-react-hooks-extra"
   ],
-  "homepage": "https://github.com/rEl1cx/eslint-react",
+  "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
-    "url": "https://github.com/rEl1cx/eslint-react/issues"
+    "url": "https://github.com/Rel1cx/eslint-react/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rEl1cx/eslint-react.git",
+    "url": "git+https://github.com/Rel1cx/eslint-react.git",
     "directory": "packages/plugins/eslint-plugin-react-hooks-extra"
   },
   "license": "MIT",
@@ -48,13 +48,13 @@
     "@typescript-eslint/utils": "^8.19.1",
     "string-ts": "^2.2.0",
     "ts-pattern": "^5.6.0",
-    "@eslint-react/ast": "1.23.3-next.8",
-    "@eslint-react/jsx": "1.23.3-next.8",
-    "@eslint-react/core": "1.23.3-next.8",
-    "@eslint-react/shared": "1.23.3-next.8",
-    "@eslint-react/types": "1.23.3-next.8",
-    "@eslint-react/var": "1.23.3-next.8",
-    "@eslint-react/eff": "1.23.3-next.8"
+    "@eslint-react/ast": "1.24.0-beta.0",
+    "@eslint-react/core": "1.24.0-beta.0",
+    "@eslint-react/jsx": "1.24.0-beta.0",
+    "@eslint-react/shared": "1.24.0-beta.0",
+    "@eslint-react/var": "1.24.0-beta.0",
+    "@eslint-react/eff": "1.24.0-beta.0",
+    "@eslint-react/types": "1.24.0-beta.0"
   },
   "devDependencies": {
     "@types/react": "^19.0.4",