@multiplatform.one/test-utils 7.49.1 → 7.49.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/test-utils",
-  "version": "7.49.1",
+  "version": "7.49.2",
   "description": "Shared testing utilities for multiplatform.one packages",
   "keywords": [
     "multiplatform.one",
@@ -43,6 +43,11 @@
       "import": "./src/setup.ts",
       "require": "./src/setup.ts"
     },
+    "./frames": {
+      "types": "./types/frames.d.ts",
+      "import": "./src/frames.ts",
+      "require": "./src/frames.ts"
+    },
     "./mocks": {
       "types": "./types/mocks.d.ts",
       "import": "./src/mocks.ts",

package/src/frames.ts

@@ -0,0 +1,85 @@
+/**
+ * Animation frames that die with the spec file that requested them (FZ-7904).
+ *
+ * A frame is one zero-delay timer, resolved at call time so fake timers still
+ * drive it. A bare Node timer belongs to Node, not to the test window, so the
+ * window's close() in vitest's teardown never stops it: a frame still pending
+ * when the file ends fires after teardown deleted the requestAnimationFrame
+ * global, and vitest fails the whole run on that one unhandled error. These
+ * frames stay tracked. close() cancels every pending frame and refuses new
+ * ones, which is what a browser does with the frames of a document it unloads.
+ */
+import { vi } from "vitest";
+
+export interface AnimationFrames {
+  request: (callback: FrameRequestCallback) => number;
+  cancel: (handle: number) => void;
+  close: () => void;
+}
+
+export function createAnimationFrames(): AnimationFrames {
+  const pending = new Map<number, ReturnType<typeof setTimeout>>();
+  let last = 0;
+  let closed = false;
+  return {
+    request(callback) {
+      last += 1;
+      const handle = last;
+      if (closed) return handle;
+      pending.set(
+        handle,
+        setTimeout(() => {
+          if (pending.delete(handle)) callback(performance.now());
+        }, 0),
+      );
+      return handle;
+    },
+    cancel(handle) {
+      clearTimeout(pending.get(handle));
+      pending.delete(handle);
+    },
+    close() {
+      closed = true;
+      for (const timer of pending.values()) clearTimeout(timer);
+      pending.clear();
+    },
+  };
+}
+
+export interface HeldAnimationFrames {
+  /** Frames requested and neither run nor cancelled. */
+  readonly pending: number;
+  /** Run the frames pending right now; frames they request wait for the next call. */
+  flush: () => void;
+}
+
+/**
+ * Replace requestAnimationFrame with frames that only run on `flush()`, so a
+ * spec can see which frames a component leaves behind. Undone by
+ * `vi.unstubAllGlobals()`.
+ */
+export function holdAnimationFrames(): HeldAnimationFrames {
+  const pending = new Map<number, FrameRequestCallback>();
+  let last = 0;
+  vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) => {
+    last += 1;
+    pending.set(last, callback);
+    return last;
+  });
+  vi.stubGlobal("cancelAnimationFrame", (handle: number) => {
+    pending.delete(handle);
+  });
+  return {
+    get pending() {
+      return pending.size;
+    },
+    flush() {
+      for (const handle of [...pending.keys()]) {
+        const callback = pending.get(handle);
+        if (!callback) continue;
+        pending.delete(handle);
+        callback(performance.now());
+      }
+    },
+  };
+}

package/src/setup.ts

@@ -217,7 +217,8 @@ import "matchmedia-polyfill";
 import { config } from "@tamagui/config";
 import { cleanup } from "@testing-library/react";
 import { createTamagui } from "tamagui";
-import { afterEach, beforeEach, vi } from "vitest";
+import { afterAll, afterEach, beforeEach, vi } from "vitest";
+import { createAnimationFrames } from "./frames";
 
 // Patch @floating-ui/react to handle missing forEach in test environment
 try {
@@ -306,14 +307,12 @@ window.matchMedia =
     removeListener: () => {},
   }));
 
-// requestAnimationFrame / cancelAnimationFrame polyfill
-global.requestAnimationFrame = ((callback: FrameRequestCallback): number => {
-  return setTimeout(callback, 0) as unknown as number;
-}) as typeof window.requestAnimationFrame;
-
-global.cancelAnimationFrame = (id: number): void => {
-  clearTimeout(id);
-};
+// Tracked frames (FZ-7904). This afterAll is registered first, so it runs
+// last in the file: after every unmount, before vitest tears the window down.
+const animationFrames = createAnimationFrames();
+global.requestAnimationFrame = animationFrames.request;
+global.cancelAnimationFrame = animationFrames.cancel;
+afterAll(animationFrames.close);
 
 // ResizeObserver mock
 class MockResizeObserver {

package/types/frames.d.ts

@@ -0,0 +1,19 @@
+export interface AnimationFrames {
+    request: (callback: FrameRequestCallback) => number;
+    cancel: (handle: number) => void;
+    close: () => void;
+}
+export declare function createAnimationFrames(): AnimationFrames;
+export interface HeldAnimationFrames {
+    /** Frames requested and neither run nor cancelled. */
+    readonly pending: number;
+    /** Run the frames pending right now; frames they request wait for the next call. */
+    flush: () => void;
+}
+/**
+ * Replace requestAnimationFrame with frames that only run on `flush()`, so a
+ * spec can see which frames a component leaves behind. Undone by
+ * `vi.unstubAllGlobals()`.
+ */
+export declare function holdAnimationFrames(): HeldAnimationFrames;
+//# sourceMappingURL=frames.d.ts.map

package/types/frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../src/frames.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,MAAM,CAAC;IACpD,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CA2BvD;AAED,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,mBAAmB,CAwBzD"}