document-cli 1.4.0 → 1.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError, OdbNoEmbeddedDataSourceError, OdbReportNotSpecifiedError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, UnrecognizedDocumentSchemaError, buildDocxPackage, buildMarkdownText, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, convertWordprocessingToLayout, createFontMeasurer, createFontRegistry, createLocalDocumentConverter, decodePackage, documentFromJson, documentPackageWithSchema, encodeMarkdownText, encodePackage, evaluateSelect, extractSourceFonts, hsqldbCellDisplayText, layoutDocumentWithSchema, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocxExtras, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readPdf, writePdf } from "documents.js";
+import { HsqldbSqlEvaluationError, HsqldbSqlParseError, HsqldbSqlUnsupportedError, OdbNoEmbeddedDataSourceError, OdbReportNotSpecifiedError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdmUnresolvedSectionError, PdfEncryptedError, PdfParseError, UnrecognizedDocumentSchemaError, buildDocxPackage, buildMarkdownText, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, convertWordprocessingToLayout, createFontMeasurer, createFontRegistry, createLocalDocumentConverter, decodeMarkdownText, decodePackage, documentFromJson, documentPackageWithSchema, encodeMarkdownText, encodePackage, evaluateSelect, extractSourceFonts, hsqldbCellDisplayText, layoutDocumentWithSchema, odbToCsv, odbToXlsx, odmToPdf, parseSelect, readDocxContent, readDocxExtras, readMarkdownContent, readOdbForms, readOdbInventory, readOdbReportContent, readOdbReports, readOdbTables, readOdfFormulaContent, readOdgContent, readOdpContent, readOdsContent, readOdtContent, readPdf, readPptxContent, writePdf, xlsxToPdf } from "documents.js";
 import { basename, dirname, extname, join } from "node:path";
 import { Command, InvalidArgumentError } from "commander";
 import { decodePackage as decodePackage$1, encodePackage as encodePackage$1 } from "odf.js";
@@ -683,7 +683,7 @@ function registerFontsCommand(program) {
 }
 //#endregion
 //#region src/commands/formats.ts
