reamkit 1.3.0 → 1.5.0

package/dist/esm/excel/sheet-drawing.d.ts

@@ -1,5 +1,5 @@
 import { OpcPackage } from '../core/opc/index.js';
-import { ParsedWorksheet } from './worksheet-parser.js';
+import { ParsedWorksheet } from '../core/spreadsheet-model/index.js';
 export interface SheetChartRef {
     readonly chartPartPath: string;
     readonly widthPt: number;

package/dist/esm/excel/sheet-to-flow.d.ts

@@ -0,0 +1,3 @@
+import { FlowDoc } from '../core/ir/flow.js';
+import { SheetDoc } from '../core/ir/sheet.js';
+export declare function projectSheetDoc(sheet: SheetDoc): FlowDoc;

package/dist/esm/excel/sheet-to-flow.js

@@ -0,0 +1,51 @@
+import { pt } from "../core/ir/units.js";
+import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+import { resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, worksheetToBody } from "./print-model.js";
+//#region src/excel/sheet-to-flow.ts
+function projectSheetDoc(sheet) {
+	const body = [];
+	let firstSheetSection;
+	const sheetGrids = new Map(sheet.sheets.map((s) => [s.name, s.grid]));
+	for (let sheetIdx = 0; sheetIdx < sheet.sheets.length; sheetIdx++) {
+		const ws = sheet.sheets[sheetIdx];
+		if (sheetIdx === 0) firstSheetSection = sectionFromWorksheet(ws.grid);
+		if (sheetIdx > 0) body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: { pageBreakBefore: true },
+				runs: []
+			}
+		});
+		const printArea = resolvePrintArea(sheet.definedNames, sheetIdx);
+		const titleRows = resolvePrintTitleRows(sheet.definedNames, sheetIdx);
+		const gridLines = ws.grid.printOptions?.gridLines === true;
+		body.push(...worksheetToBody(ws.grid, sheet.sharedStrings, sheet.styles, sheet.date1904, {
+			...printArea ? { printArea } : {},
+			...titleRows ? { titleRows } : {},
+			gridLines,
+			sheetGrids
+		}));
+		for (const ref of ws.charts ?? []) body.push({
+			kind: "chart",
+			chart: {
+				chartRelId: ref.chartPartPath,
+				width: pt(ref.widthPt),
+				height: pt(ref.heightPt),
+				paragraphProperties: {}
+			}
+		});
+	}
+	return {
+		kind: "flow",
+		body: resolveBodyStyles(body, EMPTY_STYLE_SHEET),
+		sections: [],
+		...firstSheetSection ? { section: firstSheetSection } : {},
+		styles: EMPTY_STYLE_SHEET,
+		resources: sheet.resources,
+		...sheet.chartData && sheet.chartData.size > 0 ? { charts: sheet.chartData } : {},
+		...sheet.info ? { info: sheet.info } : {}
+	};
+}
+//#endregion
+export { projectSheetDoc };

package/dist/esm/excel/styles-parser.d.ts

