reamkit 1.4.0 → 1.6.0

package/dist/esm/core/spreadsheet-model/types.d.ts

@@ -0,0 +1,189 @@
+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;
+    readonly conditionalFormats?: ReadonlyArray<ConditionalFormat>;
+    readonly sparklines?: ReadonlyArray<ParsedSparkline>;
+    readonly tablePartRelIds?: ReadonlyArray<string>;
+    readonly tables?: ReadonlyArray<ExcelTable>;
+    readonly pane?: SheetPane;
+}
+export interface SheetPane {
+    readonly frozenRows: number;
+    readonly frozenCols: number;
+}
+export interface ExcelTable {
+    readonly ref: MergedRange;
+    readonly name?: string;
+    readonly styleName?: string;
+    readonly headerRowCount: number;
+    readonly showRowStripes: boolean;
+    readonly showColumnStripes: boolean;
+    readonly showFirstColumn: boolean;
+    readonly showLastColumn: boolean;
+    readonly autoFilter: boolean;
+    readonly headerHex?: string;
+    readonly bandHex?: string;
+    readonly headerTextHex?: string;
+}
+export type SparklineKind = 'line' | 'column' | 'winLoss';
+export interface ParsedSparkline {
+    readonly kind: SparklineKind;
+    readonly dataRange: string;
+    readonly sqref: string;
+    readonly colorHex?: string;
+}
+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>;
+    readonly dxfs?: ReadonlyArray<Dxf>;
+}
+export interface Dxf {
+    readonly font?: XlsxFont;
+    readonly fill?: XlsxFill;
+}
+export interface DefinedName {
+    readonly name: string;
+    readonly localSheetId?: number;
+    readonly value: string;
+}
+export type CfOperator = 'lessThan' | 'lessThanOrEqual' | 'equal' | 'notEqual' | 'greaterThanOrEqual' | 'greaterThan' | 'between' | 'notBetween';
+export interface CfRuleCellIs {
+    readonly type: 'cellIs';
+    readonly priority: number;
+    readonly operator: CfOperator;
+    readonly formulas: ReadonlyArray<string>;
+    readonly dxfId: number;
+}
+export type CfvoType = 'num' | 'percent' | 'max' | 'min' | 'percentile' | 'formula' | 'autoMin' | 'autoMax';
+export interface Cfvo {
+    readonly type: CfvoType;
+    readonly val?: string;
+}
+export interface CfRuleColorScale {
+    readonly type: 'colorScale';
+    readonly priority: number;
+    readonly cfvos: ReadonlyArray<Cfvo>;
+    readonly colorsHex: ReadonlyArray<string>;
+}
+export interface CfRuleDataBar {
+    readonly type: 'dataBar';
+    readonly priority: number;
+    readonly cfvos: ReadonlyArray<Cfvo>;
+    readonly colorHex: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+}
+export interface CfRuleIconSet {
+    readonly type: 'iconSet';
+    readonly priority: number;
+    readonly iconSet: string;
+    readonly cfvos: ReadonlyArray<Cfvo>;
+    readonly reverse?: boolean;
+}
+export type CfRule = CfRuleCellIs | CfRuleColorScale | CfRuleDataBar | CfRuleIconSet;
+export interface ConditionalFormat {
+    readonly ranges: ReadonlyArray<MergedRange>;
+    readonly rules: ReadonlyArray<CfRule>;
+}

package/dist/esm/excel/column-bands.d.ts

@@ -0,0 +1,7 @@
+import { BodyElement, TableProperties, TableRow } from '../core/document-model/index.js';
+export interface ColumnBand {
+    readonly start: number;
+    readonly end: number;
+}
+export declare function computeColumnBands(columnWidths: ReadonlyArray<number>, contentWidthTwips: number, colBreaks: ReadonlySet<number>): Array<ColumnBand>;
+export declare function bandedTables(rows: ReadonlyArray<TableRow>, columnWidths: ReadonlyArray<number>, bands: ReadonlyArray<ColumnBand>, properties: TableProperties): Array<BodyElement>;

package/dist/esm/excel/column-bands.js

