reamkit 0.1.0-alpha.0

package/dist/esm/ooxml/wordproc/table-parser.js

@@ -0,0 +1,162 @@
+import { poAttr, poChildren, poChildrenWith, poFirstChild, poIntAttr, poToggle, poVal } from "./po-helpers.js";
+import { parseBodyElements } from "./document-parser.js";
+//#region src/ooxml/wordproc/table-parser.ts
+var BORDER_STYLES = new Set([
+	"none",
+	"single",
+	"double",
+	"thick",
+	"dotted",
+	"dashed"
+]);
+var WIDTH_TYPES = new Set([
+	"auto",
+	"dxa",
+	"pct",
+	"nil"
+]);
+var HEIGHT_RULES = new Set([
+	"auto",
+	"atLeast",
+	"exact"
+]);
+function parseTable(tbl) {
+	const properties = parseTableProperties(poFirstChild(tbl, "w:tblPr"));
+	const grid = parseTableGrid(poFirstChild(tbl, "w:tblGrid"));
+	const rows = [];
+	for (const tr of poChildrenWith(tbl, "w:tr")) rows.push(parseTableRow(tr));
+	return {
+		properties,
+		grid,
+		rows
+	};
+}
+function parseTableProperties(tblPr) {
+	if (!tblPr) return {};
+	const out = {};
+	const tblW = poFirstChild(tblPr, "w:tblW");
+	if (tblW) {
+		const w = poIntAttr(tblW, "w");
+		const type = poAttr(tblW, "type");
+		if (w !== void 0) out.widthTwips = w;
+		if (type && WIDTH_TYPES.has(type)) out.widthType = type;
+	}
+	const tblLayout = poFirstChild(tblPr, "w:tblLayout");
+	if (tblLayout) {
+		const t = poAttr(tblLayout, "type");
+		if (t === "fixed" || t === "auto") out.layout = t;
+	}
+	const borders = parseBorders(poFirstChild(tblPr, "w:tblBorders"));
+	if (borders) out.borders = borders;
+	const margins = parseCellMargins(poFirstChild(tblPr, "w:tblCellMar"));
+	if (margins) out.defaultCellMargins = margins;
+	return out;
+}
+function parseTableGrid(tblGrid) {
+	if (!tblGrid) return [];
+	const cols = [];
+	for (const gridCol of poChildrenWith(tblGrid, "w:gridCol")) {
+		const w = poIntAttr(gridCol, "w");
+		cols.push(w ?? 0);
+	}
+	return cols;
+}
+function parseTableRow(tr) {
+	const properties = parseRowProperties(poFirstChild(tr, "w:trPr"));
+	const cells = [];
+	for (const tc of poChildrenWith(tr, "w:tc")) cells.push(parseTableCell(tc));
+	return {
+		properties,
+		cells
+	};
+}
+function parseRowProperties(trPr) {
+	if (!trPr) return {};
+	const out = {};
+	const trHeight = poFirstChild(trPr, "w:trHeight");
+	if (trHeight) {
+		const val = poIntAttr(trHeight, "val");
+		const rule = poAttr(trHeight, "hRule");
+		if (val !== void 0) out.heightTwips = val;
+		if (rule && HEIGHT_RULES.has(rule)) out.heightRule = rule;
+	}
+	if (poFirstChild(trPr, "w:cantSplit")) out.cantSplit = poToggle(poFirstChild(trPr, "w:cantSplit")) ?? true;
+	if (poFirstChild(trPr, "w:tblHeader")) out.isHeader = poToggle(poFirstChild(trPr, "w:tblHeader")) ?? true;
+	return out;
+}
+function parseTableCell(tc) {
+	return {
+		properties: parseCellProperties(poFirstChild(tc, "w:tcPr")),
+		content: parseBodyElements(poChildren(tc))
+	};
+}
+function parseCellProperties(tcPr) {
+	if (!tcPr) return {};
+	const out = {};
+	const tcW = poFirstChild(tcPr, "w:tcW");
+	if (tcW) {
+		const w = poIntAttr(tcW, "w");
+		if (w !== void 0) out.widthTwips = w;
+	}
+	const gridSpan = poFirstChild(tcPr, "w:gridSpan");
+	if (gridSpan) {
+		const v = poIntAttr(gridSpan, "val");
+		if (v !== void 0) out.gridSpan = v;
+	}
+	const vMerge = poFirstChild(tcPr, "w:vMerge");
+	if (vMerge) if (poVal(vMerge) === "restart") out.vMerge = "restart";
+	else out.vMerge = "continue";
+	const borders = parseBorders(poFirstChild(tcPr, "w:tcBorders"));
+	if (borders) out.borders = borders;
+	const margins = parseCellMargins(poFirstChild(tcPr, "w:tcMar"));
+	if (margins) out.margins = margins;
+	const shd = poFirstChild(tcPr, "w:shd");
+	if (shd) {
+		const fill = poAttr(shd, "fill");
+		if (fill && fill !== "auto" && /^[0-9A-Fa-f]{6}$/.test(fill)) out.shading = { colorHex: fill.toUpperCase() };
+	}
+	return out;
+}
+function parseBorders(node) {
+	if (!node) return void 0;
+	const out = {};
+	const top = parseBorder(poFirstChild(node, "w:top"));
+	const right = parseBorder(poFirstChild(node, "w:right") ?? poFirstChild(node, "w:end"));
+	const bottom = parseBorder(poFirstChild(node, "w:bottom"));
+	const left = parseBorder(poFirstChild(node, "w:left") ?? poFirstChild(node, "w:start"));
+	const insideH = parseBorder(poFirstChild(node, "w:insideH"));
+	const insideV = parseBorder(poFirstChild(node, "w:insideV"));
+	if (top) out.top = top;
+	if (right) out.right = right;
+	if (bottom) out.bottom = bottom;
+	if (left) out.left = left;
+	if (insideH) out.insideH = insideH;
+	if (insideV) out.insideV = insideV;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function parseBorder(node) {
+	if (!node) return void 0;
+	const val = poVal(node);
+	if (!val || !BORDER_STYLES.has(val)) return void 0;
+	const sz = poIntAttr(node, "sz");
+	const color = poAttr(node, "color");
+	const out = { style: val };
+	if (sz !== void 0) out.sizeEighthPt = sz;
+	if (color && color !== "auto" && /^[0-9A-Fa-f]{6}$/.test(color)) out.colorHex = color.toUpperCase();
+	return out;
+}
+function parseCellMargins(node) {
+	if (!node) return void 0;
+	const out = {};
+	const top = poIntAttr(poFirstChild(node, "w:top"), "w");
+	const bottom = poIntAttr(poFirstChild(node, "w:bottom"), "w");
+	const left = poIntAttr(poFirstChild(node, "w:left") ?? poFirstChild(node, "w:start"), "w");
+	const right = poIntAttr(poFirstChild(node, "w:right") ?? poFirstChild(node, "w:end"), "w");
+	if (top !== void 0) out.topTwips = top;
+	if (bottom !== void 0) out.bottomTwips = bottom;
+	if (left !== void 0) out.leftTwips = left;
+	if (right !== void 0) out.rightTwips = right;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+//#endregion
+export { parseTable };

package/dist/esm/ooxml/wordproc/text-extractor.d.ts

@@ -0,0 +1 @@
+export declare function extractParagraphs(documentXml: Uint8Array): Array<string>;

package/dist/esm/ooxml/wordproc/text-extractor.js

@@ -0,0 +1 @@
+import "./document-parser.js";

package/dist/esm/ooxml/wordproc/xml-helpers.d.ts

@@ -0,0 +1,9 @@
+export type XmlAttrValue = string;
+export type XmlElement = Record<string, unknown>;
+export declare function asElement(v: unknown): XmlElement | undefined;
+export declare function asArray(v: unknown): ReadonlyArray<unknown>;
+export declare function getAttr(node: unknown, name: string): string | undefined;
+export declare function getVal(node: unknown): string | undefined;
+export declare function parseIntAttr(node: unknown, name: string): number | undefined;
+export declare function parseToggle(node: unknown): boolean | undefined;
+export declare function getText(node: unknown): string;

package/dist/esm/ooxml/wordproc/xml-helpers.js

@@ -0,0 +1,36 @@
+//#region src/ooxml/wordproc/xml-helpers.ts
+function asElement(v) {
+	if (v === null || v === void 0) return void 0;
+	if (typeof v !== "object" || Array.isArray(v)) return void 0;
+	return v;
+}
+function asArray(v) {
+	if (v === null || v === void 0) return [];
+	return Array.isArray(v) ? v : [v];
+}
+function getAttr(node, name) {
+	const el = asElement(node);
+	if (!el) return void 0;
+	const v = el[`@_w:${name}`] ?? el[`@_${name}`];
+	return typeof v === "string" ? v : void 0;
+}
+function getVal(node) {
+	return getAttr(node, "val");
+}
+function parseIntAttr(node, name) {
+	const v = getAttr(node, name);
+	if (v === void 0) return void 0;
+	const n = Number(v);
+	if (!Number.isFinite(n)) return void 0;
+	return n;
+}
+function parseToggle(node) {
+	if (node === void 0) return void 0;
+	if (node === null || node === "" || typeof node === "boolean" || typeof node === "number") return true;
+	if (typeof node === "string") return true;
+	const v = getAttr(node, "val");
+	if (v === void 0) return true;
+	return !(v === "false" || v === "0" || v === "off");
+}
+//#endregion
+export { asArray, asElement, getAttr, getVal, parseIntAttr, parseToggle };

package/dist/esm/opc/core-properties.d.ts

@@ -0,0 +1,11 @@
+export interface CoreProperties {
+    readonly title?: string;
+    readonly subject?: string;
+    readonly creator?: string;
+    readonly keywords?: string;
+    readonly description?: string;
+    readonly lastModifiedBy?: string;
+    readonly created?: Date;
+    readonly modified?: Date;
+}
+export declare function parseCoreProperties(data: Uint8Array): CoreProperties;

package/dist/esm/opc/core-properties.js

@@ -0,0 +1,51 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/opc/core-properties.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+function parseCoreProperties(data) {
+	const tree = parser.parse(decoder.decode(data));
+	const root = tree["cp:coreProperties"] ?? tree["coreProperties"];
+	if (!root) return {};
+	const out = {};
+	const title = textValue(root["dc:title"] ?? root["title"]);
+	if (title) out.title = title;
+	const subject = textValue(root["dc:subject"] ?? root["subject"]);
+	if (subject) out.subject = subject;
+	const creator = textValue(root["dc:creator"] ?? root["creator"]);
+	if (creator) out.creator = creator;
+	const keywords = textValue(root["cp:keywords"] ?? root["keywords"]);
+	if (keywords) out.keywords = keywords;
+	const description = textValue(root["dc:description"] ?? root["description"]);
+	if (description) out.description = description;
+	const lastModifiedBy = textValue(root["cp:lastModifiedBy"] ?? root["lastModifiedBy"]);
+	if (lastModifiedBy) out.lastModifiedBy = lastModifiedBy;
+	const created = parseIsoDate(textValue(root["dcterms:created"] ?? root["created"]));
+	if (created) out.created = created;
+	const modified = parseIsoDate(textValue(root["dcterms:modified"] ?? root["modified"]));
+	if (modified) out.modified = modified;
+	return out;
+}
+function textValue(node) {
+	if (node === void 0 || node === null) return void 0;
+	if (typeof node === "string") return node.length > 0 ? node : void 0;
+	if (typeof node === "number") return String(node);
+	if (typeof node === "object") {
+		const inner = node["#text"];
+		if (typeof inner === "string" && inner.length > 0) return inner;
+		if (typeof inner === "number") return String(inner);
+	}
+}
+function parseIsoDate(value) {
+	if (!value) return void 0;
+	const d = new Date(value);
+	return Number.isFinite(d.getTime()) ? d : void 0;
+}
+//#endregion
+export { parseCoreProperties };

package/dist/esm/opc/index.d.ts

@@ -0,0 +1,5 @@
+export { OpcPackage } from './package.js';
+export type { Relationship } from './relationships.js';
+export { REL_OFFICE_DOCUMENT, REL_CORE_PROPERTIES, REL_EXTENDED_PROPERTIES, } from './relationship-types.js';
+export { parseCoreProperties } from './core-properties.js';
+export type { CoreProperties } from './core-properties.js';

package/dist/esm/opc/index.js

@@ -0,0 +1,3 @@
+import "./relationship-types.js";
+import "./package.js";
+import "./core-properties.js";

package/dist/esm/opc/package.d.ts

@@ -0,0 +1,26 @@
+import { Relationship } from './relationships.js';
+export interface OpcOpenOptions {
+    readonly maxArchiveBytes?: number;
+    readonly maxEntryBytes?: number;
+    readonly maxTotalBytes?: number;
+    readonly maxEntries?: number;
+}
+export declare class OpcPackage {
+    private readonly parts;
+    private readonly rootRelationships;
+    private constructor();
+    static open(buffer: Uint8Array, options?: OpcOpenOptions): OpcPackage;
+    getPart(path: string): Uint8Array | undefined;
+    requirePart(path: string): Uint8Array;
+    listParts(): Array<string>;
+    getPartRelationships(partPath: string): Array<Relationship>;
+    resolveRelatedPart(sourcePartPath: string, relationship: Relationship): {
+        readonly path: string;
+        readonly data: Uint8Array;
+    } | undefined;
+    getMainDocumentPath(): string;
+    getMainDocument(): {
+        path: string;
+        data: Uint8Array;
+    };
+}

package/dist/esm/opc/package.js

@@ -0,0 +1,113 @@
+import { parseRelationships } from "./relationships.js";
+import "./relationship-types.js";
+import { unzipSync } from "fflate";
+//#region src/opc/package.ts
+var ROOT_RELS_PATH = "_rels/.rels";
+var MIB = 1024 * 1024;
+var OpcPackage = class OpcPackage {
+	constructor(parts, rootRelationships) {
+		this.parts = parts;
+		this.rootRelationships = rootRelationships;
+	}
+	static open(buffer, options = {}) {
+		const maxArchive = options.maxArchiveBytes ?? 128 * MIB;
+		const maxEntry = options.maxEntryBytes ?? 256 * MIB;
+		const maxTotal = options.maxTotalBytes ?? 512 * MIB;
+		const maxEntries = options.maxEntries ?? 65536;
+		if (buffer.byteLength > maxArchive) throw new Error(`OPC archive too large: ${buffer.byteLength} bytes (limit ${maxArchive}); refusing to unzip`);
+		let total = 0;
+		let count = 0;
+		let violation;
+		const entries = unzipSync(buffer, { filter: (info) => {
+			if (++count > maxEntries) {
+				violation ??= `more than ${maxEntries} entries`;
+				return false;
+			}
+			if (info.originalSize > maxEntry) {
+				violation ??= `entry "${info.name}" declares ${info.originalSize} bytes (limit ${maxEntry})`;
+				return false;
+			}
+			total += info.originalSize;
+			if (total > maxTotal) {
+				violation ??= `total uncompressed size exceeds ${maxTotal} bytes`;
+				return false;
+			}
+			return true;
+		} });
+		if (violation) throw new Error(`OPC archive rejected (zip-bomb guard): ${violation}`);
+		const parts = /* @__PURE__ */ new Map();
+		for (const [path, data] of Object.entries(entries)) parts.set(normalizePath(path), data);
+		const relsBytes = parts.get(ROOT_RELS_PATH);
+		if (!relsBytes) throw new Error(`OPC package missing ${ROOT_RELS_PATH}`);
+		return new OpcPackage(parts, parseRelationships(relsBytes));
+	}
+	getPart(path) {
+		return this.parts.get(normalizePath(path));
+	}
+	requirePart(path) {
+		const data = this.getPart(path);
+		if (!data) throw new Error(`OPC part not found: ${path}`);
+		return data;
+	}
+	listParts() {
+		return [...this.parts.keys()];
+	}
+	getPartRelationships(partPath) {
+		const normalized = normalizePath(partPath);
+		const slash = normalized.lastIndexOf("/");
+		const dir = slash >= 0 ? normalized.substring(0, slash) : "";
+		const base = slash >= 0 ? normalized.substring(slash + 1) : normalized;
+		const relsPath = dir.length > 0 ? `${dir}/_rels/${base}.rels` : `_rels/${base}.rels`;
+		const data = this.parts.get(relsPath);
+		if (!data) return [];
+		return parseRelationships(data);
+	}
+	resolveRelatedPart(sourcePartPath, relationship) {
+		if (relationship.targetMode !== "Internal") return void 0;
+		const resolved = resolveTarget(`/${normalizePath(sourcePartPath)}`, relationship.target);
+		const data = this.getPart(resolved);
+		if (!data) return void 0;
+		return {
+			path: resolved,
+			data
+		};
+	}
+	getMainDocumentPath() {
+		const candidates = this.rootRelationships.filter((r) => r.type === "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" && r.targetMode === "Internal");
+		if (candidates.length === 0) throw new Error("OPC package has no officeDocument relationship");
+		if (candidates.length > 1) throw new Error(`OPC package has multiple officeDocument relationships (${candidates.length})`);
+		return resolveTarget("/", candidates[0].target);
+	}
+	getMainDocument() {
+		const path = this.getMainDocumentPath();
+		return {
+			path,
+			data: this.requirePart(path)
+		};
+	}
+};
+function normalizePath(p) {
+	return p.startsWith("/") ? p.slice(1) : p;
+}
+function resolveTarget(sourcePath, target) {
+	if (target.startsWith("/")) return normalizePath(target);
+	return normalizePath(collapseDotSegments(`${sourcePath.endsWith("/") ? sourcePath : sourcePath.substring(0, sourcePath.lastIndexOf("/") + 1)}${target}`));
+}
+function collapseDotSegments(p) {
+	const segments = p.split("/");
+	const out = [];
+	for (const s of segments) {
+		if (s === "." || s === "") {
+			if (out.length === 0) out.push("");
+			continue;
+		}
+		if (s === "..") {
+			if (out.length > 1) out.pop();
+			continue;
+		}
+		out.push(s);
+	}
+	return out.join("/");
+}
+//#endregion
+export { OpcPackage };

package/dist/esm/opc/relationship-types.d.ts

@@ -0,0 +1,3 @@
+export declare const REL_OFFICE_DOCUMENT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+export declare const REL_CORE_PROPERTIES = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+export declare const REL_EXTENDED_PROPERTIES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties";

package/dist/esm/opc/relationship-types.js

@@ -0,0 +1,4 @@
+//#region src/opc/relationship-types.ts
+var REL_OFFICE_DOCUMENT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+//#endregion
+export { REL_OFFICE_DOCUMENT };

package/dist/esm/opc/relationships.d.ts

@@ -0,0 +1,7 @@
+export interface Relationship {
+    readonly id: string;
+    readonly type: string;
+    readonly target: string;
+    readonly targetMode: 'Internal' | 'External';
+}
+export declare function parseRelationships(data: Uint8Array): Array<Relationship>;

package/dist/esm/opc/relationships.js

@@ -0,0 +1,28 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/opc/relationships.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	trimValues: false,
+	isArray: (tagName) => tagName === "Relationship"
+});
+function parseRelationships(data) {
+	const xml = decoder.decode(data);
+	const list = parser.parse(xml).Relationships?.Relationship;
+	if (!list) return [];
+	return list.map((r) => ({
+		id: requireAttr(r, "Id"),
+		type: requireAttr(r, "Type"),
+		target: requireAttr(r, "Target"),
+		targetMode: r["@_TargetMode"] === "External" ? "External" : "Internal"
+	}));
+}
+function requireAttr(r, name) {
+	const v = r[`@_${name}`];
+	if (v === void 0) throw new Error(`Relationship missing required attribute: ${name}`);
+	return v;
+}
+//#endregion
+export { parseRelationships };

