reamkit 0.1.0-alpha.0 → 1.0.1

package/dist/esm/pdf/styled-page-emitter.js

@@ -0,0 +1,557 @@
+import { dict, name, ref, stream, unicodeString } from "./objects.js";
+import { embedTtfFont } from "./cid-font.js";
+import { reorderVisual } from "../core/bidi/algorithm.js";
+import { reverseByCodePoint } from "../core/bidi/index.js";
+import "../layout/styled-layout.js";
+import { paintPlan } from "../layout/page-doc.js";
+import { emitVectorShape } from "./vector-graphics.js";
+import { embedAssociatedFile } from "./embedded-file.js";
+import { buildSrgbIccProfile } from "./icc-profile.js";
+import { addImage } from "./image-xobject.js";
+import { addSignaturePlaceholder } from "./signature.js";
+import { buildXmpPacket } from "./xmp.js";
+//#region src/pdf/styled-page-emitter.ts
+var encoder = new TextEncoder();
+function emitStyledPdf(laid, options, doc) {
+	const { pages: renderedPages } = laid;
+	const { structBuilder, sectionCtxs, pdfaProfile, tagged } = laid.pdf;
+	const embeddedFonts = embedFontResources(doc, laid, pdfaProfile);
+	const embeddedImages = embedImageResources(doc, laid);
+	const pagesDict = dict({
+		Type: name("Pages"),
+		Count: 0,
+		Kids: []
+	});
+	const pagesRef = doc.add(pagesDict);
+	let firstPageDict;
+	const fontResourceDict = buildFontResourceDict(laid.fontResources, embeddedFonts);
+	const xobjectResourceDict = buildXObjectResourceDict(laid.imageResources, embeddedImages);
+	const resourcesDict = dict({
+		Font: fontResourceDict,
+		...xobjectResourceDict ? { XObject: xobjectResourceDict } : {}
+	});
+	let pdfaIccRef;
+	let transparencyGroup;
+	if (pdfaProfile) {
+		pdfaIccRef = doc.add(stream({
+			N: 3,
+			Alternate: name("DeviceRGB")
+		}, buildSrgbIccProfile()));
+		if (pdfaProfile.part >= 2) transparencyGroup = dict({
+			S: name("Transparency"),
+			CS: [name("ICCBased"), ref(pdfaIccRef.id)]
+		});
+	}
+	const pageRefs = [];
+	renderedPages.forEach((page, pageIndex) => {
+		let pageTagging;
+		if (structBuilder) {
+			const builder = structBuilder;
+			pageTagging = {
+				next: 0,
+				assigned: false,
+				record: (structId, mcid) => builder.addMcref(structId, pageIndex, mcid),
+				tagFor: (structId) => builder.node(structId).type
+			};
+		}
+		const contentBytes = emitPageContent(page, pageTagging);
+		const contentsRef = doc.add(stream({}, contentBytes));
+		const pageEntries = {
+			Type: name("Page"),
+			Parent: ref(pagesRef.id),
+			MediaBox: [
+				0,
+				0,
+				page.width,
+				page.height
+			],
+			Resources: resourcesDict,
+			Contents: ref(contentsRef.id)
+		};
+		if (transparencyGroup) pageEntries["Group"] = transparencyGroup;
+		if (pageTagging?.assigned) {
+			pageEntries["StructParents"] = pageIndex;
+			pageEntries["Tabs"] = name("S");
+		}
+		const pageDictObj = dict(pageEntries);
+		if (firstPageDict === void 0) firstPageDict = pageDictObj;
+		pageRefs.push(doc.add(pageDictObj));
+	});
+	if (pageRefs.length === 0) {
+		const fallback = sectionCtxs[0] ?? defaultPageCtx();
+		const contentsRef = doc.add(stream({}, new Uint8Array(0)));
+		const fallbackDict = dict({
+			Type: name("Page"),
+			Parent: ref(pagesRef.id),
+			MediaBox: [
+				0,
+				0,
+				fallback.pageWidth,
+				fallback.pageHeight
+			],
+			Resources: resourcesDict,
+			Contents: ref(contentsRef.id),
+			...transparencyGroup ? { Group: transparencyGroup } : {}
+		});
+		firstPageDict = fallbackDict;
+		pageRefs.push(doc.add(fallbackDict));
+	}
+	pagesDict.set("Count", pageRefs.length);
+	pagesDict.set("Kids", pageRefs);
+	const catalogEntries = {
+		Type: name("Catalog"),
+		Pages: ref(pagesRef.id)
+	};
+	if (pdfaProfile) {
+		catalogEntries["OutputIntents"] = [ref(doc.add(dict({
+			Type: name("OutputIntent"),
+			S: name("GTS_PDFA1"),
+			OutputConditionIdentifier: "sRGB",
+			Info: "sRGB IEC61966-2.1",
+			DestOutputProfile: ref(pdfaIccRef.id)
+		})).id)];
+		catalogEntries["Metadata"] = ref(doc.add(stream({
+			Type: name("Metadata"),
+			Subtype: name("XML")
+		}, buildXmpPacket(xmpFromInfo(options.info, pdfaProfile)))).id);
+	}
+	if (tagged && structBuilder) {
+		const structRootRef = structBuilder.emit(doc, pageRefs);
+		catalogEntries["MarkInfo"] = dict({ Marked: true });
+		catalogEntries["StructTreeRoot"] = ref(structRootRef.id);
+		catalogEntries["Lang"] = options.language ?? "en-US";
+		if (options.info?.title) catalogEntries["ViewerPreferences"] = dict({ DisplayDocTitle: true });
+	}
+	if (options.attachments?.length && (!pdfaProfile || pdfaProfile.part === 3)) {
+		const embedded = options.attachments.map((file) => ({
+			file,
+			ref: embedAssociatedFile(doc, file)
+		}));
+		catalogEntries["AF"] = embedded.map((e) => ref(e.ref.id));
+		const sorted = [...embedded].sort((a, b) => a.file.name < b.file.name ? -1 : a.file.name > b.file.name ? 1 : 0);
+		const names = [];
+		for (const e of sorted) names.push(e.file.name, ref(e.ref.id));
+		catalogEntries["Names"] = dict({ EmbeddedFiles: ref(doc.add(dict({ Names: names })).id) });
+	}
+	if (options.signaturePlaceholder && firstPageDict) {
+		const { fieldRef, acroForm } = addSignaturePlaceholder(doc, options.signaturePlaceholder, pageRefs[0]);
+		firstPageDict.set("Annots", [ref(fieldRef.id)]);
+		catalogEntries["AcroForm"] = acroForm;
+	}
+	const catalogRef = doc.add(dict(catalogEntries));
+	const infoRef = buildInfoDict(doc, options.info);
+	return doc.build(catalogRef, infoRef, { ...pdfaProfile ? {
+		version: pdfaProfile.version,
+		id: true
+	} : {} });
+}
+var DEFAULT_PRODUCER = "Ream";
+function xmpFromInfo(info, p) {
+	return {
+		pdfaPart: p ? String(p.part) : "1",
+		pdfaConformance: p ? p.level.toUpperCase() : "B",
+		producer: info?.producer ?? DEFAULT_PRODUCER,
+		...info?.title ? { title: info.title } : {},
+		...info?.author ? { author: info.author } : {},
+		...info?.subject ? { subject: info.subject } : {},
+		...info?.keywords ? { keywords: info.keywords } : {},
+		...info?.creator ? { creator: info.creator } : {},
+		...info?.creationDate ? { createDate: info.creationDate } : {},
+		...info?.modificationDate ? { modifyDate: info.modificationDate } : {}
+	};
+}
+function buildInfoDict(doc, info) {
+	const merged = {
+		...info,
+		producer: info?.producer ?? DEFAULT_PRODUCER
+	};
+	const entries = {};
+	if (merged.title) entries["Title"] = unicodeString(merged.title);
+	if (merged.author) entries["Author"] = unicodeString(merged.author);
+	if (merged.subject) entries["Subject"] = unicodeString(merged.subject);
+	if (merged.keywords) entries["Keywords"] = unicodeString(merged.keywords);
+	if (merged.creator) entries["Creator"] = unicodeString(merged.creator);
+	entries["Producer"] = unicodeString(merged.producer);
+	if (merged.creationDate) entries["CreationDate"] = formatPdfDate(merged.creationDate);
+	if (merged.modificationDate) entries["ModDate"] = formatPdfDate(merged.modificationDate);
+	return doc.add(dict(entries));
+}
+function formatPdfDate(d) {
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	return `D:${pad(d.getUTCFullYear(), 4)}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}Z`;
+}
+function defaultPageCtx() {
+	return {
+		endIndex: 0,
+		properties: {
+			headers: [],
+			footers: []
+		},
+		pageWidth: 595,
+		pageHeight: 842,
+		marginLeft: 72,
+		marginTop: 72,
+		marginBottom: 72,
+		contentWidth: 451,
+		pageContentHeight: 698,
+		headerSet: {
+			default: [],
+			first: [],
+			even: []
+		},
+		footerSet: {
+			default: [],
+			first: [],
+			even: []
+		},
+		titlePg: false,
+		evenAndOddHeaders: false
+	};
+}
+function embedImageResources(doc, laid) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [resourceId, res] of laid.imageResources) out.set(resourceId, addImage(doc, res.prepared).ref);
+	return out;
+}
+function embedFontResources(doc, laid, pdfaProfile) {
+	const cidSet = pdfaProfile?.part === 1;
+	const out = /* @__PURE__ */ new Map();
+	for (const [variant, res] of laid.fontResources) out.set(variant, embedTtfFont(doc, res.parsed, {
+		usedGids: res.gids,
+		cidSet
+	}));
+	return out;
+}
+function buildFontResourceDict(resources, embedded) {
+	const entries = {};
+	for (const [variant, res] of resources) {
+		const emb = embedded.get(variant);
+		if (emb) entries[res.resourceName] = ref(emb.fontRef.id);
+	}
+	return dict(entries);
+}
+function buildXObjectResourceDict(resources, embedded) {
+	if (embedded.size === 0) return void 0;
+	const entries = {};
+	for (const [resourceId, res] of resources) {
+		const r = embedded.get(resourceId);
+		if (r) entries[res.resourceName] = ref(r.id);
+	}
+	return dict(entries);
+}
+function emitTaggedRuns(out, cmds, tagging, body) {
+	if (!tagging) {
+		for (const c of cmds) body(c);
+		return;
+	}
+	let openKey = null;
+	const close = () => {
+		if (openKey !== null) {
+			out.push("EMC");
+			openKey = null;
+		}
+	};
+	for (const c of cmds) {
+		const key = c.structId !== void 0 ? `f${c.structId}` : c.artifact === "pagination" ? "p" : "a";
+		if (key !== openKey) {
+			close();
+			if (c.structId !== void 0) {
+				const mcid = tagging.next++;
+				tagging.assigned = true;
+				tagging.record(c.structId, mcid);
+				out.push(`/${tagging.tagFor(c.structId)} <</MCID ${mcid}>> BDC`);
+			} else if (c.artifact === "pagination") out.push("/Artifact <</Type /Pagination>> BDC");
+			else out.push("/Artifact BMC");
+			openKey = key;
+		}
+		body(c);
+	}
+	close();
+}
+function emitPageContent(page, tagging) {
+	const commands = page.commands;
+	if (commands.length === 0) return new Uint8Array(0);
+	const H = page.height;
+	const out = [];
+	const plan = paintPlan(commands);
+	const fills = plan.fills;
+	if (fills.length > 0) {
+		if (tagging) out.push("/Artifact BMC");
+		out.push("q");
+		let lastColor = "";
+		for (const f of fills) {
+			const color = f.fillColorHex;
+			if (color !== lastColor) {
+				const [r, g, b] = hexToRgb01(color);
+				out.push(`${formatNumber(r)} ${formatNumber(g)} ${formatNumber(b)} rg`);
+				lastColor = color;
+			}
+			out.push(`${formatNumber(f.x)} ${formatNumber(H - f.y - f.height)} ${formatNumber(f.width)} ${formatNumber(f.height)} re`);
+			out.push("f");
+		}
+		out.push("Q");
+		if (tagging) out.push("EMC");
+	}
+	emitTaggedRuns(out, plan.images.filter((c) => c.imageResourceName !== ""), tagging, (img) => {
+		out.push("q");
+		out.push(`${formatNumber(img.width)} 0 0 ${formatNumber(img.height)} ${formatNumber(img.x)} ${formatNumber(H - img.y - img.height)} cm`);
+		out.push(`/${img.imageResourceName} Do`);
+		out.push("Q");
+	});
+	const borders = plan.borders;
+	if (borders.length > 0) {
+		if (tagging) out.push("/Artifact BMC");
+		out.push("q");
+		let lastWidth = -1;
+		let lastColor = "";
+		for (const b of borders) {
+			const width = b.borderSizePt;
+			const color = b.borderColorHex;
+			if (width !== lastWidth) {
+				out.push(`${formatNumber(width)} w`);
+				lastWidth = width;
+			}
+			if (color !== lastColor) {
+				const [r, g, bl] = hexToRgb01(color);
+				out.push(`${formatNumber(r)} ${formatNumber(g)} ${formatNumber(bl)} RG`);
+				lastColor = color;
+			}
+			const x = b.x;
+			const y = H - b.y - b.height;
+			const w = b.width;
+			const h = b.height;
+			switch (b.side) {
+				case "top":
+					out.push(`${formatNumber(x)} ${formatNumber(y + h)} m`);
+					out.push(`${formatNumber(x + w)} ${formatNumber(y + h)} l`);
+					break;
+				case "bottom":
+					out.push(`${formatNumber(x)} ${formatNumber(y)} m`);
+					out.push(`${formatNumber(x + w)} ${formatNumber(y)} l`);
+					break;
+				case "left":
+					out.push(`${formatNumber(x)} ${formatNumber(y)} m`);
+					out.push(`${formatNumber(x)} ${formatNumber(y + h)} l`);
+					break;
+				case "right":
+					out.push(`${formatNumber(x + w)} ${formatNumber(y)} m`);
+					out.push(`${formatNumber(x + w)} ${formatNumber(y + h)} l`);
+					break;
+			}
+			out.push("S");
+		}
+		out.push("Q");
+		if (tagging) out.push("EMC");
+	}
+	const shapes = plan.shapes;
+	emitTaggedRuns(out, shapes, tagging, (sh) => {
+		const t = sh.shape.transform;
+		const shape = {
+			...sh.shape,
+			transform: [
+				t[0],
+				-t[1],
+				t[2],
+				-t[3],
+				t[4],
+				H - t[5]
+			]
+		};
+		for (const op of emitVectorShape(shape)) out.push(op);
+	});
+	const lines = plan.lines;
+	if (lines.length > 0) {
+		let inBT = false;
+		let lastFont = "";
+		let lastSize = -1;
+		let lastColor = "";
+		const switchFontIfNeeded = (tok) => {
+			const fontKey = tok.font.resourceName;
+			if (fontKey !== lastFont || tok.fontSizePt !== lastSize) {
+				out.push(`/${fontKey} ${formatNumber(tok.fontSizePt)} Tf`);
+				lastFont = fontKey;
+				lastSize = tok.fontSizePt;
+			}
+			if (tok.resolvedRun.colorHex !== lastColor) {
+				const [r, g, b] = hexToRgb01(tok.resolvedRun.colorHex);
+				out.push(`${formatNumber(r)} ${formatNumber(g)} ${formatNumber(b)} rg`);
+				lastColor = tok.resolvedRun.colorHex;
+			}
+		};
+		const emitImageToken = (tok, x, baselineY) => {
+			if (!tok.imageResourceName) return;
+			if (inBT) {
+				out.push("ET");
+				inBT = false;
+			}
+			out.push("q");
+			out.push(`${formatNumber(tok.widthPt)} 0 0 ${formatNumber(tok.heightPt)} ${formatNumber(x)} ${formatNumber(baselineY)} cm`);
+			out.push(`/${tok.imageResourceName} Do`);
+			out.push("Q");
+			lastFont = "";
+			lastSize = -1;
+			lastColor = "";
+		};
+		const emitMathToken = (tok, originX, baselineY) => {
+			for (const it of tok.items) if (it.kind === "glyph") {
+				if (!inBT) {
+					out.push("BT");
+					inBT = true;
+				}
+				if (it.font.resourceName !== lastFont || it.sizePt !== lastSize) {
+					out.push(`/${it.font.resourceName} ${formatNumber(it.sizePt)} Tf`);
+					lastFont = it.font.resourceName;
+					lastSize = it.sizePt;
+				}
+				if (lastColor !== "000000") {
+					out.push("0 0 0 rg");
+					lastColor = "000000";
+				}
+				out.push(`1 0 0 1 ${formatNumber(originX + it.x)} ${formatNumber(baselineY + it.y)} Tm`);
+				out.push(`<${it.font.measure.encodeTextAsCidHex(it.text)}> Tj`);
+			} else if (it.kind === "rule") {
+				if (inBT) {
+					out.push("ET");
+					inBT = false;
+				}
+				out.push("q");
+				out.push("0 0 0 rg");
+				out.push(`${formatNumber(originX + it.x)} ${formatNumber(baselineY + it.y)} ${formatNumber(it.w)} ${formatNumber(it.h)} re`);
+				out.push("f");
+				out.push("Q");
+				lastFont = "";
+				lastSize = -1;
+				lastColor = "";
+			} else {
+				if (inBT) {
+					out.push("ET");
+					inBT = false;
+				}
+				const shape = {
+					paths: [{ segments: it.segments }],
+					...it.fill ? { fillColorHex: "000000" } : {},
+					...it.strokeWidthPt !== void 0 ? { stroke: {
+						colorHex: "000000",
+						widthPt: it.strokeWidthPt
+					} } : {},
+					transform: [
+						1,
+						0,
+						0,
+						1,
+						originX,
+						baselineY
+					]
+				};
+				for (const op of emitVectorShape(shape)) out.push(op);
+				lastFont = "";
+				lastSize = -1;
+				lastColor = "";
+			}
+		};
+		const emitOneLine = (cmd) => {
+			const line = cmd.line;
+			const originX = cmd.originX;
+			const baselineY = H - cmd.baselineY;
+			const extraPerSpace = computeJustifyExtra(line);
+			const hasImageToken = line.tokens.some((t) => t.kind === "image");
+			const hasMathToken = line.tokens.some((t) => t.kind === "math");
+			const hasRtl = line.tokens.some((t) => t.bidiLevel % 2 === 1);
+			const encodeToken = (tok) => {
+				const text = tok.bidiLevel % 2 === 1 ? reverseByCodePoint(tok.text) : tok.text;
+				return tok.font.measure.encodeTextAsCidHex(text);
+			};
+			if (extraPerSpace > 0 || hasImageToken || hasMathToken || hasRtl) {
+				const order = hasRtl ? lineVisualOrder(line) : line.tokens.map((_, i) => i);
+				let x = originX;
+				for (const ti of order) {
+					const tok = line.tokens[ti];
+					if (tok.kind === "image") {
+						emitImageToken(tok, x, baselineY);
+						x += tok.widthPt;
+						continue;
+					}
+					if (tok.kind === "math") {
+						emitMathToken(tok, x, baselineY);
+						x += tok.widthPt;
+						continue;
+					}
+					if (!inBT) {
+						out.push("BT");
+						inBT = true;
+					}
+					switchFontIfNeeded(tok);
+					out.push(`1 0 0 1 ${formatNumber(x)} ${formatNumber(baselineY)} Tm`);
+					out.push(`<${encodeToken(tok)}> Tj`);
+					x += tok.widthPt;
+					if (tok.isSpace) x += extraPerSpace;
+				}
+			} else {
+				if (!inBT) {
+					out.push("BT");
+					inBT = true;
+				}
+				out.push(`1 0 0 1 ${formatNumber(originX)} ${formatNumber(baselineY)} Tm`);
+				for (const tok of line.tokens) {
+					if (tok.kind !== "text") continue;
+					switchFontIfNeeded(tok);
+					const hex = tok.font.measure.encodeTextAsCidHex(tok.text);
+					out.push(`<${hex}> Tj`);
+				}
+			}
+		};
+		if (tagging) for (const cmd of lines) {
+			if (inBT) {
+				out.push("ET");
+				inBT = false;
+			}
+			const sid = cmd.structId;
+			if (sid !== void 0) {
+				const mcid = tagging.next++;
+				tagging.assigned = true;
+				tagging.record(sid, mcid);
+				out.push(`/${tagging.tagFor(sid)} <</MCID ${mcid}>> BDC`);
+			} else if (cmd.artifact === "pagination") out.push("/Artifact <</Type /Pagination>> BDC");
+			else out.push("/Artifact BMC");
+			emitOneLine(cmd);
+			if (inBT) {
+				out.push("ET");
+				inBT = false;
+			}
+			out.push("EMC");
+		}
+		else {
+			out.push("BT");
+			inBT = true;
+			for (const cmd of lines) emitOneLine(cmd);
+			if (inBT) out.push("ET");
+		}
+	}
+	return encoder.encode(out.join("\n"));
+}
+function lineVisualOrder(line) {
+	return reorderVisual(line.tokens.map((t) => t.bidiLevel));
+}
+function computeJustifyExtra(line) {
+	if (line.resolved.alignment !== "both") return 0;
+	if (line.isLastInParagraph) return 0;
+	let spaces = 0;
+	for (const tok of line.tokens) if (tok.isSpace) spaces++;
+	if (spaces === 0) return 0;
+	const extra = line.availableWidthPt - line.contentWidthPt;
+	if (extra <= 0) return 0;
+	return extra / spaces;
+}
+function hexToRgb01(hex) {
+	return [
+		parseInt(hex.slice(0, 2), 16) / 255,
+		parseInt(hex.slice(2, 4), 16) / 255,
+		parseInt(hex.slice(4, 6), 16) / 255
+	];
+}
+function formatNumber(n) {
+	if (Number.isInteger(n)) return String(n);
+	return n.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
+}
+//#endregion
+export { emitStyledPdf };

