eslint-plugin-react-hooks-extra 2.0.0-next.28 → 2.0.0-next.29

package/dist/index.d.ts

@@ -13,10 +13,6 @@ declare const _default: {
                     readonly rules: {
                         readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
                         readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseLayoutEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-unnecessary-use-callback": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseCallback", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-unnecessary-use-memo": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseMemo", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "no-unnecessary-use-prefix": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUsePrefix", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-                        readonly "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseStateLazyInitialization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
                     };
                 };
             };
@@ -35,10 +31,6 @@ declare const _default: {
     rules: {
         readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
         readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseLayoutEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-unnecessary-use-callback": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseCallback", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-unnecessary-use-memo": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseMemo", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "no-unnecessary-use-prefix": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUsePrefix", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-        readonly "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseStateLazyInitialization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     };
 };
 

package/dist/index.js

@@ -1,8 +1,8 @@
 import * as AST from '@eslint-react/ast';
-import * as ER7 from '@eslint-react/core';
-import { identity, getOrElseUpdate, constVoid, constTrue } from '@eslint-react/eff';
+import * as ER from '@eslint-react/core';
+import { getOrElseUpdate, constVoid } from '@eslint-react/eff';
 import { getDocsUrl, getSettingsFromContext } from '@eslint-react/shared';
-import * as VAR4 from '@eslint-react/var';
+import * as VAR from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { match } from 'ts-pattern';
 import { ESLintUtils } from '@typescript-eslint/utils';
