import type { Browser, Page } from "puppeteer-core"; interface LoadedPage { browser: Browser; version: string; /** The latest time scheduled on the page; its frames run in order, so this is where it ends up. */ shownUpTo: number; page: Promise; queue: Promise; idleTimer?: ReturnType; } /** One loaded preview page per document URL: a thumbnail is a seek and a screenshot on it, not a * fresh load of the whole composition. A new `version` (project content) reloads the page, calls on * one page run one at a time so their seeks never interleave, and a page unused for `idleMs` closes * so an idle Studio keeps no composition running. A page only seeks forward, as a render does: a * composition need not draw the same frame when seeked back, so an earlier time gets a fresh page. */ export function createThumbnailPages(maxPages = 2, idleMs = 1_000) { const pages = new Map(); const drop = (url: string) => { const entry = pages.get(url); if (!entry) return; pages.delete(url); clearTimeout(entry.idleTimer); // After any frame still running on it. void entry.queue .then(() => entry.page) .then((page) => page.close()) .catch(() => {}); }; const entryFor = ( browser: Browser, url: string, version: string, time: number, load: (page: Page) => Promise, ): LoadedPage => { const existing = pages.get(url); if ( existing && existing.browser === browser && existing.version === version && existing.shownUpTo <= time ) { existing.shownUpTo = time; return existing; } drop(url); const page = browser.newPage().then(async (created) => { try { await load(created); } catch (error) { // The page never leaves this promise, so a failed load has to close it here. await created.close().catch(() => {}); throw error; } return created; }); const entry: LoadedPage = { browser, version, shownUpTo: time, page, queue: Promise.resolve() }; pages.set(url, entry); while (pages.size > maxPages) drop(pages.keys().next().value!); return entry; }; const armIdleClose = (url: string, entry: LoadedPage) => { if (pages.get(url) !== entry) return; clearTimeout(entry.idleTimer); entry.idleTimer = setTimeout(() => { if (pages.get(url) === entry) drop(url); }, idleMs); entry.idleTimer.unref?.(); }; return { async withPage( browser: Browser, url: string, version: string, time: number, load: (page: Page) => Promise, use: (page: Page) => Promise, ): Promise { const current = entryFor(browser, url, version, time, load); clearTimeout(current.idleTimer); const run = current.queue.then(async () => use(await current.page)); current.queue = run.catch(() => {}); try { return await run; } catch (error) { if (pages.get(url) === current) drop(url); throw error; } finally { armIdleClose(url, current); } }, closeAll(): void { for (const url of [...pages.keys()]) drop(url); }, }; }