@vickbk/tests 0.0.0-stage → 0.1.0

package/dist/react.mjs

@@ -0,0 +1,170 @@
+import * as React from "react";
+//#region src/features/react/utils/resolveArrayChild.ts
+/**
+* Resolves one array child and supplies a stable key when the result is an
+* element without one.
+*
+* @param child - The child value to resolve.
+* @param index - The child's position in its containing array.
+* @param resolveTree - The recursive tree resolver.
+* @returns The resolved child.
+* @example
+* ```ts
+* await resolveArrayChild(<Page />, 0, resolveRscTree);
+* ```
+*/
+async function resolveArrayChild(child, index, resolveTree) {
+	const resolvedChild = await resolveTree(child);
+	if (React.isValidElement(resolvedChild)) {
+		const keyToUse = resolvedChild.key ?? child?.key ?? `rsc-key-${index}`;
+		return React.cloneElement(resolvedChild, { key: keyToUse });
+	}
+	return resolvedChild;
+}
+//#endregion
+//#region src/features/react/utils/isClassComponent.ts
+/**
+* Determines whether a component type is a React class component.
+*
+* @param type - The value to inspect.
+* @returns `true` when the value is a React class component.
+* @example
+* ```ts
+* isClassComponent(MyClassComponent); // true
+* ```
+*/
+function isClassComponent(type) {
+	return typeof type === "function" && Boolean(type.prototype?.isReactComponent);
+}
+//#endregion
+//#region src/features/react/utils/executeServerComponent.ts
+/**
+* Executes a server component and awaits an asynchronous result when present.
+* Component errors intentionally propagate to the caller.
+*
+* @param type - The server component to execute.
+* @param props - Props passed to the component.
+* @returns The component's resolved render result.
+* @example
+* ```ts
+* await executeServerComponent(Page, { title: "Hello" });
+* ```
+*/
+async function executeServerComponent(type, props) {
+	if (isClassComponent(type)) return new type(props).render();
+	return await type(props);
+}
+//#endregion
+//#region src/features/react/utils/isClientComponent.ts
+/**
+* Determines whether a component should be kept behind a client boundary.
+* React client/module references and functions containing hook calls are not
+* invoked directly by the resolver.
+*
+* @param type - The React element type to inspect.
+* @returns `true` when the type represents a client boundary.
+* @example
+* ```ts
+* isClientComponent({ $$typeof: Symbol.for("react.client.reference") }); // true
+* ```
+*/
+function isClientComponent(type) {
+	if (type === null || typeof type !== "function" && typeof type !== "object") return false;
+	const reference = type;
+	if (reference.$$typeof === Symbol.for("react.client.reference") || reference.$$typeof === Symbol.for("react.module.reference") || typeof reference.$$id === "string") return true;
+	return typeof type === "function" && /\buse[A-Z0-9_]\w*\s*\(/.test(Function.prototype.toString.call(type));
+}
+//#endregion
+//#region src/features/react/utils/resolveProps.ts
+/**
+* Resolves React elements and arrays nested in a component's props.
+*
+* @param props - The component props to inspect.
+* @param resolveTree - The recursive tree resolver.
+* @returns Updated props and whether any prop value changed.
+* @example
+* ```ts
+* const result = await resolveProps({ children: <Page /> }, resolveRscTree);
+* ```
+*/
+async function resolveProps(props, resolveTree) {
+	const newProps = { ...props };
+	let hasChanged = false;
+	for (const key of Object.keys(newProps)) {
+		const value = newProps[key];
+		if (React.isValidElement(value) || Array.isArray(value)) {
+			const resolved = await resolveTree(value);
+			if (resolved !== value) {
+				newProps[key] = resolved;
+				hasChanged = true;
+			}
+		}
+	}
+	return {
+		newProps,
+		hasChanged
+	};
+}
+//#endregion
+//#region src/features/react/utils/resolveElement.ts
+/**
+* Resolves a server component element or recursively updates its element props.
+* Client component boundaries remain untouched and component errors propagate.
+*
+* @param node - The React element to resolve.
+* @param resolveTree - The recursive tree resolver.
+* @returns The resolved render result or the updated original element.
+* @example
+* ```ts
+* await resolveElement(<ServerPage />, resolveRscTree);
+* ```
+*/
+async function resolveElement(node, resolveTree) {
+	const { type, props } = node;
+	if (typeof type === "function" && !isClientComponent(type)) return resolveTree(await executeServerComponent(type, props));
+	if (props && typeof props === "object") {
+		const { newProps, hasChanged } = await resolveProps(props, resolveTree);
+		if (hasChanged) return React.cloneElement(node, newProps);
+	}
+	return node;
+}
+//#endregion
+//#region src/features/react/utils/traverseTree.ts
+/**
+* Traverses arrays and React elements, delegating component resolution.
+*
+* @param node - The tree value to visit.
+* @param resolveTree - The recursive tree resolver.
+* @returns The traversed value with server components resolved.
+* @example
+* ```ts
+* await traverseTree(tree, resolveRscTree);
+* ```
+*/
+async function traverseTree(node, resolveTree) {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) return Promise.all(node.map((child, index) => resolveArrayChild(child, index, resolveTree)));
+	if (React.isValidElement(node)) return resolveElement(node, resolveTree);
+	return node;
+}
+//#endregion
+//#region src/features/react/utils/resolveRscTree.ts
+/**
+* Recursively resolves synchronous and asynchronous React Server Components.
+* Client component boundaries are preserved, and component errors are allowed
+* to reject the returned promise.
+*
+* @param node - The React node or tree to resolve.
+* @returns A promise for the resolved React tree.
+* @example
+* ```ts
+* const resolved = await resolveRscTree(<ServerPage />);
+* ```
+*/
+async function resolveRscTree(node) {
+	return traverseTree(node, resolveRscTree);
+}
+//#endregion
+export { resolveRscTree };
+
+//# sourceMappingURL=react.mjs.map