@@ -1,52 +1,3 @@
-export interface XlsxFont {
-    readonly sizePt?: number;
-    readonly bold?: boolean;
-    readonly italic?: boolean;
-    readonly underline?: boolean;
-    readonly colorHex?: string;
-    readonly name?: string;
-}
-export interface XlsxFill {
-    readonly patternType?: string;
-    readonly fgColorHex?: string;
-    readonly bgColorHex?: string;
-}
-export type XlsxBorderStyleName = 'none' | 'thin' | 'medium' | 'thick' | 'hair' | 'dashed' | 'dotted' | 'double' | 'mediumDashed' | 'dashDot' | 'mediumDashDot' | 'dashDotDot' | 'mediumDashDotDot' | 'slantDashDot';
-export interface XlsxBorderEdge {
-    readonly style?: XlsxBorderStyleName;
-    readonly colorHex?: string;
-}
-export interface XlsxBorder {
-    readonly top?: XlsxBorderEdge;
-    readonly right?: XlsxBorderEdge;
-    readonly bottom?: XlsxBorderEdge;
-    readonly left?: XlsxBorderEdge;
-}
-export type XlsxHorizontalAlign = 'left' | 'center' | 'right' | 'fill' | 'justify' | 'centerContinuous' | 'distributed';
-export type XlsxVerticalAlign = 'top' | 'center' | 'bottom' | 'justify' | 'distributed';
-export interface XlsxCellAlignment {
-    readonly horizontal?: XlsxHorizontalAlign;
-    readonly vertical?: XlsxVerticalAlign;
-    readonly wrapText?: boolean;
-}
-export interface XlsxCellXf {
-    readonly numFmtId: number;
-    readonly fontId: number;
-    readonly fillId: number;
-    readonly borderId: number;
-    readonly applyNumberFormat?: boolean;
-    readonly applyFont?: boolean;
-    readonly applyFill?: boolean;
-    readonly applyBorder?: boolean;
-    readonly applyAlignment?: boolean;
-    readonly alignment?: XlsxCellAlignment;
-}
-export interface XlsxStyles {
-    readonly numFmts: ReadonlyMap<number, string>;
-    readonly fonts: ReadonlyArray<XlsxFont>;
-    readonly fills: ReadonlyArray<XlsxFill>;
-    readonly borders: ReadonlyArray<XlsxBorder>;
-    readonly cellXfs: ReadonlyArray<XlsxCellXf>;
-}
+import { XlsxStyles } from '../core/spreadsheet-model/index.js';
 export declare const EMPTY_XLSX_STYLES: XlsxStyles;
 export declare function parseXlsxStyles(data: Uint8Array): XlsxStyles;

package/dist/esm/excel/styles-parser.js

@@ -21,14 +21,51 @@ function parseXlsxStyles(data) {
 	const xml = decoder.decode(data);
 	const root = asObject(parser.parse(xml)["styleSheet"]);
 	if (!root) return EMPTY_XLSX_STYLES;
+	const dxfs = parseDxfs(root);
 	return {
 		numFmts: parseNumFmts(root),
 		fonts: parseFonts(root),
 		fills: parseFills(root),
 		borders: parseBorders(root),
-		cellXfs: parseCellXfs(root)
+		cellXfs: parseCellXfs(root),
+		...dxfs.length > 0 ? { dxfs } : {}
 	};
 }
