document-cli 1.2.11 → 1.4.0

package/dist/index.cjs

@@ -162,7 +162,8 @@ const EXIT_INTERRUPTED = 130;
 function mapErrorToExit(error, abortReason) {
 	if (abortReason === "interrupt") return 130;
 	if (abortReason === "timeout") return 124;
-	if (error instanceof documents_js.OdmUnresolvedSectionError || error instanceof documents_js.OdbTableNotSpecifiedError || error instanceof documents_js.OdbTableNotFoundError || error instanceof documents_js.OdbNoEmbeddedDataSourceError || error instanceof documents_js.OdbUnsupportedFormatError) return 3;
+	if (error instanceof documents_js.OdmUnresolvedSectionError || error instanceof documents_js.OdbTableNotSpecifiedError || error instanceof documents_js.OdbTableNotFoundError || error instanceof documents_js.OdbNoEmbeddedDataSourceError || error instanceof documents_js.OdbUnsupportedFormatError || error instanceof documents_js.OdbReportNotSpecifiedError) return 3;
+	if (error instanceof documents_js.HsqldbSqlUnsupportedError || error instanceof documents_js.HsqldbSqlParseError || error instanceof documents_js.HsqldbSqlEvaluationError) return 1;
 	if (error instanceof documents_js.PdfEncryptedError || error instanceof documents_js.PdfParseError) return 1;
 	return 1;
 }
@@ -532,8 +533,158 @@ function registerConversionCommands(program) {
 	});
 }
 //#endregion