package/dist/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":["ClassComponent","FunctionComponent"],"sources":["../src/features/react/utils/resolveArrayChild.ts","../src/features/react/utils/isClassComponent.ts","../src/features/react/utils/executeServerComponent.ts","../src/features/react/utils/isClientComponent.ts","../src/features/react/utils/resolveProps.ts","../src/features/react/utils/resolveElement.ts","../src/features/react/utils/traverseTree.ts","../src/features/react/utils/resolveRscTree.ts"],"sourcesContent":["import type { ReactNode } from \"react\";\r\nimport * as React from \"react\";\r\nimport type { ResolveTree } from \"./types\";\r\n\r\n/**\r\n * Resolves one array child and supplies a stable key when the result is an\r\n * element without one.\r\n *\r\n * @param child - The child value to resolve.\r\n * @param index - The child's position in its containing array.\r\n * @param resolveTree - The recursive tree resolver.\r\n * @returns The resolved child.\r\n * @example\r\n * ```ts\r\n * await resolveArrayChild(<Page />, 0, resolveRscTree);\r\n * ```\r\n */\r\nexport async function resolveArrayChild(\r\n  child: ReactNode,\r\n  index: number,\r\n  resolveTree: ResolveTree,\r\n): Promise<ReactNode> {\r\n  const resolvedChild = await resolveTree(child);\r\n  if (React.isValidElement(resolvedChild)) {\r\n    const keyToUse =\r\n      resolvedChild.key ??\r\n      (child as { key?: string })?.key ??\r\n      `rsc-key-${index}`;\r\n    return React.cloneElement(resolvedChild, { key: keyToUse });\r\n  }\r\n  return resolvedChild;\r\n}\r\n","/**\r\n * Determines whether a component type is a React class component.\r\n *\r\n * @param type - The value to inspect.\r\n * @returns `true` when the value is a React class component.\r\n * @example\r\n * ```ts\r\n * isClassComponent(MyClassComponent); // true\r\n * ```\r\n */\r\nexport function isClassComponent(type: unknown): boolean {\r\n  return (\r\n    typeof type === \"function\" &&\r\n    Boolean(\r\n      (type as { prototype?: { isReactComponent?: unknown } }).prototype\r\n        ?.isReactComponent,\r\n    )\r\n  );\r\n}\r\n","import type * as React from \"react\";\r\nimport type { ReactNode } from \"react\";\r\nimport { isClassComponent } from \"./isClassComponent\";\r\n\r\n/**\r\n * Executes a server component and awaits an asynchronous result when present.\r\n * Component errors intentionally propagate to the caller.\r\n *\r\n * @param type - The server component to execute.\r\n * @param props - Props passed to the component.\r\n * @returns The component's resolved render result.\r\n * @example\r\n * ```ts\r\n * await executeServerComponent(Page, { title: \"Hello\" });\r\n * ```\r\n */\r\nexport async function executeServerComponent(\r\n  type: React.ComponentType<Record<string, unknown>>,\r\n  props: Record<string, unknown>,\r\n): Promise<ReactNode> {\r\n  if (isClassComponent(type)) {\r\n    const ClassComponent = type as React.ComponentClass<\r\n      Record<string, unknown>\r\n    >;\r\n    return new ClassComponent(props).render();\r\n  }\r\n\r\n  const FunctionComponent = type as React.FunctionComponent<\r\n    Record<string, unknown>\r\n  >;\r\n  return await FunctionComponent(props);\r\n}\r\n","/**\r\n * Determines whether a component should be kept behind a client boundary.\r\n * React client/module references and functions containing hook calls are not\r\n * invoked directly by the resolver.\r\n *\r\n * @param type - The React element type to inspect.\r\n * @returns `true` when the type represents a client boundary.\r\n * @example\r\n * ```ts\r\n * isClientComponent({ $$typeof: Symbol.for(\"react.client.reference\") }); // true\r\n * ```\r\n */\r\nexport function isClientComponent(type: unknown): boolean {\r\n  if (type === null || (typeof type !== \"function\" && typeof type !== \"object\")) {\r\n    return false;\r\n  }\r\n\r\n  const reference = type as { $$typeof?: symbol; $$id?: unknown };\r\n  if (\r\n    reference.$$typeof === Symbol.for(\"react.client.reference\") ||\r\n    reference.$$typeof === Symbol.for(\"react.module.reference\") ||\r\n    typeof reference.$$id === \"string\"\r\n  ) {\r\n    return true;\r\n  }\r\n\r\n  return (\r\n    typeof type === \"function\" &&\r\n    /\\buse[A-Z0-9_]\\w*\\s*\\(/.test(Function.prototype.toString.call(type))\r\n  );\r\n}\r\n","import * as React from \"react\";\r\nimport type { ResolveTree } from \"./types\";\r\n\r\n/**\r\n * Resolves React elements and arrays nested in a component's props.\r\n *\r\n * @param props - The component props to inspect.\r\n * @param resolveTree - The recursive tree resolver.\r\n * @returns Updated props and whether any prop value changed.\r\n * @example\r\n * ```ts\r\n * const result = await resolveProps({ children: <Page /> }, resolveRscTree);\r\n * ```\r\n */\r\nexport async function resolveProps(\r\n  props: Record<string, unknown>,\r\n  resolveTree: ResolveTree,\r\n): Promise<{ newProps: Record<string, unknown>; hasChanged: boolean }> {\r\n  const newProps: Record<string, unknown> = { ...props };\r\n  let hasChanged = false;\r\n\r\n  for (const key of Object.keys(newProps)) {\r\n    const value = newProps[key];\r\n    if (React.isValidElement(value) || Array.isArray(value)) {\r\n      const resolved = await resolveTree(value as React.ReactNode);\r\n      if (resolved !== value) {\r\n        newProps[key] = resolved;\r\n        hasChanged = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  return { newProps, hasChanged };\r\n}\r\n","import type { ReactNode } from \"react\";\r\nimport * as React from \"react\";\r\nimport { executeServerComponent } from \"./executeServerComponent\";\r\nimport { isClientComponent } from \"./isClientComponent\";\r\nimport { resolveProps } from \"./resolveProps\";\r\nimport type { ResolveTree } from \"./types\";\r\n\r\n/**\r\n * Resolves a server component element or recursively updates its element props.\r\n * Client component boundaries remain untouched and component errors propagate.\r\n *\r\n * @param node - The React element to resolve.\r\n * @param resolveTree - The recursive tree resolver.\r\n * @returns The resolved render result or the updated original element.\r\n * @example\r\n * ```ts\r\n * await resolveElement(<ServerPage />, resolveRscTree);\r\n * ```\r\n */\r\nexport async function resolveElement(\r\n  node: React.ReactElement,\r\n  resolveTree: ResolveTree,\r\n): Promise<ReactNode> {\r\n  const { type, props } = node;\r\n\r\n  if (typeof type === \"function\" && !isClientComponent(type)) {\r\n    const serverResult = await executeServerComponent(\r\n      type as React.ComponentType<Record<string, unknown>>,\r\n      props as Record<string, unknown>,\r\n    );\r\n    return resolveTree(serverResult);\r\n  }\r\n\r\n  if (props && typeof props === \"object\") {\r\n    const { newProps, hasChanged } = await resolveProps(\r\n      props as Record<string, unknown>,\r\n      resolveTree,\r\n    );\r\n    if (hasChanged) {\r\n      return React.cloneElement(node, newProps);\r\n    }\r\n  }\r\n\r\n  return node;\r\n}\r\n","import * as React from \"react\";\r\nimport type { ReactNode } from \"react\";\r\nimport { resolveArrayChild } from \"./resolveArrayChild\";\r\nimport { resolveElement } from \"./resolveElement\";\r\nimport type { ResolveTree } from \"./types\";\r\n\r\n/**\r\n * Traverses arrays and React elements, delegating component resolution.\r\n *\r\n * @param node - The tree value to visit.\r\n * @param resolveTree - The recursive tree resolver.\r\n * @returns The traversed value with server components resolved.\r\n * @example\r\n * ```ts\r\n * await traverseTree(tree, resolveRscTree);\r\n * ```\r\n */\r\nexport async function traverseTree(\r\n  node: ReactNode,\r\n  resolveTree: ResolveTree,\r\n): Promise<ReactNode> {\r\n  if (!node || typeof node !== \"object\") return node;\r\n\r\n  if (Array.isArray(node)) {\r\n    return Promise.all(\r\n      node.map((child, index) => resolveArrayChild(child, index, resolveTree)),\r\n    );\r\n  }\r\n\r\n  if (React.isValidElement(node)) {\r\n    return resolveElement(node, resolveTree);\r\n  }\r\n\r\n  return node;\r\n}\r\n","import type { ReactNode } from \"react\";\r\nimport { traverseTree } from \"./traverseTree\";\r\n\r\n/**\r\n * Recursively resolves synchronous and asynchronous React Server Components.\r\n * Client component boundaries are preserved, and component errors are allowed\r\n * to reject the returned promise.\r\n *\r\n * @param node - The React node or tree to resolve.\r\n * @returns A promise for the resolved React tree.\r\n * @example\r\n * ```ts\r\n * const resolved = await resolveRscTree(<ServerPage />);\r\n * ```\r\n */\r\nexport async function resolveRscTree(node: ReactNode): Promise<ReactNode> {\r\n  return traverseTree(node, resolveRscTree);\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,eAAsB,kBACpB,OACA,OACA,aACoB;CACpB,MAAM,gBAAgB,MAAM,YAAY,KAAK;CAC7C,IAAI,MAAM,eAAe,aAAa,GAAG;EACvC,MAAM,WACJ,cAAc,OACb,OAA4B,OAC7B,WAAW;EACb,OAAO,MAAM,aAAa,eAAe,EAAE,KAAK,SAAS,CAAC;CAC5D;CACA,OAAO;AACT;;;;;;;;;;;;;ACrBA,SAAgB,iBAAiB,MAAwB;CACvD,OACE,OAAO,SAAS,cAChB,QACG,KAAwD,WACrD,gBACN;AAEJ;;;;;;;;;;;;;;;ACFA,eAAsB,uBACpB,MACA,OACoB;CACpB,IAAI,iBAAiB,IAAI,GAIvB,OAAO,IAAIA,KAAe,KAAK,CAAC,CAAC,OAAO;CAM1C,OAAO,MAAMC,KAAkB,KAAK;AACtC;;;;;;;;;;;;;;;ACnBA,SAAgB,kBAAkB,MAAwB;CACxD,IAAI,SAAS,QAAS,OAAO,SAAS,cAAc,OAAO,SAAS,UAClE,OAAO;CAGT,MAAM,YAAY;CAClB,IACE,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,OAAO,UAAU,SAAS,UAE1B,OAAO;CAGT,OACE,OAAO,SAAS,cAChB,yBAAyB,KAAK,SAAS,UAAU,SAAS,KAAK,IAAI,CAAC;AAExE;;;;;;;;;;;;;;AChBA,eAAsB,aACpB,OACA,aACqE;CACrE,MAAM,WAAoC,EAAE,GAAG,MAAM;CACrD,IAAI,aAAa;CAEjB,KAAK,MAAM,OAAO,OAAO,KAAK,QAAQ,GAAG;EACvC,MAAM,QAAQ,SAAS;EACvB,IAAI,MAAM,eAAe,KAAK,KAAK,MAAM,QAAQ,KAAK,GAAG;GACvD,MAAM,WAAW,MAAM,YAAY,KAAwB;GAC3D,IAAI,aAAa,OAAO;IACtB,SAAS,OAAO;IAChB,aAAa;GACf;EACF;CACF;CAEA,OAAO;EAAE;EAAU;CAAW;AAChC;;;;;;;;;;;;;;;ACdA,eAAsB,eACpB,MACA,aACoB;CACpB,MAAM,EAAE,MAAM,UAAU;CAExB,IAAI,OAAO,SAAS,cAAc,CAAC,kBAAkB,IAAI,GAKvD,OAAO,YAAY,MAJQ,uBACzB,MACA,KACF,CAC+B;CAGjC,IAAI,SAAS,OAAO,UAAU,UAAU;EACtC,MAAM,EAAE,UAAU,eAAe,MAAM,aACrC,OACA,WACF;EACA,IAAI,YACF,OAAO,MAAM,aAAa,MAAM,QAAQ;CAE5C;CAEA,OAAO;AACT;;;;;;;;;;;;;;AC3BA,eAAsB,aACpB,MACA,aACoB;CACpB,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO;CAE9C,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,QAAQ,IACb,KAAK,KAAK,OAAO,UAAU,kBAAkB,OAAO,OAAO,WAAW,CAAC,CACzE;CAGF,IAAI,MAAM,eAAe,IAAI,GAC3B,OAAO,eAAe,MAAM,WAAW;CAGzC,OAAO;AACT;;;;;;;;;;;;;;;ACnBA,eAAsB,eAAe,MAAqC;CACxE,OAAO,aAAa,MAAM,cAAc;AAC1C"}

