anu-verzum 1.21.7 → 1.22.0

package/README.md

@@ -4,7 +4,7 @@
 
 <h3>@author: <strong>Anubis-programmer</strong></h3>
 <h3>@license: <strong>MIT</strong></h3>
-<h3>@version: <strong>1.21.7</strong></h3>
+<h3>@version: <strong>1.22.0</strong></h3>
 
 <br>
 
@@ -17,6 +17,7 @@ A lightweight React-inspired UI library for building component-based web applica
 - Client-side routing over the History API
 - Context API, i18n (Intl), feature flags, and built-in event analytics (Anulytics)
 - Ships with TypeScript declaration files — no `@types` package needed
+- Built-in testing companion — **Anu Testing Library (ATL)** shipped as `anu-verzum/testing`
 
 <br>
 <hr>
@@ -188,16 +189,43 @@ The following types are exported from `anu-verzum` for use in consumer projects:
 #### Library development scripts
 
 ```bash
-npm run clean       # Delete dist/ entirely
-npm run build       # Clean, compile TypeScript sources to dist/, and emit .d.ts files
-npm run typecheck   # Type-check without emitting any output
-npm run lint        # Run ESLint on all source files
-npm run format      # Format all source files with Prettier
+npm run clean           # Delete dist/ entirely
+npm run build           # Clean, compile TypeScript sources to dist/, and emit .d.ts files
+npm run typecheck       # Type-check without emitting any output
+npm run lint            # Run ESLint on all source files
+npm run format          # Format all source files with Prettier
+npm test                # Run the Anu Testing Library test suite with Jest
+npm run test:watch      # Run Jest in interactive watch mode
+npm run test:coverage   # Run Jest and generate a coverage report
 ```
 
 <br>
 <hr>
 
