@segnavia/render 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,4 +1,10 @@
-import { PX_PER_MM, Page, sheetMm } from "@segnavia/format";
+import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
+import { renderDeckPdf } from "./deck-pdf.js";
+import { rewriteEffectsPdf } from "./effects/adapter.js";
+import { assertPrintOptions, printCss, printPage, printViewport } from "./page-paper.js";
+import { renderPagesPdf } from "./pages-pdf.js";
+import { rewritePressPdf } from "./press/adapter.js";
+import { Page, printProperties } from "@segnavia/format";
 import { frameDocument, newNonce } from "@segnavia/frame/bridge";
 import { printableDeck } from "@segnavia/frame/print-document";
 import { PDFDocument } from "pdf-lib";
@@ -18,15 +24,9 @@ const NO_NETWORK_ARGS = [
 	"--proxy-bypass-list=<-loopback>",
 	"--force-webrtc-ip-handling-policy=disable_non_proxied_udp"
 ];
-var RendererUnavailableError = class extends Error {
-	name = "RendererUnavailableError";
-};
 var RenderTimeoutError = class extends Error {
 	name = "RenderTimeoutError";
 };
-var RenderRefusedError = class extends Error {
-	name = "RenderRefusedError";
-};
 function fontFaces(fonts = []) {
 	return fonts.map((font) => `@font-face{font-family:${JSON.stringify(font.family)};src:url(data:font/${font.format === "truetype" ? "ttf" : font.format === "opentype" ? "otf" : font.format};base64,${Buffer.from(font.data).toString("base64")}) format(${JSON.stringify(font.format)});font-weight:${font.weight ?? "normal"};font-style:${font.style ?? "normal"};font-display:block}`).join("");
 }
@@ -52,6 +52,21 @@ async function enforce(pdf, limits) {
 	}
 	return pdf;
 }
