eslint-plugin-react-hooks-extra 1.10.1-next.2 → 1.10.1

package/dist/index.js

@@ -11,7 +11,7 @@ var tsPattern = require('ts-pattern');
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.10.1-next.2";
+var version = "1.10.1";
 var createRule = shared.createRuleForPlugin("hooks-extra");
 function isFromHookCall(name2, context, settings, predicate = tools.F.constTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
@@ -300,41 +300,41 @@ var no_direct_set_state_in_use_effect_default = createRule({
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
     const functionStack = [];
-    const effectFunctionRef = tools.MutRef.make(null);
-    const effectFunctionIdentifiers = [];
+    const setupFunctionRef = tools.MutRef.make(null);
+    const setupFunctionIdentifiers = [];
     const indirectFunctionCalls = [];
     const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsAsEFs = /* @__PURE__ */ new Map();
     const indirectSetStateCallsAsArgs = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsInHooks = /* @__PURE__ */ new WeakMap();
-    const onEffectFunctionEnter = (node) => {
-      tools.MutRef.set(effectFunctionRef, node);
+    const onSetupFunctionEnter = (node) => {
+      tools.MutRef.set(setupFunctionRef, node);
     };
-    const onEffectFunctionExit = (node) => {
-      tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    const onSetupFunctionExit = (node) => {
+      tools.MutRef.update(setupFunctionRef, (current) => current === node ? null : current);
     };
-    function isEffectFunction(node) {
+    function isSetupFunction(node) {
       return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectCall(node.parent);
     }
     function getCallKind(node) {
       return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseEffectCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return tsPattern.match(node).when(isEffectFunction, () => "effect").when(ast.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(ast.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const functionKind = getFunctionKind(node);
         functionStack.push([node, functionKind]);
-        if (functionKind === "effect") onEffectFunctionEnter(node);
+        if (functionKind === "setup") onSetupFunctionEnter(node);
       },
       ":function:exit"(node) {
         const [_, functionKind] = functionStack.at(-1) ?? [];
         functionStack.pop();
-        if (functionKind === "effect") onEffectFunctionExit(node);
+        if (functionKind === "setup") onSetupFunctionExit(node);
       },
       CallExpression(node) {
-        const effectFn = tools.MutRef.get(effectFunctionRef);
+        const effectFn = tools.MutRef.get(setupFunctionRef);
         const [parentFn, parentFnKind] = functionStack.at(-1) ?? [];
         if (parentFn?.async) return;
         tsPattern.match(getCallKind(node)).with("setState", () => {
@@ -359,10 +359,10 @@ var no_direct_set_state_in_use_effect_default = createRule({
           const [firstArg] = node.arguments;
           if (ast.isFunction(firstArg)) return;
           const identifiers = ast.getNestedIdentifiers(node);
-          effectFunctionIdentifiers.push(...identifiers);
+          setupFunctionIdentifiers.push(...identifiers);
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
+          const isInSetupFunction = effectFn === parentFn;
+          if (!isInSetupFunction) return;
           indirectFunctionCalls.push(node);
         }).otherwise(tools.F.constVoid);
       },
@@ -432,7 +432,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
             });
           }
         }
-        for (const id of effectFunctionIdentifiers) {
+        for (const id of setupFunctionIdentifiers) {
           const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({
@@ -474,41 +474,41 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
     const functionStack = [];
-    const effectFunctionRef = tools.MutRef.make(null);
-    const effectFunctionIdentifiers = [];
+    const setupFunctionRef = tools.MutRef.make(null);
+    const setupFunctionIdentifiers = [];
     const indirectFunctionCalls = [];
     const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsAsEFs = /* @__PURE__ */ new Map();
     const indirectSetStateCallsAsArgs = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsInHooks = /* @__PURE__ */ new WeakMap();
-    const onEffectFunctionEnter = (node) => {
-      tools.MutRef.set(effectFunctionRef, node);
+    const onSetupFunctionEnter = (node) => {
+      tools.MutRef.set(setupFunctionRef, node);
     };
-    const onEffectFunctionExit = (node) => {
-      tools.MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    const onSetupFunctionExit = (node) => {
+      tools.MutRef.update(setupFunctionRef, (current) => current === node ? null : current);
     };
-    function isEffectFunction(node) {
+    function isSetupFunction(node) {
       return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectCall(node.parent);
     }
     function getCallKind(node) {
       return tsPattern.match(node).when(isUseStateCall2, () => "useState").when(isUseEffectCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return tsPattern.match(node).when(isEffectFunction, () => "effect").when(ast.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return tsPattern.match(node).when(isSetupFunction, () => "setup").when(ast.isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const functionKind = getFunctionKind(node);
         functionStack.push([node, functionKind]);
-        if (functionKind === "effect") onEffectFunctionEnter(node);
+        if (functionKind === "setup") onSetupFunctionEnter(node);
       },
       ":function:exit"(node) {
         const [_, functionKind] = functionStack.at(-1) ?? [];
         functionStack.pop();
-        if (functionKind === "effect") onEffectFunctionExit(node);
+        if (functionKind === "setup") onSetupFunctionExit(node);
       },
       CallExpression(node) {
-        const effectFn = tools.MutRef.get(effectFunctionRef);
+        const effectFn = tools.MutRef.get(setupFunctionRef);
         const [parentFn, parentFnKind] = functionStack.at(-1) ?? [];
         if (parentFn?.async) return;
         tsPattern.match(getCallKind(node)).with("setState", () => {
@@ -533,10 +533,10 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
           const [firstArg] = node.arguments;
           if (ast.isFunction(firstArg)) return;
           const identifiers = ast.getNestedIdentifiers(node);
-          effectFunctionIdentifiers.push(...identifiers);
+          setupFunctionIdentifiers.push(...identifiers);
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
+          const isInSetupFunction = effectFn === parentFn;
+          if (!isInSetupFunction) return;
           indirectFunctionCalls.push(node);
         }).otherwise(tools.F.constVoid);
       },
@@ -606,7 +606,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             });
           }
         }
-        for (const id of effectFunctionIdentifiers) {
+        for (const id of setupFunctionIdentifiers) {
           const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({

package/dist/index.mjs

@@ -9,7 +9,7 @@ import { match, isMatching } from 'ts-pattern';
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.10.1-next.2";
+var version = "1.10.1";
 var createRule = createRuleForPlugin("hooks-extra");
 function isFromHookCall(name2, context, settings, predicate = F.constTrue) {
   const hookAlias = settings.additionalHooks?.[name2] ?? [];
@@ -298,41 +298,41 @@ var no_direct_set_state_in_use_effect_default = createRule({
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
     const functionStack = [];
-    const effectFunctionRef = MutRef.make(null);
-    const effectFunctionIdentifiers = [];
+    const setupFunctionRef = MutRef.make(null);
+    const setupFunctionIdentifiers = [];
     const indirectFunctionCalls = [];
     const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsAsEFs = /* @__PURE__ */ new Map();
     const indirectSetStateCallsAsArgs = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsInHooks = /* @__PURE__ */ new WeakMap();
-    const onEffectFunctionEnter = (node) => {
-      MutRef.set(effectFunctionRef, node);
+    const onSetupFunctionEnter = (node) => {
+      MutRef.set(setupFunctionRef, node);
     };
-    const onEffectFunctionExit = (node) => {
-      MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    const onSetupFunctionExit = (node) => {
+      MutRef.update(setupFunctionRef, (current) => current === node ? null : current);
     };
-    function isEffectFunction(node) {
+    function isSetupFunction(node) {
       return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectCall(node.parent);
     }
     function getCallKind(node) {
       return match(node).when(isUseStateCall2, () => "useState").when(isUseEffectCall, () => "useEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return match(node).when(isEffectFunction, () => "effect").when(isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return match(node).when(isSetupFunction, () => "setup").when(isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const functionKind = getFunctionKind(node);
         functionStack.push([node, functionKind]);
-        if (functionKind === "effect") onEffectFunctionEnter(node);
+        if (functionKind === "setup") onSetupFunctionEnter(node);
       },
       ":function:exit"(node) {
         const [_, functionKind] = functionStack.at(-1) ?? [];
         functionStack.pop();
-        if (functionKind === "effect") onEffectFunctionExit(node);
+        if (functionKind === "setup") onSetupFunctionExit(node);
       },
       CallExpression(node) {
-        const effectFn = MutRef.get(effectFunctionRef);
+        const effectFn = MutRef.get(setupFunctionRef);
         const [parentFn, parentFnKind] = functionStack.at(-1) ?? [];
         if (parentFn?.async) return;
         match(getCallKind(node)).with("setState", () => {
@@ -357,10 +357,10 @@ var no_direct_set_state_in_use_effect_default = createRule({
           const [firstArg] = node.arguments;
           if (isFunction(firstArg)) return;
           const identifiers = getNestedIdentifiers(node);
-          effectFunctionIdentifiers.push(...identifiers);
+          setupFunctionIdentifiers.push(...identifiers);
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
+          const isInSetupFunction = effectFn === parentFn;
+          if (!isInSetupFunction) return;
           indirectFunctionCalls.push(node);
         }).otherwise(F.constVoid);
       },
@@ -430,7 +430,7 @@ var no_direct_set_state_in_use_effect_default = createRule({
             });
           }
         }
-        for (const id of effectFunctionIdentifiers) {
+        for (const id of setupFunctionIdentifiers) {
           const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({
@@ -472,41 +472,41 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
     const isSetStateCall = isSetFunctionCall(context, settings);
     const isIdFromUseStateCall = isFromUseStateCall(context, settings);
     const functionStack = [];
-    const effectFunctionRef = MutRef.make(null);
-    const effectFunctionIdentifiers = [];
+    const setupFunctionRef = MutRef.make(null);
+    const setupFunctionIdentifiers = [];
     const indirectFunctionCalls = [];
     const indirectSetStateCalls = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsAsEFs = /* @__PURE__ */ new Map();
     const indirectSetStateCallsAsArgs = /* @__PURE__ */ new WeakMap();
     const indirectSetStateCallsInHooks = /* @__PURE__ */ new WeakMap();
-    const onEffectFunctionEnter = (node) => {
-      MutRef.set(effectFunctionRef, node);
+    const onSetupFunctionEnter = (node) => {
+      MutRef.set(setupFunctionRef, node);
     };
-    const onEffectFunctionExit = (node) => {
-      MutRef.update(effectFunctionRef, (current) => current === node ? null : current);
+    const onSetupFunctionExit = (node) => {
+      MutRef.update(setupFunctionRef, (current) => current === node ? null : current);
     };
-    function isEffectFunction(node) {
+    function isSetupFunction(node) {
       return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectCall(node.parent);
     }
     function getCallKind(node) {
       return match(node).when(isUseStateCall2, () => "useState").when(isUseEffectCall, () => "useLayoutEffect").when(isSetStateCall, () => "setState").when(isThenCall, () => "then").otherwise(() => "other");
     }
     function getFunctionKind(node) {
-      return match(node).when(isEffectFunction, () => "effect").when(isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
+      return match(node).when(isSetupFunction, () => "setup").when(isFunctionOfImmediatelyInvoked, () => "immediate").otherwise(() => "other");
     }
     return {
       ":function"(node) {
         const functionKind = getFunctionKind(node);
         functionStack.push([node, functionKind]);
-        if (functionKind === "effect") onEffectFunctionEnter(node);
+        if (functionKind === "setup") onSetupFunctionEnter(node);
       },
       ":function:exit"(node) {
         const [_, functionKind] = functionStack.at(-1) ?? [];
         functionStack.pop();
-        if (functionKind === "effect") onEffectFunctionExit(node);
+        if (functionKind === "setup") onSetupFunctionExit(node);
       },
       CallExpression(node) {
-        const effectFn = MutRef.get(effectFunctionRef);
+        const effectFn = MutRef.get(setupFunctionRef);
         const [parentFn, parentFnKind] = functionStack.at(-1) ?? [];
         if (parentFn?.async) return;
         match(getCallKind(node)).with("setState", () => {
@@ -531,10 +531,10 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
           const [firstArg] = node.arguments;
           if (isFunction(firstArg)) return;
           const identifiers = getNestedIdentifiers(node);
-          effectFunctionIdentifiers.push(...identifiers);
+          setupFunctionIdentifiers.push(...identifiers);
         }).with("other", () => {
-          const isInEffectFunction = effectFn === parentFn;
-          if (!isInEffectFunction) return;
+          const isInSetupFunction = effectFn === parentFn;
+          if (!isInSetupFunction) return;
           indirectFunctionCalls.push(node);
         }).otherwise(F.constVoid);
       },
@@ -604,7 +604,7 @@ var no_direct_set_state_in_use_layout_effect_default = createRule({
             });
           }
         }
-        for (const id of effectFunctionIdentifiers) {
+        for (const id of setupFunctionIdentifiers) {
           const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
           for (const setStateCall of setStateCalls) {
             context.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-hooks-extra",
-  "version": "1.10.1-next.2",
+  "version": "1.10.1",
   "description": "ESLint React's ESLint plugin for React Hooks related rules.",
   "keywords": [
     "eslint",
@@ -41,18 +41,18 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.0.1",
-    "@typescript-eslint/type-utils": "^8.0.1",
-    "@typescript-eslint/types": "^8.0.1",
-    "@typescript-eslint/utils": "^8.0.1",
+    "@typescript-eslint/scope-manager": "^8.1.0",
+    "@typescript-eslint/type-utils": "^8.1.0",
+    "@typescript-eslint/types": "^8.1.0",
+    "@typescript-eslint/utils": "^8.1.0",
     "ts-pattern": "^5.3.1",
-    "@eslint-react/ast": "1.10.1-next.2",
-    "@eslint-react/core": "1.10.1-next.2",
-    "@eslint-react/jsx": "1.10.1-next.2",
-    "@eslint-react/shared": "1.10.1-next.2",
-    "@eslint-react/tools": "1.10.1-next.2",
-    "@eslint-react/var": "1.10.1-next.2",
-    "@eslint-react/types": "1.10.1-next.2"
+    "@eslint-react/ast": "1.10.1",
+    "@eslint-react/core": "1.10.1",
+    "@eslint-react/jsx": "1.10.1",
+    "@eslint-react/tools": "1.10.1",
+    "@eslint-react/var": "1.10.1",
+    "@eslint-react/types": "1.10.1",
+    "@eslint-react/shared": "1.10.1"
   },
   "devDependencies": {
     "@types/react": "^18.3.3",