reamkit 0.1.0-alpha.0 → 1.0.1

package/dist/esm/core/numbering/apply.js

@@ -0,0 +1,62 @@
+import { NumberingState } from "./state.js";
+//#region src/core/numbering/apply.ts
+function applyNumbering(body, numbering) {
+	if (!numbering || numbering.abstractNums.size === 0) return body.map((b) => b);
+	const state = new NumberingState();
+	const transformParagraph = (p) => {
+		const ref = p.properties.numbering;
+		if (!ref) return p;
+		const marker = state.resolveMarker(numbering, ref);
+		if (marker === null) return p;
+		const instance = numbering.numInstances.get(ref.numId);
+		const level = (instance ? numbering.abstractNums.get(instance.abstractNumId) : void 0)?.levels.get(ref.ilvl);
+		const markerRun = {
+			text: `${marker}\t`,
+			properties: level?.runProperties ?? {}
+		};
+		return {
+			properties: mergeIndentFromLevel(p.properties, level?.paragraphProperties),
+			runs: [markerRun, ...p.runs]
+		};
+	};
+	const visit = (el) => {
+		if (el.kind === "paragraph") return {
+			kind: "paragraph",
+			paragraph: transformParagraph(el.paragraph)
+		};
+		if (el.kind === "image") return el;
+		if (el.kind === "shape") return el;
+		if (el.kind === "chart") return el;
+		return {
+			kind: "table",
+			table: {
+				...el.table,
+				rows: el.table.rows.map((row) => ({
+					...row,
+					cells: row.cells.map((cell) => ({
+						...cell,
+						content: cell.content.map(visit)
+					}))
+				}))
+			}
+		};
+	};
+	return body.map(visit);
+}
+function mergeIndentFromLevel(paragraphProps, levelProps) {
+	if (!levelProps) return paragraphProps;
+	const out = { ...paragraphProps };
+	if (out.indentLeft === void 0 && levelProps.indentLeft !== void 0) out.indentLeft = levelProps.indentLeft;
+	if (out.indentRight === void 0 && levelProps.indentRight !== void 0) out.indentRight = levelProps.indentRight;
+	if (out.indentFirstLine === void 0 && levelProps.indentFirstLine !== void 0) out.indentFirstLine = levelProps.indentFirstLine;
+	return out;
+}
+function applyNumberingToHeadersFooters(hf, numbering) {
+	if (!hf || hf.size === 0) return /* @__PURE__ */ new Map();
+	if (!numbering || numbering.abstractNums.size === 0) return hf;
+	const out = /* @__PURE__ */ new Map();
+	for (const [key, value] of hf) out.set(key, applyNumbering(value, numbering));
+	return out;
+}
+//#endregion
+export { applyNumbering, applyNumberingToHeadersFooters };

package/dist/esm/core/numbering/index.d.ts

@@ -0,0 +1,2 @@
+export { NumberingState, formatLevelMarker } from './state.js';
+export { applyNumbering, applyNumberingToHeadersFooters } from './apply.js';

package/dist/esm/{numbering → core/numbering}/state.js