@@ -0,0 +1,87 @@
+import { twipsToPt } from "../core/ir/units.js";
+//#region src/excel/column-bands.ts
+function computeColumnBands(columnWidths, contentWidthTwips, colBreaks) {
+	const n = columnWidths.length;
+	if (n === 0) return [];
+	const bands = [];
+	let start = 0;
+	let acc = 0;
+	for (let c = 0; c < n; c++) {
+		const w = columnWidths[c] ?? 0;
+		const atBreak = c > start && colBreaks.has(c);
+		const overflows = c > start && acc + w > contentWidthTwips;
+		if (atBreak || overflows) {
+			bands.push({
+				start,
+				end: c - 1
+			});
+			start = c;
+			acc = 0;
+		}
+		acc += w;
+	}
+	bands.push({
+		start,
+		end: n - 1
+	});
+	return bands;
+}
+function bandedTables(rows, columnWidths, bands, properties) {
+	return bands.map((band, bandIndex) => {
+		return {
+			kind: "table",
+			table: {
+				properties,
+				grid: columnWidths.slice(band.start, band.end + 1).map((w) => twipsToPt(w)),
+				rows: rows.map((row, rowIndex) => {
+					const cells = sliceRowCells(row.cells, band);
+					return {
+						properties: bandIndex > 0 && rowIndex === 0 ? {
+							...row.properties,
+							pageBreakBefore: true
+						} : row.properties,
+						cells
+					};
+				})
+			}
+		};
+	});
+}
+function sliceRowCells(cells, band) {
+	const out = [];
+	let col = 0;
+	for (const cell of cells) {
+		const span = cell.properties.colSpan ?? 1;
+		const cellStart = col;
+		const cellEnd = col + span - 1;
+		col += span;
+		if (cellEnd < band.start || cellStart > band.end) continue;
+		const clampedSpan = Math.min(cellEnd, band.end) - Math.max(cellStart, band.start) + 1;
+		if (cellStart >= band.start) out.push(clampedSpan === span ? cell : withColSpan(cell, clampedSpan));
+		else out.push(blankCell(clampedSpan));
+	}
+	return out;
+}
+function withColSpan(cell, span) {
+	const props = { ...cell.properties };
+	if (span > 1) props.colSpan = span;
+	else delete props.colSpan;
+	return {
+		...cell,
+		properties: props
+	};
+}
+function blankCell(span) {
+	return {
+		properties: span > 1 ? { colSpan: span } : {},
+		content: [{
+			kind: "paragraph",
+			paragraph: {
+				properties: {},
+				runs: []
+			}
+		}]
+	};
+}
+//#endregion
+export { bandedTables, computeColumnBands };

package/dist/esm/excel/conditional-format.d.ts

@@ -0,0 +1,16 @@
+import { CellIcon } from '../core/document-model/index.js';
+import { ConditionalFormat, WorksheetCell, XlsxStyles } from '../core/spreadsheet-model/index.js';
+export interface CfOverride {
+    readonly fillHex?: string;
+    readonly fontColorHex?: string;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly dataBar?: {
+        readonly fraction: number;
+        readonly colorHex: string;
+        readonly startFraction?: number;
+    };
+    readonly icon?: CellIcon;
+}
+export type CellConditionalFormatter = (row: number, col: number, numericValue: number | undefined) => CfOverride | undefined;
+export declare function buildConditionalFormatter(conditionalFormats: ReadonlyArray<ConditionalFormat> | undefined, styles: XlsxStyles, cells: ReadonlyArray<WorksheetCell>): CellConditionalFormatter | undefined;

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

@@ -0,0 +1,327 @@
+//#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;
+	if (/Rating/i.test(setName)) return {
+		shape: "bars",
+		colorHex: METER_HEX,
+		fill: {
+			filled: e + 1,
+			levels: count
+		}
+	};
+	if (/Quarters/i.test(setName)) return {
+		shape: "pie",
+		colorHex: METER_HEX,
+		fill: {
+			filled: e,
+			levels: count - 1
+		}
+	};
+	const colorHex = /Gray/i.test(setName) ? GRAY_HEX : iconColor(count, e);
+	return {
+		shape: iconShape(setName, e, count),
+		colorHex
+	};
+}
+var GRAY_HEX = "808080";
+var METER_HEX = "595959";
+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("Symbols")) {
+		if (e <= 0) return "cross";
+		if (e >= count - 1) return "check";
+		return "exclamation";
+	}
+	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 {};