eslint-plugin-react-hooks-extra 1.14.3 → 1.15.0-beta.11

package/dist/index.d.mts

@@ -7,6 +7,7 @@ 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-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>;
@@ -15,8 +16,6 @@ declare const _default: {
         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>;
     };
 };
 

package/dist/index.d.ts

@@ -7,6 +7,7 @@ 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-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>;
@@ -15,8 +16,6 @@ declare const _default: {
         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>;
     };
 };
 

package/dist/index.js

@@ -4,7 +4,7 @@ var AST2 = require('@eslint-react/ast');
 var core = require('@eslint-react/core');
 var shared = require('@eslint-react/shared');
 var tools = require('@eslint-react/tools');
-var VAR3 = require('@eslint-react/var');
+var VAR4 = require('@eslint-react/var');
 var types = require('@typescript-eslint/types');
 var tsPattern = require('ts-pattern');
 var astUtils = require('@typescript-eslint/utils/ast-utils');
@@ -28,17 +28,17 @@ function _interopNamespace(e) {
 }
 
 var AST2__namespace = /*#__PURE__*/_interopNamespace(AST2);
-var VAR3__namespace = /*#__PURE__*/_interopNamespace(VAR3);
+var VAR4__namespace = /*#__PURE__*/_interopNamespace(VAR4);
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.14.3";
+var version = "1.15.0-beta.11";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 function isFromHookCall(name2, context, settings, predicate = tools.F.constTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
   return (topLevelId) => tools.F.pipe(
-    VAR3__namespace.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-    tools.O.flatMap(VAR3__namespace.getVariableNode(0)),
+    VAR4__namespace.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
+    tools.O.flatMap(VAR4__namespace.getVariableNode(0)),
     tools.O.filter(AST2__namespace.is(types.AST_NODE_TYPES.CallExpression)),
     tools.O.filter(core.isReactHookCallWithNameAlias(name2, context, hookAlias)),
     tools.O.exists((call) => predicate(topLevelId, call))
@@ -131,17 +131,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
     if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
     const settings = shared.decodeSettings(context.settings);
     const additionalHooks = settings.additionalHooks ?? {};
-    const isUseEffectLikeCall = core.isReactHookCallWithNameAlias(
-      "useEffect",
-      context,
-      [
-        "useLayoutEffect",
-        "useInsertionEffect",
-        ...additionalHooks.useEffect ?? [],
-        ...additionalHooks.useLayoutEffect ?? [],
-        ...additionalHooks.useInsertionEffect ?? []
-      ]
-    );
+    const isUseEffectLikeCall = core.isReactHookCallWithNameAlias("useEffect", context, additionalHooks.useEffect ?? []);
     const isUseStateCall2 = core.isReactHookCallWithNameAlias("useState", context, additionalHooks.useState ?? []);
     const isUseMemoCall2 = core.isReactHookCallWithNameAlias("useMemo", context, additionalHooks.useMemo ?? []);
     const isUseCallbackCall2 = core.isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
@@ -249,7 +239,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
       },
       "Program:exit"() {
         const getSetStateCalls = (id, initialScope) => {
-          const node = tools.O.flatMap(VAR3__namespace.findVariable(id, initialScope), VAR3__namespace.getVariableNode(0)).pipe(tools.O.getOrNull);
+          const node = tools.O.flatMap(VAR4__namespace.findVariable(id, initialScope), VAR4__namespace.getVariableNode(0)).pipe(tools.O.getOrNull);
           switch (node?.type) {
             case types.AST_NODE_TYPES.FunctionDeclaration:
             case types.AST_NODE_TYPES.FunctionExpression:
@@ -300,7 +290,187 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME2 = "no-redundant-custom-hook";
+var RULE_NAME2 = "no-direct-set-state-in-use-layout-effect";
+var no_direct_set_state_in_use_layout_effect_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow direct calls to the 'set' function of 'useState' in 'useLayoutEffect'"
+    },
+    messages: {
+      noDirectSetStateInUseLayoutEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useLayoutEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME2,
+  create(context) {
+    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+    const settings = shared.decodeSettings(context.settings);
+    const additionalHooks = settings.additionalHooks ?? {};
+    const isUseEffectLikeCall = core.isReactHookCallWithNameAlias(
+      "useLayoutEffect",
+      context,
+      additionalHooks.useLayoutEffect ?? []
+    );
+    const isUseStateCall2 = core.isReactHookCallWithNameAlias("useState", context, additionalHooks.useState ?? []);
+    const isUseMemoCall2 = core.isReactHookCallWithNameAlias("useMemo", context, additionalHooks.useMemo ?? []);
+    const isUseCallbackCall2 = core.isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
+    const isSetStateCall = isSetFunctionCall(context, settings);
+    const isIdFromUseStateCall = isFromUseStateCall(context, settings);
+    const functionStack = [];
+    const setupFunctionRef = tools.MutRef.make(null);
+    const setupFunctionIdentifiers = [];
+    const indirectFunctionCalls = [];
+    const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
+    const indirectSetStateCallsAsArgs = /* @__PURE__ */ new WeakMap();
+    const indirectSetStateCallsAsSetups = /* @__PURE__ */ new Map();
+    const indirectSetStateCallsInHooks = /* @__PURE__ */ new WeakMap();
+    const onSetupFunctionEnter = (node) => {
+      tools.MutRef.set(setupFunctionRef, node);
+    };
+    const onSetupFunctionExit = (node) => {
+      tools.MutRef.update(setupFunctionRef, (current) => current === node ? null : current);
+    };
+    function isSetupFunction(node) {
+      return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
+    }
+    function getCallKind(node) {
+      return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
+    }
+    function getFunctionKind(node) {
+      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(AST2__namespace.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+    }
+    return {
+      ":function"(node) {
+        const functionKind = getFunctionKind(node);
+        functionStack.push([node, functionKind]);
+        if (functionKind === "setup") onSetupFunctionEnter(node);
+      },
+      ":function:exit"(node) {
+        const [_, functionKind] = functionStack.at(-1) ?? [];
+        functionStack.pop();
+        if (functionKind === "setup") onSetupFunctionExit(node);
+      },
+      CallExpression(node) {
+        const effectFn = tools.MutRef.get(setupFunctionRef);
+        const [parentFn, parentFnKind] = functionStack.at(-1) ?? [];
+        if (parentFn?.async) return;
+        tsPattern.match(getCallKind(node)).with("setState", () => {
+          if (!parentFn) return;
+          if (parentFn !== effectFn && parentFnKind !== "immediate") {
+            const maybeVd = AST2__namespace.traverseUpGuard(node, isVariableDeclaratorFromHookCall);
+            if (tools.O.isSome(maybeVd)) {
+              const vd = maybeVd.value;
+              const calls2 = indirectSetStateCallsInHooks.get(vd.init) ?? [];
+              indirectSetStateCallsInHooks.set(vd.init, [...calls2, node]);
+              return;
+            }
+            const calls = indirectSetStateCalls.get(parentFn) ?? [];
+            indirectSetStateCalls.set(parentFn, [...calls, node]);
+            return;
+          }
+          context.report({
+            messageId: "noDirectSetStateInUseLayoutEffect",
+            node,
+            data: { name: context.sourceCode.getText(node.callee) }
+          });
+        }).with("useLayoutEffect", () => {
+          const [firstArg] = node.arguments;
+          if (AST2__namespace.isFunction(firstArg)) return;
+          const identifiers = AST2__namespace.getNestedIdentifiers(node);
+          setupFunctionIdentifiers.push(...identifiers);
+        }).with("other", () => {
+          const isInSetupFunction = effectFn === parentFn;
+          if (!isInSetupFunction) return;
+          indirectFunctionCalls.push(node);
+        }).otherwise(tools.F.constVoid);
+      },
+      Identifier(node) {
+        if (node.parent.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee === node) return;
+        if (!isIdFromUseStateCall(node)) return;
+        switch (node.parent.type) {
+          case types.AST_NODE_TYPES.CallExpression: {
+            const [firstArg] = node.parent.arguments;
+            if (node !== firstArg) break;
+            if (isUseCallbackCall2(node.parent)) {
+              const maybeVd = AST2__namespace.traverseUpGuard(node.parent, isVariableDeclaratorFromHookCall);
+              if (tools.O.isNone(maybeVd)) break;
+              const vd = maybeVd.value;
+              const calls = indirectSetStateCallsAsArgs.get(vd.init) ?? [];
+              indirectSetStateCallsAsArgs.set(vd.init, [...calls, node]);
+            }
+            if (isUseEffectLikeCall(node.parent)) {
+              const calls = indirectSetStateCallsAsArgs.get(node.parent) ?? [];
+              indirectSetStateCallsAsSetups.set(node.parent, [...calls, node]);
+            }
+            break;
+          }
+          case types.AST_NODE_TYPES.ArrowFunctionExpression: {
+            const parent = node.parent.parent;
+            if (parent.type !== types.AST_NODE_TYPES.CallExpression) break;
+            if (!isUseMemoCall2(parent)) break;
+            const maybeVd = AST2__namespace.traverseUpGuard(parent, isVariableDeclaratorFromHookCall);
+            if (tools.O.isNone(maybeVd)) break;
+            const vd = maybeVd.value;
+            const calls = indirectSetStateCallsAsArgs.get(vd.init) ?? [];
+            indirectSetStateCallsAsArgs.set(vd.init, [...calls, node]);
+          }
+        }
+      },
+      "Program:exit"() {
+        const getSetStateCalls = (id, initialScope) => {
+          const node = tools.O.flatMap(VAR4__namespace.findVariable(id, initialScope), VAR4__namespace.getVariableNode(0)).pipe(tools.O.getOrNull);
+          switch (node?.type) {
+            case types.AST_NODE_TYPES.FunctionDeclaration:
+            case types.AST_NODE_TYPES.FunctionExpression:
+            case types.AST_NODE_TYPES.ArrowFunctionExpression:
+              return indirectSetStateCalls.get(node) ?? [];
+            case types.AST_NODE_TYPES.CallExpression:
+              return indirectSetStateCallsInHooks.get(node) ?? indirectSetStateCallsAsArgs.get(node) ?? [];
+          }
+          return [];
+        };
+        for (const [_, calls] of indirectSetStateCallsAsSetups) {
+          for (const call of calls) {
+            context.report({
+              messageId: "noDirectSetStateInUseLayoutEffect",
+              node: call,
+              data: { name: call.name }
+            });
+          }
+        }
+        for (const { callee } of indirectFunctionCalls) {
+          if (!("name" in callee)) continue;
+          const { name: name2 } = callee;
+          const setStateCalls = getSetStateCalls(name2, context.sourceCode.getScope(callee));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              messageId: "noDirectSetStateInUseLayoutEffect",
+              node: setStateCall,
+              data: {
+                name: AST2__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+              }
+            });
+          }
+        }
+        for (const id of setupFunctionIdentifiers) {
+          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              messageId: "noDirectSetStateInUseLayoutEffect",
+              node: setStateCall,
+              data: {
+                name: AST2__namespace.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+              }
+            });
+          }
+        }
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME3 = "no-redundant-custom-hook";
 var no_redundant_custom_hook_default = createRule({
   meta: {
     type: "problem",
@@ -312,7 +482,7 @@ var no_redundant_custom_hook_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME2,
+  name: RULE_NAME3,
   create(context) {
     const { ctx, listeners } = core.useHookCollector();
     return {
@@ -335,7 +505,7 @@ var no_redundant_custom_hook_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME3 = "no-unnecessary-use-callback";
+var RULE_NAME4 = "no-unnecessary-use-callback";
 var no_unnecessary_use_callback_default = createRule({
   meta: {
     type: "problem",
@@ -347,7 +517,7 @@ var no_unnecessary_use_callback_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME3,
+  name: RULE_NAME4,
   create(context) {
     if (!context.sourceCode.text.includes("use")) return {};
     const alias = shared.decodeSettings(context.settings).additionalHooks?.useCallback ?? [];
@@ -372,8 +542,8 @@ var no_unnecessary_use_callback_default = createRule({
         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(
-              VAR3__namespace.findVariable(n.name, initialScope),
-              tools.O.flatMap(VAR3__namespace.getVariableNode(0)),
+              VAR4__namespace.findVariable(n.name, initialScope),
+              tools.O.flatMap(VAR4__namespace.getVariableNode(0)),
               tools.O.filter(AST2__namespace.is(types.AST_NODE_TYPES.ArrayExpression))
             );
           }).otherwise(tools.O.none),
@@ -395,13 +565,13 @@ var no_unnecessary_use_callback_default = createRule({
             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(
-              VAR3__namespace.findVariable(n.name, initialScope),
-              tools.O.flatMap(VAR3__namespace.getVariableNode(0)),
+              VAR4__namespace.findVariable(n.name, initialScope),
+              tools.O.flatMap(VAR4__namespace.getVariableNode(0)),
               tools.O.filter(AST2__namespace.isFunction)
             );
           }).otherwise(tools.O.none),
           tools.O.map((n) => context.sourceCode.getScope(n)),
-          tools.O.map((s) => VAR3__namespace.getChidScopes(s).flatMap((x) => x.references)),
+          tools.O.map((s) => VAR4__namespace.getChidScopes(s).flatMap((x) => x.references)),
           tools.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
         );
         if (isReferencedToComponentScope) return;
@@ -414,7 +584,7 @@ var no_unnecessary_use_callback_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME4 = "no-unnecessary-use-memo";
+var RULE_NAME5 = "no-unnecessary-use-memo";
 var no_unnecessary_use_memo_default = createRule({
   meta: {
     type: "problem",
@@ -426,7 +596,7 @@ var no_unnecessary_use_memo_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME4,
+  name: RULE_NAME5,
   create(context) {
     if (!context.sourceCode.text.includes("use")) return {};
     const alias = shared.decodeSettings(context.settings).additionalHooks?.useMemo ?? [];
@@ -451,8 +621,8 @@ var no_unnecessary_use_memo_default = createRule({
         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(
-              VAR3__namespace.findVariable(n.name, initialScope),
-              tools.O.flatMap(VAR3__namespace.getVariableNode(0)),
+              VAR4__namespace.findVariable(n.name, initialScope),
+              tools.O.flatMap(VAR4__namespace.getVariableNode(0)),
               tools.O.filter(AST2__namespace.is(types.AST_NODE_TYPES.ArrayExpression))
             );
           }).otherwise(tools.O.none),
@@ -474,13 +644,13 @@ var no_unnecessary_use_memo_default = createRule({
             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(
-              VAR3__namespace.findVariable(n.name, initialScope),
-              tools.O.flatMap(VAR3__namespace.getVariableNode(0)),
+              VAR4__namespace.findVariable(n.name, initialScope),
+              tools.O.flatMap(VAR4__namespace.getVariableNode(0)),
               tools.O.filter(AST2__namespace.isFunction)
             );
           }).otherwise(tools.O.none),
           tools.O.map((n) => context.sourceCode.getScope(n)),
-          tools.O.map((s) => VAR3__namespace.getChidScopes(s).flatMap((x) => x.references)),
+          tools.O.map((s) => VAR4__namespace.getChidScopes(s).flatMap((x) => x.references)),
           tools.O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
         );
         if (isReferencedToComponentScope) return;
@@ -493,7 +663,7 @@ var no_unnecessary_use_memo_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME5 = "prefer-use-state-lazy-initialization";
+var RULE_NAME6 = "prefer-use-state-lazy-initialization";
 var ALLOW_LIST = ["Boolean", "String", "Number"];
 var prefer_use_state_lazy_initialization_default = createRule({
   meta: {
@@ -506,7 +676,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME5,
+  name: RULE_NAME6,
   create(context) {
     if (!context.sourceCode.text.includes("use")) return {};
     const alias = shared.decodeSettings(context.settings).additionalHooks?.useState ?? [];
@@ -520,7 +690,10 @@ var prefer_use_state_lazy_initialization_default = createRule({
         const hasFunctionCall = nestedCallExpressions.some((n) => {
           return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
         });
-        if (!hasFunctionCall) return;
+        const hasNewCall = AST2__namespace.getNestedNewExpressions(useStateInput).some((n) => {
+          return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
+        });
+        if (!hasFunctionCall && !hasNewCall) return;
         context.report({
           messageId: "preferUseStateLazyInitialization",
           node: useStateInput
@@ -539,6 +712,7 @@ var src_default = {
   },
   rules: {
     "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
+    "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_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,
@@ -547,9 +721,7 @@ var src_default = {
     /** @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
+    "ensure-use-memo-has-non-empty-deps": no_unnecessary_use_memo_default
   }
 };
 

package/dist/index.mjs

@@ -2,20 +2,20 @@ import * as AST2 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 { MutRef, O, F } from '@eslint-react/tools';
-import * as VAR3 from '@eslint-react/var';
+import * as VAR4 from '@eslint-react/var';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 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.14.3";
+var version = "1.15.0-beta.11";
 var createRule = createRuleForPlugin("hooks-extra");
 function isFromHookCall(name2, context, settings, predicate = F.constTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
   return (topLevelId) => F.pipe(
-    VAR3.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
-    O.flatMap(VAR3.getVariableNode(0)),
+    VAR4.findVariable(topLevelId, context.sourceCode.getScope(topLevelId)),
+    O.flatMap(VAR4.getVariableNode(0)),
     O.filter(AST2.is(AST_NODE_TYPES.CallExpression)),
     O.filter(isReactHookCallWithNameAlias(name2, context, hookAlias)),
     O.exists((call) => predicate(topLevelId, call))
@@ -108,17 +108,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
     if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
     const settings = decodeSettings(context.settings);
     const additionalHooks = settings.additionalHooks ?? {};
-    const isUseEffectLikeCall = isReactHookCallWithNameAlias(
-      "useEffect",
-      context,
-      [
-        "useLayoutEffect",
-        "useInsertionEffect",
-        ...additionalHooks.useEffect ?? [],
-        ...additionalHooks.useLayoutEffect ?? [],
-        ...additionalHooks.useInsertionEffect ?? []
-      ]
-    );
+    const isUseEffectLikeCall = isReactHookCallWithNameAlias("useEffect", context, additionalHooks.useEffect ?? []);
     const isUseStateCall2 = isReactHookCallWithNameAlias("useState", context, additionalHooks.useState ?? []);
     const isUseMemoCall2 = isReactHookCallWithNameAlias("useMemo", context, additionalHooks.useMemo ?? []);
     const isUseCallbackCall2 = isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
@@ -226,7 +216,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
       },
       "Program:exit"() {
         const getSetStateCalls = (id, initialScope) => {
-          const node = O.flatMap(VAR3.findVariable(id, initialScope), VAR3.getVariableNode(0)).pipe(O.getOrNull);
+          const node = O.flatMap(VAR4.findVariable(id, initialScope), VAR4.getVariableNode(0)).pipe(O.getOrNull);
           switch (node?.type) {
             case AST_NODE_TYPES.FunctionDeclaration:
             case AST_NODE_TYPES.FunctionExpression:
@@ -277,7 +267,187 @@ var no_direct_set_state_in_use_effect_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME2 = "no-redundant-custom-hook";
+var RULE_NAME2 = "no-direct-set-state-in-use-layout-effect";
+var no_direct_set_state_in_use_layout_effect_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow direct calls to the 'set' function of 'useState' in 'useLayoutEffect'"
+    },
+    messages: {
+      noDirectSetStateInUseLayoutEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useLayoutEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME2,
+  create(context) {
+    if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
+    const settings = decodeSettings(context.settings);
+    const additionalHooks = settings.additionalHooks ?? {};
+    const isUseEffectLikeCall = isReactHookCallWithNameAlias(
+      "useLayoutEffect",
+      context,
+      additionalHooks.useLayoutEffect ?? []
+    );
+    const isUseStateCall2 = isReactHookCallWithNameAlias("useState", context, additionalHooks.useState ?? []);
+    const isUseMemoCall2 = isReactHookCallWithNameAlias("useMemo", context, additionalHooks.useMemo ?? []);
+    const isUseCallbackCall2 = isReactHookCallWithNameAlias("useCallback", context, additionalHooks.useCallback ?? []);
+    const isSetStateCall = isSetFunctionCall(context, settings);
+    const isIdFromUseStateCall = isFromUseStateCall(context, settings);
+    const functionStack = [];
+    const setupFunctionRef = MutRef.make(null);
+    const setupFunctionIdentifiers = [];
+    const indirectFunctionCalls = [];
+    const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
+    const indirectSetStateCallsAsArgs = /* @__PURE__ */ new WeakMap();
+    const indirectSetStateCallsAsSetups = /* @__PURE__ */ new Map();
+    const indirectSetStateCallsInHooks = /* @__PURE__ */ new WeakMap();
+    const onSetupFunctionEnter = (node) => {
+      MutRef.set(setupFunctionRef, node);
+    };
+    const onSetupFunctionExit = (node) => {
+      MutRef.update(setupFunctionRef, (current) => current === node ? null : current);
+    };
+    function isSetupFunction(node) {
+      return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
+    }
+    function getCallKind(node) {
+      return match(node).when(isUseStateCall2, () => "useState").when(isUseEffectLikeCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
+    }
+    function getFunctionKind(node) {
+      return match(node).when(isSetupFunction, () => "setup").when(AST2.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+    }
+    return {
+      ":function"(node) {
+        const functionKind = getFunctionKind(node);
+        functionStack.push([node, functionKind]);
+        if (functionKind === "setup") onSetupFunctionEnter(node);
+      },
+      ":function:exit"(node) {
+        const [_, functionKind] = functionStack.at(-1) ?? [];
+        functionStack.pop();
+        if (functionKind === "setup") onSetupFunctionExit(node);
+      },
+      CallExpression(node) {
+        const effectFn = MutRef.get(setupFunctionRef);
+        const [parentFn, parentFnKind] = functionStack.at(-1) ?? [];
+        if (parentFn?.async) return;
+        match(getCallKind(node)).with("setState", () => {
+          if (!parentFn) return;
+          if (parentFn !== effectFn && parentFnKind !== "immediate") {
+            const maybeVd = AST2.traverseUpGuard(node, isVariableDeclaratorFromHookCall);
+            if (O.isSome(maybeVd)) {
+              const vd = maybeVd.value;
+              const calls2 = indirectSetStateCallsInHooks.get(vd.init) ?? [];
+              indirectSetStateCallsInHooks.set(vd.init, [...calls2, node]);
+              return;
+            }
+            const calls = indirectSetStateCalls.get(parentFn) ?? [];
+            indirectSetStateCalls.set(parentFn, [...calls, node]);
+            return;
+          }
+          context.report({
+            messageId: "noDirectSetStateInUseLayoutEffect",
+            node,
+            data: { name: context.sourceCode.getText(node.callee) }
+          });
+        }).with("useLayoutEffect", () => {
+          const [firstArg] = node.arguments;
+          if (AST2.isFunction(firstArg)) return;
+          const identifiers = AST2.getNestedIdentifiers(node);
+          setupFunctionIdentifiers.push(...identifiers);
+        }).with("other", () => {
+          const isInSetupFunction = effectFn === parentFn;
+          if (!isInSetupFunction) return;
+          indirectFunctionCalls.push(node);
+        }).otherwise(F.constVoid);
+      },
+      Identifier(node) {
+        if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) return;
+        if (!isIdFromUseStateCall(node)) return;
+        switch (node.parent.type) {
+          case AST_NODE_TYPES.CallExpression: {
+            const [firstArg] = node.parent.arguments;
+            if (node !== firstArg) break;
+            if (isUseCallbackCall2(node.parent)) {
+              const maybeVd = AST2.traverseUpGuard(node.parent, isVariableDeclaratorFromHookCall);
+              if (O.isNone(maybeVd)) break;
+              const vd = maybeVd.value;
+              const calls = indirectSetStateCallsAsArgs.get(vd.init) ?? [];
+              indirectSetStateCallsAsArgs.set(vd.init, [...calls, node]);
+            }
+            if (isUseEffectLikeCall(node.parent)) {
+              const calls = indirectSetStateCallsAsArgs.get(node.parent) ?? [];
+              indirectSetStateCallsAsSetups.set(node.parent, [...calls, node]);
+            }
+            break;
+          }
+          case AST_NODE_TYPES.ArrowFunctionExpression: {
+            const parent = node.parent.parent;
+            if (parent.type !== AST_NODE_TYPES.CallExpression) break;
+            if (!isUseMemoCall2(parent)) break;
+            const maybeVd = AST2.traverseUpGuard(parent, isVariableDeclaratorFromHookCall);
+            if (O.isNone(maybeVd)) break;
+            const vd = maybeVd.value;
+            const calls = indirectSetStateCallsAsArgs.get(vd.init) ?? [];
+            indirectSetStateCallsAsArgs.set(vd.init, [...calls, node]);
+          }
+        }
+      },
+      "Program:exit"() {
+        const getSetStateCalls = (id, initialScope) => {
+          const node = O.flatMap(VAR4.findVariable(id, initialScope), VAR4.getVariableNode(0)).pipe(O.getOrNull);
+          switch (node?.type) {
+            case AST_NODE_TYPES.FunctionDeclaration:
+            case AST_NODE_TYPES.FunctionExpression:
+            case AST_NODE_TYPES.ArrowFunctionExpression:
+              return indirectSetStateCalls.get(node) ?? [];
+            case AST_NODE_TYPES.CallExpression:
+              return indirectSetStateCallsInHooks.get(node) ?? indirectSetStateCallsAsArgs.get(node) ?? [];
+          }
+          return [];
+        };
+        for (const [_, calls] of indirectSetStateCallsAsSetups) {
+          for (const call of calls) {
+            context.report({
+              messageId: "noDirectSetStateInUseLayoutEffect",
+              node: call,
+              data: { name: call.name }
+            });
+          }
+        }
+        for (const { callee } of indirectFunctionCalls) {
+          if (!("name" in callee)) continue;
+          const { name: name2 } = callee;
+          const setStateCalls = getSetStateCalls(name2, context.sourceCode.getScope(callee));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              messageId: "noDirectSetStateInUseLayoutEffect",
+              node: setStateCall,
+              data: {
+                name: AST2.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+              }
+            });
+          }
+        }
+        for (const id of setupFunctionIdentifiers) {
+          const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
+          for (const setStateCall of setStateCalls) {
+            context.report({
+              messageId: "noDirectSetStateInUseLayoutEffect",
+              node: setStateCall,
+              data: {
+                name: AST2.toReadableNodeName(setStateCall, (n) => context.sourceCode.getText(n))
+              }
+            });
+          }
+        }
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME3 = "no-redundant-custom-hook";
 var no_redundant_custom_hook_default = createRule({
   meta: {
     type: "problem",
@@ -289,7 +459,7 @@ var no_redundant_custom_hook_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME2,
+  name: RULE_NAME3,
   create(context) {
     const { ctx, listeners } = useHookCollector();
     return {
@@ -312,7 +482,7 @@ var no_redundant_custom_hook_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME3 = "no-unnecessary-use-callback";
+var RULE_NAME4 = "no-unnecessary-use-callback";
 var no_unnecessary_use_callback_default = createRule({
   meta: {
     type: "problem",
@@ -324,7 +494,7 @@ var no_unnecessary_use_callback_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME3,
+  name: RULE_NAME4,
   create(context) {
     if (!context.sourceCode.text.includes("use")) return {};
     const alias = decodeSettings(context.settings).additionalHooks?.useCallback ?? [];
@@ -349,8 +519,8 @@ var no_unnecessary_use_callback_default = createRule({
         const hasEmptyDeps = F.pipe(
           match(deps).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
             return F.pipe(
-              VAR3.findVariable(n.name, initialScope),
-              O.flatMap(VAR3.getVariableNode(0)),
+              VAR4.findVariable(n.name, initialScope),
+              O.flatMap(VAR4.getVariableNode(0)),
               O.filter(AST2.is(AST_NODE_TYPES.ArrayExpression))
             );
           }).otherwise(O.none),
@@ -372,13 +542,13 @@ var no_unnecessary_use_callback_default = createRule({
             return O.some(n);
           }).with({ type: AST_NODE_TYPES.FunctionExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
             return F.pipe(
-              VAR3.findVariable(n.name, initialScope),
-              O.flatMap(VAR3.getVariableNode(0)),
+              VAR4.findVariable(n.name, initialScope),
+              O.flatMap(VAR4.getVariableNode(0)),
               O.filter(AST2.isFunction)
             );
           }).otherwise(O.none),
           O.map((n) => context.sourceCode.getScope(n)),
-          O.map((s) => VAR3.getChidScopes(s).flatMap((x) => x.references)),
+          O.map((s) => VAR4.getChidScopes(s).flatMap((x) => x.references)),
           O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
         );
         if (isReferencedToComponentScope) return;
@@ -391,7 +561,7 @@ var no_unnecessary_use_callback_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME4 = "no-unnecessary-use-memo";
+var RULE_NAME5 = "no-unnecessary-use-memo";
 var no_unnecessary_use_memo_default = createRule({
   meta: {
     type: "problem",
@@ -403,7 +573,7 @@ var no_unnecessary_use_memo_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME4,
+  name: RULE_NAME5,
   create(context) {
     if (!context.sourceCode.text.includes("use")) return {};
     const alias = decodeSettings(context.settings).additionalHooks?.useMemo ?? [];
@@ -428,8 +598,8 @@ var no_unnecessary_use_memo_default = createRule({
         const hasEmptyDeps = F.pipe(
           match(deps).with({ type: AST_NODE_TYPES.ArrayExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
             return F.pipe(
-              VAR3.findVariable(n.name, initialScope),
-              O.flatMap(VAR3.getVariableNode(0)),
+              VAR4.findVariable(n.name, initialScope),
+              O.flatMap(VAR4.getVariableNode(0)),
               O.filter(AST2.is(AST_NODE_TYPES.ArrayExpression))
             );
           }).otherwise(O.none),
@@ -451,13 +621,13 @@ var no_unnecessary_use_memo_default = createRule({
             return O.some(n);
           }).with({ type: AST_NODE_TYPES.FunctionExpression }, O.some).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
             return F.pipe(
-              VAR3.findVariable(n.name, initialScope),
-              O.flatMap(VAR3.getVariableNode(0)),
+              VAR4.findVariable(n.name, initialScope),
+              O.flatMap(VAR4.getVariableNode(0)),
               O.filter(AST2.isFunction)
             );
           }).otherwise(O.none),
           O.map((n) => context.sourceCode.getScope(n)),
-          O.map((s) => VAR3.getChidScopes(s).flatMap((x) => x.references)),
+          O.map((s) => VAR4.getChidScopes(s).flatMap((x) => x.references)),
           O.exists((refs) => refs.some((x) => x.resolved?.scope.block === component))
         );
         if (isReferencedToComponentScope) return;
@@ -470,7 +640,7 @@ var no_unnecessary_use_memo_default = createRule({
   },
   defaultOptions: []
 });
-var RULE_NAME5 = "prefer-use-state-lazy-initialization";
+var RULE_NAME6 = "prefer-use-state-lazy-initialization";
 var ALLOW_LIST = ["Boolean", "String", "Number"];
 var prefer_use_state_lazy_initialization_default = createRule({
   meta: {
@@ -483,7 +653,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME5,
+  name: RULE_NAME6,
   create(context) {
     if (!context.sourceCode.text.includes("use")) return {};
     const alias = decodeSettings(context.settings).additionalHooks?.useState ?? [];
@@ -497,7 +667,10 @@ var prefer_use_state_lazy_initialization_default = createRule({
         const hasFunctionCall = nestedCallExpressions.some((n) => {
           return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
         });
-        if (!hasFunctionCall) return;
+        const hasNewCall = AST2.getNestedNewExpressions(useStateInput).some((n) => {
+          return "name" in n.callee && !ALLOW_LIST.includes(n.callee.name);
+        });
+        if (!hasFunctionCall && !hasNewCall) return;
         context.report({
           messageId: "preferUseStateLazyInitialization",
           node: useStateInput
@@ -516,6 +689,7 @@ var src_default = {
   },
   rules: {
     "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
+    "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_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,
@@ -524,9 +698,7 @@ var src_default = {
     /** @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
+    "ensure-use-memo-has-non-empty-deps": no_unnecessary_use_memo_default
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.14.3",
+  "version": "1.15.0-beta.11",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "eslint",
@@ -41,22 +41,22 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.7.0",
-    "@typescript-eslint/type-utils": "^8.7.0",
-    "@typescript-eslint/types": "^8.7.0",
-    "@typescript-eslint/utils": "^8.7.0",
+    "@typescript-eslint/scope-manager": "^8.8.1",
+    "@typescript-eslint/type-utils": "^8.8.1",
+    "@typescript-eslint/types": "^8.8.1",
+    "@typescript-eslint/utils": "^8.8.1",
     "ts-pattern": "^5.4.0",
-    "@eslint-react/ast": "1.14.3",
-    "@eslint-react/core": "1.14.3",
-    "@eslint-react/jsx": "1.14.3",
-    "@eslint-react/tools": "1.14.3",
-    "@eslint-react/types": "1.14.3",
-    "@eslint-react/var": "1.14.3",
-    "@eslint-react/shared": "1.14.3"
+    "@eslint-react/ast": "1.15.0-beta.11",
+    "@eslint-react/shared": "1.15.0-beta.11",
+    "@eslint-react/jsx": "1.15.0-beta.11",
+    "@eslint-react/tools": "1.15.0-beta.11",
+    "@eslint-react/types": "1.15.0-beta.11",
+    "@eslint-react/var": "1.15.0-beta.11",
+    "@eslint-react/core": "1.15.0-beta.11"
   },
   "devDependencies": {
-    "@types/react": "^18.3.10",
-    "@types/react-dom": "^18.3.0",
+    "@types/react": "^18.3.11",
+    "@types/react-dom": "^18.3.1",
     "string-ts": "^2.2.0",
     "tsup": "^8.3.0"
   },