eslint-plugin-react-hooks-extra 1.33.0 → 1.34.0-beta.1

package/dist/index.js

@@ -50,7 +50,7 @@ var rules = {
 
 // package.json
 var name2 = "eslint-plugin-react-hooks-extra";
-var version = "1.33.0";
+var version = "1.34.0-beta.1";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 function isFromHookCall(context, name3, settings, predicate = eff.constTrue) {
   const hookAlias = settings.additionalHooks[name3] ?? [];
@@ -331,17 +331,18 @@ var no_direct_set_state_in_use_effect_default = createRule({
     schema: []
   },
   name: RULE_NAME,
-  create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-    return useNoDirectSetStateInUseEffect(context, {
-      onViolation(ctx, node, data) {
-        ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
-      },
-      useEffectKind: "useEffect"
-    });
-  },
+  create,
   defaultOptions: []
 });
+function create(context) {
+  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+  return useNoDirectSetStateInUseEffect(context, {
+    onViolation(ctx, node, data) {
+      ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
+    },
+    useEffectKind: "useEffect"
+  });
+}
 
 // src/rules/no-direct-set-state-in-use-layout-effect.ts
 var RULE_NAME2 = "no-direct-set-state-in-use-layout-effect";
@@ -361,17 +362,18 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     schema: []
   },
   name: RULE_NAME2,
-  create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-    return useNoDirectSetStateInUseEffect(context, {
-      onViolation(ctx, node, data) {
-        ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
-      },
-      useEffectKind: "useLayoutEffect"
-    });
-  },
+  create: create2,
   defaultOptions: []
 });
+function create2(context) {
+  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+  return useNoDirectSetStateInUseEffect(context, {
+    onViolation(ctx, node, data) {
+      ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
+    },
+    useEffectKind: "useLayoutEffect"
+  });
+}
 var RULE_NAME3 = "no-unnecessary-use-callback";
 var RULE_FEATURES3 = [
   "CHK"
@@ -389,68 +391,67 @@ var no_unnecessary_use_callback_default = createRule({
     schema: []
   },
   name: RULE_NAME3,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) {
-      return {};
-    }
-    const alias = shared.getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-    return {
-      CallExpression(node) {
-        if (!core.isReactHookCall(node)) {
-          return;
-        }
-        const initialScope = context.sourceCode.getScope(node);
-        if (!core.isUseCallbackCall(context, node) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!AST__namespace.isFunction(component)) {
-          return;
-        }
-        const [arg0, arg1] = node.arguments;
-        if (arg0 == null || arg1 == null) {
-          return;
+  create: create3,
+  defaultOptions: []
+});
+function create3(context) {
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = shared.getSettingsFromContext(context).additionalHooks.useCallback ?? [];
+  return {
+    CallExpression(node) {
+      if (!core.isReactHookCall(node)) {
+        return;
+      }
+      const initialScope = context.sourceCode.getScope(node);
+      if (!core.isUseCallbackCall(context, node) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
+        return;
+      }
+      const scope = context.sourceCode.getScope(node);
+      const component = scope.block;
+      if (!AST__namespace.isFunction(component)) {
+        return;
+      }
+      const [arg0, arg1] = node.arguments;
+      if (arg0 == null || arg1 == null) {
+        return;
+      }
+      const hasEmptyDeps = tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4__namespace.findVariable(n.name, initialScope);
+        const variableNode = VAR4__namespace.getVariableInitNode(variable, 0);
+        if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
+          return false;
         }
-        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 = VAR4__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR4__namespace.getVariableInitNode(variable, 0);
-          if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
-            return false;
-          }
-          return variableNode.elements.length === 0;
-        }).otherwise(() => false);
-        if (!hasEmptyDeps) {
-          return;
+        return variableNode.elements.length === 0;
+      }).otherwise(() => false);
+      if (!hasEmptyDeps) {
+        return;
+      }
+      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;
         }