+//#region src/docx-extras-format.ts
+const INDENT$1 = "  ";
+function indent$1(depth) {
+	return INDENT$1.repeat(depth);
+}
+function commentLine(comment, position) {
+	const author = comment.author ?? "(no author)";
+	return `${indent$1(1)}[${position}] ${author}: ${comment.text}`;
+}
+function footnoteLine(footnote, position) {
+	const typeSuffix = footnote.type === void 0 ? "" : ` (${footnote.type})`;
+	return `${indent$1(1)}[${position}]${typeSuffix} ${footnote.text}`;
+}
+function commentsSection(comments) {
+	if (comments.length === 0) return [];
+	return ["comments", ...comments.map((comment, index) => commentLine(comment, index + 1))];
+}
+function footnotesSection(footnotes) {
+	if (footnotes.length === 0) return [];
+	return ["footnotes", ...footnotes.map((footnote, index) => footnoteLine(footnote, index + 1))];
+}
+function headerOrFooterSection(label, values) {
+	if (values.length === 0) return [];
+	return [label, ...values.map((text, index) => `${indent$1(1)}[${index + 1}] ${text}`)];
+}
+function numberingLevelLine(ilvl, level) {
+	const restartSuffix = level.restart === void 0 ? "" : `, restarts at level ${level.restart}`;
+	return `${indent$1(2)}level ${ilvl}: ${level.format} ${JSON.stringify(level.text)} starting at ${level.startAt}${restartSuffix}`;
+}
+function numberingSection(numbering) {
+	const numIds = Object.keys(numbering);
+	if (numIds.length === 0) return [];
+	const lines = ["numbering"];
+	for (const numId of numIds) {
+		const definition = numbering[numId];
+		if (definition === void 0) continue;
+		lines.push(`${indent$1(1)}numId ${numId}`);
+		const ilvls = Object.keys(definition.levels).sort((a, b) => Number(a) - Number(b));
+		for (const ilvl of ilvls) {
+			const level = definition.levels[ilvl];
+			if (level === void 0) continue;
+			lines.push(numberingLevelLine(ilvl, level));
+		}
+	}
+	return lines;
+}
+function formatDocxExtrasLines(extras) {
+	const nonEmptySections = [
+		commentsSection(extras.comments),
+		footnotesSection(extras.footnotes),
+		headerOrFooterSection("headers", extras.headers),
+		headerOrFooterSection("footers", extras.footers),
+		numberingSection(extras.numbering)
+	].filter((section) => section.length > 0);
+	if (nonEmptySections.length === 0) return ["This document carries no comments, footnotes, headers, footers, or numbering definitions."];
+	return nonEmptySections.flatMap((section, index) => index === 0 ? section : ["", ...section]);
+}
+//#endregion
+//#region src/commands/docx-extras.ts
+async function runDocxExtras(input, options) {
+	const command = "docx-extras";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const pkg = (0, documents_js.decodePackage)(new Uint8Array(inputBytes));
+		const extras = (0, documents_js.readDocxExtras)(pkg);
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(extras)}\n`);
+			return 0;
+		}
+		for (const line of formatDocxExtrasLines(extras)) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		process.stderr.write(`[${command}] ${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerDocxExtrasCommand(program) {
+	program.command("docx-extras <input>").description("print a docx's own comments, footnotes, headers, footers, and numbering definitions -- data readDocxContent's ContentDocument cannot carry").option("--json", "emit the raw DocxExtras object as JSON instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runDocxExtras(input, options);
+	});
+}
+//#endregion
+//#region src/commands/fonts.ts
+const FONT_SOURCE_FORMATS = {
+	docx: true,
+	pptx: true,
+	odt: true,
+	odp: true,
+	ods: true,
+	odg: true
+};
+function isFontSourceFormat(format) {
+	return format in FONT_SOURCE_FORMATS;
+}
+function resolveFontSourcePackage(format, bytes) {
+	if (format === "docx" || format === "pptx") return {
+		kind: format,
+		package: (0, documents_js.decodePackage)(bytes)
+	};
+	return {
+		kind: "odf",
+		package: (0, odf_js.decodePackage)(bytes)
+	};
+}
+async function runFonts(input, options) {
+	const command = "fonts";
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const format = inferFormatFromExtension(input);
+		if (format === void 0) {
+			process.stderr.write(`[${command}] cannot infer a document format from '${input}'; expected one of docx, pptx, odt, odp, ods, odg\n`);
+			return 2;
+		}
+		if (!isFontSourceFormat(format)) {
+			process.stderr.write(`[${command}] '${format}' documents carry no source-embedded font faces this command can extract; expected one of docx, pptx, odt, odp, ods, odg\n`);
+			return 2;
+		}
+		const inputBytes = await readInput(input, { signal });
+		const source = resolveFontSourcePackage(format, new Uint8Array(inputBytes));
+		const summaries = (0, documents_js.extractSourceFonts)(source).map((face) => ({
+			family: face.family,
+			bold: face.bold,
+			italic: face.italic,
+			byteLength: face.bytes.length
+		}));
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(summaries)}\n`);
+			return 0;
+		}
+		if (summaries.length === 0) {
+			process.stdout.write("This document embeds no source fonts.\n");
+			return 0;
+		}
+		for (const face of summaries) {
+			const style = [face.bold ? "bold" : void 0, face.italic ? "italic" : void 0].filter((value) => value !== void 0).join(" ");
+			process.stdout.write(`${face.family}${style === "" ? "" : ` (${style})`} -- ${face.byteLength} bytes\n`);
+		}
+		return 0;
+	} catch (error) {
+		process.stderr.write(`${formatError(error, false)}\n`);
+		return mapErrorToExit(error, getAbortReason());
+	}
+}
+function registerFontsCommand(program) {
+	program.command("fonts <input>").description("list every source-embedded font face a docx/pptx/odt/odp/ods/odg document carries (family, weight/style, byte length)").option("--json", "emit the face list as a JSON array instead of a human-readable report", false).action(async (input, options) => {
+		process.exitCode = await runFonts(input, options);
+	});
+}
+//#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";
+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";
 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 } = (0, documents_js.createLocalDocumentConverter)();
@@ -758,6 +909,27 @@ function formatOdbReportLines(report) {
 	return lines;
 }
 //#endregion
+//#region src/sql-result-format.ts
+const COLUMN_GAP = "  ";
+function columnWidths(columns, cells) {
+	return columns.map((column, index) => {
+		const cellWidths = cells.map((row) => row[index]?.length ?? 0);
+		return Math.max(column.length, ...cellWidths);
+	});
+}
+function formatRow(values, widths) {
+	return values.map((value, index) => value.padEnd(widths[index] ?? value.length)).join(COLUMN_GAP).trimEnd();
+}
+function formatSqlResultSetTable(result) {
+	const { columns, rows } = result;
+	const cells = rows.map((row) => row.map((value) => (0, documents_js.hsqldbCellDisplayText)(value)));
+	const widths = columnWidths(columns, cells);
+	const lines = [formatRow(columns, widths), formatRow(widths.map((width) => "-".repeat(width)), widths)];
+	for (const row of cells) lines.push(formatRow(row, widths));
+	lines.push(`${rows.length} row${rows.length === 1 ? "" : "s"}`);
+	return lines;
+}
+//#endregion
 //#region src/commands/odb.ts
 function reportOdbError(command, error, verbose, abortReason) {
 	if (error instanceof documents_js.OdbNoEmbeddedDataSourceError || error instanceof documents_js.OdbUnsupportedFormatError) {
@@ -774,6 +946,13 @@ function reportOdbCsvError(command, error, verbose, abortReason) {
 	}
 	return reportOdbError(command, error, verbose, abortReason);
 }
+function reportOdbReportError(command, error, verbose, abortReason) {
+	if (error instanceof documents_js.OdbReportNotSpecifiedError) {
+		process.stderr.write(`[${command}] ${error.message}\nrun 'odb-reports' first to see the available reports\n`);
+		return mapErrorToExit(error, abortReason);
+	}
+	return reportOdbError(command, error, verbose, abortReason);
+}
 function resolveDefaultCsvOutputPath(inputPath) {
 	const directory = (0, node_path.dirname)(inputPath);
 	const stem = (0, node_path.basename)(inputPath, (0, node_path.extname)(inputPath));
@@ -859,6 +1038,48 @@ async function runOdbTables(input, options) {
 		return reportOdbError(command, error, false, getAbortReason());
 	}
 }
+function resolveQuerySql(pkg, options) {
+	if (options.sql !== void 0) return { sql: options.sql };
+	const queryName = options.query;
+	if (queryName === void 0) return { errorMessage: "pass --sql <text> or --query <savedName>" };
+	const inventory = (0, documents_js.readOdbInventory)(pkg);
+	const saved = inventory.queries.find((candidate) => candidate.name === queryName);
+	if (saved === void 0) {
+		const available = inventory.queries.map((candidate) => candidate.name);
+		return { errorMessage: `this .odb declares no saved query named '${queryName}'${available.length === 0 ? "" : ` -- available: ${available.join(", ")}`}` };
+	}
+	return { sql: saved.command };
+}
+async function runOdbQuery(input, options) {
+	const command = "odb-query";
+	if (options.sql !== void 0 && options.query !== void 0) {
+		process.stderr.write(`[${command}] pass --sql or --query, not both\n`);
+		return 2;
+	}
+	if (options.sql === void 0 && options.query === void 0) {
+		process.stderr.write(`[${command}] pass --sql <text> or --query <savedName>\n`);
+		return 2;
+	}
+	const { signal, getAbortReason } = createRuntimeSignal({});
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const pkg = (0, odf_js.decodePackage)(new Uint8Array(inputBytes));
+		const resolved = resolveQuerySql(pkg, options);
+		if ("errorMessage" in resolved) {
+			process.stderr.write(`[${command}] ${resolved.errorMessage}\n`);
+			return 2;
+		}
+		const result = (0, documents_js.evaluateSelect)((0, documents_js.parseSelect)(resolved.sql), (0, documents_js.readOdbTables)(pkg));
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify(result)}\n`);
+			return 0;
+		}
+		for (const line of formatSqlResultSetTable(result)) process.stdout.write(`${line}\n`);
+		return 0;
+	} catch (error) {
+		return reportOdbError(command, error, false, getAbortReason());
+	}
+}
 async function runOdbForms(input, options) {
 	const command = "odb-forms";
 	const { signal, getAbortReason } = createRuntimeSignal({});
@@ -905,6 +1126,93 @@ async function runOdbReports(input, options) {
 		return reportOdbError(command, error, false, getAbortReason());
 	}
 }
