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

package/dist/index.js

@@ -9,7 +9,7 @@ var astUtils = require('@typescript-eslint/utils/ast-utils');
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.5.26-next.1";
+var version = "1.5.26-next.3";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -227,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: []
   },
@@ -236,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",
@@ -249,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),
@@ -257,13 +260,33 @@ 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)),
+          tools.O.map((s2) => [...s2.childScopes, s2].flatMap((x2) => x2.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
+        });
       }
     };
   },
@@ -277,7 +300,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: []
   },
@@ -286,10 +309,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",
@@ -297,7 +325,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),
@@ -305,13 +333,33 @@ 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)),
+          tools.O.map((s2) => [...s2.childScopes, s2].flatMap((x2) => x2.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_MEMO_HAS_NON_EMPTY_DEPS",
+          node
+        });
       }
     };
   },

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall, isUseEffectCall, isUseLayoutEffectCall } from '@eslint-react/core';
 import { createRuleForPlugin, getESLintReactSettings } from '@eslint-react/shared';
-import { NodeType, is, traverseUp, 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.26-next.1";
+var version = "1.5.26-next.3";
 var createRule = createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -225,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: []
   },
@@ -234,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",
@@ -247,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),
@@ -255,13 +258,33 @@ 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)),
+          O.map((s2) => [...s2.childScopes, s2].flatMap((x2) => x2.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
+        });
       }
     };
   },
@@ -275,7 +298,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: []
   },
@@ -284,10 +307,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",
@@ -295,7 +323,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),
@@ -303,13 +331,33 @@ 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)),
+          O.map((s2) => [...s2.childScopes, s2].flatMap((x2) => x2.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_MEMO_HAS_NON_EMPTY_DEPS",
+          node
+        });
       }
     };
   },

package/package.json

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