package/dist/rolldown-runtime-VH7oDXx4.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/types-BlSFP07Z.d.cts

@@ -0,0 +1,8 @@
+//#region src/shared/regex/types.d.ts
+type TEXT_PATTERN = RegExp | string;
+type LABEL_LOCATOR = [TEXT_PATTERN, string];
+type TEXT_WITH_NTH = [TEXT_PATTERN, number];
+type TEXT_MATCHER = TEXT_PATTERN | TEXT_WITH_NTH;
+//#endregion
+export { TEXT_WITH_NTH as i, TEXT_MATCHER as n, TEXT_PATTERN as r, LABEL_LOCATOR as t };
+//# sourceMappingURL=types-BlSFP07Z.d.cts.map

package/dist/types-BlSFP07Z.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BlSFP07Z.d.cts","names":[],"sources":["../src/shared/regex/types.ts"],"mappings":";KAAY,eAAe;KACf,iBAAiB;KACjB,iBAAiB;KACjB,eAAe,eAAe"}

package/dist/types-BlSFP07Z.d.mts

@@ -0,0 +1,8 @@
+//#region src/shared/regex/types.d.ts
+type TEXT_PATTERN = RegExp | string;
+type LABEL_LOCATOR = [TEXT_PATTERN, string];
+type TEXT_WITH_NTH = [TEXT_PATTERN, number];
+type TEXT_MATCHER = TEXT_PATTERN | TEXT_WITH_NTH;
+//#endregion
+export { TEXT_WITH_NTH as i, TEXT_MATCHER as n, TEXT_PATTERN as r, LABEL_LOCATOR as t };
+//# sourceMappingURL=types-BlSFP07Z.d.mts.map

