@piwitests/reporter 0.54.0 → 0.56.0

package/dist/internal/capture/attachments.d.ts

@@ -17,6 +17,8 @@ declare const ATTACHMENT_NAMES: {
     readonly pageInventory: "piwi-page-inventory";
     readonly locatorPages: "piwi-locator-pages";
     readonly codeReach: "piwi-code-reach";
+    readonly browserCoverage: "piwi-browser-coverage";
+    readonly browserFunctions: "piwi-browser-functions";
     readonly serverCoverageRequests: "piwi-server-coverage-requests";
     readonly webVitals: "piwi-web-vitals";
     readonly locatorSuggestion: "piwi-locator-suggestion";

package/dist/internal/capture/attachments.js

@@ -42,6 +42,8 @@ var ATTACHMENT_NAMES = {
   pageInventory: "piwi-page-inventory",
   locatorPages: "piwi-locator-pages",
   codeReach: "piwi-code-reach",
+  browserCoverage: "piwi-browser-coverage",
+  browserFunctions: "piwi-browser-functions",
   serverCoverageRequests: "piwi-server-coverage-requests",
   webVitals: "piwi-web-vitals",
   locatorSuggestion: "piwi-locator-suggestion",

package/dist/internal/capture/capture-fixtures.d.ts

@@ -54,9 +54,17 @@ declare function internalCall<T>(owner: unknown, run: () => Promise<T>): Promise
 interface CodeReachRoots {
     /** Directories a module path or a map source is tried against, first match wins; the repository root is last. */
     roots: string[];
+    /**
+     * Directories tried before `roots` for the scripts an origin serves, or, when the script's own origin has none,
+     * that a page at the origin loads: an application served by several dev servers (one per portal) resolves each
+     * one's modules against its own directory.
+     */
+    byOrigin?: Map<string, string[]>;
     /** Paths go out relative to it. */
     repoRoot: string;
 }
+/** The `codeReachRoots` option: directories for every script, or directories per origin, `*` for the rest. */
+type CodeReachRootsOption = string[] | Record<string, string | string[]>;
 /** Fetches a source map's text; null when it cannot. */
 type MapFetcher = (url: string) => Promise<string | null>;
 /**
@@ -67,20 +75,30 @@ type MapFetcher = (url: string) => Promise<string | null>;
 interface CoveredScript extends JsCoverageEntry {
     /** V8's content hash of the script; without it, the version is a hash of `source`. */
     hash?: string;
+    /** The address of the page's document as it parsed the script, whose origin's roots it falls back on. */
+    pageUrl?: string;
 }
 /**
- * The roots for a test: `codeReachRoots` when set, else the Playwright config's
- * directory; the repository root always comes last, since bundlers name
- * sources from the project root (Turbopack's `[project]/`).
+ * The roots for a test: `codeReachRoots` when set (an array, or the `*` entry of
+ * an object), else the Playwright config's directory; the repository root always
+ * comes last, since bundlers name sources from the project root (Turbopack's
+ * `[project]/`). An object's other keys are origins, each with the directories
+ * tried first for its scripts. Relative directories resolve against the config's.
+ */
+declare function codeReachRoots(configDir: string, configured: CodeReachRootsOption | null | undefined): CodeReachRoots;
+/**
+ * The repository-relative files the covered scripts reached, sorted and capped.
+ * A script whose own origin has no roots takes those of its page's origin: the
+ * page's address as it parsed the script, else `pageUrl`.
  */
-declare function codeReachRoots(configDir: string, configured: string[] | null | undefined): CodeReachRoots;
-/** The repository-relative files the covered scripts reached, sorted and capped. */
-declare function resolveCodeReach(entries: CoveredScript[], roots: CodeReachRoots, fetchMap: MapFetcher): Promise<string[]>;
+declare function resolveCodeReach(entries: CoveredScript[], roots: CodeReachRoots, fetchMap: MapFetcher, pageUrl?: string): Promise<string[]>;
 /** A map fetcher through the page's request context, bounded in size and time. */
 declare function pageMapFetcher(page: Page): MapFetcher;
 /**
  * Start function coverage on a page, with the debugger on to learn each
- * script's version; false when the browser has none or it fails.
+ * script's version and to stop as each document is left (its `beforeunload`,
+ * from a listener the capture adds in an isolated world); false when the
+ * browser has none or it fails.
  */
 declare function startCodeReach(page: Page): Promise<boolean>;
 /**
@@ -481,8 +499,11 @@ declare function computeCoreVitals(lcpEntries: RawVitalEntry[] | null, shiftEntr
     cls: number | null;
     inp: number | null;
 } | null;
-/** The code reach roots from `PIWI_CODE_REACH_ROOTS` (a JSON array or a path list). */
-declare function configuredCodeReachRoots(): string[] | null;
+/**
+ * The code reach roots from `PIWI_CODE_REACH_ROOTS`: a JSON array, a JSON object
+ * of directories per origin (`*` for every other origin), or a path list.
+ */
+declare function configuredCodeReachRoots(): CodeReachRootsOption | null;
 /** Page state captured at test end. Storage values and cookie values are NEVER included. */
 interface PageState extends PageInteraction {
     url: string;
@@ -527,7 +548,8 @@ interface RawPageState {
  * Assemble the wire page-state from the in-page reads, the context cookies and
  * what the page was doing (`readPageInteraction`). Pure and Node-side so the
  * sanitization (token masking, caps, value-free cookies, well-formed element
- * paths) is unit-testable.
+ * paths) is unit-testable. The URL goes without its fragment, which `hash`
+ * carries with its credentials masked (`#access_token=[masked]`).
  */
 declare function buildPageState(raw: RawPageState, cookies: Array<Record<string, unknown>> | null, interaction?: unknown): PageState;
 /**