+function parseDxfs(root) {
+	const node = asObject(root["dxfs"]);
+	if (!node) return [];
+	const out = [];
+	for (const item of asArray(node["dxf"])) {
+		const obj = asObject(item);
+		if (!obj) {
+			out.push({});
+			continue;
+		}
+		const dxf = {};
+		const fontObj = asObject(obj["font"]);
+		if (fontObj) {
+			const font = {};
+			if (hasChild(fontObj, "b")) font.bold = childToggle(fontObj, "b");
+			if (hasChild(fontObj, "i")) font.italic = childToggle(fontObj, "i");
+			const colorHex = colorOf(asObject(fontObj["color"]));
+			if (colorHex) font.colorHex = colorHex;
+			if (Object.keys(font).length > 0) dxf.font = font;
+		}
+		const pf = asObject(asObject(obj["fill"])?.["patternFill"]);
+		if (pf) {
+			const fill = {};
+			const pt = strAttr(pf, "patternType");
+			if (pt) fill.patternType = pt;
+			const fg = colorOf(asObject(pf["fgColor"]));
+			const bg = colorOf(asObject(pf["bgColor"]));
+			if (fg) fill.fgColorHex = fg;
+			if (bg) fill.bgColorHex = bg;
+			if (Object.keys(fill).length > 0) dxf.fill = fill;
+		}
+		out.push(dxf);
+	}
+	return out;
+}
 var VALID_BORDER_STYLES = new Set([
 	"none",
 	"thin",

package/dist/esm/excel/table-parser.d.ts

@@ -0,0 +1,2 @@
+import { ExcelTable } from '../core/spreadsheet-model/index.js';
+export declare function parseTablePart(data: Uint8Array): ExcelTable | undefined;

package/dist/esm/excel/table-parser.js

@@ -0,0 +1,51 @@
+import { parseAreaRef } from "./defined-name-ref.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/table-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	removeNSPrefix: true
+});
+function parseTablePart(data) {
+	const t = asObj(parser.parse(decoder.decode(data))["table"]);
+	if (!t) return void 0;
+	const refStr = strAttr(t, "ref");
+	const ref = refStr ? parseAreaRef(refStr) : void 0;
+	if (!ref) return void 0;
+	const si = asObj(t["tableStyleInfo"]);
+	const name = strAttr(t, "name");
+	const styleName = si ? strAttr(si, "name") : void 0;
+	return {
+		ref,
+		...name ? { name } : {},
+		...styleName ? { styleName } : {},
+		headerRowCount: numAttr(t, "headerRowCount") ?? 1,
+		showRowStripes: si ? boolAttr(si, "showRowStripes") : false,
+		showColumnStripes: si ? boolAttr(si, "showColumnStripes") : false,
+		showFirstColumn: si ? boolAttr(si, "showFirstColumn") : false,
+		showLastColumn: si ? boolAttr(si, "showLastColumn") : false,
+		autoFilter: asObj(t["autoFilter"]) !== void 0
+	};
+}
+function asObj(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function strAttr(obj, name) {
+	const v = obj[`@_${name}`];
+	return typeof v === "string" ? v : void 0;
+}
+function numAttr(obj, name) {
+	const v = strAttr(obj, name);
+	if (v === void 0) return void 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : void 0;
+}
+function boolAttr(obj, name) {
+	const v = strAttr(obj, name);
+	return v === "1" || v === "true";
+}
+//#endregion
+export { parseTablePart };

package/dist/esm/excel/workbook-parser.d.ts

@@ -1,13 +1,9 @@
+import { DefinedName } from '../core/spreadsheet-model/index.js';
 export interface SheetReference {
     readonly name: string;
     readonly sheetId: string;
     readonly relationshipId: string;
 }
-export interface DefinedName {
-    readonly name: string;
-    readonly localSheetId?: number;
-    readonly value: string;
-}
 export interface ParsedWorkbook {
     readonly sheets: ReadonlyArray<SheetReference>;
     readonly date1904: boolean;

package/dist/esm/excel/worksheet-parser.d.ts

@@ -1,61 +1,2 @@
-export type CellType = 'n' | 's' | 'str' | 'b' | 'd' | 'e' | 'inlineStr';
-export interface WorksheetCell {
-    readonly column: number;
-    readonly row: number;
-    readonly type: CellType;
-    readonly rawValue: string;
-    readonly inlineText?: string;
-    readonly styleIndex?: number;
-}
-export interface ColumnWidth {
-    readonly min: number;
-    readonly max: number;
-    readonly widthChars: number;
-}
-export interface MergedRange {
-    readonly startColumn: number;
-    readonly startRow: number;
-    readonly endColumn: number;
-    readonly endRow: number;
-}
-export interface RowHeight {
-    readonly row: number;
-    readonly heightPt: number;
-    readonly customHeight: boolean;
-}
-export interface XlsxPageMargins {
-    readonly leftInches: number;
-    readonly rightInches: number;
-    readonly topInches: number;
-    readonly bottomInches: number;
-    readonly headerInches?: number;
-    readonly footerInches?: number;
-}
-export interface XlsxPageSetup {
-    readonly paperSize?: number;
-    readonly orientation?: 'portrait' | 'landscape' | 'default';
-    readonly scale?: number;
-    readonly fitToWidth?: number;
-    readonly fitToHeight?: number;
-}
-export interface XlsxPrintOptions {
-    readonly gridLines?: boolean;
-    readonly horizontalCentered?: boolean;
-    readonly verticalCentered?: boolean;
-}
-export interface ParsedWorksheet {
-    readonly cells: ReadonlyArray<WorksheetCell>;
-    readonly maxRow: number;
-    readonly maxColumn: number;
-    readonly columns: ReadonlyArray<ColumnWidth>;
-    readonly merges: ReadonlyArray<MergedRange>;
-    readonly rowHeights: ReadonlyArray<RowHeight>;
-    readonly pageMargins?: XlsxPageMargins;
-    readonly pageSetup?: XlsxPageSetup;
-    readonly fitToPage?: boolean;
-    readonly printOptions?: XlsxPrintOptions;
-    readonly rowBreaks?: ReadonlyArray<number>;
-    readonly colBreaks?: ReadonlyArray<number>;
-    readonly drawingRelId?: string;
-}
+import { ParsedWorksheet } from '../core/spreadsheet-model/index.js';
 export declare function parseWorksheet(data: Uint8Array): ParsedWorksheet;

package/dist/esm/excel/worksheet-parser.js

@@ -1,4 +1,5 @@
 import { parseCellRef } from "./cell-reference.js";
+import { parseAreaRef } from "./defined-name-ref.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/worksheet-parser.ts
 var decoder = new TextDecoder("utf-8");
@@ -34,6 +35,9 @@ function parseWorksheet(data) {
 	const colBreaks = parseBreaks(wsObj, "colBreaks");
 	const drawingNode = wsObj["drawing"];
 	const drawingRelId = drawingNode && typeof drawingNode === "object" ? strAttr(drawingNode, "id") : void 0;
+	const conditionalFormats = parseConditionalFormatting(wsObj);
+	const sparklines = parseSparklines(wsObj);
+	const tablePartRelIds = parseTableParts(wsObj);
 	const printModel = {
 		...pageMargins ? { pageMargins } : {},
 		...pageSetup ? { pageSetup } : {},
@@ -41,7 +45,10 @@ function parseWorksheet(data) {
 		...printOptions ? { printOptions } : {},
 		...rowBreaks.length > 0 ? { rowBreaks } : {},
 		...colBreaks.length > 0 ? { colBreaks } : {},
-		...drawingRelId !== void 0 ? { drawingRelId } : {}
+		...drawingRelId !== void 0 ? { drawingRelId } : {},
+		...conditionalFormats.length > 0 ? { conditionalFormats } : {},
+		...sparklines.length > 0 ? { sparklines } : {},
+		...tablePartRelIds.length > 0 ? { tablePartRelIds } : {}
 	};
 	const sheetData = wsObj["sheetData"];
 	if (!sheetData || typeof sheetData !== "object") return {
@@ -239,6 +246,237 @@ function parseMerges(ws) {
 	}
 	return out;
 }
+function parseConditionalFormatting(ws) {
+	const raw = ws["conditionalFormatting"];
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const item of items) {
+		if (!item || typeof item !== "object") continue;
+		const obj = item;
+		const sqref = strAttr(obj, "sqref");
+		if (!sqref) continue;
+		const ranges = parseSqref(sqref);
+		if (ranges.length === 0) continue;
+		const ruleRaw = obj["cfRule"];
+		const ruleItems = Array.isArray(ruleRaw) ? ruleRaw : ruleRaw !== void 0 ? [ruleRaw] : [];
+		const rules = [];
+		for (const rn of ruleItems) {
+			if (!rn || typeof rn !== "object") continue;
+			const rule = parseCfRule(rn);
+			if (rule) rules.push(rule);
+		}
+		if (rules.length > 0) out.push({
+			ranges,
+			rules
+		});
+	}
+	return out;
+}
+function parseSqref(sqref) {
+	const out = [];
+	for (const token of sqref.split(/\s+/)) {
+		if (!token) continue;
+		const r = parseAreaRef(token);
+		if (r) out.push({
+			startColumn: r.startColumn,
+			startRow: r.startRow,
+			endColumn: r.endColumn,
+			endRow: r.endRow
+		});
+	}
+	return out;
+}
+var CF_OPERATORS = new Set([
+	"lessThan",
+	"lessThanOrEqual",
+	"equal",
+	"notEqual",
+	"greaterThanOrEqual",
+	"greaterThan",
+	"between",
+	"notBetween"
+]);
+function parseCfRule(obj) {
+	const priority = parseNumericAttr(obj, "priority") ?? 0;
+	switch (strAttr(obj, "type")) {
+		case "cellIs": return parseCellIsRule(obj, priority);
+		case "colorScale": return parseColorScaleRule(obj, priority);
+		case "dataBar": return parseDataBarRule(obj, priority);
+		case "iconSet": return parseIconSetRule(obj, priority);
+		default: return;
+	}
+}
+function parseIconSetRule(obj, priority) {
+	const is = obj["iconSet"];
+	if (!is || typeof is !== "object") return void 0;
+	const isObj = is;
+	const cfvos = parseCfvos(isObj["cfvo"]);
+	if (cfvos.length < 3) return void 0;
+	const iconSet = strAttr(isObj, "iconSet") ?? "3TrafficLights1";
+	const reverseRaw = strAttr(isObj, "reverse");
+	const reverse = reverseRaw === "1" || reverseRaw === "true";
+	return {
+		type: "iconSet",
+		priority,
+		iconSet,
+		cfvos,
+		...reverse ? { reverse } : {}
+	};
+}
+function parseDataBarRule(obj, priority) {
+	const db = obj["dataBar"];
+	if (!db || typeof db !== "object") return void 0;
+	const dbObj = db;
+	const cfvos = parseCfvos(dbObj["cfvo"]);
+	if (cfvos.length < 2) return void 0;
+	const colorHex = colorRgbHex(dbObj["color"]);
+	if (!colorHex) return void 0;
+	const minLength = parseNumericAttr(dbObj, "minLength");
+	const maxLength = parseNumericAttr(dbObj, "maxLength");
+	return {
+		type: "dataBar",
+		priority,
+		cfvos,
+		colorHex,
+		...minLength !== void 0 ? { minLength } : {},
+		...maxLength !== void 0 ? { maxLength } : {}
+	};
+}
+function parseCellIsRule(obj, priority) {
+	const operator = strAttr(obj, "operator");
+	if (!operator || !CF_OPERATORS.has(operator)) return void 0;
+	const dxfId = parseNumericAttr(obj, "dxfId");
+	if (dxfId === void 0) return void 0;
+	const fRaw = obj["formula"];
+	const fItems = Array.isArray(fRaw) ? fRaw : fRaw !== void 0 ? [fRaw] : [];
+	const formulas = [];
+	for (const f of fItems) {
+		const text = formulaText(f);
+		if (text !== void 0) formulas.push(text);
+	}
+	if (formulas.length === 0) return void 0;
+	return {
+		type: "cellIs",
+		priority,
+		operator,
+		formulas,
+		dxfId
+	};
+}
+var CFVO_TYPES = new Set([
+	"num",
+	"percent",
+	"max",
+	"min",
+	"percentile",
+	"formula",
+	"autoMin",
+	"autoMax"
+]);
+function parseColorScaleRule(obj, priority) {
+	const cs = obj["colorScale"];
+	if (!cs || typeof cs !== "object") return void 0;
+	const csObj = cs;
+	const cfvos = parseCfvos(csObj["cfvo"]);
+	const colorsHex = parseScaleColors(csObj["color"]);
+	if (cfvos.length < 2 || cfvos.length !== colorsHex.length) return void 0;
+	return {
+		type: "colorScale",
+		priority,
+		cfvos,
+		colorsHex
+	};
+}
+function parseCfvos(raw) {
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const it of items) {
+		if (!it || typeof it !== "object") continue;
+		const o = it;
+		const type = strAttr(o, "type");
+		if (!type || !CFVO_TYPES.has(type)) return [];
+		const val = strAttr(o, "val");
+		out.push(val !== void 0 ? {
+			type,
+			val
+		} : { type });
+	}
+	return out;
+}
+function parseScaleColors(raw) {
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const it of items) {
+		const hex = colorRgbHex(it);
+		if (!hex) return [];
+		out.push(hex);
+	}
+	return out;
+}
+function colorRgbHex(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const rgb = strAttr(node, "rgb");
+	if (!rgb) return void 0;
+	if (/^[0-9A-Fa-f]{8}$/.test(rgb)) return rgb.substring(2).toUpperCase();
+	if (/^[0-9A-Fa-f]{6}$/.test(rgb)) return rgb.toUpperCase();
+}
+function formulaText(node) {
+	if (typeof node === "string") return node;
+	if (typeof node === "number") return String(node);
+	if (node && typeof node === "object") {
+		const t = node["#text"];
+		if (typeof t === "string") return t;
+		if (typeof t === "number") return String(t);
+	}
+}
+function toArray(v) {
+	return Array.isArray(v) ? v : v === void 0 || v === null ? [] : [v];
+}
+function parseSparklines(ws) {
+	const extLst = asObjectNode(ws["extLst"]);
+	if (!extLst) return [];
+	const out = [];
+	for (const ext of toArray(extLst["ext"])) {
+		const groupsNode = asObjectNode(asObjectNode(ext)?.["sparklineGroups"]);
+		if (!groupsNode) continue;
+		for (const g of toArray(groupsNode["sparklineGroup"])) {
+			const group = asObjectNode(g);
+			if (!group) continue;
+			const typeStr = strAttr(group, "type");
+			const kind = typeStr === "column" ? "column" : typeStr === "stacked" ? "winLoss" : "line";
+			const colorHex = colorRgbHex(group["colorSeries"]);
+			const slNode = asObjectNode(group["sparklines"]);
+			if (!slNode) continue;
+			for (const sl of toArray(slNode["sparkline"])) {
+				const spark = asObjectNode(sl);
+				if (!spark) continue;
+				const dataRange = formulaText(spark["f"]);
+				const sqref = formulaText(spark["sqref"]);
+				if (dataRange && sqref) out.push({
+					kind,
+					dataRange,
+					sqref,
+					...colorHex ? { colorHex } : {}
+				});
+			}
+		}
+	}
+	return out;
+}
+function asObjectNode(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function parseTableParts(ws) {
+	const node = asObjectNode(ws["tableParts"]);
+	if (!node) return [];
+	const out = [];
+	for (const tp of toArray(node["tablePart"])) {
+		const obj = asObjectNode(tp);
+		const rid = obj ? strAttr(obj, "id") : void 0;
+		if (rid) out.push(rid);
+	}
+	return out;
+}
 function parseCell(c, fallbackRow, fallbackCol) {
 	if (!c || typeof c !== "object") return null;
 	const obj = c;

package/dist/esm/excel/xlsx-reader.d.ts

@@ -1,4 +1,6 @@
 import { DocumentReader, ReadResult } from '../core/ir/adapters.js';
 import { FlowDoc } from '../core/ir/flow.js';
+import { SheetDoc } from '../core/ir/sheet.js';
 export declare function readXlsx(xlsx: Uint8Array): ReadResult<FlowDoc>;
-export declare const xlsxReader: DocumentReader<FlowDoc>;
+export declare function readXlsxToSheetDoc(xlsx: Uint8Array): SheetDoc;
+export declare const xlsxReader: DocumentReader<SheetDoc>;