@trackunit/react-vite-test-setup 0.0.49-alpha-df0e8d549b3.0 → 0.0.50

package/index.cjs.js

@@ -1,13 +1,13 @@
 'use strict';
 
+var react = require('@testing-library/react');
+var vitest = require('vitest');
 require('vitest-canvas-mock');
 var failOnConsole = require('vitest-fail-on-console');
 var jsxRuntime = require('react/jsx-runtime');
-var vitest = require('vitest');
 require('@testing-library/jest-dom/vitest');
-var react$1 = require('@testing-library/react');
 var util = require('util');
-var react = require('react');
+var react$1 = require('react');
 var reactI18next = require('react-i18next');
 var polyfill = require('@js-temporal/polyfill');
 var web = require('@react-spring/web');
@@ -32,6 +32,66 @@ function _interopNamespaceDefault(e) {
 
 var reactI18next__namespace = /*#__PURE__*/_interopNamespaceDefault(reactI18next);
 
+// Tracks the decorators we've installed so repeated `setupReactTestingLibrary()`
+// calls don't stack the decorator on top of itself.
+const reliableAsyncWrappers = new WeakSet();
+/**
+ * Makes React Testing Library's async utilities (`waitFor`, `findBy*`,
+ * `waitForElementToBeRemoved`) poll in real wall-clock time even though
+ * `setupTimeAndLanguage` collapses the global `setTimeout`/`setInterval` to fire
+ * at 0ms.
+ *
+ * Every RTL async utility funnels through the configurable `asyncWrapper`:
+ * `@testing-library/react` installs an `act`-based one on import, and
+ * `@testing-library/dom`'s `waitFor` — plus `findBy*` and
+ * `waitForElementToBeRemoved`, which build on the module-internal `waitFor` —
+ * run their poll/timeout loop inside it. We decorate that single seam: for the
+ * duration of each async-utility call we temporarily restore the real timers
+ * (`globalThis.ORG_setTimeout`/`ORG_setInterval`), then put the collapsed 0ms
+ * timers back in a `finally`. Timers stay instant everywhere else, so debounces
+ * and animations still resolve immediately and the suite does not slow down.
+ *
+ * Guards:
+ *  - Delegates unchanged when fake timers are active (`vi.isFakeTimers()`), so
+ *    opt-in fake-timer tests keep RTL's fake-timer path.
+ *  - No-ops the timer swap when `ORG_setTimeout` is absent (projects that don't
+ *    collapse timers), leaving behaviour unchanged there.
+ *  - Idempotent: repeated calls don't stack decorators.
+ *
+ * Must run after RTL's `act` wrapper is installed, i.e. from
+ * `setupReactTestingLibrary()`.
+ */
+const configureReliableAsyncUtils = () => {
+    const originalAsyncWrapper = react.getConfig().asyncWrapper;
+    if (reliableAsyncWrappers.has(originalAsyncWrapper)) {
+        return;
+    }
+    const reliableAsyncWrapper = async (cb) => {
+        const orgSetTimeout = globalThis.ORG_setTimeout;
+        const orgSetInterval = globalThis.ORG_setInterval;
+        // Preserve fake-timer tests, and don't touch projects that never collapsed
+        // timers in the first place.
+        if (vitest.vi.isFakeTimers() || orgSetTimeout === undefined) {
+            return originalAsyncWrapper(cb);
+        }
+        const collapsedSetTimeout = global.setTimeout;
+        const collapsedSetInterval = global.setInterval;
+        global.setTimeout = orgSetTimeout;
+        if (orgSetInterval !== undefined) {
+            global.setInterval = orgSetInterval;
+        }
+        try {
+            return await originalAsyncWrapper(cb);
+        }
+        finally {
+            global.setTimeout = collapsedSetTimeout;
+            global.setInterval = collapsedSetInterval;
+        }
+    };
+    reliableAsyncWrappers.add(reliableAsyncWrapper);
+    react.configure({ asyncWrapper: reliableAsyncWrapper });
+};
+
 /**
  * Sets up a mock implementation for HTML Canvas API in testing environments.
  *
@@ -599,13 +659,13 @@ const setupTranslations = () => {
         }
         return Object.keys(reactNodes).map((key, i) => {
             const child = reactNodes[key];
-            const isElement = react.isValidElement(child);
+            const isElement = react$1.isValidElement(child);
             if (typeof child === "string") {
                 return child;
             }
             if (hasChildren(child)) {
                 const inner = renderNodes(getChildren(child));
-                return react.cloneElement(child, { ...child.props, key: i }, inner);
+                return react$1.cloneElement(child, { ...child.props, key: i }, inner);
             }
             if (typeof child === "object" && !isElement) {
                 return Object.keys(child).reduce((str, childKey) => `${str}${child[childKey]}`, "");
@@ -741,7 +801,7 @@ const installPostMessagePolyfill = () => {
  * @returns {Promise<void>} - Returns a promise that resolves after the wait time.
  */
 const flushPromisesInAct = (waitTimeInMS = 0) => {
-    return react$1.act(() => {
+    return react.act(() => {
         return new Promise(resolve => {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             if (global.ORG_setTimeout) {
@@ -764,7 +824,7 @@ vitest.afterEach(async () => {
     // `vi.useRealTimers()` is a no-op when no fake timers are installed.
     vitest.vi.useRealTimers();
     vitest.vi.clearAllMocks();
-    react$1.cleanup();
+    react.cleanup();
     await flushPromisesInAct();
 });
 const setupResponseForTanstackRouter = () => {
@@ -973,6 +1033,11 @@ const setupReactTestingLibrary = () => {
     setupResizeObserver();
     setupIntersectionObserver();
     installPostMessagePolyfill();
+    // Make RTL's async utilities (waitFor/findBy*/waitForElementToBeRemoved) wait
+    // in real wall-clock time despite the 0ms timer collapse from
+    // `setupTimeAndLanguage`. Runs last so RTL's `act` asyncWrapper is already
+    // installed before we decorate it. See `configureReliableAsyncUtils`.
+    configureReliableAsyncUtils();
 };
 
 /**
@@ -1292,6 +1357,7 @@ const setupTanstackReactRouter = () => {
     }));
 };
 
+exports.configureReliableAsyncUtils = configureReliableAsyncUtils;
 exports.createMockClickEvent = createMockClickEvent;
 exports.createMockMapboxMap = createMockMapboxMap;
 exports.setupAllMocks = setupAllMocks;

package/index.esm.js

@@ -1,9 +1,9 @@
+import { getConfig, configure, cleanup, act } from '@testing-library/react';
+import { vi, beforeEach, afterEach } from 'vitest';
 import 'vitest-canvas-mock';
 import failOnConsole from 'vitest-fail-on-console';
 import { jsx, Fragment } from 'react/jsx-runtime';
-import { vi, beforeEach, afterEach } from 'vitest';
 import '@testing-library/jest-dom/vitest';
-import { cleanup, act } from '@testing-library/react';
 import { TextEncoder, TextDecoder } from 'util';
 import { isValidElement, cloneElement } from 'react';
 import * as reactI18next from 'react-i18next';
@@ -11,6 +11,66 @@ import { Temporal } from '@js-temporal/polyfill';
 import { Globals } from '@react-spring/web';
 import { WritableStream, TransformStream } from 'web-streams-polyfill';
 
+// Tracks the decorators we've installed so repeated `setupReactTestingLibrary()`
+// calls don't stack the decorator on top of itself.
+const reliableAsyncWrappers = new WeakSet();
+/**
+ * Makes React Testing Library's async utilities (`waitFor`, `findBy*`,
+ * `waitForElementToBeRemoved`) poll in real wall-clock time even though
+ * `setupTimeAndLanguage` collapses the global `setTimeout`/`setInterval` to fire
+ * at 0ms.
+ *
+ * Every RTL async utility funnels through the configurable `asyncWrapper`:
+ * `@testing-library/react` installs an `act`-based one on import, and
+ * `@testing-library/dom`'s `waitFor` — plus `findBy*` and
+ * `waitForElementToBeRemoved`, which build on the module-internal `waitFor` —
+ * run their poll/timeout loop inside it. We decorate that single seam: for the
+ * duration of each async-utility call we temporarily restore the real timers
+ * (`globalThis.ORG_setTimeout`/`ORG_setInterval`), then put the collapsed 0ms
+ * timers back in a `finally`. Timers stay instant everywhere else, so debounces
+ * and animations still resolve immediately and the suite does not slow down.
+ *
+ * Guards:
+ *  - Delegates unchanged when fake timers are active (`vi.isFakeTimers()`), so
+ *    opt-in fake-timer tests keep RTL's fake-timer path.
+ *  - No-ops the timer swap when `ORG_setTimeout` is absent (projects that don't
+ *    collapse timers), leaving behaviour unchanged there.
+ *  - Idempotent: repeated calls don't stack decorators.
+ *
+ * Must run after RTL's `act` wrapper is installed, i.e. from
+ * `setupReactTestingLibrary()`.
+ */
+const configureReliableAsyncUtils = () => {
+    const originalAsyncWrapper = getConfig().asyncWrapper;
+    if (reliableAsyncWrappers.has(originalAsyncWrapper)) {
+        return;
+    }
+    const reliableAsyncWrapper = async (cb) => {
+        const orgSetTimeout = globalThis.ORG_setTimeout;
+        const orgSetInterval = globalThis.ORG_setInterval;
+        // Preserve fake-timer tests, and don't touch projects that never collapsed
+        // timers in the first place.
+        if (vi.isFakeTimers() || orgSetTimeout === undefined) {
+            return originalAsyncWrapper(cb);
+        }
+        const collapsedSetTimeout = global.setTimeout;
+        const collapsedSetInterval = global.setInterval;
+        global.setTimeout = orgSetTimeout;
+        if (orgSetInterval !== undefined) {
+            global.setInterval = orgSetInterval;
+        }
+        try {
+            return await originalAsyncWrapper(cb);
+        }
+        finally {
+            global.setTimeout = collapsedSetTimeout;
+            global.setInterval = collapsedSetInterval;
+        }
+    };
+    reliableAsyncWrappers.add(reliableAsyncWrapper);
+    configure({ asyncWrapper: reliableAsyncWrapper });
+};
+
 /**
  * Sets up a mock implementation for HTML Canvas API in testing environments.
  *
@@ -952,6 +1012,11 @@ const setupReactTestingLibrary = () => {
     setupResizeObserver();
     setupIntersectionObserver();
     installPostMessagePolyfill();
+    // Make RTL's async utilities (waitFor/findBy*/waitForElementToBeRemoved) wait
+    // in real wall-clock time despite the 0ms timer collapse from
+    // `setupTimeAndLanguage`. Runs last so RTL's `act` asyncWrapper is already
+    // installed before we decorate it. See `configureReliableAsyncUtils`.
+    configureReliableAsyncUtils();
 };
 
 /**
@@ -1271,4 +1336,4 @@ const setupTanstackReactRouter = () => {
     }));
 };
 
-export { createMockClickEvent, createMockMapboxMap, setupAllMocks, setupBasicMocks, setupCanvasMock, setupDefaultMocks, setupFailOnConsole, setupGoogleMaps, setupHelmetMock, setupIntersectionObserver, setupMapbox, setupMatchMediaMock, setupReactTestingLibrary, setupReactVirtualizedAutoSizer, setupResizeObserver, setupTanstackReactRouter, setupTanstackReactVirtual, setupTimeAndLanguage, setupTimeZone, setupTranslations, setupWebStreams };
+export { configureReliableAsyncUtils, createMockClickEvent, createMockMapboxMap, setupAllMocks, setupBasicMocks, setupCanvasMock, setupDefaultMocks, setupFailOnConsole, setupGoogleMaps, setupHelmetMock, setupIntersectionObserver, setupMapbox, setupMatchMediaMock, setupReactTestingLibrary, setupReactVirtualizedAutoSizer, setupResizeObserver, setupTanstackReactRouter, setupTanstackReactVirtual, setupTimeAndLanguage, setupTimeZone, setupTranslations, setupWebStreams };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trackunit/react-vite-test-setup",
   "description": "Test setup utilities for React applications",
-  "version": "0.0.49-alpha-df0e8d549b3.0",
+  "version": "0.0.50",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {

package/src/configureReliableAsyncUtils.d.ts

@@ -0,0 +1,31 @@
+declare global {
+    var ORG_setTimeout: typeof setTimeout | undefined;
+    var ORG_setInterval: typeof setInterval | undefined;
+}
+/**
+ * Makes React Testing Library's async utilities (`waitFor`, `findBy*`,
+ * `waitForElementToBeRemoved`) poll in real wall-clock time even though
+ * `setupTimeAndLanguage` collapses the global `setTimeout`/`setInterval` to fire
+ * at 0ms.
+ *
+ * Every RTL async utility funnels through the configurable `asyncWrapper`:
+ * `@testing-library/react` installs an `act`-based one on import, and
+ * `@testing-library/dom`'s `waitFor` — plus `findBy*` and
+ * `waitForElementToBeRemoved`, which build on the module-internal `waitFor` —
+ * run their poll/timeout loop inside it. We decorate that single seam: for the
+ * duration of each async-utility call we temporarily restore the real timers
+ * (`globalThis.ORG_setTimeout`/`ORG_setInterval`), then put the collapsed 0ms
+ * timers back in a `finally`. Timers stay instant everywhere else, so debounces
+ * and animations still resolve immediately and the suite does not slow down.
+ *
+ * Guards:
+ *  - Delegates unchanged when fake timers are active (`vi.isFakeTimers()`), so
+ *    opt-in fake-timer tests keep RTL's fake-timer path.
+ *  - No-ops the timer swap when `ORG_setTimeout` is absent (projects that don't
+ *    collapse timers), leaving behaviour unchanged there.
+ *  - Idempotent: repeated calls don't stack decorators.
+ *
+ * Must run after RTL's `act` wrapper is installed, i.e. from
+ * `setupReactTestingLibrary()`.
+ */
+export declare const configureReliableAsyncUtils: () => void;

package/src/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./configureReliableAsyncUtils";
 export * from "./setupAllMocks";
 export * from "./setupBasicMocks";
 export * from "./setupCanvasMock";