+async function finishPdf(pdf, options) {
+	if (options.limits?.maxBytes !== void 0 && pdf.byteLength > options.limits.maxBytes) throw new RenderRefusedError(`The PDF is ${pdf.byteLength} bytes; the limit is ${options.limits.maxBytes}.`);
+	let output = pdf;
+	if (options.effects !== false) {
+		const rewritten = await rewriteEffectsPdf(output);
+		output = rewritten.bytes;
+		options.effects?.report?.(rewritten.report);
+	}
+	if (options.press) {
+		const converted = await rewritePressPdf(output, options.press.profile);
+		output = converted.bytes;
+		options.press.report?.(converted.report);
+	}
+	return enforce(output, options.limits);
+}
 async function captureImage(tab, options, fullPage) {
 	const format = options.format ?? "png";
 	if (format !== "webp") return tab.screenshot({
@@ -171,8 +186,8 @@ async function openRenderer(options) {
 			release();
 		}
 	}
-	function pageDocument(page, options) {
-		const css = `${fontFaces(options.fonts)}${options.css ?? ""}`;
+	function pageDocument(page, options, printing = false) {
+		const css = `${page.print ? printing ? printCss(page.print) : printProperties(page.print) : ""}${fontFaces(options.fonts)}${options.css ?? ""}`;
 		return frameDocument(page.html, {
 			scripts: page.scripts,
 			nonce: newNonce(),
@@ -183,14 +198,8 @@ async function openRenderer(options) {
 			reportHeight: false
 		});
 	}
-	function pageViewport(page, width) {
-		if (page.print) {
-			const mm = sheetMm(page.print);
-			return {
-				width: Math.round(mm.width * PX_PER_MM),
-				height: Math.round(mm.height * PX_PER_MM)
-			};
-		}
+	function pageViewport(page, width, printing = false) {
+		if (page.print) return printViewport(page.print, printing);
 		if (page.size === "fluid") return {
 			width: width ?? FLUID_WIDTH,
 			height: 800
@@ -201,43 +210,62 @@ async function openRenderer(options) {
 		};
 	}
 	const image = captureImage;
+	async function renderPagePdf(page, opts) {
+		if (page.print) assertPrintOptions(page.print, opts.preferCssPageSize);
+		const viewport = pageViewport(page, void 0, true);
+		return await withTab({
+			viewport,
+			scripts: page.scripts === "sandboxed",
+			html: pageDocument(page, opts, true),
+			waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+			boundMs: opts.boundMs,
+			beforeOutput: opts.beforeOutput
+		}, async (tab) => {
+			if (page.print) return printPage(tab, page.print, opts.preferCssPageSize);
+			const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
+			const height = fixedHeight ?? await contentHeight(tab);
+			return tab.pdf({
+				width: `${viewport.width}px`,
+				height: `${height}px`,
+				printBackground: true,
+				pageRanges: fixedHeight ? void 0 : "1"
+			});
+		});
+	}
+	async function renderPiecePdf(page, geometry, css, opts) {
+		const html = frameDocument(page.html, {
+			scripts: page.scripts,
+			nonce: newNonce(),
+			dir: page.dir,
+			lang: page.lang,
+			css,
+			relayKeys: false,
+			reportHeight: false
+		});
+		return withTab({
+			viewport: geometry.viewport,
+			scripts: page.scripts === "sandboxed",
+			html,
+			waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
+			boundMs: opts.boundMs,
+			beforeOutput: opts.beforeOutput
+		}, (tab) => tab.pdf({
+			width: geometry.pdf.width,
+			height: geometry.pdf.height,
+			printBackground: true,
+			preferCSSPageSize: false,
+			pageRanges: "1",
+			margin: {
+				top: "0mm",
+				right: "0mm",
+				bottom: "0mm",
+				left: "0mm"
+			}
+		}));
+	}
 	return {
 		async pagePdf(input, opts = {}) {
-			const page = Page.parse(input);
-			const viewport = pageViewport(page);
-			return enforce(await withTab({
-				viewport,
-				scripts: page.scripts === "sandboxed",
-				html: pageDocument(page, opts),
-				waitForReady: page.scripts === "sandboxed" && opts.waitForPageReady !== false,
-				boundMs: opts.boundMs,
-				beforeOutput: opts.beforeOutput
-			}, async (tab) => {
-				if (page.print) {
-					const mm = sheetMm(page.print);
-					const margin = page.print.margin;
-					return tab.pdf({
-						width: `${mm.width}mm`,
-						height: `${mm.height}mm`,
-						printBackground: true,
-						preferCSSPageSize: opts.preferCssPageSize ?? false,
-						margin: margin ? {
-							top: `${margin.top}mm`,
-							right: `${margin.right}mm`,
-							bottom: `${margin.bottom}mm`,
-							left: `${margin.left}mm`
-						} : void 0
-					});
-				}
-				const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
-				const height = fixedHeight ?? await contentHeight(tab);
-				return tab.pdf({
-					width: `${viewport.width}px`,
-					height: `${height}px`,
-					printBackground: true,
-					pageRanges: fixedHeight ? void 0 : "1"
-				});
-			}), opts.limits);
+			return finishPdf(await renderPagePdf(Page.parse(input), opts), opts);
 		},
 		async pageImage(input, opts = {}) {
 			const page = Page.parse(input);
@@ -256,31 +284,23 @@ async function openRenderer(options) {
 				return image(tab, opts, false);
 			});
 		},
-		async deckPdf(deck, opts = {}) {
-			const css = `${fontFaces(opts.fonts)}${opts.css ?? ""}`;
-			const html = printableDeck(deck, {
-				...opts,
-				css
+		pagesPdf(inputs, opts = {}) {
+			return renderPagesPdf(inputs, opts, {
+				pagePdf: renderPagePdf,
+				piecePdf: renderPiecePdf,
+				fontFaces: (options) => fontFaces(options.fonts),
+				finish: finishPdf
+			});
+		},
+		deckPdf(deck, opts = {}) {
+			return renderDeckPdf(deck, opts, {
+				renderPdf: (setup, pdf) => withTab({
+					...setup,
+					waitForReady: false
+				}, (tab) => tab.pdf(pdf)),
+				fontFaces: (options) => fontFaces(options.fonts),
+				finish: finishPdf
 			});
-			return enforce(await withTab({
-				viewport: opts.layout === "notes" ? pageViewport({
-					html: "",
-					size: "fluid",
-					scripts: "refuse",
-					print: opts.notesPaper ?? {
-						paper: "letter",
-						orientation: "portrait"
-					}
-				}) : deck.size,
-				scripts: deck.scripts === "sandboxed",
-				html,
-				waitForReady: false,
-				boundMs: opts.boundMs,
-				beforeOutput: opts.beforeOutput
-			}, (tab) => tab.pdf({
-				preferCSSPageSize: true,
-				printBackground: true
-			})), opts.limits);
 		},
 		async slideImage(deck, index, opts = {}) {
 			const slide = deck.slides[index];

package/dist/page-paper.js

@@ -0,0 +1,94 @@
+import { RenderRefusedError } from "./errors.js";
+import { pdfBox, pdfPoint, pt } from "./pdf-geometry.js";
+import { PX_PER_MM, printBoxes, printPadding, printProperties, sheetMm } from "@segnavia/format";
+import { PDFDocument, PDFName, rgb } from "pdf-lib";
+//#region src/page-paper.ts
+const usesPressLayout = (print) => print.bleed > 0 || print.marks;
+function printCss(print) {
+	const properties = printProperties(print);
+	if (!usesPressLayout(print)) return properties;
+	const margin = print.margin ?? {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	return `${properties}${printPadding({
+		top: margin.top + print.bleed,
+		right: margin.right + print.bleed,
+		bottom: margin.bottom + print.bleed,
+		left: margin.left + print.bleed
+	})}`;
+}
+function printViewport(print, pressLayout) {
+	const size = pressLayout && usesPressLayout(print) ? printBoxes(print).bleedBox : sheetMm(print);
+	return {
+		width: Math.round(size.width * PX_PER_MM),
+		height: Math.round(size.height * PX_PER_MM)
+	};
+}
+function assertPrintOptions(print, preferCssPageSize) {
+	if (usesPressLayout(print) && preferCssPageSize) throw new RenderRefusedError("A page with bleed or marks takes its size from its print setting. Remove preferCssPageSize, or remove the bleed and marks, to clear this refusal.");
+}
+async function addPressBoxes(pdf, print) {
+	const boxes = printBoxes(print);
+	const document = await PDFDocument.load(pdf);
+	const source = document.getPage(0);
+	const content = await document.embedPage(source);
+	const page = document.addPage([pt(boxes.media.width), pt(boxes.media.height)]);
+	const bleedBox = pdfBox(boxes.bleedBox, boxes.media.height);
+	const trimBox = pdfBox(boxes.trim, boxes.media.height);
+	page.drawPage(content, {
+		x: bleedBox.x,
+		y: bleedBox.y,
+		width: source.getWidth(),
+		height: source.getHeight()
+	});
+	document.removePage(0);
+	page.node.delete(PDFName.of("CropBox"));
+	page.setBleedBox(bleedBox.x, bleedBox.y, bleedBox.width, bleedBox.height);
+	page.setTrimBox(trimBox.x, trimBox.y, trimBox.width, trimBox.height);
+	for (const mark of boxes.marks) page.drawLine({
+		start: pdfPoint(mark.x1, mark.y1, boxes.media.height),
+		end: pdfPoint(mark.x2, mark.y2, boxes.media.height),
+		thickness: .25,
+		color: rgb(0, 0, 0)
+	});
+	return document.save();
+}
+async function printPage(tab, print, preferCssPageSize) {
+	if (!usesPressLayout(print)) {
+		const mm = sheetMm(print);
+		const margin = print.margin;
+		return tab.pdf({
+			width: `${mm.width}mm`,
+			height: `${mm.height}mm`,
+			printBackground: true,
+			preferCSSPageSize: preferCssPageSize ?? false,
+			margin: margin ? {
+				top: `${margin.top}mm`,
+				right: `${margin.right}mm`,
+				bottom: `${margin.bottom}mm`,
+				left: `${margin.left}mm`
+			} : void 0
+		});
+	}
+	const boxes = printBoxes(print);
+	const pdf = await tab.pdf({
+		width: `${boxes.bleedBox.width}mm`,
+		height: `${boxes.bleedBox.height}mm`,
+		printBackground: true,
+		preferCSSPageSize: false,
+		margin: {
+			top: "0mm",
+			right: "0mm",
+			bottom: "0mm",
+			left: "0mm"
+		}
+	});
+	const papers = (await PDFDocument.load(pdf)).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);
+}
+//#endregion
+export { assertPrintOptions, printCss, printPage, printViewport };

package/dist/pages-imposition.js

@@ -0,0 +1,65 @@
+import { pdfBox } from "./pdf-geometry.js";
+import { fitPage, pagePlacementLayout } from "@segnavia/format";
+//#region src/pages-imposition.ts
+const geometryKey = (page, pageValue, placement) => pageValue.size === "fluid" ? JSON.stringify([
+	page,
+	placement.bleedBox.width,
+	placement.bleedBox.height,
+	placement.bleed.top,
+	placement.bleed.right,
+	placement.bleed.bottom,
+	placement.bleed.left
+]) : String(page);
+function groupPieces(pages, imposed, mode) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const placement of imposed.placements) {
+		const page = pages[placement.page];
+		if (!page) throw new RangeError(`The placement names missing page ${placement.page}.`);
+		const fit = fitPage(page, placement, mode);
+		const layout = pagePlacementLayout(page.size, placement, fit);
+		const key = geometryKey(placement.page, page, placement);
+		const group = groups.get(key) ?? {
+			key,
+			page: placement.page,
+			placements: []
+		};
+		group.placements.push({
+			placement,
+			layout
+		});
+		groups.set(key, group);
+	}
+	return [...groups.values()];
+}
+function pieceGeometry(item) {
+	const { placement, layout } = item;
+	if (layout.kind === "fluid") return {
+		viewport: {
+			width: Math.round(layout.piece.width),
+			height: Math.round(layout.piece.height)
+		},
+		pdf: {
+			width: `${layout.paper.width}mm`,
+			height: `${layout.paper.height}mm`
+		},
+		padding: layout.inset ? placement.bleed : void 0
+	};
+	return {
+		viewport: {
+			width: layout.piece.width,
+			height: Math.round(layout.piece.height)
+		},
+		pdf: {
+			width: `${layout.piece.width}px`,
+			height: `${layout.piece.height}px`
+		}
+	};
+}
+function placementPdfGeometry(placement, layout, paperHeight) {
+	return {
+		draw: pdfBox(layout.paper, paperHeight),
+		clip: pdfBox(placement.bleedBox, paperHeight)
+	};
+}
+//#endregion
+export { groupPieces, pieceGeometry, placementPdfGeometry };

package/dist/pages-pdf.js

@@ -0,0 +1,67 @@
+import { RenderRefusedError } from "./errors.js";
+import { groupPieces, pieceGeometry } from "./pages-imposition.js";
+import { composeImposedPdf } from "./pdf-compose.js";
+import { Imposition, Page, impose, printPadding, printProperties } from "@segnavia/format";
+import { PDFDocument } from "pdf-lib";
+//#region src/pages-pdf.ts
+async function joinPdfs(pdfs) {
+	const joined = await PDFDocument.create();
+	for (const bytes of pdfs) {
+		const source = await PDFDocument.load(bytes);
+		const pages = await joined.copyPages(source, source.getPageIndices());
+		for (const page of pages) joined.addPage(page);
+	}
+	return joined.save();
+}
+function namePageError(error, page) {
+	if (error instanceof Error) {
+		error.message = `Page at index ${page} could not be rendered: ${error.message}`;
+		throw error;
+	}
+	throw new Error(`Page at index ${page} could not be rendered: ${String(error)}`);
+}
+async function composedPdf(pages, imposition, opts, services) {
+	const imposed = impose(imposition, pages.length);
+	const groups = groupPieces(pages, imposed, imposition.fit);
+	const properties = printProperties(imposition, imposition.unit);
+	const hostCss = `${services.fontFaces(opts)}${opts.css ?? ""}`;
+	const rendered = await Promise.all(groups.map(async (group) => {
+		const page = pages[group.page];
+		const first = group.placements[0];
+		if (!page || !first) throw new Error(`The piece for page ${group.page} has no placement.`);
+		const geometry = pieceGeometry(first);
+		const css = `${properties}${geometry.padding ? printPadding(geometry.padding) : ""}${hostCss}`;
+		try {
+			return {
+				group,
+				bytes: await services.piecePdf(page, geometry, css, opts)
+			};
+		} catch (error) {
+			namePageError(error, group.page);
+		}
+	}));
+	return composeImposedPdf(imposed, rendered.map(({ group, bytes }) => ({
+		key: group.key,
+		name: `The rendered piece for page ${group.page}`,
+		bytes,
+		placements: group.placements
+	})));
+}
+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, {
+			...opts,
+			effects: false,
+			limits: void 0,
+			press: void 0
+		})));
+		return services.finish(await joinPdfs(rendered), opts);
+	}
+	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.");
+	return services.finish(await composedPdf(pages, imposition, opts, services), opts);
+}
+//#endregion
+export { renderPagesPdf };

package/dist/pdf-compose.js

@@ -0,0 +1,35 @@
+import { placementPdfGeometry } from "./pages-imposition.js";
+import { MM_PER_PT } from "@segnavia/format";
+import { PDFDocument, clip, endPath, popGraphicsState, pushGraphicsState, rectangle } from "pdf-lib";
+//#region src/pdf-compose.ts
+async function embedOnePage(output, bytes, name) {
+	const [embedded] = await output.embedPdf(bytes, [0]);
+	if (!embedded) throw new Error(`${name} has no PDF page.`);
+	return embedded;
+}
+function drawClippedPage(target, embedded, draw, clipBox) {
+	target.pushOperators(pushGraphicsState(), rectangle(clipBox.x, clipBox.y, clipBox.width, clipBox.height), clip(), endPath());
+	target.drawPage(embedded, draw);
+	target.pushOperators(popGraphicsState());
+}
+function drawImposedSide(output, imposed, embedded, pieces, paperIndex, side) {
+	const paper = output.addPage([imposed.paper.width / MM_PER_PT, imposed.paper.height / MM_PER_PT]);
+	for (const piece of pieces) {
+		const image = embedded.get(piece.key);
+		if (!image) throw new Error(`${piece.name} was not embedded.`);
+		for (const { placement, layout } of piece.placements) {
+			if (placement.paper !== paperIndex || placement.side !== side) continue;
+			const { draw, clip: clipBox } = placementPdfGeometry(placement, layout, imposed.paper.height);
+			drawClippedPage(paper, image, draw, clipBox);
+		}
+	}
+}
+async function composeImposedPdf(imposed, pieces) {
+	const output = await PDFDocument.create();
+	const embedded = /* @__PURE__ */ new Map();
+	for (const piece of pieces) embedded.set(piece.key, await embedOnePage(output, piece.bytes, piece.name));
+	for (let paperIndex = 0; paperIndex < imposed.papers; paperIndex += 1) for (const side of ["front", "back"].slice(0, imposed.sides)) drawImposedSide(output, imposed, embedded, pieces, paperIndex, side);
+	return output.save();
+}
+//#endregion
+export { composeImposedPdf, drawClippedPage, embedOnePage };

package/dist/pdf-geometry.js

@@ -0,0 +1,27 @@
+import { MM_PER_PT, PX_PER_MM } from "@segnavia/format";
+//#region src/pdf-geometry.ts
+const pt = (millimeters) => millimeters / MM_PER_PT;
+const pixelPt = (pixels) => pt(pixels / PX_PER_MM);
+function pdfPoint(x, y, mediaHeight) {
+	return {
+		x: pt(x),
+		y: pt(mediaHeight - y)
+	};
+}
+function pdfBox(box, mediaHeight) {
+	return {
+		...pdfPoint(box.x, box.y + box.height, mediaHeight),
+		width: pt(box.width),
+		height: pt(box.height)
+	};
+}
+function pdfPixelBox(box, mediaHeight) {
+	return {
+		x: pixelPt(box.x),
+		y: pixelPt(mediaHeight - box.y - box.height),
+		width: pixelPt(box.width),
+		height: pixelPt(box.height)
+	};
+}
+//#endregion
+export { pdfBox, pdfPixelBox, pdfPoint, pixelPt, pt };