repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/mockup/preview.ts
Rawimport { 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();
});
});
}