@vickbk/tests 0.1.0 → 0.2.1

package/dist/promises.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.mjs","names":[],"sources":["../src/features/promises/utils/resolvedPromise.ts","../src/features/promises/utils/rejectedPromise.ts"],"sourcesContent":["/**\n * Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.\n *\n * @param value The value with which the promise is fulfilled.\n * @returns A fulfilled Promise<T> with `status: \"fulfilled\"` and its `value`.\n * @example\n * ```ts\n * const payload = await resolvedPromise({ id: 1 });\n * expect(payload).toEqual({ id: 1 });\n * ```\n */\nexport function resolvedPromise<T>(\n  value: T,\n): Promise<T> & { status: \"fulfilled\"; value: T } {\n  const promise = Promise.resolve(value);\n  return Object.assign(promise, { status: \"fulfilled\" as const, value });\n}\n","/**\n * Creates a rejected promise augmented with Vitest's rejected-promise metadata.\n *\n * @param reason The rejection reason, preserved as an unknown value; defaults to `undefined`.\n * @returns A rejected Promise<never> with `status: \"rejected\"` and its `reason`.\n * @example\n * ```ts\n * await expect(rejectedPromise(new Error(\"Request failed\"))).rejects.toThrow(\"Request failed\");\n * ```\n */\nexport function rejectedPromise(\n  reason: unknown = undefined,\n): Promise<never> & { status: \"rejected\"; reason: unknown } {\n  const promise = Promise.reject<never>(reason);\n\n  promise.catch((error) => error);\n\n  return Object.assign(promise, { status: \"rejected\" as const, reason });\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,gBACd,OACgD;CAChD,MAAM,UAAU,QAAQ,QAAQ,KAAK;CACrC,OAAO,OAAO,OAAO,SAAS;EAAE,QAAQ;EAAsB;CAAM,CAAC;AACvE;;;;;;;;;;;;;ACNA,SAAgB,gBACd,SAAkB,KAAA,GACwC;CAC1D,MAAM,UAAU,QAAQ,OAAc,MAAM;CAE5C,QAAQ,OAAO,UAAU,KAAK;CAE9B,OAAO,OAAO,OAAO,SAAS;EAAE,QAAQ;EAAqB;CAAO,CAAC;AACvE"}

package/dist/react.cjs

@@ -58,6 +58,31 @@ async function executeServerComponent(type, props) {
 	return await type(props);
 }
 //#endregion
