@jterrazz/test 17.0.0 → 18.0.1

package/dist/browser/index.js

@@ -1,2 +1 @@
-import { A as region, B as option, C as component, D as form, E as contentinfo, F as dialog, G as directory, H as status, I as field, J as defineStubs, K as file, L as heading, M as within, N as button, O as main, P as content, R as link, S as http, T as complementary, U as table, V as row, W as testId, X as match, Y as Matcher, _ as clock, a as ruleTester, b as openai, c as waitUntil, d as disabled, f as enabled, g as mockOf, h as valued, i as redis, j as search, k as navigation, l as required, m as selected, n as postgres, o as specification, p as focused, q as defineStub, r as process, s as sqlite, t as ProcessHandle, u as text, v as packed, w as banner, x as anthropic, y as intercept, z as listitem } from "../shared-index.browser.js";
-export { Matcher, ProcessHandle, anthropic, banner, button, clock, complementary, component, content, contentinfo, defineStub, defineStubs, dialog, directory, disabled, enabled, field, file, focused, form, heading, http, intercept, link, listitem, main, match, mockOf, navigation, openai, option, packed, postgres, process, redis, region, required, row, ruleTester, search, selected, specification, sqlite, status, table, testId, text, valued, waitUntil, within };
+export { Y as Matcher, t as ProcessHandle, x as anthropic, w as banner, N as button, _ as clock, T as complementary, C as component, P as content, E as contentinfo, q as defineStub, J as defineStubs, F as dialog, G as directory, d as disabled, f as enabled, I as field, K as file, p as focused, D as form, L as heading, S as http, y as intercept, R as link, z as listitem, O as main, X as match, g as mockOf, k as navigation, b as openai, B as option, v as packed, n as postgres, r as process, i as redis, A as region, l as required, V as row, a as ruleTester, j as search, m as selected, o as specification, s as sqlite, H as status, U as table, W as testId, u as text, h as valued, c as waitUntil, M as within } from "../browser-shared-index.browser.js";

package/dist/browser/services.js

@@ -1,2 +1 @@
-import { i as redis, n as postgres, r as process, s as sqlite, t as ProcessHandle } from "../shared-index.browser.js";
-export { ProcessHandle, postgres, process, redis, sqlite };
+export { t as ProcessHandle, n as postgres, r as process, i as redis, s as sqlite } from "../browser-shared-index.browser.js";

package/dist/browser/stubs.js

@@ -1,2 +1 @@
-import { J as defineStubs, S as http, b as openai, q as defineStub, x as anthropic, y as intercept } from "../shared-index.browser.js";
-export { anthropic, defineStub, defineStubs, http, intercept, openai };
+export { x as anthropic, q as defineStub, J as defineStubs, S as http, y as intercept, b as openai } from "../browser-shared-index.browser.js";

package/dist/{shared-index.browser.js → browser-shared-index.browser.js}

@@ -191,14 +191,6 @@ const clock$1 = defineCapability({
 	}
 });
 //#endregion
-//#region src/chain/pause.ts
-async function pause(ms) {
-	if (ms <= 0) return;
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
-//#endregion
 //#region src/stubs/exchange.ts
 /** Each adapter serialises an object as JSON, so a stream declared as a plain value would arrive as `{}`: the tag tells them apart. */
 const STREAM_BODY = "@jterrazz/test:stream";
@@ -718,7 +710,36 @@ var StubQueue = class {
 	}
 };
 //#endregion
