@segnavia/render 0.6.0 → 0.7.0

package/dist/book-pdf.js

@@ -5,10 +5,11 @@ import { Book, formatNumber, resolveDirection, sheetMm } from "@segnavia/format"
 import { PDFDocument } from "pdf-lib";
 import { bookDocument, bookPrintPart } from "@segnavia/html";
 //#region src/book-pdf.ts
-async function inspect(bytes) {
-	const document = await PDFDocument.load(bytes);
+async function inspect(output) {
+	const document = await PDFDocument.load(output.bytes);
 	return {
-		bytes,
+		bytes: output.bytes,
+		overflow: output.overflow,
 		pages: document.getPageCount(),
 		destinations: namedDestinations(document)
 	};
@@ -127,7 +128,7 @@ async function printBody(book, options, adapter) {
 		targets: true
 	});
 	if (firstDocument.issues.length > 0) throw new RenderRefusedError(`The book cannot be printed: ${firstDocument.issues.join("; ")}.`);
-	let part = await inspect(await adapter.print(firstDocument.html, book, options));
+	let part = await inspect(await adapter.print(firstDocument.html, book, options, "body"));
 	requireTargets(part, hashTargets(firstDocument));
 	const plan = book.rectoOpenings ? planBlanks(firstDocument.sections, part.destinations) : {
 		ids: [],
@@ -139,7 +140,7 @@ async function printBody(book, options, adapter) {
 			targets: true,
 			blankBefore: plan.ids
 		});
-		part = await inspect(await adapter.print(finalDocument.html, book, options));
+		part = await inspect(await adapter.print(finalDocument.html, book, options, "body"));
 		requireTargets(part, hashTargets(finalDocument));
 		verifyStarts("body", sectionsFor(firstDocument.sections, "body"), plan.predicted, part.destinations);
 	}
@@ -169,7 +170,7 @@ async function printFront(book, source, body, options, adapter) {
 			crossLinks: true,
 			pageNumbers: numbers
 		});
-		const printed = await inspect(await adapter.print(document.html, book, options));
+		const printed = await inspect(await adapter.print(document.html, book, options, "front"));
 		if (ids.length === 0) ids.push(...hashTargets(document));
 		requireTargets(printed, ids);
 		prints.push(printed);
