eslint-plugin-react-hooks-extra 1.5.25 → 1.5.26-beta.2

package/README.md

@@ -30,7 +30,8 @@ export default [
       "react-hooks-extra": reactHooksExtra,
       rules: {
         // react-hooks-extra recommended rules
-        "react-hooks-extra/ensure-custom-hooks-using-other-hooks": "warn",
+        "react-hooks-extra/no-direct-set-state-in-use-effect": "warn",
+        "react-hooks-extra/no-direct-set-state-in-use-layout-effect": "warn",
         "react-hooks-extra/prefer-use-state-lazy-initialization": "warn",
       }
     ],
@@ -40,9 +41,11 @@ 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.     | 🧐  |     |     |
-| `prefer-use-state-lazy-initialization`   | Warns function calls made inside `useState` calls.                | 🚀  |     |     |
+| 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`.       |  ✔️  |     |     |
+| `no-direct-set-state-in-use-layout-effect` | Disallow direct calls to the `set` function of `useState` in `useLayoutEffect`. |  ✔️  |     |     |
+| `prefer-use-state-lazy-initialization`     | Warns function calls made inside `useState` calls.                              | 🚀  |     |     |

package/dist/index.d.mts

@@ -8,6 +8,8 @@ declare const rules: {
     readonly "ensure-custom-hooks-using-other-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "ensure-use-callback-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "ensure-use-memo-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+    readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"NO_DIRECT_SET_STATE_IN_USE_EFFECT", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+    readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"PREFER_USE_STATE_LAZY_INITIALIZATION", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
 };
 

package/dist/index.d.ts

@@ -8,6 +8,8 @@ declare const rules: {
     readonly "ensure-custom-hooks-using-other-hooks": _typescript_eslint_utils_ts_eslint.RuleModule<"ENSURE_CUSTOM_HOOKS_USING_OTHER_HOOKS", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "ensure-use-callback-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "ensure-use-memo-has-non-empty-deps": _typescript_eslint_utils_ts_eslint.RuleModule<"ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+    readonly "no-direct-set-state-in-use-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"NO_DIRECT_SET_STATE_IN_USE_EFFECT", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+    readonly "no-direct-set-state-in-use-layout-effect": _typescript_eslint_utils_ts_eslint.RuleModule<"NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     readonly "prefer-use-state-lazy-initialization": _typescript_eslint_utils_ts_eslint.RuleModule<"PREFER_USE_STATE_LAZY_INITIALIZATION", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
 };
 

package/dist/index.js

@@ -5,10 +5,11 @@ 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 astUtils = require('@typescript-eslint/utils/ast-utils');
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.5.25";
+var version = "1.5.26-beta.2";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -226,7 +227,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
       description: "enforce 'useCallback' has non-empty dependencies array"
     },
     messages: {
-      ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS: "An useCallback should have a non-empty dependencies array."
+      ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS: "An 'useCallback' should have a non-empty dependencies array."
     },
     schema: []
   },
@@ -235,12 +236,15 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
     const alias = shared.getESLintReactSettings(context.settings).additionalHooks?.useCallback ?? [];
     return {
       CallExpression(node) {
-        const initialScope = context.sourceCode.getScope(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))) {
           return;
         }
-        const [_2, deps] = node.arguments;
+        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: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
@@ -248,7 +252,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           });
           return;
         }
-        const maybeDescriptor = tools.F.pipe(
+        const hasEmptyDeps = tools.F.pipe(
           $(deps).with({ type: ast.NodeType.ArrayExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
             return tools.F.pipe(
               _var.findVariable(n2.name, initialScope),
@@ -256,13 +260,32 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
               tools.O.filter(ast.is(ast.NodeType.ArrayExpression))
             );
           }).otherwise(tools.O.none),
-          tools.O.filter((x2) => x2.elements.length === 0),
-          tools.O.map(() => ({
+          tools.O.exists((x2) => x2.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
             messageId: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
             node
-          }))
+          });
+          return;
+        }
+        const isReferencedToComponentScope = tools.F.pipe(
+          $(cb).with({ type: ast.NodeType.ArrowFunctionExpression }, tools.O.some).with({ type: ast.NodeType.FunctionExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
+            return tools.F.pipe(
+              _var.findVariable(n2.name, initialScope),
+              tools.O.flatMap(_var.getVariableInit(0)),
+              tools.O.filter(ast.isFunction)
+            );
+          }).otherwise(tools.O.none),
+          tools.O.map((n2) => context.sourceCode.getScope(n2).references),
+          tools.O.exists((refs) => refs.some((x2) => x2.resolved?.scope.block === component))
         );
-        tools.O.map(maybeDescriptor, context.report);
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
+          node
+        });
       }
     };
   },
@@ -276,7 +299,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
       description: "enforce 'useMemo' has non-empty dependencies array"
     },
     messages: {
-      ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS: "An useMemo should have a non-empty dependencies array."
+      ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS: "An 'useMemo' should have a non-empty dependencies array."
     },
     schema: []
   },
@@ -285,10 +308,15 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
     const alias = shared.getESLintReactSettings(context.settings).additionalHooks?.useMemo ?? [];
     return {
       CallExpression(node) {
-        const initialScope = context.sourceCode.getScope(node);
         if (!core.isReactHookCall(node)) return;
-        if (!core.isUseMemoCall(node, context) && !alias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node))) return;
-        const [_2, deps] = node.arguments;
+        const initialScope = context.sourceCode.getScope(node);
+        if (!core.isUseMemoCall(node, context) && !alias.some(tools.F.flip(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: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
@@ -296,7 +324,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           });
           return;
         }
-        const maybeDescriptor = tools.F.pipe(
+        const hasEmptyDeps = tools.F.pipe(
           $(deps).with({ type: ast.NodeType.ArrayExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
             return tools.F.pipe(
               _var.findVariable(n2.name, initialScope),
@@ -304,19 +332,194 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
               tools.O.filter(ast.is(ast.NodeType.ArrayExpression))
             );
           }).otherwise(tools.O.none),
-          tools.O.filter((x2) => x2.elements.length === 0),
-          tools.O.map(() => ({
+          tools.O.exists((x2) => x2.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
             messageId: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
             node
-          }))
+          });
+          return;
+        }
+        const isReferencedToComponentScope = tools.F.pipe(
+          $(cb).with({ type: ast.NodeType.ArrowFunctionExpression }, tools.O.some).with({ type: ast.NodeType.FunctionExpression }, tools.O.some).with({ type: ast.NodeType.Identifier }, (n2) => {
+            return tools.F.pipe(
+              _var.findVariable(n2.name, initialScope),
+              tools.O.flatMap(_var.getVariableInit(0)),
+              tools.O.filter(ast.isFunction)
+            );
+          }).otherwise(tools.O.none),
+          tools.O.map((n2) => context.sourceCode.getScope(n2).references),
+          tools.O.exists((refs) => refs.some((x2) => x2.resolved?.scope.block === component))
+        );
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME4 = "no-direct-set-state-in-use-effect";
+var no_direct_set_state_in_use_effect_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow direct calls to the 'set' function of 'useState' in 'useEffect'"
+    },
+    messages: {
+      NO_DIRECT_SET_STATE_IN_USE_EFFECT: "Do not call the 'set' function of 'useState' directly in 'useEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME4,
+  create(context) {
+    const settings = shared.getESLintReactSettings(context.settings);
+    const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
+    function isUseEffectCallWithAlias(node, context2) {
+      return core.isUseEffectCall(node, context2) || useEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    }
+    function isUseStateCallWithAlias(node, context2) {
+      return core.isUseStateCall(node, context2) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    }
+    function isEffectFunction(node) {
+      return node.parent?.type === ast.NodeType.CallExpression && isUseEffectCallWithAlias(node.parent, context);
+    }
+    return {
+      CallExpression(node) {
+        const effectFunction = ast.traverseUp(node, isEffectFunction);
+        if (tools.O.isNone(effectFunction)) return;
+        const scope = context.sourceCode.getScope(node);
+        if (scope.block !== effectFunction.value) return;
+        const name2 = $(node.callee).with({ type: ast.NodeType.Identifier }, (n2) => tools.O.some(n2.name)).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.name);
+          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 = $(n2.callee).with(
+            {
+              type: ast.NodeType.MemberExpression,
+              property: {
+                type: ast.NodeType.Identifier,
+                name: "at"
+              }
+            },
+            tools.F.constTrue
+          ).otherwise(tools.F.constFalse);
+          if (!isAt) return tools.O.none();
+          const [index] = n2.arguments;
+          if (!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.name);
+          return tools.O.none();
+        }).otherwise(tools.O.none);
+        tools.F.pipe(
+          name2,
+          tools.O.flatMap(_var.findVariable(scope)),
+          tools.O.flatMap(_var.getVariableInit(0)),
+          tools.O.filter(ast.is(ast.NodeType.CallExpression)),
+          tools.O.filter((name3) => isUseStateCallWithAlias(name3, context)),
+          tools.O.map((name3) => ({
+            data: {
+              setState: name3
+            },
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
+            node
+          })),
+          tools.O.map(context.report)
+        );
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME5 = "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: {
+      NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT: "Do not call the 'set' function of 'useState' directly in 'useLayoutEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME5,
+  create(context) {
+    const settings = shared.getESLintReactSettings(context.settings);
+    const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
+    function isUseLayoutEffectCallWithAlias(node, context2) {
+      return core.isUseLayoutEffectCall(node, context2) || useLayoutEffectAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    }
+    function isUseStateCallWithAlias(node, context2) {
+      return core.isUseStateCall(node, context2) || useStateAlias.some(tools.F.flip(core.isReactHookCallWithNameLoose)(node));
+    }
+    function isEffectFunction(node) {
+      return node.parent?.type === ast.NodeType.CallExpression && isUseLayoutEffectCallWithAlias(node.parent, context);
+    }
+    return {
+      CallExpression(node) {
+        const effectFunction = ast.traverseUp(node, isEffectFunction);
+        if (tools.O.isNone(effectFunction)) return;
+        const scope = context.sourceCode.getScope(node);
+        if (scope.block !== effectFunction.value) return;
+        const name2 = $(node.callee).with({ type: ast.NodeType.Identifier }, (n2) => tools.O.some(n2.name)).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.name);
+          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 = $(n2.callee).with(
+            {
+              type: ast.NodeType.MemberExpression,
+              property: {
+                type: ast.NodeType.Identifier,
+                name: "at"
+              }
+            },
+            tools.F.constTrue
+          ).otherwise(tools.F.constFalse);
+          if (!isAt) return tools.O.none();
+          const [index] = n2.arguments;
+          if (!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.name);
+          return tools.O.none();
+        }).otherwise(tools.O.none);
+        tools.F.pipe(
+          name2,
+          tools.O.flatMap(_var.findVariable(scope)),
+          tools.O.flatMap(_var.getVariableInit(0)),
+          tools.O.filter(ast.is(ast.NodeType.CallExpression)),
+          tools.O.filter((name3) => isUseStateCallWithAlias(name3, context)),
+          tools.O.map((name3) => ({
+            data: {
+              setState: name3
+            },
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
+            node
+          })),
+          tools.O.map(context.report)
         );
-        tools.O.map(maybeDescriptor, context.report);
       }
     };
   },
   defaultOptions: []
 });
-var RULE_NAME4 = "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: {
@@ -329,7 +532,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME4,
+  name: RULE_NAME6,
   create(context) {
     const alias = shared.getESLintReactSettings(context.settings).additionalHooks?.useState ?? [];
     return {
@@ -362,6 +565,8 @@ 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-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_effect_default,
   "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
 };
 

package/dist/index.mjs

@@ -1,12 +1,13 @@
-import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall } from '@eslint-react/core';
+import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall, isUseEffectCall, isUseLayoutEffectCall } from '@eslint-react/core';
 import { createRuleForPlugin, getESLintReactSettings } from '@eslint-react/shared';
-import { NodeType, is, getNestedCallExpressions } from '@eslint-react/ast';
+import { isFunction, NodeType, is, traverseUp, getNestedCallExpressions } from '@eslint-react/ast';
 import { F, O } from '@eslint-react/tools';
 import { findVariable, getVariableInit } from '@eslint-react/var';
+import { getStaticValue } from '@typescript-eslint/utils/ast-utils';
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.5.25";
+var version = "1.5.26-beta.2";
 var createRule = createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -224,7 +225,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
       description: "enforce 'useCallback' has non-empty dependencies array"
     },
     messages: {
-      ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS: "An useCallback should have a non-empty dependencies array."
+      ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS: "An 'useCallback' should have a non-empty dependencies array."
     },
     schema: []
   },
@@ -233,12 +234,15 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
     const alias = getESLintReactSettings(context.settings).additionalHooks?.useCallback ?? [];
     return {
       CallExpression(node) {
-        const initialScope = context.sourceCode.getScope(node);
         if (!isReactHookCall(node)) return;
+        const initialScope = context.sourceCode.getScope(node);
         if (!isUseCallbackCall(node, context) && !alias.some(F.flip(isReactHookCallWithNameLoose)(node))) {
           return;
         }
-        const [_2, deps] = node.arguments;
+        const scope = context.sourceCode.getScope(node);
+        const component = scope.block;
+        if (!isFunction(component)) return;
+        const [cb, deps] = node.arguments;
         if (!deps) {
           context.report({
             messageId: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
@@ -246,7 +250,7 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           });
           return;
         }
-        const maybeDescriptor = F.pipe(
+        const hasEmptyDeps = F.pipe(
           $(deps).with({ type: NodeType.ArrayExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
             return F.pipe(
               findVariable(n2.name, initialScope),
@@ -254,13 +258,32 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
               O.filter(is(NodeType.ArrayExpression))
             );
           }).otherwise(O.none),
-          O.filter((x2) => x2.elements.length === 0),
-          O.map(() => ({
+          O.exists((x2) => x2.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
             messageId: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
             node
-          }))
+          });
+          return;
+        }
+        const isReferencedToComponentScope = F.pipe(
+          $(cb).with({ type: NodeType.ArrowFunctionExpression }, O.some).with({ type: NodeType.FunctionExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
+            return F.pipe(
+              findVariable(n2.name, initialScope),
+              O.flatMap(getVariableInit(0)),
+              O.filter(isFunction)
+            );
+          }).otherwise(O.none),
+          O.map((n2) => context.sourceCode.getScope(n2).references),
+          O.exists((refs) => refs.some((x2) => x2.resolved?.scope.block === component))
         );
-        O.map(maybeDescriptor, context.report);
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
+          node
+        });
       }
     };
   },
@@ -274,7 +297,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
       description: "enforce 'useMemo' has non-empty dependencies array"
     },
     messages: {
-      ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS: "An useMemo should have a non-empty dependencies array."
+      ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS: "An 'useMemo' should have a non-empty dependencies array."
     },
     schema: []
   },
@@ -283,10 +306,15 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
     const alias = getESLintReactSettings(context.settings).additionalHooks?.useMemo ?? [];
     return {
       CallExpression(node) {
-        const initialScope = context.sourceCode.getScope(node);
         if (!isReactHookCall(node)) return;
-        if (!isUseMemoCall(node, context) && !alias.some(F.flip(isReactHookCallWithNameLoose)(node))) return;
-        const [_2, deps] = node.arguments;
+        const initialScope = context.sourceCode.getScope(node);
+        if (!isUseMemoCall(node, context) && !alias.some(F.flip(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: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
@@ -294,7 +322,7 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           });
           return;
         }
-        const maybeDescriptor = F.pipe(
+        const hasEmptyDeps = F.pipe(
           $(deps).with({ type: NodeType.ArrayExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
             return F.pipe(
               findVariable(n2.name, initialScope),
@@ -302,19 +330,194 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
               O.filter(is(NodeType.ArrayExpression))
             );
           }).otherwise(O.none),
-          O.filter((x2) => x2.elements.length === 0),
-          O.map(() => ({
+          O.exists((x2) => x2.elements.length === 0)
+        );
+        if (!hasEmptyDeps) return;
+        if (!cb) {
+          context.report({
             messageId: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
             node
-          }))
+          });
+          return;
+        }
+        const isReferencedToComponentScope = F.pipe(
+          $(cb).with({ type: NodeType.ArrowFunctionExpression }, O.some).with({ type: NodeType.FunctionExpression }, O.some).with({ type: NodeType.Identifier }, (n2) => {
+            return F.pipe(
+              findVariable(n2.name, initialScope),
+              O.flatMap(getVariableInit(0)),
+              O.filter(isFunction)
+            );
+          }).otherwise(O.none),
+          O.map((n2) => context.sourceCode.getScope(n2).references),
+          O.exists((refs) => refs.some((x2) => x2.resolved?.scope.block === component))
+        );
+        if (isReferencedToComponentScope) return;
+        context.report({
+          messageId: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME4 = "no-direct-set-state-in-use-effect";
+var no_direct_set_state_in_use_effect_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "disallow direct calls to the 'set' function of 'useState' in 'useEffect'"
+    },
+    messages: {
+      NO_DIRECT_SET_STATE_IN_USE_EFFECT: "Do not call the 'set' function of 'useState' directly in 'useEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME4,
+  create(context) {
+    const settings = getESLintReactSettings(context.settings);
+    const { useEffect: useEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
+    function isUseEffectCallWithAlias(node, context2) {
+      return isUseEffectCall(node, context2) || useEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    }
+    function isUseStateCallWithAlias(node, context2) {
+      return isUseStateCall(node, context2) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    }
+    function isEffectFunction(node) {
+      return node.parent?.type === NodeType.CallExpression && isUseEffectCallWithAlias(node.parent, context);
+    }
+    return {
+      CallExpression(node) {
+        const effectFunction = traverseUp(node, isEffectFunction);
+        if (O.isNone(effectFunction)) return;
+        const scope = context.sourceCode.getScope(node);
+        if (scope.block !== effectFunction.value) return;
+        const name2 = $(node.callee).with({ type: NodeType.Identifier }, (n2) => O.some(n2.name)).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.name);
+          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 = $(n2.callee).with(
+            {
+              type: NodeType.MemberExpression,
+              property: {
+                type: NodeType.Identifier,
+                name: "at"
+              }
+            },
+            F.constTrue
+          ).otherwise(F.constFalse);
+          if (!isAt) return O.none();
+          const [index] = n2.arguments;
+          if (!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.name);
+          return O.none();
+        }).otherwise(O.none);
+        F.pipe(
+          name2,
+          O.flatMap(findVariable(scope)),
+          O.flatMap(getVariableInit(0)),
+          O.filter(is(NodeType.CallExpression)),
+          O.filter((name3) => isUseStateCallWithAlias(name3, context)),
+          O.map((name3) => ({
+            data: {
+              setState: name3
+            },
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_EFFECT",
+            node
+          })),
+          O.map(context.report)
+        );
+      }
+    };
+  },
+  defaultOptions: []
+});
+var RULE_NAME5 = "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: {
+      NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT: "Do not call the 'set' function of 'useState' directly in 'useLayoutEffect'."
+    },
+    schema: []
+  },
+  name: RULE_NAME5,
+  create(context) {
+    const settings = getESLintReactSettings(context.settings);
+    const { useLayoutEffect: useLayoutEffectAlias = [], useState: useStateAlias = [] } = settings.additionalHooks ?? {};
+    function isUseLayoutEffectCallWithAlias(node, context2) {
+      return isUseLayoutEffectCall(node, context2) || useLayoutEffectAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    }
+    function isUseStateCallWithAlias(node, context2) {
+      return isUseStateCall(node, context2) || useStateAlias.some(F.flip(isReactHookCallWithNameLoose)(node));
+    }
+    function isEffectFunction(node) {
+      return node.parent?.type === NodeType.CallExpression && isUseLayoutEffectCallWithAlias(node.parent, context);
+    }
+    return {
+      CallExpression(node) {
+        const effectFunction = traverseUp(node, isEffectFunction);
+        if (O.isNone(effectFunction)) return;
+        const scope = context.sourceCode.getScope(node);
+        if (scope.block !== effectFunction.value) return;
+        const name2 = $(node.callee).with({ type: NodeType.Identifier }, (n2) => O.some(n2.name)).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.name);
+          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 = $(n2.callee).with(
+            {
+              type: NodeType.MemberExpression,
+              property: {
+                type: NodeType.Identifier,
+                name: "at"
+              }
+            },
+            F.constTrue
+          ).otherwise(F.constFalse);
+          if (!isAt) return O.none();
+          const [index] = n2.arguments;
+          if (!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.name);
+          return O.none();
+        }).otherwise(O.none);
+        F.pipe(
+          name2,
+          O.flatMap(findVariable(scope)),
+          O.flatMap(getVariableInit(0)),
+          O.filter(is(NodeType.CallExpression)),
+          O.filter((name3) => isUseStateCallWithAlias(name3, context)),
+          O.map((name3) => ({
+            data: {
+              setState: name3
+            },
+            messageId: "NO_DIRECT_SET_STATE_IN_USE_LAYOUT_EFFECT",
+            node
+          })),
+          O.map(context.report)
         );
-        O.map(maybeDescriptor, context.report);
       }
     };
   },
   defaultOptions: []
 });
-var RULE_NAME4 = "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: {
@@ -327,7 +530,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME4,
+  name: RULE_NAME6,
   create(context) {
     const alias = getESLintReactSettings(context.settings).additionalHooks?.useState ?? [];
     return {
@@ -360,6 +563,8 @@ 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-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_effect_default,
   "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.5.25",
+  "version": "1.5.26-beta.2",
   "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.16.0",
     "@typescript-eslint/types": "^7.16.0",
     "@typescript-eslint/utils": "^7.16.0",
-    "@eslint-react/core": "1.5.25",
-    "@eslint-react/shared": "1.5.25",
-    "@eslint-react/jsx": "1.5.25",
-    "@eslint-react/tools": "1.5.25",
-    "@eslint-react/types": "1.5.25",
-    "@eslint-react/ast": "1.5.25",
-    "@eslint-react/var": "1.5.25"
+    "@eslint-react/ast": "1.5.26-beta.2",
+    "@eslint-react/jsx": "1.5.26-beta.2",
+    "@eslint-react/core": "1.5.26-beta.2",
+    "@eslint-react/shared": "1.5.26-beta.2",
+    "@eslint-react/tools": "1.5.26-beta.2",
+    "@eslint-react/types": "1.5.26-beta.2",
+    "@eslint-react/var": "1.5.26-beta.2"
   },
   "devDependencies": {
     "string-ts": "2.2.0",