eslint-plugin-react-hooks-extra 1.6.1-next.1 → 1.6.1-next.3

package/dist/index.js

@@ -9,44 +9,22 @@ var astUtils = require('@typescript-eslint/utils/ast-utils');
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.6.1-next.1";
+var version = "1.6.1-next.3";
 var createRule = shared.createRuleForPlugin("hooks-extra");
-
-// 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: {
-      ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS: "A custom hook '{{name}}' should use other hooks."
-    },
-    schema: []
-  },
-  name: RULE_NAME,
-  create(context) {
-    const { ctx, listeners } = core.useHookCollector();
-    return {
-      ...listeners,
-      "Program:exit"(node) {
-        const allHooks = ctx.getAllHooks(node);
-        for (const { name: name2, hookCalls, node: node2 } of allHooks.values()) {
-          if (hookCalls.length > 0) continue;
-          context.report({
-            data: {
-              name: name2.value
-            },
-            messageId: "ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS",
-            node: node2
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: []
-});
+function isFromUseStateCall(context, useStateAlias) {
+  return (topLevelId) => {
+    const useStateCall = tools.F.pipe(
+      _var.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
+      tools.O.flatMap(_var.getVariableNode(0)),
+      tools.O.filter(ast.is(ast.NodeType.CallExpression)),
+      tools.O.filter(core.isReactHookCallWithNameAlias("useState", context, useStateAlias))
+    );
+    if (tools.O.isNone(useStateCall)) return false;
+    const { parent } = useStateCall.value;
+    if (!("id" in parent && parent.id?.type === ast.NodeType.ArrayPattern)) return true;
+    return parent.id.elements.findIndex((e2) => e2?.type === ast.NodeType.Identifier && e2.name === topLevelId.name) === 1;
+  };
+}
 
 // ../../../node_modules/.pnpm/ts-pattern@5.2.0/node_modules/ts-pattern/dist/index.js
 var t = Symbol.for("@ts-pattern/matcher");
@@ -231,7 +209,74 @@ var z = class _z {
   }
 };
 
-// src/rules/ensure-use-callback-has-non-empty-deps.ts
+// src/utils/is-set-state-call.ts
+function isSetStateCall(context, useStateAlias) {
+  return (node) => {
+    const topLevelId = $(node.callee).with({ type: ast.NodeType.Identifier }, tools.O.some).with({ type: ast.NodeType.MemberExpression }, (n2) => {
+      if (!("name" in n2.object)) return tools.O.none();
+      const initialScope = context.sourceCode.getScope(n2);
+      const property = astUtils.getStaticValue(n2.property, initialScope);
+      if (property?.value === 1) return tools.O.fromNullable(n2.object);
+      return tools.O.none();
+    }).with({ type: ast.NodeType.CallExpression }, (n2) => {
+      if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
+      if (!("name" in n2.callee.object)) return tools.O.none();
+      const isAt = a({
+        type: ast.NodeType.MemberExpression,
+        property: {
+          type: ast.NodeType.Identifier,
+          name: "at"
+        }
+      }, n2.callee);
+      const [index] = n2.arguments;
+      if (!isAt || !index) return tools.O.none();
+      const initialScope = context.sourceCode.getScope(n2);
+      const value = astUtils.getStaticValue(index, initialScope);
+      if (value?.value === 1) return tools.O.fromNullable(n2.callee.object);
+      return tools.O.none();
+    }).otherwise(tools.O.none);
+    return tools.O.exists(topLevelId, isFromUseStateCall(context, useStateAlias));
+  };
+}
+function isThenCall(node) {
+  return node.callee.type === ast.NodeType.MemberExpression && node.callee.property.type === ast.NodeType.Identifier && node.callee.property.name === "then";
+}
+
+// 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: {
+      ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS: "A custom hook '{{name}}' should use other hooks."
+    },
+    schema: []
+  },
+  name: RULE_NAME,
+  create(context) {
+    const { ctx, listeners } = core.useHookCollector();
+    return {
+      ...listeners,
+      "Program:exit"(node) {
+        const allHooks = ctx.getAllHooks(node);
+        for (const { name: name2, hookCalls, node: node2 } of allHooks.values()) {
+          if (hookCalls.length > 0) continue;
+          context.report({
+            data: {
+              name: name2.value
+            },
+            messageId: "ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS",
+            node: node2
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: []
+});
 var RULE_NAME2 = "ensure-use-callback-has-non-empty-deps";
 var ensure_use_callback_has_non_empty_deps_default = createRule({
   meta: {
@@ -251,7 +296,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
       CallExpression(node) {
         if (!core.isReactHookCall(node)) return;
         const initialScope = context.sourceCode.getScope(node);
-        if (!core.isUseCallbackCall(node, context) && !alias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node))) {
+        if (!core.isUseCallbackCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
@@ -329,7 +374,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
       CallExpression(node) {
         if (!core.isReactHookCall(node)) return;
         const initialScope = context.sourceCode.getScope(node);
-        if (!core.isUseMemoCall(node, context) && !alias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node))) {
+        if (!core.isUseMemoCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
@@ -389,6 +434,15 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
   defaultOptions: []
 });
 var RULE_NAME4 = "no-direct-set-state-in-use-effect";
+function isEffectFunction(context, useSomeEffectAlias) {
+  return (node) => node.parent?.type === ast.NodeType.CallExpression && node.parent.callee !== node && core.isReactHookCallWithNameAlias("useEffect", context, useSomeEffectAlias)(node.parent);
+}
+function getCallKind(node, context, useStateAlias, useEffectAlias) {
+  return $(node).when(isThenCall, () => "then").when(isSetStateCall(context, useStateAlias), () => "setState").when(core.isReactHookCallWithNameAlias("useState", context, useStateAlias), () => "useState").when(core.isReactHookCallWithNameAlias("useEffect", context, useEffectAlias), () => "useEffect").otherwise(() => "other");
+}
+function getFunctionKind(node, context, useEffectAlias) {
+  return $(node).when(isEffectFunction(context, useEffectAlias), () => "effect").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
+}
 var no_direct_set_state_in_use_effect_default = createRule({
   meta: {
     type: "problem",
@@ -404,68 +458,6 @@ var no_direct_set_state_in_use_effect_default = createRule({
   create(context) {
     const settings = shared.decodeSettings(context.settings);
     const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseEffectCallWithAlias(node) {
-      return core.isUseEffectCall(node, context) || useEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
-    }
-    function isUseStateCallWithAlias(node) {
-      return core.isUseStateCall(node, context) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
-    }
-    function isEffectFunction(node) {
-      return node.parent?.type === ast.NodeType.CallExpression && node.parent.callee !== node && isUseEffectCallWithAlias(node.parent);
-    }
-    function isCleanUpFunction(_2) {
-    }
-    function isFromUseStateCall(topLevelId) {
-      const useStateCall = tools.F.pipe(
-        _var.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-        tools.O.flatMap(_var.getVariableNode(0)),
-        tools.O.filter(ast.is(ast.NodeType.CallExpression)),
-        tools.O.filter(isUseStateCallWithAlias)
-      );
-      if (tools.O.isNone(useStateCall)) return false;
-      const { parent } = useStateCall.value;
-      if (!a({ id: { type: ast.NodeType.ArrayPattern }, type: ast.NodeType.VariableDeclarator }, parent)) return true;
-      return parent.id.elements.findIndex((e2) => e2?.type === ast.NodeType.Identifier && e2.name === topLevelId.name) === 1;
-    }
-    function isSetStateCall(node) {
-      const topLevelId = $(node.callee).with({ type: ast.NodeType.Identifier }, tools.O.some).with({ type: ast.NodeType.MemberExpression }, (n2) => {
-        if (!("name" in n2.object)) return tools.O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const property = astUtils.getStaticValue(n2.property, initialScope);
-        if (property?.value === 1) return tools.O.fromNullable(n2.object);
-        return tools.O.none();
-      }).with({ type: ast.NodeType.CallExpression }, (n2) => {
-        if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
-        if (!("name" in n2.callee.object)) return tools.O.none();
-        const isAt = a({
-          type: ast.NodeType.MemberExpression,
-          property: {
-            type: ast.NodeType.Identifier,
-            name: "at"
-          }
-        }, n2.callee);
-        const [index] = n2.arguments;
-        if (!isAt || !index) return tools.O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const value = astUtils.getStaticValue(index, initialScope);
-        if (value?.value === 1) return tools.O.fromNullable(n2.callee.object);
-        return tools.O.none();
-      }).otherwise(tools.O.none);
-      return tools.O.exists(topLevelId, isFromUseStateCall);
-    }
-    function isThenCall(node) {
-      if (node.callee.type !== ast.NodeType.MemberExpression) return false;
-      return a({
-        type: ast.NodeType.Identifier,
-        name: "then"
-      }, node.callee.property);
-    }
-    function getCallKind(node) {
-      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseEffectCallWithAlias, () => "useEffect").otherwise(() => "other");
-    }
-    function getFunctionKind(node) {
-      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
-    }
     const functionStack = tools.MutList.make();
     const effectFunctionRef = tools.MutRef.make(null);
     const effectFunctionIdentifiers = [];
@@ -479,7 +471,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
     };
     return {
       ":function"(node) {
-        const functionKind = getFunctionKind(node);
+        const functionKind = getFunctionKind(node, context, useEffectAlias);
         tools.MutList.append(functionStack, [node, functionKind]);
         $(functionKind).with("effect", () => {
           onEffectFunctionEnter(node);
@@ -493,7 +485,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
         const effectFn = tools.MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = tools.MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
-        const callKind = getCallKind(node);
+        const callKind = getCallKind(node, context, useStateAlias, useEffectAlias);
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
@@ -553,6 +545,15 @@ var no_direct_set_state_in_use_effect_default = createRule({
   defaultOptions: []
 });
 var RULE_NAME5 = "no-direct-set-state-in-use-layout-effect";
+function isLayoutEffectFunction(context, useSomeEffectAlias) {
+  return (node) => node.parent?.type === ast.NodeType.CallExpression && node.parent.callee !== node && core.isReactHookCallWithNameAlias("useLayoutEffect", context, useSomeEffectAlias)(node.parent);
+}
+function getCallKind2(node, context, useStateAlias, useLayoutEffectAlias) {
+  return $(node).when(isThenCall, () => "then").when(isSetStateCall(context, useStateAlias), () => "setState").when(core.isReactHookCallWithNameAlias("useState", context, useStateAlias), () => "useState").when(core.isReactHookCallWithNameAlias("useLayoutEffect", context, useLayoutEffectAlias), () => "useLayoutEffect").otherwise(() => "other");
+}
+function getFunctionKind2(node, context, useLayoutEffectAlias) {
+  return $(node).when(isLayoutEffectFunction(context, useLayoutEffectAlias), () => "effect").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
+}
 var no_direct_set_state_in_use_layout_effect_default = createRule({
   meta: {
     type: "problem",
@@ -568,68 +569,6 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   create(context) {
     const settings = shared.decodeSettings(context.settings);
     const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseLayoutEffectCallWithAlias(node) {
-      return core.isUseLayoutEffectCall(node, context) || useLayoutEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
-    }
-    function isUseStateCallWithAlias(node) {
-      return core.isUseStateCall(node, context) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
-    }
-    function isEffectFunction(node) {
-      return node.parent?.type === ast.NodeType.CallExpression && node.parent.callee !== node && isUseLayoutEffectCallWithAlias(node.parent);
-    }
-    function isCleanUpFunction(_2) {
-    }
-    function isFromUseStateCall(topLevelId) {
-      const useStateCall = tools.F.pipe(
-        _var.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-        tools.O.flatMap(_var.getVariableNode(0)),
-        tools.O.filter(ast.is(ast.NodeType.CallExpression)),
-        tools.O.filter(isUseStateCallWithAlias)
-      );
-      if (tools.O.isNone(useStateCall)) return false;
-      const { parent } = useStateCall.value;
-      if (!a({ id: { type: ast.NodeType.ArrayPattern }, type: ast.NodeType.VariableDeclarator }, parent)) return true;
-      return parent.id.elements.findIndex((e2) => e2?.type === ast.NodeType.Identifier && e2.name === topLevelId.name) === 1;
-    }
-    function isSetStateCall(node) {
-      const topLevelId = $(node.callee).with({ type: ast.NodeType.Identifier }, tools.O.some).with({ type: ast.NodeType.MemberExpression }, (n2) => {
-        if (!("name" in n2.object)) return tools.O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const property = astUtils.getStaticValue(n2.property, initialScope);
-        if (property?.value === 1) return tools.O.fromNullable(n2.object);
-        return tools.O.none();
-      }).with({ type: ast.NodeType.CallExpression }, (n2) => {
-        if (!ast.is(ast.NodeType.MemberExpression)(n2.callee)) return tools.O.none();
-        if (!("name" in n2.callee.object)) return tools.O.none();
-        const isAt = a({
-          type: ast.NodeType.MemberExpression,
-          property: {
-            type: ast.NodeType.Identifier,
-            name: "at"
-          }
-        }, n2.callee);
-        const [index] = n2.arguments;
-        if (!isAt || !index) return tools.O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const value = astUtils.getStaticValue(index, initialScope);
-        if (value?.value === 1) return tools.O.fromNullable(n2.callee.object);
-        return tools.O.none();
-      }).otherwise(tools.O.none);
-      return tools.O.exists(topLevelId, isFromUseStateCall);
-    }
-    function isThenCall(node) {
-      if (node.callee.type !== ast.NodeType.MemberExpression) return false;
-      return a({
-        type: ast.NodeType.Identifier,
-        name: "then"
-      }, node.callee.property);
-    }
-    function getCallKind(node) {
-      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseLayoutEffectCallWithAlias, () => "useLayoutEffect").otherwise(() => "other");
-    }
-    function getFunctionKind(node) {
-      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(ast.isIIFE, () => "immediate").otherwise(() => "other");
-    }
     const functionStack = tools.MutList.make();
     const effectFunctionRef = tools.MutRef.make(null);
     const effectFunctionIdentifiers = [];
@@ -643,7 +582,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     };
     return {
       ":function"(node) {
-        const functionKind = getFunctionKind(node);
+        const functionKind = getFunctionKind2(node, context, useLayoutEffectAlias);
         tools.MutList.append(functionStack, [node, functionKind]);
         $(functionKind).with("effect", () => {
           onEffectFunctionEnter(node);
@@ -657,7 +596,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
         const effectFn = tools.MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = tools.MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
-        const callKind = getCallKind(node);
+        const callKind = getCallKind2(node, context, useStateAlias, useLayoutEffectAlias);
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
@@ -735,7 +674,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     return {
       CallExpression(node) {
         if (!core.isReactHookCall(node)) return;
-        if (!core.isUseStateCall(node, context) && !alias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node))) return;
+        if (!core.isUseStateCall(node, context) && !alias.some(core.isReactHookCallWithNameLoose(node))) return;
         const [useStateInput] = node.arguments;
         if (!useStateInput) return;
         const nestedCallExpressions = ast.getNestedCallExpressions(useStateInput);

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall, isUseEffectCall, isUseLayoutEffectCall } from '@eslint-react/core';
+import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall, isReactHookCallWithNameAlias } from '@eslint-react/core';
 import { createRuleForPlugin, decodeSettings } from '@eslint-react/shared';
 import { isFunction, NodeType, is, getNestedIdentifiers, getNestedCallExpressions, isIIFE } from '@eslint-react/ast';
 import { F, O, MutList, MutRef } from '@eslint-react/tools';
@@ -7,44 +7,22 @@ import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.6.1-next.1";
+var version = "1.6.1-next.3";
 var createRule = createRuleForPlugin("hooks-extra");
-
-// 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: {
-      ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS: "A custom hook '{{name}}' should use other hooks."
-    },
-    schema: []
-  },
-  name: RULE_NAME,
-  create(context) {
-    const { ctx, listeners } = useHookCollector();
-    return {
-      ...listeners,
-      "Program:exit"(node) {
-        const allHooks = ctx.getAllHooks(node);
-        for (const { name: name2, hookCalls, node: node2 } of allHooks.values()) {
-          if (hookCalls.length > 0) continue;
-          context.report({
-            data: {
-              name: name2.value
-            },
-            messageId: "ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS",
-            node: node2
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: []
-});
+function isFromUseStateCall(context, useStateAlias) {
+  return (topLevelId) => {
+    const useStateCall = F.pipe(
+      findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
+      O.flatMap(getVariableNode(0)),
+      O.filter(is(NodeType.CallExpression)),
+      O.filter(isReactHookCallWithNameAlias("useState", context, useStateAlias))
+    );
+    if (O.isNone(useStateCall)) return false;
+    const { parent } = useStateCall.value;
+    if (!("id" in parent && parent.id?.type === NodeType.ArrayPattern)) return true;
+    return parent.id.elements.findIndex((e2) => e2?.type === NodeType.Identifier && e2.name === topLevelId.name) === 1;
+  };
+}
 
 // ../../../node_modules/.pnpm/ts-pattern@5.2.0/node_modules/ts-pattern/dist/index.js
 var t = Symbol.for("@ts-pattern/matcher");
@@ -229,7 +207,74 @@ var z = class _z {
   }
 };
 
-// src/rules/ensure-use-callback-has-non-empty-deps.ts
+// src/utils/is-set-state-call.ts
+function isSetStateCall(context, useStateAlias) {
+  return (node) => {
+    const topLevelId = $(node.callee).with({ type: NodeType.Identifier }, O.some).with({ type: NodeType.MemberExpression }, (n2) => {
+      if (!("name" in n2.object)) return O.none();
+      const initialScope = context.sourceCode.getScope(n2);
+      const property = getStaticValue(n2.property, initialScope);
+      if (property?.value === 1) return O.fromNullable(n2.object);
+      return O.none();
+    }).with({ type: NodeType.CallExpression }, (n2) => {
+      if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
+      if (!("name" in n2.callee.object)) return O.none();
+      const isAt = a({
+        type: NodeType.MemberExpression,
+        property: {
+          type: NodeType.Identifier,
+          name: "at"
+        }
+      }, n2.callee);
+      const [index] = n2.arguments;
+      if (!isAt || !index) return O.none();
+      const initialScope = context.sourceCode.getScope(n2);
+      const value = getStaticValue(index, initialScope);
+      if (value?.value === 1) return O.fromNullable(n2.callee.object);
+      return O.none();
+    }).otherwise(O.none);
+    return O.exists(topLevelId, isFromUseStateCall(context, useStateAlias));
+  };
+}
+function isThenCall(node) {
+  return node.callee.type === NodeType.MemberExpression && node.callee.property.type === NodeType.Identifier && node.callee.property.name === "then";
+}
+
+// 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: {
+      ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS: "A custom hook '{{name}}' should use other hooks."
+    },
+    schema: []
+  },
+  name: RULE_NAME,
+  create(context) {
+    const { ctx, listeners } = useHookCollector();
+    return {
+      ...listeners,
+      "Program:exit"(node) {
+        const allHooks = ctx.getAllHooks(node);
+        for (const { name: name2, hookCalls, node: node2 } of allHooks.values()) {
+          if (hookCalls.length > 0) continue;
+          context.report({
+            data: {
+              name: name2.value
+            },
+            messageId: "ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS",
+            node: node2
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: []
+});
 var RULE_NAME2 = "ensure-use-callback-has-non-empty-deps";
 var ensure_use_callback_has_non_empty_deps_default = createRule({
   meta: {
@@ -249,7 +294,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
       CallExpression(node) {
         if (!isReactHookCall(node)) return;
         const initialScope = context.sourceCode.getScope(node);
-        if (!isUseCallbackCall(node, context) && !alias.some(F.flip(isReactHookCallWithNameLoose)(node))) {
+        if (!isUseCallbackCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
@@ -327,7 +372,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
       CallExpression(node) {
         if (!isReactHookCall(node)) return;
         const initialScope = context.sourceCode.getScope(node);
-        if (!isUseMemoCall(node, context) && !alias.some(F.flip(isReactHookCallWithNameLoose)(node))) {
+        if (!isUseMemoCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
@@ -387,6 +432,15 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
   defaultOptions: []
 });
 var RULE_NAME4 = "no-direct-set-state-in-use-effect";
+function isEffectFunction(context, useSomeEffectAlias) {
+  return (node) => node.parent?.type === NodeType.CallExpression && node.parent.callee !== node && isReactHookCallWithNameAlias("useEffect", context, useSomeEffectAlias)(node.parent);
+}
+function getCallKind(node, context, useStateAlias, useEffectAlias) {
+  return $(node).when(isThenCall, () => "then").when(isSetStateCall(context, useStateAlias), () => "setState").when(isReactHookCallWithNameAlias("useState", context, useStateAlias), () => "useState").when(isReactHookCallWithNameAlias("useEffect", context, useEffectAlias), () => "useEffect").otherwise(() => "other");
+}
+function getFunctionKind(node, context, useEffectAlias) {
+  return $(node).when(isEffectFunction(context, useEffectAlias), () => "effect").when(isIIFE, () => "immediate").otherwise(() => "other");
+}
 var no_direct_set_state_in_use_effect_default = createRule({
   meta: {
     type: "problem",
@@ -402,68 +456,6 @@ var no_direct_set_state_in_use_effect_default = createRule({
   create(context) {
     const settings = decodeSettings(context.settings);
     const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseEffectCallWithAlias(node) {
-      return isUseEffectCall(node, context) || useEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
-    }
-    function isUseStateCallWithAlias(node) {
-      return isUseStateCall(node, context) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
-    }
-    function isEffectFunction(node) {
-      return node.parent?.type === NodeType.CallExpression && node.parent.callee !== node && isUseEffectCallWithAlias(node.parent);
-    }
-    function isCleanUpFunction(_2) {
-    }
-    function isFromUseStateCall(topLevelId) {
-      const useStateCall = F.pipe(
-        findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-        O.flatMap(getVariableNode(0)),
-        O.filter(is(NodeType.CallExpression)),
-        O.filter(isUseStateCallWithAlias)
-      );
-      if (O.isNone(useStateCall)) return false;
-      const { parent } = useStateCall.value;
-      if (!a({ id: { type: NodeType.ArrayPattern }, type: NodeType.VariableDeclarator }, parent)) return true;
-      return parent.id.elements.findIndex((e2) => e2?.type === NodeType.Identifier && e2.name === topLevelId.name) === 1;
-    }
-    function isSetStateCall(node) {
-      const topLevelId = $(node.callee).with({ type: NodeType.Identifier }, O.some).with({ type: NodeType.MemberExpression }, (n2) => {
-        if (!("name" in n2.object)) return O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const property = getStaticValue(n2.property, initialScope);
-        if (property?.value === 1) return O.fromNullable(n2.object);
-        return O.none();
-      }).with({ type: NodeType.CallExpression }, (n2) => {
-        if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
-        if (!("name" in n2.callee.object)) return O.none();
-        const isAt = a({
-          type: NodeType.MemberExpression,
-          property: {
-            type: NodeType.Identifier,
-            name: "at"
-          }
-        }, n2.callee);
-        const [index] = n2.arguments;
-        if (!isAt || !index) return O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const value = getStaticValue(index, initialScope);
-        if (value?.value === 1) return O.fromNullable(n2.callee.object);
-        return O.none();
-      }).otherwise(O.none);
-      return O.exists(topLevelId, isFromUseStateCall);
-    }
-    function isThenCall(node) {
-      if (node.callee.type !== NodeType.MemberExpression) return false;
-      return a({
-        type: NodeType.Identifier,
-        name: "then"
-      }, node.callee.property);
-    }
-    function getCallKind(node) {
-      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseEffectCallWithAlias, () => "useEffect").otherwise(() => "other");
-    }
-    function getFunctionKind(node) {
-      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(isIIFE, () => "immediate").otherwise(() => "other");
-    }
     const functionStack = MutList.make();
     const effectFunctionRef = MutRef.make(null);
     const effectFunctionIdentifiers = [];
@@ -477,7 +469,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
     };
     return {
       ":function"(node) {
-        const functionKind = getFunctionKind(node);
+        const functionKind = getFunctionKind(node, context, useEffectAlias);
         MutList.append(functionStack, [node, functionKind]);
         $(functionKind).with("effect", () => {
           onEffectFunctionEnter(node);
@@ -491,7 +483,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
         const effectFn = MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
-        const callKind = getCallKind(node);
+        const callKind = getCallKind(node, context, useStateAlias, useEffectAlias);
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
@@ -551,6 +543,15 @@ var no_direct_set_state_in_use_effect_default = createRule({
   defaultOptions: []
 });
 var RULE_NAME5 = "no-direct-set-state-in-use-layout-effect";
+function isLayoutEffectFunction(context, useSomeEffectAlias) {
+  return (node) => node.parent?.type === NodeType.CallExpression && node.parent.callee !== node && isReactHookCallWithNameAlias("useLayoutEffect", context, useSomeEffectAlias)(node.parent);
+}
+function getCallKind2(node, context, useStateAlias, useLayoutEffectAlias) {
+  return $(node).when(isThenCall, () => "then").when(isSetStateCall(context, useStateAlias), () => "setState").when(isReactHookCallWithNameAlias("useState", context, useStateAlias), () => "useState").when(isReactHookCallWithNameAlias("useLayoutEffect", context, useLayoutEffectAlias), () => "useLayoutEffect").otherwise(() => "other");
+}
+function getFunctionKind2(node, context, useLayoutEffectAlias) {
+  return $(node).when(isLayoutEffectFunction(context, useLayoutEffectAlias), () => "effect").when(isIIFE, () => "immediate").otherwise(() => "other");
+}
 var no_direct_set_state_in_use_layout_effect_default = createRule({
   meta: {
     type: "problem",
@@ -566,68 +567,6 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
   create(context) {
     const settings = decodeSettings(context.settings);
     const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
-    function isUseLayoutEffectCallWithAlias(node) {
-      return isUseLayoutEffectCall(node, context) || useLayoutEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
-    }
-    function isUseStateCallWithAlias(node) {
-      return isUseStateCall(node, context) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
-    }
-    function isEffectFunction(node) {
-      return node.parent?.type === NodeType.CallExpression && node.parent.callee !== node && isUseLayoutEffectCallWithAlias(node.parent);
-    }
-    function isCleanUpFunction(_2) {
-    }
-    function isFromUseStateCall(topLevelId) {
-      const useStateCall = F.pipe(
-        findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-        O.flatMap(getVariableNode(0)),
-        O.filter(is(NodeType.CallExpression)),
-        O.filter(isUseStateCallWithAlias)
-      );
-      if (O.isNone(useStateCall)) return false;
-      const { parent } = useStateCall.value;
-      if (!a({ id: { type: NodeType.ArrayPattern }, type: NodeType.VariableDeclarator }, parent)) return true;
-      return parent.id.elements.findIndex((e2) => e2?.type === NodeType.Identifier && e2.name === topLevelId.name) === 1;
-    }
-    function isSetStateCall(node) {
-      const topLevelId = $(node.callee).with({ type: NodeType.Identifier }, O.some).with({ type: NodeType.MemberExpression }, (n2) => {
-        if (!("name" in n2.object)) return O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const property = getStaticValue(n2.property, initialScope);
-        if (property?.value === 1) return O.fromNullable(n2.object);
-        return O.none();
-      }).with({ type: NodeType.CallExpression }, (n2) => {
-        if (!is(NodeType.MemberExpression)(n2.callee)) return O.none();
-        if (!("name" in n2.callee.object)) return O.none();
-        const isAt = a({
-          type: NodeType.MemberExpression,
-          property: {
-            type: NodeType.Identifier,
-            name: "at"
-          }
-        }, n2.callee);
-        const [index] = n2.arguments;
-        if (!isAt || !index) return O.none();
-        const initialScope = context.sourceCode.getScope(n2);
-        const value = getStaticValue(index, initialScope);
-        if (value?.value === 1) return O.fromNullable(n2.callee.object);
-        return O.none();
-      }).otherwise(O.none);
-      return O.exists(topLevelId, isFromUseStateCall);
-    }
-    function isThenCall(node) {
-      if (node.callee.type !== NodeType.MemberExpression) return false;
-      return a({
-        type: NodeType.Identifier,
-        name: "then"
-      }, node.callee.property);
-    }
-    function getCallKind(node) {
-      return $(node).when(isThenCall, () => "then").when(isSetStateCall, () => "setState").when(isUseStateCallWithAlias, () => "useState").when(isUseLayoutEffectCallWithAlias, () => "useLayoutEffect").otherwise(() => "other");
-    }
-    function getFunctionKind(node) {
-      return $(node).when(isEffectFunction, () => "effect").when(isCleanUpFunction, () => "cleanup").when(isIIFE, () => "immediate").otherwise(() => "other");
-    }
     const functionStack = MutList.make();
     const effectFunctionRef = MutRef.make(null);
     const effectFunctionIdentifiers = [];
@@ -641,7 +580,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     };
     return {
       ":function"(node) {
-        const functionKind = getFunctionKind(node);
+        const functionKind = getFunctionKind2(node, context, useLayoutEffectAlias);
         MutList.append(functionStack, [node, functionKind]);
         $(functionKind).with("effect", () => {
           onEffectFunctionEnter(node);
@@ -655,7 +594,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
         const effectFn = MutRef.get(effectFunctionRef);
         const [parentFn, parentFnKind] = MutList.tail(functionStack) ?? [];
         if (parentFn?.async) return;
-        const callKind = getCallKind(node);
+        const callKind = getCallKind2(node, context, useStateAlias, useLayoutEffectAlias);
         $(callKind).with("setState", () => {
           if (!parentFn) return;
           if (parentFn !== effectFn && parentFnKind !== "immediate") {
@@ -733,7 +672,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     return {
       CallExpression(node) {
         if (!isReactHookCall(node)) return;
-        if (!isUseStateCall(node, context) && !alias.some(F.flip(isReactHookCallWithNameLoose)(node))) return;
+        if (!isUseStateCall(node, context) && !alias.some(isReactHookCallWithNameLoose(node))) return;
         const [useStateInput] = node.arguments;
         if (!useStateInput) return;
         const nestedCallExpressions = getNestedCallExpressions(useStateInput);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.6.1-next.1",
+  "version": "1.6.1-next.3",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "homepage": "https://github.com/rel1cx/eslint-react",
   "bugs": {
@@ -39,13 +39,13 @@
     "@typescript-eslint/type-utils": "^7.17.0",
     "@typescript-eslint/types": "^7.17.0",
     "@typescript-eslint/utils": "^7.17.0",
-    "@eslint-react/ast": "1.6.1-next.1",
-    "@eslint-react/jsx": "1.6.1-next.1",
-    "@eslint-react/core": "1.6.1-next.1",
-    "@eslint-react/types": "1.6.1-next.1",
-    "@eslint-react/var": "1.6.1-next.1",
-    "@eslint-react/shared": "1.6.1-next.1",
-    "@eslint-react/tools": "1.6.1-next.1"
+    "@eslint-react/ast": "1.6.1-next.3",
+    "@eslint-react/core": "1.6.1-next.3",
+    "@eslint-react/jsx": "1.6.1-next.3",
+    "@eslint-react/shared": "1.6.1-next.3",
+    "@eslint-react/types": "1.6.1-next.3",
+    "@eslint-react/tools": "1.6.1-next.3",
+    "@eslint-react/var": "1.6.1-next.3"
   },
   "devDependencies": {
     "@types/react": "^18.3.3",