-        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 = VAR4__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR4__namespace.getVariableInitNode(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 == null) return;
-        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR4__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
-        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-        if (!isReferencedToComponentScope) {
-          context.report({
-            messageId: "noUnnecessaryUseCallback",
-            node
-          });
+        return n;
+      }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.identity).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4__namespace.findVariable(n.name, initialScope);
+        const variableNode = VAR4__namespace.getVariableInitNode(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 == null) return;
+      const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+      const arg0NodeReferences = VAR4__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
+      if (!isReferencedToComponentScope) {
+        context.report({
+          messageId: "noUnnecessaryUseCallback",
+          node
+        });
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 var RULE_NAME4 = "no-unnecessary-use-memo";
 var RULE_FEATURES4 = [
   "CHK"
@@ -468,72 +469,71 @@ var no_unnecessary_use_memo_default = createRule({
     schema: []
   },
   name: RULE_NAME4,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) {
-      return {};
-    }
-    const alias = shared.getSettingsFromContext(context).additionalHooks.useMemo ?? [];
-    return {
-      CallExpression(node) {
-        if (!core.isReactHookCall(node)) {
-          return;
-        }
-        const initialScope = context.sourceCode.getScope(node);
-        if (!core.isUseMemoCall(context, node) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!AST__namespace.isFunction(component)) {
-          return;
-        }
-        const [arg0, arg1] = node.arguments;
-        if (arg0 == null || arg1 == null) {
-          return;
-        }
-        const hasCallInArg0 = AST__namespace.isFunction(arg0) && [...AST__namespace.getNestedCallExpressions(arg0.body), ...AST__namespace.getNestedNewExpressions(arg0.body)].length > 0;
-        if (hasCallInArg0) {
-          return;
+  create: create4,
+  defaultOptions: []
+});
+function create4(context) {
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = shared.getSettingsFromContext(context).additionalHooks.useMemo ?? [];
+  return {
+    CallExpression(node) {
+      if (!core.isReactHookCall(node)) {
+        return;
+      }
+      const initialScope = context.sourceCode.getScope(node);
+      if (!core.isUseMemoCall(context, node) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
+        return;
+      }
+      const scope = context.sourceCode.getScope(node);
+      const component = scope.block;
+      if (!AST__namespace.isFunction(component)) {
+        return;
+      }
+      const [arg0, arg1] = node.arguments;
+      if (arg0 == null || arg1 == null) {
+        return;
+      }
+      const hasCallInArg0 = AST__namespace.isFunction(arg0) && [...AST__namespace.getNestedCallExpressions(arg0.body), ...AST__namespace.getNestedNewExpressions(arg0.body)].length > 0;
+      if (hasCallInArg0) {
+        return;
+      }
+      const hasEmptyDeps = tsPattern.match(arg1).with({ type: types.AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4__namespace.findVariable(n.name, initialScope);
+        const variableNode = VAR4__namespace.getVariableInitNode(variable, 0);
+        if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
+          return false;
         }
-        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 = VAR4__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR4__namespace.getVariableInitNode(variable, 0);
-          if (variableNode?.type !== types.AST_NODE_TYPES.ArrayExpression) {
-            return false;
-          }
-          return variableNode.elements.length === 0;
-        }).otherwise(() => false);
-        if (!hasEmptyDeps) {
-          return;
+        return variableNode.elements.length === 0;
+      }).otherwise(() => false);
+      if (!hasEmptyDeps) {
+        return;
+      }
+      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;
         }
-        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 = VAR4__namespace.findVariable(n.name, initialScope);
-          const variableNode = VAR4__namespace.getVariableInitNode(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 == null) return;
-        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR4__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
-        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-        if (!isReferencedToComponentScope) {
-          context.report({
-            messageId: "noUnnecessaryUseMemo",
-            node
-          });
+        return n;
+      }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, eff.identity).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4__namespace.findVariable(n.name, initialScope);
+        const variableNode = VAR4__namespace.getVariableInitNode(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 == null) return;
+      const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+      const arg0NodeReferences = VAR4__namespace.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
+      if (!isReferencedToComponentScope) {
+        context.report({
+          messageId: "noUnnecessaryUseMemo",
+          node
+        });
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 var RULE_NAME5 = "no-useless-custom-hooks";
 var RULE_FEATURES5 = [
   "CHK"
@@ -554,35 +554,36 @@ var no_useless_custom_hooks_default = createRule({
     schema: []
   },
   name: RULE_NAME5,
-  create(context) {
-    const { ctx, listeners } = core.useHookCollector();
-    return {
-      ...listeners,
-      "Program:exit"(node) {
-        const allHooks = ctx.getAllHooks(node);
-        for (const { name: name3, node: node2, hookCalls } of allHooks.values()) {
-          if (AST__namespace.isEmptyFunction(node2)) {
-            continue;
-          }
-          if (hookCalls.length > 0) {
-            continue;
-          }
-          if (isNodeContainsUseCallComments(context, node2)) {
-            continue;
-          }
-          context.report({
-            messageId: "noUselessCustomHooks",
-            node: node2,
-            data: {
-              name: name3
-            }
-          });
-        }
-      }
-    };
-  },
+  create: create5,
   defaultOptions: []
 });
+function create5(context) {
+  const { ctx, listeners } = core.useHookCollector();
+  return {
+    ...listeners,
+    "Program:exit"(node) {
+      const allHooks = ctx.getAllHooks(node);
+      for (const { name: name3, node: node2, hookCalls } of allHooks.values()) {
+        if (AST__namespace.isEmptyFunction(node2)) {
+          continue;
+        }
+        if (hookCalls.length > 0) {
+          continue;
+        }
+        if (isNodeContainsUseCallComments(context, node2)) {
+          continue;
+        }
+        context.report({
+          messageId: "noUselessCustomHooks",
+          node: node2,
+          data: {
+            name: name3
+          }
+        });
+      }
+    }
+  };
+}
 var RULE_NAME6 = "prefer-use-state-lazy-initialization";
 var RULE_FEATURES6 = [
   "CHK"
@@ -601,42 +602,41 @@ var prefer_use_state_lazy_initialization_default = createRule({
     schema: []
   },
   name: RULE_NAME6,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) {
-      return {};
-    }
-    const alias = shared.getSettingsFromContext(context).additionalHooks.useState ?? [];
-    return {
-      CallExpression(node) {
-        if (!core.isReactHookCall(node)) {
-          return;
-        }
-        if (!core.isUseStateCall(context, node) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const [useStateInput] = node.arguments;
-        if (useStateInput == null) {
-          return;
-        }
-        const nestedCallExpressions = AST__namespace.getNestedCallExpressions(useStateInput);
-        const hasFunctionCall = nestedCallExpressions.some((n) => {
-          return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
-        });
-        const hasNewCall = AST__namespace.getNestedNewExpressions(useStateInput).some((n) => {
-          return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
-        });
-        if (!hasFunctionCall && !hasNewCall) {
-          return;
-        }
-        context.report({
-          messageId: "preferUseStateLazyInitialization",
-          node: useStateInput
-        });
-      }
-    };
-  },
+  create: create6,
   defaultOptions: []
 });
+function create6(context) {
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = shared.getSettingsFromContext(context).additionalHooks.useState ?? [];
+  return {
+    CallExpression(node) {
+      if (!core.isReactHookCall(node)) {
+        return;
+      }
+      if (!core.isUseStateCall(context, node) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
+        return;
+      }
+      const [useStateInput] = node.arguments;
+      if (useStateInput == null) {
+        return;
+      }
+      const nestedCallExpressions = AST__namespace.getNestedCallExpressions(useStateInput);
+      const hasFunctionCall = nestedCallExpressions.some((n) => {
+        return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
+      });
+      const hasNewCall = AST__namespace.getNestedNewExpressions(useStateInput).some((n) => {
+        return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
+      });
+      if (!hasFunctionCall && !hasNewCall) {
+        return;
+      }
+      context.report({
+        messageId: "preferUseStateLazyInitialization",
+        node: useStateInput
+      });
+    }
+  };
+}
 
 // src/plugin.ts
 var plugin = {

package/dist/index.mjs

@@ -27,7 +27,7 @@ var rules = {
 
 // package.json
 var name2 = "eslint-plugin-react-hooks-extra";
-var version = "1.33.0";
+var version = "1.34.0-beta.1";
 var createRule = createRuleForPlugin("hooks-extra");
 function isFromHookCall(context, name3, settings, predicate = constTrue) {
   const hookAlias = settings.additionalHooks[name3] ?? [];
@@ -308,17 +308,18 @@ var no_direct_set_state_in_use_effect_default = createRule({
     schema: []
   },
   name: RULE_NAME,
-  create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-    return useNoDirectSetStateInUseEffect(context, {
-      onViolation(ctx, node, data) {
-        ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
-      },
-      useEffectKind: "useEffect"
-    });
-  },
+  create,
   defaultOptions: []
 });
+function create(context) {
+  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+  return useNoDirectSetStateInUseEffect(context, {
+    onViolation(ctx, node, data) {
+      ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
+    },
+    useEffectKind: "useEffect"
+  });
+}
 
 // src/rules/no-direct-set-state-in-use-layout-effect.ts
 var RULE_NAME2 = "no-direct-set-state-in-use-layout-effect";
@@ -338,17 +339,18 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     schema: []
   },
   name: RULE_NAME2,
-  create(context) {
-    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-    return useNoDirectSetStateInUseEffect(context, {
-      onViolation(ctx, node, data) {
-        ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
-      },
-      useEffectKind: "useLayoutEffect"
-    });
-  },
+  create: create2,
   defaultOptions: []
 });