@@ -1,4 +1,4 @@
-//#region src/numbering/state.ts
+//#region src/core/numbering/state.ts
 var NumberingState = class {
 	counters = /* @__PURE__ */ new Map();
 	resolveMarker(numbering, ref) {

package/dist/esm/{opc → core/opc}/core-properties.js

@@ -1,5 +1,5 @@
 import { XMLParser } from "fast-xml-parser";
-//#region src/opc/core-properties.ts
+//#region src/core/opc/core-properties.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
 	ignoreAttributes: false,

package/dist/esm/{opc → core/opc}/package.d.ts

@@ -9,11 +9,12 @@ export declare class OpcPackage {
     private readonly parts;
     private readonly rootRelationships;
     private constructor();
+    private readonly relsCache;
     static open(buffer: Uint8Array, options?: OpcOpenOptions): OpcPackage;
     getPart(path: string): Uint8Array | undefined;
     requirePart(path: string): Uint8Array;
     listParts(): Array<string>;
-    getPartRelationships(partPath: string): Array<Relationship>;
+    getPartRelationships(partPath: string): ReadonlyArray<Relationship>;
     resolveRelatedPart(sourcePartPath: string, relationship: Relationship): {
         readonly path: string;
         readonly data: Uint8Array;

package/dist/esm/{opc → core/opc}/package.js

@@ -1,7 +1,7 @@
 import { parseRelationships } from "./relationships.js";
 import "./relationship-types.js";
 import { unzipSync } from "fflate";
-//#region src/opc/package.ts
+//#region src/core/opc/package.ts
 var ROOT_RELS_PATH = "_rels/.rels";
 var MIB = 1024 * 1024;
 var OpcPackage = class OpcPackage {
@@ -9,6 +9,7 @@ var OpcPackage = class OpcPackage {
 		this.parts = parts;
 		this.rootRelationships = rootRelationships;
 	}
+	relsCache = /* @__PURE__ */ new Map();
 	static open(buffer, options = {}) {
 		const maxArchive = options.maxArchiveBytes ?? 128 * MIB;
 		const maxEntry = options.maxEntryBytes ?? 256 * MIB;
@@ -54,13 +55,16 @@ var OpcPackage = class OpcPackage {
 	}
 	getPartRelationships(partPath) {
 		const normalized = normalizePath(partPath);
+		const cached = this.relsCache.get(normalized);
+		if (cached) return cached;
 		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);
+		const rels = data ? parseRelationships(data) : [];
+		this.relsCache.set(normalized, rels);
+		return rels;
 	}
 	resolveRelatedPart(sourcePartPath, relationship) {
 		if (relationship.targetMode !== "Internal") return void 0;

package/dist/esm/{opc → core/opc}/relationship-types.js

@@ -1,4 +1,4 @@
-//#region src/opc/relationship-types.ts
+//#region src/core/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 → core/opc}/relationships.js

@@ -1,5 +1,5 @@
 import { XMLParser } from "fast-xml-parser";
-//#region src/opc/relationships.ts
+//#region src/core/opc/relationships.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
 	ignoreAttributes: false,

package/dist/esm/{ooxml/wordproc → core}/po-helpers.js

@@ -1,4 +1,4 @@
-//#region src/ooxml/wordproc/po-helpers.ts
+//#region src/core/po-helpers.ts
 var ATTRS_KEY = ":@";
 var TEXT_KEY = "#text";
 function poTag(node) {

package/dist/esm/core/style-cascade/index.d.ts

@@ -0,0 +1,3 @@
+export { EMPTY_STYLE_SHEET, resolveBodyStyles, resolveHeadersFootersStyles, resolveParagraphProperties, resolveRunProperties, } from './resolver.js';
+export type { ResolvedRunProperties, ResolvedParagraphProperties, } from './types.js';
+export { DEFAULT_RESOLVED_RUN, DEFAULT_RESOLVED_PARAGRAPH } from './types.js';

package/dist/esm/core/style-cascade/index.js

@@ -0,0 +1,2 @@
+import "./types.js";
+import "./resolver.js";

package/dist/esm/core/style-cascade/resolver.d.ts

@@ -0,0 +1,7 @@
+import { BodyElement, ParagraphProperties, RunProperties, StyleSheet } from '../document-model/index.js';
+import { ResolvedParagraphProperties, ResolvedRunProperties } from './types.js';
+export declare const EMPTY_STYLE_SHEET: StyleSheet;
+export declare function resolveRunProperties(runDirect: RunProperties, paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedRunProperties;
+export declare function resolveParagraphProperties(paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedParagraphProperties;
+export declare function resolveBodyStyles(body: ReadonlyArray<BodyElement>, sheet: StyleSheet): Array<BodyElement>;
+export declare function resolveHeadersFootersStyles(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>>, sheet: StyleSheet): ReadonlyMap<string, ReadonlyArray<BodyElement>>;

package/dist/esm/{style-cascade → core/style-cascade}/resolver.js

@@ -1,6 +1,29 @@
 import { DEFAULT_RESOLVED_PARAGRAPH, DEFAULT_RESOLVED_RUN } from "./types.js";
-//#region src/style-cascade/resolver.ts
+//#region src/core/style-cascade/resolver.ts
+var EMPTY_STYLE_SHEET = {
+	defaultRunProperties: {},
+	defaultParagraphProperties: {},
+	styles: /* @__PURE__ */ new Map()
+};
+var runCascadeCache = /* @__PURE__ */ new WeakMap();
 function resolveRunProperties(runDirect, paragraphDirect, sheet) {
+	let bySheet = runCascadeCache.get(sheet);
+	if (!bySheet) {
+		bySheet = /* @__PURE__ */ new WeakMap();
+		runCascadeCache.set(sheet, bySheet);
+	}
+	let byRun = bySheet.get(runDirect);
+	if (!byRun) {
+		byRun = /* @__PURE__ */ new WeakMap();
+		bySheet.set(runDirect, byRun);
+	}
+	const hit = byRun.get(paragraphDirect);
+	if (hit) return hit;
+	const resolved = computeRunProperties(runDirect, paragraphDirect, sheet);
+	byRun.set(paragraphDirect, resolved);
+	return resolved;
+}
+function computeRunProperties(runDirect, paragraphDirect, sheet) {
 	let acc = mergeRun(DEFAULT_RESOLVED_RUN, sheet.defaultRunProperties);
 	if (paragraphDirect.styleId) {
 		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
@@ -52,7 +75,7 @@ function mergeRun(base, override) {
 		italic: override.italic ?? base.italic,
 		underline: override.underline ?? base.underline,
 		strike: override.strike ?? base.strike,
-		fontSizeHalfPoints: override.fontSizeHalfPoints ?? base.fontSizeHalfPoints,
+		fontSizePt: override.fontSizePt ?? base.fontSizePt,
 		colorHex: override.colorHex ?? base.colorHex,
 		fontFamily: override.fontFamily ?? base.fontFamily,
 		verticalAlign: override.verticalAlign ?? base.verticalAlign,
@@ -63,19 +86,21 @@ function mergeRun(base, override) {
 function mergePar(base, override) {
 	const outlineLevel = override.outlineLevel ?? base.outlineLevel;
 	const styleId = override.styleId ?? base.styleId;
+	const numbering = override.numbering ?? base.numbering;
 	return {
 		alignment: override.alignment ?? base.alignment,
-		spacingBeforeTwips: override.spacingBeforeTwips ?? base.spacingBeforeTwips,
-		spacingAfterTwips: override.spacingAfterTwips ?? base.spacingAfterTwips,
-		spacingLineTwips: override.spacingLineTwips ?? base.spacingLineTwips,
+		spacingBefore: override.spacingBefore ?? base.spacingBefore,
+		spacingAfter: override.spacingAfter ?? base.spacingAfter,
+		spacingLine: override.spacingLine ?? base.spacingLine,
 		spacingLineRule: override.spacingLineRule ?? base.spacingLineRule,
-		indentLeftTwips: override.indentLeftTwips ?? base.indentLeftTwips,
-		indentRightTwips: override.indentRightTwips ?? base.indentRightTwips,
-		indentFirstLineTwips: override.indentFirstLineTwips ?? base.indentFirstLineTwips,
+		indentLeft: override.indentLeft ?? base.indentLeft,
+		indentRight: override.indentRight ?? base.indentRight,
+		indentFirstLine: override.indentFirstLine ?? base.indentFirstLine,
 		pageBreakBefore: override.pageBreakBefore ?? base.pageBreakBefore,
 		bidi: override.bidi ?? base.bidi,
 		...outlineLevel !== void 0 ? { outlineLevel } : {},
-		...styleId !== void 0 ? { styleId } : {}
+		...styleId !== void 0 ? { styleId } : {},
+		...numbering !== void 0 ? { numbering } : {}
 	};
 }
 function mergeRunPartial(base, override) {
@@ -92,5 +117,52 @@ function copyDefined(base, override) {
 	}
 	return out;
 }
+function resolveBodyStyles(body, sheet) {
+	const visitParagraph = (p) => ({
+		...p,
+		properties: resolveParagraphProperties(p.properties, sheet),
+		runs: p.runs.map((r) => ({
+			...r,
+			properties: resolveRunProperties(r.properties, p.properties, sheet)
+		}))
+	});
+	const visit = (el) => {
+		if (el.kind === "paragraph") return {
+			kind: "paragraph",
+			paragraph: visitParagraph(el.paragraph)
+		};
+		if (el.kind === "table") return {
+			kind: "table",
+			table: {
+				...el.table,
+				rows: el.table.rows.map((row) => ({
+					...row,
+					cells: row.cells.map((cell) => ({
+						...cell,
+						content: cell.content.map(visit)
+					}))
+				}))
+			}
+		};
+		if (el.kind === "shape" && el.shape.text) return {
+			kind: "shape",
+			shape: {
+				...el.shape,
+				text: {
+					...el.shape.text,
+					content: el.shape.text.content.map(visit)
+				}
+			}
+		};
+		return el;
+	};
+	return body.map(visit);
+}
+function resolveHeadersFootersStyles(hf, sheet) {
+	if (hf.size === 0) return hf;
+	const out = /* @__PURE__ */ new Map();
+	for (const [key, value] of hf) out.set(key, resolveBodyStyles(value, sheet));
+	return out;
+}
 //#endregion
-export { resolveParagraphProperties, resolveRunProperties };
+export { EMPTY_STYLE_SHEET, resolveBodyStyles, resolveHeadersFootersStyles, resolveParagraphProperties, resolveRunProperties };

package/dist/esm/{style-cascade → core/style-cascade}/types.d.ts

@@ -1,10 +1,11 @@
-import { Alignment, FontFamilyMap, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
+import { Alignment, FontFamilyMap, NumberingReference, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
+import { Pt } from '../ir/index.js';
 export interface ResolvedRunProperties {
     readonly bold: boolean;
     readonly italic: boolean;
     readonly underline: UnderlineStyle;
     readonly strike: boolean;
-    readonly fontSizeHalfPoints: number;
+    readonly fontSizePt: Pt;
     readonly colorHex: string;
     readonly fontFamily: FontFamilyMap;
     readonly verticalAlign: VerticalAlign;
@@ -13,17 +14,18 @@ export interface ResolvedRunProperties {
 }
 export interface ResolvedParagraphProperties {
     readonly alignment: Alignment;
-    readonly spacingBeforeTwips: number;
-    readonly spacingAfterTwips: number;
-    readonly spacingLineTwips: number;
+    readonly spacingBefore: Pt;
+    readonly spacingAfter: Pt;
+    readonly spacingLine: Pt;
     readonly spacingLineRule: 'auto' | 'exact' | 'atLeast';
-    readonly indentLeftTwips: number;
-    readonly indentRightTwips: number;
-    readonly indentFirstLineTwips: number;
+    readonly indentLeft: Pt;
+    readonly indentRight: Pt;
+    readonly indentFirstLine: Pt;
     readonly pageBreakBefore: boolean;
     readonly bidi: boolean;
     readonly outlineLevel?: number;
     readonly styleId?: string;
+    readonly numbering?: NumberingReference;
 }
 export declare const DEFAULT_RESOLVED_RUN: ResolvedRunProperties;
 export declare const DEFAULT_RESOLVED_PARAGRAPH: ResolvedParagraphProperties;

package/dist/esm/{style-cascade → core/style-cascade}/types.js

@@ -1,10 +1,11 @@
-//#region src/style-cascade/types.ts
+import { halfPtToPt, twipsToPt } from "../ir/units.js";
+//#region src/core/style-cascade/types.ts
 var DEFAULT_RESOLVED_RUN = {
 	bold: false,
 	italic: false,
 	underline: "none",
 	strike: false,
-	fontSizeHalfPoints: 22,
+	fontSizePt: halfPtToPt(22),
 	colorHex: "000000",
 	fontFamily: {},
 	verticalAlign: "baseline",
@@ -12,13 +13,13 @@ var DEFAULT_RESOLVED_RUN = {
 };
 var DEFAULT_RESOLVED_PARAGRAPH = {
 	alignment: "left",
-	spacingBeforeTwips: 0,
-	spacingAfterTwips: 0,
-	spacingLineTwips: 240,
+	spacingBefore: twipsToPt(0),
+	spacingAfter: twipsToPt(0),
+	spacingLine: twipsToPt(240),
 	spacingLineRule: "auto",
-	indentLeftTwips: 0,
-	indentRightTwips: 0,
-	indentFirstLineTwips: 0,
+	indentLeft: twipsToPt(0),
+	indentRight: twipsToPt(0),
+	indentFirstLine: twipsToPt(0),
 	pageBreakBefore: false,
 	bidi: false
 };

package/dist/esm/core/vector.d.ts

@@ -0,0 +1,45 @@
+export type PathSegment = {
+    readonly op: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'close';
+};
+export interface VectorPath {
+    readonly segments: ReadonlyArray<PathSegment>;
+    readonly fillRule?: 'nonzero' | 'evenodd';
+}
+export interface StrokeStyle {
+    readonly colorHex: string;
+    readonly widthPt: number;
+    readonly cap?: 'butt' | 'round' | 'square';
+    readonly join?: 'miter' | 'round' | 'bevel';
+    readonly dash?: ReadonlyArray<number>;
+}
+export interface VectorShape {
+    readonly paths: ReadonlyArray<VectorPath>;
+    readonly fillColorHex?: string;
+    readonly stroke?: StrokeStyle;
+    readonly transform: readonly [number, number, number, number, number, number];
+}
+export declare class PathBuilder {
+    private readonly segments;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    cubicTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
+    append(segments: ReadonlyArray<PathSegment>): this;
+    close(): this;
+    build(fillRule?: 'nonzero' | 'evenodd'): VectorPath;
+}

package/dist/esm/core/vector.js

@@ -0,0 +1,48 @@
+//#region src/core/vector.ts
+var PathBuilder = class {
+	segments = [];
+	moveTo(x, y) {
+		this.segments.push({
+			op: "move",
+			x,
+			y
+		});
+		return this;
+	}
+	lineTo(x, y) {
+		this.segments.push({
+			op: "line",
+			x,
+			y
+		});
+		return this;
+	}
+	cubicTo(x1, y1, x2, y2, x, y) {
+		this.segments.push({
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		});
+		return this;
+	}
+	append(segments) {
+		for (const s of segments) this.segments.push(s);
+		return this;
+	}
+	close() {
+		this.segments.push({ op: "close" });
+		return this;
+	}
+	build(fillRule) {
+		return {
+			segments: this.segments.slice(),
+			...fillRule ? { fillRule } : {}
+		};
+	}
+};
+//#endregion
+export { PathBuilder };

package/dist/esm/{ooxml/spreadsheet → excel}/cell-reference.js

@@ -1,4 +1,4 @@
-//#region src/ooxml/spreadsheet/cell-reference.ts
+//#region src/excel/cell-reference.ts
 var A = 65;
 var Z = 90;
 var a = 97;

package/dist/esm/{ooxml/spreadsheet → excel}/defined-name-ref.js

@@ -1,5 +1,5 @@
 import { parseCellRef } from "./cell-reference.js";
-//#region src/ooxml/spreadsheet/defined-name-ref.ts
+//#region src/excel/defined-name-ref.ts
 function stripQualifier(token) {
 	const bang = token.lastIndexOf("!");
 	return (bang >= 0 ? token.substring(bang + 1) : token).replace(/\$/g, "").trim();

package/dist/esm/{ooxml/spreadsheet → excel}/index.d.ts

@@ -4,7 +4,7 @@ export { parseAreaRef, parseTitleRowRange } from './defined-name-ref.js';
 export type { CellRange } from './defined-name-ref.js';
 export { parseSharedStrings } from './shared-strings-parser.js';
 export { parseWorkbook } from './workbook-parser.js';
-export type { DefinedName, ParsedWorkbook, SheetReference, } from './workbook-parser.js';
+export type { DefinedName, ParsedWorkbook, SheetReference } from './workbook-parser.js';
 export { parseWorksheet } from './worksheet-parser.js';
 export type { CellType, ColumnWidth, MergedRange, ParsedWorksheet, RowHeight, WorksheetCell, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, } from './worksheet-parser.js';
 export { parseXlsxStyles, EMPTY_XLSX_STYLES } from './styles-parser.js';

package/dist/esm/{ooxml/spreadsheet → excel}/number-format.js

@@ -1,4 +1,4 @@
-//#region src/ooxml/spreadsheet/number-format.ts
+//#region src/excel/number-format.ts
 var BUILTIN = new Map([
 	[0, "General"],
 	[1, "0"],

package/dist/esm/excel/print-model.d.ts

@@ -0,0 +1,18 @@
+import { BodyElement, SectionProperties } from '../core/document-model/index.js';
+import { CellRange, DefinedName, ParsedWorksheet, XlsxStyles } from './index.js';
+export declare function sectionFromWorksheet(worksheet: ParsedWorksheet): SectionProperties | undefined;
+export declare function resolvePrintArea(definedNames: ReadonlyArray<DefinedName>, sheetIdx: number): CellRange | undefined;
+export declare function resolvePrintTitleRows(definedNames: ReadonlyArray<DefinedName>, sheetIdx: number): {
+    readonly startRow: number;
+    readonly endRow: number;
+} | undefined;
+interface PrintModelOptions {
+    readonly printArea?: CellRange;
+    readonly gridLines: boolean;
+    readonly titleRows?: {
+        readonly startRow: number;
+        readonly endRow: number;
+    };
+}
+export declare function worksheetToBody(worksheet: ParsedWorksheet, sharedStrings: Array<string>, styles: XlsxStyles, date1904: boolean, print: PrintModelOptions): Array<BodyElement>;
+export {};