rtf-codec 0.0.0 → 1.0.0

package/dist/write.cjs

@@ -0,0 +1,364 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_base64 = require("./base64.cjs");
+const require_diagnostics = require("./diagnostics.cjs");
+const require_units = require("./units.cjs");
+const require_list_id = require("./list-id.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/write.ts
+const LEVEL_NUMBER_FORMAT_BULLET = 23;
+const LEVEL_NUMBER_FORMAT_ARABIC = 0;
+const LIST_LEVEL_INDENT_TWIPS = 720;
+const LIST_MARKER_HANG_TWIPS = 360;
+const BULLET_LEVEL_TEXT = "\\'01\\u183 ?";
+const ARABIC_LEVEL_TEXT = "\\'02\\'00.";
+const OUTPUT_CODEPAGE = 1252;
+const ALIGNMENT_CONTROL_WORDS = /* @__PURE__ */ new Map([
+	["left", "\\ql"],
+	["center", "\\qc"],
+	["right", "\\qr"],
+	["justify", "\\qj"]
+]);
+const DEFAULT_FONT_NAME = "Times New Roman";
+function collectTables(document) {
+	const fonts = /* @__PURE__ */ new Map([[DEFAULT_FONT_NAME, 0]]);
+	const colors = /* @__PURE__ */ new Map();
+	const headingStyles = /* @__PURE__ */ new Map();
+	const lists = /* @__PURE__ */ new Map();
+	const noteRun = (run) => {
+		if (run.fontFamily !== void 0 && !fonts.has(run.fontFamily)) fonts.set(run.fontFamily, fonts.size);
+		if (run.color !== void 0) {
+			const hex = (0, document_schema_js.colorToRgbHex)(run.color);
+			if (!colors.has(hex)) colors.set(hex, colors.size + 1);
+		}
+	};
+	const noteBlock = (block) => {
+		if (block.kind === "paragraph") {
+			for (const run of block.runs) noteRun(run);
+			if (block.headingLevel !== void 0) {
+				const level = (0, document_schema_js.clampHeadingLevel)(block.headingLevel);
+				if (!headingStyles.has(level)) headingStyles.set(level, level);
+			}
+			const numId = block.list?.numId;
+			if (numId !== void 0 && !lists.has(numId)) {
+				const parsed = require_list_id.parseRtfListNumId(numId);
+				lists.set(numId, {
+					index: lists.size + 1,
+					definition: {
+						type: parsed?.type ?? "bullet",
+						start: parsed?.start ?? 1
+					}
+				});
+			}
+			return;
+		}
+		if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) for (const inner of cell.blocks) noteBlock(inner);
+	};
+	if (document.kind === "wordprocessing") for (const section of document.sections) for (const block of section.blocks) noteBlock(block);
+	return {
+		fonts,
+		colors,
+		headingStyles,
+		lists
+	};
+}
+function escapeText(text) {
+	let out = "";
+	for (const character of text) {
+		switch (character) {
+			case "\\":
+				out += "\\\\";
+				continue;
+			case "{":
+				out += "\\{";
+				continue;
+			case "}":
+				out += "\\}";
+				continue;
+			case "	":
+				out += "\\tab ";
+				continue;
+			case "\n":
+			case "\r":
+				out += "\\line ";
+				continue;
+		}
+		const code = character.codePointAt(0) ?? 0;
+		if (code >= 32 && code < 127) {
+			out += character;
+			continue;
+		}
+		for (let unit = 0; unit < character.length; unit += 1) {
+			const value = character.charCodeAt(unit);
+			const signed = value > 32767 ? value - 65536 : value;
+			out += `\\u${String(signed)} ?`;
+		}
+	}
+	return out;
+}
+var RtfWriter = class {
+	tables;
+	sink;
+	lineEnding;
+	out = "";
+	constructor(tables, sink, lineEnding) {
+		this.tables = tables;
+		this.sink = sink;
+		this.lineEnding = lineEnding;
+	}
+	raw(text) {
+		this.out += text;
+	}
+	line(text) {
+		this.out += text + this.lineEnding;
+	}
+	get text() {
+		return this.out;
+	}
+	writeHeader(document) {
+		this.raw(`{\\rtf1\\ansi\\ansicpg${String(OUTPUT_CODEPAGE)}\\deff0\\uc1`);
+		this.writeFontTable();
+		this.writeColorTable();
+		this.writeStyleSheet();
+		this.writeListTables();
+		this.writeInfoGroup(document);
+		this.line("");
+	}
+	writeFontTable() {
+		this.raw("{\\fonttbl");
+		for (const [name, index] of [...this.tables.fonts].sort((left, right) => left[1] - right[1])) this.raw(`{\\f${String(index)}\\fnil\\fcharset0 ${escapeText(name)};}`);
+		this.raw("}");
+	}
+	writeColorTable() {
+		if (this.tables.colors.size === 0) return;
+		this.raw("{\\colortbl;");
+		for (const [hex] of [...this.tables.colors].sort((left, right) => left[1] - right[1])) {
+			const red = Number.parseInt(hex.slice(0, 2), 16);
+			const green = Number.parseInt(hex.slice(2, 4), 16);
+			const blue = Number.parseInt(hex.slice(4, 6), 16);
+			this.raw(`\\red${String(red)}\\green${String(green)}\\blue${String(blue)};`);
+		}
+		this.raw("}");
+	}
+	writeStyleSheet() {
+		if (this.tables.headingStyles.size === 0) return;
+		this.raw("{\\stylesheet{\\s0\\snext0 Normal;}");
+		for (const [level, handle] of [...this.tables.headingStyles].sort((left, right) => left[0] - right[0])) this.raw(`{\\s${String(handle)}\\sbasedon0\\snext0\\outlinelevel${String(level - 1)} heading ${String(level)};}`);
+		this.raw("}");
+	}
+	writeListTables() {
+		if (this.tables.lists.size === 0) return;
+		const entries = [...this.tables.lists.values()].sort((left, right) => left.index - right.index);
+		this.raw("{\\*\\listtable");
+		for (const entry of entries) {
+			const bullet = entry.definition.type === "bullet";
+			const numberFormat = bullet ? LEVEL_NUMBER_FORMAT_BULLET : LEVEL_NUMBER_FORMAT_ARABIC;
+			const levelText = bullet ? BULLET_LEVEL_TEXT : ARABIC_LEVEL_TEXT;
+			const levelNumbers = bullet ? "" : "\\'01";
+			this.raw(`{\\list\\listtemplateid${String(entry.index)}\\listhybrid`);
+			for (let level = 0; level < 9; level += 1) {
+				const indent = LIST_LEVEL_INDENT_TWIPS * (level + 1);
+				this.raw(`{\\listlevel\\levelnfc${String(numberFormat)}\\levelnfcn${String(numberFormat)}\\leveljc0\\leveljcn0\\levelfollow0\\levelstartat${String(entry.definition.start)}\\levelspace0\\levelindent0{\\leveltext${levelText};}{\\levelnumbers${levelNumbers};}\\fi-${String(LIST_MARKER_HANG_TWIPS)}\\li${String(indent)}\\lin${String(indent)}}`);
+			}
+			this.raw(`\\listid${String(1e3 + entry.index)}}`);
+		}
+		this.raw("}{\\*\\listoverridetable");
+		for (const entry of entries) this.raw(`{\\listoverride\\listid${String(1e3 + entry.index)}\\listoverridecount0\\ls${String(entry.index)}}`);
+		this.raw("}");
+	}
+	writeInfoGroup(document) {
+		const { title, author, subject, keywords } = document.metadata;
+		const fields = [];
+		if (title !== void 0) fields.push(`{\\title ${escapeText(title)}}`);
+		if (author !== void 0) fields.push(`{\\author ${escapeText(author)}}`);
+		if (subject !== void 0) fields.push(`{\\subject ${escapeText(subject)}}`);
+		if (keywords !== void 0 && keywords.length > 0) fields.push(`{\\keywords ${escapeText(keywords.join("; "))}}`);
+		if (fields.length > 0) this.raw(`{\\info${fields.join("")}}`);
+	}
+	writeSection(section, isFirst) {
+		if (!isFirst) this.line("\\sect");
+		this.line(`\\sectd\\paperw${String(require_units.pointsToTwips(section.pageSize.widthPt))}\\paperh${String(require_units.pointsToTwips(section.pageSize.heightPt))}\\margl${String(require_units.pointsToTwips(section.margins.leftPt))}\\margr${String(require_units.pointsToTwips(section.margins.rightPt))}\\margt${String(require_units.pointsToTwips(section.margins.topPt))}\\margb${String(require_units.pointsToTwips(section.margins.bottomPt))}`);
+		this.writeBlocks(section.blocks);
+	}
+	writeBlocks(blocks) {
+		for (const block of blocks) this.writeBlock(block);
+	}
+	writeBlock(block) {
+		switch (block.kind) {
+			case "paragraph":
+				this.writeParagraph(block, false);
+				return;
+			case "table":
+				this.writeTable(block);
+				return;
+			case "image":
+				this.writeImageParagraph(block.base64, block);
+				return;
+			case "pageBreak":
+				this.line("\\page\\pard");
+				return;
+			case "embeddedObject":
+				this.sink({
+					code: require_diagnostics.RtfDiagnosticCodes.EMBEDDED_OBJECT_DROPPED,
+					severity: "warning",
+					message: `an embedded ${block.objectKind} object is dropped: writing it as an RTF \\object would need the OLE container this package does not build`
+				});
+				return;
+			case "constructStart":
+			case "constructEnd":
+				this.sink({
+					code: require_diagnostics.RtfDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+					severity: "warning",
+					message: `a ${block.kind} boundary marker is dropped; this writer emits no RTF construct for the fidelity-construct vocabulary`
+				});
+				return;
+			default: return;
+		}
+	}
+	writeParagraph(paragraph, inTable) {
+		this.raw("\\pard\\plain");
+		if (inTable) this.raw("\\intbl");
+		this.raw(this.paragraphProperties(paragraph));
+		this.raw(" ");
+		for (const run of paragraph.runs) this.writeRun(run);
+		if (!inTable) this.line("\\par");
+	}
+	paragraphProperties(paragraph) {
+		let out = "";
+		const level = paragraph.headingLevel === void 0 ? void 0 : (0, document_schema_js.clampHeadingLevel)(paragraph.headingLevel);
+		const styleHandle = level === void 0 ? void 0 : this.tables.headingStyles.get(level);
+		if (styleHandle !== void 0 && level !== void 0) out += `\\s${String(styleHandle)}\\outlinelevel${String(level - 1)}`;
+		const alignment = paragraph.alignment === void 0 ? void 0 : ALIGNMENT_CONTROL_WORDS.get(paragraph.alignment);
+		if (alignment !== void 0) out += alignment;
+		const list = paragraph.list;
+		if (list !== void 0) {
+			const numId = list.numId;
+			const entry = numId === void 0 ? void 0 : this.tables.lists.get(numId);
+			if (entry === void 0) this.sink({
+				code: require_diagnostics.RtfDiagnosticCodes.CONSTRUCT_UNREPRESENTED,
+				severity: "info",
+				message: "a list membership carries no numId this writer minted a list for; the paragraph keeps its indentation but no list marker"
+			});
+			else {
+				const indent = LIST_LEVEL_INDENT_TWIPS * (list.level + 1);
+				out += `\\ls${String(entry.index)}\\ilvl${String(list.level)}\\fi-${String(LIST_MARKER_HANG_TWIPS)}\\li${String(indent)}`;
+			}
+		}
+		if (paragraph.indentLeftPt !== void 0) out += `\\li${String(require_units.pointsToTwips(paragraph.indentLeftPt))}`;
+		if (paragraph.indentFirstLinePt !== void 0) out += `\\fi${String(require_units.pointsToTwips(paragraph.indentFirstLinePt))}`;
+		if (paragraph.spacingBeforePt !== void 0) out += `\\sb${String(require_units.pointsToTwips(paragraph.spacingBeforePt))}`;
+		if (paragraph.spacingAfterPt !== void 0) out += `\\sa${String(require_units.pointsToTwips(paragraph.spacingAfterPt))}`;
+		if (paragraph.lineSpacing !== void 0) out += `\\sl${String(Math.round(paragraph.lineSpacing * 240))}\\slmult1`;
+		if (paragraph.pageBreakBefore === true) out += "\\pagebb";
+		return out;
+	}
+	writeRun(run) {
+		const properties = this.runProperties(run);
+		const body = `${properties}${properties.length > 0 ? " " : ""}${escapeText(run.text)}`;
+		if (run.hyperlink === void 0) {
+			this.raw(`{${body}}`);
+			return;
+		}
+		this.raw(`{\\field{\\*\\fldinst{HYPERLINK "${escapeText(run.hyperlink)}"}}{\\fldrslt{${body}}}}`);
+	}
+	runProperties(run) {
+		let out = "";
+		const fontIndex = run.fontFamily === void 0 ? void 0 : this.tables.fonts.get(run.fontFamily);
+		if (fontIndex !== void 0 && fontIndex !== 0) out += `\\f${String(fontIndex)}`;
+		const halfPoints = run.sizePt === void 0 ? 24 : require_units.pointsToHalfPoints(run.sizePt);
+		if (halfPoints !== 24) out += `\\fs${String(halfPoints)}`;
+		if (run.bold === true) out += "\\b";
+		if (run.italic === true) out += "\\i";
+		if (run.underline === true) out += "\\ul";
+		if (run.strike === true) out += "\\strike";
+		const colorIndex = colorIndexOf(run.color, this.tables.colors);
+		if (colorIndex !== void 0) out += `\\cf${String(colorIndex)}`;
+		return out;
+	}
+	writeTable(table) {
+		for (const row of table.rows) {
+			let right = 0;
+			const boundaries = [];
+			for (let column = 0; column < row.cells.length; column += 1) {
+				right += require_units.pointsToTwips(table.columnWidthsPt[column] ?? 0);
+				boundaries.push(right);
+			}
+			const rowDefinition = `\\trowd\\trgaph108\\trleft0${boundaries.map((boundary) => `\\cellx${String(boundary)}`).join("")}`;
+			this.line(rowDefinition);
+			for (const cell of row.cells) {
+				if (cell.borders !== void 0 || cell.background !== void 0) this.sink({
+					code: require_diagnostics.RtfDiagnosticCodes.CELL_BORDER_DROPPED,
+					severity: "info",
+					message: "a table cell's borders or background are dropped; this writer emits cell boundaries only"
+				});
+				this.writeCellBlocks(cell.blocks);
+				this.raw("\\cell");
+			}
+			this.line(`${rowDefinition}\\row`);
+		}
+		this.line("\\pard");
+	}
+	writeCellBlocks(blocks) {
+		const paragraphs = blocks.filter((block) => block.kind === "paragraph");
+		if (paragraphs.length === 0) {
+			this.raw("\\pard\\plain\\intbl ");
+			return;
+		}
+		for (const [index, paragraph] of paragraphs.entries()) {
+			this.writeParagraph(paragraph, true);
+			if (index < paragraphs.length - 1) this.raw("\\par");
+		}
+	}
+	writeImageParagraph(base64, image) {
+		const bytes = require_base64.base64ToBytes(base64);
+		if (bytes === void 0 || bytes.length === 0) {
+			this.sink({
+				code: require_diagnostics.RtfDiagnosticCodes.UNSUPPORTED_PICTURE_FORMAT,
+				severity: "warning",
+				message: "an image block's base64 payload could not be decoded, so no \\pict destination is written for it"
+			});
+			return;
+		}
+		const widthTwips = require_units.pointsToTwips(image.widthPt);
+		const heightTwips = require_units.pointsToTwips(image.heightPt);
+		this.line(`\\pard\\plain {\\*\\shppict{\\pict\\${image.format === "png" ? "pngblip" : "jpegblip"}\\picwgoal${String(widthTwips)}\\pichgoal${String(heightTwips)}${this.lineEnding}${wrapHex(require_base64.bytesToHex(bytes), this.lineEnding)}}}\\par`);
+	}
+};
+function colorIndexOf(color, colors) {
+	return color === void 0 ? void 0 : colors.get((0, document_schema_js.colorToRgbHex)(color));
+}
+const HEX_LINE_LENGTH = 128;
+function wrapHex(hex, lineEnding) {
+	const lines = [];
+	for (let index = 0; index < hex.length; index += HEX_LINE_LENGTH) lines.push(hex.slice(index, index + HEX_LINE_LENGTH));
+	return lines.join(lineEnding);
+}
+function encodeAscii(text) {
+	const out = new Uint8Array(text.length);
+	for (let index = 0; index < text.length; index += 1) out[index] = text.charCodeAt(index) & 127;
+	return out;
+}
+function writeRtfContent(document, options = {}) {
+	options.signal?.throwIfAborted();
+	if (document.kind !== "wordprocessing") throw new require_diagnostics.RtfUnsupportedDocumentKindError(document.kind);
+	const sink = options.sink ?? (() => {});
+	const writer = new RtfWriter(collectTables(document), sink, options.lineEnding ?? "\n");
+	writer.writeHeader(document);
+	for (const [index, section] of document.sections.entries()) writer.writeSection(section, index === 0);
+	writer.raw("}");
+	return encodeAscii(writer.text);
+}
+function writeRtf(documentPackage, options = {}) {
+	const sink = options.sink;
+	if (sink !== void 0 && hasPackageTables(documentPackage)) sink({
+		code: require_diagnostics.RtfDiagnosticCodes.PACKAGE_TABLE_DROPPED,
+		severity: "info",
+		message: "the package's definitions/layers/attachments/destinations tables are dropped: flattening resolves style refs, and RTF has no destination for the remaining tenants"
+	});
+	return writeRtfContent((0, document_schema_js.flattenTree)(documentPackage), options);
+}
+function hasPackageTables(documentPackage) {
+	return documentPackage.definitions !== void 0 || documentPackage.layers !== void 0 || documentPackage.attachments !== void 0 || documentPackage.destinations !== void 0;
+}
+//#endregion
+exports.writeRtf = writeRtf;
+exports.writeRtfContent = writeRtfContent;

package/dist/write.d.cts

@@ -0,0 +1,7 @@
+import { WriteRtfOptions } from "./options.cjs";
+import { ContentDocument, DocumentTree } from "document-schema.js";
+//#region src/write.d.ts
+declare function writeRtfContent(document: ContentDocument, options?: WriteRtfOptions): Uint8Array<ArrayBuffer>;
+declare function writeRtf(documentPackage: DocumentTree, options?: WriteRtfOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { writeRtf, writeRtfContent };

package/dist/write.d.ts

@@ -0,0 +1,7 @@
+import { WriteRtfOptions } from "./options.js";
+import { ContentDocument, DocumentTree } from "document-schema.js";
+//#region src/write.d.ts
+declare function writeRtfContent(document: ContentDocument, options?: WriteRtfOptions): Uint8Array<ArrayBuffer>;
+declare function writeRtf(documentPackage: DocumentTree, options?: WriteRtfOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { writeRtf, writeRtfContent };