+function create2(context) {
+  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+  return useNoDirectSetStateInUseEffect(context, {
+    onViolation(ctx, node, data) {
+      ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
+    },
+    useEffectKind: "useLayoutEffect"
+  });
+}
 var RULE_NAME3 = "no-unnecessary-use-callback";
 var RULE_FEATURES3 = [
   "CHK"
@@ -366,68 +368,67 @@ var no_unnecessary_use_callback_default = createRule({
     schema: []
   },
   name: RULE_NAME3,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) {
-      return {};
-    }
-    const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-    return {
-      CallExpression(node) {
-        if (!isReactHookCall(node)) {
-          return;
-        }
-        const initialScope = context.sourceCode.getScope(node);
-        if (!isUseCallbackCall(context, node) && !alias.some(isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!AST.isFunction(component)) {
-          return;
-        }
-        const [arg0, arg1] = node.arguments;
-        if (arg0 == null || arg1 == null) {
-          return;
+  create: create3,
+  defaultOptions: []
+});
+function create3(context) {
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
+  return {
+    CallExpression(node) {
+      if (!isReactHookCall(node)) {
+        return;
+      }
+      const initialScope = context.sourceCode.getScope(node);
+      if (!isUseCallbackCall(context, node) && !alias.some(isReactHookCallWithNameLoose(node))) {
+        return;
+      }
+      const scope = context.sourceCode.getScope(node);
+      const component = scope.block;
+      if (!AST.isFunction(component)) {
+        return;
+      }
+      const [arg0, arg1] = node.arguments;
+      if (arg0 == null || arg1 == null) {
+        return;
+      }
+      const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4.findVariable(n.name, initialScope);
+        const variableNode = VAR4.getVariableInitNode(variable, 0);
+        if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
+          return false;
         }
-        const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR4.findVariable(n.name, initialScope);
-          const variableNode = VAR4.getVariableInitNode(variable, 0);
-          if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
-            return false;
-          }
-          return variableNode.elements.length === 0;
-        }).otherwise(() => false);
-        if (!hasEmptyDeps) {
-          return;
+        return variableNode.elements.length === 0;
+      }).otherwise(() => false);
+      if (!hasEmptyDeps) {
+        return;
+      }
+      const arg0Node = match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+        if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+          return n.body;
         }
