Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/mockup/preview.ts

Raw
import { randomUUID } from "node:crypto";
import { createServer, type Server } from "node:http";
import { type Browser, chromium } from "playwright";
import { type MockupRequest, renderPreviewPage } from "./mockup.js";

export type PreviewShot = {
	optionId: string;
	pageId?: string;
	data: Buffer;
};

export type PreviewCapture = {
	shots: PreviewShot[];
	skipped: Array<{ optionId: string; pageId?: string }>;
};

type PreviewTarget = { optionId: string; pageId?: string; pageIndex?: number };

const DEFAULT_SHOT_LIMIT = 8;

export async function captureMockupPreviews(
	request: MockupRequest,
	options: { limit?: number; signal?: AbortSignal } = {},
): Promise<PreviewCapture> {
	const { signal } = options;
	signal?.throwIfAborted();
	const flattened: PreviewTarget[] = request.options.flatMap((option) =>
		option.pages
			? option.pages.map((page, pageIndex) => ({
					optionId: option.id,
					pageId: page.id,
					pageIndex,
				}))
			: [{ optionId: option.id }],
	);
	const limit = Math.max(
		1,
		Math.min(DEFAULT_SHOT_LIMIT, options.limit ?? DEFAULT_SHOT_LIMIT),
	);
	const targets = flattened.slice(0, limit);
	const identity = ({ optionId, pageId }: PreviewTarget) => ({
		optionId,
		...(pageId !== undefined && { pageId }),
	});
	const skipped = flattened.slice(targets.length).map(identity);
	const shots: PreviewShot[] = [];
	const token = randomUUID();
	const previewHtml = renderPreviewPage(request);
	const server = createServer((req, res) => {
		if (req.method !== "GET" || req.url !== `/preview?k=${token}`) {
			res.writeHead(404).end();
			return;
		}
		res.writeHead(200, {
			"Content-Type": "text/html; charset=utf-8",
			"Cache-Control": "no-store",
		});
		res.end(previewHtml);
	});
	let browser: Browser | undefined;
	const abort = () => {
		void browser?.close().catch(() => undefined);
	};
	signal?.addEventListener("abort", abort, { once: true });
	try {
		await listen(server);
		const address = server.address();
		if (!address || typeof address === "string")
			throw new Error("failed to bind preview server");
		signal?.throwIfAborted();
		try {
			browser = await chromium.launch({ headless: true, timeout: 10_000 });
		} catch (error) {
			signal?.throwIfAborted();
			const reason = (
				error instanceof Error ? error.message : String(error)
			).split("\n")[0];
			throw new Error(
				`Headless Chromium could not be launched (${reason}). Install the matching browser with mise run //extensions/mockup:install-browser in the pi-ext checkout, then retry.`,
				{ cause: error },
			);
		}
		signal?.throwIfAborted();
		const context = await browser.newContext({
			viewport: { width: 680, height: 1000 },
			deviceScaleFactor: 1,
			serviceWorkers: "block",
		});
		const url = `http://127.0.0.1:${address.port}/preview?k=${token}`;
		let served = false;
		await context.route("**/*", async (route) => {
			const req = route.request();
			if (!served && req.isNavigationRequest() && req.url() === url) {
				served = true;
				await route.continue();
			} else await route.abort();
		});
		await context.routeWebSocket("**/*", (socket) => socket.close());
		const page = await context.newPage();
		page.setDefaultTimeout(10_000);
		await page.goto(url, { waitUntil: "load" });
		for (const target of targets) {
			signal?.throwIfAborted();
			try {
				if (target.pageIndex !== undefined)
					await page.evaluate(
						({ optionId, index }) => {
							const host = document.querySelector(
								`[data-preview-option="${optionId}"]`,
							);
							const root = host?.shadowRoot as
								| (ShadowRoot & { showPage(index: number): void })
								| null;
							root?.showPage(index);
						},
						{ optionId: target.optionId, index: target.pageIndex },
					);
				const data = await page
					.locator(`[data-preview-option="${target.optionId}"]`)
					.screenshot({ animations: "disabled" });
				signal?.throwIfAborted();
				shots.push({ ...identity(target), data });
			} catch (error) {
				signal?.throwIfAborted();
				if (!browser.isConnected()) throw error;
				skipped.push(identity(target));
			}
		}
		signal?.throwIfAborted();
		return { shots, skipped };
	} finally {
		signal?.removeEventListener("abort", abort);
		await browser?.close().catch(() => undefined);
		server.close();
		server.closeAllConnections();
	}
}

function listen(server: Server): Promise<void> {
	return new Promise((resolve, reject) => {
		server.once("error", reject);
		server.listen(0, "127.0.0.1", () => {
			server.off("error", reject);
			resolve();
		});
	});
}