+const ODB_REPORT_TARGET_FORMATS = {
+	docx: true,
+	odt: true,
+	pdf: true
+};
+function isOdbReportTargetFormat(format) {
+	return format in ODB_REPORT_TARGET_FORMATS;
+}
+function renderOdbReportBytes(content, target, options) {
+	if (target === "docx") return (0, documents_js.encodePackage)((0, documents_js.buildDocxPackage)(content));
+	if (target === "odt") return (0, odf_js.encodePackage)((0, documents_js.buildOdtPackage)(content));
+	if (content.kind !== "wordprocessing") throw new Error("readOdbReportContent returned a non-wordprocessing ContentDocument");
+	const fonts = (0, documents_js.createFontRegistry)({
+		fonts: options.fonts,
+		onSubstitution: (substitution) => {
+			if (options.reportFontSubstitution !== void 0) {
+				options.reportFontSubstitution(substitution);
+				return;
+			}
+			options.onDiagnosticCounted();
+			options.reporter.report(fontSubstitutionToDiagnostic(substitution));
+		}
+	});
+	const { document: layout, formulas } = (0, documents_js.convertWordprocessingToLayout)(content, { measurer: (0, documents_js.createFontMeasurer)(fonts) });
+	return (0, documents_js.writePdf)(layout, {
+		signal: options.signal,
+		onSubstitution: (substitution, context) => {
+			options.onDiagnosticCounted();
+			options.reporter.report(substitutionToDiagnostic(substitution, context.pageIndex));
+		},
+		formulas,
+		fonts
+	});
+}
+async function runOdbRenderReport(input, output, options) {
+	const command = "odb-render-report";
+	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;
+	}
+	if (!isOdbReportTargetFormat(target.format)) {
+		process.stderr.write(`[${command}] '${target.format}' is not a supported report render target; expected one of docx, odt, pdf\n`);
+		return 2;
+	}
+	const targetFormat = target.format;
+	const resolvedOutput = output ?? options.out ?? (input === "-" ? "-" : resolveDefaultOutputPath(input, targetFormat));
+	const { signal, getAbortReason } = createRuntimeSignal({ timeoutMs: options.timeout });
+	const reporter = createDiagnosticReporter({
+		json: options.json,
+		quiet: options.quiet,
+		command
+	});
+	let diagnosticCount = 0;
+	const reportFontSubstitution = options.reportFontSubstitutions === true ? createFontSubstitutionReporter({
+		json: options.json,
+		quiet: options.quiet,
+		command
+	}) : void 0;
+	try {
+		const inputBytes = await readInput(input, { signal });
+		const fonts = await loadProvidedFonts(options.fontFile ?? [], { signal });
+		const pkg = (0, odf_js.decodePackage)(new Uint8Array(inputBytes));
+		const bytes = renderOdbReportBytes((0, documents_js.readOdbReportContent)(pkg, { report: options.report }), targetFormat, {
+			fonts,
+			signal,
+			reporter,
+			reportFontSubstitution,
+			onDiagnosticCounted: () => {
+				diagnosticCount += 1;
+			}
+		});
+		await writeOutput(resolvedOutput, bytes);
+		reporter.summarize({
+			output: resolvedOutput,
+			bytes: bytes.byteLength,
+			diagnosticCount
+		});
+		return 0;
+	} catch (error) {
+		return reportOdbReportError(command, error, options.verbose, getAbortReason());
+	}
+}
 function registerOdbToXlsxCommand(program) {
 	const command = program.command("odb-to-xlsx <input> [output]").description("extract every table an embedded .odb database declares into one xlsx workbook, one sheet per table");
 	addOutOption(command);
@@ -943,12 +1251,33 @@ function registerOdbReportsCommand(program) {
 		process.exitCode = await runOdbReports(input, options);
 	});
 }