package/dist/esm/pdf/arc-to-bezier.d.ts

@@ -0,0 +1,5 @@
+import { PathSegment } from './vector-graphics.js';
+export declare function arcPoint(cx: number, cy: number, rx: number, ry: number, angleRad: number): readonly [number, number];
+export declare function arcToBeziers(cx: number, cy: number, rx: number, ry: number, startAngleRad: number, sweepAngleRad: number): Array<PathSegment>;
+export declare function ellipseSegments(w: number, h: number): ReadonlyArray<PathSegment>;
+export declare function roundRectSegments(w: number, h: number, r: number): ReadonlyArray<PathSegment>;

package/dist/esm/pdf/arc-to-bezier.js

@@ -0,0 +1,58 @@
+import { PathBuilder } from "./vector-graphics.js";
+//#region src/pdf/arc-to-bezier.ts
+function arcPoint(cx, cy, rx, ry, angleRad) {
+	return [cx + rx * Math.cos(angleRad), cy + ry * Math.sin(angleRad)];
+}
+function arcToBeziers(cx, cy, rx, ry, startAngleRad, sweepAngleRad) {
+	const segments = [];
+	if (!(rx > 0) || !(ry > 0) || sweepAngleRad === 0 || !Number.isFinite(sweepAngleRad)) return segments;
+	const nSegs = Math.max(1, Math.ceil(Math.abs(sweepAngleRad) / (Math.PI / 2 + 1e-9)));
+	const delta = sweepAngleRad / nSegs;
+	const alpha = 4 / 3 * Math.tan(delta / 4);
+	let theta = startAngleRad;
+	for (let i = 0; i < nSegs; i++) {
+		const t2 = theta + delta;
+		const cos1 = Math.cos(theta);
+		const sin1 = Math.sin(theta);
+		const cos2 = Math.cos(t2);
+		const sin2 = Math.sin(t2);
+		segments.push({
+			op: "cubic",
+			x1: cx + rx * cos1 - alpha * rx * sin1,
+			y1: cy + ry * sin1 + alpha * ry * cos1,
+			x2: cx + rx * cos2 + alpha * rx * sin2,
+			y2: cy + ry * sin2 - alpha * ry * cos2,
+			x: cx + rx * cos2,
+			y: cy + ry * sin2
+		});
+		theta = t2;
+	}
+	return segments;
+}
+function ellipseSegments(w, h) {
+	const rx = w / 2;
+	const ry = h / 2;
+	const cx = rx;
+	const cy = ry;
+	const start = arcPoint(cx, cy, rx, ry, 0);
+	return new PathBuilder().moveTo(start[0], start[1]).append(arcToBeziers(cx, cy, rx, ry, 0, 2 * Math.PI)).close().build().segments;
+}
+function roundRectSegments(w, h, r) {
+	const rr = Math.max(0, Math.min(r, Math.min(w, h) / 2));
+	const b = new PathBuilder();
+	if (rr === 0) return b.moveTo(0, 0).lineTo(w, 0).lineTo(w, h).lineTo(0, h).close().build().segments;
+	const Q = Math.PI / 2;
+	b.moveTo(rr, 0);
+	b.lineTo(w - rr, 0);
+	b.append(arcToBeziers(w - rr, rr, rr, rr, -Q, Q));
+	b.lineTo(w, h - rr);
+	b.append(arcToBeziers(w - rr, h - rr, rr, rr, 0, Q));
+	b.lineTo(rr, h);
+	b.append(arcToBeziers(rr, h - rr, rr, rr, Q, Q));
+	b.lineTo(0, rr);
+	b.append(arcToBeziers(rr, rr, rr, rr, Math.PI, Q));
+	b.close();
+	return b.build().segments;
+}
+//#endregion
+export { arcPoint, arcToBeziers, ellipseSegments, roundRectSegments };

