eslint-plugin-react-hooks-extra 1.12.5-next.6 → 1.13.0-beta.1

package/README.md

@@ -31,7 +31,7 @@ export default [
     },
     rules: {
       // react-hooks-extra recommended rules
-      "hooks-extra/ensure-custom-hooks-using-other-hooks": "warn",
+      "hooks-extra/no-redundant-custom-hook": "warn",
       "hooks-extra/no-direct-set-state-in-use-effect": "warn",
       "hooks-extra/prefer-use-state-lazy-initialization": "warn",
     },
@@ -41,10 +41,10 @@ export default [
 
 ## Rules
 
-| Rule                                     | Description                                                               | 💼  | 💭  |     |
-| :--------------------------------------- | :------------------------------------------------------------------------ | :-: | :-: | :-: |
-| `ensure-custom-hooks-using-other-hooks`  | Warns when custom Hooks that don't use other Hooks.                       |  ✔️  |     |     |
-| `ensure-use-callback-has-non-empty-deps` | Warns when `useCallback` is called with empty dependencies array.         | 🧐  |     |     |
-| `ensure-use-memo-has-non-empty-deps`     | Warns when `useMemo` is called with empty dependencies array.             | 🧐  |     |     |
-| `no-direct-set-state-in-use-effect`      | Disallow direct calls to the `set` function of `useState` in `useEffect`. |  ✔️  |     |     |
-| `prefer-use-state-lazy-initialization`   | Warns function calls made inside `useState` calls.                        | 🚀  |     |     |
+| Rule                                   | Description                                                               | 💼  | 💭  |     |
+| :------------------------------------- | :------------------------------------------------------------------------ | :-: | :-: | :-: |
+| `no-direct-set-state-in-use-effect`    | Disallow direct calls to the `set` function of `useState` in `useEffect`. |  ✔️  |     |     |
+| `no-redundant-custom-hook`             | Warns when custom Hooks that don't use other Hooks.                       |  ✔️  |     |     |
+| `no-unnecessary-use-callback`          | Disallow unnecessary usage of `useCallback`.                              |  ✔️  |     |     |
+| `no-unnecessary-use-memo`              | Disallow unnecessary usage of `useMemo`.                                  |  ✔️  |     |     |
+| `prefer-use-state-lazy-initialization` | Warns function calls made inside `useState` calls.                        | 🚀  |     |     |

package/dist/index.d.mts

@@ -5,13 +5,17 @@ declare const meta: {
     readonly version: string;
 };
 declare const rules: {
-    readonly "ensure-custom-hooks-using-other-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"ensureCustomHooksUsingOtherHooks", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    readonly "ensure-use-callback-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ensureUseCallbackHasNonEmptyDeps", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    readonly "ensure-use-memo-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ensureUseMemoHasNonEmptyDeps", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    readonly "no-redundant-custom-hook": _typescript_eslint_utils_ts_eslint.RuleModule<"noRedundantCustomHook", [], 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 "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseStateLazyInitialization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    /** @deprecated Use `no-redundant-custom-hook` instead */
+    readonly "ensure-custom-hooks-using-other-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"noRedundantCustomHook", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    /** @deprecated Use `no-unnecessary-use-memo` instead */
+    readonly "ensure-use-memo-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseMemo", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     /** @deprecated Use `no-direct-set-state-in-use-effect` instead */
     readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], 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>;
 };
 
 export { meta, rules };

package/dist/index.d.ts

@@ -5,13 +5,17 @@ declare const meta: {
     readonly version: string;
 };
 declare const rules: {
-    readonly "ensure-custom-hooks-using-other-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"ensureCustomHooksUsingOtherHooks", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    readonly "ensure-use-callback-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ensureUseCallbackHasNonEmptyDeps", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
-    readonly "ensure-use-memo-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ensureUseMemoHasNonEmptyDeps", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    readonly "no-redundant-custom-hook": _typescript_eslint_utils_ts_eslint.RuleModule<"noRedundantCustomHook", [], 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 "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"preferUseStateLazyInitialization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    /** @deprecated Use `no-redundant-custom-hook` instead */
+    readonly "ensure-custom-hooks-using-other-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"noRedundantCustomHook", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
+    /** @deprecated Use `no-unnecessary-use-memo` instead */
+    readonly "ensure-use-memo-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"noUnnecessaryUseMemo", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener>;
     /** @deprecated Use `no-direct-set-state-in-use-effect` instead */
     readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectSetStateInUseEffect", [], 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>;
 };
 
 export { meta, rules };

