reamkit 1.4.0 → 1.5.0

package/dist/esm/excel/conditional-format.js

@@ -0,0 +1,305 @@
+//#region src/excel/conditional-format.ts
+function buildConditionalFormatter(conditionalFormats, styles, cells) {
+	if (!conditionalFormats || conditionalFormats.length === 0) return void 0;
+	const dxfs = styles.dxfs ?? [];
+	const flat = [];
+	for (const cf of conditionalFormats) for (const rule of cf.rules) if (rule.type === "colorScale") flat.push({
+		ranges: cf.ranges,
+		rule,
+		scale: resolveColorScale(rule, cf.ranges, cells)
+	});
+	else if (rule.type === "dataBar") flat.push({
+		ranges: cf.ranges,
+		rule,
+		bar: resolveDataBar(rule, cf.ranges, cells)
+	});
+	else if (rule.type === "iconSet") flat.push({
+		ranges: cf.ranges,
+		rule,
+		iconThresholds: resolveIconThresholds(rule, cf.ranges, cells)
+	});
+	else flat.push({
+		ranges: cf.ranges,
+		rule
+	});
+	flat.sort((a, b) => a.rule.priority - b.rule.priority);
+	return (row, col, value) => {
+		if (value === void 0) return void 0;
+		let textFmt;
+		let textClaimed = false;
+		let bar;
+		let icon;
+		for (const { ranges, rule, scale, bar: resolved, iconThresholds } of flat) {
+			if (!coversCell(ranges, row, col)) continue;
+			switch (rule.type) {
+				case "cellIs":
+					if (!textClaimed && cellIsMatches(rule.operator, value, rule.formulas)) {
+						textFmt = dxfToOverride(dxfs[rule.dxfId]);
+						textClaimed = true;
+					}
+					break;
+				case "colorScale":
+					if (!textClaimed && scale) {
+						textFmt = { fillHex: rgbHex(colorScaleColor(scale, value)) };
+						textClaimed = true;
+					}
+					break;
+				case "dataBar":
+					if (!bar && resolved) bar = dataBarBar(resolved, value);
+					break;
+				case "iconSet":
+					if (!icon && iconThresholds) {
+						const bucket = iconBucket(iconThresholds, value);
+						icon = iconToCell(rule.iconSet, iconThresholds.length, bucket, rule.reverse ?? false);
+					}
+					break;
+			}
+		}
+		if (!bar && !icon) return textFmt;
+		return {
+			...textFmt ?? {},
+			...bar ? { dataBar: bar } : {},
+			...icon ? { icon } : {}
+		};
+	};
+}
+function coversCell(ranges, row, col) {
+	for (const r of ranges) if (row >= r.startRow && row <= r.endRow && col >= r.startColumn && col <= r.endColumn) return true;
+	return false;
+}
+function cellIsMatches(operator, value, formulas) {
+	const a = Number(formulas[0]);
+	if (!Number.isFinite(a)) return false;
+	switch (operator) {
+		case "lessThan": return value < a;
+		case "lessThanOrEqual": return value <= a;
+		case "equal": return value === a;
+		case "notEqual": return value !== a;
+		case "greaterThanOrEqual": return value >= a;
+		case "greaterThan": return value > a;
+		case "between":
+		case "notBetween": {
+			const b = Number(formulas[1]);
+			if (!Number.isFinite(b)) return false;
+			const inside = value >= Math.min(a, b) && value <= Math.max(a, b);
+			return operator === "between" ? inside : !inside;
+		}
+	}
+}
+function dxfToOverride(dxf) {
+	if (!dxf) return void 0;
+	const fillHex = dxf.fill?.bgColorHex ?? dxf.fill?.fgColorHex;
+	const out = {};
+	if (fillHex) out.fillHex = fillHex;
+	if (dxf.font?.colorHex) out.fontColorHex = dxf.font.colorHex;
+	if (dxf.font?.bold !== void 0) out.bold = dxf.font.bold;
+	if (dxf.font?.italic !== void 0) out.italic = dxf.font.italic;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function collectRangeValues(cells, ranges) {
+	const out = [];
+	for (const cell of cells) {
+		if (cell.type !== "n") continue;
+		const n = Number(cell.rawValue);
+		if (!Number.isFinite(n)) continue;
+		if (coversCell(ranges, cell.row, cell.column)) out.push(n);
+	}
+	return out;
+}
+function resolveColorScale(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const sorted = [...vals].sort((a, b) => a - b);
+	const vmin = sorted[0];
+	const vmax = sorted[sorted.length - 1];
+	const thresholds = [];
+	for (const cfvo of rule.cfvos) {
+		const t = resolveCfvo(cfvo, vmin, vmax, sorted);
+		if (t === void 0) return void 0;
+		thresholds.push(t);
+	}
+	const colors = [];
+	for (const hex of rule.colorsHex) {
+		const rgb = parseRgb(hex);
+		if (!rgb) return void 0;
+		colors.push(rgb);
+	}
+	if (thresholds.length < 2 || thresholds.length !== colors.length) return void 0;
+	for (let i = 1; i < thresholds.length; i++) if (thresholds[i] < thresholds[i - 1]) thresholds[i] = thresholds[i - 1];
+	return {
+		thresholds,
+		colors
+	};
+}
+function resolveCfvo(cfvo, vmin, vmax, sorted) {
+	switch (cfvo.type) {
+		case "min":
+		case "autoMin": return vmin;
+		case "max":
+		case "autoMax": return vmax;
+		case "num":
+		case "formula": {
+			const n = Number(cfvo.val);
+			return Number.isFinite(n) ? n : void 0;
+		}
+		case "percent": {
+			const p = Number(cfvo.val);
+			return Number.isFinite(p) ? vmin + (vmax - vmin) * (p / 100) : void 0;
+		}
+		case "percentile": {
+			const p = Number(cfvo.val);
+			return Number.isFinite(p) ? percentile(sorted, p) : void 0;
+		}
+	}
+}
+function percentile(sorted, p) {
+	const n = sorted.length;
+	if (n === 1) return sorted[0];
+	const rank = Math.min(100, Math.max(0, p)) / 100 * (n - 1);
+	const lo = Math.floor(rank);
+	const frac = rank - lo;
+	const a = sorted[lo];
+	return a + frac * (sorted[Math.min(lo + 1, n - 1)] - a);
+}
+function colorScaleColor(scale, value) {
+	const { thresholds: t, colors } = scale;
+	const last = t.length - 1;
+	if (value <= t[0]) return colors[0];
+	if (value >= t[last]) return colors[last];
+	let i = 0;
+	while (i < last && value > t[i + 1]) i++;
+	const a = t[i];
+	const b = t[i + 1];
+	const f = b > a ? (value - a) / (b - a) : 0;
+	return lerpRgb(colors[i], colors[i + 1], f);
+}
+function lerpRgb(c0, c1, f) {
+	return [
+		c0[0] + (c1[0] - c0[0]) * f,
+		c0[1] + (c1[1] - c0[1]) * f,
+		c0[2] + (c1[2] - c0[2]) * f
+	];
+}
+function parseRgb(hex) {
+	const h = hex.length === 8 ? hex.slice(2) : hex;
+	if (!/^[0-9A-Fa-f]{6}$/.test(h)) return void 0;
+	return [
+		parseInt(h.slice(0, 2), 16),
+		parseInt(h.slice(2, 4), 16),
+		parseInt(h.slice(4, 6), 16)
+	];
+}
+function rgbHex([r, g, b]) {
+	const h = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0").toUpperCase();
+	return `${h(r)}${h(g)}${h(b)}`;
+}
+function resolveDataBar(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const sorted = [...vals].sort((a, b) => a - b);
+	const vmin = sorted[0];
+	const vmax = sorted[sorted.length - 1];
+	const lower = resolveCfvo(rule.cfvos[0], vmin, vmax, sorted);
+	const upper = resolveCfvo(rule.cfvos[1], vmin, vmax, sorted);
+	if (lower === void 0 || upper === void 0) return void 0;
+	return {
+		lower,
+		upper,
+		colorHex: rule.colorHex,
+		negativeColorHex: "FF0000",
+		minLen: (rule.minLength ?? 0) / 100,
+		maxLen: (rule.maxLength ?? 100) / 100
+	};
+}
+function dataBarBar(bar, value) {
+	if (bar.lower < 0 && bar.upper > 0) {
+		const axis = -bar.lower / (bar.upper - bar.lower);
+		if (value >= 0) return {
+			fraction: value / bar.upper * (1 - axis),
+			colorHex: bar.colorHex,
+			startFraction: axis
+		};
+		const w = Math.abs(value) / Math.abs(bar.lower) * axis;
+		return {
+			fraction: w,
+			colorHex: bar.negativeColorHex,
+			startFraction: axis - w
+		};
+	}
+	return {
+		fraction: dataBarFraction(bar, value),
+		colorHex: bar.colorHex
+	};
+}
+function dataBarFraction(bar, value) {
+	const t = bar.upper > bar.lower ? Math.min(1, Math.max(0, (value - bar.lower) / (bar.upper - bar.lower))) : value >= bar.upper ? 1 : 0;
+	return bar.minLen + t * (bar.maxLen - bar.minLen);
+}
+function resolveIconThresholds(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const sorted = [...vals].sort((a, b) => a - b);
+	const vmin = sorted[0];
+	const vmax = sorted[sorted.length - 1];
+	const out = [];
+	for (const cfvo of rule.cfvos) {
+		const t = resolveCfvo(cfvo, vmin, vmax, sorted);
+		if (t === void 0) return void 0;
+		out.push(t);
+	}
+	return out;
+}
+function iconBucket(thresholds, value) {
+	let idx = 0;
+	for (let i = 1; i < thresholds.length; i++) if (value >= thresholds[i]) idx++;
+	return idx;
+}
+function iconToCell(setName, count, index, reverse) {
+	const e = reverse ? count - 1 - index : index;
+	const colorHex = /Gray/i.test(setName) ? GRAY_HEX : iconColor(count, e);
+	return {
+		shape: iconShape(setName, e, count),
+		colorHex
+	};
+}
+var GRAY_HEX = "808080";
+function iconShape(setName, e, count) {
+	if (setName.includes("Arrows")) {
+		if (e <= 0) return "triangleDown";
+		if (e >= count - 1) return "triangleUp";
+		return "triangleRight";
+	}
+	if (setName.includes("Signs")) {
+		if (e <= 0) return "diamond";
+		if (e >= count - 1) return "circle";
+		return "triangleUp";
+	}
+	if (setName.includes("Flags")) return "square";
+	return "circle";
+}
+var ICON_RAMPS = {
+	3: [
+		"FF0000",
+		"FFC000",
+		"00B050"
+	],
+	4: [
+		"FF0000",
+		"FF8C00",
+		"FFC000",
+		"00B050"
+	],
+	5: [
+		"FF0000",
+		"FF8C00",
+		"FFC000",
+		"92D050",
+		"00B050"
+	]
+};
+function iconColor(count, e) {
+	const ramp = ICON_RAMPS[count] ?? ICON_RAMPS[3];
+	return ramp[Math.max(0, Math.min(ramp.length - 1, e))];
+}
+//#endregion
+export { buildConditionalFormatter };

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

@@ -4,9 +4,10 @@ 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 { ParsedWorkbook, SheetReference } from './workbook-parser.js';
+export type { DefinedName } from '../core/spreadsheet-model/index.js';
 export { parseWorksheet } from './worksheet-parser.js';
-export type { CellType, ColumnWidth, MergedRange, ParsedWorksheet, RowHeight, WorksheetCell, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, } from './worksheet-parser.js';
+export type { CellType, ColumnWidth, ExcelTable, MergedRange, ParsedWorksheet, RowHeight, WorksheetCell, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, } from '../core/spreadsheet-model/index.js';
 export { parseXlsxStyles, EMPTY_XLSX_STYLES } from './styles-parser.js';
-export type { XlsxBorder, XlsxBorderEdge, XlsxBorderStyleName, XlsxCellAlignment, XlsxCellXf, XlsxFill, XlsxFont, XlsxHorizontalAlign, XlsxStyles, XlsxVerticalAlign, } from './styles-parser.js';
+export type { XlsxBorder, XlsxBorderEdge, XlsxBorderStyleName, XlsxCellAlignment, XlsxCellXf, XlsxFill, XlsxFont, XlsxHorizontalAlign, XlsxStyles, XlsxVerticalAlign, } from '../core/spreadsheet-model/index.js';
 export { applyNumberFormat } from './number-format.js';

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

@@ -16,6 +16,7 @@ interface PrintModelOptions {
         readonly startRow: number;
         readonly endRow: number;
     };
+    readonly sheetGrids?: ReadonlyMap<string, ParsedWorksheet>;
 }