+//#region src/features/react/utils/mayUseHooks.ts
+/**
+* Determines whether a function's source appears to contain a React hook call.
+*
+* Recognizes calls whose names are `use` or begin with `use` followed by an
+* uppercase letter, digit, or underscore. It also supports transformed calls
+* where a closing parenthesis appears between the hook name and its opening
+* call parenthesis, such as `(0, imported.useState)(initialValue)`.
+*
+* Comments are removed before matching to reduce false positives from
+* hook-like text in comments.
+*
+* This is a heuristic, not a complete JavaScript parser. In particular,
+* comment-like sequences inside strings or template literals can confuse
+* comment removal, and hook calls can be missed or falsely detected when
+* source code is transformed or contains hook-like text in string literals.
+*
+* @param type - The function whose source should be inspected.
+* @returns `true` if the source matches a likely hook call; otherwise `false`.
+*/
+function mayUseHooks(type) {
+	const withoutComments = Function.prototype.toString.call(type).replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, "");
+	return /\buse(?:[A-Z0-9_]\w*)?\s*\)?\s*\(/.test(withoutComments);
+}
+//#endregion
 //#region src/features/react/utils/isClientComponent.ts
 /**
 * Determines whether a component should be kept behind a client boundary.
@@ -75,7 +100,7 @@ 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));
+	return typeof type === "function" && mayUseHooks(type);
 }
 //#endregion
 //#region src/features/react/utils/resolveProps.ts

package/dist/react.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"react.cjs","names":["React","ClassComponent","FunctionComponent","React","React","React"],"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,IAAIA,MAAM,eAAe,aAAa,GAAG;EACvC,MAAM,WACJ,cAAc,OACb,OAA4B,OAC7B,WAAW;EACb,OAAOA,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,IAAIC,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,IAAIC,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,OAAOC,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,IAAIC,MAAM,eAAe,IAAI,GAC3B,OAAO,eAAe,MAAM,WAAW;CAGzC,OAAO;AACT;;;;;;;;;;;;;;;ACnBA,eAAsB,eAAe,MAAqC;CACxE,OAAO,aAAa,MAAM,cAAc;AAC1C"}
+{"version":3,"file":"react.cjs","names":["React","ClassComponent","FunctionComponent","React","React","React"],"sources":["../src/features/react/utils/resolveArrayChild.ts","../src/features/react/utils/isClassComponent.ts","../src/features/react/utils/executeServerComponent.ts","../src/features/react/utils/mayUseHooks.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\";\nimport * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves one array child and supplies a stable key when the result is an\n * element without one.\n *\n * @param child - The child value to resolve.\n * @param index - The child's position in its containing array.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved child.\n * @example\n * ```ts\n * await resolveArrayChild(<Page />, 0, resolveRscTree);\n * ```\n */\nexport async function resolveArrayChild(\n  child: ReactNode,\n  index: number,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const resolvedChild = await resolveTree(child);\n  if (React.isValidElement(resolvedChild)) {\n    const keyToUse =\n      resolvedChild.key ??\n      (child as { key?: string })?.key ??\n      `rsc-key-${index}`;\n    return React.cloneElement(resolvedChild, { key: keyToUse });\n  }\n  return resolvedChild;\n}\n","/**\n * Determines whether a component type is a React class component.\n *\n * @param type - The value to inspect.\n * @returns `true` when the value is a React class component.\n * @example\n * ```ts\n * isClassComponent(MyClassComponent); // true\n * ```\n */\nexport function isClassComponent(type: unknown): boolean {\n  return (\n    typeof type === \"function\" &&\n    Boolean(\n      (type as { prototype?: { isReactComponent?: unknown } }).prototype\n        ?.isReactComponent,\n    )\n  );\n}\n","import type * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { isClassComponent } from \"./isClassComponent\";\n\n/**\n * Executes a server component and awaits an asynchronous result when present.\n * Component errors intentionally propagate to the caller.\n *\n * @param type - The server component to execute.\n * @param props - Props passed to the component.\n * @returns The component's resolved render result.\n * @example\n * ```ts\n * await executeServerComponent(Page, { title: \"Hello\" });\n * ```\n */\nexport async function executeServerComponent(\n  type: React.ComponentType<Record<string, unknown>>,\n  props: Record<string, unknown>,\n): Promise<ReactNode> {\n  if (isClassComponent(type)) {\n    const ClassComponent = type as React.ComponentClass<\n      Record<string, unknown>\n    >;\n    return new ClassComponent(props).render();\n  }\n\n  const FunctionComponent = type as React.FunctionComponent<\n    Record<string, unknown>\n  >;\n  return await FunctionComponent(props);\n}\n","/**\n * Determines whether a function's source appears to contain a React hook call.\n *\n * Recognizes calls whose names are `use` or begin with `use` followed by an\n * uppercase letter, digit, or underscore. It also supports transformed calls\n * where a closing parenthesis appears between the hook name and its opening\n * call parenthesis, such as `(0, imported.useState)(initialValue)`.\n *\n * Comments are removed before matching to reduce false positives from\n * hook-like text in comments.\n *\n * This is a heuristic, not a complete JavaScript parser. In particular,\n * comment-like sequences inside strings or template literals can confuse\n * comment removal, and hook calls can be missed or falsely detected when\n * source code is transformed or contains hook-like text in string literals.\n *\n * @param type - The function whose source should be inspected.\n * @returns `true` if the source matches a likely hook call; otherwise `false`.\n */\nexport function mayUseHooks(type: (...args: never[]) => unknown): boolean {\n  const source = Function.prototype.toString.call(type);\n\n  const withoutComments = source.replace(/\\/\\*[\\s\\S]*?\\*\\/|\\/\\/[^\\r\\n]*/g, \"\");\n\n  return /\\buse(?:[A-Z0-9_]\\w*)?\\s*\\)?\\s*\\(/.test(withoutComments);\n}\n","import { mayUseHooks } from \"./mayUseHooks\";\n\n/**\n * Determines whether a component should be kept behind a client boundary.\n * React client/module references and functions containing hook calls are not\n * invoked directly by the resolver.\n *\n * @param type - The React element type to inspect.\n * @returns `true` when the type represents a client boundary.\n * @example\n * ```ts\n * isClientComponent({ $$typeof: Symbol.for(\"react.client.reference\") }); // true\n * ```\n */\nexport function isClientComponent(type: unknown): boolean {\n  if (\n    type === null ||\n    (typeof type !== \"function\" && typeof type !== \"object\")\n  ) {\n    return false;\n  }\n\n  const reference = type as { $$typeof?: symbol; $$id?: unknown };\n  if (\n    reference.$$typeof === Symbol.for(\"react.client.reference\") ||\n    reference.$$typeof === Symbol.for(\"react.module.reference\") ||\n    typeof reference.$$id === \"string\"\n  ) {\n    return true;\n  }\n\n  return typeof type === \"function\" && mayUseHooks(type as never);\n}\n","import * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves React elements and arrays nested in a component's props.\n *\n * @param props - The component props to inspect.\n * @param resolveTree - The recursive tree resolver.\n * @returns Updated props and whether any prop value changed.\n * @example\n * ```ts\n * const result = await resolveProps({ children: <Page /> }, resolveRscTree);\n * ```\n */\nexport async function resolveProps(\n  props: Record<string, unknown>,\n  resolveTree: ResolveTree,\n): Promise<{ newProps: Record<string, unknown>; hasChanged: boolean }> {\n  const newProps: Record<string, unknown> = { ...props };\n  let hasChanged = false;\n\n  for (const key of Object.keys(newProps)) {\n    const value = newProps[key];\n    if (React.isValidElement(value) || Array.isArray(value)) {\n      const resolved = await resolveTree(value as React.ReactNode);\n      if (resolved !== value) {\n        newProps[key] = resolved;\n        hasChanged = true;\n      }\n    }\n  }\n\n  return { newProps, hasChanged };\n}\n","import type { ReactNode } from \"react\";\nimport * as React from \"react\";\nimport { executeServerComponent } from \"./executeServerComponent\";\nimport { isClientComponent } from \"./isClientComponent\";\nimport { resolveProps } from \"./resolveProps\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves a server component element or recursively updates its element props.\n * Client component boundaries remain untouched and component errors propagate.\n *\n * @param node - The React element to resolve.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved render result or the updated original element.\n * @example\n * ```ts\n * await resolveElement(<ServerPage />, resolveRscTree);\n * ```\n */\nexport async function resolveElement(\n  node: React.ReactElement,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const { type, props } = node;\n\n  if (typeof type === \"function\" && !isClientComponent(type)) {\n    const serverResult = await executeServerComponent(\n      type as React.ComponentType<Record<string, unknown>>,\n      props as Record<string, unknown>,\n    );\n    return resolveTree(serverResult);\n  }\n\n  if (props && typeof props === \"object\") {\n    const { newProps, hasChanged } = await resolveProps(\n      props as Record<string, unknown>,\n      resolveTree,\n    );\n    if (hasChanged) {\n      return React.cloneElement(node, newProps);\n    }\n  }\n\n  return node;\n}\n","import * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { resolveArrayChild } from \"./resolveArrayChild\";\nimport { resolveElement } from \"./resolveElement\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Traverses arrays and React elements, delegating component resolution.\n *\n * @param node - The tree value to visit.\n * @param resolveTree - The recursive tree resolver.\n * @returns The traversed value with server components resolved.\n * @example\n * ```ts\n * await traverseTree(tree, resolveRscTree);\n * ```\n */\nexport async function traverseTree(\n  node: ReactNode,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  if (!node || typeof node !== \"object\") return node;\n\n  if (Array.isArray(node)) {\n    return Promise.all(\n      node.map((child, index) => resolveArrayChild(child, index, resolveTree)),\n    );\n  }\n\n  if (React.isValidElement(node)) {\n    return resolveElement(node, resolveTree);\n  }\n\n  return node;\n}\n","import type { ReactNode } from \"react\";\nimport { traverseTree } from \"./traverseTree\";\n\n/**\n * Recursively resolves synchronous and asynchronous React Server Components.\n * Client component boundaries are preserved, and component errors are allowed\n * to reject the returned promise.\n *\n * @param node - The React node or tree to resolve.\n * @returns A promise for the resolved React tree.\n * @example\n * ```ts\n * const resolved = await resolveRscTree(<ServerPage />);\n * ```\n */\nexport async function resolveRscTree(node: ReactNode): Promise<ReactNode> {\n  return traverseTree(node, resolveRscTree);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,eAAsB,kBACpB,OACA,OACA,aACoB;CACpB,MAAM,gBAAgB,MAAM,YAAY,KAAK;CAC7C,IAAIA,MAAM,eAAe,aAAa,GAAG;EACvC,MAAM,WACJ,cAAc,OACb,OAA4B,OAC7B,WAAW;EACb,OAAOA,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,IAAIC,KAAe,KAAK,CAAC,CAAC,OAAO;CAM1C,OAAO,MAAMC,KAAkB,KAAK;AACtC;;;;;;;;;;;;;;;;;;;;;;ACZA,SAAgB,YAAY,MAA8C;CAGxE,MAAM,kBAFS,SAAS,UAAU,SAAS,KAAK,IAEnB,CAAC,CAAC,QAAQ,kCAAkC,EAAE;CAE3E,OAAO,oCAAoC,KAAK,eAAe;AACjE;;;;;;;;;;;;;;;ACXA,SAAgB,kBAAkB,MAAwB;CACxD,IACE,SAAS,QACR,OAAO,SAAS,cAAc,OAAO,SAAS,UAE/C,OAAO;CAGT,MAAM,YAAY;CAClB,IACE,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,OAAO,UAAU,SAAS,UAE1B,OAAO;CAGT,OAAO,OAAO,SAAS,cAAc,YAAY,IAAa;AAChE;;;;;;;;;;;;;;AClBA,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,IAAIC,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,OAAOC,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,IAAIC,MAAM,eAAe,IAAI,GAC3B,OAAO,eAAe,MAAM,WAAW;CAGzC,OAAO;AACT;;;;;;;;;;;;;;;ACnBA,eAAsB,eAAe,MAAqC;CACxE,OAAO,aAAa,MAAM,cAAc;AAC1C"}

package/dist/react.mjs

@@ -55,6 +55,31 @@ async function executeServerComponent(type, props) {
 	return await type(props);
 }
 //#endregion
+//#region src/features/react/utils/mayUseHooks.ts
+/**
+* Determines whether a function's source appears to contain a React hook call.
+*
+* Recognizes calls whose names are `use` or begin with `use` followed by an
+* uppercase letter, digit, or underscore. It also supports transformed calls
+* where a closing parenthesis appears between the hook name and its opening
+* call parenthesis, such as `(0, imported.useState)(initialValue)`.
+*
+* Comments are removed before matching to reduce false positives from
+* hook-like text in comments.
+*
+* This is a heuristic, not a complete JavaScript parser. In particular,
+* comment-like sequences inside strings or template literals can confuse
+* comment removal, and hook calls can be missed or falsely detected when
+* source code is transformed or contains hook-like text in string literals.
+*
+* @param type - The function whose source should be inspected.
+* @returns `true` if the source matches a likely hook call; otherwise `false`.
+*/
+function mayUseHooks(type) {
+	const withoutComments = Function.prototype.toString.call(type).replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, "");
+	return /\buse(?:[A-Z0-9_]\w*)?\s*\)?\s*\(/.test(withoutComments);
+}
+//#endregion
 //#region src/features/react/utils/isClientComponent.ts
 /**
 * Determines whether a component should be kept behind a client boundary.
@@ -72,7 +97,7 @@ 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));
+	return typeof type === "function" && mayUseHooks(type);
 }
 //#endregion
 //#region src/features/react/utils/resolveProps.ts

package/dist/react.mjs.map

@@ -1 +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"}
+{"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/mayUseHooks.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\";\nimport * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves one array child and supplies a stable key when the result is an\n * element without one.\n *\n * @param child - The child value to resolve.\n * @param index - The child's position in its containing array.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved child.\n * @example\n * ```ts\n * await resolveArrayChild(<Page />, 0, resolveRscTree);\n * ```\n */\nexport async function resolveArrayChild(\n  child: ReactNode,\n  index: number,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const resolvedChild = await resolveTree(child);\n  if (React.isValidElement(resolvedChild)) {\n    const keyToUse =\n      resolvedChild.key ??\n      (child as { key?: string })?.key ??\n      `rsc-key-${index}`;\n    return React.cloneElement(resolvedChild, { key: keyToUse });\n  }\n  return resolvedChild;\n}\n","/**\n * Determines whether a component type is a React class component.\n *\n * @param type - The value to inspect.\n * @returns `true` when the value is a React class component.\n * @example\n * ```ts\n * isClassComponent(MyClassComponent); // true\n * ```\n */\nexport function isClassComponent(type: unknown): boolean {\n  return (\n    typeof type === \"function\" &&\n    Boolean(\n      (type as { prototype?: { isReactComponent?: unknown } }).prototype\n        ?.isReactComponent,\n    )\n  );\n}\n","import type * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { isClassComponent } from \"./isClassComponent\";\n\n/**\n * Executes a server component and awaits an asynchronous result when present.\n * Component errors intentionally propagate to the caller.\n *\n * @param type - The server component to execute.\n * @param props - Props passed to the component.\n * @returns The component's resolved render result.\n * @example\n * ```ts\n * await executeServerComponent(Page, { title: \"Hello\" });\n * ```\n */\nexport async function executeServerComponent(\n  type: React.ComponentType<Record<string, unknown>>,\n  props: Record<string, unknown>,\n): Promise<ReactNode> {\n  if (isClassComponent(type)) {\n    const ClassComponent = type as React.ComponentClass<\n      Record<string, unknown>\n    >;\n    return new ClassComponent(props).render();\n  }\n\n  const FunctionComponent = type as React.FunctionComponent<\n    Record<string, unknown>\n  >;\n  return await FunctionComponent(props);\n}\n","/**\n * Determines whether a function's source appears to contain a React hook call.\n *\n * Recognizes calls whose names are `use` or begin with `use` followed by an\n * uppercase letter, digit, or underscore. It also supports transformed calls\n * where a closing parenthesis appears between the hook name and its opening\n * call parenthesis, such as `(0, imported.useState)(initialValue)`.\n *\n * Comments are removed before matching to reduce false positives from\n * hook-like text in comments.\n *\n * This is a heuristic, not a complete JavaScript parser. In particular,\n * comment-like sequences inside strings or template literals can confuse\n * comment removal, and hook calls can be missed or falsely detected when\n * source code is transformed or contains hook-like text in string literals.\n *\n * @param type - The function whose source should be inspected.\n * @returns `true` if the source matches a likely hook call; otherwise `false`.\n */\nexport function mayUseHooks(type: (...args: never[]) => unknown): boolean {\n  const source = Function.prototype.toString.call(type);\n\n  const withoutComments = source.replace(/\\/\\*[\\s\\S]*?\\*\\/|\\/\\/[^\\r\\n]*/g, \"\");\n\n  return /\\buse(?:[A-Z0-9_]\\w*)?\\s*\\)?\\s*\\(/.test(withoutComments);\n}\n","import { mayUseHooks } from \"./mayUseHooks\";\n\n/**\n * Determines whether a component should be kept behind a client boundary.\n * React client/module references and functions containing hook calls are not\n * invoked directly by the resolver.\n *\n * @param type - The React element type to inspect.\n * @returns `true` when the type represents a client boundary.\n * @example\n * ```ts\n * isClientComponent({ $$typeof: Symbol.for(\"react.client.reference\") }); // true\n * ```\n */\nexport function isClientComponent(type: unknown): boolean {\n  if (\n    type === null ||\n    (typeof type !== \"function\" && typeof type !== \"object\")\n  ) {\n    return false;\n  }\n\n  const reference = type as { $$typeof?: symbol; $$id?: unknown };\n  if (\n    reference.$$typeof === Symbol.for(\"react.client.reference\") ||\n    reference.$$typeof === Symbol.for(\"react.module.reference\") ||\n    typeof reference.$$id === \"string\"\n  ) {\n    return true;\n  }\n\n  return typeof type === \"function\" && mayUseHooks(type as never);\n}\n","import * as React from \"react\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves React elements and arrays nested in a component's props.\n *\n * @param props - The component props to inspect.\n * @param resolveTree - The recursive tree resolver.\n * @returns Updated props and whether any prop value changed.\n * @example\n * ```ts\n * const result = await resolveProps({ children: <Page /> }, resolveRscTree);\n * ```\n */\nexport async function resolveProps(\n  props: Record<string, unknown>,\n  resolveTree: ResolveTree,\n): Promise<{ newProps: Record<string, unknown>; hasChanged: boolean }> {\n  const newProps: Record<string, unknown> = { ...props };\n  let hasChanged = false;\n\n  for (const key of Object.keys(newProps)) {\n    const value = newProps[key];\n    if (React.isValidElement(value) || Array.isArray(value)) {\n      const resolved = await resolveTree(value as React.ReactNode);\n      if (resolved !== value) {\n        newProps[key] = resolved;\n        hasChanged = true;\n      }\n    }\n  }\n\n  return { newProps, hasChanged };\n}\n","import type { ReactNode } from \"react\";\nimport * as React from \"react\";\nimport { executeServerComponent } from \"./executeServerComponent\";\nimport { isClientComponent } from \"./isClientComponent\";\nimport { resolveProps } from \"./resolveProps\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Resolves a server component element or recursively updates its element props.\n * Client component boundaries remain untouched and component errors propagate.\n *\n * @param node - The React element to resolve.\n * @param resolveTree - The recursive tree resolver.\n * @returns The resolved render result or the updated original element.\n * @example\n * ```ts\n * await resolveElement(<ServerPage />, resolveRscTree);\n * ```\n */\nexport async function resolveElement(\n  node: React.ReactElement,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  const { type, props } = node;\n\n  if (typeof type === \"function\" && !isClientComponent(type)) {\n    const serverResult = await executeServerComponent(\n      type as React.ComponentType<Record<string, unknown>>,\n      props as Record<string, unknown>,\n    );\n    return resolveTree(serverResult);\n  }\n\n  if (props && typeof props === \"object\") {\n    const { newProps, hasChanged } = await resolveProps(\n      props as Record<string, unknown>,\n      resolveTree,\n    );\n    if (hasChanged) {\n      return React.cloneElement(node, newProps);\n    }\n  }\n\n  return node;\n}\n","import * as React from \"react\";\nimport type { ReactNode } from \"react\";\nimport { resolveArrayChild } from \"./resolveArrayChild\";\nimport { resolveElement } from \"./resolveElement\";\nimport type { ResolveTree } from \"./types\";\n\n/**\n * Traverses arrays and React elements, delegating component resolution.\n *\n * @param node - The tree value to visit.\n * @param resolveTree - The recursive tree resolver.\n * @returns The traversed value with server components resolved.\n * @example\n * ```ts\n * await traverseTree(tree, resolveRscTree);\n * ```\n */\nexport async function traverseTree(\n  node: ReactNode,\n  resolveTree: ResolveTree,\n): Promise<ReactNode> {\n  if (!node || typeof node !== \"object\") return node;\n\n  if (Array.isArray(node)) {\n    return Promise.all(\n      node.map((child, index) => resolveArrayChild(child, index, resolveTree)),\n    );\n  }\n\n  if (React.isValidElement(node)) {\n    return resolveElement(node, resolveTree);\n  }\n\n  return node;\n}\n","import type { ReactNode } from \"react\";\nimport { traverseTree } from \"./traverseTree\";\n\n/**\n * Recursively resolves synchronous and asynchronous React Server Components.\n * Client component boundaries are preserved, and component errors are allowed\n * to reject the returned promise.\n *\n * @param node - The React node or tree to resolve.\n * @returns A promise for the resolved React tree.\n * @example\n * ```ts\n * const resolved = await resolveRscTree(<ServerPage />);\n * ```\n */\nexport async function resolveRscTree(node: ReactNode): Promise<ReactNode> {\n  return traverseTree(node, resolveRscTree);\n}\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;;;;;;;;;;;;;;;;;;;;;;ACZA,SAAgB,YAAY,MAA8C;CAGxE,MAAM,kBAFS,SAAS,UAAU,SAAS,KAAK,IAEnB,CAAC,CAAC,QAAQ,kCAAkC,EAAE;CAE3E,OAAO,oCAAoC,KAAK,eAAe;AACjE;;;;;;;;;;;;;;;ACXA,SAAgB,kBAAkB,MAAwB;CACxD,IACE,SAAS,QACR,OAAO,SAAS,cAAc,OAAO,SAAS,UAE/C,OAAO;CAGT,MAAM,YAAY;CAClB,IACE,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,UAAU,aAAa,OAAO,IAAI,wBAAwB,KAC1D,OAAO,UAAU,SAAS,UAE1B,OAAO;CAGT,OAAO,OAAO,SAAS,cAAc,YAAY,IAAa;AAChE;;;;;;;;;;;;;;AClBA,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/vitest/console.d.mts

@@ -0,0 +1,2 @@
+import { n as shutConsole, t as resetConsole } from "../index-DtGBqDev.mjs";
+export { resetConsole, shutConsole };

package/dist/vitest/console.mjs

@@ -0,0 +1 @@
+export { t as resetConsole, n as shutConsole } from "../console-Cf1taTRK.mjs";

package/dist/vitest/dom.d.mts

@@ -0,0 +1,2 @@
+import { a as shouldSee, c as shouldHaveTestId, d as isChecked, f as clickLabelInput, h as ToggleState, i as togglePopover, l as shouldHaveAttributes, m as ToggleConfig, n as userTypes, o as shouldNotSee, p as fireEvent, r as userClicks, s as shouldNotHaveTestId, t as userTypesMultiple, u as isNotChecked } from "../index-CKsosUpb.mjs";
+export { type ToggleConfig, type ToggleState, clickLabelInput, fireEvent, isChecked, isNotChecked, shouldHaveAttributes, shouldHaveTestId, shouldNotHaveTestId, shouldNotSee, shouldSee, togglePopover, userClicks, userTypes, userTypesMultiple };

package/dist/vitest/dom.mjs

@@ -0,0 +1 @@
+export { f as clickLabelInput, p as fireEvent, d as isChecked, u as isNotChecked, l as shouldHaveAttributes, c as shouldHaveTestId, s as shouldNotHaveTestId, o as shouldNotSee, a as shouldSee, i as togglePopover, r as userClicks, n as userTypes, t as userTypesMultiple } from "../dom-DeHbD1ni.mjs";

package/dist/vitest.d.mts

@@ -1,251 +1,6 @@
-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
+import { n as shutConsole, t as resetConsole } from "./index-DtGBqDev.mjs";
+import { a as shouldSee, c as shouldHaveTestId, d as isChecked, f as clickLabelInput, h as ToggleState, i as togglePopover, l as shouldHaveAttributes, m as ToggleConfig, n as userTypes, o as shouldNotSee, p as fireEvent, r as userClicks, s as shouldNotHaveTestId, t as userTypesMultiple, u as isNotChecked } from "./index-CKsosUpb.mjs";
+//#region src/features/promises/utils/resolvedPromise.d.ts
 /**
  * Creates a fulfilled promise augmented with Vitest's fulfilled-promise metadata.
  *
@@ -257,12 +12,12 @@ export declare function userTypesMultiple(inputs: Record<string, string>, contai
  * expect(payload).toEqual({ id: 1 });
  * ```
  */
-export declare function resolvedPromise<T>(value: T): Promise<T> & {
+declare function resolvedPromise$1<T>(value: T): Promise<T> & {
   status: "fulfilled";
   value: T;
 };
 //#endregion
-//#region src/features/vitest/modules/promises/utils/rejectedPromise.d.ts
+//#region src/features/promises/utils/rejectedPromise.d.ts
 /**
  * Creates a rejected promise augmented with Vitest's rejected-promise metadata.
  *
@@ -273,33 +28,22 @@ export declare function resolvedPromise<T>(value: T): Promise<T> & {
  * await expect(rejectedPromise(new Error("Request failed"))).rejects.toThrow("Request failed");
  * ```
  */
-export declare function rejectedPromise(reason?: unknown): Promise<never> & {
+declare function rejectedPromise$1(reason?: unknown): Promise<never> & {
   status: "rejected";
   reason: unknown;
 };
 //#endregion
-//#region src/features/vitest/utils/console.d.ts
+//#region src/features/vitest/index.d.ts
 /**
- * Suppresses console.log, console.warn, and console.error until resetConsole runs.
- *
- * @example
- * ```ts
- * beforeEach(shutConsole);
- * afterEach(resetConsole);
- * ```
+ * @deprecated Import `rejectedPromise` from `@vickbk/tests/promises` instead.
+ * This re-export is retained for backward compatibility.
  */
-export declare function shutConsole(): void;
+export declare const rejectedPromise: typeof rejectedPromise$1;
 /**
- * Restores the console methods most recently suppressed by shutConsole.
- *
- * @example
- * ```ts
- * shutConsole();
- * // Run code whose console output should be ignored.
- * resetConsole();
- * ```
+ * @deprecated Import `resolvedPromise` from `@vickbk/tests/promises` instead.
+ * This re-export is retained for backward compatibility.
  */
-export declare function resetConsole(): void;
+export declare const resolvedPromise: typeof resolvedPromise$1;
 //#endregion
-export type { ToggleConfig, ToggleState };
+export { type ToggleConfig, type ToggleState, clickLabelInput, fireEvent, isChecked, isNotChecked, resetConsole, shouldHaveAttributes, shouldHaveTestId, shouldNotHaveTestId, shouldNotSee, shouldSee, shutConsole, togglePopover, userClicks, userTypes, userTypesMultiple };
 //# sourceMappingURL=vitest.d.mts.map

package/dist/vitest.d.mts.map

@@ -1 +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"}
+{"version":3,"file":"vitest.d.mts","names":["resolvedPromise","rejectedPromise","_rejectedPromise","_resolvedPromise"],"sources":["../src/features/promises/utils/resolvedPromise.ts","../src/features/promises/utils/rejectedPromise.ts","../src/features/vitest/index.ts"],"mappings":";;;;;;;;;;;;;;iBAWgBA,kBAAgB,GAC9B,OAAO,IACN,QAAQ;EAAO;EAAqB,OAAO;;;;;;;;;;;;;;iBCH9BC,kBACd,mBACC;EAAmB;EAAoB;;;;;;;;qBCC7B,wBAAeC;;;;;qBAMf,wBAAeC"}