package/dist/index.js

@@ -1,17 +1,17 @@
 'use strict';
 
+var ast = require('@eslint-react/ast');
 var core = require('@eslint-react/core');
 var shared = require('@eslint-react/shared');
-var ast = require('@eslint-react/ast');
 var tools = require('@eslint-react/tools');
 var _var = require('@eslint-react/var');
 var types = require('@typescript-eslint/types');
-var astUtils = require('@typescript-eslint/utils/ast-utils');
 var tsPattern = require('ts-pattern');
+var astUtils = require('@typescript-eslint/utils/ast-utils');
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.12.5-next.6";
+var version = "1.13.0-beta.1";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 function isFromHookCall(name2, context, settings, predicate = tools.F.constTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
@@ -92,201 +92,8 @@ function isVariableDeclaratorFromHookCall(node) {
   }
 }
 
-// src/rules/ensure-custom-hooks-using-other-hooks.ts
-var RULE_NAME = "ensure-custom-hooks-using-other-hooks";
-var ensure_custom_hooks_using_other_hooks_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce custom hooks using other hooks"
-    },
-    messages: {
-      ensureCustomHooksUsingOtherHooks: "A custom hook '{{name}}' should use other hooks."
-    },
-    schema: []
-  },
-  name: RULE_NAME,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) return {};
-    const { ctx, listeners } = core.useHookCollector();
-    return {
-      ...listeners,
-      "Program:exit"(node) {
-        const allHooks = ctx.getAllHooks(node);
-        for (const { name: name2, node: node2, hookCalls } of allHooks.values()) {
-          if (hookCalls.length > 0) continue;
-          context.report({
-            messageId: "ensureCustomHooksUsingOtherHooks",
-            node: node2,
-            data: {
-              name: name2.value
-            }
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: []
-});
-var RULE_NAME2 = "ensure-use-callback-has-non-empty-deps";
-var ensure_use_callback_has_non_empty_deps_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce 'useCallback' has non-empty dependencies array"
-    },
-    messages: {
-      ensureUseCallbackHasNonEmptyDeps: "An 'useCallback' should have a non-empty dependencies array."
-    },
-    schema: []
-  },
-  name: RULE_NAME2,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) return {};
-    const alias = shared.decodeSettings(context.settings).additionalHooks?.useCallback ?? [];
-    return {
-      CallExpression(node) {
-        if (!core.isReactHookCall(node)) return;
-        const initialScope = context.sourceCode.getScope(node);
-        if (!core.isUseCallbackCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!ast.isFunction(component)) return;
-        const [cb, deps] = node.arguments;
-        if (!deps) {
-          context.report({
-            messageId: "ensureUseCallbackHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const hasEmptyDeps = tools.F.pipe(
-          tsPattern.match(deps).with({ type: types.AST_NODE_TYPES.ArrayExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return tools.F.pipe(
-              _var.findVariable(n.name, initialScope),
-              tools.O.flatMap(_var.getVariableNode(0)),
-              tools.O.filter(ast.is(types.AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(tools.O.none),
-          tools.O.exists((x) => x.elements.length === 0)
-        );
-        if (!hasEmptyDeps) return;
-        if (!cb) {
-          context.report({
-            messageId: "ensureUseCallbackHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const isReferencedToComponentScope = tools.F.pipe(
-          tsPattern.match(cb).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-            if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
-              return tools.O.some(n.body);
-            }
-            return tools.O.some(n);
-          }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return tools.F.pipe(
-              _var.findVariable(n.name, initialScope),
-              tools.O.flatMap(_var.getVariableNode(0)),
-              tools.O.filter(ast.isFunction)
-            );
-          }).otherwise(tools.O.none),
-          tools.O.map((n) => context.sourceCode.getScope(n)),
-          tools.O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
-          tools.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
-        if (isReferencedToComponentScope) return;
-        context.report({
-          messageId: "ensureUseCallbackHasNonEmptyDeps",
-          node
-        });
-      }
-    };
-  },
-  defaultOptions: []
-});
-var RULE_NAME3 = "ensure-use-memo-has-non-empty-deps";
-var ensure_use_memo_has_non_empty_deps_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce 'useMemo' has non-empty dependencies array"
-    },
-    messages: {
-      ensureUseMemoHasNonEmptyDeps: "An 'useMemo' should have a non-empty dependencies array."
-    },
-    schema: []
-  },
-  name: RULE_NAME3,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) return {};
-    const alias = shared.decodeSettings(context.settings).additionalHooks?.useMemo ?? [];
-    return {
-      CallExpression(node) {
-        if (!core.isReactHookCall(node)) return;
-        const initialScope = context.sourceCode.getScope(node);
-        if (!core.isUseMemoCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!ast.isFunction(component)) return;
-        const [cb, deps] = node.arguments;
-        if (!deps) {
-          context.report({
-            messageId: "ensureUseMemoHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const hasEmptyDeps = tools.F.pipe(
-          tsPattern.match(deps).with({ type: types.AST_NODE_TYPES.ArrayExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return tools.F.pipe(
-              _var.findVariable(n.name, initialScope),
-              tools.O.flatMap(_var.getVariableNode(0)),
-              tools.O.filter(ast.is(types.AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(tools.O.none),
-          tools.O.exists((x) => x.elements.length === 0)
-        );
-        if (!hasEmptyDeps) return;
-        if (!cb) {
-          context.report({
-            messageId: "ensureUseMemoHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const isReferencedToComponentScope = tools.F.pipe(
-          tsPattern.match(cb).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
-            if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
-              return tools.O.some(n.body);
-            }
-            return tools.O.some(n);
-          }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-            return tools.F.pipe(
-              _var.findVariable(n.name, initialScope),
-              tools.O.flatMap(_var.getVariableNode(0)),
-              tools.O.filter(ast.isFunction)
-            );
-          }).otherwise(tools.O.none),
-          tools.O.map((n) => context.sourceCode.getScope(n)),
-          tools.O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
-          tools.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
-        if (isReferencedToComponentScope) return;
-        context.report({
-          messageId: "ensureUseMemoHasNonEmptyDeps",
-          node
-        });
-      }
-    };
-  },
-  defaultOptions: []
-});
-var RULE_NAME4 = "no-direct-set-state-in-use-effect";
+// src/rules/no-direct-set-state-in-use-effect.ts
+var RULE_NAME = "no-direct-set-state-in-use-effect";
 var no_direct_set_state_in_use_effect_default = createRule({
   meta: {
     type: "problem",
@@ -298,7 +105,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME4,
+  name: RULE_NAME,
   create(context) {
     if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
     const settings = shared.decodeSettings(context.settings);
@@ -472,6 +279,199 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   defaultOptions: []
 });
+var RULE_NAME2 = "no-redundant-custom-hook";
+var no_redundant_custom_hook_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "enforce custom hooks to use at least one other hook inside"
+    },
+    messages: {
+      noRedundantCustomHook: "A custom hook '{{name}}' should use at least one other hook."
+    },
+    schema: []
+  },
+  name: RULE_NAME2,
+  create(context) {
+    const { ctx, listeners } = core.useHookCollector();
+    return {
+      ...listeners,
+      "Program:exit"(node) {
+        const allHooks = ctx.getAllHooks(node);
+        for (const { name: name2, node: node2, hookCalls } of allHooks.values()) {
+          if (ast.isEmptyFunction(node2)) continue;
+          if (hookCalls.length > 0) continue;
+          context.report({
+            messageId: "noRedundantCustomHook",
+            node: node2,
+            data: {
+              name: name2.value
+            }
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME3 = "no-unnecessary-use-callback";
+var no_unnecessary_use_callback_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow unnecessary usage of 'useCallback'"
+    },
+    messages: {
+      noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
+    },
+    schema: []
+  },
+  name: RULE_NAME3,
+  create(context) {
+    if (!context.sourceCode.text.includes("use")) return {};
+    const alias = shared.decodeSettings(context.settings).additionalHooks?.useCallback ?? [];
+    return {
+      CallExpression(node) {
+        if (!core.isReactHookCall(node)) return;
+        const initialScope = context.sourceCode.getScope(node);
+        if (!core.isUseCallbackCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        const component = scope.block;
+        if (!ast.isFunction(component)) return;
+        const [cb, deps] = node.arguments;
+        if (!deps) {
+          context.report({
+            messageId: "noUnnecessaryUseCallback",
+            node
+          });
+          return;
+        }
+        const hasEmptyDeps = tools.F.pipe(
+          tsPattern.match(deps).with({ type: types.AST_NODE_TYPES.ArrayExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+            return tools.F.pipe(
+              _var.findVariable(n.name, initialScope),
+              tools.O.flatMap(_var.getVariableNode(0)),
+              tools.O.filter(ast.is(types.AST_NODE_TYPES.ArrayExpression))
+            );
+          }).otherwise(tools.O.none),
+          tools.O.exists((x) => x.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
+            messageId: "noUnnecessaryUseCallback",
+            node
+          });
+          return;
+        }
+        const isReferencedToComponentScope = tools.F.pipe(
+          tsPattern.match(cb).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+            if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
+              return tools.O.some(n.body);
+            }
+            return tools.O.some(n);
+          }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+            return tools.F.pipe(
+              _var.findVariable(n.name, initialScope),
+              tools.O.flatMap(_var.getVariableNode(0)),
+              tools.O.filter(ast.isFunction)
+            );
+          }).otherwise(tools.O.none),
+          tools.O.map((n) => context.sourceCode.getScope(n)),
+          tools.O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
+          tools.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
+        );
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "noUnnecessaryUseCallback",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME4 = "no-unnecessary-use-memo";
+var no_unnecessary_use_memo_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow unnecessary usage of 'useMemo'"
+    },
+    messages: {
+      noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
+    },
+    schema: []
+  },
+  name: RULE_NAME4,
+  create(context) {
+    if (!context.sourceCode.text.includes("use")) return {};
+    const alias = shared.decodeSettings(context.settings).additionalHooks?.useMemo ?? [];
+    return {
+      CallExpression(node) {
+        if (!core.isReactHookCall(node)) return;
+        const initialScope = context.sourceCode.getScope(node);
+        if (!core.isUseMemoCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        const component = scope.block;
+        if (!ast.isFunction(component)) return;
+        const [cb, deps] = node.arguments;
+        if (!deps) {
+          context.report({
+            messageId: "noUnnecessaryUseMemo",
+            node
+          });
+          return;
+        }
+        const hasEmptyDeps = tools.F.pipe(
+          tsPattern.match(deps).with({ type: types.AST_NODE_TYPES.ArrayExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+            return tools.F.pipe(
+              _var.findVariable(n.name, initialScope),
+              tools.O.flatMap(_var.getVariableNode(0)),
+              tools.O.filter(ast.is(types.AST_NODE_TYPES.ArrayExpression))
+            );
+          }).otherwise(tools.O.none),
+          tools.O.exists((x) => x.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
+            messageId: "noUnnecessaryUseMemo",
+            node
+          });
+          return;
+        }
+        const isReferencedToComponentScope = tools.F.pipe(
+          tsPattern.match(cb).with({ type: types.AST_NODE_TYPES.ArrowFunctionExpression }, (n) => {
+            if (n.body.type === types.AST_NODE_TYPES.ArrowFunctionExpression) {
+              return tools.O.some(n.body);
+            }
+            return tools.O.some(n);
+          }).with({ type: types.AST_NODE_TYPES.FunctionExpression }, tools.O.some).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
+            return tools.F.pipe(
+              _var.findVariable(n.name, initialScope),
+              tools.O.flatMap(_var.getVariableNode(0)),
+              tools.O.filter(ast.isFunction)
+            );
+          }).otherwise(tools.O.none),
+          tools.O.map((n) => context.sourceCode.getScope(n)),
+          tools.O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
+          tools.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
+        );
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "noUnnecessaryUseMemo",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: []
+});
 var RULE_NAME5 = "prefer-use-state-lazy-initialization";
 var ALLOW_LIST = ["Boolean", "String", "Number"];
 var prefer_use_state_lazy_initialization_default = createRule({
@@ -516,13 +516,18 @@ var meta = {
   version
 };
 var rules = {
-  "ensure-custom-hooks-using-other-hooks": ensure_custom_hooks_using_other_hooks_default,
-  "ensure-use-callback-has-non-empty-deps": ensure_use_callback_has_non_empty_deps_default,
-  "ensure-use-memo-has-non-empty-deps": ensure_use_memo_has_non_empty_deps_default,
   "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
+  "no-redundant-custom-hook": no_redundant_custom_hook_default,
+  "no-unnecessary-use-callback": no_unnecessary_use_callback_default,
+  "no-unnecessary-use-memo": no_unnecessary_use_memo_default,
+  "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default,
+  // Deprecated Rules
+  /** @deprecated Use `no-redundant-custom-hook` instead */
+  "ensure-custom-hooks-using-other-hooks": no_redundant_custom_hook_default,
+  /** @deprecated Use `no-unnecessary-use-memo` instead */
+  "ensure-use-memo-has-non-empty-deps": no_unnecessary_use_memo_default,
   /** @deprecated Use `no-direct-set-state-in-use-effect` instead */
-  "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_effect_default,
-  "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_effect_default
 };
 
 exports.meta = meta;

package/dist/index.mjs

@@ -1,15 +1,15 @@
-import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isReactHookCallWithNameAlias, isUseStateCall, isReactHookName } from '@eslint-react/core';
+import { traverseUpGuard, isFunction, getNestedIdentifiers, toReadableNodeName, isEmptyFunction, is, getNestedCallExpressions, isFunctionOfImmediatelyInvoked } from '@eslint-react/ast';
+import { isReactHookCallWithNameAlias, useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall, isReactHookName } from '@eslint-react/core';
 import { createRuleForPlugin, decodeSettings } from '@eslint-react/shared';
-import { isFunction, is, traverseUpGuard, getNestedIdentifiers, toReadableNodeName, getNestedCallExpressions, isFunctionOfImmediatelyInvoked } from '@eslint-react/ast';
-import { F, O, MutRef } from '@eslint-react/tools';
+import { MutRef, O, F } from '@eslint-react/tools';
 import { findVariable, getVariableNode } from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
-import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
 import { match, isMatching } from 'ts-pattern';
+import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.12.5-next.6";
+var version = "1.13.0-beta.1";
 var createRule = createRuleForPlugin("hooks-extra");
 function isFromHookCall(name2, context, settings, predicate = F.constTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
@@ -90,201 +90,8 @@ function isVariableDeclaratorFromHookCall(node) {
   }
 }
 
-// src/rules/ensure-custom-hooks-using-other-hooks.ts
-var RULE_NAME = "ensure-custom-hooks-using-other-hooks";
-var ensure_custom_hooks_using_other_hooks_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce custom hooks using other hooks"
-    },
-    messages: {
-      ensureCustomHooksUsingOtherHooks: "A custom hook '{{name}}' should use other hooks."
-    },
-    schema: []
-  },
-  name: RULE_NAME,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) return {};
-    const { ctx, listeners } = useHookCollector();
-    return {
-      ...listeners,
-      "Program:exit"(node) {
-        const allHooks = ctx.getAllHooks(node);
-        for (const { name: name2, node: node2, hookCalls } of allHooks.values()) {
-          if (hookCalls.length > 0) continue;
-          context.report({
-            messageId: "ensureCustomHooksUsingOtherHooks",
-            node: node2,
-            data: {
-              name: name2.value
-            }
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: []
-});
-var RULE_NAME2 = "ensure-use-callback-has-non-empty-deps";
-var ensure_use_callback_has_non_empty_deps_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce 'useCallback' has non-empty dependencies array"
-    },
-    messages: {
-      ensureUseCallbackHasNonEmptyDeps: "An 'useCallback' should have a non-empty dependencies array."
-    },
-    schema: []
-  },
-  name: RULE_NAME2,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) return {};
-    const alias = decodeSettings(context.settings).additionalHooks?.useCallback ?? [];
-    return {
-      CallExpression(node) {
-        if (!isReactHookCall(node)) return;
-        const initialScope = context.sourceCode.getScope(node);
-        if (!isUseCallbackCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!isFunction(component)) return;
-        const [cb, deps] = node.arguments;
-        if (!deps) {
-          context.report({
-            messageId: "ensureUseCallbackHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const hasEmptyDeps = F.pipe(
-          match(deps).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-            return F.pipe(
-              findVariable(n.name, initialScope),
-              O.flatMap(getVariableNode(0)),
-              O.filter(is(AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(O.none),
-          O.exists((x) => x.elements.length === 0)
-        );
-        if (!hasEmptyDeps) return;
-        if (!cb) {
-          context.report({
-            messageId: "ensureUseCallbackHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const isReferencedToComponentScope = F.pipe(
-          match(cb).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(
-              findVariable(n.name, initialScope),
-              O.flatMap(getVariableNode(0)),
-              O.filter(isFunction)
-            );
-          }).otherwise(O.none),
-          O.map((n) => context.sourceCode.getScope(n)),
-          O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
-          O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
-        if (isReferencedToComponentScope) return;
-        context.report({
-          messageId: "ensureUseCallbackHasNonEmptyDeps",
-          node
-        });
-      }
-    };
-  },
-  defaultOptions: []
-});
-var RULE_NAME3 = "ensure-use-memo-has-non-empty-deps";
-var ensure_use_memo_has_non_empty_deps_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce 'useMemo' has non-empty dependencies array"
-    },
-    messages: {
-      ensureUseMemoHasNonEmptyDeps: "An 'useMemo' should have a non-empty dependencies array."
-    },
-    schema: []
-  },
-  name: RULE_NAME3,
-  create(context) {
-    if (!context.sourceCode.text.includes("use")) return {};
-    const alias = decodeSettings(context.settings).additionalHooks?.useMemo ?? [];
-    return {
-      CallExpression(node) {
-        if (!isReactHookCall(node)) return;
-        const initialScope = context.sourceCode.getScope(node);
-        if (!isUseMemoCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) {
-          return;
-        }
-        const scope = context.sourceCode.getScope(node);
-        const component = scope.block;
-        if (!isFunction(component)) return;
-        const [cb, deps] = node.arguments;
-        if (!deps) {
-          context.report({
-            messageId: "ensureUseMemoHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const hasEmptyDeps = F.pipe(
-          match(deps).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-            return F.pipe(
-              findVariable(n.name, initialScope),
-              O.flatMap(getVariableNode(0)),
-              O.filter(is(AST_NODE_TYPES.ArrayExpression))
-            );
-          }).otherwise(O.none),
-          O.exists((x) => x.elements.length === 0)
-        );
-        if (!hasEmptyDeps) return;
-        if (!cb) {
-          context.report({
-            messageId: "ensureUseMemoHasNonEmptyDeps",
-            node
-          });
-          return;
-        }
-        const isReferencedToComponentScope = F.pipe(
-          match(cb).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(
-              findVariable(n.name, initialScope),
-              O.flatMap(getVariableNode(0)),
-              O.filter(isFunction)
-            );
-          }).otherwise(O.none),
-          O.map((n) => context.sourceCode.getScope(n)),
-          O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
-          O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
-        );
-        if (isReferencedToComponentScope) return;
-        context.report({
-          messageId: "ensureUseMemoHasNonEmptyDeps",
-          node
-        });
-      }
-    };
-  },
-  defaultOptions: []
-});
-var RULE_NAME4 = "no-direct-set-state-in-use-effect";
+// src/rules/no-direct-set-state-in-use-effect.ts
+var RULE_NAME = "no-direct-set-state-in-use-effect";
 var no_direct_set_state_in_use_effect_default = createRule({
   meta: {
     type: "problem",
@@ -296,7 +103,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME4,
+  name: RULE_NAME,
   create(context) {
     if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
     const settings = decodeSettings(context.settings);
@@ -470,6 +277,199 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   defaultOptions: []
 });
+var RULE_NAME2 = "no-redundant-custom-hook";
+var no_redundant_custom_hook_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "enforce custom hooks to use at least one other hook inside"
+    },
+    messages: {
+      noRedundantCustomHook: "A custom hook '{{name}}' should use at least one other hook."
+    },
+    schema: []
+  },
+  name: RULE_NAME2,
+  create(context) {
+    const { ctx, listeners } = useHookCollector();
+    return {
+      ...listeners,
+      "Program:exit"(node) {
+        const allHooks = ctx.getAllHooks(node);
+        for (const { name: name2, node: node2, hookCalls } of allHooks.values()) {
+          if (isEmptyFunction(node2)) continue;
+          if (hookCalls.length > 0) continue;
+          context.report({
+            messageId: "noRedundantCustomHook",
+            node: node2,
+            data: {
+              name: name2.value
+            }
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME3 = "no-unnecessary-use-callback";
+var no_unnecessary_use_callback_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow unnecessary usage of 'useCallback'"
+    },
+    messages: {
+      noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
+    },
+    schema: []
+  },
+  name: RULE_NAME3,
+  create(context) {
+    if (!context.sourceCode.text.includes("use")) return {};
+    const alias = decodeSettings(context.settings).additionalHooks?.useCallback ?? [];
+    return {
+      CallExpression(node) {
+        if (!isReactHookCall(node)) return;
+        const initialScope = context.sourceCode.getScope(node);
+        if (!isUseCallbackCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) {
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        const component = scope.block;
+        if (!isFunction(component)) return;
+        const [cb, deps] = node.arguments;
+        if (!deps) {
+          context.report({
+            messageId: "noUnnecessaryUseCallback",
+            node
+          });
+          return;
+        }
+        const hasEmptyDeps = F.pipe(
+          match(deps).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+            return F.pipe(
+              findVariable(n.name, initialScope),
+              O.flatMap(getVariableNode(0)),
+              O.filter(is(AST_NODE_TYPES.ArrayExpression))
+            );
+          }).otherwise(O.none),
+          O.exists((x) => x.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
+            messageId: "noUnnecessaryUseCallback",
+            node
+          });
+          return;
+        }
+        const isReferencedToComponentScope = F.pipe(
+          match(cb).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(
+              findVariable(n.name, initialScope),
+              O.flatMap(getVariableNode(0)),
+              O.filter(isFunction)
+            );
+          }).otherwise(O.none),
+          O.map((n) => context.sourceCode.getScope(n)),
+          O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
+          O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
+        );
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "noUnnecessaryUseCallback",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME4 = "no-unnecessary-use-memo";
+var no_unnecessary_use_memo_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow unnecessary usage of 'useMemo'"
+    },
+    messages: {
+      noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
+    },
+    schema: []
+  },
+  name: RULE_NAME4,
+  create(context) {
+    if (!context.sourceCode.text.includes("use")) return {};
+    const alias = decodeSettings(context.settings).additionalHooks?.useMemo ?? [];
+    return {
+      CallExpression(node) {
+        if (!isReactHookCall(node)) return;
+        const initialScope = context.sourceCode.getScope(node);
+        if (!isUseMemoCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) {
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        const component = scope.block;
+        if (!isFunction(component)) return;
+        const [cb, deps] = node.arguments;
+        if (!deps) {
+          context.report({
+            messageId: "noUnnecessaryUseMemo",
+            node
+          });
+          return;
+        }
+        const hasEmptyDeps = F.pipe(
+          match(deps).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
+            return F.pipe(
+              findVariable(n.name, initialScope),
+              O.flatMap(getVariableNode(0)),
+              O.filter(is(AST_NODE_TYPES.ArrayExpression))
+            );
+          }).otherwise(O.none),
+          O.exists((x) => x.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
+            messageId: "noUnnecessaryUseMemo",
+            node
+          });
+          return;
+        }
+        const isReferencedToComponentScope = F.pipe(
+          match(cb).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(
+              findVariable(n.name, initialScope),
+              O.flatMap(getVariableNode(0)),
+              O.filter(isFunction)
+            );
+          }).otherwise(O.none),
+          O.map((n) => context.sourceCode.getScope(n)),
+          O.map((s) => [...s.childScopes, s].flatMap((x) => x.references)),
+          O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
+        );
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "noUnnecessaryUseMemo",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: []
+});
 var RULE_NAME5 = "prefer-use-state-lazy-initialization";
 var ALLOW_LIST = ["Boolean", "String", "Number"];
 var prefer_use_state_lazy_initialization_default = createRule({
@@ -514,13 +514,18 @@ var meta = {
   version
 };
 var rules = {
-  "ensure-custom-hooks-using-other-hooks": ensure_custom_hooks_using_other_hooks_default,
-  "ensure-use-callback-has-non-empty-deps": ensure_use_callback_has_non_empty_deps_default,
-  "ensure-use-memo-has-non-empty-deps": ensure_use_memo_has_non_empty_deps_default,
   "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
+  "no-redundant-custom-hook": no_redundant_custom_hook_default,
+  "no-unnecessary-use-callback": no_unnecessary_use_callback_default,
+  "no-unnecessary-use-memo": no_unnecessary_use_memo_default,
+  "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default,
+  // Deprecated Rules
+  /** @deprecated Use `no-redundant-custom-hook` instead */
+  "ensure-custom-hooks-using-other-hooks": no_redundant_custom_hook_default,
+  /** @deprecated Use `no-unnecessary-use-memo` instead */
+  "ensure-use-memo-has-non-empty-deps": no_unnecessary_use_memo_default,
   /** @deprecated Use `no-direct-set-state-in-use-effect` instead */
-  "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_effect_default,
-  "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_effect_default
 };
 
 export { meta, rules };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.12.5-next.6",
+  "version": "1.13.0-beta.1",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "eslint",
@@ -46,13 +46,13 @@
     "@typescript-eslint/types": "^8.4.0",
     "@typescript-eslint/utils": "^8.4.0",
     "ts-pattern": "^5.3.1",
-    "@eslint-react/ast": "1.12.5-next.6",
-    "@eslint-react/core": "1.12.5-next.6",
-    "@eslint-react/jsx": "1.12.5-next.6",
-    "@eslint-react/tools": "1.12.5-next.6",
-    "@eslint-react/shared": "1.12.5-next.6",
-    "@eslint-react/types": "1.12.5-next.6",
-    "@eslint-react/var": "1.12.5-next.6"
+    "@eslint-react/ast": "1.13.0-beta.1",
+    "@eslint-react/core": "1.13.0-beta.1",
+    "@eslint-react/jsx": "1.13.0-beta.1",
+    "@eslint-react/tools": "1.13.0-beta.1",
+    "@eslint-react/shared": "1.13.0-beta.1",
+    "@eslint-react/var": "1.13.0-beta.1",
+    "@eslint-react/types": "1.13.0-beta.1"
   },
   "devDependencies": {
     "@types/react": "^18.3.5",