-export declare function worksheetToBody(worksheet: ParsedWorksheet, sharedStrings: Array<string>, styles: XlsxStyles, date1904: boolean, print: PrintModelOptions): Array<BodyElement>;
+export declare function worksheetToBody(worksheet: ParsedWorksheet, sharedStrings: ReadonlyArray<string>, styles: XlsxStyles, date1904: boolean, print: PrintModelOptions): Array<BodyElement>;
 export {};

package/dist/esm/excel/print-model.js

@@ -2,6 +2,7 @@ import { eighthPtToPt, halfPtToPt, twipsToPt } from "../core/ir/units.js";
 import { parseAreaRef, parseTitleRowRange } from "./defined-name-ref.js";
 import { applyNumberFormat } from "./number-format.js";
 import "./index.js";
+import { buildConditionalFormatter } from "./conditional-format.js";
 var TWIPS_PER_POINT = 20;
 var TWIPS_PER_INCH = 1440;
 var PAPER_SIZES_TWIPS = new Map([
@@ -107,6 +108,12 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		if (m.endRow > usedRow) usedRow = m.endRow;
 		if (m.endColumn > usedCol) usedCol = m.endColumn;
 	}
+	for (const sp of worksheet.sparklines ?? []) {
+		const host = parseAreaRef(sp.sqref);
+		if (!host) continue;
+		if (host.startRow > usedRow) usedRow = host.startRow;
+		if (host.startColumn > usedCol) usedCol = host.startColumn;
+	}
 	if (usedRow < 0 || usedCol < 0) return [];
 	let rowStart = 0;
 	let colStart = 0;
@@ -184,6 +191,9 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		}
 		return props;
 	};