@@ -219,8 +220,14 @@ async function renderBookPdf(input, options, adapter) {
 	const bodyBlankPages = new Set(printedBody.blankBefore.map((id) => (printedBody.part.destinations.get(id)?.page ?? 1) - 1));
 	const frontBlankPages = new Set(printedFront.trailingBlank ? [front.pages] : []);
 	const marginPages = [...marginsFor(book, sectionsFor(printedBody.document.sections, "front"), front.destinations, front.pages, 0, frontBlankPages, book.numbering.frontMatter), ...marginsFor(book, sectionsFor(printedBody.document.sections, "body"), printedBody.part.destinations, printedBody.part.pages, front.pages, bodyBlankPages, book.numbering.body)];
-	const marginBytes = await adapter.print(marginDocument(book, marginPages), book, options, true);
-	return adapter.finish(await join(front, printedBody.part, marginBytes), options);
+	const margin = await adapter.print(marginDocument(book, marginPages), book, options, "margin");
+	const output = await adapter.finish(await join(front, printedBody.part, margin.bytes), options);
+	options.overflow?.report?.({ entries: [
+		front.overflow,
+		printedBody.part.overflow,
+		margin.overflow
+	].filter((entry) => entry !== void 0) });
+	return output;
 }
 function bookPageCss(book, marginLayer = false) {
 	if (!book.page) return "";

package/dist/book-render.js

@@ -6,9 +6,10 @@ import { frameDocument, newNonce } from "@segnavia/frame/bridge";
 //#region src/book-render.ts
 function renderBrowserBookPdf(input, options, dependencies) {
 	return renderBookPdf(input, options, {
-		print: (html, book, renderOptions, marginLayer = false) => {
+		print: (html, book, renderOptions, part) => {
 			if (!book.page) throw new RenderRefusedError("Printing a continuous book needs page; set page before calling bookPdf.");
 			const size = sheetMm(book.page);
+			const marginLayer = part === "margin";
 			const css = `${bookPageCss(book, marginLayer)}${marginLayer ? marginCss(book) : ""}${dependencies.fontFaces(renderOptions)}${renderOptions.css ?? ""}`;
 			return dependencies.render({
 				viewport: {
@@ -39,7 +40,7 @@ function renderBrowserBookPdf(input, options, dependencies) {
 					bottom: "0mm",
 					left: "0mm"
 				}
-			});
+			}, Math.round(size.width * PX_PER_MM), part);
 		},
 		finish: dependencies.finish
 	});

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { EffectsReport } from "./effects/types.js";
 import { PressDestination, PressImage, PressReport } from "./press/types.js";
-import { Font, ImageOptions, RenderLimits, RenderOptions } from "./options.js";
+import { Font, ImageOptions, OverflowContribution, OverflowEntry, OverflowPart, OverflowReport, RenderLimits, RenderOptions } from "./options.js";
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
 import { BookInput, Deck, ImpositionInput, PageInput } from "@segnavia/format";
 import { PrintOptions } from "@segnavia/frame/print-document";
@@ -33,4 +33,4 @@ export declare function fontFaces(fonts?: Font[]): string;
 export declare function captureImage(tab: Page$1, options: Pick<ImageOptions, 'format' | 'quality' | 'limits'>, fullPage: boolean): Promise<Uint8Array>;
 export declare function openRenderer(options: RendererOptions): Promise<Renderer>;
 //#endregion
-export { type EffectsReport, type Font, type ImageOptions, type PressDestination, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };
+export { type EffectsReport, type Font, type ImageOptions, type OverflowContribution, type OverflowEntry, type OverflowPart, type OverflowReport, type PressDestination, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };

package/dist/index.js

@@ -5,6 +5,7 @@ import { containFixedPageOverflow } from "./overflow-containment.js";
 import { renderDeckPdf } from "./deck-pdf.js";
 import { assertNeutralTolerance } from "./press/color-policy.js";
 import { rewriteEffectsPdf } from "./effects/adapter.js";
+import { measureOverflow, printWithOverflow } from "./overflow.js";
 import { assertPrintOptions, printCss, printPage, printViewport } from "./page-paper.js";
 import { renderPagesPdf } from "./pages-pdf.js";
 import { rewritePressPdf } from "./press/adapter.js";
@@ -230,10 +231,10 @@ async function openRenderer(options) {
 		};
 	}
 	const image = captureImage;
-	async function renderPagePdf(page, opts) {
+	async function renderPagePdf(page, opts, inputIndex) {
 		if (page.print) assertPrintOptions(page.print, opts.preferCssPageSize);
 		const viewport = pageViewport(page, void 0, true);
-		return await withTab({
+		return withTab({
 			viewport,
 			scripts: page.scripts === "sandboxed",
 			html: pageDocument(page, opts, true),
@@ -241,15 +242,26 @@ async function openRenderer(options) {
 			boundMs: opts.boundMs,
 			beforeOutput: opts.beforeOutput
 		}, async (tab) => {
-			if (page.print) return printPage(tab, page.print, opts.preferCssPageSize);
+			if (page.print) return printPage(tab, page.print, opts.preferCssPageSize, inputIndex);
 			const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
 			const height = fixedHeight ?? await contentHeight(tab);
-			return tab.pdf({
+			if (fixedHeight !== null) {
+				const overflow = await measureOverflow(tab, viewport.width, "page", inputIndex);
+				return {
+					bytes: await tab.pdf({
+						width: `${viewport.width}px`,
+						height: `${height}px`,
+						printBackground: true
+					}),
+					overflow
+				};
+			}
+			return printWithOverflow(tab, viewport.width, "page", {
 				width: `${viewport.width}px`,
 				height: `${height}px`,
 				printBackground: true,
-				pageRanges: fixedHeight ? void 0 : "1"
-			});
+				pageRanges: "1"
+			}, inputIndex);
 		});
 	}
 	async function renderPiecePdf(page, geometry, css, opts) {
@@ -286,13 +298,16 @@ async function openRenderer(options) {
 	return {
 		bookPdf(input, opts = {}) {
 			return renderBrowserBookPdf(input, opts, {
-				render: (setup, pdf) => withTab(setup, (tab) => tab.pdf(pdf)),
+				render: (setup, pdf, pageWidth, part) => withTab(setup, (tab) => printWithOverflow(tab, pageWidth, part, pdf)),
 				fontFaces: (options) => fontFaces(options.fonts),
 				finish: finishWithBrowser
 			});
 		},
 		async pagePdf(input, opts = {}) {
-			return finishWithBrowser(await renderPagePdf(Page.parse(input), opts), opts);
+			const printed = await renderPagePdf(Page.parse(input), opts);
+			const output = await finishWithBrowser(printed.bytes, opts);
+			if (printed.overflow) opts.overflow?.report?.({ entries: [printed.overflow] });
+			return output;
 		},
 		async pageImage(input, opts = {}) {
 			const page = Page.parse(input);
@@ -313,7 +328,7 @@ async function openRenderer(options) {
 		},
 		pagesPdf(inputs, opts = {}) {
 			return renderPagesPdf(inputs, opts, {
-				pagePdf: renderPagePdf,
+				pagePdf: (page, options, inputIndex) => renderPagePdf(page, options, inputIndex),
 				piecePdf: renderPiecePdf,
 				fontFaces: (options) => fontFaces(options.fonts),
 				finish: finishWithBrowser

package/dist/options.d.ts

@@ -2,6 +2,37 @@ import { EffectsReport } from "./effects/types.js";
 import { PressReport } from "./press/types.js";
 import { Page } from "playwright-core";
 //#region src/options.d.ts
+export type OverflowPart = 'page' | 'front' | 'body' | 'margin';
+export interface OverflowContribution {
+  /** A short id or tag-and-class path locating the element. */
+  locator: string;
+  /** Border-box pixels clipped beyond the inline start of the page. */
+  clippedStart: number;
+  /** Border-box pixels clipped beyond the inline end of the page. */
+  clippedEnd: number;
+}
+export interface OverflowEntry {
+  /** Output part printed by this entry. */
+  part: OverflowPart;
+  /** Input position when the public render is pagesPdf. */
+  inputIndex?: number;
+  /** Printable inline width in CSS pixels. */
+  pageWidth: number;
+  /** Greatest document scroll width in CSS pixels. */
+  extent: number;
+  /** Pixels clipped beyond the inline start of the page. */
+  clippedStart: number;
+  /** Pixels clipped beyond the inline end of the page. */
+  clippedEnd: number;
+  /** PDF scale used to preserve the print's true size. */
+  scale: number;
+  /** Up to twenty border boxes that extend beyond the page. */
+  elements: OverflowContribution[];
+}
+export interface OverflowReport {
+  /** Kept prints in output order. */
+  entries: OverflowEntry[];
+}
 export interface Font {
   family: string;
   data: Uint8Array;
@@ -24,6 +55,9 @@ export interface RenderOptions {
   effects?: false | {
     report?: (report: EffectsReport) => void;
   };
+  overflow?: {
+    report?: (report: OverflowReport) => void;
+  };
   press?: {
     profile: Uint8Array;
     neutralTolerance?: number;

package/dist/overflow.js

@@ -0,0 +1,123 @@
+//#region src/overflow.ts
+/**
+* Chromium's measured maximum print shrink; the 3x overflow demo check fails
+* if it changes. Chromium lays a scaled print out at the narrower width P / s,
+* then shrinks it by at most this factor. The solved scale searches layout
+* widths for the point where rightward content reaches P, and uses this exact
+* cap when it is already reached at the narrowest layout. Rightward generated
+* content in an RTL root is a known limit: neither scroll extent nor element
+* boxes expose it.
+*/
+const CHROMIUM_MAX_SHRINK = 1.5;
+/** Decides the next layout to measure, or the print scale, from measured widths. */
+function solveScale(pageWidth, measurements) {
+	const measured = new Map(measurements.map((measurement) => [measurement.layoutWidth, measurement.contentWidth]));
+	const atPage = measured.get(pageWidth);
+	if (atPage === void 0) return { measure: pageWidth };
+	if (atPage <= pageWidth) return { scale: 1 };
+	const narrowest = Math.ceil(pageWidth / CHROMIUM_MAX_SHRINK);
+	const atNarrowest = measured.get(narrowest);
+	if (atNarrowest === void 0) return { measure: narrowest };
+	if (atNarrowest >= pageWidth) return { scale: CHROMIUM_MAX_SHRINK };
+	let low = narrowest;
+	let high = pageWidth;
+	let lastSatisfied = pageWidth;
+	while (high - low > 1) {
+		const middle = Math.floor((low + high) / 2);
+		const width = measured.get(middle);
+		if (width === void 0) return { measure: middle };
+		if (width >= pageWidth) {
+			high = middle;
+			lastSatisfied = middle;
+		} else low = middle;
+	}
+	return { scale: pageWidth / (measured.get(high) !== void 0 && measured.get(high) >= pageWidth ? high : lastSatisfied) };
+}
+async function measuredOverflow(tab, pageWidth) {
+	return tab.evaluate((width) => {
+		const root = document.documentElement;
+		const extent = Math.max(root.scrollWidth, document.body?.scrollWidth ?? 0);
+		const endOverflow = Math.max(0, extent - root.clientWidth);
+		const rtl = getComputedStyle(root).direction === "rtl";
+		const contributions = [];
+		let clippedStart = 0;
+		let rightOverflow = rtl ? 0 : endOverflow;
+		const locator = (element) => {
+			if (element.id) return `#${CSS.escape(element.id)}`;
+			const parts = [];
+			let current = element;
+			while (current && current !== root && parts.length < 3) {
+				const classes = [...current.classList].slice(0, 2).map((name) => `.${CSS.escape(name)}`).join("");
+				parts.unshift(`${current.localName}${classes}`);
+				current = current.parentElement;
+			}
+			return parts.join(" > ");
+		};
+		for (const element of document.querySelectorAll("*")) {
+			const box = element.getBoundingClientRect();
+			const elementStart = Math.max(0, rtl ? box.right - width : -box.left);
+			const elementEnd = Math.max(0, rtl ? -box.left : box.right - width);
+			clippedStart = Math.max(clippedStart, elementStart);
+			rightOverflow = Math.max(rightOverflow, box.right - width);
+			if ((elementStart > 0 || elementEnd > 0) && contributions.length < 20) contributions.push({
+				locator: locator(element),
+				clippedStart: elementStart,
+				clippedEnd: elementEnd
+			});
+		}
+		return {
+			overflow: {
+				pageWidth: width,
+				extent,
+				clippedStart,
+				clippedEnd: endOverflow,
+				elements: contributions
+			},
+			rightOverflow
+		};
+	}, pageWidth);
+}
+function overflowEntry(measured, scale, part, inputIndex) {
+	return {
+		part,
+		...inputIndex === void 0 ? {} : { inputIndex },
+		...measured.overflow,
+		scale
+	};
+}
+async function measureOverflow(tab, pageWidth, part, inputIndex) {
+	await tab.emulateMedia({ media: "print" });
+	return overflowEntry(await measuredOverflow(tab, pageWidth), 1, part, inputIndex);
+}
+async function printWithOverflow(tab, pageWidth, part, pdf, inputIndex) {
+	await tab.emulateMedia({ media: "print" });
+	const viewport = tab.viewportSize();
+	if (!viewport) throw new Error("The print tab has no viewport.");
+	const measurements = [];
+	let original;
+	let decision = solveScale(pageWidth, measurements);
+	while ("measure" in decision) {
+		await tab.setViewportSize({
+			width: decision.measure,
+			height: viewport.height
+		});
+		const measured = await measuredOverflow(tab, decision.measure);
+		if (decision.measure === pageWidth) original = measured;
+		measurements.push({
+			layoutWidth: decision.measure,
+			contentWidth: decision.measure + measured.rightOverflow
+		});
+		decision = solveScale(pageWidth, measurements);
+	}
+	await tab.setViewportSize(viewport);
+	if (!original) throw new Error("The page-width overflow measurement was not made.");
+	return {
+		bytes: await tab.pdf({
+			...pdf,
+			scale: decision.scale
+		}),
+		overflow: overflowEntry(original, decision.scale, part, inputIndex)
+	};
+}
+//#endregion
+export { CHROMIUM_MAX_SHRINK, measureOverflow, printWithOverflow, solveScale };

package/dist/page-paper.js

@@ -1,5 +1,6 @@
 import { RenderRefusedError } from "./errors.js";
 import { pdfBox, pdfPoint, pt } from "./pdf-geometry.js";
+import { printWithOverflow } from "./overflow.js";
 import { PX_PER_MM, printBoxes, printPadding, printProperties, sheetMm } from "@segnavia/format";
 import { PDFDocument, PDFName, rgb } from "pdf-lib";
 //#region src/page-paper.ts
@@ -56,11 +57,12 @@ async function addPressBoxes(pdf, print) {
 	});
 	return document.save();
 }
-async function printPage(tab, print, preferCssPageSize) {
+async function printPage(tab, print, preferCssPageSize, inputIndex) {
 	if (!usesPressLayout(print)) {
 		const mm = sheetMm(print);
 		const margin = print.margin;
-		return tab.pdf({
+		const pageWidth = Math.round(mm.width * PX_PER_MM);
+		return printWithOverflow(tab, pageWidth, "page", {
 			width: `${mm.width}mm`,
 			height: `${mm.height}mm`,
 			printBackground: true,
@@ -71,10 +73,10 @@ async function printPage(tab, print, preferCssPageSize) {
 				bottom: `${margin.bottom}mm`,
 				left: `${margin.left}mm`
 			} : void 0
-		});
+		}, inputIndex);
 	}
 	const boxes = printBoxes(print);
-	const pdf = await tab.pdf({
+	const printed = await printWithOverflow(tab, Math.round(boxes.bleedBox.width * PX_PER_MM), "page", {
 		width: `${boxes.bleedBox.width}mm`,
 		height: `${boxes.bleedBox.height}mm`,
 		printBackground: true,
@@ -85,10 +87,13 @@ async function printPage(tab, print, preferCssPageSize) {
 			bottom: "0mm",
 			left: "0mm"
 		}
-	});
-	const papers = (await PDFDocument.load(pdf)).getPageCount();
+	}, inputIndex);
+	const papers = (await PDFDocument.load(printed.bytes)).getPageCount();
 	if (papers > 1) throw new RenderRefusedError(`A page with bleed or marks is one printed piece, but the content needs ${papers} papers. Shorten the content, or remove the bleed and marks.`);
-	return addPressBoxes(pdf, print);
+	return {
+		bytes: await addPressBoxes(printed.bytes, print),
+		overflow: printed.overflow
+	};
 }
 //#endregion
 export { assertPrintOptions, printCss, printPage, printViewport };

package/dist/pages-pdf.js

@@ -51,13 +51,16 @@ async function renderPagesPdf(inputs, opts, services) {
 	if (inputs.length === 0) throw new RenderRefusedError("There is nothing to render. Pass at least one page to clear this refusal.");
 	const pages = inputs.map((input) => Page.parse(input));
 	if (!opts.imposition) {
-		const rendered = await Promise.all(pages.map((page) => services.pagePdf(page, {
+		const rendered = await Promise.all(pages.map((page, inputIndex) => services.pagePdf(page, {
 			...opts,
 			effects: false,
 			limits: void 0,
-			press: void 0
-		})));
-		return services.finish(await joinPdfs(rendered), opts);
+			press: void 0,
+			overflow: void 0
+		}, inputIndex)));
+		const output = await services.finish(await joinPdfs(rendered.map((part) => part.bytes)), opts);
+		opts.overflow?.report?.({ entries: rendered.flatMap((part) => part.overflow ? [part.overflow] : []) });
+		return output;
 	}
 	const imposition = Imposition.parse(opts.imposition);
 	if (opts.preferCssPageSize) throw new RenderRefusedError("Pages in an imposition take their size from its paper. Remove preferCssPageSize, or remove the imposition, to clear this refusal.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/render",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,9 +26,9 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.6.0",
-    "@segnavia/frame": "0.6.0",
-    "@segnavia/html": "0.6.0",
+    "@segnavia/format": "0.7.0",
+    "@segnavia/frame": "0.7.0",
+    "@segnavia/html": "0.7.0",
     "playwright-core": "1.55.1",
     "pdf-lib": "^1.17.1"
   }