document-cli 1.0.1 → 1.2.0

package/dist/odb-structure-CX_0zL8_.js

@@ -0,0 +1,382 @@
+import { readFile, writeFile } from "node:fs/promises";
+import "documents.js";
+import { basename, dirname, extname, join } from "node:path";
+//#region src/format.ts
+const EXTENSION_TO_FORMAT = {
+	docx: "docx",
+	pptx: "pptx",
+	xlsx: "xlsx",
+	odt: "odt",
+	odp: "odp",
+	ods: "ods",
+	odg: "odg",
+	odf: "odf",
+	markdown: "markdown",
+	md: "markdown",
+	pdf: "pdf"
+};
+const FORMAT_TO_EXTENSION = {
+	docx: "docx",
+	pptx: "pptx",
+	xlsx: "xlsx",
+	odt: "odt",
+	odp: "odp",
+	ods: "ods",
+	odg: "odg",
+	odf: "odf",
+	markdown: "md",
+	pdf: "pdf"
+};
+function isDocumentFormat(value) {
+	return value in FORMAT_TO_EXTENSION;
+}
+function inferFormatFromExtension(path) {
+	if (path === "-") return;
+	const lastSegment = path.split(/[/\\]/).pop() ?? path;
+	const dotIndex = lastSegment.lastIndexOf(".");
+	if (dotIndex <= 0) return;
+	const extension = lastSegment.slice(dotIndex + 1).toLowerCase();
+	return EXTENSION_TO_FORMAT[extension];
+}
+function formatToExtension(format) {
+	return FORMAT_TO_EXTENSION[format];
+}
+//#endregion
+//#region src/runtime/font-face.ts
+var FontFaceError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FontFaceError";
+	}
+};
+const SFNT_VERSION_TRUETYPE = 65536;
+const SFNT_VERSION_CFF = 1330926671;
+const SFNT_VERSION_APPLE_TRUE = 1953658213;
+const SFNT_VERSION_APPLE_TYP1 = 1954115633;
+const SFNT_VERSION_COLLECTION = 1953784678;
+const SFNT_VERSIONS = /* @__PURE__ */ new Set([
+	SFNT_VERSION_TRUETYPE,
+	SFNT_VERSION_CFF,
+	SFNT_VERSION_APPLE_TRUE,
+	SFNT_VERSION_APPLE_TYP1
+]);
+const TABLE_DIRECTORY_HEADER_SIZE = 12;
+const TABLE_RECORD_SIZE = 16;
+const TABLE_TAG_SIZE = 4;
+const NAME_HEADER_SIZE = 6;
+const NAME_RECORD_SIZE = 12;
+const NAME_ID_FAMILY = 1;
+const NAME_ID_TYPOGRAPHIC_FAMILY = 16;
+const PLATFORM_UNICODE = 0;
+const PLATFORM_MACINTOSH = 1;
+const PLATFORM_WINDOWS = 3;
+const MACINTOSH_ENCODING_ROMAN = 0;
+const OS2_FS_SELECTION_OFFSET = 62;
+const OS2_MINIMUM_SIZE = 64;
+const OS2_FS_SELECTION_ITALIC = 1;
+const OS2_FS_SELECTION_BOLD = 32;
+const HEAD_MAC_STYLE_OFFSET = 44;
+const HEAD_MINIMUM_SIZE = 46;
+const HEAD_MAC_STYLE_BOLD = 1;
+const HEAD_MAC_STYLE_ITALIC = 2;
+function viewOf(bytes) {
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function decodeTag(view, offset) {
+	let tag = "";
+	for (let i = 0; i < TABLE_TAG_SIZE; i++) tag += String.fromCharCode(view.getUint8(offset + i));
+	return tag;
+}
+function decodeUtf16Be(view, offset, length) {
+	let text = "";
+	for (let i = 0; i + 1 < length; i += 2) text += String.fromCharCode(view.getUint16(offset + i));
+	return text;
+}
+function decodeMacintoshAscii(view, offset, length) {
+	let text = "";
+	for (let i = 0; i < length; i++) {
+		const byte = view.getUint8(offset + i);
+		if (byte > 126) return;
+		text += String.fromCharCode(byte);
+	}
+	return text;
+}
+function readTableDirectory(view, source) {
+	if (view.byteLength < TABLE_DIRECTORY_HEADER_SIZE) throw new FontFaceError(`${source} is too short to be a font file (${String(view.byteLength)} bytes)`);
+	const sfntVersion = view.getUint32(0);
+	if (sfntVersion === SFNT_VERSION_COLLECTION) throw new FontFaceError(`${source} is a TrueType Collection (.ttc), which packs several faces into one file; extract the single face you want and pass that instead`);
+	if (!SFNT_VERSIONS.has(sfntVersion)) throw new FontFaceError(`${source} is not a TrueType/OpenType font file (no recognised sfnt version); a .woff/.woff2 file must be converted to .ttf/.otf first`);
+	const numTables = view.getUint16(4);
+	if (view.byteLength < TABLE_DIRECTORY_HEADER_SIZE + numTables * TABLE_RECORD_SIZE) throw new FontFaceError(`${source} declares ${String(numTables)} tables but is too short to hold that many table records`);
+	const tables = /* @__PURE__ */ new Map();
+	for (let i = 0; i < numTables; i++) {
+		const recordOffset = TABLE_DIRECTORY_HEADER_SIZE + i * TABLE_RECORD_SIZE;
+		const tag = decodeTag(view, recordOffset);
+		const offset = view.getUint32(recordOffset + 8);
+		const length = view.getUint32(recordOffset + 12);
+		if (offset + length > view.byteLength || tables.has(tag)) continue;
+		tables.set(tag, {
+			offset,
+			length
+		});
+	}
+	return tables;
+}
+function tableView(bytes, table) {
+	return new DataView(bytes.buffer, bytes.byteOffset + table.offset, table.length);
+}
+function readNameRecords(name) {
+	if (name.byteLength < NAME_HEADER_SIZE) return [];
+	const count = name.getUint16(2);
+	const storageOffset = name.getUint16(4);
+	if (name.byteLength < NAME_HEADER_SIZE + count * NAME_RECORD_SIZE) return [];
+	const records = [];
+	for (let i = 0; i < count; i++) {
+		const recordOffset = NAME_HEADER_SIZE + i * NAME_RECORD_SIZE;
+		records.push({
+			platformId: name.getUint16(recordOffset),
+			encodingId: name.getUint16(recordOffset + 2),
+			nameId: name.getUint16(recordOffset + 6),
+			length: name.getUint16(recordOffset + 8),
+			stringOffset: storageOffset + name.getUint16(recordOffset + 10)
+		});
+	}
+	return records;
+}
+function platformPreference(record) {
+	if (record.platformId === PLATFORM_WINDOWS) return 0;
+	if (record.platformId === PLATFORM_UNICODE) return 1;
+	if (record.platformId === PLATFORM_MACINTOSH && record.encodingId === MACINTOSH_ENCODING_ROMAN) return 2;
+	return Number.POSITIVE_INFINITY;
+}
+function readNameString(name, records, nameId) {
+	const candidates = records.filter((record) => record.nameId === nameId && Number.isFinite(platformPreference(record))).sort((left, right) => platformPreference(left) - platformPreference(right));
+	for (const record of candidates) {
+		if (record.stringOffset + record.length > name.byteLength) continue;
+		const text = record.platformId === PLATFORM_MACINTOSH ? decodeMacintoshAscii(name, record.stringOffset, record.length) : decodeUtf16Be(name, record.stringOffset, record.length);
+		if (text !== void 0 && text.length > 0) return text;
+	}
+}
+function readStyleBits(bytes, tables, source) {
+	const os2 = tables.get("OS/2");
+	if (os2 !== void 0 && os2.length >= OS2_MINIMUM_SIZE) {
+		const fsSelection = tableView(bytes, os2).getUint16(OS2_FS_SELECTION_OFFSET);
+		return {
+			bold: (fsSelection & OS2_FS_SELECTION_BOLD) !== 0,
+			italic: (fsSelection & OS2_FS_SELECTION_ITALIC) !== 0
+		};
+	}
+	const head = tables.get("head");
+	if (head !== void 0 && head.length >= HEAD_MINIMUM_SIZE) {
+		const macStyle = tableView(bytes, head).getUint16(HEAD_MAC_STYLE_OFFSET);
+		return {
+			bold: (macStyle & HEAD_MAC_STYLE_BOLD) !== 0,
+			italic: (macStyle & HEAD_MAC_STYLE_ITALIC) !== 0
+		};
+	}
+	throw new FontFaceError(`${source} declares neither a readable 'OS/2' nor a readable 'head' table, so its weight and slope cannot be determined`);
+}
+function describeFontFace(bytes, source) {
+	const tables = readTableDirectory(viewOf(bytes), source);
+	const nameTable = tables.get("name");
+	if (nameTable === void 0) throw new FontFaceError(`${source} declares no 'name' table, so the font family it provides cannot be determined`);
+	const name = tableView(bytes, nameTable);
+	const records = readNameRecords(name);
+	const family = readNameString(name, records, NAME_ID_TYPOGRAPHIC_FAMILY) ?? readNameString(name, records, NAME_ID_FAMILY);
+	if (family === void 0) throw new FontFaceError(`${source} declares no family name in its 'name' table, so the font family it provides cannot be determined`);
+	const { bold, italic } = readStyleBits(bytes, tables, source);
+	return {
+		family,
+		bold,
+		italic
+	};
+}
+//#endregion
+//#region src/runtime/fonts.ts
+async function loadProvidedFonts(paths, options) {
+	const fonts = [];
+	for (const path of paths) {
+		const bytes = new Uint8Array(await readFile(path, { signal: options?.signal }));
+		const face = describeFontFace(bytes, path);
+		fonts.push({
+			family: face.family,
+			bold: face.bold,
+			italic: face.italic,
+			bytes
+		});
+	}
+	return fonts;
+}
+//#endregion
+//#region src/runtime/io.ts
+function isUint8Array(value) {
+	return value instanceof Uint8Array;
+}
+async function readStdin(signal) {
+	const chunks = [];
+	for await (const chunk of process.stdin) {
+		if (signal?.aborted === true) throw new Error("Reading from stdin was aborted");
+		if (!isUint8Array(chunk)) throw new Error("Unexpected non-buffer chunk read from stdin");
+		chunks.push(chunk);
+	}
+	return new Uint8Array(Buffer.concat(chunks));
+}
+async function readInput(pathOrDash, options) {
+	if (pathOrDash === "-") return readStdin(options?.signal);
+	const buffer = await readFile(pathOrDash, { signal: options?.signal });
+	return new Uint8Array(buffer);
+}
+async function writeOutput(pathOrDash, bytes) {
+	if (pathOrDash === "-") {
+		await new Promise((resolve, reject) => {
+			process.stdout.write(bytes, (error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+		return;
+	}
+	await writeFile(pathOrDash, bytes);
+}
+function resolveDefaultOutputPath(inputPath, targetFormat) {
+	const directory = dirname(inputPath);
+	const stem = basename(inputPath, extname(inputPath));
+	return join(directory, `${stem}.${formatToExtension(targetFormat)}`);
+}
+//#endregion
+//#region src/odb-structure.ts
+const INDENT = "  ";
+function indent(depth) {
+	return INDENT.repeat(depth);
+}
+function quoted(value) {
+	return `"${value}"`;
+}
+function describeDataSource(command, commandType) {
+	if (command === void 0) return commandType;
+	return commandType === void 0 ? quoted(command) : `${commandType} ${quoted(command)}`;
+}
+function countOdbFormControls(controls) {
+	return controls.reduce((total, control) => total + 1 + countOdbFormControls(control.controls), 0);
+}
+function countOdbFormDefinitionControls(definition) {
+	return countOdbFormControls(definition.controls) + definition.subForms.reduce((total, subForm) => total + countOdbFormDefinitionControls(subForm), 0);
+}
+function countOdbFormBoundControls(controls) {
+	return controls.reduce((total, control) => total + (control.dataField === void 0 ? 0 : 1) + countOdbFormBoundControls(control.controls), 0);
+}
+function countOdbFormDefinitionBoundControls(definition) {
+	return countOdbFormBoundControls(definition.controls) + definition.subForms.reduce((total, subForm) => total + countOdbFormDefinitionBoundControls(subForm), 0);
+}
+function describeOdbForm(form) {
+	const controlCount = form.forms.reduce((total, definition) => total + countOdbFormDefinitionControls(definition), 0);
+	const boundCount = form.forms.reduce((total, definition) => total + countOdbFormDefinitionBoundControls(definition), 0);
+	return `${form.name} [${form.href}] -- ${form.forms.length} form${form.forms.length === 1 ? "" : "s"}, ${controlCount} control${controlCount === 1 ? "" : "s"} (${boundCount} bound)`;
+}
+function formControlLines(control, depth) {
+	const parts = [control.tag];
+	if (control.name !== void 0) parts.push(control.name);
+	if (control.dataField !== void 0) parts.push(`-> ${control.dataField}`);
+	if (control.label !== void 0) parts.push(`label ${quoted(control.label)}`);
+	if (control.controlImplementation !== void 0) parts.push(`(${control.controlImplementation})`);
+	const nested = control.controls.flatMap((child) => formControlLines(child, depth + 1));
+	return [`${indent(depth)}${parts.join(" ")}`, ...nested];
+}
+function formDefinitionLines(definition, depth, kindLabel) {
+	const headerParts = [kindLabel];
+	if (definition.name !== void 0) headerParts.push(definition.name);
+	const dataSource = describeDataSource(definition.command, definition.commandType);
+	if (dataSource !== void 0) headerParts.push(`on ${dataSource}`);
+	const lines = [`${indent(depth)}${headerParts.join(" ")}`];
+	if (definition.datasource !== void 0) lines.push(`${indent(depth + 1)}datasource: ${definition.datasource}`);
+	if (definition.filter !== void 0) lines.push(`${indent(depth + 1)}filter: ${definition.filter}`);
+	if (definition.order !== void 0) lines.push(`${indent(depth + 1)}order: ${definition.order}`);
+	if (definition.controls.length === 0) lines.push(`${indent(depth + 1)}(no controls)`);
+	for (const control of definition.controls) lines.push(...formControlLines(control, depth + 1));
+	for (const subForm of definition.subForms) lines.push(...formDefinitionLines(subForm, depth + 1, "subform"));
+	return lines;
+}
+function formatOdbFormLines(form) {
+	if (form.forms.length === 0) return ["(this form document declares no form:form definitions)"];
+	return form.forms.flatMap((definition) => formDefinitionLines(definition, 0, "form"));
+}
+function odbFormSummary(form) {
+	return {
+		name: form.name,
+		href: form.href,
+		forms: form.forms
+	};
+}
+function countReportBandElements(band) {
+	return band?.elements.length ?? 0;
+}
+function countReportGroupElements(group) {
+	return countReportBandElements(group.header) + countReportBandElements(group.footer) + group.groups.reduce((total, nested) => total + countReportGroupElements(nested), 0);
+}
+function countReportGroups(groups) {
+	return groups.reduce((total, group) => total + 1 + countReportGroups(group.groups), 0);
+}
+function describeOdbReport(report) {
+	const dataSource = describeDataSource(report.command, report.commandType);
+	const groupCount = countReportGroups(report.groups);
+	const elementCount = countReportBandElements(report.reportHeader) + countReportBandElements(report.pageHeader) + countReportBandElements(report.detail) + countReportBandElements(report.pageFooter) + countReportBandElements(report.reportFooter) + report.groups.reduce((total, group) => total + countReportGroupElements(group), 0);
+	const source = dataSource === void 0 ? "no data source" : `on ${dataSource}`;
+	return `${report.name} [${report.href}] -- ${source}, ${groupCount} group${groupCount === 1 ? "" : "s"}, ${elementCount} element${elementCount === 1 ? "" : "s"}`;
+}
+function reportElementLine(element, depth) {
+	const parts = [element.tag];
+	if (element.name !== void 0) parts.push(quoted(element.name));
+	if (element.formula !== void 0) parts.push(`= ${element.formula}`);
+	if (element.dataField !== void 0) parts.push(`-> ${element.dataField}`);
+	const head = `${indent(depth)}${parts.join(" ")}`;
+	return element.text === void 0 ? head : `${head}: ${quoted(element.text)}`;
+}
+function reportBandLines(band, depth) {
+	if (band === void 0) return [];
+	const header = band.name === void 0 ? band.kind : `${band.kind} ${quoted(band.name)}`;
+	const lines = [`${indent(depth)}${header}`];
+	if (band.elements.length === 0) lines.push(`${indent(depth + 1)}(no elements)`);
+	for (const element of band.elements) lines.push(reportElementLine(element, depth + 1));
+	return lines;
+}
+function reportFunctionLines(functions, depth) {
+	if (functions.length === 0) return [];
+	return [`${indent(depth)}functions`, ...functions.map((fn) => `${indent(depth + 1)}${fn.name} = ${fn.formula}`)];
+}
+function reportGroupLines(group, depth) {
+	const headerParts = ["group"];
+	if (group.groupExpression !== void 0) headerParts.push(group.groupExpression);
+	const attributes = [];
+	if (group.sortExpression !== void 0) attributes.push(`sort ${group.sortExpression} ${group.sortAscending === false ? "descending" : "ascending"}`);
+	if (group.startNewColumn === true) attributes.push("new column");
+	if (group.resetPageNumber === true) attributes.push("reset page number");
+	if (group.keepTogether !== void 0) attributes.push(`keep together ${group.keepTogether}`);
+	if (attributes.length > 0) headerParts.push(`(${attributes.join(", ")})`);
+	return [
+		`${indent(depth)}${headerParts.join(" ")}`,
+		...reportBandLines(group.header, depth + 1),
+		...group.groups.flatMap((nested) => reportGroupLines(nested, depth + 1)),
+		...reportFunctionLines(group.functions, depth + 1),
+		...reportBandLines(group.footer, depth + 1)
+	];
+}
+function formatOdbReportLines(report) {
+	const lines = [];
+	const dataSource = describeDataSource(report.command, report.commandType);
+	if (dataSource !== void 0) lines.push(`data source: ${dataSource}`);
+	if (report.caption !== void 0) lines.push(`caption: ${report.caption}`);
+	if (report.mimeType !== void 0) lines.push(`mime type: ${report.mimeType}`);
+	lines.push(...reportBandLines(report.reportHeader, 0));
+	lines.push(...reportBandLines(report.pageHeader, 0));
+	lines.push(...report.groups.flatMap((group) => reportGroupLines(group, 0)));
+	lines.push(...reportBandLines(report.detail, 0));
+	lines.push(...reportBandLines(report.pageFooter, 0));
+	lines.push(...reportBandLines(report.reportFooter, 0));
+	lines.push(...reportFunctionLines(report.functions, 0));
+	return lines;
+}
+//#endregion
+export { odbFormSummary as a, writeOutput as c, inferFormatFromExtension as d, isDocumentFormat as f, formatOdbReportLines as i, loadProvidedFonts as l, describeOdbReport as n, readInput as o, formatOdbFormLines as r, resolveDefaultOutputPath as s, describeOdbForm as t, formatToExtension as u };