package/dist/esm/pdf/builtin-fonts.d.ts

@@ -0,0 +1,2 @@
+export type BuiltinFontName = 'Helvetica' | 'Helvetica-Bold' | 'Helvetica-Oblique' | 'Helvetica-BoldOblique' | 'Times-Roman' | 'Times-Bold' | 'Times-Italic' | 'Times-BoldItalic' | 'Courier' | 'Courier-Bold' | 'Courier-Oblique' | 'Courier-BoldOblique' | 'Symbol' | 'ZapfDingbats';
+export declare const BUILTIN_FONTS: ReadonlyArray<BuiltinFontName>;

package/dist/esm/pdf/chart-geometry.d.ts

@@ -0,0 +1,64 @@
+import { Chart, ChartSeries } from '../document-model/index.js';
+export interface ChartRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    readonly fillHex?: string;
+    readonly strokeHex?: string;
+    readonly strokeWidthPt?: number;
+}
+export interface ChartPolyline {
+    readonly points: ReadonlyArray<readonly [number, number]>;
+    readonly strokeHex: string;
+    readonly widthPt: number;
+}
+export interface ChartPolygon {
+    readonly points: ReadonlyArray<readonly [number, number]>;
+    readonly fillHex: string;
+    readonly strokeHex?: string;
+    readonly widthPt?: number;
+}
+export interface ChartWedge {
+    readonly cx: number;
+    readonly cy: number;
+    readonly r: number;
+    readonly startRad: number;
+    readonly sweepRad: number;
+    readonly fillHex: string;
+    readonly strokeHex?: string;
+}
+export type LabelAlign = 'left' | 'center' | 'right';
+export interface ChartLabel {
+    readonly text: string;
+    readonly x: number;
+    readonly y: number;
+    readonly sizePt: number;
+    readonly colorHex: string;
+    readonly align: LabelAlign;
+}
+export interface ChartScene {
+    readonly rects: ReadonlyArray<ChartRect>;
+    readonly polylines: ReadonlyArray<ChartPolyline>;
+    readonly wedges: ReadonlyArray<ChartWedge>;
+    readonly labels: ReadonlyArray<ChartLabel>;
+    readonly polygons?: ReadonlyArray<ChartPolygon>;
+}
+export type MeasureText = (text: string, sizePt: number) => number;
+export declare const CHART_LABEL_PT = 9;
+export declare const CHART_TITLE_PT = 13;
+export declare const SERIES_COLORS: string[];
+export declare const seriesColor: (s: ChartSeries, i: number) => string;
+export interface Scale {
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+}
+export declare function niceScale(dataMin: number, dataMax: number, maxTicks?: number): Scale;
+export declare function formatTick(v: number, step: number): string;
+export declare function buildBarScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
+export declare function buildAreaScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
+export declare function buildScatterScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
+export declare function buildLineScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
+export declare function buildPieScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene;
+export declare function buildChartScene(chart: Chart, wPt: number, hPt: number, measure: MeasureText): ChartScene | null;