+<h2 id="testing">Testing</h2>
+
+ANUVerzum ships a built-in testing library — **Anu Testing Library (ATL)** — importable as `anu-verzum/testing`. It mirrors the philosophy of Testing Library: query the DOM the way a user would (by role, text, label), fire events, and assert on real output — no component internals, no custom matchers.
+
+```typescript
+import Anu from 'anu-verzum';
+import { render, fireEvent } from 'anu-verzum/testing';
+
+const { getByText, getByRole } = render(<Counter />);
+fireEvent.click(getByRole('button'));
+expect(getByText('Count: 1')).toBeDefined();
+```
+
+If TypeScript reports that `describe`, `test`, or `expect` are not found, your `tsconfig.json` likely has an explicit `"types"` list. Add `"jest"` to it — and `"node"` if tests reference `process.env`:
+
+```json
+{ "compilerOptions": { "types": ["node", "jest"] } }
+```
+
+See **[USERS_MANUAL.md — Testing](./documentation/USERS_MANUAL.md#testing)** for the full API reference and usage guide.
+
+<br>
+<hr>
+
 <h2>Documentation</h2>
 
 Full usage documentation, API reference, and code examples:

package/dist/core/components/AnulyticsProvider.d.ts

@@ -29,3 +29,6 @@ declare class AnulyticsProvider extends Component<AnulyticsProviderProps> {
     render(): AnuElement | AnuElement[] | null;
 }
 export default AnulyticsProvider;
+export declare const __testing: {
+    reset(): void;
+};

package/dist/core/components/AnulyticsProvider.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.trackStateChange = exports.trackRouteChange = exports.trackEvent = exports.default = void 0;
+exports.trackStateChange = exports.trackRouteChange = exports.trackEvent = exports.default = exports.__testing = void 0;
 var _Component = require("./Component");
 var _serverApi = _interopRequireDefault(require("../../server-api/server-api"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -218,4 +218,12 @@ class AnulyticsProvider extends _Component.Component {
     }
   }
 }
-var _default = exports.default = AnulyticsProvider;
+var _default = exports.default = AnulyticsProvider;
+const __testing = exports.__testing = {
+  reset() {
+    if (process.env.NODE_ENV !== 'test') {
+      return;
+    }
+    AnulyticsState.setAnulyticsInstanceExist(false);
+  }
+};

package/dist/core/components/History.d.ts

@@ -47,3 +47,6 @@ declare const History: {
     getAllUrlParamNames: () => string[];
 };
 export default History;
+export declare const __testing: {
+    reset(): void;
+};

package/dist/core/components/History.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.goTo = exports.default = void 0;
+exports.goTo = exports.default = exports.__testing = void 0;
 var _elements = require("../elements");
 var _Component = require("./Component");
 var _AnulyticsProvider = require("./AnulyticsProvider");
@@ -210,4 +210,12 @@ const History = {
   getUrlParams,
   getAllUrlParamNames
 };
-var _default = exports.default = History;
+var _default = exports.default = History;
+const __testing = exports.__testing = {
+  reset() {
+    if (process.env.NODE_ENV !== 'test') {
+      return;
+    }
+    instances.length = 0;
+  }
+};

package/dist/core/components/Intl.d.ts

@@ -21,3 +21,6 @@ declare const Intl: {
     Provider: ({ locale, messages, defaultLocale, children }: IntlProviderProps) => AnuElement | null;
 };
 export default Intl;
+export declare const __testing: {
+    reset(): void;
+};

package/dist/core/components/Intl.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.__testing = void 0;
 var _elements = require("../elements");
 var _Context = require("./Context");
 const _Intl = (0, _Context.createContext)({});
@@ -168,4 +168,15 @@ const Intl = {
   formatMessage,
   Provider: IntlProvider
 };
-var _default = exports.default = Intl;
+var _default = exports.default = Intl;
+const __testing = exports.__testing = {
+  reset() {
+    if (process.env.NODE_ENV !== 'test') {
+      return;
+    }
+    __messagesContext = {
+      locale: undefined,
+      messages: {}
+    };
+  }
+};

package/dist/core/elements.d.ts

@@ -12,7 +12,7 @@ export type Ref<T> = {
 };
 export type FunctionComponent<P extends Props = Props> = (props: P) => AnuElement<any, any> | AnuElement<any, any>[] | string | number | boolean | null | undefined;
 export type ComponentConstructor<P extends Props = Props> = new (props: P, context?: Record<string, any>) => any;
-export type ElementType = string | FunctionComponent | ComponentConstructor;
+export type ElementType = string | FunctionComponent<any> | ComponentConstructor<any>;
 export type AnuElement<P = Props, T extends ElementType = ElementType> = {
     type: T;
     props: P;

package/dist/core/reconciler.d.ts

@@ -2,3 +2,8 @@ import { AnuElement, Ref } from './elements';
 export declare const createRef: <T = any>() => Ref<T>;
 export declare const scheduleUpdate: (instance: any, partialState: Record<string, any>, partialStateCallback?: (prevState: any, prevProps: any) => any) => void;
 export declare const render: (elements: AnuElement | AnuElement[], containerDom: Element) => void;
+export declare const unmountComponentAtNode: (containerDom: Element) => void;
+export declare const __testing: {
+    flushSync(): void;
+    resetGlobals(): void;
+};

package/dist/core/reconciler.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.scheduleUpdate = exports.render = exports.createRef = void 0;
+exports.unmountComponentAtNode = exports.scheduleUpdate = exports.render = exports.createRef = exports.__testing = void 0;
 var _domUtils = require("./domUtils");
 const HOST_COMPONENT = 'host';
 const CLASS_COMPONENT = 'class';
@@ -446,4 +446,43 @@ const render = (elements, containerDom) => {
   });
   requestIdleCallback(performWork);
 };
