reamkit 1.4.0 → 1.5.0

package/README.md

@@ -35,6 +35,7 @@ const pdf = await doc.convert('pdf');     // async — fetches a font if needed
 const svg = await doc.convert('svg');     // same parse, different target
 const html = await doc.convert('html');   // flowed HTML — needs no fonts at all
 const docx = await doc.convert('docx');   // write WordprocessingML back out
+const xlsx = await doc.convert('xlsx');   // write SpreadsheetML back (xlsx source)
 
 // Hand the bytes to the browser: preview, download, upload, …
 const url = URL.createObjectURL(new Blob([pdf], { type: 'application/pdf' }));
@@ -166,14 +167,15 @@ multi-section and multi-column layout/headers-footers (incl. PAGE/NUMPAGES
 fields)/footnotes and endnotes/hyperlinks and bookmarks/floating drawings/
 images/tracked changes, SpreadsheetML grids,
 number formats and the print model (gridlines, print area, fit-to-page,
-repeated titles, page breaks), DrawingML shapes and charts, OMML math,
-Type0+CIDFontType2 embedding with subsetting, Knuth-Plass line breaking,
-Liang hyphenation, OpenType ligatures/kerning + Arabic cursive joining,
-BiDi (UAX #9), hyperlinks (PDF link annotations + HTML anchors,
+repeated titles, page breaks), **conditional formatting** (color scales, data
+bars, icon sets), **sparklines** and **Excel tables**, DrawingML shapes and
+charts, OMML math, Type0+CIDFontType2 embedding with subsetting, Knuth-Plass
+line breaking, Liang hyphenation, OpenType ligatures/kerning + Arabic cursive
+joining, BiDi (UAX #9), hyperlinks (PDF link annotations + HTML anchors,
 scheme-allowlisted), tagged PDF, PDF/A-1/2/3 (a/b/u), PDF/UA-1, AES-256
 encryption, digital signatures (PKCS#7/ECDSA/PAdES/RFC 3161), SVG page
-preview, flowed HTML export, and **docx output** (write WordprocessingML back
-out, incl. docx → docx). Reads OOXML Transitional and Strict.
+preview, flowed HTML export, and **docx + xlsx output** (write WordprocessingML
+/ SpreadsheetML back out, incl. round-trips). Reads OOXML Transitional and Strict.
 
 See `handoff.md` for the full feature matrix and known limitations.
 

package/dist/esm/core/converter/facade.d.ts

@@ -1,12 +1,16 @@
 import { ConvertDocxOptions } from '../../word/docx-to-pdf.js';
 import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
+import { SheetDoc } from '../ir/sheet.js';
 import { FontProvider } from '../fonts/provider.js';
 import { Loss, LossReport } from '../ir/index.js';
 import { FontBytesByVariant } from '../font/index.js';
 export interface ConvertOptions extends ConvertDocxOptions {
-    /** Target: 'pdf' (default), 'svg' (page-stack preview), 'html' or 'docx' (flowed). */
-    readonly to?: 'pdf' | 'svg' | 'html' | 'docx';
+    /**
+     * Target: 'pdf' (default), 'svg' (page-stack preview), 'html'/'docx' (flowed),
+     * or 'xlsx' (the native grid writer — spreadsheet input only).
+     */
+    readonly to?: 'pdf' | 'svg' | 'html' | 'docx' | 'xlsx';
     /**
      * Strict mode (handoff v1 §5): throw ConversionLossError on the first
      * recorded loss instead of returning it in the report.
@@ -26,18 +30,20 @@ export interface ConvertResult {
     readonly bytes: Uint8Array;
     readonly losses: LossReport;
 }
+export type SourceDoc = FlowDoc | SheetDoc;
+export declare function toFlowDoc(doc: SourceDoc): FlowDoc;
 export interface Converter {
     /** The registered readers, in sniffing order. */
-    readonly readers: ReadonlyArray<DocumentReader<FlowDoc>>;
+    readonly readers: ReadonlyArray<DocumentReader<SourceDoc>>;
     /** Detect the input format by reader sniffing; undefined when unknown. */
-    detect: (bytes: Uint8Array) => DocumentReader<FlowDoc> | undefined;
+    detect: (bytes: Uint8Array) => DocumentReader<SourceDoc> | undefined;
     convert: (bytes: Uint8Array, options?: ConvertOptions) => Promise<ConvertResult>;
 }
 export interface CreateConverterOptions {
     /** Override / extend the reader registry (defaults to docx + xlsx). */
-    readonly readers?: ReadonlyArray<DocumentReader<FlowDoc>>;
+    readonly readers?: ReadonlyArray<DocumentReader<SourceDoc>>;
 }
-export declare const DEFAULT_READERS: ReadonlyArray<DocumentReader<FlowDoc>>;
+export declare const DEFAULT_READERS: ReadonlyArray<DocumentReader<SourceDoc>>;
 export declare function createConverter(opts?: CreateConverterOptions): Converter;
 export declare function resolveFontsViaChain(providers: ReadonlyArray<FontProvider>): Promise<{
     fonts?: FontBytesByVariant;

package/dist/esm/core/converter/facade.js

@@ -3,15 +3,27 @@ import { FEATURES } from "../ir/features.js";
 import { ConversionLossError } from "../ir/loss.js";
 import { layoutStyledDocument } from "../../layout/styled-layout.js";
 import { docxReader } from "../../word/docx-reader.js";
+import { projectSheetDoc } from "../../excel/sheet-to-flow.js";
 import { xlsxReader } from "../../excel/xlsx-reader.js";
 import { chainProviders } from "../fonts/provider.js";
 import { flowRenderOptions } from "./project.js";
 import { writeDocx } from "../../word/docx-writer.js";
+import { writeXlsx } from "../../excel/xlsx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { convertDocxToPdf } from "../../word/docx-to-pdf.js";
 import { convertXlsxToPdf } from "../../excel/xlsx-to-pdf.js";
 //#region src/core/converter/facade.ts
+function toFlowDoc(doc) {
+	return doc.kind === "sheet" ? projectSheetDoc(doc) : doc;
+}
+function readToFlow(reader, bytes) {
+	const { doc, losses } = reader.read(bytes);
+	return {
+		doc: toFlowDoc(doc),
+		losses
+	};
+}
 var DEFAULT_READERS = [docxReader, xlsxReader];
 function createConverter(opts = {}) {
 	const readers = opts.readers ?? DEFAULT_READERS;
@@ -22,7 +34,7 @@ function createConverter(opts = {}) {
 		if (!reader) throw new Error("Unrecognized input format (no registered reader sniffs these bytes)");
 		const losses = [];
 		if (to === "docx") {
-			const { doc: flow, losses: readLosses } = reader.read(bytes);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes);
 			losses.push(...readLosses);
 			const out = writeDocx(flow);
 			losses.push(...out.losses);
@@ -33,7 +45,7 @@ function createConverter(opts = {}) {
 			};
 		}
 		if (to === "html") {
-			const { doc: flow, losses: readLosses } = reader.read(bytes);
+			const { doc: flow, losses: readLosses } = readToFlow(reader, bytes);
 			losses.push(...readLosses);
 			const html = writeHtml(flow);
 			losses.push(...html.losses);
@@ -43,6 +55,18 @@ function createConverter(opts = {}) {
 				losses
 			};
 		}
+		if (to === "xlsx") {
+			const { doc, losses: readLosses } = reader.read(bytes);
+			losses.push(...readLosses);
+			if (doc.kind !== "sheet") throw new Error("to: 'xlsx' requires a spreadsheet input; a flow document has no grid");
+			const out = writeXlsx(doc);
+			losses.push(...out.losses);
+			if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+			return {
+				bytes: out.bytes,
+				losses
+			};
+		}
 		let conv = rest;
 		if (fontProviders && fontProviders.length > 0 && !rest.fonts && !rest.fontBytes) {
 			const { fonts, loss } = await resolveFontsViaChain(fontProviders);
@@ -55,7 +79,7 @@ function createConverter(opts = {}) {
 		if (to === "svg") {
 			const fonts = conv.fonts ?? (conv.fontBytes ? { regular: conv.fontBytes } : void 0);
 			if (!fonts) throw new Error("to: 'svg' requires options.fonts/fontBytes or fontProviders");
-			const { doc: flow } = reader.read(bytes);
+			const { doc: flow } = readToFlow(reader, bytes);
 			const svg = writeSvg(layoutStyledDocument(flow.body, {
 				registry: FontRegistry.fromBytes(fonts),
 				...flowRenderOptions(flow)
@@ -110,4 +134,4 @@ async function resolveFontsViaChain(providers) {
 	};
 }
 //#endregion
-export { DEFAULT_READERS, createConverter, resolveFontsViaChain };
+export { DEFAULT_READERS, createConverter, resolveFontsViaChain, toFlowDoc };

package/dist/esm/core/converter/ream.d.ts

@@ -1,14 +1,15 @@
-import { ConvertResult } from './facade.js';
+import { ConvertResult, SourceDoc } from './facade.js';
 import { FontBytesByVariant } from '../font/index.js';
 import { FetchLike } from '../fonts/index.js';
 import { FontProvider } from '../fonts/provider.js';
 import { Loss } from '../ir/index.js';
 import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
+import { SheetDoc } from '../ir/sheet.js';
 import { SignatureOptions, StyledRenderOptions } from '../../pdf/index.js';
-export type ReamTarget = 'pdf' | 'svg' | 'html' | 'docx';
+export type ReamTarget = 'pdf' | 'svg' | 'html' | 'docx' | 'xlsx';
 export interface ReamParseOptions {
-    readonly readers?: ReadonlyArray<DocumentReader>;
+    readonly readers?: ReadonlyArray<DocumentReader<SourceDoc>>;
 }
 export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry' | 'styles'> {
     readonly fonts?: FontBytesByVariant;
@@ -22,6 +23,7 @@ export interface ReamConvertOptions extends Omit<StyledRenderOptions, 'registry'
 }
 export declare class Ream {
     readonly flow: FlowDoc;
+    readonly sheet: SheetDoc | undefined;
     readonly losses: ReadonlyArray<Loss>;
     private readonly source;
     private readonly readerId;

package/dist/esm/core/converter/ream.js

@@ -7,18 +7,20 @@ import { renderStyledPdf, renderStyledPdfEncrypted } from "../../pdf/styled-page
 import "../../pdf/index.js";
 import { flowRenderOptions } from "./project.js";
 import { writeDocx } from "../../word/docx-writer.js";
+import { writeXlsx } from "../../excel/xlsx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
-import { DEFAULT_READERS, resolveFontsViaChain } from "./facade.js";
+import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
 //#region src/core/converter/ream.ts
 var SOURCE_MIME = {
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
 	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 };
 var Ream = class Ream {
-	constructor(flow, losses, source, readerId) {
+	constructor(flow, sheet, losses, source, readerId) {
 		this.flow = flow;
+		this.sheet = sheet;
 		this.losses = losses;
 		this.source = source;
 		this.readerId = readerId;
@@ -28,7 +30,8 @@ var Ream = class Ream {
 		const reader = readers.find((r) => r.sniff(bytes));
 		if (!reader) throw new Error(`Unrecognized document format (readers: ${readers.map((r) => r.id).join(", ")})`);
 		const { doc, losses } = reader.read(bytes);
-		return new Ream(doc, losses, bytes, reader.id);
+		const sheet = doc.kind === "sheet" ? doc : void 0;
+		return new Ream(toFlowDoc(doc), sheet, losses, bytes, reader.id);
 	}
 	get format() {
 		return this.readerId;
@@ -56,6 +59,16 @@ var Ream = class Ream {
 				losses
 			};
 		}
+		if (to === "xlsx") {
+			if (!this.sheet) throw new Error("convert('xlsx') requires a spreadsheet source; this document has no grid");
+			const xlsx = writeXlsx(this.sheet);
+			losses.push(...xlsx.losses);
+			this.enforceStrict(options, losses);
+			return {
+				bytes: xlsx.bytes,
+				losses
+			};
+		}
 		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
 		const registry = FontRegistry.fromBytes(fonts);
 		if (to === "svg") {

package/dist/esm/core/document-model/index.d.ts

@@ -1 +1 @@
-export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';
+export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, CellDataBar, CellIcon, CellIconShape, CellSparkline, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';

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

@@ -221,6 +221,21 @@ export interface CellMargins {
 export interface CellShading {
     readonly colorHex: string;
 }
+export interface CellDataBar {
+    readonly fraction: number;
+    readonly colorHex: string;
+    readonly startFraction?: number;
+}
+export type CellIconShape = 'circle' | 'square' | 'diamond' | 'triangleUp' | 'triangleDown' | 'triangleRight';
+export interface CellIcon {
+    readonly shape: CellIconShape;
+    readonly colorHex: string;
+}
+export interface CellSparkline {
+    readonly kind: 'line' | 'column' | 'winLoss';
+    readonly values: ReadonlyArray<number | null>;
+    readonly colorHex?: string;
+}
 export type CellMerge = 'start' | 'middle' | 'end';
 export interface CellProperties {
     readonly width?: Pt;
@@ -229,6 +244,9 @@ export interface CellProperties {
     readonly borders?: CellBorders;
     readonly margins?: CellMargins;
     readonly shading?: CellShading;
+    readonly dataBar?: CellDataBar;
+    readonly icon?: CellIcon;
+    readonly sparkline?: CellSparkline;
 }
 export interface RowProperties {
     readonly height?: Pt;

package/dist/esm/core/drawingml/sparkline-geometry.d.ts

@@ -0,0 +1,8 @@
+import { StrokeStyle, VectorPath } from '../vector.js';
+export type SparklineKind = 'line' | 'column' | 'winLoss';
+export interface SparklinePrim {
+    readonly paths: ReadonlyArray<VectorPath>;
+    readonly fillColorHex?: string;
+    readonly stroke?: StrokeStyle;
+}
+export declare function buildSparkline(kind: SparklineKind, values: ReadonlyArray<number | null>, width: number, height: number, colorHex?: string): Array<SparklinePrim>;

package/dist/esm/core/drawingml/sparkline-geometry.js

@@ -0,0 +1,111 @@
+import { PathBuilder } from "../vector.js";
+//#region src/core/drawingml/sparkline-geometry.ts
+var DEFAULT_SERIES_HEX = "376092";
+var LOSS_HEX = "D00000";
+function buildSparkline(kind, values, width, height, colorHex) {
+	if (width <= 0 || height <= 0 || values.every((v) => v === null)) return [];
+	const color = colorHex ?? DEFAULT_SERIES_HEX;
+	switch (kind) {
+		case "line": return lineSpark(values, width, height, color);
+		case "column": return columnSpark(values, width, height, color);
+		case "winLoss": return winLossSpark(values, width, height, color);
+	}
+}
+function lineSpark(values, w, h, color) {
+	const n = values.length;
+	const pad = Math.min(1, h * .12);
+	const { min, span } = extent(values);
+	const x = (i) => n === 1 ? w / 2 : i / (n - 1) * w;
+	const y = (v) => pad + (v - min) / span * (h - 2 * pad);
+	const b = new PathBuilder();
+	let penDown = false;
+	for (let i = 0; i < n; i++) {
+		const v = values[i];
+		if (v === null || v === void 0) {
+			penDown = false;
+			continue;
+		}
+		if (penDown) b.lineTo(x(i), y(v));
+		else {
+			b.moveTo(x(i), y(v));
+			penDown = true;
+		}
+	}
+	return [{
+		paths: [b.build()],
+		stroke: {
+			colorHex: color,
+			widthPt: .75,
+			join: "round"
+		}
+	}];
+}
+function columnSpark(values, w, h, color) {
+	const n = values.length;
+	const { min, span } = extent(values);
+	const slot = w / n;
+	const bw = slot * .72;
+	const off = (slot - bw) / 2;
+	const pad = h * .06;
+	const paths = [];
+	for (let i = 0; i < n; i++) {
+		const v = values[i];
+		if (v === null || v === void 0) continue;
+		const frac = (v - min) / span;
+		const bh = Math.max(.4, pad + frac * (h - pad));
+		paths.push(rectPath(i * slot + off, 0, bw, bh));
+	}
+	return paths.length > 0 ? [{
+		paths,
+		fillColorHex: color
+	}] : [];
+}
+function winLossSpark(values, w, h, color) {
+	const n = values.length;
+	const slot = w / n;
+	const bw = slot * .72;
+	const off = (slot - bw) / 2;
+	const mid = h / 2;
+	const barH = h * .4;
+	const wins = [];
+	const losses = [];
+	for (let i = 0; i < n; i++) {
+		const v = values[i];
+		if (v === null || v === void 0 || v === 0) continue;
+		const x = i * slot + off;
+		if (v > 0) wins.push(rectPath(x, mid, bw, barH));
+		else losses.push(rectPath(x, mid - barH, bw, barH));
+	}
+	const out = [];
+	if (wins.length > 0) out.push({
+		paths: wins,
+		fillColorHex: color
+	});
+	if (losses.length > 0) out.push({
+		paths: losses,
+		fillColorHex: LOSS_HEX
+	});
+	return out;
+}
+function extent(values) {
+	let min = Infinity;
+	let max = -Infinity;
+	for (const v of values) {
+		if (v === null) continue;
+		if (v < min) min = v;
+		if (v > max) max = v;
+	}
+	if (min === Infinity) return {
+		min: 0,
+		span: 1
+	};
+	return {
+		min,
+		span: max - min || 1
+	};
+}
+function rectPath(x, y, w, h) {
+	return new PathBuilder().moveTo(x, y).lineTo(x + w, y).lineTo(x + w, y + h).lineTo(x, y + h).close().build();
+}
+//#endregion
+export { buildSparkline };

package/dist/esm/core/ir/adapters.d.ts

@@ -12,8 +12,8 @@ export interface ReadResult<TDoc> {
 export interface DocumentReader<TDoc = FlowDoc> {
     /** Format id: 'docx', 'xlsx', 'pdf', … */
     readonly id: string;
-    /** Which tree this reader produces. */
-    readonly produces: 'flow' | 'page';
+    /** Which tree this reader produces ('sheet' projects to flow at the boundary). */
+    readonly produces: 'flow' | 'page' | 'sheet';
     /** Feature vocabulary this reader understands (capability matrix source). */
     readonly supports: ReadonlySet<Feature>;
     /** Cheap format detection (magic bytes / container markers). */
@@ -28,10 +28,10 @@ export interface WriteResult {
     readonly losses: LossReport;
 }
 export interface DocumentWriter<TDoc> {
-    /** Output format id: 'pdf', 'svg', 'html', 'docx', … */
+    /** Output format id: 'pdf', 'svg', 'html', 'docx', 'xlsx', … */
     readonly id: string;
-    /** Which tree this writer consumes. */
-    readonly consumes: 'flow' | 'page';
+    /** Which tree this writer consumes ('sheet' for the native grid writer). */
+    readonly consumes: 'flow' | 'page' | 'sheet';
     readonly supports: ReadonlySet<Feature>;
     write: (doc: TDoc, opts?: WriteOptions) => WriteResult;
 }

package/dist/esm/core/ir/sheet.d.ts

@@ -0,0 +1,31 @@
+import { Chart, DocumentInfo } from '../document-model/index.js';
+import { DefinedName, ParsedWorksheet, XlsxStyles } from '../spreadsheet-model/index.js';
+import { ResourceStore } from './resources.js';
+export interface SheetChartRef {
+    readonly chartPartPath: string;
+    readonly widthPt: number;
+    readonly heightPt: number;
+}
+export interface Sheet {
+    readonly name: string;
+    readonly grid: ParsedWorksheet;
+    readonly charts?: ReadonlyArray<SheetChartRef>;
+}
+export interface SheetDoc {
+    readonly kind: 'sheet';
+    readonly sheets: ReadonlyArray<Sheet>;
+    /** §18.8 workbook style table (cellXfs + fonts/fills/borders/numFmts). */
+    readonly styles: XlsxStyles;
+    /** §18.4 shared string table; a cell with type 's' indexes into it. */
+    readonly sharedStrings: ReadonlyArray<string>;
+    /** §18.2.5 workbook defined names (print areas/titles, named ranges). */
+    readonly definedNames: ReadonlyArray<DefinedName>;
+    /** §18.2.28 1904 date system (serial-to-date epoch). */
+    readonly date1904: boolean;
+    /** Parsed charts keyed by part path (SheetChartRef.chartPartPath). */
+    readonly chartData?: ReadonlyMap<string, Chart>;
+    /** Content-addressed binary resources (sheet images). */
+    readonly resources: ResourceStore;
+    /** Document metadata from docProps/core.xml. */
+    readonly info?: DocumentInfo;
+}

package/dist/esm/core/opc/relationships.js

@@ -6,6 +6,7 @@ var parser = new XMLParser({
 	attributeNamePrefix: "@_",
 	parseAttributeValue: false,
 	trimValues: false,
+	removeNSPrefix: true,
 	isArray: (tagName) => tagName === "Relationship"
 });
 function parseRelationships(data) {

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

@@ -0,0 +1 @@
+export type { CellType, WorksheetCell, ColumnWidth, MergedRange, RowHeight, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, ParsedWorksheet, XlsxFont, XlsxFill, XlsxBorderStyleName, XlsxBorderEdge, XlsxBorder, XlsxHorizontalAlign, XlsxVerticalAlign, XlsxCellAlignment, XlsxCellXf, XlsxStyles, DefinedName, Dxf, CfOperator, CfRuleCellIs, CfvoType, Cfvo, CfRuleColorScale, CfRuleDataBar, CfRuleIconSet, CfRule, ConditionalFormat, SparklineKind, ParsedSparkline, ExcelTable, } from './types.js';

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

@@ -0,0 +1,184 @@
+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>;
+}
+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/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;