touchpress 0.0.1

package/dist/index.mjs

@@ -0,0 +1,439 @@
+import { A as textMatch, D as parseDeviceOptions, S as resolve, T as TANGERE_DEFAULTS, _ as sleep, a as sizeOf, c as createClient, h as openSession, i as relativeTo, j as TangereError, l as captureEvidence, n as compareScreenshot, o as toPixelBox, r as cropScreenshot, s as createAgentDeviceDriver, t as preflight, u as createDevice, y as silentSink } from "./preflight-C83jCNPs.mjs";
+import { expect as expect$1, test as test$1 } from "@playwright/test";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+//#region src/playwright/fixtures.ts
+const SESSION_FIXTURE_TIMEOUT_MS = 18e4;
+const DEVICE_FIXTURE_TIMEOUT_MS = 12e4;
+/**
+* Tangere's options and none of its fixtures, for a setup project that reads the
+* configuration before any session exists, such as one calling `preflight`.
+*
+* `platform`, `app`, and `readyWhen` default to `undefined` rather than to a
+* plausible value. A Playwright option fixture needs a default of its declared
+* type, and `parseDeviceOptions` rejects `undefined` by name, so a config that
+* forgot a key and one that never set it fail the same way.
+*/
+const setupTest = test$1.extend({
+	platform: [void 0, {
+		option: true,
+		scope: "worker"
+	}],
+	app: [void 0, {
+		option: true,
+		scope: "worker"
+	}],
+	readyWhen: [void 0, {
+		option: true,
+		scope: "worker"
+	}],
+	deviceName: [void 0, {
+		option: true,
+		scope: "worker"
+	}],
+	launchUrl: [void 0, {
+		option: true,
+		scope: "worker"
+	}],
+	relaunch: [TANGERE_DEFAULTS.relaunch, {
+		option: true,
+		scope: "worker"
+	}],
+	onDeviceInUse: [TANGERE_DEFAULTS.onDeviceInUse, {
+		option: true,
+		scope: "worker"
+	}],
+	settleQuietMs: [TANGERE_DEFAULTS.settleQuietMs, {
+		option: true,
+		scope: "worker"
+	}],
+	launchTimeout: [TANGERE_DEFAULTS.launchTimeout, {
+		option: true,
+		scope: "worker"
+	}],
+	dismissDevOverlay: [TANGERE_DEFAULTS.dismissDevOverlay, {
+		option: true,
+		scope: "worker"
+	}],
+	evidence: [TANGERE_DEFAULTS.evidence, {
+		option: true,
+		scope: "worker"
+	}],
+	sessionPrefix: [TANGERE_DEFAULTS.sessionPrefix, {
+		option: true,
+		scope: "worker"
+	}]
+});
+/** The worker session already opened the app with a relaunch, so the first test skips one. */
+const startedTests = /* @__PURE__ */ new WeakSet();
+/**
+* `device` is auto so evidence capture runs for every test in a device project,
+* whether or not the body touched it. Its teardown runs before the session's,
+* inside the separate budget Playwright grants after the test finishes, so a
+* timed-out test still gets a screenshot.
+*
+* Importing and extending `test` launches no browser: `browser`, `context`, and
+* `page` are lazy and non-auto, and nothing here names them.
+*/
+const test = setupTest.extend({
+	session: [async ({ platform, app, readyWhen, deviceName, launchUrl, relaunch, onDeviceInUse, settleQuietMs, launchTimeout, dismissDevOverlay, evidence, sessionPrefix }, use, workerInfo) => {
+		const options = parseDeviceOptions({
+			platform,
+			app,
+			readyWhen,
+			deviceName,
+			launchUrl,
+			relaunch,
+			onDeviceInUse,
+			settleQuietMs,
+			launchTimeout,
+			dismissDevOverlay,
+			evidence,
+			sessionPrefix,
+			actionTimeout: workerInfo.project.use.actionTimeout
+		});
+		const session = await openSession({
+			options,
+			slot: workerInfo.parallelIndex,
+			scope: workerInfo.project.name,
+			sink: playwrightSink(),
+			createDriver: (name, selection) => createAgentDeviceDriver(createClient(), name, selection)
+		});
+		await use(session);
+		await session.close("worker-exit");
+	}, {
+		scope: "worker",
+		timeout: SESSION_FIXTURE_TIMEOUT_MS
+	}],
+	device: [async ({ session }, use, testInfo) => {
+		const sink = playwrightSink();
+		if (session.options.relaunch === "per-test" && startedTests.has(session)) await session.relaunch(sink);
+		startedTests.add(session);
+		await use(createDevice(session, sink));
+		if (shouldCapture(testInfo, session.options.evidence)) await captureEvidence(session, sink);
+	}, {
+		auto: true,
+		timeout: DEVICE_FIXTURE_TIMEOUT_MS
+	}]
+});
+function shouldCapture(testInfo, evidence) {
+	if (evidence === "off") return false;
+	return evidence === "always" || testInfo.status !== testInfo.expectedStatus;
+}
+/**
+* Resolves the running test on every call rather than capturing a `TestInfo`. A
+* worker outlives every test in it, so a captured one would file the second
+* test's evidence under the first test's report entry.
+*/
+function playwrightSink() {
+	return {
+		step: (title, body, options) => test$1.step(title, body, options),
+		attach: async (file) => {
+			const info = currentTest();
+			if (info === null) return;
+			await info.attach(file.name, "path" in file ? {
+				path: file.path,
+				contentType: file.contentType
+			} : {
+				body: file.body,
+				contentType: file.contentType
+			});
+		},
+		note: (key, value) => {
+			currentTest()?.annotations.push({
+				type: key,
+				description: value
+			});
+		},
+		outputPath: (fileName) => currentTest()?.outputPath(fileName) ?? silentSink.outputPath(fileName)
+	};
+}
+function currentTest() {
+	try {
+		return test$1.info();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/playwright/screenshot.ts
+const POLL_INTERVAL_MS = 250;
+const DEFAULT_MAX_DIFF_PIXEL_RATIO = .01;
+const DEFAULT_THRESHOLD = .2;
+/**
+* Numbers an unnamed screenshot per test, so two assertions in one test do not
+* write over each other's baseline. A retried test gets a fresh `TestInfo`, so
+* the numbering starts again and the same run reproduces the same paths.
+*/
+const ordinals = /* @__PURE__ */ new WeakMap();
+/**
+* The baseline path comes from `testInfo.snapshotPath`, so
+* `snapshotPathTemplate`, the per-project suffix and `--update-snapshots` behave
+* the way they do for Playwright's own screenshot assertion.
+*
+* A locator's crop and every mask are resolved off one snapshot taken next to
+* the image. Rects from two snapshots would index into the image at two
+* different scroll positions, which crops the wrong thing rather than failing.
+*/
+async function assertScreenshot(state, target, nameOrOptions, extra) {
+	const options = (typeof nameOrOptions === "string" ? extra : nameOrOptions) ?? {};
+	const info = test$1.info();
+	const sink = playwrightSink();
+	const timeout = options.timeout ?? state.timeout;
+	const maxDiffPixelRatio = options.maxDiffPixelRatio ?? DEFAULT_MAX_DIFF_PIXEL_RATIO;
+	const expected = `${state.isNot ? "not " : ""}at most ${percent(maxDiffPixelRatio)} of pixels to differ`;
+	const label = "query" in target ? target.description : "the whole device";
+	const baseline = info.snapshotPath(typeof nameOrOptions === "string" ? nameOrOptions : defaultName(info), { kind: "screenshot" });
+	const update = info.config.updateSnapshots;
+	const deadline = Date.now() + timeout;
+	let captures = 0;
+	let attempt = await capture(target, info, options.mask ?? []);
+	for (;;) {
+		captures += 1;
+		if (attempt.kind === "captured") {
+			if (!existsSync(baseline)) return missingBaseline(state, {
+				expected,
+				label,
+				baseline,
+				update,
+				png: attempt.png
+			});
+			const comparison = compareScreenshot(readFileSync(baseline), attempt.png, {
+				threshold: options.threshold ?? DEFAULT_THRESHOLD,
+				maxDiffPixelRatio,
+				mask: attempt.mask
+			});
+			const matched = comparison.kind === "match";
+			if (matched !== state.isNot) return {
+				pass: matched,
+				name: "toHaveScreenshot",
+				expected,
+				actual: received(comparison),
+				message: () => ""
+			};
+			if (!state.isNot && (update === "all" || update === "changed")) {
+				write(baseline, attempt.png);
+				return {
+					pass: true,
+					name: "toHaveScreenshot",
+					expected,
+					actual: received(comparison),
+					message: () => ""
+				};
+			}
+			if (Date.now() >= deadline) {
+				await attachAll(sink, baseline, attempt.png, comparison);
+				return fail(state, expected, received(comparison), [
+					`Expected ${state.isNot ? "not." : ""}toHaveScreenshot but it never ${state.isNot ? "differed" : "matched"}.`,
+					``,
+					`Target: ${label}`,
+					`Baseline: ${baseline}`,
+					`Expected: ${expected}`,
+					`Received: ${received(comparison)}`,
+					timeoutLine(timeout, captures),
+					``,
+					`expected.png, actual.png and diff.png are attached to this test in the HTML report.`
+				]);
+			}
+		} else if (Date.now() >= deadline) return fail(state, expected, null, [
+			`Expected ${state.isNot ? "not." : ""}toHaveScreenshot but the locator never resolved.`,
+			``,
+			`Target: ${label}`,
+			`Received: ${attempt.detail}`,
+			timeoutLine(timeout, captures)
+		]);
+		await sleep(Math.min(POLL_INTERVAL_MS, deadline - Date.now()));
+		attempt = await capture(target, info, options.mask ?? []);
+	}
+}
+/**
+* The scale is derived rather than asked for. A tree reports rects in whatever
+* units its platform uses, so the image width over the widest rect on screen,
+* which is the window, is what one unit is worth in pixels. It comes out at 1 on
+* both devices this is tested against, because agent-device writes the iOS
+* simulator's image at point resolution and the Android tree already reports
+* pixels. Deriving it keeps a device writing a 2x or 3x image from cropping the
+* wrong region.
+*/
+async function capture(target, info, masks) {
+	const device = "query" in target ? target.device : target;
+	const screen = await device.screen();
+	const path = await device.screenshot({ path: info.outputPath(`toHaveScreenshot-actual.png`) });
+	const full = readFileSync(path);
+	const scale = scaleOf(screen, sizeOf(full).width);
+	const region = "query" in target ? regionOf(screen, target.query, scale) : null;
+	if (typeof region === "string") return {
+		kind: "unresolved",
+		detail: region
+	};
+	const boxes = masks.flatMap((mask) => boxesOf(screen, mask.query, scale));
+	if (region === null) return {
+		kind: "captured",
+		png: full,
+		mask: boxes
+	};
+	return {
+		kind: "captured",
+		png: cropScreenshot(full, region),
+		mask: boxes.map((box) => relativeTo(box, region))
+	};
+}
+/** The crop for a locator, or why it could not be taken. */
+function regionOf(screen, query, scale) {
+	const resolution = resolve(screen, query);
+	switch (resolution.outcome) {
+		case "none": return "no node matched";
+		case "many": return `${String(resolution.nodes.length)} nodes matched, which is ambiguous. Narrow the locator or use .first() / .nth(n).`;
+		case "one": {
+			const rect = resolution.node.rect;
+			if (rect === null) return `${resolution.node.ref} reports no rect, so there is nothing to crop`;
+			return toPixelBox(rect, scale);
+		}
+		default: throw new Error(`unhandled resolution ${JSON.stringify(resolution)}`);
+	}
+}
+/** A mask hides a region rather than picking one node, so ambiguity is not an error here. */
+function boxesOf(screen, query, scale) {
+	const resolution = resolve(screen, query);
+	return (resolution.outcome === "one" ? [resolution.node] : resolution.outcome === "many" ? resolution.nodes : []).flatMap((node) => node.rect === null ? [] : [toPixelBox(node.rect, scale)]);
+}
+function scaleOf(screen, imageWidth) {
+	const widest = Math.max(0, ...screen.nodes.map((node) => node.rect?.width ?? 0));
+	return widest > 0 ? imageWidth / widest : 1;
+}
+function missingBaseline(state, input) {
+	if (state.isNot) return fail(state, input.expected, null, [
+		`Expected not.toHaveScreenshot, but there is no baseline to differ from.`,
+		``,
+		`Target: ${input.label}`,
+		`Baseline: ${input.baseline}`,
+		``,
+		`Write one with a passing toHaveScreenshot first.`
+	]);
+	write(input.baseline, input.png);
+	if (input.update === "all" || input.update === "missing") return {
+		pass: true,
+		name: "toHaveScreenshot",
+		expected: input.expected,
+		actual: null,
+		message: () => ""
+	};
+	return fail(state, input.expected, null, [`A snapshot doesn't exist at ${input.baseline}, writing actual.`]);
+}
+async function attachAll(sink, baseline, actual, comparison) {
+	await sink.attach({
+		name: "expected.png",
+		path: baseline,
+		contentType: "image/png"
+	});
+	const actualPath = sink.outputPath("actual.png");
+	writeFileSync(actualPath, actual);
+	await sink.attach({
+		name: "actual.png",
+		path: actualPath,
+		contentType: "image/png"
+	});
+	if (comparison.kind !== "mismatch") return;
+	const diffPath = sink.outputPath("diff.png");
+	writeFileSync(diffPath, comparison.diff);
+	await sink.attach({
+		name: "diff.png",
+		path: diffPath,
+		contentType: "image/png"
+	});
+}
+function received(comparison) {
+	switch (comparison.kind) {
+		case "match":
+		case "mismatch": return `${percent(comparison.ratio)} of pixels differ`;
+		case "size-mismatch": return `the screenshot is ${size(comparison.actual)} and the baseline is ${size(comparison.expected)}`;
+		default: throw new Error(`unhandled comparison ${JSON.stringify(comparison)}`);
+	}
+}
+function size(value) {
+	return `${String(value.width)}x${String(value.height)}`;
+}
+function percent(ratio) {
+	const shown = ratio * 100;
+	return `${shown < .1 && shown > 0 ? shown.toFixed(3) : String(Math.round(shown * 100) / 100)}%`;
+}
+function timeoutLine(timeout, captures) {
+	return `Timeout: ${String(timeout)}ms (${String(captures)} capture${captures === 1 ? "" : "s"})`;
+}
+function fail(state, expected, actual, lines) {
+	return {
+		pass: state.isNot,
+		name: "toHaveScreenshot",
+		expected,
+		actual,
+		message: () => lines.join("\n")
+	};
+}
+function write(path, png) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, png);
+}
+function defaultName(info) {
+	const next = (ordinals.get(info) ?? 0) + 1;
+	ordinals.set(info, next);
+	return `${info.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}-${String(next)}.png`;
+}
+//#endregion
+//#region src/playwright/expect.ts
+/**
+* `this.timeout` is `expect.timeout` from the Playwright config. `this.isNot`
+* selects the predicate the poll waits for, which is what makes
+* `.not.toBeVisible()` wait for a control to leave instead of passing on a race.
+*/
+async function runCheck(state, locator, check, timeout) {
+	const result = await locator.expect(check, {
+		negate: state.isNot,
+		timeoutMs: timeout ?? state.timeout
+	});
+	return {
+		pass: result.pass,
+		name: check.name,
+		expected: result.expected,
+		actual: result.actual,
+		message: () => result.message
+	};
+}
+function retrying(name) {
+	return function(locator, options) {
+		return runCheck(this, locator, { name }, options?.timeout);
+	};
+}
+/**
+* Playwright's own matcher names on this package's `expect` only. Matcher
+* typing is by the first parameter, so these surface on `expect(locator)` and
+* nothing else.
+*/
+const expect = expect$1.extend({
+	toBeVisible: retrying("toBeVisible"),
+	toBeEnabled: retrying("toBeEnabled"),
+	toBeSelected: retrying("toBeSelected"),
+	toBeFocused: retrying("toBeFocused"),
+	toHaveText(locator, expected, options) {
+		return runCheck(this, locator, {
+			name: "toHaveText",
+			expected: textMatch(expected, options?.exact)
+		}, options?.timeout);
+	},
+	toHaveValue(locator, expected, options) {
+		return runCheck(this, locator, {
+			name: "toHaveValue",
+			expected: textMatch(expected, true)
+		}, options?.timeout);
+	},
+	toHaveCount(locator, expected, options) {
+		return runCheck(this, locator, {
+			name: "toHaveCount",
+			expected
+		}, options?.timeout);
+	},
+	toHaveScreenshot(target, nameOrOptions, options) {
+		return assertScreenshot(this, target, nameOrOptions, options);
+	}
+});
+//#endregion
+export { TangereError, expect, preflight, setupTest, test };