-exports.render = render;
+exports.render = render;
+const unmountComponentAtNode = containerDom => {
+  if (!containerDom._rootContainerFiber) {
+    return;
+  }
+  updateQueue.push({
+    from: HOST_ROOT,
+    dom: containerDom,
+    newProps: {
+      children: []
+    }
+  });
+  requestIdleCallback(performWork);
+};
+exports.unmountComponentAtNode = unmountComponentAtNode;
+const __testing = exports.__testing = {
+  flushSync() {
+    if (process.env.NODE_ENV !== 'test') {
+      return;
+    }
+    const syncDeadline = {
+      didTimeout: false,
+      timeRemaining: () => 999
+    };
+    while (updateQueue.length > 0 || nextUnitOfWork != null) {
+      workLoop(syncDeadline);
+    }
+    nextUnitOfWork = null;
+    pendingCommit = null;
+  },
+  resetGlobals() {
+    if (process.env.NODE_ENV !== 'test') {
+      return;
+    }
+    updateQueue.length = 0;
+    componentLifecyclesQueue.length = 0;
+    nextUnitOfWork = null;
+    pendingCommit = null;
+  }
+};

package/dist/testing/__tests__/smoke.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/testing/__tests__/smoke.test.js

@@ -0,0 +1,180 @@
+"use strict";
+
+var _index = _interopRequireWildcard(require("../../index"));
+var _index2 = require("../index");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+class Counter extends _index.Component {
+  state = {
+    count: 0
+  };
+  render() {
+    return _index.default.createElement('div', {}, _index.default.createElement('p', {}, `Count: ${this.state.count}`), _index.default.createElement('button', {
+      onClick: () => this.setState({
+        count: this.state.count + 1
+      })
+    }, 'Increment'));
+  }
+}
+const Greeting = ({
+  name
+}) => _index.default.createElement('h1', {}, `Hello, ${name}!`);
+describe('render', () => {
+  test('renders a function component', () => {
+    const {
+      getByText
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'World'
+    }));
+    expect(getByText('Hello, World!')).toBeDefined();
+  });
+  test('renders a class component', () => {
+    const {
+      getByText
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    expect(getByText('Count: 0')).toBeDefined();
+  });
+  test('returns a container attached to document.body', () => {
+    const {
+      container
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'test'
+    }));
+    expect(document.body.contains(container)).toBe(true);
+  });
+});
+describe('queries', () => {
+  test('getByRole finds button', () => {
+    const {
+      getByRole
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    const btn = getByRole('button');
+    expect(btn).toBeDefined();
+    expect(btn.textContent).toBe('Increment');
+  });
+  test('getByRole with name option', () => {
+    const {
+      getByRole
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    const btn = getByRole('button', {
+      name: 'Increment'
+    });
+    expect(btn).toBeDefined();
+  });
+  test('queryByText returns null when not found', () => {
+    const {
+      queryByText
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'test'
+    }));
+    expect(queryByText('Not here')).toBeNull();
+  });
+  test('getByText throws when not found', () => {
+    const {
+      getByText
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'test'
+    }));
+    expect(() => getByText('Not here')).toThrow();
+  });
+  test('findByText resolves asynchronously', async () => {
+    const {
+      findByText
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'World'
+    }));
+    const el = await findByText('Hello, World!');
+    expect(el).toBeDefined();
+  });
+});
+describe('fireEvent', () => {
+  test('click triggers onClick and re-renders', () => {
+    const {
+      getByText,
+      getByRole
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    expect(getByText('Count: 0')).toBeDefined();
+    _index2.fireEvent.click(getByRole('button'));
+    expect(getByText('Count: 1')).toBeDefined();
+  });
+  test('multiple clicks accumulate', () => {
+    const {
+      getByText,
+      getByRole
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    _index2.fireEvent.click(getByRole('button'));
+    _index2.fireEvent.click(getByRole('button'));
+    _index2.fireEvent.click(getByRole('button'));
+    expect(getByText('Count: 3')).toBeDefined();
+  });
+});
+describe('userEvent', () => {
+  test('click fires full mouse event sequence', () => {
+    const {
+      getByText,
+      getByRole
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    _index2.userEvent.click(getByRole('button'));
+    expect(getByText('Count: 1')).toBeDefined();
+  });
+});
+describe('rerender', () => {
+  test('updates the component with new props', () => {
+    const {
+      getByText,
+      rerender
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'Alice'
+    }));
+    expect(getByText('Hello, Alice!')).toBeDefined();
+    rerender(_index.default.createElement(Greeting, {
+      name: 'Bob'
+    }));
+    expect(getByText('Hello, Bob!')).toBeDefined();
+  });
+});
+describe('waitFor', () => {
+  test('polls until assertion passes', async () => {
+    const {
+      getByText
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'World'
+    }));
+    await (0, _index2.waitFor)(() => {
+      expect(getByText('Hello, World!')).toBeDefined();
+    });
+  });
+  test('rejects when assertion never passes', async () => {
+    const {
+      queryByText
+    } = (0, _index2.render)(_index.default.createElement(Greeting, {
+      name: 'World'
+    }));
+    await expect((0, _index2.waitFor)(() => {
+      expect(queryByText('MISSING')).not.toBeNull();
+    }, {
+      timeout: 100,
+      interval: 20
+    })).rejects.toThrow();
+  });
+});
+describe('act', () => {
+  test('flushes state updates synchronously', () => {
+    const {
+      getByText,
+      getByRole
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    (0, _index2.act)(() => {
+      _index2.fireEvent.click(getByRole('button'));
+    });
+    expect(getByText('Count: 1')).toBeDefined();
+  });
+  test('wraps async callbacks', async () => {
+    const {
+      getByText
+    } = (0, _index2.render)(_index.default.createElement(Counter, {}));
+    await (0, _index2.act)(async () => {
+      await Promise.resolve();
+    });
+    expect(getByText('Count: 0')).toBeDefined();
+  });
+});

package/dist/testing/act.d.ts

@@ -0,0 +1,4 @@
+export declare const installSyncScheduler: () => void;
+export declare const uninstallSyncScheduler: () => void;
+export declare const flushEffects: () => void;
+export declare const act: (callback: () => void | Promise<void>) => void | Promise<void>;

package/dist/testing/act.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uninstallSyncScheduler = exports.installSyncScheduler = exports.flushEffects = exports.act = void 0;
+var _reconciler = require("../core/reconciler");
+const FAKE_DEADLINE = {
+  didTimeout: false,
+  timeRemaining: () => 999
+};
+let _installed = false;
+const installSyncScheduler = () => {
+  if (_installed) {
+    return;
+  }
+  _installed = true;
+  window.requestIdleCallback = cb => {
+    cb(FAKE_DEADLINE);
+    return 0;
+  };
+  window.cancelIdleCallback = () => {};
+};
+exports.installSyncScheduler = installSyncScheduler;
+const uninstallSyncScheduler = () => {
+  _installed = false;
+};
+exports.uninstallSyncScheduler = uninstallSyncScheduler;
+const flushEffects = () => {
+  _reconciler.__testing.flushSync();
+};
+exports.flushEffects = flushEffects;
+const act = callback => {
+  const result = callback();
+  if (result && typeof result.then === 'function') {
+    return result.then(() => {
+      _reconciler.__testing.flushSync();
+    });
+  }
+  _reconciler.__testing.flushSync();
+};
+exports.act = act;

package/dist/testing/cleanup.d.ts

@@ -0,0 +1,3 @@
+export declare const registerContainer: (container: Element) => void;
+export declare const cleanup: () => void;
+export declare const setupAutoCleanup: () => void;

package/dist/testing/cleanup.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setupAutoCleanup = exports.registerContainer = exports.cleanup = void 0;
+var _reconciler = require("../core/reconciler");
+var _History = require("../core/components/History");
+var _Intl = require("../core/components/Intl");
+var _AnulyticsProvider = require("../core/components/AnulyticsProvider");
+const mountedContainers = new Set();
+const registerContainer = container => {
+  mountedContainers.add(container);
+};
+exports.registerContainer = registerContainer;
+const cleanup = () => {
+  mountedContainers.forEach(container => {
+    container.parentNode?.removeChild(container);
+  });
+  mountedContainers.clear();
+  _reconciler.__testing.resetGlobals();
+  _History.__testing.reset();
+  _Intl.__testing.reset();
+  _AnulyticsProvider.__testing.reset();
+};
+exports.cleanup = cleanup;
+const setupAutoCleanup = () => {
+  if (typeof afterEach === 'function') {
+    afterEach(cleanup);
+  }
+};
+exports.setupAutoCleanup = setupAutoCleanup;

package/dist/testing/events/fireEvent.d.ts

@@ -0,0 +1,17 @@
+type EventInit = globalThis.EventInit & Record<string, any>;
+export declare const fireEvent: {
+    (element: Element, eventName: string, init?: EventInit): boolean;
+    click(el: Element, init?: MouseEventInit): boolean;
+    dblclick(el: Element, init?: MouseEventInit): boolean;
+    change(el: Element, init?: globalThis.EventInit): boolean;
+    input(el: Element, init?: globalThis.EventInit): boolean;
+    focus(el: Element, init?: FocusEventInit): boolean;
+    blur(el: Element, init?: FocusEventInit): boolean;
+    keyDown(el: Element, init?: KeyboardEventInit): boolean;
+    keyUp(el: Element, init?: KeyboardEventInit): boolean;
+    keyPress(el: Element, init?: KeyboardEventInit): boolean;
+    submit(el: Element, init?: globalThis.EventInit): boolean;
+    mouseDown(el: Element, init?: MouseEventInit): boolean;
+    mouseUp(el: Element, init?: MouseEventInit): boolean;
+};
+export {};

package/dist/testing/events/fireEvent.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fireEvent = void 0;
+var _act = require("../act");
+const buildEvent = (eventName, init) => {
+  const opts = {
+    bubbles: true,
+    cancelable: true,
+    ...init
+  };
+  if (/^(click|mouse|contextmenu|dblclick)/i.test(eventName)) {
+    return new MouseEvent(eventName, opts);
+  }
+  if (/^key/i.test(eventName)) {
+    return new KeyboardEvent(eventName, opts);
+  }
+  if (/^(focus|blur)/i.test(eventName)) {
+    return new FocusEvent(eventName, opts);
+  }
+  if (/^pointer/i.test(eventName)) {
+    return new PointerEvent(eventName, opts);
+  }
+  return new Event(eventName, opts);
+};
+const fireEvent = (element, eventName, init) => {
+  const dispatched = element.dispatchEvent(buildEvent(eventName, init));
+  (0, _act.flushEffects)();
+  return dispatched;
+};
+exports.fireEvent = fireEvent;
+fireEvent.click = (el, init) => fireEvent(el, 'click', init);
+fireEvent.dblclick = (el, init) => fireEvent(el, 'dblclick', init);
+fireEvent.change = (el, init) => fireEvent(el, 'change', init);
+fireEvent.input = (el, init) => fireEvent(el, 'input', init);
+fireEvent.focus = (el, init) => fireEvent(el, 'focus', init);
+fireEvent.blur = (el, init) => fireEvent(el, 'blur', init);
+fireEvent.keyDown = (el, init) => fireEvent(el, 'keydown', init);
+fireEvent.keyUp = (el, init) => fireEvent(el, 'keyup', init);
+fireEvent.keyPress = (el, init) => fireEvent(el, 'keypress', init);
+fireEvent.submit = (el, init) => fireEvent(el, 'submit', init);
+fireEvent.mouseDown = (el, init) => fireEvent(el, 'mousedown', init);
+fireEvent.mouseUp = (el, init) => fireEvent(el, 'mouseup', init);

package/dist/testing/events/userEvent.d.ts

@@ -0,0 +1,12 @@
+export declare const userEvent: {
+    click: (element: Element) => void;
+    dblclick: (element: Element) => void;
+    type: (element: HTMLInputElement | HTMLTextAreaElement, text: string) => void;
+    clear: (element: HTMLInputElement | HTMLTextAreaElement) => void;
+    change: (element: HTMLInputElement | HTMLSelectElement, value: string) => void;
+    submit: (form: HTMLFormElement) => void;
+    selectOption: (select: HTMLSelectElement, value: string) => void;
+    tab: (options?: {
+        shift?: boolean;
+    }) => void;
+};

package/dist/testing/events/userEvent.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.userEvent = void 0;
+var _fireEvent = require("./fireEvent");
+const userEvent = exports.userEvent = {
+  click: element => {
+    (0, _fireEvent.fireEvent)(element, 'mousedown');
+    (0, _fireEvent.fireEvent)(element, 'mouseup');
+    (0, _fireEvent.fireEvent)(element, 'click');
+  },
+  dblclick: element => {
+    (0, _fireEvent.fireEvent)(element, 'mousedown');
+    (0, _fireEvent.fireEvent)(element, 'mouseup');
+    (0, _fireEvent.fireEvent)(element, 'click');
+    (0, _fireEvent.fireEvent)(element, 'mousedown');
+    (0, _fireEvent.fireEvent)(element, 'mouseup');
+    (0, _fireEvent.fireEvent)(element, 'click');
+    (0, _fireEvent.fireEvent)(element, 'dblclick');
+  },
+  type: (element, text) => {
+    (0, _fireEvent.fireEvent)(element, 'focus');
+    for (const char of text) {
+      (0, _fireEvent.fireEvent)(element, 'keydown', {
+        key: char
+      });
+      (0, _fireEvent.fireEvent)(element, 'keypress', {
+        key: char
+      });
+      element.value += char;
+      (0, _fireEvent.fireEvent)(element, 'input');
+      (0, _fireEvent.fireEvent)(element, 'keyup', {
+        key: char
+      });
+    }
+    (0, _fireEvent.fireEvent)(element, 'change');
+  },
+  clear: element => {
+    (0, _fireEvent.fireEvent)(element, 'focus');
+    element.value = '';
+    (0, _fireEvent.fireEvent)(element, 'input');
+    (0, _fireEvent.fireEvent)(element, 'change');
+  },
+  change: (element, value) => {
+    element.value = value;
+    (0, _fireEvent.fireEvent)(element, 'input');
+    (0, _fireEvent.fireEvent)(element, 'change');
+  },
+  submit: form => {
+    (0, _fireEvent.fireEvent)(form, 'submit');
+  },
+  selectOption: (select, value) => {
+    select.value = value;
+    (0, _fireEvent.fireEvent)(select, 'change');
+  },
+  tab: (options = {}) => {
+    const focused = document.activeElement;
+    if (focused) {
+      (0, _fireEvent.fireEvent)(focused, 'keydown', {
+        key: 'Tab',
+        shiftKey: options.shift ?? false
+      });
+    }
+  }
+};

package/dist/testing/globals.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/testing/index.d.ts

@@ -0,0 +1,9 @@
+export { render } from './render';
+export { act, flushEffects, installSyncScheduler, uninstallSyncScheduler } from './act';
+export { cleanup, setupAutoCleanup } from './cleanup';
+export { waitFor, waitForElementToBeRemoved } from './waitFor';
+export { fireEvent } from './events/fireEvent';
+export { userEvent } from './events/userEvent';
+export { renderWithStore, renderWithRouter, renderWithIntl, renderWithContext } from './wrappers';
+export { buildQueries } from './queries/index';
+export type { RenderOptions, RenderResult, BoundQueries, BoundQuery, ByRoleOptions, TextMatch, WaitForOptions, } from './types';