package/dist/esm/pdf/styled-page-renderer.d.ts

@@ -1,43 +1,5 @@
-import { BodyElement, Chart, Numbering, Section, SectionProperties, StyleSheet } from '../document-model/index.js';
-import { FontRegistry } from '../font/index.js';
-import { FamilyKey } from '../fonts/index.js';
-import { Hyphenator } from '../hyphenation/index.js';
-import { AttachedFile } from './embedded-file.js';
-import { SignaturePlaceholder } from './signature.js';
-export type PdfALevel = 'PDF/A-1b' | 'PDF/A-1a' | 'PDF/A-2b' | 'PDF/A-2u' | 'PDF/A-2a' | 'PDF/A-3b' | 'PDF/A-3u' | 'PDF/A-3a';
-export interface StyledRenderOptions {
-    readonly registry: FontRegistry;
-    readonly registriesByFamily?: ReadonlyMap<FamilyKey, FontRegistry>;
-    readonly embeddedFonts?: ReadonlyMap<string, FontRegistry>;
-    readonly styles: StyleSheet;
-    readonly numbering?: Numbering;
-    readonly section?: SectionProperties;
-    readonly sections?: ReadonlyArray<Section>;
-    readonly headersFooters?: ReadonlyMap<string, ReadonlyArray<BodyElement>>;
-    readonly images?: ReadonlyMap<string, Uint8Array>;
-    readonly charts?: ReadonlyMap<string, Chart>;
-    readonly pageWidth?: number;
-    readonly pageHeight?: number;
-    readonly marginLeft?: number;
-    readonly marginRight?: number;
-    readonly marginTop?: number;
-    readonly marginBottom?: number;
-    readonly hyphenator?: Hyphenator;
-    readonly info?: DocumentInfo;
-    readonly pdfA?: PdfALevel;
-    readonly tagged?: boolean;
-    readonly language?: string;
-    readonly attachments?: ReadonlyArray<AttachedFile>;
-    readonly signaturePlaceholder?: SignaturePlaceholder;
-}
-export interface DocumentInfo {
-    readonly title?: string;
-    readonly author?: string;
-    readonly subject?: string;
-    readonly keywords?: string;
-    readonly creator?: string;
-    readonly producer?: string;
-    readonly creationDate?: Date;
-    readonly modificationDate?: Date;
-}
+import { BodyElement } from '../core/document-model/index.js';
+import { StyledRenderOptions } from '../layout/styled-layout.js';
 export declare function renderStyledPdf(body: ReadonlyArray<BodyElement>, options: StyledRenderOptions): Uint8Array;
+export * from '../layout/page-doc.js';
+export * from '../layout/styled-layout.js';