documents.js 1.57.1 → 1.58.0

package/dist/convert/local.js

@@ -0,0 +1,392 @@
+import { docxToOdt, docxToPdf, odfToPdf, odgToPdf, odpToPdf, odpToPptx, odsToPdf, odsToXlsx, odtToDocx, odtToPdf, pdfToDocx, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pptxToOdp, pptxToPdf, xlsxToOds } from "./convert.js";
+//#region src/convert/local.ts
+const SUPPORTED_CONVERSIONS = [
+	{
+		source: "docx",
+		target: "pdf"
+	},
+	{
+		source: "pptx",
+		target: "pdf"
+	},
+	{
+		source: "odt",
+		target: "pdf"
+	},
+	{
+		source: "odp",
+		target: "pdf"
+	},
+	{
+		source: "ods",
+		target: "pdf"
+	},
+	{
+		source: "odg",
+		target: "pdf"
+	},
+	{
+		source: "odf",
+		target: "pdf"
+	},
+	{
+		source: "pdf",
+		target: "docx"
+	},
+	{
+		source: "pdf",
+		target: "pptx"
+	},
+	{
+		source: "pdf",
+		target: "odt"
+	},
+	{
+		source: "pdf",
+		target: "odp"
+	},
+	{
+		source: "pdf",
+		target: "ods"
+	},
+	{
+		source: "pdf",
+		target: "odg"
+	},
+	{
+		source: "odt",
+		target: "docx"
+	},
+	{
+		source: "docx",
+		target: "odt"
+	},
+	{
+		source: "odp",
+		target: "pptx"
+	},
+	{
+		source: "pptx",
+		target: "odp"
+	},
+	{
+		source: "ods",
+		target: "xlsx"
+	},
+	{
+		source: "xlsx",
+		target: "ods"
+	}
+];
+function substitutionDiagnostic(substitution, context) {
+	return {
+		severity: "info",
+		code: "char/substituted",
+		message: `"${substitution.from}" is not representable in a standard-14 font; substituted "${substitution.to}"`,
+		pageIndex: context.pageIndex
+	};
+}
+function fromPdfDiagnostic(diagnostic) {
+	return {
+		severity: diagnostic.severity,
+		code: diagnostic.code,
+		message: diagnostic.message,
+		pageIndex: diagnostic.pageIndex
+	};
+}
+function createLocalDocumentConverter() {
+	return {
+		contractVersion: 2,
+		conversions: SUPPORTED_CONVERSIONS,
+		convert(request, options) {
+			const { source, targetFormat } = request;
+			const diagnostics = [];
+			let documentPackage;
+			const onDocument = (pkg) => {
+				documentPackage = pkg;
+			};
+			if (source.format === "docx" && targetFormat === "pdf") {
+				const bytes = docxToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pptx" && targetFormat === "pdf") {
+				const bytes = pptxToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "odt" && targetFormat === "pdf") {
+				const bytes = odtToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "odp" && targetFormat === "pdf") {
+				const bytes = odpToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "ods" && targetFormat === "pdf") {
+				const bytes = odsToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "odg" && targetFormat === "pdf") {
+				const bytes = odgToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "odf" && targetFormat === "pdf") {
+				const bytes = odfToPdf(source.bytes, {
+					signal: options.signal,
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pdf",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pdf" && targetFormat === "docx") {
+				const bytes = pdfToDocx(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "docx",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pdf" && targetFormat === "pptx") {
+				const bytes = pdfToPptx(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pptx",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pdf" && targetFormat === "odt") {
+				const bytes = pdfToOdt(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "odt",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pdf" && targetFormat === "odp") {
+				const bytes = pdfToOdp(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "odp",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pdf" && targetFormat === "ods") {
+				const bytes = pdfToOds(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "ods",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pdf" && targetFormat === "odg") {
+				const bytes = pdfToOdg(source.bytes, {
+					signal: options.signal,
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "odg",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "odt" && targetFormat === "docx") {
+				const bytes = odtToDocx(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "docx",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "docx" && targetFormat === "odt") {
+				const bytes = docxToOdt(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "odt",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "odp" && targetFormat === "pptx") {
+				const bytes = odpToPptx(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "pptx",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "pptx" && targetFormat === "odp") {
+				const bytes = pptxToOdp(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "odp",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "ods" && targetFormat === "xlsx") {
+				const bytes = odsToXlsx(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "xlsx",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			if (source.format === "xlsx" && targetFormat === "ods") {
+				const bytes = xlsxToOds(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
+				return Promise.resolve({
+					document: {
+						format: "ods",
+						bytes
+					},
+					diagnostics,
+					package: documentPackage
+				});
+			}
+			return Promise.reject(/* @__PURE__ */ new Error(`unsupported conversion: ${source.format} -> ${targetFormat}`));
+		}
+	};
+}
+//#endregion
+export { createLocalDocumentConverter };

package/dist/convert/port.d.cts

@@ -0,0 +1,34 @@
+import { DocumentPackage } from "document-schema.js";
+//#region src/convert/port.d.ts
+type DocumentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'odf' | 'pdf';
+interface DocumentPayload {
+  readonly format: DocumentFormat;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+interface Diagnostic {
+  readonly severity: 'info' | 'warning';
+  readonly code: string;
+  readonly message: string;
+  readonly pageIndex?: number;
+}
+interface ConversionRequest {
+  readonly source: DocumentPayload;
+  readonly targetFormat: DocumentFormat;
+}
+interface ConversionResult {
+  readonly document: DocumentPayload;
+  readonly diagnostics: readonly Diagnostic[];
+  readonly package?: DocumentPackage;
+}
+interface DocumentConverter {
+  readonly contractVersion: number;
+  readonly conversions: readonly {
+    readonly source: DocumentFormat;
+    readonly target: DocumentFormat;
+  }[];
+  convert(request: ConversionRequest, options: {
+    readonly signal: AbortSignal;
+  }): Promise<ConversionResult>;
+}
+//#endregion
+export { ConversionRequest, ConversionResult, Diagnostic, DocumentConverter, DocumentFormat, DocumentPayload };

package/dist/convert/port.d.ts

@@ -0,0 +1,34 @@
+import { DocumentPackage } from "document-schema.js";
+//#region src/convert/port.d.ts
+type DocumentFormat = 'docx' | 'pptx' | 'xlsx' | 'odt' | 'odp' | 'ods' | 'odg' | 'odf' | 'pdf';
+interface DocumentPayload {
+  readonly format: DocumentFormat;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+interface Diagnostic {
+  readonly severity: 'info' | 'warning';
+  readonly code: string;
+  readonly message: string;
+  readonly pageIndex?: number;
+}
+interface ConversionRequest {
+  readonly source: DocumentPayload;
+  readonly targetFormat: DocumentFormat;
+}
+interface ConversionResult {
+  readonly document: DocumentPayload;
+  readonly diagnostics: readonly Diagnostic[];
+  readonly package?: DocumentPackage;
+}
+interface DocumentConverter {
+  readonly contractVersion: number;
+  readonly conversions: readonly {
+    readonly source: DocumentFormat;
+    readonly target: DocumentFormat;
+  }[];
+  convert(request: ConversionRequest, options: {
+    readonly signal: AbortSignal;
+  }): Promise<ConversionResult>;
+}
+//#endregion
+export { ConversionRequest, ConversionResult, Diagnostic, DocumentConverter, DocumentFormat, DocumentPayload };

package/dist/edit/docx/content.cjs

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_units = require("../../model/units.cjs");
+const require_edit_docx_editor = require("./editor.cjs");
+let ooxml_js = require("ooxml.js");
+//#region src/edit/docx/content.ts
+function buildDocxPackage(content) {
+	if (content.kind !== "wordprocessing") throw new Error("buildDocxPackage requires a wordprocessing ContentDocument");
+	const editor = require_edit_docx_editor.createDocx();
+	content.sections.forEach((section, sectionIndex) => {
+		if (sectionIndex > 0) editor.body.appendPageBreak();
+		for (const block of section.blocks) appendBlock(editor.body, block);
+	});
+	return editor.toPackage();
+}
+function populateParagraph(paragraph, block) {
+	paragraph.styleId = block.styleId;
+	paragraph.alignment = block.alignment;
+	paragraph.list = block.list;
+	for (const run of block.runs) {
+		if (run.text === "	") {
+			paragraph.appendTab();
+			continue;
+		}
+		const docxRun = paragraph.appendRun({ text: run.text });
+		if (run.bold === true) docxRun.bold = true;
+		if (run.italic === true) docxRun.italic = true;
+		if (run.underline === true) docxRun.underline = true;
+		if (run.fontFamily !== void 0) docxRun.fontFamily = run.fontFamily;
+		if (run.sizePt !== void 0) docxRun.sizePt = run.sizePt;
+		if (run.color !== void 0) docxRun.color = run.color;
+	}
+}
+function appendTable(body, block) {
+	const columns = block.columnWidthsPt.length;
+	if (block.rows.length === 0 || columns === 0) return;
+	const table = body.appendTable({
+		rows: block.rows.length,
+		columns,
+		columnWidthsTwips: block.columnWidthsPt.map(require_model_units.ptToTwips)
+	});
+	block.rows.forEach((row, rowIndex) => {
+		const tableRow = table.rows()[rowIndex];
+		if (tableRow === void 0) return;
+		row.cells.forEach((cell, cellIndex) => {
+			const tableCell = tableRow.cells()[cellIndex];
+			if (tableCell === void 0) return;
+			const [firstBlock, ...restBlocks] = cell.blocks;
+			const firstParagraph = tableCell.paragraphs()[0];
+			if (firstBlock?.kind === "paragraph" && firstParagraph !== void 0) populateParagraph(firstParagraph, firstBlock);
+			else if (firstBlock !== void 0) appendCellBlock(tableCell, firstBlock);
+			for (const remaining of restBlocks) appendCellBlock(tableCell, remaining);
+		});
+	});
+}
+function appendCellBlock(cell, block) {
+	if (block.kind === "paragraph") populateParagraph(cell.appendParagraph(), block);
+}
+function appendBlock(body, block) {
+	if (block.kind === "paragraph") populateParagraph(body.appendParagraph(), block);
+	else if (block.kind === "image") body.appendParagraph().insertImageAfter({
+		format: block.format,
+		bytes: (0, ooxml_js.base64ToBytes)(block.base64),
+		widthPt: block.widthPt,
+		heightPt: block.heightPt,
+		altText: block.altText
+	});
+	else if (block.kind === "pageBreak") body.appendPageBreak();
+	else if (block.kind === "table") appendTable(body, block);
+}
+//#endregion
+exports.buildDocxPackage = buildDocxPackage;

package/dist/edit/docx/content.d.cts

@@ -0,0 +1,6 @@
+import { ContentDocument } from "../../model/content.cjs";
+import { Package } from "ooxml.js";
+//#region src/edit/docx/content.d.ts
+declare function buildDocxPackage(content: ContentDocument): Package;
+//#endregion
+export { buildDocxPackage };

package/dist/edit/docx/content.d.ts

@@ -0,0 +1,6 @@
+import { ContentDocument } from "../../model/content.js";
+import { Package } from "ooxml.js";
+//#region src/edit/docx/content.d.ts
+declare function buildDocxPackage(content: ContentDocument): Package;
+//#endregion
+export { buildDocxPackage };

package/dist/edit/docx/content.js

@@ -0,0 +1,70 @@
+import { ptToTwips } from "../../model/units.js";
+import { createDocx } from "./editor.js";
+import { base64ToBytes } from "ooxml.js";
+//#region src/edit/docx/content.ts
+function buildDocxPackage(content) {
+	if (content.kind !== "wordprocessing") throw new Error("buildDocxPackage requires a wordprocessing ContentDocument");
+	const editor = createDocx();
+	content.sections.forEach((section, sectionIndex) => {
+		if (sectionIndex > 0) editor.body.appendPageBreak();
+		for (const block of section.blocks) appendBlock(editor.body, block);
+	});
+	return editor.toPackage();
+}
+function populateParagraph(paragraph, block) {
+	paragraph.styleId = block.styleId;
+	paragraph.alignment = block.alignment;
+	paragraph.list = block.list;
+	for (const run of block.runs) {
+		if (run.text === "	") {
+			paragraph.appendTab();
+			continue;
+		}
+		const docxRun = paragraph.appendRun({ text: run.text });
+		if (run.bold === true) docxRun.bold = true;
+		if (run.italic === true) docxRun.italic = true;
+		if (run.underline === true) docxRun.underline = true;
+		if (run.fontFamily !== void 0) docxRun.fontFamily = run.fontFamily;
+		if (run.sizePt !== void 0) docxRun.sizePt = run.sizePt;
+		if (run.color !== void 0) docxRun.color = run.color;
+	}
+}
+function appendTable(body, block) {
+	const columns = block.columnWidthsPt.length;
+	if (block.rows.length === 0 || columns === 0) return;
+	const table = body.appendTable({
+		rows: block.rows.length,
+		columns,
+		columnWidthsTwips: block.columnWidthsPt.map(ptToTwips)
+	});
+	block.rows.forEach((row, rowIndex) => {
+		const tableRow = table.rows()[rowIndex];
+		if (tableRow === void 0) return;
+		row.cells.forEach((cell, cellIndex) => {
+			const tableCell = tableRow.cells()[cellIndex];
+			if (tableCell === void 0) return;
+			const [firstBlock, ...restBlocks] = cell.blocks;
+			const firstParagraph = tableCell.paragraphs()[0];
+			if (firstBlock?.kind === "paragraph" && firstParagraph !== void 0) populateParagraph(firstParagraph, firstBlock);
+			else if (firstBlock !== void 0) appendCellBlock(tableCell, firstBlock);
+			for (const remaining of restBlocks) appendCellBlock(tableCell, remaining);
+		});
+	});
+}
+function appendCellBlock(cell, block) {
+	if (block.kind === "paragraph") populateParagraph(cell.appendParagraph(), block);
+}
+function appendBlock(body, block) {
+	if (block.kind === "paragraph") populateParagraph(body.appendParagraph(), block);
+	else if (block.kind === "image") body.appendParagraph().insertImageAfter({
+		format: block.format,
+		bytes: base64ToBytes(block.base64),
+		widthPt: block.widthPt,
+		heightPt: block.heightPt,
+		altText: block.altText
+	});
+	else if (block.kind === "pageBreak") body.appendPageBreak();
+	else if (block.kind === "table") appendTable(body, block);
+}
+//#endregion
+export { buildDocxPackage };