documents.js 1.57.0 → 1.58.0

package/dist/convert/local.cjs

@@ -0,0 +1,393 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_convert_convert = require("./convert.cjs");
+//#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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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 = require_convert_convert.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
+exports.createLocalDocumentConverter = createLocalDocumentConverter;

package/dist/convert/local.d.cts

@@ -0,0 +1,5 @@
+import { DocumentConverter } from "./port.cjs";
+//#region src/convert/local.d.ts
+declare function createLocalDocumentConverter(): DocumentConverter;
+//#endregion
+export { createLocalDocumentConverter };

package/dist/convert/local.d.ts

@@ -0,0 +1,5 @@
+import { DocumentConverter } from "./port.js";
+//#region src/convert/local.d.ts
+declare function createLocalDocumentConverter(): DocumentConverter;
+//#endregion
+export { createLocalDocumentConverter };