+//#region src/chain/pause.ts
+async function pause(ms) {
+	if (ms <= 0) return;
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+/** Asks `probe` until it answers something other than `undefined`, which it hands back, or answers `undefined` once `timeout` has passed. Measured on `performance.now()`, so `clock.at()`, which fakes `Date`, cannot freeze it. */
+async function untilDeadline(probe, { interval = 0, timeout, wait }) {
+	const deadline = performance.now() + timeout;
+	for (;;) {
+		const answer = await probe();
+		if (answer !== void 0) return answer;
+		const remaining = deadline - performance.now();
+		if (remaining <= 0) return;
+		await (wait === void 0 ? pause(interval) : wait(remaining));
+	}
+}
+//#endregion
 //#region src/stubs/delivery/stream-body.ts
+async function nextTask() {
+	const { port1, port2 } = new MessageChannel();
+	await new Promise((resolve) => {
+		port1.onmessage = () => {
+			port1.close();
+			resolve();
+		};
+		port2.postMessage(null);
+	});
+}
 /** One serialisation for all three deliveries (msw server, msw worker, `node:http` stub). */
 function toReadableStream(body) {
 	const encoder = new TextEncoder();
@@ -729,12 +750,39 @@ function toReadableStream(body) {
 			controller.close();
 			return;
 		}
-		if (body.delayBetweenChunks > 0 && index > 0) await pause(body.delayBetweenChunks);
+		if (index > 0) {
+			await pause(body.delayBetweenChunks);
+			await nextTask();
+		}
 		index += 1;
 		controller.enqueue(encoder.encode(chunk));
 	} });
 }
 //#endregion
