documents.js 1.97.10 → 1.98.0

package/dist/convert/composition.cjs

@@ -0,0 +1,415 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_metadata = require("../model/metadata.cjs");
+const require_edit_docx_content = require("../edit/docx/content.cjs");
+const require_edit_pptx_content = require("../edit/pptx/content.cjs");
+const require_edit_odt_content = require("../edit/odt/content.cjs");
+const require_edit_odp_content = require("../edit/odp/content.cjs");
+const require_edit_ods_content = require("../edit/ods/content.cjs");
+const require_edit_odg_content = require("../edit/odg/content.cjs");
+const require_markdown_read = require("../markdown/read.cjs");
+const require_markdown_write = require("../markdown/write.cjs");
+const require_fonts_registry = require("../fonts/registry.cjs");
+const require_ooxml_docx_read = require("../ooxml/docx/read.cjs");
+const require_ooxml_pptx_read = require("../ooxml/pptx/read.cjs");
+const require_odf_odt_read = require("../odf/odt/read.cjs");
+const require_odf_odp_read = require("../odf/odp/read.cjs");
+const require_odf_ods_read = require("../odf/ods/read.cjs");
+const require_odf_odg_read = require("../odf/odg/read.cjs");
+const require_markdown_text = require("../markdown/text.cjs");
+const require_layout_engine = require("../layout/engine.cjs");
+const require_layout_slides = require("../layout/slides.cjs");
+const require_ports_abort = require("../ports/abort.cjs");
+const require_layout_sheets = require("../layout/sheets.cjs");
+const require_layout_drawing = require("../layout/drawing.cjs");
+const require_layout_reconstruct = require("../layout/reconstruct.cjs");
+const require_convert_variant_bridges = require("./variant-bridges.cjs");
+const require_convert_capability = require("./capability.cjs");
+let ooxml_js = require("ooxml.js");
+let document_schema_js = require("document-schema.js");
+let odf_js = require("odf.js");
+require("markdown-codec");
+let pdf_codec = require("pdf-codec");
+//#region src/convert/composition.ts
+const mathMetricsAt = (sizePt) => (0, pdf_codec.loadMathFont)().metricsAt(sizePt);
+const CONTENT_FORMATS = [
+	"docx",
+	"pptx",
+	"xlsx",
+	"odt",
+	"odp",
+	"ods",
+	"odg",
+	"markdown"
+];
+const FORMAT_NODES = {
+	docx: {
+		variant: "wordprocessing",
+		family: "ooxml",
+		decode: (bytes) => (0, ooxml_js.decodePackage)(bytes),
+		read: (pkg, options) => require_ooxml_docx_read.readDocxContent(pkg, { onMathDiagnostic: options?.onMathDiagnostic }),
+		build: (content, options) => require_edit_docx_content.buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }),
+		encode: (pkg) => (0, ooxml_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	pptx: {
+		variant: "presentation",
+		family: "ooxml",
+		decode: (bytes) => (0, ooxml_js.decodePackage)(bytes),
+		read: (pkg) => require_ooxml_pptx_read.readPptxContent(pkg),
+		build: (content) => require_edit_pptx_content.buildPptxPackage(content),
+		encode: (pkg) => (0, ooxml_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	xlsx: {
+		variant: "spreadsheet",
+		family: "ooxml",
+		decode: (bytes) => (0, ooxml_js.decodePackage)(bytes),
+		read: (pkg) => (0, ooxml_js.readXlsxContent)(pkg),
+		build: (content) => (0, ooxml_js.buildXlsxPackage)(content),
+		encode: (pkg) => (0, ooxml_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	odt: {
+		variant: "wordprocessing",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_odt_read.readOdtContent(pkg),
+		build: (content) => require_edit_odt_content.buildOdtPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	odp: {
+		variant: "presentation",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_odp_read.readOdpContent(pkg),
+		build: (content) => require_edit_odp_content.buildOdpPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	ods: {
+		variant: "spreadsheet",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_ods_read.readOdsContent(pkg),
+		build: (content) => require_edit_ods_content.buildOdsPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	odg: {
+		variant: "drawing",
+		family: "odf",
+		decode: (bytes) => (0, odf_js.decodePackage)(bytes),
+		read: (pkg) => require_odf_odg_read.readOdgContent(pkg),
+		build: (content) => require_edit_odg_content.buildOdgPackage(content),
+		encode: (pkg) => (0, odf_js.encodePackage)(pkg),
+		hasSourcePackage: true
+	},
+	markdown: {
+		variant: "wordprocessing",
+		family: "markdown",
+		decode: (bytes) => require_markdown_text.decodeMarkdownText(bytes),
+		read: (text, options) => require_markdown_read.readMarkdownContent(text, {
+			signal: options?.signal,
+			images: options?.images
+		}),
+		build: (content) => require_markdown_write.buildMarkdownText(content),
+		encode: (text) => require_markdown_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 require_convert_variant_bridges.wordprocessingToPresentation(doc);
+	},
+	"presentation->wordprocessing": (doc) => {
+		if (doc.kind !== "presentation") throw new Error("presentationToWordprocessing: expected a presentation ContentDocument");
+		return require_convert_variant_bridges.presentationToWordprocessing(doc);
+	}
+};
+const LAYOUT_ENGINES = {
+	wordprocessing: require_layout_engine.convertWordprocessingToLayout,
+	presentation: require_layout_slides.convertPresentationToLayout,
+	spreadsheet: require_layout_sheets.convertSpreadsheetToLayout,
+	drawing: require_layout_drawing.convertDrawingToLayout
+};
+const RECONSTRUCTORS = {
+	wordprocessing: require_layout_reconstruct.reconstructWordprocessing,
+	presentation: require_layout_reconstruct.reconstructPresentation,
+	drawing: require_layout_reconstruct.reconstructDrawing,
+	spreadsheet: require_layout_reconstruct.reconstructSpreadsheet
+};
+function executeBridge(source, target, bytes, options) {
+	require_ports_abort.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);
+	}
+	require_ports_abort.throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: document_schema_js.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") {
+		require_ports_abort.throwIfAborted(options?.signal);
+		const text = node.decode(bytes);
+		const read = node.read(text, options);
+		content = {
+			...read,
+			metadata: require_model_metadata.resolveMetadataTimestamps(read.metadata, options?.clock)
+		};
+		fonts = (0, pdf_codec.createFontRegistry)({
+			fonts: options?.fonts,
+			onSubstitution: options?.onFontSubstitution
+		});
+	} else {
+		const pkg = node.decode(bytes);
+		const read = node.read(pkg, options);
+		content = {
+			...read,
+			metadata: require_model_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 = require_fonts_registry.createDocumentFontRegistry(fontSource, {
+			fonts: options?.fonts,
+			onFontSubstitution: options?.onFontSubstitution
+		});
+	}
+	const measurer = (0, pdf_codec.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_schema_js.DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	if (formulas === void 0) return (0, pdf_codec.writePdf)(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		fonts
+	});
+	return (0, pdf_codec.writePdf)(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas,
+		fonts
+	});
+}
+function executeFromPdf(target, bytes, options) {
+	const node = FORMAT_NODES[target];
+	const layout = (0, pdf_codec.readPdf)(bytes, {
+		signal: options?.signal,
+		sink: options?.sink
+	});
+	const content = RECONSTRUCTORS[node.variant](layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: document_schema_js.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 require_convert_capability.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
+exports.FORMAT_NODES = FORMAT_NODES;
+exports.convertDocument = convertDocument;
+exports.resolveCompositionPlan = resolveCompositionPlan;

package/dist/convert/composition.d.cts

@@ -0,0 +1,60 @@
+import { t as ClockPort } from "../clock-C7SUuYN0.cjs";
+import { DocumentFormat } from "./port.cjs";
+import { t as ContentVariant } from "../capability-an5gSNsu.cjs";
+import { t as OmmlDiagnostic } from "../shared-DLZ3IQUl.cjs";
+import { ContentDocument, DocumentPackage, FontSubstitution, ProvidedFont } from "document-schema.js";
+import { MarkdownImageResolver } from "markdown-codec";
+import { Package } from "ooxml.js";
+import { PdfDiagnosticSink, WinAnsiSubstitution } from "pdf-codec";
+//#region src/convert/composition.d.ts
+type SourcePackage = Package;
+interface UnifiedConversionOptions {
+  readonly signal?: AbortSignal;
+  readonly onDocument?: (pkg: DocumentPackage) => void;
+  readonly fonts?: readonly ProvidedFont[];
+  readonly onFontSubstitution?: (substitution: FontSubstitution) => void;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly sink?: PdfDiagnosticSink;
+  readonly onMathDiagnostic?: (diagnostic: OmmlDiagnostic, context: {
+    readonly sourcePath?: string;
+  }) => void;
+  readonly images?: MarkdownImageResolver;
+  readonly clock?: ClockPort;
+}
+type ContentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'markdown';
+type LayoutVariant = Exclude<ContentVariant, 'formula'>;
+interface PackageFormatNode {
+  readonly variant: LayoutVariant;
+  readonly family: 'ooxml' | 'odf';
+  readonly decode: (bytes: Uint8Array<ArrayBuffer>) => SourcePackage;
+  readonly read: (pkg: SourcePackage, options?: UnifiedConversionOptions) => ContentDocument;
+  readonly build: (content: ContentDocument, options?: UnifiedConversionOptions) => SourcePackage;
+  readonly encode: (pkg: SourcePackage) => Uint8Array<ArrayBuffer>;
+  readonly hasSourcePackage: true;
+}
+interface MarkdownFormatNode {
+  readonly variant: LayoutVariant;
+  readonly family: 'markdown';
+  readonly decode: (bytes: Uint8Array<ArrayBuffer>) => string;
+  readonly read: (text: string, options?: UnifiedConversionOptions) => ContentDocument;
+  readonly build: (content: ContentDocument) => string;
+  readonly encode: (text: string) => Uint8Array<ArrayBuffer>;
+  readonly hasSourcePackage: false;
+}
+type FormatNode = PackageFormatNode | MarkdownFormatNode;
+declare const FORMAT_NODES: Readonly<Record<ContentFormat, FormatNode>>;
+type HopExecutor = 'bridge' | 'toPdf' | 'fromPdf';
+interface CompositionHop {
+  readonly executor: HopExecutor;
+  readonly from: DocumentFormat;
+  readonly to: DocumentFormat;
+}
+interface ConversionPlan {
+  readonly hops: readonly CompositionHop[];
+}
+declare function resolveCompositionPlan(source: DocumentFormat, target: DocumentFormat): ConversionPlan | undefined;
+declare function convertDocument(source: DocumentFormat, target: DocumentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { CompositionHop, ContentFormat, ConversionPlan, FORMAT_NODES, FormatNode, HopExecutor, UnifiedConversionOptions, convertDocument, resolveCompositionPlan };

package/dist/convert/composition.d.ts

@@ -0,0 +1,60 @@
+import { t as ClockPort } from "../clock-C7SUuYN0.js";
+import { DocumentFormat } from "./port.js";
+import { t as ContentVariant } from "../capability-DX0lCSiI.js";
+import { t as OmmlDiagnostic } from "../shared-DUOzjwcL.js";
+import { Package } from "ooxml.js";
+import { ContentDocument, DocumentPackage, FontSubstitution, ProvidedFont } from "document-schema.js";
+import { MarkdownImageResolver } from "markdown-codec";
+import { PdfDiagnosticSink, WinAnsiSubstitution } from "pdf-codec";
+//#region src/convert/composition.d.ts
+type SourcePackage = Package;
+interface UnifiedConversionOptions {
+  readonly signal?: AbortSignal;
+  readonly onDocument?: (pkg: DocumentPackage) => void;
+  readonly fonts?: readonly ProvidedFont[];
+  readonly onFontSubstitution?: (substitution: FontSubstitution) => void;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly sink?: PdfDiagnosticSink;
+  readonly onMathDiagnostic?: (diagnostic: OmmlDiagnostic, context: {
+    readonly sourcePath?: string;
+  }) => void;
+  readonly images?: MarkdownImageResolver;
+  readonly clock?: ClockPort;
+}
+type ContentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'markdown';
+type LayoutVariant = Exclude<ContentVariant, 'formula'>;
+interface PackageFormatNode {
+  readonly variant: LayoutVariant;
+  readonly family: 'ooxml' | 'odf';
+  readonly decode: (bytes: Uint8Array<ArrayBuffer>) => SourcePackage;
+  readonly read: (pkg: SourcePackage, options?: UnifiedConversionOptions) => ContentDocument;
+  readonly build: (content: ContentDocument, options?: UnifiedConversionOptions) => SourcePackage;
+  readonly encode: (pkg: SourcePackage) => Uint8Array<ArrayBuffer>;
+  readonly hasSourcePackage: true;
+}
+interface MarkdownFormatNode {
+  readonly variant: LayoutVariant;
+  readonly family: 'markdown';
+  readonly decode: (bytes: Uint8Array<ArrayBuffer>) => string;
+  readonly read: (text: string, options?: UnifiedConversionOptions) => ContentDocument;
+  readonly build: (content: ContentDocument) => string;
+  readonly encode: (text: string) => Uint8Array<ArrayBuffer>;
+  readonly hasSourcePackage: false;
+}
+type FormatNode = PackageFormatNode | MarkdownFormatNode;
+declare const FORMAT_NODES: Readonly<Record<ContentFormat, FormatNode>>;
+type HopExecutor = 'bridge' | 'toPdf' | 'fromPdf';
+interface CompositionHop {
+  readonly executor: HopExecutor;
+  readonly from: DocumentFormat;
+  readonly to: DocumentFormat;
+}
+interface ConversionPlan {
+  readonly hops: readonly CompositionHop[];
+}
+declare function resolveCompositionPlan(source: DocumentFormat, target: DocumentFormat): ConversionPlan | undefined;
+declare function convertDocument(source: DocumentFormat, target: DocumentFormat, bytes: Uint8Array<ArrayBuffer>, options?: UnifiedConversionOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { CompositionHop, ContentFormat, ConversionPlan, FORMAT_NODES, FormatNode, HopExecutor, UnifiedConversionOptions, convertDocument, resolveCompositionPlan };