@mui/internal-test-utils 2.0.15 → 2.0.16

package/createRenderer.d.ts

@@ -0,0 +1,214 @@
+import { queries, RenderResult, fireEvent as rtlFireEvent, Screen, RenderOptions as TestingLibraryRenderOptions } from '@testing-library/react/pure';
+import { userEvent } from '@testing-library/user-event';
+import * as React from 'react';
+import { useFakeTimers } from 'sinon';
+declare function queryAllDescriptionsOf(baseElement: HTMLElement, element: Element): HTMLElement[];
+declare const customQueries: {
+  queryDescriptionOf: import("@testing-library/react/pure").QueryBy<[Element]>;
+  queryAllDescriptionsOf: typeof queryAllDescriptionsOf;
+  getDescriptionOf: import("@testing-library/react/pure").GetBy<[Element]>;
+  getAllDescriptionsOf: import("@testing-library/react/pure").GetAllBy<[Element]>;
+  findDescriptionOf: import("@testing-library/react/pure").FindBy<[Element]>;
+  findAllDescriptionsOf: import("@testing-library/react/pure").FindAllBy<[Element]>;
+};
+interface RenderConfiguration extends Pick<TestingLibraryRenderOptions, 'reactStrictMode'> {
+  /**
+   * https://testing-library.com/docs/react-testing-library/api#container
+   */
+  container?: HTMLElement;
+  /**
+   * if true does not cleanup before mount
+   */
+  disableUnmount?: boolean;
+  /**
+   * wrap in React.StrictMode?
+   */
+  strict?: boolean;
+  /**
+   * Set to `true` if the test fails due to [Strict Effects](https://github.com/reactwg/react-18/discussions/19).
+   */
+  strictEffects?: boolean;
+  wrapper: React.JSXElementConstructor<{
+    children?: React.ReactNode;
+  }>;
+}
+export type RenderOptions = Omit<Partial<RenderConfiguration>, 'reactStrictMode'>;
+export interface MuiRenderResult extends RenderResult<typeof queries & typeof customQueries> {
+  user: ReturnType<typeof userEvent.setup>;
+  forceUpdate(): void;
+  /**
+   * convenience helper. Better than repeating all props.
+   */
+  setProps(props: object): void;
+}
+export interface MuiRenderToStringResult {
+  container: HTMLElement;
+  hydrate(): MuiRenderResult;
+}
+interface DataAttributes {
+  [key: `data-${string}`]: string;
+}
+export interface Clock {
+  /**
+   * Runs all timers until there are no more remaining.
+   * WARNING: This may cause an infinite loop if a timeout constantly schedules another timeout.
+   * Prefer to to run only pending timers with `runToLast` and unmount your component directly.
+   */
+  runAll(): void;
+  /**
+   * Runs only the currently pending timers.
+   */
+  runToLast(): void;
+  /**
+   * Tick the clock ahead `timeoutMS` milliseconds.
+   * @param timeoutMS
+   */
+  tick(timeoutMS: number): void;
+  /**
+   * Returns true if we're running with "real" i.e. native timers.
+   */
+  isReal(): boolean;
+  /**
+   * Runs the current test suite (i.e. `describe` block) with fake timers.
+   */
+  withFakeTimers(): void;
+  /**
+   * Restore the real timer
+   */
+  restore(): void;
+}
+export type ClockConfig = undefined | number | Date;
+declare function createClock(defaultMode: 'fake' | 'real', config: ClockConfig, options: Exclude<Parameters<typeof useFakeTimers>[0], number | Date>): Clock;
+export interface Renderer {
+  clock: Clock;
+  render(element: React.ReactElement<DataAttributes>, options?: RenderOptions): MuiRenderResult;
+  renderToString(element: React.ReactElement<DataAttributes>, options?: RenderOptions): MuiRenderToStringResult;
+}
+export interface CreateRendererOptions extends Pick<RenderOptions, 'strict' | 'strictEffects'> {
+  /**
+   * @default 'real'
+   */
+  clock?: 'fake' | 'real';
+  clockConfig?: ClockConfig;
+  clockOptions?: Parameters<typeof createClock>[2];
+}
+export declare function createRenderer(globalOptions?: CreateRendererOptions): Renderer;
+declare const fireEvent: typeof rtlFireEvent;
+export declare function fireTouchChangedEvent(target: Element, type: 'touchstart' | 'touchmove' | 'touchend', options: {
+  changedTouches: Array<Pick<TouchInit, 'clientX' | 'clientY'>>;
+}): void;
+declare function act<T>(callback: () => T | Promise<T>): Promise<T>;
+declare function act(callback: () => void): void;
+declare const bodyBoundQueries: {
+  getByLabelText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.GetByText<T>>;
+  getAllByLabelText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.AllByText<T>>;
+  queryByLabelText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.QueryByText<T>>;
+  queryAllByLabelText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.AllByText<T>>;
+  findByLabelText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByText<T>>;
+  findAllByLabelText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByText<T>>;
+  getByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.GetByBoundAttribute<T>>;
+  getAllByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  queryByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.QueryByBoundAttribute<T>>;
+  queryAllByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  findByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByBoundAttribute<T>>;
+  findAllByPlaceholderText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByBoundAttribute<T>>;
+  getByText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.GetByText<T>>;
+  getAllByText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.AllByText<T>>;
+  queryByText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.QueryByText<T>>;
+  queryAllByText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined): ReturnType<queries.AllByText<T>>;
+  findByText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByText<T>>;
+  findAllByText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByText<T>>;
+  getByAltText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.GetByBoundAttribute<T>>;
+  getAllByAltText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  queryByAltText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.QueryByBoundAttribute<T>>;
+  queryAllByAltText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  findByAltText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByBoundAttribute<T>>;
+  findAllByAltText<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByBoundAttribute<T>>;
+  getByTitle<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.GetByBoundAttribute<T>>;
+  getAllByTitle<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  queryByTitle<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.QueryByBoundAttribute<T>>;
+  queryAllByTitle<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  findByTitle<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByBoundAttribute<T>>;
+  findAllByTitle<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByBoundAttribute<T>>;
+  getByDisplayValue<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.GetByBoundAttribute<T>>;
+  getAllByDisplayValue<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  queryByDisplayValue<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.QueryByBoundAttribute<T>>;
+  queryAllByDisplayValue<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  findByDisplayValue<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByBoundAttribute<T>>;
+  findAllByDisplayValue<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByBoundAttribute<T>>;
+  getByRole<T extends HTMLElement = HTMLElement>(role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined): ReturnType<queries.GetByRole<T>>;
+  getAllByRole<T extends HTMLElement = HTMLElement>(role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined): ReturnType<queries.AllByRole<T>>;
+  queryByRole<T extends HTMLElement = HTMLElement>(role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined): ReturnType<queries.QueryByRole<T>>;
+  queryAllByRole<T extends HTMLElement = HTMLElement>(role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined): ReturnType<queries.AllByRole<T>>;
+  findByRole<T extends HTMLElement = HTMLElement>(role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByRole<T>>;
+  findAllByRole<T extends HTMLElement = HTMLElement>(role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByRole<T>>;
+  getByTestId<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.GetByBoundAttribute<T>>;
+  getAllByTestId<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  queryByTestId<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.QueryByBoundAttribute<T>>;
+  queryAllByTestId<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined): ReturnType<queries.AllByBoundAttribute<T>>;
+  findByTestId<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindByBoundAttribute<T>>;
+  findAllByTestId<T extends HTMLElement = HTMLElement>(id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined): ReturnType<queries.FindAllByBoundAttribute<T>>;
+} & {
+  queryDescriptionOf: (args_0: Element) => HTMLElement | null;
+  queryAllDescriptionsOf: (element: Element) => HTMLElement[];
+  getDescriptionOf: (args_0: Element) => HTMLElement;
+  getAllDescriptionsOf: (args_0: Element) => HTMLElement[];
+  findDescriptionOf: (args_0: Element, args_1?: undefined, args_2?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllDescriptionsOf: (args_0: Element, args_1?: undefined, args_2?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByLabelText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement;
+  getAllByLabelText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement[];
+  queryByLabelText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement | null;
+  queryAllByLabelText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement[];
+  findByLabelText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByLabelText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByPlaceholderText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement;
+  getAllByPlaceholderText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  queryByPlaceholderText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement | null;
+  queryAllByPlaceholderText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  findByPlaceholderText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByPlaceholderText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement;
+  getAllByText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement[];
+  queryByText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement | null;
+  queryAllByText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined) => HTMLElement[];
+  findByText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByAltText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement;
+  getAllByAltText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  queryByAltText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement | null;
+  queryAllByAltText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  findByAltText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByAltText: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByTitle: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement;
+  getAllByTitle: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  queryByTitle: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement | null;
+  queryAllByTitle: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  findByTitle: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByTitle: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByDisplayValue: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement;
+  getAllByDisplayValue: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  queryByDisplayValue: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement | null;
+  queryAllByDisplayValue: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  findByDisplayValue: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByDisplayValue: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByRole: (role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined) => HTMLElement;
+  getAllByRole: (role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined) => HTMLElement[];
+  queryByRole: (role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined) => HTMLElement | null;
+  queryAllByRole: (role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined) => HTMLElement[];
+  findByRole: (role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByRole: (role: import("@testing-library/react/pure").ByRoleMatcher, options?: queries.ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+  getByTestId: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement;
+  getAllByTestId: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  queryByTestId: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement | null;
+  queryAllByTestId: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined) => HTMLElement[];
+  findByTestId: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement>;
+  findAllByTestId: (id: import("@testing-library/react/pure").Matcher, options?: import("@testing-library/react/pure").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react/pure").waitForOptions | undefined) => Promise<HTMLElement[]>;
+};
+export { renderHook, waitFor, within, createEvent, type RenderHookResult, type EventType } from '@testing-library/react/pure';
+export { act, fireEvent };
+export declare const screen: Screen & typeof bodyBoundQueries;
+export declare function flushEffects(): Promise<void>;
+/**
+ * returns true when touch is suported and can be mocked
+ */
+export declare function supportsTouch(): boolean;

package/createRenderer.js

@@ -0,0 +1,428 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.act = act;
+Object.defineProperty(exports, "createEvent", {
+  enumerable: true,
+  get: function () {
+    return _pure.createEvent;
+  }
+});
+exports.createRenderer = createRenderer;
+exports.fireEvent = void 0;
+exports.fireTouchChangedEvent = fireTouchChangedEvent;
+exports.flushEffects = flushEffects;
+Object.defineProperty(exports, "renderHook", {
+  enumerable: true,
+  get: function () {
+    return _pure.renderHook;
+  }
+});
+exports.screen = void 0;
+exports.supportsTouch = supportsTouch;
+Object.defineProperty(exports, "waitFor", {
+  enumerable: true,
+  get: function () {
+    return _pure.waitFor;
+  }
+});
+Object.defineProperty(exports, "within", {
+  enumerable: true,
+  get: function () {
+    return _pure.within;
+  }
+});
+var _cache = _interopRequireDefault(require("@emotion/cache"));
+var _react = require("@emotion/react");
+var _pure = require("@testing-library/react/pure");
+var _userEvent = require("@testing-library/user-event");
+var React = _interopRequireWildcard(require("react"));
+var ReactDOMServer = _interopRequireWildcard(require("react-dom/server"));
+var _vitest = require("vitest");
+var _reactMajor = _interopRequireDefault(require("./reactMajor"));
+var _jsxRuntime = require("react/jsx-runtime");
+/* eslint-disable compat/compat -- Test environment */
+
+function queryAllDescriptionsOf(baseElement, element) {
+  const ariaDescribedBy = element.getAttribute('aria-describedby');
+  if (ariaDescribedBy === null) {
+    return [];
+  }
+  return ariaDescribedBy.split(' ').map(id => {
+    return document.getElementById(id);
+  }).filter(maybeElement => {
+    return maybeElement !== null && baseElement.contains(maybeElement);
+  });
+}
+const [queryDescriptionOf, getAllDescriptionsOf, getDescriptionOf, findAllDescriptionsOf, findDescriptionOf] = (0, _pure.buildQueries)(queryAllDescriptionsOf, function getMultipleError() {
+  return `Found multiple descriptions.`;
+}, function getMissingError() {
+  return `Found no describing element.`;
+});
+const customQueries = {
+  queryDescriptionOf,
+  queryAllDescriptionsOf,
+  getDescriptionOf,
+  getAllDescriptionsOf,
+  findDescriptionOf,
+  findAllDescriptionsOf
+};
+function render(element, configuration) {
+  const {
+    container,
+    hydrate,
+    wrapper,
+    reactStrictMode
+  } = configuration;
+  const testingLibraryRenderResult = (0, _pure.render)(element, {
+    container,
+    hydrate,
+    queries: {
+      ..._pure.queries,
+      ...customQueries
+    },
+    wrapper,
+    reactStrictMode
+  });
+  const result = {
+    ...testingLibraryRenderResult,
+    user: _userEvent.userEvent.setup({
+      document
+    }),
+    forceUpdate() {
+      testingLibraryRenderResult.rerender(/*#__PURE__*/React.cloneElement(element, {
+        'data-force-update': String(Math.random())
+      }));
+    },
+    setProps(props) {
+      testingLibraryRenderResult.rerender(/*#__PURE__*/React.cloneElement(element, props));
+    }
+  };
+  return result;
+}
+function renderToString(element, configuration) {
+  const {
+    container,
+    wrapper: Wrapper
+  } = configuration;
+  container.innerHTML = ReactDOMServer.renderToString(/*#__PURE__*/(0, _jsxRuntime.jsx)(Wrapper, {
+    children: element
+  }));
+  return {
+    container,
+    hydrate() {
+      return render(element, {
+        ...configuration,
+        hydrate: true
+      });
+    }
+  };
+}
+function createClock(defaultMode, config, options) {
+  if (defaultMode === 'fake') {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.useFakeTimers({
+        now: config,
+        // useIsFocusVisible schedules a global timer that needs to persist regardless of whether components are mounted or not.
+        // Technically we'd want to reset all modules between tests but we don't have that technology.
+        // In the meantime just continue to clear native timers like we did for the past years when using `sinon` < 8.
+        shouldClearNativeTimers: true,
+        toFake: ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame', 'cancelAnimationFrame', 'performance', 'Date'],
+        ...options
+      });
+      if (config) {
+        _vitest.vi.setSystemTime(config);
+      }
+    });
+  } else {
+    (0, _vitest.beforeEach)(() => {
+      if (config) {
+        _vitest.vi.setSystemTime(config);
+      }
+    });
+  }
+  (0, _vitest.afterEach)(async () => {
+    if (_vitest.vi.isFakeTimers()) {
+      await (0, _pure.act)(async () => {
+        _vitest.vi.runOnlyPendingTimers();
+      });
+      _vitest.vi.useRealTimers();
+    }
+  });
+  return {
+    withFakeTimers: () => {
+      if (_vitest.vi.isFakeTimers()) {
+        return;
+      }
+      (0, _vitest.beforeEach)(() => {
+        _vitest.vi.useFakeTimers({
+          now: config,
+          // useIsFocusVisible schedules a global timer that needs to persist regardless of whether components are mounted or not.
+          // Technically we'd want to reset all modules between tests but we don't have that technology.
+          // In the meantime just continue to clear native timers like we did for the past years when using `sinon` < 8.
+          shouldClearNativeTimers: true,
+          toFake: ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame', 'cancelAnimationFrame', 'performance', 'Date'],
+          ...options
+        });
+        if (config) {
+          _vitest.vi.setSystemTime(config);
+        }
+      });
+    },
+    runToLast: () => {
+      (0, _pure.act)(() => {
+        _vitest.vi.runOnlyPendingTimers();
+      });
+    },
+    isReal() {
+      return !_vitest.vi.isFakeTimers();
+    },
+    restore() {
+      _vitest.vi.useRealTimers();
+    },
+    tick(timeoutMS) {
+      (0, _pure.act)(() => {
+        _vitest.vi.advanceTimersByTime(timeoutMS);
+      });
+    },
+    runAll() {
+      (0, _pure.act)(() => {
+        _vitest.vi.runAllTimers();
+      });
+    }
+  };
+}
+function createRenderer(globalOptions = {}) {
+  const {
+    clock: clockMode = 'real',
+    clockConfig,
+    strict: globalStrict = true,
+    strictEffects: globalStrictEffects = globalStrict,
+    clockOptions
+  } = globalOptions;
+  // save stack to re-use in test-hooks
+  const {
+    stack: createClientRenderStack
+  } = new Error();
+  const clock = createClock(clockMode, clockConfig, clockOptions);
+
+  /**
+   * Flag whether `createRenderer` was called in a suite i.e. describe() block.
+   * For legacy reasons `createRenderer` might accidentally be called in a beforeAll(Each) hook.
+   */
+  let wasCalledInSuite = false;
+  (0, _vitest.beforeAll)(function beforeHook() {
+    wasCalledInSuite = true;
+  });
+  let emotionCache = null;
+  /**
+   * target container for SSR
+   */
+  let serverContainer;
+  /**
+   * Flag whether all setup for `configuredClientRender` was completed.
+   * For legacy reasons `configuredClientRender` might accidentally be called in a beforeAll(Each) hook.
+   */
+  let prepared = false;
+  (0, _vitest.beforeEach)(function beforeEachHook() {
+    if (!wasCalledInSuite) {
+      const error = new Error('Unable to run `before` hook for `createRenderer`. This usually indicates that `createRenderer` was called in a `before` hook instead of in a `describe()` block.');
+      error.stack = createClientRenderStack;
+      throw error;
+    }
+    const id = _vitest.expect.getState().currentTestName;
+    if (!id) {
+      throw new Error('Unable to find the currently running test. This is a bug with the client-renderer. Please report this issue to a maintainer.');
+    }
+    emotionCache = (0, _cache.default)({
+      key: 'emotion-client-render'
+    });
+    serverContainer = document.createElement('div');
+    document.body.appendChild(serverContainer);
+    prepared = true;
+  });
+  (0, _vitest.afterEach)(() => {
+    if (!clock.isReal()) {
+      const error = new Error("Can't cleanup before fake timers are restored.\n" + 'Be sure to:\n' + '  1. Only use `clock` from `createRenderer`.\n' + '  2. Call `createRenderer` in a suite and not any test hook (for example `beforeEach`) or test itself (for example `it`).');
+      // Use saved stack otherwise the stack trace will not include the test location.
+      error.stack = createClientRenderStack;
+      throw error;
+    }
+    (0, _pure.cleanup)();
+    emotionCache.sheet.tags.forEach(styleTag => {
+      styleTag.remove();
+    });
+    emotionCache = null;
+    serverContainer.remove();
+    serverContainer = null;
+  });
+  function createWrapper(options) {
+    const {
+      wrapper: InnerWrapper = React.Fragment
+    } = options;
+    return function Wrapper({
+      children
+    }) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_react.CacheProvider, {
+        value: emotionCache,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(InnerWrapper, {
+          children: children
+        })
+      });
+    };
+  }
+  return {
+    clock,
+    render(element, options = {}) {
+      if (!prepared) {
+        throw new Error('Unable to finish setup before `render()` was called. ' + 'This usually indicates that `render()` was called in a `beforeAll()` or `beforeEach` hook. ' + 'Move the call into each `it()`. Otherwise you cannot run a specific test and we cannot isolate each test.');
+      }
+      const usesLegacyRoot = _reactMajor.default < 18;
+      const reactStrictMode = (options.strict ?? globalStrict) && ((options.strictEffects ?? globalStrictEffects) || usesLegacyRoot);
+      return render(element, {
+        ...options,
+        reactStrictMode,
+        hydrate: false,
+        wrapper: createWrapper(options)
+      });
+    },
+    renderToString(element, options = {}) {
+      if (!prepared) {
+        throw new Error('Unable to finish setup before `render()` was called. ' + 'This usually indicates that `render()` was called in a `beforeAll()` or `beforeEach` hook. ' + 'Move the call into each `it()`. Otherwise you cannot run a specific test and we cannot isolate each test.');
+      }
+      const {
+        container = serverContainer,
+        ...localOptions
+      } = options;
+      return renderToString(element, {
+        ...localOptions,
+        container,
+        wrapper: createWrapper(options)
+      });
+    }
+  };
+}
+const fireEvent = (target, event, ...args) => {
+  return (0, _pure.fireEvent)(target, event, ...args);
+};
+exports.fireEvent = fireEvent;
+Object.keys(_pure.fireEvent).forEach(
+// @ts-expect-error
+eventType => {
+  fireEvent[eventType] = (...args) => _pure.fireEvent[eventType](...args);
+});
+const originalFireEventKeyDown = _pure.fireEvent.keyDown;
+fireEvent.keyDown = (desiredTarget, options = {}) => {
+  const element = desiredTarget;
+  // `element` shouldn't be `document` but we catch this later anyway
+  const document = element.ownerDocument || element;
+  const target = document.activeElement || document.body || document.documentElement;
+  if (target !== element) {
+    // see https://www.w3.org/TR/uievents/#keydown
+    const error = new Error(`\`keydown\` events can only be targeted at the active element which is ${(0, _pure.prettyDOM)(target, undefined, {
+      maxDepth: 1
+    })}`);
+    // We're only interested in the callsite of fireEvent.keyDown
+    error.stack = error.stack.split('\n').filter(line => !/at Function.key/.test(line)).join('\n');
+    throw error;
+  }
+  return originalFireEventKeyDown(element, options);
+};
+const originalFireEventKeyUp = _pure.fireEvent.keyUp;
+fireEvent.keyUp = (desiredTarget, options = {}) => {
+  const element = desiredTarget;
+  // `element` shouldn't be `document` but we catch this later anyway
+  const document = element.ownerDocument || element;
+  const target = document.activeElement || document.body || document.documentElement;
+  if (target !== element) {
+    // see https://www.w3.org/TR/uievents/#keyup
+    const error = new Error(`\`keyup\` events can only be targeted at the active element which is ${(0, _pure.prettyDOM)(target, undefined, {
+      maxDepth: 1
+    })}`);
+    // We're only interested in the callsite of fireEvent.keyUp
+    error.stack = error.stack.split('\n').filter(line => !/at Function.key/.test(line)).join('\n');
+    throw error;
+  }
+  return originalFireEventKeyUp(element, options);
+};
+function fireTouchChangedEvent(target, type, options) {
+  const {
+    changedTouches
+  } = options;
+  const originalGetBoundingClientRect = target.getBoundingClientRect;
+  target.getBoundingClientRect = () => ({
+    x: 0,
+    y: 0,
+    bottom: 0,
+    height: 0,
+    left: 0,
+    right: 0,
+    top: 0,
+    width: 0,
+    toJSON() {
+      return {
+        x: 0,
+        y: 0,
+        bottom: 0,
+        height: 0,
+        left: 0,
+        right: 0,
+        top: 0,
+        width: 0
+      };
+    }
+  });
+  const event = new window.TouchEvent(type, {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    changedTouches: changedTouches.map(opts => new window.Touch({
+      target,
+      identifier: 0,
+      ...opts
+    }))
+  });
+  fireEvent(target, event);
+  target.getBoundingClientRect = originalGetBoundingClientRect;
+}
+function act(callback) {
+  return (0, _pure.act)(callback);
+}
+const bodyBoundQueries = (0, _pure.within)(document.body, {
+  ..._pure.queries,
+  ...customQueries
+});
+const screen = exports.screen = {
+  ..._pure.screen,
+  ...bodyBoundQueries
+};
+async function flushEffects() {
+  await act(async () => {});
+}
+
+/**
+ * returns true when touch is suported and can be mocked
+ */
+function supportsTouch() {
+  // only run in supported browsers
+  if (typeof Touch === 'undefined') {
+    return false;
+  }
+  try {
+    // eslint-disable-next-line no-new
+    new Touch({
+      identifier: 0,
+      target: window,
+      pageX: 0,
+      pageY: 0
+    });
+  } catch {
+    // Touch constructor not supported
+    return false;
+  }
+  return true;
+}

package/createRenderer.test.d.ts

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