-const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, odb-forms, odb-reports, pdf-inspect, from-package, fonts, docx-extras";
+const COMMANDS_NOT_LISTED = "odm-to-pdf, odb-to-csv, odb-to-xlsx, odb-tables, odb-forms, odb-reports, pdf-inspect, from-package, fonts, docx-extras, metadata, set-metadata";
 function registerFormatsCommand(program) {
 	program.command("formats").description("list every source -> target conversion this CLI supports via a <source>-to-<target> command").option("--json", "emit the conversion list as a JSON array instead of a human-readable table", false).action((options) => {
 		const { conversions } = createLocalDocumentConverter();
@@ -776,6 +776,78 @@ function registerFromPackageCommand(program) {
 	});
 }
 //#endregion
+//#region src/runtime/metadata-format.ts
+const METADATA_KEYS = [
+	"title",
+	"author",
+	"subject",
+	"keywords",
+	"creator",
+	"producer",
+	"createdIso",
+	"modifiedIso"
+];
+function isPresent(entry) {
+	return entry[1] !== void 0;
+}
+function formatMetadataValue(value) {
+	return typeof value === "string" ? value : value.join(", ");
+}
+function presentMetadataEntries(metadata) {
+	return METADATA_KEYS.map((key) => [key, metadata[key]]).filter(isPresent);
+}
+function formatMetadataLines(metadata) {
+	return presentMetadataEntries(metadata).map(([key, value]) => `${key}: ${formatMetadataValue(value)}`);
+}
+//#endregion
+//#region src/commands/metadata.ts
+function readMetadataForFormat(format, bytes, signal) {
+	switch (format) {
+		case "docx": return readDocxContent(decodePackage(bytes)).metadata;
+		case "pptx": return readPptxContent(decodePackage(bytes)).metadata;
+		case "odt": return readOdtContent(decodePackage$1(bytes)).metadata;
+		case "odp": return readOdpContent(decodePackage$1(bytes)).metadata;
+		case "ods": return readOdsContent(decodePackage$1(bytes)).metadata;
+		case "odg": return readOdgContent(decodePackage$1(bytes)).metadata;
+		case "odf": return readOdfFormulaContent(decodePackage$1(bytes)).metadata;
+		case "markdown": return readMarkdownContent(decodeMarkdownText(bytes)).metadata;
+		case "pdf": return readPdf(bytes, { signal }).metadata;
+		case "xlsx": return readPdf(xlsxToPdf(bytes, { signal }), { signal }).metadata;
+	}
+}
+async function runMetadata(input, options) {
+	const command = "metadata";
+	const source = inferFormatFromExtension(input);
+	if (source === void 0) {
+		process.stderr.write(`[${command}] cannot infer a source format from '${input}'; rename the file with a recognised extension (${KNOWN_DOCUMENT_FORMATS})\n`);
+		return 2;
+	}
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const metadata = readMetadataForFormat(source, new Uint8Array(inputBytes), signal);
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(metadata)}\n`);
+			return 0;
+		}
+		const lines = formatMetadataLines(metadata);
+		if (lines.length === 0) {
+			process.stdout.write("This document carries no metadata.\n");
+			return 0;
+		}
+		for (const line of lines) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		process.stderr.write(`[${command}] ${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerMetadataCommand(program) {
+	program.command("metadata <input>").description(`print a document's own title/author/subject/keywords/creator/producer/created/modified metadata (${KNOWN_DOCUMENT_FORMATS})`).option("--json", "emit the metadata as a JSON object instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runMetadata(input, options);
+	});
+}
+//#endregion
 //#region src/odb-structure.ts
 const INDENT = "  ";
 function indent(depth) {
@@ -1379,12 +1451,6 @@ function countImagesByFormat(images) {
 	for (const asset of Object.values(images)) counts.set(asset.format, (counts.get(asset.format) ?? 0) + 1);
 	return counts;
 }
-function isPresent(entry) {
-	return entry[1] !== void 0;
-}
-function formatMetadataValue(value) {
-	return typeof value === "string" ? value : value.join(", ");
-}
 async function runPdfInspect(input, options) {
 	const command = "pdf-inspect";
 	const { signal, getAbortReason } = createRuntimeSignal({});
@@ -1426,19 +1492,9 @@ async function runPdfInspect(input, options) {
 			const histogramText = Array.from(histogram.entries()).map(([kind, count]) => `${kind}=${count}`).join(", ");
 			process.stdout.write(`  page ${index + 1}: ${page.widthPt}pt x ${page.heightPt}pt${histogramText === "" ? "" : ` (${histogramText})`}\n`);
 		});
-		const presentMetadata = [
-			["title", layout.metadata.title],
-			["author", layout.metadata.author],
-			["subject", layout.metadata.subject],
-			["keywords", layout.metadata.keywords],
-			["creator", layout.metadata.creator],
-			["producer", layout.metadata.producer],
-			["createdIso", layout.metadata.createdIso],
-			["modifiedIso", layout.metadata.modifiedIso]
-		].filter(isPresent);
-		if (presentMetadata.length > 0) {
+		if (presentMetadataEntries(layout.metadata).length > 0) {
 			process.stdout.write("metadata:\n");
-			for (const [key, value] of presentMetadata) process.stdout.write(`  ${key}: ${formatMetadataValue(value)}\n`);
+			for (const line of formatMetadataLines(layout.metadata)) process.stdout.write(`  ${line}\n`);
 		}
 		if (imagesByFormat.size > 0) {
 			process.stdout.write("images:\n");
@@ -1456,8 +1512,155 @@ function registerPdfInspectCommand(program) {
 	});
 }
 //#endregion
+//#region src/commands/set-metadata.ts
+const REBUILD_FORMATS = {
+	docx: true,
+	pptx: true,
+	odt: true,
+	odp: true,
+	ods: true,
+	odg: true,
+	markdown: true
+};
+function isRebuildFormat(format) {
+	return format in REBUILD_FORMATS;
+}
+function readContentForFormat(format, bytes) {
+	switch (format) {
+		case "docx": return readDocxContent(decodePackage(bytes));
+		case "pptx": return readPptxContent(decodePackage(bytes));
+		case "odt": return readOdtContent(decodePackage$1(bytes));
+		case "odp": return readOdpContent(decodePackage$1(bytes));
+		case "ods": return readOdsContent(decodePackage$1(bytes));
+		case "odg": return readOdgContent(decodePackage$1(bytes));
+		case "markdown": return readMarkdownContent(decodeMarkdownText(bytes));
+	}
+}
+function buildBytesForRebuildFormat(format, content) {
+	switch (format) {
+		case "docx": return encodePackage(buildDocxPackage(content));
+		case "pptx": return encodePackage(buildPptxPackage(content));
+		case "odt": return encodePackage$1(buildOdtPackage(content));
+		case "odp": return encodePackage$1(buildOdpPackage(content));
+		case "ods": return encodePackage$1(buildOdsPackage(content));
+		case "odg": return encodePackage$1(buildOdgPackage(content));
+		case "markdown": return encodeMarkdownText(buildMarkdownText(content));
+	}
+}
+function mergeMetadata(current, overrides) {
+	return {
+		...current,
+		...overrides.title !== void 0 ? { title: overrides.title } : {},
+		...overrides.author !== void 0 ? { author: overrides.author } : {},
+		...overrides.subject !== void 0 ? { subject: overrides.subject } : {},
+		...overrides.keywords !== void 0 ? { keywords: overrides.keywords } : {}
+	};
+}
+function parseKeywords(csv) {
+	return csv.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function classifyWritePath(source, target) {
+	if (source === "pdf" && target === "pdf") return { kind: "pdf" };
+	if (target === "xlsx" || source === "xlsx") return { errorMessage: "'xlsx' is not a supported set-metadata source or target -- documents.js does not re-export a ContentDocument-to-xlsx builder or a readXlsxContent from its own public surface (see that package's own README, Architecture section); convert with 'xlsx-to-ods'/'ods-to-xlsx' first, then set metadata on the ods" };
+	if (target === "odf" || source === "odf") return { errorMessage: "'odf' (a standalone formula document) is not a supported set-metadata source or target -- it has no write path back out at all" };
+	if (!isRebuildFormat(source) || !isRebuildFormat(target)) return { errorMessage: `set-metadata only patches metadata in place; it does not convert format -- source ('${source}') and target ('${target}') must be the same format (or both 'pdf'). Run 'convert'/'from-package' first if you need a different target format.` };
+	if (source !== target) return { errorMessage: `set-metadata only patches metadata in place; it does not convert format -- source ('${source}') and target ('${target}') must be the same format. Run 'convert'/'from-package' first if you need a different target format.` };
+	return {
+		kind: "rebuild",
+		format: source
+	};
+}
+async function runSetMetadata(input, output, options) {
+	const command = "set-metadata";
+	if (output !== void 0 && options.out !== void 0 && output !== options.out) {
+		process.stderr.write(`[${command}] conflicting output destinations: positional '${output}' and --out '${options.out}'\n`);
+		return 2;
+	}
+	const target = resolveTargetFormat(output, options.out, options.to);
+	if ("errorMessage" in target) {
+		process.stderr.write(`[${command}] ${target.errorMessage}\n`);
+		return 2;
+	}
+	const source = inferFormatFromExtension(input);
+	if (source === void 0) {
+		process.stderr.write(`[${command}] cannot infer a source format from '${input}'; rename the file with a recognised extension (${KNOWN_DOCUMENT_FORMATS})\n`);
+		return 2;
+	}
+	const writePath = classifyWritePath(source, target.format);
+	if ("errorMessage" in writePath) {
+		process.stderr.write(`[${command}] ${writePath.errorMessage}\n`);
+		return 2;
+	}
+	const overrides = {
+		title: options.setTitle,
+		author: options.setAuthor,
+		subject: options.setSubject,
+		keywords: options.setKeywords === void 0 ? void 0 : parseKeywords(options.setKeywords)
+	};
+	const resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, target.format));
+	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const bytes = writePath.kind === "pdf" ? (() => {
+			const layout = readPdf(new Uint8Array(inputBytes), { signal });
+			const patched = {
+				...layout,
+				metadata: mergeMetadata(layout.metadata, overrides)
+			};
+			return writePdf(patched, { signal });
+		})() : (() => {
+			const content = readContentForFormat(writePath.format, new Uint8Array(inputBytes));
+			const nextContent = {
+				...content,
+				metadata: mergeMetadata(content.metadata, overrides)
+			};
+			return buildBytesForRebuildFormat(writePath.format, nextContent);
+		})();
+		await writeOutput(resolvedOutput, bytes);
+		createDiagnosticReporter({
+			json: options.json,
+			quiet: options.quiet,
+			command
+		}).summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount: 0
+		});
+		return 0;
+	} catch (error) {
+		process.stderr.write(`${formatError(error, options.verbose)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerSetMetadataCommand(program) {
+	const command = program.command("set-metadata <input> [output]").description("patch a document's own title/author/subject/keywords, leaving every other field and every other flag as-is").addHelpText("after", [
+		"",
+		"Two write paths: a pdf source/target patches the metadata directly on the parsed PDF (writePdf), with no layout engine",
+		"involved at all -- genuinely lossless for everything else on the page. Every other supported format (docx, pptx, odt,",
+		"odp, ods, odg, markdown) rebuilds a fresh package from that format's own ContentDocument -- for docx specifically,",
+		"this is LOSSY: it drops anything docx-extras covers (comments, footnotes, headers/footers, numbering definitions),",
+		"since buildDocxPackage builds a fresh package from the ContentDocument alone, with no way to carry that data through.",
+		"",
+		"set-metadata does not convert format -- source and target must match. Run convert/from-package first, then",
+		"set-metadata on the result, if you need a different target format."
+	].join("\n"));
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	command.option("--to <format>", `target format when it cannot be inferred from the output path (${KNOWN_DOCUMENT_FORMATS})`);
+	command.option("--set-title <text>", "set the title field");
+	command.option("--set-author <text>", "set the author field");
+	command.option("--set-subject <text>", "set the subject field");
+	command.option("--set-keywords <csv>", "set the keywords field, comma-separated (trimmed, empty entries dropped)");
+	command.action(async (input, output, options) => {
+		process.exitCode = await runSetMetadata(input, output, options);
+	});
+}
+//#endregion
 //#region package.json
-var version = "1.4.0";
+var version = "1.6.0";
 //#endregion
 //#region src/program.ts
 function createProgram() {
@@ -1476,6 +1679,8 @@ function createProgram() {
 	registerPdfInspectCommand(program);
 	registerFontsCommand(program);
 	registerDocxExtrasCommand(program);
+	registerMetadataCommand(program);
+	registerSetMetadataCommand(program);
 	return program;
 }
 //#endregion

package/dist/{odb-structure-DkfNyHGR.js → odb-structure-Du1w_hOU.js}

@@ -305,6 +305,30 @@ function formatDocxExtrasLines(extras) {
 	return nonEmptySections.flatMap((section, index) => index === 0 ? section : ["", ...section]);
 }
 //#endregion
+//#region src/runtime/metadata-format.ts
+const METADATA_KEYS = [
+	"title",
+	"author",
+	"subject",
+	"keywords",
+	"creator",
+	"producer",
+	"createdIso",
+	"modifiedIso"
+];
+function isPresent(entry) {
+	return entry[1] !== void 0;
+}
+function formatMetadataValue(value) {
+	return typeof value === "string" ? value : value.join(", ");
+}
+function presentMetadataEntries(metadata) {
+	return METADATA_KEYS.map((key) => [key, metadata[key]]).filter(isPresent);
+}
+function formatMetadataLines(metadata) {
+	return presentMetadataEntries(metadata).map(([key, value]) => `${key}: ${formatMetadataValue(value)}`);
+}
+//#endregion
 //#region src/odb-structure.ts
 const INDENT = "  ";
 function indent(depth) {
@@ -437,4 +461,4 @@ function formatOdbReportLines(report) {
 	return lines;
 }
 //#endregion
-export { odbFormSummary as a, resolveDefaultOutputPath as c, formatToExtension as d, inferFormatFromExtension as f, formatOdbReportLines as i, writeOutput as l, describeOdbReport as n, formatDocxExtrasLines as o, isDocumentFormat as p, formatOdbFormLines as r, readInput as s, describeOdbForm as t, loadProvidedFonts as u };
+export { odbFormSummary as a, formatDocxExtrasLines as c, writeOutput as d, loadProvidedFonts as f, isDocumentFormat as h, formatOdbReportLines as i, readInput as l, inferFormatFromExtension as m, describeOdbReport as n, formatMetadataLines as o, formatToExtension as p, formatOdbFormLines as r, presentMetadataEntries as s, describeOdbForm as t, resolveDefaultOutputPath as u };