diff --git a/client/src/components/Studio/PhotoView.tsx b/client/src/components/Studio/PhotoView.tsx
index f3313042e..0b45eb63f 100644
--- a/client/src/components/Studio/PhotoView.tsx
+++ b/client/src/components/Studio/PhotoView.tsx
@@ -2,7 +2,7 @@ import { photoLookOf, type BookFrame, type BookPhotoElement, type BookShapeId, t
import type { CSSProperties, ReactNode } from 'react';
import { fontStack } from './bookFonts';
-import { photoSrc } from './bookRender';
+import { PRINT_SRC_ATTR, photoSrc } from './bookRender';
import { usePaintId } from './paint/usePaintId';
import { pictureFilter, silhouetteShadows, svgFilterMatrices, zoomPlacement } from './photo/photoLook';
import { photoClip } from './shapeOutline';
@@ -172,7 +172,7 @@ function Picture({
const zoom = zoomPlacement(look.zoom, el.focalX, el.focalY);
const img = (
` starts loading the
+ * moment it has a `src`. A journey of a few hundred photos asked the server for
+ * every original at once, twice (off screen in the editor, then in the print
+ * frame), and the browser gave up with "insufficient resources" (#3102). So the
+ * print markup carries the source here and `loadPrintImages` hands it over a
+ * few at a time.
+ */
+export const PRINT_SRC_ATTR = 'data-print-src'
+
export function photoSrc(photoId: number, big: boolean): string {
return `/api/photos/${photoId}/${big ? 'original' : 'thumbnail'}`
}
diff --git a/client/src/components/Studio/printImages.test.ts b/client/src/components/Studio/printImages.test.ts
new file mode 100644
index 000000000..7658c22e4
--- /dev/null
+++ b/client/src/components/Studio/printImages.test.ts
@@ -0,0 +1,86 @@
+/**
+ * FE-STUDIO-PRINTIMG-001 to FE-STUDIO-PRINTIMG-004
+ *
+ * The print view hands a book's photographs their sources a few at a time, so
+ * a large journey does not ask for every original at once (#3102).
+ */
+import { describe, expect, it } from 'vitest';
+
+import { PRINT_SRC_ATTR } from './bookRender';
+import { loadPrintImages } from './printImages';
+
+/** A print document with `count` deferred photos. */
+function printDoc(count: number): { doc: Document; imgs: HTMLImageElement[] } {
+ const doc = document.implementation.createHTMLDocument('print');
+ doc.body.innerHTML = Array.from(
+ { length: count },
+ (_, i) => `
`
+ ).join('');
+ return { doc, imgs: Array.from(doc.images) };
+}
+
+/**
+ * Answers each source the loader sets, on the next tick, the way a browser fires
+ * load or error. `fails` says how many times a source errors before it loads;
+ * a source mapped to Infinity never answers. Tracks the most in flight at once.
+ */
+function answer(imgs: HTMLImageElement[], fails: Record = {}) {
+ const state = { inFlight: 0, maxInFlight: 0, requests: [] as string[] };
+ for (const img of imgs) {
+ Object.defineProperty(img, 'src', {
+ configurable: true,
+ get: () => img.getAttribute('src') ?? '',
+ set: (src: string) => {
+ img.setAttribute('src', src);
+ state.requests.push(src);
+ if (fails[src] === Infinity) return;
+ state.inFlight++;
+ state.maxInFlight = Math.max(state.maxInFlight, state.inFlight);
+ setTimeout(() => {
+ state.inFlight--;
+ const left = fails[src] ?? 0;
+ if (left > 0) {
+ fails[src] = left - 1;
+ img.dispatchEvent(new Event('error'));
+ } else img.dispatchEvent(new Event('load'));
+ }, 0);
+ },
+ });
+ }
+ return state;
+}
+
+describe('loadPrintImages', () => {
+ it('FE-STUDIO-PRINTIMG-001: loads every deferred photo with no more than the limit in flight', async () => {
+ const { doc, imgs } = printDoc(10);
+ const state = answer(imgs);
+ const progress: string[] = [];
+ await loadPrintImages(doc, { concurrency: 3, onProgress: (done, total) => progress.push(`${done}/${total}`) });
+ expect(state.maxInFlight).toBe(3);
+ expect(imgs.every((img) => img.getAttribute('src')?.startsWith('/api/photos/'))).toBe(true);
+ expect(imgs.some((img) => img.hasAttribute(PRINT_SRC_ATTR))).toBe(false);
+ expect(progress.at(-1)).toBe('10/10');
+ });
+
+ it('FE-STUDIO-PRINTIMG-002: asks once more for a photo that failed', async () => {
+ const { doc, imgs } = printDoc(1);
+ const state = answer(imgs, { '/api/photos/0/original': 1 });
+ await loadPrintImages(doc);
+ expect(state.requests).toEqual(['/api/photos/0/original', '/api/photos/0/original']);
+ expect(imgs[0].getAttribute('src')).toBe('/api/photos/0/original');
+ });
+
+ it('FE-STUDIO-PRINTIMG-003: gives up on a photo that never answers, so the others and the button still finish', async () => {
+ const { doc, imgs } = printDoc(2);
+ answer(imgs, { '/api/photos/0/original': Infinity });
+ const progress: number[] = [];
+ await loadPrintImages(doc, { timeoutMs: 5, onProgress: (done) => progress.push(done) });
+ expect(progress).toEqual([1, 2]);
+ expect(imgs[1].getAttribute('src')).toBe('/api/photos/1/original');
+ });
+
+ it('FE-STUDIO-PRINTIMG-004: a book without photos is ready at once', async () => {
+ const { doc } = printDoc(0);
+ await expect(loadPrintImages(doc)).resolves.toBeUndefined();
+ });
+});
diff --git a/client/src/components/Studio/printImages.ts b/client/src/components/Studio/printImages.ts
new file mode 100644
index 000000000..8cb740531
--- /dev/null
+++ b/client/src/components/Studio/printImages.ts
@@ -0,0 +1,71 @@
+/**
+ * Loading a book's photographs into its print view a few at a time.
+ *
+ * The sheets carry each photo's source in `PRINT_SRC_ATTR` rather than in
+ * `src` (see bookRender.ts), so nothing loads until this hands the sources
+ * over. A handful run at once: enough to keep the connection busy, few enough
+ * that a book of several hundred originals does not exhaust the browser
+ * (#3102). A photo that fails is asked for once more before it is left blank,
+ * and one that never answers is given up on after a while, so the Save button
+ * always comes on in the end.
+ */
+
+import { PRINT_SRC_ATTR } from './bookRender';
+
+const PRINT_IMAGES = {
+ concurrency: 4,
+ timeoutMs: 60_000,
+ retries: 1,
+} as const;
+
+export interface PrintImageOptions {
+ concurrency?: number;
+ timeoutMs?: number;
+ /** Called after each photo has loaded or been given up on. */
+ onProgress?: (done: number, total: number) => void;
+}
+
+/** Point `img` at `src` and resolve with whether it loaded, or false after `timeoutMs`. */
+function loadOne(img: HTMLImageElement, src: string, timeoutMs: number): Promise {
+ return new Promise((resolve) => {
+ const finish = (ok: boolean) => {
+ clearTimeout(timer);
+ img.removeEventListener('load', onLoad);
+ img.removeEventListener('error', onError);
+ resolve(ok);
+ };
+ const onLoad = () => finish(true);
+ const onError = () => finish(false);
+ const timer = setTimeout(() => finish(false), timeoutMs);
+ img.addEventListener('load', onLoad);
+ img.addEventListener('error', onError);
+ img.src = src;
+ });
+}
+
+/** Resolves once every deferred photo in `doc` has loaded or been given up on. */
+export async function loadPrintImages(doc: Document, options: PrintImageOptions = {}): Promise {
+ const concurrency = Math.max(1, options.concurrency ?? PRINT_IMAGES.concurrency);
+ const timeoutMs = options.timeoutMs ?? PRINT_IMAGES.timeoutMs;
+ const images = Array.from(doc.querySelectorAll(`img[${PRINT_SRC_ATTR}]`));
+ const total = images.length;
+ let next = 0;
+ let done = 0;
+
+ const worker = async () => {
+ while (next < images.length) {
+ const img = images[next++];
+ const src = img.getAttribute(PRINT_SRC_ATTR) ?? '';
+ img.removeAttribute(PRINT_SRC_ATTR);
+ for (let attempt = 0; attempt <= PRINT_IMAGES.retries; attempt++) {
+ if (await loadOne(img, src, timeoutMs)) break;
+ // A second request for the same URL needs the attribute to change to fire again.
+ img.removeAttribute('src');
+ }
+ done++;
+ options.onProgress?.(done, total);
+ }
+ };
+
+ await Promise.all(Array.from({ length: Math.min(concurrency, total) }, worker));
+}
diff --git a/client/src/components/Studio/printSheets.ts b/client/src/components/Studio/printSheets.ts
index f5ef2b745..215fbb29b 100644
--- a/client/src/components/Studio/printSheets.ts
+++ b/client/src/components/Studio/printSheets.ts
@@ -23,6 +23,7 @@
* standalone PWA. An overlay with a `srcdoc` iframe works everywhere.
*/
+import { loadPrintImages } from './printImages'
import { whenReady } from './printReady'
/*
@@ -248,7 +249,11 @@ ${singleRule(input)}
iframe.addEventListener('load', () => {
fitPreview()
- void whenReady(iframe).then(() => {
+ const frameDoc = iframe.contentDocument
+ const photos = frameDoc ? loadPrintImages(frameDoc, {
+ onProgress: (done, total) => { save.textContent = `${input.labels.preparing} ${done}/${total}` },
+ }) : Promise.resolve()
+ void photos.then(() => whenReady(iframe)).then(() => {
save.disabled = false
save.textContent = input.labels.save
})
diff --git a/client/tests/unit/studio/BookSheetsView.test.tsx b/client/tests/unit/studio/BookSheetsView.test.tsx
index 88d4ba873..41e914ba2 100644
--- a/client/tests/unit/studio/BookSheetsView.test.tsx
+++ b/client/tests/unit/studio/BookSheetsView.test.tsx
@@ -219,7 +219,9 @@ describe('what the sheets are made of', () => {
const img = container.querySelector('img')
expect(img).not.toBeNull()
// `original`, not `thumbnail` — the print is the one place the big file is
- // worth waiting for.
- expect(img!.getAttribute('src')).toContain('/original')
+ // worth waiting for. Held back from `src` until the print view loads it a
+ // few at a time (#3102).
+ expect(img!.getAttribute('data-print-src')).toContain('/original')
+ expect(img!.hasAttribute('src')).toBe(false)
})
})