@embedpdf/core 3.0.0-next.15 → 3.0.0-next.16

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_settings = require("./settings-maKtf237.cjs");
+const require_settings = require("./settings-BS97q3tq.cjs");
 let _embedpdf_engine_core_runtime = require("@embedpdf/engine-core/runtime");
 //#region src/order.ts
 /**
@@ -97,7 +97,8 @@ function layoutFromEvent(event) {
 		case "pages.reordered":
 		case "pages.rotated":
 		case "pages.deleted":
-		case "pages.inserted": return event.layout;
+		case "pages.inserted":
+		case "pages.restored": return event.layout;
 		default: return null;
 	}
 }
@@ -147,6 +148,16 @@ async function fetchUrlSource(source, signal) {
 }
 const isUrlSource = (source) => source.kind === "url";
 const noLayer = () => new require_settings.PluginError("unsupported", "documents", "only the local engine gives a layer to download");
+/** How a print comes out at each tier, one object each, so readers can compare them with `Object.is`. */
+const PRINT_STANDARD = Object.freeze({
+	kind: "images",
+	dpi: 150
+});
+const PRINT_HIGH = Object.freeze({
+	kind: "images",
+	dpi: 300
+});
+const PRINT_PDF = Object.freeze({ kind: "pdf" });
 /**
 * The documents capability as seen from inside one document's scope: every call whose document
 * is optional uses that document instead of the active one. The rest is the registry itself.
@@ -157,6 +168,9 @@ const documentsInScope = (documents, documentId) => ({
 	download: (id = documentId, options) => documents.download(id, options),
 	downloadLayer: (id = documentId, options) => documents.downloadLayer(id, options),
 	canDownload: (id = documentId) => documents.canDownload(id),
+	preparePrint: (id = documentId, options) => documents.preparePrint(id, options),
+	print: (id = documentId, options) => documents.print(id, options),
+	getPrintQuality: (id = documentId) => documents.getPrintQuality(id),
 	canPrint: (id = documentId) => documents.canPrint(id),
 	listPages: (id = documentId) => documents.listPages(id),
 	getPage: (page, id = documentId) => documents.getPage(page, id),
@@ -294,12 +308,14 @@ function createKernel(config) {
 			leases: /* @__PURE__ */ new Map(),
 			settleFlushes: /* @__PURE__ */ new Set(),
 			downloadWraps: [],
+			printWraps: [],
 			changes: require_settings.createDocumentChanges({
 				handle: () => session.handle,
 				notify: () => store.notify(),
 				report
 			}),
 			changeCount: 0,
+			changesSeen: 0,
 			close: () => closeSession(session)
 		};
 		session.settleFlushes.add(() => session.changes.settle());
@@ -518,13 +534,202 @@ function createKernel(config) {
 				readAt = session.changeCount;
 				return require_settings.cancellable("documents", signal, read(handle));
 			};
-			const bytes = await require_settings.readWrapped(session.downloadWraps, readFile);
+			const bytes = await require_settings.runWrapped(session.downloadWraps, readFile);
 			if (readAt === session.changeCount) setUnsavedChanges(session, false);
 			return bytes;
 		} catch (error) {
 			throw require_settings.toPluginError("documents", error);
 		}
 	}