package/dist/types-BlSFP07Z.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BlSFP07Z.d.mts","names":[],"sources":["../src/shared/regex/types.ts"],"mappings":";KAAY,eAAe;KACf,iBAAiB;KACjB,iBAAiB;KACjB,eAAe,eAAe"}

package/dist/vitest.d.mts

@@ -0,0 +1,305 @@
+import { fireEvent as fireEvent$1 } from "@testing-library/react";
+//#region src/features/vitest/modules/dom/modules/toggle-event/utils/types.d.ts
+/**
+ * Possible states for a disclosure or popover toggle transition.
+ *
+ * @example
+ * ```ts
+ * const nextState: ToggleState = "open";
+ * ```
+ */
+type ToggleState = "open" | "closed";
+/**
+ * The previous and next states dispatched by the toggle-event polyfill.
+ *
+ * @example
+ * ```ts
+ * const transition: ToggleConfig = { oldState: "closed", newState: "open" };
+ * ```
+ */
+type ToggleConfig = Record<"oldState" | "newState", ToggleState>;
+/**
+ * Internal shape added to Testing Library's `fireEvent` by its type augmentation.
+ *
+ * @example
+ * ```ts
+ * installToggleEvent();
+ * fireEvent.toggle(document.body, { newState: "open" });
+ * ```
+ */
+type ToggleFireEventExtensions = {
+  toggle: (element: Document | Element | Window | Node, initDict?: Partial<ToggleConfig>) => boolean;
+};
+//#endregion
+//#region src/features/vitest/modules/dom/modules/toggle-event/utils/fireEvent.d.ts
+/**
+ * Testing Library's fireEvent API with an additional `toggle` event helper.
+ *
+ * The exported object copies the standard `fireEvent` properties and adds
+ * `toggle`, which dispatches the toggle event through `togglePolyfill`.
+ * It does not install the extension onto Testing Library's original export.
+ *
+ * Standard Testing Library event helpers remain available, including
+ * `click`, `change`, `input`, `submit`, `focus`, and keyboard/mouse events.
+ *
+ * @remarks
+ * The `toggle` helper defaults to a transition from `closed` to `open`.
+ * Call-specific configuration overrides those defaults. This helper does
+ * not maintain state between calls.
+ *
+ * @example
+ * ```ts
+ * import { fireEvent } from "@vickbk/tests/vitest";
+ *
+ * const disclosure = document.querySelector("details")!;
+ *
+ * fireEvent.toggle(disclosure);
+ * fireEvent.toggle(disclosure, { newState: "closed" });
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { fireEvent } from "@vickbk/tests/vitest";
+ *
+ * const button = document.querySelector("button")!;
+ *
+ * fireEvent.click(button);
+ * ```
+ */
+export declare const fireEvent: typeof fireEvent$1 & ToggleFireEventExtensions;
+//#endregion
+//#region src/shared/regex/types.d.ts
+type TEXT_PATTERN = RegExp | string;
+type TEXT_WITH_NTH = [TEXT_PATTERN, number];
+type TEXT_MATCHER = TEXT_PATTERN | TEXT_WITH_NTH;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/clickLabelInput.d.ts
+/**
+ * Simulates clicking an input found by its label or placeholder.
+ *
+ * @param label Label or placeholder text/regular expression identifying the input.
+ * @param container Optional element that limits the input search.
+ * @returns A promise that resolves after the click interaction completes.
+ * @example
+ * ```ts
+ * await clickLabelInput("Email address");
+ * ```
+ */
+export declare function clickLabelInput(label: TEXT_PATTERN, container?: HTMLElement): Promise<void>;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/isChecked.d.ts
+/**
+ * Asserts that the radio button or checkbox matching the accessible name is checked.
+ *
+ * @param selector Accessible label text or regular expression for the control.
+ * @param container Optional element that limits the control search.
+ * @returns Nothing; throws an assertion error if the control is absent or unchecked.
+ * @example
+ * ```ts
+ * isChecked("Accept terms");
+ * ```
+ */
+export declare function isChecked(selector: TEXT_PATTERN, container?: HTMLElement): void;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/isNotChecked.d.ts
+/**
+ * Asserts that the radio button or checkbox matching the accessible name is unchecked.
+ *
+ * @param selector Accessible label text or regular expression for the control.
+ * @param container Optional element that limits the control search.
+ * @returns Nothing; throws an assertion error if the control is absent or checked.
+ * @example
+ * ```ts
+ * isNotChecked("Subscribe to updates");
+ * ```
+ */
+export declare function isNotChecked(selector: TEXT_PATTERN, container?: HTMLElement): void;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/shouldHaveAttributes.d.ts
+/**
+ * Asserts that an HTMLElement possesses the expected set of DOM attributes and values.
+ *
+ * Handles string/numeric values, boolean attributes (true = present, false = absent),
+ * and null/undefined values (absent).
+ *
+ * @param element The DOM element whose attributes will be checked.
+ * @param attributes Attribute names mapped to their expected values.
+ * @returns Nothing; throws an assertion error when any attribute does not match.
+ * @example
+ * ```ts
+ * shouldHaveAttributes(input, { required: true, "aria-label": "Email" });
+ * ```
+ */
+export declare function shouldHaveAttributes(element: HTMLElement, attributes: Record<string, unknown>): void;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/shouldHaveTestId.d.ts
+/**
+ * Asserts that elements with all supplied test IDs are present in the document.
+ *
+ * @param ids One or more `data-testid` values to locate.
+ * @returns The elements found, in the same order as the supplied IDs.
+ * @example
+ * ```ts
+ * const [submitButton] = shouldHaveTestId("submit-button");
+ * ```
+ */
+export declare function shouldHaveTestId(...ids: string[]): HTMLElement[];
+//#endregion
+//#region src/features/vitest/modules/dom/utils/shouldNotHaveTestId.d.ts
+/**
+ * Asserts that elements with all supplied test IDs are absent from the document.
+ *
+ * @param ids One or more `data-testid` values to verify are absent.
+ * @returns The query results (`null` for each absent element), in ID order.
+ * @example
+ * ```ts
+ * shouldNotHaveTestId("loading-spinner");
+ * ```
+ */
+export declare function shouldNotHaveTestId(...ids: string[]): (HTMLElement | null)[];
+//#endregion
+//#region src/features/vitest/modules/dom/utils/shouldNotSee.d.ts
+/**
+ * Asserts that none of the supplied text matchers appear in the document.
+ *
+ * @param texts Text strings or regular expressions that must be absent.
+ * @returns Nothing; throws an assertion error if any text is found.
+ * @example
+ * ```ts
+ * shouldNotSee("Error", /failed/i);
+ * ```
+ */
+export declare const shouldNotSee: (...texts: (string | RegExp)[]) => void;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/shouldSee.d.ts
+/**
+ * Asserts that each requested text matcher is present in the document.
+ *
+ * @param texts Text strings, regular expressions, or `[matcher, occurrenceIndex]` pairs.
+ * @returns The matching elements in the same order as the supplied matchers.
+ * @example
+ * ```ts
+ * const [heading] = shouldSee("Welcome");
+ * ```
+ */
+export declare const shouldSee: (...texts: TEXT_MATCHER[]) => HTMLElement[];
+//#endregion
+//#region src/features/vitest/modules/dom/utils/togglePopover.d.ts
+/**
+ * Dispatches a toggle event on the first element matching a selector.
+ *
+ * @param options Selector, optional search container, and target open/closed state.
+ * @returns The matched element, or `undefined` when no matching element exists.
+ * @example
+ * ```ts
+ * const popover = togglePopover({ selector: "#help", newState: "open" });
+ * ```
+ */
+export declare function togglePopover({ container, selector, newState }: {
+  container?: HTMLElement;
+  selector: string;
+  newState?: ToggleState;
+}): Element | undefined;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/userClicks.d.ts
+/**
+ * Simulates a user click on a button with the requested name, or matching text.
+ *
+ * @param target Button accessible name or text string/regular expression.
+ * @param container Optional element that limits the target search.
+ * @returns A promise that resolves after the click interaction completes.
+ * @example
+ * ```ts
+ * await userClicks("Save");
+ * ```
+ */
+export declare const userClicks: (target: string | RegExp, container?: HTMLElement) => Promise<void>;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/userTypes.d.ts
+/**
+ * Replaces the value of a textbox found by its label, placeholder, or textbox name.
+ *
+ * @param target Accessible label, placeholder, or textbox name as text or a regex.
+ * @param text Text to type after clearing the existing value.
+ * @param container Optional element that limits the textbox search.
+ * @param user User-event instance used for the interaction; defaults to a new instance.
+ * @returns A promise resolving to the textbox that was updated.
+ * @example
+ * ```ts
+ * const emailInput = await userTypes("Email", "person@example.com");
+ * ```
+ */
+export declare const userTypes: (target: TEXT_PATTERN, text: string, container?: HTMLElement, user?: import("@testing-library/user-event").UserEvent) => Promise<HTMLElement>;
+//#endregion
+//#region src/features/vitest/modules/dom/utils/userTypesMultiple.d.ts
+/**
+ * Replaces the values of multiple textboxes, located by their respective selectors.
+ *
+ * @param inputs Object mapping each textbox label/placeholder to the text to enter.
+ * @param container Optional element that limits all textbox searches.
+ * @returns A promise resolving to an object mapping each selector to its updated textbox.
+ * @example
+ * ```ts
+ * const fields = await userTypesMultiple({ Email: "person@example.com", Name: "Pat" });
+ * ```
+ */
+export declare function userTypesMultiple(inputs: Record<string, string>, container?: HTMLElement): Promise<Record<string, HTMLElement>>;
+//#endregion
+//#region src/features/vitest/modules/promises/utils/resolvedPromise.d.ts
+/**
+ * Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.
+ *
+ * @param value The value with which the promise is fulfilled.
+ * @returns A fulfilled Promise<T> with `status: "fulfilled"` and its `value`.
+ * @example
+ * ```ts
+ * const payload = await resolvedPromise({ id: 1 });
+ * expect(payload).toEqual({ id: 1 });
+ * ```
+ */
+export declare function resolvedPromise<T>(value: T): Promise<T> & {
+  status: "fulfilled";
+  value: T;
+};
+//#endregion
+//#region src/features/vitest/modules/promises/utils/rejectedPromise.d.ts
+/**
+ * Creates a rejected promise augmented with Vitest's rejected-promise metadata.
+ *
+ * @param reason The rejection reason, preserved as an unknown value; defaults to `undefined`.
+ * @returns A rejected Promise<never> with `status: "rejected"` and its `reason`.
+ * @example
+ * ```ts
+ * await expect(rejectedPromise(new Error("Request failed"))).rejects.toThrow("Request failed");
+ * ```
+ */
+export declare function rejectedPromise(reason?: unknown): Promise<never> & {
+  status: "rejected";
+  reason: unknown;
+};
+//#endregion
+//#region src/features/vitest/utils/console.d.ts
+/**
+ * Suppresses console.log, console.warn, and console.error until resetConsole runs.
+ *
+ * @example
+ * ```ts
+ * beforeEach(shutConsole);
+ * afterEach(resetConsole);
+ * ```
+ */
+export declare function shutConsole(): void;
+/**
+ * Restores the console methods most recently suppressed by shutConsole.
+ *
+ * @example
+ * ```ts
+ * shutConsole();
+ * // Run code whose console output should be ignored.
+ * resetConsole();
+ * ```
+ */
+export declare function resetConsole(): void;
+//#endregion
+export type { ToggleConfig, ToggleState };
+//# sourceMappingURL=vitest.d.mts.map

