remove & forbid wrong act calls

.eslintrc

@@ -90,7 +90,8 @@
         "testing-library/prefer-user-event": "error",
         "testing-library/no-wait-for-multiple-assertions": "off",
         "local-rules/require-using-disposable": "error",
-        "local-rules/require-disable-act-environment": "error"
+        "local-rules/require-disable-act-environment": "error",
+        "local-rules/forbid-act-in-disabled-act-environment": "error"
       }
     }
   ],

eslint-local-rules/forbid-act-in-disabled-act-environment.test.ts

@@ -0,0 +1,56 @@
+import { rule } from "./forbid-act-in-disabled-act-environment";
+import { ruleTester } from "./testSetup";
+
+ruleTester.run("forbid-act-in-disabled-act-environment", rule, {
+  valid: [
+    `
+  () => {
+    using _disabledAct = disableActEnvironment();
+  }
+  () => {
+    act(() => {})
+  }
+    `,
+    `
+  () => {
+    using _disabledAct = disableActEnvironment();
+  }
+  () => {
+    actAsync(() => {})
+  }
+    `,
+  ],
+  invalid: [
+    `
+    () => {
+      using _disabledAct = disableActEnvironment();
+      act(() => {})
+    }
+      `,
+    `
+    () => {
+      using _disabledAct = disableActEnvironment();
+      actAsync(() => {})
+    }
+    `,
+    `
+    () => {
+      using _disabledAct = disableActEnvironment();
+      () => {
+        act(() => {})
+      }
+    }
+      `,
+    `
+    () => {
+      using _disabledAct = disableActEnvironment();
+      () => {
+        actAsync(() => {})
+      }
+    }
+    `,
+  ].map((code) => ({
+    code,
+    errors: [{ messageId: "forbiddenActInNonActEnvironment" }],
+  })),
+});

eslint-local-rules/forbid-act-in-disabled-act-environment.ts

@@ -0,0 +1,63 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+export const rule = ESLintUtils.RuleCreator.withoutDocs({
+  create(context) {
+    let depth = 1;
+    let disabledDepth: number | false = false;
+
+    function EnterFn() {
+      depth++;
+    }
+    function ExitFn() {
+      depth--;
+      if (disabledDepth !== false && disabledDepth > depth) {
+        disabledDepth = false;
+      }
+    }
+
+    return {
+      CallExpression(node) {
+        const directCallee =
+          node.callee.type === "Identifier" ? node.callee
+          : node.callee.type === "MemberExpression" ? node.callee.property
+          : null;
+
+        if (
+          directCallee?.type === "Identifier" &&
+          directCallee.name === "disableActEnvironment"
+        ) {
+          if (disabledDepth === false) {
+            disabledDepth = depth;
+          }
+        }
+
+        if (
+          directCallee?.type === "Identifier" &&
+          (directCallee.name === "act" || directCallee.name === "actAsync")
+        ) {
+          if (disabledDepth !== false) {
+            context.report({
+              messageId: "forbiddenActInNonActEnvironment",
+              node: node,
+            });
+          }
+        }
+      },
+      ArrowFunctionExpression: EnterFn,
+      FunctionExpression: EnterFn,
+      FunctionDeclaration: EnterFn,
+      "ArrowFunctionExpression:exit": ExitFn,
+      "FunctionExpression:exit": ExitFn,
+      "FunctionDeclaration:exit": ExitFn,
+    };
+  },
+  meta: {
+    messages: {
+      forbiddenActInNonActEnvironment:
+        "`act` should not be called in a `disableActEnvironment`.",
+    },
+    type: "problem",
+    schema: [],
+  },
+  defaultOptions: [],
+});

eslint-local-rules/index.js

@@ -13,4 +13,6 @@ module.exports = {
   "require-using-disposable": require("./require-using-disposable").rule,
   "require-disable-act-environment":
     require("./require-disable-act-environment").rule,
+  "forbid-act-in-disabled-act-environment":
+    require("./forbid-act-in-disabled-act-environment").rule,
 };

src/react/hooks/__tests__/useFragment.test.tsx

@@ -2002,12 +2002,9 @@ describe("has the same timing as `useQuery`", () => {
       expect(withinDOM().queryAllByText(/Item #2/).length).toBe(2);
     }
 
-    act(
-      () =>
-        void cache.evict({
-          id: cache.identify(item2),
-        })
-    );
+    cache.evict({
+      id: cache.identify(item2),
+    });
 
     {
       const { withinDOM } = await takeRender();