+	const printer = config.printer ?? null;
+	const canPrintOn = (documentId) => printer !== null && allowsOn(documentId, "doc.print");
+	/**
+	* How a print comes out: the PDF copy with `doc.print.high`, a right to keep the copy (every
+	* print dialog can save it as a file) and a printer that prints a PDF; else pictures, at the
+	* resolution `doc.print.high` or `doc.print` allows.
+	*/
+	const printQualityOf = (documentId) => {
+		if (!canPrintOn(documentId)) return null;
+		if (!allowsOn(documentId, "doc.print.high")) return PRINT_STANDARD;
+		return (allowsOn(documentId, "doc.download") || allowsOn(documentId, "doc.download.flattened")) && printer?.stagePdf ? PRINT_PDF : PRINT_HIGH;
+	};
+	/** The pages a print asks for, in its order: every page when it names none. */
+	function printPagesOf(session, pages) {
+		const all = metaOf(session.id)?.pages ?? EMPTY_PAGES;
+		if (pages === void 0) return all;
+		if (pages.length === 0) throw new require_settings.PluginError("invalid-input", "documents", "a print needs at least one page");
+		const found = pages.map((ref) => {
+			const page = require_settings.findPage(all, ref);
+			if (!page) throw new require_settings.PluginError("not-found", "documents", `page ${ref.objectNumber} is not in this document`);
+			return page;
+		});
+		if (new Set(found).size !== found.length) throw new require_settings.PluginError("invalid-input", "documents", "a print names a page twice");
+		return found;
+	}
+	/**
+	* What prints beside the page content: the annotations as the options ask, by default when
+	* the user may read them; the form fields whenever the user may read the form.
+	*/
+	const printLayersOf = (documentId, options) => ({
+		includeAnnotations: options.includeAnnotations ?? allowsOn(documentId, "doc.annotate.read"),
+		includeFormFields: allowsOn(documentId, "doc.forms.read")
+	});
+	/**
+	* Make the pages as they print and hand them to the printer, once the document settled: the
+	* PDF copy, or a picture of each page. The pages are looked up again each time, so one deleted
+	* meanwhile refuses `not-found`. Returns the staged print, how it came out, and the change it
+	* saw last, so a print can tell it went stale.
+	*/
+	async function stagePrint(session, activePrinter, quality, options) {
+		const { signal } = options;
+		await require_settings.settle(session.settleFlushes, [signal, session.signal], report);
+		const handle = documentHandle(session.id);
+		if (!handle) throw new require_settings.PluginError("not-ready", "documents", "no open document to print");
+		const changesSeen = session.changesSeen;
+		const job = {
+			handle,
+			pages: printPagesOf(session, options.pages),
+			layers: printLayersOf(session.id, options),
+			name: session.name ?? "document",
+			options
+		};
+		options.onProgress?.({
+			pagesRendered: 0,
+			pageCount: job.pages.length
+		});
+		if (quality.kind === "images") return {
+			staged: await stagePictures(job, activePrinter, quality.dpi),
+			quality,
+			changesSeen
+		};
+		try {
+			return {
+				staged: await stagePdfCopy(job, activePrinter),
+				quality,
+				changesSeen
+			};
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			return {
+				staged: await stagePictures(job, activePrinter, PRINT_HIGH.dpi),
+				quality: PRINT_HIGH,
+				changesSeen
+			};
+		}
+	}
+	/** The PDF copy of the pages as they print, staged with the printer. */
+	async function stagePdfCopy(job, activePrinter) {
+		const { handle, pages, layers, name, options } = job;
+		const { signal } = options;
+		if (!activePrinter.stagePdf) throw new require_settings.PluginError("unsupported", "documents", "this printer prints no PDF");
+		const pdf = await require_settings.cancellable("documents", signal, handle.pages.extract(pages.map((page) => page.ref), {
+			flatten: { usage: "print" },
+			...layers
+		}));
+		const staged = await activePrinter.stagePdf(pdf, {
+			name,
+			...signal ? { signal } : {}
+		});
+		options.onProgress?.({
+			pagesRendered: pages.length,
+			pageCount: pages.length
+		});
+		return staged;
+	}
+	/** A picture of each page, drawn by the print rules at `dpi`, staged with the printer. */
+	async function stagePictures(job, activePrinter, dpi) {
+		const { handle, pages, layers, name, options } = job;
+		const { signal } = options;
+		const sheets = [];
+		for (const page of pages) {
+			const blob = await require_settings.cancellable("documents", signal, (await require_settings.cancellable("documents", signal, handle.page(page.ref).render.image({
+				usage: "print",
+				viewport: {
+					kind: "dpi",
+					dpi
+				},
+				format: "png",
+				...layers
+			}))).blob());
+			sheets.push({
+				image: blob,
+				widthPt: page.size.width,
+				heightPt: page.size.height
+			});
+			options.onProgress?.({
+				pagesRendered: sheets.length,
+				pageCount: pages.length
+			});
+		}
+		return activePrinter.stage(sheets, {
+			name,
+			...signal ? { signal } : {}
+		});
+	}
+	/**
+	* Get a print ready. Refused before anything runs without `doc.print` or a printer, or for
+	* pages the document doesn't have. Its `print()` runs inside every `aroundPrint` wrap (the
+	* document's own print actions), and prepares again first when the document changed since:
+	* a will-print action that fills in a date is on the paper. When the printer turns the PDF
+	* copy down, preparing or printing, the same pages print as pictures, and `quality` says so.
+	*/
+	async function preparePrint(documentId, options = {}) {
+		const session = readySession(documentId, "preparePrint");
+		if (!allowsOn(session.id, "doc.print")) throw require_settings.permissionDenied("documents", "doc.print", "documents.preparePrint");
+		const quality = printQualityOf(session.id);
+		if (!printer || !quality) throw new require_settings.PluginError("unsupported", "documents", "no printer: pass one to createKernel({ printer }), such as browserPrinter() from @embedpdf/web");
+		const pageCount = printPagesOf(session, options.pages).length;
+		try {
+			let { staged, changesSeen, quality: printed } = await stagePrint(session, printer, quality, options);
+			let disposed = false;
+			const dispose = () => {
+				if (disposed) return;
+				disposed = true;
+				staged.dispose();
+			};
+			session.scope.defer(dispose);
+			/** Stage the print again, as `as`, in place of what was staged. */
+			const restage = async (as, signal) => {
+				const fresh = await stagePrint(session, printer, as, {
+					...options.pages ? { pages: options.pages } : {},
+					...options.includeAnnotations !== void 0 ? { includeAnnotations: options.includeAnnotations } : {},
+					...signal ? { signal } : {}
+				});
+				staged.dispose();
+				({staged, changesSeen, quality: printed} = fresh);
+			};
+			return {
+				get quality() {
+					return printed;
+				},
+				pageCount,
+				needsTap: printer.needsTap === true,
+				async print(printOptions) {
+					if (disposed) throw new require_settings.PluginError("invalid-input", "documents", "this print was disposed");
+					const signal = printOptions?.signal;
+					const run = async () => {
+						if (session.changesSeen !== changesSeen) await restage(quality, signal);
+						if (signal?.aborted) throw new require_settings.PluginError("operation-cancelled", "documents", "print cancelled", { cause: signal.reason });
+						try {
+							await staged.print();
+						} catch (error) {
+							if (printed.kind !== "pdf") throw error;
+							await restage(PRINT_HIGH, signal);
+							await staged.print();
+						}
+					};
+					try {
+						await require_settings.runWrapped(session.printWraps, run);
+					} catch (error) {
+						throw require_settings.toPluginError("documents", error);
+					}
+				},
+				dispose
+			};
+		} catch (error) {
+			throw require_settings.toPluginError("documents", error);
+		}
+	}
 	/** Whether the plugin's `create()` is running for this document: it has no capability yet. */
 	const isBuilding = (plugin, session) => session.building.has(plugin) && !session.capabilities.has(plugin);
 	function buildDocumentCapability(plugin, session) {
@@ -666,9 +871,12 @@ function createKernel(config) {
 		session.scope.defer(bursts.close);
 		const unsubscribeEvents = session.handle.events.subscribe((event) => {
 			bursts.first(event);
-			if (tracksChanges && changesDocument(event)) {
-				session.changeCount += 1;
-				setUnsavedChanges(session, true);
+			if (changesDocument(event)) {
+				session.changesSeen += 1;
+				if (tracksChanges) {
+					session.changeCount += 1;
+					setUnsavedChanges(session, true);
+				}
 			}
 			const layout = layoutFromEvent(event);
 			if (!layout) return;
@@ -955,8 +1163,18 @@ function createKernel(config) {
 		},
 		download: (id, options) => downloadFile(id, options?.signal, "download", (handle) => handle.download(options?.mode !== void 0 ? { mode: options.mode } : void 0)),
 		downloadLayer: (id, options) => downloadFile(id, options?.signal, "downloadLayer", (handle) => (0, _embedpdf_engine_core_runtime.isLocalDocument)(handle) ? handle.downloadLayer() : Promise.reject(noLayer()), (handle) => (0, _embedpdf_engine_core_runtime.isLocalDocument)(handle) ? null : noLayer()),
+		preparePrint: (id, options) => preparePrint(id, options),
+		async print(id, options = {}) {
+			const prepared = await preparePrint(id, options);
+			try {
+				await prepared.print(options.signal ? { signal: options.signal } : void 0);
+			} finally {
+				prepared.dispose();
+			}
+		},
+		getPrintQuality: (id) => printQualityOf(id),
 		canDownload: (id) => allowsOn(id, "doc.download"),
-		canPrint: (id) => allowsOn(id, "doc.print"),
+		canPrint: (id) => canPrintOn(id),
 		listPages: (id) => metaOf(id)?.pages ?? EMPTY_PAGES,
 		getPage: (page, id) => require_settings.findPage(metaOf(id)?.pages ?? EMPTY_PAGES, page),
 		getPageIndex: (ref, id) => metaOf(id)?.pages.findIndex((pageInfo) => (0, _embedpdf_engine_core_runtime.pageRefsEqual)(pageInfo.ref, ref)) ?? -1,