@jterrazz/test 16.1.0 → 17.0.0

package/dist/playwright.adapter.js

@@ -1,349 +0,0 @@
-import { a as formatElement, i as describeAmbiguity, n as widenedForWindow, r as AmbiguousElementError } from "./substring-warning.js";
-import { mkdtempSync } from "node:fs";
-import { resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { setTimeout } from "node:timers/promises";
-//#region src/seams/playwright/playwright.adapter.ts
-/** How many candidates the ambiguity error enumerates before truncating. */
-const MAX_REPORTED_MATCHES = 10;
-const VALUE_TIMEOUT_MS = 3e4;
-const VALUE_POLL_MS = 100;
-/**
-* The roles a FIELD can carry — what `field('Name')` designates.
-*
-* A field is named by its ACCESSIBLE name, not by the text of the label
-* element that happens to wrap it: `<label><span>Channel</span><select>…` has
-* a label whose text carries every option of the select, while the control's
-* accessible name is `Channel` — which is what the ARIA tree shows and what a
-* screen reader reads. Resolving by label text alone made the ordinary
-* wrapping-label form unreachable under the 16.0 whole-name default.
-*
-* The label-text locator stays in the union for the controls ARIA gives no
-* role at all (a date or colour input), which nothing else would find.
-*/
-const FIELD_ROLES = [
-	"checkbox",
-	"combobox",
-	"radio",
-	"searchbox",
-	"slider",
-	"spinbutton",
-	"switch",
-	"textbox"
-];
-/**
-* Translate a user-facing descriptor into a playwright locator, resolving
-* `scope` outside-in so `within(navigation(), link('X'))` searches the nav
-* subtree. No `.first()` anywhere: playwright's strict mode is the mechanism
-* behind CONVENTIONS W3, and swallowing it would reintroduce the silent
-* wrong-element bug the rule exists to prevent.
-*/
-function locate(root, element) {
-	const scope = element.scope ? locate(root, element.scope) : root;
-	const exact = element.exact ?? true;
-	const name = element.name ?? "";
-	if (element.kind === "field") {
-		let field = scope.getByLabel(name, { exact });
-		for (const role of FIELD_ROLES) field = field.or(scope.getByRole(role, {
-			exact,
-			name
-		}));
-		return field;
-	}
-	if (element.kind === "testId") return scope.getByTestId(name);
-	if (element.kind === "text") return scope.getByText(name, { exact });
-	return scope.getByRole(element.kind, element.name === void 0 ? { exact } : {
-		exact,
-		name: element.name
-	});
-}
-/** Playwright signals "more than one match" through this error text. */
-function isStrictViolation(error) {
-	return error instanceof Error && error.message.includes("strict mode violation");
-}
-/** Capture the candidates in-page — the evidence the refusal enumerates. */
-async function captureMatches(locator) {
-	return await locator.evaluateAll((nodes, limit) => {
-		const LANDMARKS = "nav, header, footer, main, aside, section, form, [role]";
-		return nodes.slice(0, limit).map((node) => {
-			const element = node;
-			const landmark = element.parentElement?.closest(LANDMARKS);
-			const context = landmark ? landmark.getAttribute("role") ?? landmark.tagName.toLowerCase() : null;
-			const detail = element.getAttribute("href") ?? element.getAttribute("name");
-			const text = (element.textContent ?? "").replaceAll(/\s+/gu, " ").trim().slice(0, 80);
-			const label = element.getAttribute("aria-label")?.trim();
-			return {
-				accessibleName: label && label !== text ? label : void 0,
-				context: context ?? void 0,
-				detail: detail ?? void 0,
-				tag: element.tagName.toLowerCase(),
-				text
-			};
-		});
-	}, MAX_REPORTED_MATCHES);
-}
-/**
-* Run one visitor action, converting a strict-mode violation into the W3
-* refusal. The ambiguous level is identified before reporting: a scope that
-* matches several landmarks is the real fault, and naming the target instead
-* would send the author to fix the wrong descriptor.
-*/
-async function act(page, element, action) {
-	const target = await widenedForWindow(element, page.url(), probeOf(page)) ?? element;
-	try {
-		return await action(locate(page, target));
-	} catch (error) {
-		if (!isStrictViolation(error)) throw error;
-		const culprit = await findAmbiguousLevel(page, target);
-		const matches = await captureMatches(locate(page, culprit));
-		throw new AmbiguousElementError(describeAmbiguity({
-			element: culprit,
-			matches,
-			url: page.url()
-		}));
-	}
-}
-/** What the transitional window may ask of the page. */
-function probeOf(page) {
-	return {
-		count: async (element) => await locate(page, element).count(),
-		nameOf: async (element) => {
-			const [match] = await captureMatches(locate(page, element));
-			return match?.accessibleName ?? match?.text;
-		}
-	};
-}
-/** Walk the scope chain outside-in; the outermost ambiguous level is the fault. */
-async function findAmbiguousLevel(page, element) {
-	const chain = [];
-	for (let current = element; current; current = current.scope) chain.unshift(current);
-	for (const level of chain.slice(0, -1)) if (await locate(page, level).count() > 1) return level;
-	return element;
-}
-/**
-* The same element, narrowed by whatever STATE the descriptor carries — focus,
-* or accepting input — or `null` when it carries none.
-*
-* A second condition on the locator rather than a one-shot probe: the locator
-* keeps playwright's own retry, so `see(focused(x))` waits for the keyboard to
-* arrive instead of asking once and failing on a frame of animation. It also
-* needs nothing but `playwright` — `expect(...).toBeFocused()` lives in
-* `@playwright/test`, which this package deliberately does not carry.
-*/
-function stateOnly(page, locator, element) {
-	if (element.focused === true) return locator.and(page.locator(":focus"));
-	if (element.disabled !== void 0) return locator.and(page.locator(element.disabled ? ":disabled" : ":enabled"));
-	if (element.selected !== void 0) return locator.and(page.locator(element.selected ? ":checked" : ":not(:checked)"));
-	return null;
-}
-/**
-* Is this descriptor answered by PRESENCE rather than by visibility? The
-* options of a collapsed `<select>` are in the document and in the tree, and
-* none of them has a box on the screen until a visitor opens it.
-*/
-function byPresence(element) {
-	return element.kind === "option";
-}
-/** The field's live value, or `null` when nothing (unambiguous) is there yet. */
-async function currentValue(locator) {
-	try {
-		return await locator.inputValue({ timeout: VALUE_POLL_MS });
-	} catch (error) {
-		if (isStrictViolation(error)) throw error;
-		return null;
-	}
-}
-/**
-* Wait until the field holds the value the descriptor carries — or, for
-* `gone()`, until it no longer does.
-*
-* A poll rather than a narrowed locator: a value is a PROPERTY of the node,
-* and the CSS a locator narrows with reads ATTRIBUTES — a controlled input
-* whose `value` attribute never moves would answer for a value it no longer
-* holds. The locator is re-read every round, so a re-rendered field is read
-* again rather than held as a stale handle.
-*/
-async function waitForValue(locator, element, wanted) {
-	const value = element.value ?? "";
-	const deadline = Date.now() + VALUE_TIMEOUT_MS;
-	for (;;) {
-		const actual = await currentValue(locator);
-		if (actual === null ? !wanted : actual === value === wanted) return;
-		if (Date.now() >= deadline) throw new Error(`${formatElement(element)} ${wanted ? "never held" : "still holds"} ${JSON.stringify(value)}${actual === null ? " (it is not on the page)" : `, it holds ${JSON.stringify(actual)}`}`);
-		await setTimeout(VALUE_POLL_MS);
-	}
-}
-/** The visitor implementation — every action auto-waits via playwright actionability. */
-function createVisitor(page, baseUrl) {
-	return {
-		check: async (element) => {
-			await act(page, element, async (locator) => {
-				await locator.check();
-			});
-		},
-		click: async (element) => {
-			await act(page, element, async (locator) => {
-				await locator.click();
-			});
-		},
-		fill: async (element, value) => {
-			await act(page, element, async (locator) => {
-				await locator.fill(value);
-			});
-		},
-		goto: async (path) => {
-			await page.goto(`${baseUrl}${path}`, { waitUntil: "load" });
-		},
-		hover: async (element) => {
-			await act(page, element, async (locator) => {
-				await locator.hover();
-			});
-		},
-		press: async (key) => {
-			await page.keyboard.press(key);
-		},
-		gone: async (element) => {
-			await act(page, element, async (locator) => {
-				if (element.value !== void 0) {
-					await waitForValue(locator, element, false);
-					return;
-				}
-				const narrowed = stateOnly(page, locator, element);
-				if (narrowed !== null) {
-					await narrowed.waitFor({ state: "detached" });
-					return;
-				}
-				await locator.waitFor({ state: byPresence(element) ? "detached" : "hidden" });
-			});
-		},
-		see: async (element) => {
-			await act(page, element, async (locator) => {
-				if (element.value !== void 0) {
-					await waitForValue(locator, element, true);
-					return;
-				}
-				const narrowed = stateOnly(page, locator, element);
-				if (narrowed !== null) {
-					await narrowed.waitFor({ state: "attached" });
-					return;
-				}
-				await locator.waitFor({ state: byPresence(element) ? "attached" : "visible" });
-			});
-		},
-		select: async (element, option) => {
-			await act(page, element, async (locator) => await locator.selectOption(option));
-		}
-	};
-}
-/**
-* Browser adapter backed by playwright chromium.
-*
-* ONE browser process per adapter (= per runner = per vitest worker),
-* launched lazily on the first `open()`. Each visit gets a fresh
-* `BrowserContext` — isolation without paying a browser launch per spec.
-*
-* Playwright is an optional peer dependency: it is only imported here, and
-* this module is only loaded when a spec calls `.visit()`.
-*/
-var PlaywrightAdapter = class {
-	browser = null;
-	async close() {
-		if (this.browser) {
-			await this.browser.close();
-			this.browser = null;
-		}
-	}
-	async open(url, options) {
-		const context = await (await this.launch()).newContext({ extraHTTPHeaders: options.headers ?? {} });
-		if (options.external === "block") {
-			const allowed = /* @__PURE__ */ new Set([new URL(options.baseUrl).origin, ...options.allowedOrigins ?? []]);
-			await context.route("**/*", (route) => {
-				if (allowed.has(new URL(route.request().url()).origin)) route.continue();
-				else route.abort();
-			});
-		}
-		try {
-			const page = await context.newPage();
-			if (options.clock !== void 0) await page.clock.setFixedTime(new Date(options.clock));
-			const consoleMessages = [];
-			page.on("console", (message) => {
-				consoleMessages.push({
-					text: message.text(),
-					type: message.type()
-				});
-			});
-			const response = await page.goto(url, { waitUntil: "load" });
-			if (options.scenario) try {
-				await options.scenario(createVisitor(page, options.baseUrl));
-			} catch (error) {
-				const evidence = await this.captureEvidence(page);
-				const suffix = evidence ? `\nEvidence: ${evidence}` : "";
-				if (error instanceof AmbiguousElementError) {
-					error.message += suffix;
-					throw error;
-				}
-				throw new Error(`visit scenario failed: ${error instanceof Error ? error.message : String(error)}${suffix}`, { cause: error });
-			}
-			const extraction = await page.evaluate(() => {
-				const links = [...document.querySelectorAll("link")].map((link) => ({
-					href: link.href,
-					hreflang: link.hreflang || void 0,
-					rel: link.rel,
-					type: link.type || void 0
-				}));
-				const metas = [...document.querySelectorAll("meta")].map((meta) => ({
-					content: meta.content,
-					name: meta.name || void 0,
-					property: meta.getAttribute("property") ?? void 0
-				}));
-				const jsonLdBlocks = [...document.querySelectorAll("script[type=\"application/ld+json\"]")].map((script) => script.textContent ?? "");
-				return {
-					html: document.documentElement.outerHTML,
-					jsonLdBlocks,
-					links,
-					metas,
-					text: document.body?.innerText ?? "",
-					title: document.title
-				};
-			});
-			const tree = await page.locator("body").ariaSnapshot();
-			return {
-				consoleMessages,
-				status: response?.status() ?? 0,
-				tree,
-				url: page.url(),
-				...extraction
-			};
-		} finally {
-			await context.close();
-		}
-	}
-	/** Screenshot the failing state into a temp file; never masks the original error. */
-	async captureEvidence(page) {
-		try {
-			const dir = mkdtempSync(resolve(tmpdir(), "spec-website-"));
-			const path = resolve(dir, "failure.png");
-			await page.screenshot({
-				fullPage: true,
-				path
-			});
-			return path;
-		} catch {
-			return null;
-		}
-	}
-	/** Launch the shared chromium instance (once), with an actionable error when playwright is absent. */
-	async launch() {
-		if (this.browser) return this.browser;
-		let chromium;
-		try {
-			({chromium} = await import("playwright"));
-		} catch {
-			throw new Error(".visit() requires playwright (optional peer dependency): npm install -D playwright && npx playwright install chromium");
-		}
-		this.browser = await chromium.launch();
-		return this.browser;
-	}
-};
-//#endregion
-export { PlaywrightAdapter };

package/dist/server.js

@@ -1,160 +0,0 @@
-import { a as isStreamBody, n as ContractQueue, t as toReadableStream } from "./stream.js";
-//#region src/seams/msw/handlers.ts
-/**
-* What a chain with zero contracts gets where the facet's scope is KNOWN but
-* not total — the node engine, which shares a process with everything else the
-* test does. Nothing was declared, so nothing is guarded and nothing has to be
-* torn down (CONVENTIONS D7, known scope).
-*/
-const NO_CONTRACTS = {
-	cleanup: () => {},
-	violation: () => null
-};
-/**
-* A contract answers the request that was made, never a copy of an earlier one.
-*
-* In a page the reply travels through a real service worker and a real HTTP
-* cache, so a second render of the same component can be served the FIRST
-* test's answer and never reach the queue at all — a contract that was
-* exhausted, or replaced, silently keeps answering. Stated as a default, so a
-* spec whose subject IS caching can still say otherwise.
-*/
-const NEVER_CACHED = { "cache-control": "no-store" };
-/** Turn a contract response into the msw reply, body kind by body kind. */
-function toMswResponse(msw, response) {
-	const { body, headers, status = 200 } = response;
-	if (response.transport === "network-error") return msw.HttpResponse.error();
-	if (body === null || body === void 0) return new msw.HttpResponse(null, {
-		headers: {
-			...NEVER_CACHED,
-			...headers
-		},
-		status
-	});
-	if (isStreamBody(body)) return new msw.HttpResponse(toReadableStream(body), {
-		headers: {
-			...NEVER_CACHED,
-			"content-type": body.contentType,
-			...headers
-		},
-		status
-	});
-	if (typeof body === "string") return new msw.HttpResponse(body, {
-		headers: {
-			...NEVER_CACHED,
-			"content-type": "text/plain; charset=utf-8",
-			...headers
-		},
-		status
-	});
-	return msw.HttpResponse.json(body, {
-		headers: {
-			...NEVER_CACHED,
-			...headers
-		},
-		status
-	});
-}
-/**
-* The handlers one chain's contracts become, plus the trailing catch-all that
-* records any request no contract accepted (CONVENTIONS D7). The caller decides
-* what to do with the recorded violation — the api chain rethrows it, the
-* component chain fails the render. An EMPTY contract list is still a guard:
-* the catch-all alone says "this subject has no network".
-*
-* `bypass` names the traffic that is not the subject's: under node there is
-* none, in a page it is everything the runner fetches to BE a page.
-*/
-function buildContractHandlers(msw, contracts, bypass) {
-	const queue = new ContractQueue(contracts);
-	let violation = null;
-	const recordViolation = (method, url) => {
-		violation ??= queue.unmatchedError(method, url);
-		return msw.HttpResponse.json({ error: `@jterrazz/test strict contracts: unmatched request ${method} ${url}` }, {
-			headers: NEVER_CACHED,
-			status: 501
-		});
-	};
-	const handlers = [];
-	for (const route of queue.routes) for (const method of route.methods) {
-		const handlerFn = method === "*" ? msw.http.all : msw.http[method.toLowerCase()];
-		if (!handlerFn) continue;
-		handlers.push(handlerFn(route.url, async ({ request }) => {
-			const observed = await observe(request);
-			const contract = queue.take(observed);
-			if (!contract) return recordViolation(request.method, request.url);
-			const response = typeof contract.response === "function" ? contract.response(observed) : contract.response;
-			if (response.delay) await new Promise((resolve) => setTimeout(resolve, response.delay));
-			return toMswResponse(msw, response);
-		}));
-	}
-	handlers.push(msw.http.all("*", ({ request }) => bypass?.(request.url) === true ? msw.passthrough() : recordViolation(request.method, request.url)));
-	return {
-		handlers,
-		violation: () => violation ?? queue.requiredError()
-	};
-}
-/** The request as the queue matches it — body parsed when it is JSON. */
-async function observe(request) {
-	let body = null;
-	const rawText = await request.clone().text();
-	if (rawText) try {
-		body = JSON.parse(rawText);
-	} catch {
-		body = rawText;
-	}
-	const headers = {};
-	request.headers.forEach((value, key) => {
-		headers[key.toLowerCase()] = value;
-	});
-	return {
-		body,
-		headers,
-		method: request.method.toUpperCase(),
-		url: request.url
-	};
-}
-//#endregion
-//#region src/seams/msw/server.ts
-let mswModule = null;
-let mswHttp = null;
-async function loadMsw() {
-	if (mswModule === null) {
-		mswModule = await import("msw/node");
-		mswHttp = await import("msw");
-	}
-	return {
-		msw: mswHttp,
-		node: mswModule
-	};
-}
-let serverInstance = null;
-/**
-* Start the MSW server (once per process).
-*/
-async function ensureContractServer() {
-	if (serverInstance !== null) return;
-	const { node } = await loadMsw();
-	serverInstance = node.setupServer();
-	serverInstance.listen({ onUnhandledRequest: "bypass" });
-}
-/**
-* Register a chain's contracts as MSW handlers. A trailing catch-all handler
-* records any request no contract accepted — the builder rethrows it as the
-* spec failure (rejecting the action promise, never an unhandled rejection).
-*/
-async function registerContracts(contracts) {
-	if (contracts.length === 0) return NO_CONTRACTS;
-	await ensureContractServer();
-	const { msw } = await loadMsw();
-	const { handlers, violation } = buildContractHandlers(msw, contracts);
-	serverInstance.use(...handlers);
-	return {
-		cleanup: () => {
-			serverInstance.resetHandlers();
-		},
-		violation
-	};
-}
-//#endregion
-export { registerContracts };