documents.js 1.97.11 → 1.98.0

package/dist/convert/composition.js

@@ -1,2 +1,412 @@
-import { H as FORMAT_NODES, U as convertDocument, W as resolveCompositionPlan } from "../convert-ULGgwmSb.js";
+import { resolveMetadataTimestamps } from "../model/metadata.js";
+import { buildDocxPackage } from "../edit/docx/content.js";
+import { buildPptxPackage } from "../edit/pptx/content.js";
+import { buildOdtPackage } from "../edit/odt/content.js";
+import { buildOdpPackage } from "../edit/odp/content.js";
+import { buildOdsPackage } from "../edit/ods/content.js";
+import { buildOdgPackage } from "../edit/odg/content.js";
+import { readMarkdownContent } from "../markdown/read.js";
+import { buildMarkdownText } from "../markdown/write.js";
+import { createDocumentFontRegistry } from "../fonts/registry.js";
+import { readDocxContent } from "../ooxml/docx/read.js";
+import { readPptxContent } from "../ooxml/pptx/read.js";
+import { readOdtContent } from "../odf/odt/read.js";
+import { readOdpContent } from "../odf/odp/read.js";
+import { readOdsContent } from "../odf/ods/read.js";
+import { readOdgContent } from "../odf/odg/read.js";
+import { decodeMarkdownText, encodeMarkdownText } from "../markdown/text.js";
+import { convertWordprocessingToLayout } from "../layout/engine.js";
+import { convertPresentationToLayout } from "../layout/slides.js";
+import { throwIfAborted } from "../ports/abort.js";
+import { convertSpreadsheetToLayout } from "../layout/sheets.js";
+import { convertDrawingToLayout } from "../layout/drawing.js";
+import { reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing } from "../layout/reconstruct.js";
+import { presentationToWordprocessing, wordprocessingToPresentation } from "./variant-bridges.js";
+import { UnsupportedConversionError } from "./capability.js";
+import { buildXlsxPackage, decodePackage, encodePackage, readXlsxContent } from "ooxml.js";
+import { DOCUMENT_PACKAGE_FORMAT_VERSION } from "document-schema.js";
+import { decodePackage as decodePackage$1, encodePackage as encodePackage$1 } from "odf.js";
+import "markdown-codec";
+import { createFontMeasurer, createFontRegistry, loadMathFont, readPdf, writePdf } from "pdf-codec";
+//#region src/convert/composition.ts
+const mathMetricsAt = (sizePt) => loadMathFont().metricsAt(sizePt);
+const CONTENT_FORMATS = [
+	"docx",
+	"pptx",
+	"xlsx",
+	"odt",
+	"odp",
+	"ods",
+	"odg",
+	"markdown"
+];
+const FORMAT_NODES = {
+	docx: {
+		variant: "wordprocessing",
+		family: "ooxml",
+		decode: (bytes) => decodePackage(bytes),
+		read: (pkg, options) => readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic }),
+		build: (content, options) => buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }),
+		encode: (pkg) => encodePackage(pkg),
+		hasSourcePackage: true
+	},
+	pptx: {
+		variant: "presentation",
+		family: "ooxml",
+		decode: (bytes) => decodePackage(bytes),
+		read: (pkg) => readPptxContent(pkg),
+		build: (content) => buildPptxPackage(content),
+		encode: (pkg) => encodePackage(pkg),
+		hasSourcePackage: true
+	},
+	xlsx: {
+		variant: "spreadsheet",
+		family: "ooxml",
+		decode: (bytes) => decodePackage(bytes),
+		read: (pkg) => readXlsxContent(pkg),
+		build: (content) => buildXlsxPackage(content),
+		encode: (pkg) => encodePackage(pkg),
+		hasSourcePackage: true
+	},
+	odt: {
+		variant: "wordprocessing",
+		family: "odf",
+		decode: (bytes) => decodePackage$1(bytes),
+		read: (pkg) => readOdtContent(pkg),
+		build: (content) => buildOdtPackage(content),
+		encode: (pkg) => encodePackage$1(pkg),
+		hasSourcePackage: true
+	},
+	odp: {
+		variant: "presentation",
+		family: "odf",
+		decode: (bytes) => decodePackage$1(bytes),
+		read: (pkg) => readOdpContent(pkg),
+		build: (content) => buildOdpPackage(content),
+		encode: (pkg) => encodePackage$1(pkg),
+		hasSourcePackage: true
+	},
+	ods: {
+		variant: "spreadsheet",
+		family: "odf",
+		decode: (bytes) => decodePackage$1(bytes),
+		read: (pkg) => readOdsContent(pkg),
+		build: (content) => buildOdsPackage(content),
+		encode: (pkg) => encodePackage$1(pkg),
+		hasSourcePackage: true
+	},
+	odg: {
+		variant: "drawing",
+		family: "odf",
+		decode: (bytes) => decodePackage$1(bytes),
+		read: (pkg) => readOdgContent(pkg),
+		build: (content) => buildOdgPackage(content),
+		encode: (pkg) => encodePackage$1(pkg),
+		hasSourcePackage: true
+	},
+	markdown: {
+		variant: "wordprocessing",
+		family: "markdown",
+		decode: (bytes) => decodeMarkdownText(bytes),
+		read: (text, options) => readMarkdownContent(text, {
+			signal: options?.signal,
+			images: options?.images
+		}),
+		build: (content) => buildMarkdownText(content),
+		encode: (text) => encodeMarkdownText(text),
+		hasSourcePackage: false
+	}
+};
+const LAYOUT_CAPABLE = /* @__PURE__ */ new Set([
+	"docx",
+	"pptx",
+	"odt",
+	"odp",
+	"ods",
+	"odg",
+	"markdown"
+]);
+const TRANSFORMS = {
+	"wordprocessing->presentation": (doc) => {
+		if (doc.kind !== "wordprocessing") throw new Error("wordprocessingToPresentation: expected a wordprocessing ContentDocument");
+		return wordprocessingToPresentation(doc);
+	},
+	"presentation->wordprocessing": (doc) => {
+		if (doc.kind !== "presentation") throw new Error("presentationToWordprocessing: expected a presentation ContentDocument");
+		return presentationToWordprocessing(doc);
+	}
+};
+const LAYOUT_ENGINES = {
+	wordprocessing: convertWordprocessingToLayout,
+	presentation: convertPresentationToLayout,
+	spreadsheet: convertSpreadsheetToLayout,
+	drawing: convertDrawingToLayout
+};
+const RECONSTRUCTORS = {
+	wordprocessing: reconstructWordprocessing,
+	presentation: reconstructPresentation,
+	drawing: reconstructDrawing,
+	spreadsheet: reconstructSpreadsheet
+};
+function executeBridge(source, target, bytes, options) {
+	throwIfAborted(options?.signal);
+	const sourceNode = FORMAT_NODES[source];
+	const targetNode = FORMAT_NODES[target];
+	let content;
+	if (sourceNode.family === "markdown") {
+		const text = sourceNode.decode(bytes);
+		content = sourceNode.read(text, options);
+	} else {
+		const pkg = sourceNode.decode(bytes);
+		content = sourceNode.read(pkg, options);
+	}
+	if (content.kind !== sourceNode.variant) throw new Error(`executeBridge: ${source} read returned a non-${sourceNode.variant} ContentDocument`);
+	let buildContent = content;
+	if (sourceNode.variant !== targetNode.variant) {
+		const key = `${sourceNode.variant}->${targetNode.variant}`;
+		const transform = TRANSFORMS[key];
+		if (transform === void 0) throw new Error(`executeBridge: no transform registered for ${key}`);
+		buildContent = transform(content);
+	}
+	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content: buildContent
+	});
+	if (targetNode.family === "markdown") {
+		const text = targetNode.build(buildContent);
+		return targetNode.encode(text);
+	}
+	const pkg = targetNode.build(buildContent, options);
+	return targetNode.encode(pkg);
+}
+function executeToPdf(format, bytes, options) {
+	if (!LAYOUT_CAPABLE.has(format)) throw new Error(`executeToPdf: '${format}' has no layout engine of its own`);
+	const node = FORMAT_NODES[format];
+	let content;
+	let fonts;
+	if (node.family === "markdown") {
+		throwIfAborted(options?.signal);
+		const text = node.decode(bytes);
+		const read = node.read(text, options);
+		content = {
+			...read,
+			metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		fonts = createFontRegistry({
+			fonts: options?.fonts,
+			onSubstitution: options?.onFontSubstitution
+		});
+	} else {
+		const pkg = node.decode(bytes);
+		const read = node.read(pkg, options);
+		content = {
+			...read,
+			metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		const fontSource = node.family === "odf" ? {
+			kind: "odf",
+			package: pkg
+		} : format === "pptx" ? {
+			kind: "pptx",
+			package: pkg
+		} : {
+			kind: "docx",
+			package: pkg
+		};
+		fonts = createDocumentFontRegistry(fontSource, {
+			fonts: options?.fonts,
+			onFontSubstitution: options?.onFontSubstitution
+		});
+	}
+	const measurer = createFontMeasurer(fonts);
+	let layout;
+	let formulas;
+	switch (content.kind) {
+		case "wordprocessing": {
+			const result = LAYOUT_ENGINES.wordprocessing(content, {
+				measurer,
+				mathMetricsAt
+			});
+			layout = result.document;
+			formulas = result.formulas;
+			break;
+		}
+		case "presentation": {
+			const result = LAYOUT_ENGINES.presentation(content, {
+				measurer,
+				mathMetricsAt
+			});
+			layout = result.document;
+			formulas = result.formulas;
+			break;
+		}
+		case "spreadsheet": {
+			const result = LAYOUT_ENGINES.spreadsheet(content, {
+				measurer,
+				mathMetricsAt,
+				signal: options?.signal
+			});
+			layout = result.document;
+			formulas = result.formulas;
+			break;
+		}
+		case "drawing":
+			layout = LAYOUT_ENGINES.drawing(content, { measurer });
+			break;
+		default: throw new Error(`executeToPdf: cannot lay out a '${content.kind}' document`);
+	}
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	if (formulas === void 0) return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		fonts
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas,
+		fonts
+	});
+}
+function executeFromPdf(target, bytes, options) {
+	const node = FORMAT_NODES[target];
+	const layout = readPdf(bytes, {
+		signal: options?.signal,
+		sink: options?.sink
+	});
+	const content = RECONSTRUCTORS[node.variant](layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	if (node.family === "markdown") {
+		const text = node.build(content);
+		return node.encode(text);
+	}
+	const pkg = node.build(content);
+	return node.encode(pkg);
+}
+function buildCompositionGraph() {
+	const adj = /* @__PURE__ */ new Map();
+	const addDirected = (from, to, cost) => {
+		const list = adj.get(from);
+		if (list === void 0) adj.set(from, [{
+			to,
+			cost
+		}]);
+		else list.push({
+			to,
+			cost
+		});
+	};
+	const addEdge = (from, to, cost) => {
+		addDirected(from, to, cost);
+		addDirected(to, from, cost);
+	};
+	for (const a of CONTENT_FORMATS) for (const b of CONTENT_FORMATS) {
+		if (a === b) continue;
+		if (FORMAT_NODES[a].variant === FORMAT_NODES[b].variant) addEdge(a, b, 1);
+	}
+	for (const key of Object.keys(TRANSFORMS)) {
+		const parts = key.split("->");
+		const fromVariant = parts[0];
+		const toVariant = parts[1];
+		if (fromVariant === void 0 || toVariant === void 0) continue;
+		for (const a of CONTENT_FORMATS) {
+			if (FORMAT_NODES[a].variant !== fromVariant) continue;
+			for (const b of CONTENT_FORMATS) {
+				if (FORMAT_NODES[b].variant !== toVariant) continue;
+				addEdge(a, b, 2);
+			}
+		}
+	}
+	for (const format of CONTENT_FORMATS) if (LAYOUT_CAPABLE.has(format)) addEdge(format, "pdf", 3);
+	return adj;
+}
+const COMPOSITION_GRAPH = buildCompositionGraph();
+function shortestPath(source, target) {
+	if (source === target) return;
+	const distances = /* @__PURE__ */ new Map([[source, 0]]);
+	const previous = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	while (true) {
+		let current = void 0;
+		let currentDist = Infinity;
+		for (const [node, dist] of distances) if (!visited.has(node) && dist < currentDist) {
+			current = node;
+			currentDist = dist;
+		}
+		if (current === void 0 || current === target) break;
+		visited.add(current);
+		for (const edge of COMPOSITION_GRAPH.get(current) ?? []) {
+			if (visited.has(edge.to)) continue;
+			const alt = currentDist + edge.cost;
+			const known = distances.get(edge.to);
+			if (known === void 0 || alt < known) {
+				distances.set(edge.to, alt);
+				previous.set(edge.to, current);
+			}
+		}
+	}
+	if (distances.get(target) === void 0) return;
+	const path = [];
+	let cursor = target;
+	while (cursor !== void 0) {
+		path.unshift(cursor);
+		cursor = previous.get(cursor);
+	}
+	return path;
+}
+function resolveCompositionPlan(source, target) {
+	const path = shortestPath(source, target);
+	if (path === void 0) return;
+	if (path.length > 4) return;
+	const hops = [];
+	for (let i = 0; i + 1 < path.length; i++) {
+		const from = path[i];
+		const to = path[i + 1];
+		if (from === void 0 || to === void 0) return;
+		const executor = to === "pdf" ? "toPdf" : from === "pdf" ? "fromPdf" : "bridge";
+		hops.push({
+			executor,
+			from,
+			to
+		});
+	}
+	return { hops };
+}
+function isContentFormat(format) {
+	return format !== "pdf" && format !== "odf";
+}
+function convertDocument(source, target, bytes, options) {
+	const plan = resolveCompositionPlan(source, target);
+	if (plan === void 0) throw new UnsupportedConversionError(source, target);
+	let current = bytes;
+	for (let i = 0; i < plan.hops.length; i++) {
+		const hop = plan.hops[i];
+		if (hop === void 0) throw new Error("convertDocument: resolveCompositionPlan returned a malformed hop");
+		const hopOptions = i === plan.hops.length - 1 ? options : options === void 0 ? void 0 : {
+			...options,
+			onDocument: void 0
+		};
+		if (hop.executor === "toPdf") {
+			if (!isContentFormat(hop.from)) throw new Error(`convertDocument: toPdf source '${hop.from}' is not a content format`);
+			current = executeToPdf(hop.from, current, hopOptions);
+		} else if (hop.executor === "fromPdf") {
+			if (!isContentFormat(hop.to)) throw new Error(`convertDocument: fromPdf target '${hop.to}' is not a content format`);
+			current = executeFromPdf(hop.to, current, hopOptions);
+		} else {
+			if (!isContentFormat(hop.from) || !isContentFormat(hop.to)) throw new Error(`convertDocument: bridge endpoints '${hop.from}' -> '${hop.to}' are not both content formats`);
+			current = executeBridge(hop.from, hop.to, current, hopOptions);
+		}
+	}
+	return current;
+}
+//#endregion
 export { FORMAT_NODES, convertDocument, resolveCompositionPlan };