-        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 = VAR4.findVariable(n.name, initialScope);
-          const variableNode = VAR4.getVariableInitNode(variable, 0);
-          if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
-            return _;
-          }
-          return variableNode;
-        }).otherwise(() => _);
-        if (arg0Node == null) return;
-        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
-        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-        if (!isReferencedToComponentScope) {
-          context.report({
-            messageId: "noUnnecessaryUseCallback",
-            node
-          });
+        return n;
+      }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4.findVariable(n.name, initialScope);
+        const variableNode = VAR4.getVariableInitNode(variable, 0);
+        if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
+          return _;
         }
+        return variableNode;
+      }).otherwise(() => _);
+      if (arg0Node == null) return;
+      const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+      const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
+      if (!isReferencedToComponentScope) {
+        context.report({
+          messageId: "noUnnecessaryUseCallback",
+          node
+        });
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 var RULE_NAME4 = "no-unnecessary-use-memo";
 var RULE_FEATURES4 = [
   "CHK"
@@ -445,72 +446,71 @@ var no_unnecessary_use_memo_default = createRule({
     schema: []
   },
   name: RULE_NAME4,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) {
-      return {};
-    }
-    const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
-    return {
-      CallExpression(node) {
-        if (!isReactHookCall(node)) {
-          return;
-        }
-        const initialScope = context.sourceCode.getScope(node);
-        if (!isUseMemoCall(context, node) && !alias.some(isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!AST.isFunction(component)) {
-          return;
-        }
-        const [arg0, arg1] = node.arguments;
-        if (arg0 == null || arg1 == null) {
-          return;
-        }
-        const hasCallInArg0 = AST.isFunction(arg0) && [...AST.getNestedCallExpressions(arg0.body), ...AST.getNestedNewExpressions(arg0.body)].length > 0;
-        if (hasCallInArg0) {
-          return;
+  create: create4,
+  defaultOptions: []
+});
+function create4(context) {
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
+  return {
+    CallExpression(node) {
+      if (!isReactHookCall(node)) {
+        return;
+      }
+      const initialScope = context.sourceCode.getScope(node);
+      if (!isUseMemoCall(context, node) && !alias.some(isReactHookCallWithNameLoose(node))) {
+        return;
+      }
+      const scope = context.sourceCode.getScope(node);
+      const component = scope.block;
+      if (!AST.isFunction(component)) {
+        return;
+      }
+      const [arg0, arg1] = node.arguments;
+      if (arg0 == null || arg1 == null) {
+        return;
+      }
+      const hasCallInArg0 = AST.isFunction(arg0) && [...AST.getNestedCallExpressions(arg0.body), ...AST.getNestedNewExpressions(arg0.body)].length > 0;
+      if (hasCallInArg0) {
+        return;
+      }
+      const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4.findVariable(n.name, initialScope);
+        const variableNode = VAR4.getVariableInitNode(variable, 0);
+        if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
+          return false;
         }
-        const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-          const variable = VAR4.findVariable(n.name, initialScope);
-          const variableNode = VAR4.getVariableInitNode(variable, 0);
-          if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
-            return false;
-          }
-          return variableNode.elements.length === 0;
-        }).otherwise(() => false);
-        if (!hasEmptyDeps) {
-          return;
+        return variableNode.elements.length === 0;
+      }).otherwise(() => false);
+      if (!hasEmptyDeps) {
+        return;
+      }
+      const arg0Node = match(arg0).with({ type: AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+        if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+          return n.body;
         }
-        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 = VAR4.findVariable(n.name, initialScope);
-          const variableNode = VAR4.getVariableInitNode(variable, 0);
-          if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
-            return _;
-          }
-          return variableNode;
-        }).otherwise(() => _);
-        if (arg0Node == null) return;
-        const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-        const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
-        const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
-        if (!isReferencedToComponentScope) {
-          context.report({
-            messageId: "noUnnecessaryUseMemo",
-            node
-          });
+        return n;
+      }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+        const variable = VAR4.findVariable(n.name, initialScope);
+        const variableNode = VAR4.getVariableInitNode(variable, 0);
+        if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
+          return _;
         }