@@ -22,41 +22,97 @@ __export(recommended_exports, {
 var name = "react-hooks-extra/recommended";
 var rules = {
   "react-hooks-extra/no-direct-set-state-in-use-effect": "warn",
-  "react-hooks-extra/no-unnecessary-use-prefix": "warn",
-  "react-hooks-extra/prefer-use-state-lazy-initialization": "warn"
+  "react-hooks-extra/no-unnecessary-use-prefix": "warn"
 };
 
 // package.json
 var name2 = "eslint-plugin-react-hooks-extra";
-var version = "2.0.0-next.28";
+var version = "2.0.0-next.29";
 var createRule = ESLintUtils.RuleCreator(getDocsUrl("hooks-extra"));
-function isFromHookCall(context, name3, settings, predicate = constTrue) {
-  const hookAlias = settings.additionalHooks[name3] ?? [];
-  return (topLevelId) => {
-    const variable = VAR4.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR4.getVariableInitNode(variable, 0);
+
+// src/rules/no-direct-set-state-in-use-effect.ts
+var RULE_NAME = "no-direct-set-state-in-use-effect";
+var RULE_FEATURES = [
+  "EXP"
+];
+var no_direct_set_state_in_use_effect_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
+      [Symbol.for("rule_features")]: RULE_FEATURES
+    },
+    messages: {
+      noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME,
+  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"
+  });
+}
+function useNoDirectSetStateInUseEffect(context, options) {
+  const { onViolation, useEffectKind } = options;
+  const settings = getSettingsFromContext(context);
+  const hooks = settings.additionalHooks;
+  const getText = (n) => context.sourceCode.getText(n);
+  const isUseEffectLikeCall = ER.isReactHookCallWithNameAlias(context, useEffectKind, hooks[useEffectKind]);
+  const isUseStateCall = ER.isReactHookCallWithNameAlias(context, "useState", hooks.useState);
+  const isUseMemoCall = ER.isReactHookCallWithNameAlias(context, "useMemo", hooks.useMemo);
+  const isUseCallbackCall = ER.isReactHookCallWithNameAlias(context, "useCallback", hooks.useCallback);
+  const functionEntries = [];
+  const setupFunctionRef = { current: null };
+  const setupFunctionIdentifiers = [];
+  const indFunctionCalls = [];
+  const indSetStateCalls = /* @__PURE__ */ new WeakMap();
+  const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new WeakMap();
+  const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
+  const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
+  const onSetupFunctionEnter = (node) => {
+    setupFunctionRef.current = node;
+  };
+  const onSetupFunctionExit = (node) => {
+    if (setupFunctionRef.current === node) {
+      setupFunctionRef.current = null;
+    }
+  };
+  function isFunctionOfUseEffectSetup(node) {
+    return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
+  }
+  function getCallName(node) {
+    if (node.type === AST_NODE_TYPES.CallExpression) {
+      return AST.toStringFormat(node.callee, getText);
+    }
+    return AST.toStringFormat(node, getText);
+  }
+  function getCallKind(node) {
+    return match(node).when(isUseStateCall, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(AST.isThenCall, () => "then").otherwise(() => "other");
+  }
+  function getFunctionKind(node) {
+    return match(node).when(isFunctionOfUseEffectSetup, () => "setup").when(AST.isImmediatelyInvokedFunction, () => "immediate").otherwise(() => "other");
+  }
+  function isIdFromUseStateCall(topLevelId, at) {
+    const variable = VAR.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
+    const variableNode = VAR.getVariableInitNode(variable, 0);
     if (variableNode == null) return false;
     if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
-    if (!ER7.isReactHookCallWithNameAlias(context, name3, hookAlias)(variableNode)) return false;
-    return predicate(topLevelId, variableNode);
-  };
-}
-function isFromUseStateCall(context, settings) {
-  const predicate = (topLevelId, call) => {
-    const { parent } = call;
-    if (!("id" in parent) || parent.id?.type !== AST_NODE_TYPES.ArrayPattern) {
+    if (!ER.isReactHookCallWithNameAlias(context, "useState", hooks.useState)(variableNode)) return false;
+    const variableNodeParent = variableNode.parent;
+    if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) {
       return true;
     }
-    return parent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === 1;
-  };
-  return isFromHookCall(context, "useState", settings, predicate);
-}
-function isFunctionOfImmediatelyInvoked(node) {
-  return node.type !== AST_NODE_TYPES.FunctionDeclaration && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node;
-}
-function isSetFunctionCall(context, settings) {
-  const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-  return (node) => {
+    return variableNodeParent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === at;
+  }
+  function isSetStateCall(node) {
     switch (node.callee.type) {
       // const data = useState();
       // data.at(1)();
@@ -74,7 +130,7 @@ function isSetFunctionCall(context, settings) {
           return false;
         }
         const indexScope = context.sourceCode.getScope(node);
-        const indexValue = VAR4.toStaticValue({
+        const indexValue = VAR.toStaticValue({
           kind: "lazy",
           node: index,
           initialScope: indexScope
@@ -84,7 +140,7 @@ function isSetFunctionCall(context, settings) {
       // const [data, setData] = useState();
       // setData();
       case AST_NODE_TYPES.Identifier: {
-        return isIdFromUseStateCall(node.callee);
+        return isIdFromUseStateCall(node.callee, 1);
       }
       // const data = useState();
       // data[1]();
@@ -94,84 +150,17 @@ function isSetFunctionCall(context, settings) {
         }
         const property = node.callee.property;
         const propertyScope = context.sourceCode.getScope(node);
-        const propertyValue = VAR4.toStaticValue({
+        const propertyValue = VAR.toStaticValue({
           kind: "lazy",
           node: property,
           initialScope: propertyScope
         }).value;
-        return propertyValue === 1 && isIdFromUseStateCall(node.callee.object);
+        return propertyValue === 1 && isIdFromUseStateCall(node.callee.object, 1);
       }
       default: {
         return false;
       }
     }
-  };
-}
-function isThenCall(node) {
-  return node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "then";
-}
-function isVariableDeclaratorFromHookCall(node) {
-  if (node.type !== AST_NODE_TYPES.VariableDeclarator) {
-    return false;
-  }
-  if (node.id.type !== AST_NODE_TYPES.Identifier) {
-    return false;
-  }
-  if (node.init?.type !== AST_NODE_TYPES.CallExpression) {
-    return false;
-  }
-  switch (node.init.callee.type) {
-    case AST_NODE_TYPES.Identifier:
-      return ER7.isReactHookName(node.init.callee.name);
-    case AST_NODE_TYPES.MemberExpression:
-      return node.init.callee.property.type === AST_NODE_TYPES.Identifier && ER7.isReactHookName(node.init.callee.property.name);
-    default:
-      return false;
-  }
-}
-
-// src/hooks/use-no-direct-set-state-in-use-effect.ts
-function useNoDirectSetStateInUseEffect(context, options) {
-  const { onViolation, useEffectKind } = options;
-  const settings = getSettingsFromContext(context);
-  const hooks = settings.additionalHooks;
-  const getText = (n) => context.sourceCode.getText(n);
-  const isUseEffectLikeCall = ER7.isReactHookCallWithNameAlias(context, useEffectKind, hooks[useEffectKind]);
-  const isUseStateCall = ER7.isReactHookCallWithNameAlias(context, "useState", hooks.useState);
-  const isUseMemoCall = ER7.isReactHookCallWithNameAlias(context, "useMemo", hooks.useMemo);
-  const isUseCallbackCall = ER7.isReactHookCallWithNameAlias(context, "useCallback", hooks.useCallback);
-  const isSetStateCall = isSetFunctionCall(context, settings);
-  const isIdFromUseStateCall = isFromUseStateCall(context, settings);
-  const functionEntries = [];
-  const setupFunctionRef = { current: null };
-  const setupFunctionIdentifiers = [];
-  const indFunctionCalls = [];
-  const indSetStateCalls = /* @__PURE__ */ new WeakMap();
-  const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new WeakMap();
-  const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
-  const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
-  const onSetupFunctionEnter = (node) => {
-    setupFunctionRef.current = node;
-  };
-  const onSetupFunctionExit = (node) => {
-    if (setupFunctionRef.current === node) {
-      setupFunctionRef.current = null;
-    }
-  };
-  function isFunctionOfUseEffectSetup(node) {
-    return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
-  }
-  function getCallName(node) {
-    if (node.type === AST_NODE_TYPES.CallExpression) {
-      return AST.toStringFormat(node.callee, getText);
-    }
-    return AST.toStringFormat(node, getText);
-  }
-  function getCallKind(node) {
-    return match(node).when(isUseStateCall, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
-  }
-  function getFunctionKind(node) {
-    return match(node).when(isFunctionOfUseEffectSetup, () => "setup").when(isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
   }
   return {
     ":function"(node) {
@@ -221,7 +210,7 @@ function useNoDirectSetStateInUseEffect(context, options) {
       if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
         return;
       }
-      if (!isIdFromUseStateCall(node)) {
+      if (!isIdFromUseStateCall(node, 1)) {
         return;
       }
       switch (node.parent.type) {
@@ -258,7 +247,7 @@ function useNoDirectSetStateInUseEffect(context, options) {
     },
     "Program:exit"() {
       const getSetStateCalls = (id, initialScope) => {
-        const node = VAR4.getVariableInitNode(VAR4.findVariable(id, initialScope), 0);
+        const node = VAR.getVariableInitNode(VAR.findVariable(id, initialScope), 0);
         switch (node?.type) {
           case AST_NODE_TYPES.ArrowFunctionExpression:
           case AST_NODE_TYPES.FunctionDeclaration:
@@ -297,37 +286,21 @@ function useNoDirectSetStateInUseEffect(context, options) {
     }
   };
 }
-
-// src/rules/no-direct-set-state-in-use-effect.ts
-var RULE_NAME = "no-direct-set-state-in-use-effect";
-var RULE_FEATURES = [
-  "EXP"
-];
-var no_direct_set_state_in_use_effect_default = createRule({
-  meta: {
-    type: "problem",
-    deprecated: true,
-    docs: {
-      description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES
-    },
-    messages: {
-      noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'."
-    },
-    schema: []
-  },
-  name: RULE_NAME,
-  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"
-  });
+function isInitFromHookCall(init) {
+  if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
+  switch (init.callee.type) {
+    case AST_NODE_TYPES.Identifier:
+      return ER.isReactHookName(init.callee.name);
+    case AST_NODE_TYPES.MemberExpression:
+      return init.callee.property.type === AST_NODE_TYPES.Identifier && ER.isReactHookName(init.callee.property.name);
+    default:
+      return false;
+  }
+}
+function isVariableDeclaratorFromHookCall(node) {
+  if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+  if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
+  return isInitFromHookCall(node.init);
 }
 
 // src/rules/no-direct-set-state-in-use-layout-effect.ts
@@ -338,7 +311,6 @@ var RULE_FEATURES2 = [
 var no_direct_set_state_in_use_layout_effect_default = createRule({
   meta: {
     type: "problem",
-    deprecated: true,
     docs: {
       description: "Disallow direct calls to the `set` function of `useState` in `useLayoutEffect`.",
       [Symbol.for("rule_features")]: RULE_FEATURES2
@@ -361,312 +333,6 @@ function create2(context) {
     useEffectKind: "useLayoutEffect"
   });
 }
-var RULE_NAME3 = "no-unnecessary-use-callback";
-var RULE_FEATURES3 = [
-  "EXP"
-];
-var no_unnecessary_use_callback_default = createRule({
-  meta: {
-    type: "problem",
-    deprecated: true,
-    docs: {
-      description: "Disallow unnecessary usage of `useCallback`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES3
-    },
-    messages: {
-      noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
-    },
-    schema: []
-  },
-  name: RULE_NAME3,
-  create: create3,
-  defaultOptions: []
-});
-function create3(context) {
-  if (!context.sourceCode.text.includes("use")) return {};
-  const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-  const isUseCallbackCall = ER7.isReactHookCallWithNameAlias(context, "useCallback", alias);
-  return {
-    CallExpression(node) {
-      if (!ER7.isReactHookCall(node)) {
-        return;
-      }
-      const initialScope = context.sourceCode.getScope(node);
-      if (!isUseCallbackCall(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;
-        }
-        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;
-        }
-        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 null;
-        }
-        return variableNode;
-      }).otherwise(() => null);
-      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
-        });
-      }
-    }
-  };
-}
-var RULE_NAME4 = "no-unnecessary-use-memo";
-var RULE_FEATURES4 = [
-  "EXP"
-];
-var no_unnecessary_use_memo_default = createRule({
-  meta: {
-    type: "problem",
-    deprecated: true,
-    docs: {
-      description: "Disallow unnecessary usage of `useMemo`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES4
-    },
-    messages: {
-      noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
-    },
-    schema: []
-  },
-  name: RULE_NAME4,
-  create: create4,
-  defaultOptions: []
-});
-function create4(context) {
-  if (!context.sourceCode.text.includes("use")) return {};
-  const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
-  const isUseMemoCall = ER7.isReactHookCallWithNameAlias(context, "useMemo", alias);
-  return {
-    CallExpression(node) {
-      if (!ER7.isReactHookCall(node)) {
-        return;
-      }
-      const initialScope = context.sourceCode.getScope(node);
-      if (!isUseMemoCall(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;
-        }
-        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;
-        }
-        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 null;
-        }
-        return variableNode;
-      }).otherwise(() => null);
-      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
-        });
-      }
-    }
-  };
-}
-var RULE_NAME5 = "no-unnecessary-use-prefix";
-var RULE_FEATURES5 = [];
-var WELL_KNOWN_HOOKS = [
-  "useMDXComponents"
-];
-function containsUseComments(context, node) {
-  return context.sourceCode.getCommentsInside(node).some(({ value }) => /use\([\s\S]*?\)/u.test(value) || /use[A-Z0-9]\w*\([\s\S]*?\)/u.test(value));
-}
-var no_unnecessary_use_prefix_default = createRule({
-  meta: {
-    type: "problem",
-    deprecated: true,
-    docs: {
-      description: "Enforces that a function with the `use` prefix should use at least one Hook inside of it.",
-      [Symbol.for("rule_features")]: RULE_FEATURES5
-    },
-    messages: {
-      noUnnecessaryUsePrefix: "If your function doesn't call any Hooks, avoid the 'use' prefix. Instead, write it as a regular function without the 'use' prefix."
-    },
-    schema: []
-  },
-  name: RULE_NAME5,
-  create: create5,
-  defaultOptions: []
-});
-function create5(context) {
-  const { ctx, listeners } = ER7.useHookCollector();
-  return {
-    ...listeners,
-    "Program:exit"(program) {
-      const allHooks = ctx.getAllHooks(program);
-      for (const { id, name: name3, node, hookCalls } of allHooks.values()) {
-        if (WELL_KNOWN_HOOKS.includes(name3)) {
-          continue;
-        }
-        if (AST.isEmptyFunction(node)) {
-          continue;
-        }
-        if (hookCalls.length > 0) {
-          continue;
-        }
-        if (containsUseComments(context, node)) {
-          continue;
-        }
-        if (id != null) {
-          context.report({
-            messageId: "noUnnecessaryUsePrefix",
-            data: {
-              name: name3
-            },
-            loc: getPreferredLoc(context, id)
-          });
-          continue;
-        }
-        context.report({
-          messageId: "noUnnecessaryUsePrefix",
-          node,
-          data: {
-            name: name3
-          }
-        });
-      }
-    }
-  };
-}
-function getPreferredLoc(context, id) {
-  if (AST.isMultiLine(id)) return id.loc;
-  if (!context.sourceCode.getText(id).startsWith("use")) return id.loc;
-  return {
-    end: {
-      column: id.loc.start.column + 3,
-      line: id.loc.start.line
-    },
-    start: {
-      column: id.loc.start.column,
-      line: id.loc.start.line
-    }
-  };
-}
-var RULE_NAME6 = "prefer-use-state-lazy-initialization";
-var RULE_FEATURES6 = [
-  "EXP"
-];
-var ALLOW_LIST = [
-  "Boolean",
-  "String",
-  "Number"
-];
-var prefer_use_state_lazy_initialization_default = createRule({
-  meta: {
-    type: "problem",
-    deprecated: true,
-    docs: {
-      description: "Enforces function calls made inside `useState` to be wrapped in an `initializer function`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES6
-    },
-    messages: {
-      preferUseStateLazyInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'."
-    },
-    schema: []
-  },
-  name: RULE_NAME6,
-  create: create6,
-  defaultOptions: []
-});
-function create6(context) {
-  const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-  const isUseStateCall = ER7.isReactHookCallWithNameAlias(context, "useState", alias);
-  return {
-    CallExpression(node) {
-      if (!ER7.isReactHookCall(node)) {
-        return;
-      }
-      if (!isUseStateCall(node)) {
-        return;
-      }
-      const [useStateInput] = node.arguments;
-      if (useStateInput == null) {
-        return;
-      }
-      for (const expr of AST.getNestedNewExpressions(useStateInput)) {
-        if (!("name" in expr.callee)) continue;
-        if (ALLOW_LIST.includes(expr.callee.name)) continue;
-        if (AST.findParentNode(expr, (n) => ER7.isUseCall(context, n)) != null) continue;
-        context.report({
-          messageId: "preferUseStateLazyInitialization",
-          node: expr
-        });
-      }
-      for (const expr of AST.getNestedCallExpressions(useStateInput)) {
-        if (!("name" in expr.callee)) continue;
-        if (ER7.isReactHookName(expr.callee.name)) continue;
-        if (ALLOW_LIST.includes(expr.callee.name)) continue;
-        if (AST.findParentNode(expr, (n) => ER7.isUseCall(context, n)) != null) continue;
-        context.report({
-          messageId: "preferUseStateLazyInitialization",
-          node: expr
-        });
-      }
-    }
-  };
-}
 
 // src/plugin.ts
 var plugin = {
@@ -675,18 +341,8 @@ var plugin = {
     version
   },
   rules: {
-    /** @deprecated Use `react-x/no-direct-set-state-in-use-effect` instead */
     "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
-    /** @deprecated Use `react-x/no-direct-set-state-in-use-layout-effect` instead */
-    "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_effect_default,
-    /** @deprecated Use `react-x/no-unnecessary-use-callback` instead */
-    "no-unnecessary-use-callback": no_unnecessary_use_callback_default,
-    /** @deprecated Use `react-x/no-unnecessary-use-memo` instead */
-    "no-unnecessary-use-memo": no_unnecessary_use_memo_default,
-    /** @deprecated Use `react-x/no-unnecessary-use-prefix` instead */
-    "no-unnecessary-use-prefix": no_unnecessary_use_prefix_default,
-    /** @deprecated Use `react-x/prefer-use-state-lazy-initialization` instead */
-    "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
+    "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_effect_default
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "2.0.0-next.28",
+  "version": "2.0.0-next.29",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "react",
@@ -42,12 +42,12 @@
     "@typescript-eslint/utils": "^8.33.0",
     "string-ts": "^2.2.1",
     "ts-pattern": "^5.7.1",
-    "@eslint-react/ast": "2.0.0-next.28",
-    "@eslint-react/eff": "2.0.0-next.28",
-    "@eslint-react/kit": "2.0.0-next.28",
-    "@eslint-react/core": "2.0.0-next.28",
-    "@eslint-react/shared": "2.0.0-next.28",
-    "@eslint-react/var": "2.0.0-next.28"
+    "@eslint-react/ast": "2.0.0-next.29",
+    "@eslint-react/kit": "2.0.0-next.29",
+    "@eslint-react/eff": "2.0.0-next.29",
+    "@eslint-react/shared": "2.0.0-next.29",
+    "@eslint-react/var": "2.0.0-next.29",
+    "@eslint-react/core": "2.0.0-next.29"
   },
   "devDependencies": {
     "@types/react": "^19.1.6",