+//#region src/stubs/delivery/stub-reply.ts
+/** A request's body as a stub's filter reads it: the parsed JSON, the raw text when it is none, `null` when there is none. */
+function requestBody(raw) {
+	if (raw.length === 0) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+/** The reply a matched stub states for this request, once its delay has passed. */
+async function replyOf(response, observed) {
+	const reply = typeof response === "function" ? response(observed) : response;
+	await pause(reply.delay ?? 0);
+	return reply;
+}
+/** The `error` of the 501 every delivery answers a request it refuses, whichever process serves it. */
+function refusedReply(summary) {
+	return `@jterrazz/test strict stubs: ${summary}`;
+}
+function unmatchedSummary(method, url) {
+	return `unmatched request ${method} ${url}`;
+}
+//#endregion
 //#region src/stubs/delivery/msw-handlers.ts
 const NEVER_CACHED = { "cache-control": "no-store" };
 function toMswResponse(msw, response) {
@@ -786,13 +834,14 @@ function handlerOf(msw, method) {
 function buildStubHandlers(msw, stubs, bypass) {
 	const queue = new StubQueue(stubs);
 	let violation = null;
-	const recordViolation = (method, url) => {
-		violation ??= queue.unmatchedError(method, url);
-		return msw.HttpResponse.json({ error: `@jterrazz/test strict stubs: unmatched request ${method} ${url}` }, {
+	const refuse = (error, summary) => {
+		violation ??= error;
+		return msw.HttpResponse.json({ error: refusedReply(summary) }, {
 			headers: NEVER_CACHED,
 			status: 501
 		});
 	};
+	const recordViolation = (method, url) => refuse(queue.unmatchedError(method, url), unmatchedSummary(method, url));
 	const handlers = [];
 	for (const route of queue.routes) for (const method of route.methods) {
 		const handlerFn = handlerOf(msw, method);
@@ -801,27 +850,19 @@ function buildStubHandlers(msw, stubs, bypass) {
 			const observed = await observe(request);
 			const stub = queue.take(observed);
 			if (!stub) return recordViolation(request.method, request.url);
-			const response = typeof stub.response === "function" ? stub.response(observed) : stub.response;
-			await pause(response.delay ?? 0);
-			return toMswResponse(msw, response);
+			return toMswResponse(msw, await replyOf(stub.response, observed));
 		}));
 	}
 	handlers.push(msw.http.all("*", ({ request }) => bypass?.(request.url) === true ? msw.passthrough() : recordViolation(request.method, request.url)));
 	return {
 		handlers,
+		refuse,
 		violation: () => queue.verdict(violation)
 	};
 }
 async function observe(request) {
-	let body = null;
-	const rawText = await request.clone().text();
-	if (rawText) try {
-		body = JSON.parse(rawText);
-	} catch {
-		body = rawText;
-	}
 	return {
-		body,
+		body: requestBody(await request.clone().text()),
 		headers: Object.fromEntries(request.headers),
 		method: request.method.toUpperCase(),
 		url: request.url
@@ -842,15 +883,19 @@ function isRunnerRequest(url) {
 	const { pathname } = new URL(url);
 	return RUNNER_PREFIXES.some((prefix) => pathname.startsWith(prefix));
 }
+/** msw's hook for a frame no handler took: the subject's HTTP request prints msw's error; the runner's own request and a WebSocket frame, which carries none, pass. */
+function onUnhandledFrame({ defaults, frame }) {
+	const { data } = frame;
+	if (typeof data !== "object" || data === null || !("request" in data)) return;
+	if (data.request instanceof Request && !isRunnerRequest(data.request.url)) defaults.error();
+}
 async function ensureStubWorker() {
 	if (workerInstance !== null) return;
 	const { setupWorker } = await import("msw/browser");
 	const worker = setupWorker();
 	workerInstance = worker;
 	await worker.start({
-		onUnhandledRequest: (request, print) => {
-			if (!isRunnerRequest(request.url)) print.error();
-		},
+		onUnhandledFrame,
 		quiet: true,
 		serviceWorker: { url: "/mockServiceWorker.js" }
 	});
@@ -1260,7 +1305,7 @@ function recordConsole() {
 const ANSI_RE = /\u001B\[[0-9;]*m/gu;
 /** rule `no-transform-duplicating-tokens`: a golden compares the text, never its colour. */
 function stripAnsiCodes(value) {
-	return value.replace(ANSI_RE, "");
+	return value.replaceAll(ANSI_RE, "");
 }
 //#endregion
 //#region src/expectations/text/grep.ts
@@ -3154,18 +3199,15 @@ const DEFAULT_INTERVAL_MS = 50;
 /** Wait until a condition holds; measured on `performance.now()`, so `clock.at()` cannot freeze it. Under `clock.run()` it never wakes: use `clock.advance()`. */
 async function waitUntil(predicate, options = {}) {
 	const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
-	const interval = options.interval ?? DEFAULT_INTERVAL_MS;
-	const deadline = performance.now() + timeout;
-	for (;;) {
-		if (await predicate()) return;
-		if (performance.now() >= deadline) throw new Error(refusal({
-			fix: "raise the budget if the wait is legitimate, or wait on what actually changes",
-			found: `waitUntil(): ${options.why ?? "the condition"} did not hold within ${timeout}ms`,
-			read: "docs/reference/assertions.md#two-helpers-that-are-not-matchers",
-			why: "`waitUntil()` waits on a condition, within a budget."
-		}));
-		await pause(interval);
-	}
+	if (await untilDeadline(async () => await predicate() || void 0, {
+		interval: options.interval ?? DEFAULT_INTERVAL_MS,
+		timeout
+	}) === void 0) throw new Error(refusal({
+		fix: "raise the budget if the wait is legitimate, or wait on what actually changes",
+		found: `waitUntil(): ${options.why ?? "the condition"} did not hold within ${timeout}ms`,
+		read: "docs/reference/assertions.md#two-helpers-that-are-not-matchers",
+		why: "`waitUntil()` waits on a condition, within a budget."
+	}));
 }
 //#endregion
 //#region src/index.browser.ts
@@ -3188,4 +3230,4 @@ const sqlite = () => refuse("sqlite()");
 //#endregion
 export { region as A, option as B, component as C, form as D, contentinfo as E, dialog as F, directory as G, status as H, field as I, defineStubs as J, file as K, heading as L, within as M, button as N, main as O, content as P, link as R, http as S, complementary as T, table as U, row as V, testId as W, match as X, Matcher as Y, clock as _, ruleTester as a, openai as b, waitUntil as c, disabled as d, enabled as f, mockOf as g, valued as h, redis as i, search as j, navigation as k, required as l, selected as m, postgres as n, specification as o, focused as p, defineStub as q, process$1 as r, sqlite as s, ProcessHandle as t, text as u, packed as v, banner as w, anthropic as x, intercept as y, listitem as z };
 
-//# sourceMappingURL=shared-index.browser.js.map
+//# sourceMappingURL=browser-shared-index.browser.js.map