+        return variableNode;
+      }).otherwise(() => _);
+      if (arg0Node == null) return;
+      const arg0NodeScope = context.sourceCode.getScope(arg0Node);
+      const arg0NodeReferences = VAR4.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
+      if (!isReferencedToComponentScope) {
+        context.report({
+          messageId: "noUnnecessaryUseMemo",
+          node
+        });
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 var RULE_NAME5 = "no-useless-custom-hooks";
 var RULE_FEATURES5 = [
   "CHK"
@@ -531,35 +531,36 @@ var no_useless_custom_hooks_default = createRule({
     schema: []
   },
   name: RULE_NAME5,
-  create(context) {
-    const { ctx, listeners } = useHookCollector();
-    return {
-      ...listeners,
-      "Program:exit"(node) {
-        const allHooks = ctx.getAllHooks(node);
-        for (const { name: name3, node: node2, hookCalls } of allHooks.values()) {
-          if (AST.isEmptyFunction(node2)) {
-            continue;
-          }
-          if (hookCalls.length > 0) {
-            continue;
-          }
-          if (isNodeContainsUseCallComments(context, node2)) {
-            continue;
-          }
-          context.report({
-            messageId: "noUselessCustomHooks",
-            node: node2,
-            data: {
-              name: name3
-            }
-          });
-        }
-      }
-    };
-  },
+  create: create5,
   defaultOptions: []
 });
+function create5(context) {
+  const { ctx, listeners } = useHookCollector();
+  return {
+    ...listeners,
+    "Program:exit"(node) {
+      const allHooks = ctx.getAllHooks(node);
+      for (const { name: name3, node: node2, hookCalls } of allHooks.values()) {
+        if (AST.isEmptyFunction(node2)) {
+          continue;
+        }
+        if (hookCalls.length > 0) {
+          continue;
+        }
+        if (isNodeContainsUseCallComments(context, node2)) {
+          continue;
+        }
+        context.report({
+          messageId: "noUselessCustomHooks",
+          node: node2,
+          data: {
+            name: name3
+          }
+        });
+      }
+    }
+  };
+}
 var RULE_NAME6 = "prefer-use-state-lazy-initialization";
 var RULE_FEATURES6 = [
   "CHK"
@@ -578,42 +579,41 @@ var prefer_use_state_lazy_initialization_default = createRule({
     schema: []
   },
   name: RULE_NAME6,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) {
-      return {};
-    }
-    const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-    return {
-      CallExpression(node) {
-        if (!isReactHookCall(node)) {
-          return;
-        }
-        if (!isUseStateCall(context, node) && !alias.some(isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const [useStateInput] = node.arguments;
-        if (useStateInput == null) {
-          return;
-        }
-        const nestedCallExpressions = AST.getNestedCallExpressions(useStateInput);
-        const hasFunctionCall = nestedCallExpressions.some((n) => {
-          return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
-        });
-        const hasNewCall = AST.getNestedNewExpressions(useStateInput).some((n) => {
-          return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
-        });
-        if (!hasFunctionCall && !hasNewCall) {
-          return;
-        }
-        context.report({
-          messageId: "preferUseStateLazyInitialization",
-          node: useStateInput
-        });
-      }
-    };
-  },
+  create: create6,
   defaultOptions: []
 });
+function create6(context) {
+  if (!context.sourceCode.text.includes("use")) return {};
+  const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
+  return {
+    CallExpression(node) {
+      if (!isReactHookCall(node)) {
+        return;
+      }
+      if (!isUseStateCall(context, node) && !alias.some(isReactHookCallWithNameLoose(node))) {
+        return;
+      }
+      const [useStateInput] = node.arguments;
+      if (useStateInput == null) {
+        return;
+      }
+      const nestedCallExpressions = AST.getNestedCallExpressions(useStateInput);
+      const hasFunctionCall = nestedCallExpressions.some((n) => {
+        return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
+      });
+      const hasNewCall = AST.getNestedNewExpressions(useStateInput).some((n) => {
+        return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
+      });
+      if (!hasFunctionCall && !hasNewCall) {
+        return;
+      }
+      context.report({
+        messageId: "preferUseStateLazyInitialization",
+        node: useStateInput
+      });
+    }
+  };
+}
 
 // src/plugin.ts
 var plugin = {

package/package.json

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