+	const cfFormatter = buildConditionalFormatter(worksheet.conditionalFormats, styles, worksheet.cells);
+	const sparklineByCell = buildSparklineLookup(worksheet, print);
+	const tableFormatByCell = buildTableFormatLookup(worksheet);
 	const rows = [];
 	for (let r = 0; r < rowCount; r++) {
 		const absR = r + rowStart;
@@ -201,10 +211,28 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 			if (text.length > textBudget) text = text.slice(0, Math.max(0, textBudget));
 			textBudget -= text.length;
 			const xf = ws && ws.styleIndex !== void 0 ? styles.cellXfs[ws.styleIndex] : void 0;
-			const runProps = cellRunProps(xf);
+			let runProps = cellRunProps(xf);
 			const alignment = xf ? alignmentFromXf(xf) : void 0;
-			const shading = xf ? shadingFromXf(xf, styles) : void 0;
+			let shading = xf ? shadingFromXf(xf, styles) : void 0;
+			const tableFmt = tableFormatByCell.get(key(absR, absC));
+			if (!shading && tableFmt?.shading) shading = tableFmt.shading;
+			if (tableFmt?.fontColorHex) runProps = {
+				...runProps,
+				colorHex: tableFmt.fontColorHex
+			};
 			const borders = xf ? bordersFromXf(xf, styles) : void 0;
+			let dataBar;
+			let icon;
+			const sparkline = sparklineByCell.get(key(absR, absC));
+			if (cfFormatter && ws) {
+				const over = cfFormatter(absR, absC, ws.type === "n" && Number.isFinite(Number(ws.rawValue)) ? Number(ws.rawValue) : void 0);
+				if (over) {
+					if (over.fillHex) shading = { colorHex: over.fillHex };
+					if (over.dataBar) dataBar = over.dataBar;
+					if (over.icon) icon = over.icon;
+					runProps = applyCfOverride(runProps, over);
+				}
+			}
 			if (text.length > 0 && !merge && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && (alignment === void 0 || alignment === "left")) {
 				let availTwips = columnWidths[c];
 				let cc = c + 1;
@@ -222,6 +250,9 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				...merge && visibleEndCol > merge.startColumn ? { colSpan: visibleEndCol - merge.startColumn + 1 } : {},
 				...merge && Math.min(merge.endRow, rowWindowEnd) > merge.startRow ? { merge: "start" } : {},
 				...shading ? { shading } : {},
+				...dataBar ? { dataBar } : {},
+				...icon ? { icon } : {},
+				...sparkline ? { sparkline } : {},
 				...borders ? { borders } : {}
 			};
 			const paragraphProps = cellParaProps(alignment);
@@ -321,6 +352,14 @@ function runPropsFromXf(xf, styles) {
 	if (font.colorHex) props.colorHex = font.colorHex;
 	return props;
 }
+function applyCfOverride(base, o) {
+	return {
+		...base,
+		...o.fontColorHex ? { colorHex: o.fontColorHex } : {},
+		...o.bold !== void 0 ? { bold: o.bold } : {},
+		...o.italic !== void 0 ? { italic: o.italic } : {}
+	};
+}
 function alignmentFromXf(xf) {
 	const align = xf.alignment;
 	if (!align) return void 0;
@@ -413,6 +452,79 @@ function mapBorderStyle(style) {
 function key(row, col) {
 	return `${row},${col}`;
 }
+function buildSparklineLookup(worksheet, print) {
+	const out = /* @__PURE__ */ new Map();
+	for (const sp of worksheet.sparklines ?? []) {
+		const host = parseAreaRef(sp.sqref);
+		const area = parseAreaRef(sp.dataRange);
+		if (!host || !area) continue;
+		const values = collectSeriesValues(resolveSeriesGrid(sp.dataRange, worksheet, print.sheetGrids).cells, area);
+		if (values.length === 0 || values.every((v) => v === null)) continue;
+		out.set(key(host.startRow, host.startColumn), {
+			kind: sp.kind,
+			values,
+			...sp.colorHex ? { colorHex: sp.colorHex } : {}
+		});
+	}
+	return out;
+}
+function resolveSeriesGrid(dataRange, current, sheetGrids) {
+	if (!sheetGrids) return current;
+	const firstToken = dataRange.split(",")[0] ?? dataRange;
+	const bang = firstToken.lastIndexOf("!");
+	if (bang < 0) return current;
+	let name = firstToken.slice(0, bang).trim();
+	if (name.startsWith("'") && name.endsWith("'")) name = name.slice(1, -1).replace(/''/g, "'");
+	return sheetGrids.get(name) ?? current;
+}
+var MAX_SPARKLINE_POINTS = 1e3;
+function collectSeriesValues(cells, area) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const c of cells) {
+		if (c.row < area.startRow || c.row > area.endRow) continue;
+		if (c.column < area.startColumn || c.column > area.endColumn) continue;
+		if (c.type !== "n") continue;
+		const v = Number(c.rawValue);
+		if (Number.isFinite(v)) byKey.set(key(c.row, c.column), v);
+	}
+	if ((area.endRow - area.startRow + 1) * (area.endColumn - area.startColumn + 1) > MAX_SPARKLINE_POINTS) {
+		const pts = [...byKey.entries()].map(([k, v]) => {
+			const [r, col] = k.split(",").map(Number);
+			return {
+				r,
+				col,
+				v
+			};
+		});
+		pts.sort((a, b) => a.r - b.r || a.col - b.col);
+		return pts.map((p) => p.v);
+	}
+	const out = [];
+	for (let r = area.startRow; r <= area.endRow; r++) for (let col = area.startColumn; col <= area.endColumn; col++) out.push(byKey.get(key(r, col)) ?? null);
+	return out;
+}
+function buildTableFormatLookup(worksheet) {
+	const out = /* @__PURE__ */ new Map();
+	for (const t of worksheet.tables ?? []) {
+		const { ref } = t;
+		const firstDataRow = ref.startRow + t.headerRowCount;
+		for (let r = ref.startRow; r <= ref.endRow; r++) {
+			let colorHex;
+			let fontColorHex;
+			if (r < firstDataRow) {
+				colorHex = t.headerHex;
+				fontColorHex = t.headerTextHex;
+			} else if (t.showRowStripes && t.bandHex) colorHex = (r - firstDataRow) % 2 === 1 ? t.bandHex : void 0;
+			if (!colorHex && !fontColorHex) continue;
+			const fmt = {
+				...colorHex ? { shading: { colorHex } } : {},
+				...fontColorHex ? { fontColorHex } : {}
+			};
+			for (let c = ref.startColumn; c <= ref.endColumn; c++) out.set(key(r, c), fmt);
+		}
+	}
+	return out;
+}
 function cellHasContent(cell) {
 	return !!cell && (cell.rawValue !== "" || cell.inlineText !== void 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;