package/dist/vitest.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.d.mts","names":["rtlFireEvent"],"sources":["../src/features/vitest/modules/dom/modules/toggle-event/utils/types.ts","../src/features/vitest/modules/dom/modules/toggle-event/utils/fireEvent.ts","../src/shared/regex/types.ts","../src/features/vitest/modules/dom/utils/clickLabelInput.ts","../src/features/vitest/modules/dom/utils/isChecked.ts","../src/features/vitest/modules/dom/utils/isNotChecked.ts","../src/features/vitest/modules/dom/utils/shouldHaveAttributes.ts","../src/features/vitest/modules/dom/utils/shouldHaveTestId.ts","../src/features/vitest/modules/dom/utils/shouldNotHaveTestId.ts","../src/features/vitest/modules/dom/utils/shouldNotSee.ts","../src/features/vitest/modules/dom/utils/shouldSee.ts","../src/features/vitest/modules/dom/utils/togglePopover.ts","../src/features/vitest/modules/dom/utils/userClicks.ts","../src/features/vitest/modules/dom/utils/userTypes.ts","../src/features/vitest/modules/dom/utils/userTypesMultiple.ts","../src/features/vitest/modules/promises/utils/resolvedPromise.ts","../src/features/vitest/modules/promises/utils/rejectedPromise.ts","../src/features/vitest/utils/console.ts"],"mappings":";;;;;;;;;;KAQY;;;;;;;;;KAUA,eAAe,gCAAgC;;;;;;;;;;KAW/C;EACV,SACE,SAAS,WAAW,UAAU,SAAS,MACvC,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCQV,kBAyBAA,cAAe;;;KCjEhB,eAAe;KAEf,iBAAiB;KACjB,eAAe,eAAe;;;;;;;;;;;;;;wBCapB,gBACpB,OAAO,cACP,YAAY,cAAW;;;;;;;;;;;;;;wBCHT,UAAU,UAAU,cAAc,YAAY;;;;;;;;;;;;;;wBCA9C,aAAa,UAAU,cAAc,YAAY;;;;;;;;;;;;;;;;;wBCCjD,qBACd,SAAS,aACT,YAAY;;;;;;;;;;;;;wBCLE,oBAAoB,gBAAa;;;;;;;;;;;;;wBCAjC,uBAAuB,iBAAa;;;;;;;;;;;;;qBCDvC,kBAAmB,iBAAiB;;;;;;;;;;;;;qBCCpC,eAAgB,OAAO,mBAAc;;;;;;;;;;;;;wBCDlC,gBACd,WACA,UACA;EAEA,YAAY;EACZ;EACA,WAAW;IACZ;;;;;;;;;;;;;;qBCLY,aACX,iBAAiB,QACjB,YAAY,gBAAW;;;;;;;;;;;;;;;;qBCAZ,YACX,QAAQ,cACR,cACA,YAAY,aACZ,6CAAA,cAAwB,QAAA;;;;;;;;;;;;;;wBCRJ,kBACpB,QAAQ,wBACR,YAAY,cAAW,QAAA,eAAA;;;;;;;;;;;;;;wBCJT,gBAAgB,GAC9B,OAAO,IACN,QAAQ;EAAO;EAAqB,OAAO;;;;;;;;;;;;;;wBCH9B,gBACd,mBACC;EAAmB;EAAoB;;;;;;;;;;;;;wBCG1B;;;;;;;;;;;wBAkBA"}