+function registerOdbQueryCommand(program) {
+	program.command("odb-query <input>").description("run a bounded SELECT over an embedded .odb database's own extracted tables, given directly or by naming one of its saved queries").option("--sql <text>", "the SELECT statement to run -- mutually exclusive with --query").option("--query <savedName>", "the name of one of the .odb's own saved queries to run -- mutually exclusive with --sql").option("--json", "emit the result set as JSON ({ columns, rows }) instead of a plain-text table", false).action(async (input, options) => {
+		process.exitCode = await runOdbQuery(input, options);
+	});
+}
+function registerOdbRenderReportCommand(program) {
+	const command = program.command("odb-render-report <input> [output]").description("render one of an .odb's own reports -- its query resolved, its rpt: formulas evaluated, its bands laid out -- to docx, odt, or pdf");
+	addOutOption(command);
+	addTimeoutOption(command);
+	addJsonOption(command);
+	addQuietOption(command);
+	addVerboseOption(command);
+	addFontOptions(command);
+	command.option("--report <name>", "the report to render -- required only when the .odb declares more than one report");
+	command.option("--to <format>", "target format when it cannot be inferred from the output path (docx, odt, pdf)");
+	command.action(async (input, output, options) => {
+		process.exitCode = await runOdbRenderReport(input, output, options);
+	});
+}
 function registerOdbCommands(program) {
 	registerOdbToXlsxCommand(program);
 	registerOdbToCsvCommand(program);
 	registerOdbTablesCommand(program);
 	registerOdbFormsCommand(program);
 	registerOdbReportsCommand(program);
+	registerOdbQueryCommand(program);
+	registerOdbRenderReportCommand(program);
 }
 //#endregion
 //#region src/commands/odm.ts
@@ -1074,7 +1403,7 @@ async function runPdfInspect(input, options) {
 			}
 		});
 		if (options.full) {
-			process.stdout.write(`${JSON.stringify(layout, void 0, 2)}\n`);
+			process.stdout.write(`${JSON.stringify((0, documents_js.layoutDocumentWithSchema)(layout), void 0, 2)}\n`);
 			return 0;
 		}
 		const imagesByFormat = countImagesByFormat(layout.images);
@@ -1129,7 +1458,7 @@ function registerPdfInspectCommand(program) {
 }
 //#endregion
 //#region package.json
-var version = "1.2.11";
+var version = "1.4.0";
 //#endregion
 //#region src/program.ts
 function createProgram() {
@@ -1146,6 +1475,8 @@ function createProgram() {
 	registerOdmCommand(program);
 	registerOdbCommands(program);
 	registerPdfInspectCommand(program);
+	registerFontsCommand(program);
+	registerDocxExtrasCommand(program);
 	return program;
 }
 //#endregion