@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/commands.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The keyboard commands themselves, written against `GridCommandContext` so
+ * they stay testable without mounting a grid.
+ *
+ * Every one that writes more than one cell runs inside `cmd.batch()`, so the
+ * whole action is a single Ctrl+Z. That is the seam added in @svgrid/grid;
+ * without it a Ctrl+D down a hundred rows would take a hundred presses to undo
+ * and would evict the history behind it.
+ *
+ * Phase 1 fills VALUES. Excel also translates relative references as it fills,
+ * so `=A1*2` in the source row becomes `=A2*2` one row down; that needs the
+ * formula engine's AST and lands with it in phase 2. Until then a formula
+ * fills as literal text, which is wrong for formulas and right for everything
+ * else, and is why `fillDown` routes through one `translateForFill` hook
+ * rather than inlining the copy.
+ */
+import type { GridCommandContext } from '@svgrid/grid/shortcuts';
+import { type Rect } from './navigate.js';
+/**
+ * How a value copied from (srcRow, srcCol) to (dstRow, dstCol) is rewritten.
+ * Phase 1 is identity. Phase 2 swaps in the engine's `translateFormula`, which
+ * is why every fill path calls it rather than copying the value directly.
+ */
+export type FillTranslator = (value: unknown, delta: {
+    rows: number;
+    cols: number;
+}) => unknown;
+/** Install the formula-aware translator. The engine calls this in phase 2. */
+export declare function setFillTranslator(fn: FillTranslator | null): void;
+export declare function targetRect(cmd: GridCommandContext): Rect | null;
+/**
+ * Ctrl+D. Copies the TOP row of the selection into every row below it.
+ *
+ * Excel has a second behaviour here: with only one cell selected it fills from
+ * the cell directly above instead, which is what makes Ctrl+D useful while
+ * typing down a column. Both are implemented.
+ */
+export declare function fillDown(cmd: GridCommandContext): boolean;
+/** Ctrl+R. The same shape as fillDown, across instead of down. */
+export declare function fillRight(cmd: GridCommandContext): boolean;
+/** Write one value into every cell of the selection. Excel's Ctrl+Enter. */
+export declare function fillSelection(cmd: GridCommandContext, value: unknown): boolean;
+/** Ctrl+; and Ctrl+Shift+;. ISO rather than locale-formatted, because the
+ *  value goes into the data and a column's own `format` decides how it reads;
+ *  stamping a localised string would put display text in the model. */
+export declare function stampNow(kind: 'date' | 'time' | 'datetime', now?: Date): string;
+export declare function stampDate(cmd: GridCommandContext, kind: 'date' | 'time' | 'datetime', now?: Date): boolean;
+/**
+ * Ctrl+'. Copies the cell above VERBATIM - no reference translation, which is
+ * the whole point of the shortcut: it is how you get a copy of the formula
+ * above to edit, rather than one that has already shifted.
+ */
+export declare function copyFromAbove(cmd: GridCommandContext): boolean;
+/**
+ * Ctrl+Shift+". The VALUE of the cell above: what a formula there shows,
+ * not the formula, so a running total can be frozen as a number. With an
+ * engine attached the evaluated value is what goes in; without one there is
+ * nothing but the text, which is what Ctrl+' copies. An error above copies
+ * nothing.
+ */
+export declare function copyValueFromAbove(cmd: GridCommandContext): boolean;
+/**
+ * Alt+=. The range Excel guesses for a SUM anchored at the active cell: the
+ * run of numbers directly above, or directly to the left when there is nothing
+ * above. Returns null when neither direction has numbers to add.
+ */
+export declare function guessSumRange(cmd: GridCommandContext, isNumeric?: (value: unknown) => boolean): Rect | null;
+/**
+ * How to find out what a cell actually EVALUATES to.
+ *
+ * Cells hold raw text, so a cell containing `=SUM(A1:A3)` reads as the string
+ * "=SUM(A1:A3)" and `looksNumeric` says no. AutoSum under a column of
+ * subtotals then finds no run and declines, which is the opposite of what
+ * Excel does: there, a formula that produces a number IS a number.
+ *
+ * Optional. Without one, a sheet with no engine behind it behaves as before
+ * and only literal numbers count.
+ */
+export type SheetValueProbe = (row: number, col: number) => unknown;
+export declare function setSheetValueProbe(fn: SheetValueProbe | null): void;
+export declare function getSheetValueProbe(): SheetValueProbe | null;
+/**
+ * The numeric test AutoSum should use for the cell at (row, col): the
+ * evaluated value when an engine is attached, the raw text otherwise.
+ */
+export declare function numericAt(cmd: GridCommandContext, row: number, col: number): boolean;
+/** Default numeric test for AutoSum: a finite number, or a string that parses
+ *  as one. A blank is not a number, so a gap ends the run. */
+export declare function looksNumeric(value: unknown): boolean;

package/dist/sheet/commands.js

@@ -0,0 +1,230 @@
+import { isBlankValue } from './navigate.js';
+const identity = (value) => value;
+let translator = identity;
+/** Install the formula-aware translator. The engine calls this in phase 2. */
+export function setFillTranslator(fn) {
+    translator = fn ?? identity;
+}
+/** The rectangle a command should act on: the active range, or the active cell
+ *  alone when nothing is selected. Returns null when there is no active cell. */
+/**
+ * Whether a command may write a cell. `setCellValue` trusts its caller, so
+ * a fill over a protected sheet has to ask for itself and leave the locked
+ * cells as they are, the way the grid's own fill handle does.
+ */
+function writable(cmd, r, c) {
+    return cmd.canEdit?.(r, c) !== false;
+}
+export function targetRect(cmd) {
+    const last = cmd.ranges[cmd.ranges.length - 1];
+    if (last)
+        return last;
+    const active = cmd.activeCell;
+    if (!active)
+        return null;
+    return [active.rowIndex, active.colIndex, active.rowIndex, active.colIndex];
+}
+/**
+ * Ctrl+D. Copies the TOP row of the selection into every row below it.
+ *
+ * Excel has a second behaviour here: with only one cell selected it fills from
+ * the cell directly above instead, which is what makes Ctrl+D useful while
+ * typing down a column. Both are implemented.
+ */
+export function fillDown(cmd) {
+    const rect = targetRect(cmd);
+    if (!rect)
+        return false;
+    const [minRow, minCol, maxRow, maxCol] = rect;
+    if (minRow === maxRow) {
+        // Single row selected: pull from the row above.
+        if (minRow === 0)
+            return false;
+        return cmd.batch(() => {
+            for (let c = minCol; c <= maxCol; c += 1) {
+                if (!writable(cmd, minRow, c))
+                    continue;
+                const value = cmd.getCellValue(minRow - 1, c);
+                cmd.setCellValue(minRow, c, translator(value, { rows: 1, cols: 0 }));
+            }
+            return true;
+        });
+    }
+    return cmd.batch(() => {
+        for (let c = minCol; c <= maxCol; c += 1) {
+            const source = cmd.getCellValue(minRow, c);
+            for (let r = minRow + 1; r <= maxRow; r += 1) {
+                if (!writable(cmd, r, c))
+                    continue;
+                cmd.setCellValue(r, c, translator(source, { rows: r - minRow, cols: 0 }));
+            }
+        }
+        return true;
+    });
+}
+/** Ctrl+R. The same shape as fillDown, across instead of down. */
+export function fillRight(cmd) {
+    const rect = targetRect(cmd);
+    if (!rect)
+        return false;
+    const [minRow, minCol, maxRow, maxCol] = rect;
+    if (minCol === maxCol) {
+        if (minCol === 0)
+            return false;
+        return cmd.batch(() => {
+            for (let r = minRow; r <= maxRow; r += 1) {
+                if (!writable(cmd, r, minCol))
+                    continue;
+                const value = cmd.getCellValue(r, minCol - 1);
+                cmd.setCellValue(r, minCol, translator(value, { rows: 0, cols: 1 }));
+            }
+            return true;
+        });
+    }
+    return cmd.batch(() => {
+        for (let r = minRow; r <= maxRow; r += 1) {
+            const source = cmd.getCellValue(r, minCol);
+            for (let c = minCol + 1; c <= maxCol; c += 1) {
+                if (!writable(cmd, r, c))
+                    continue;
+                cmd.setCellValue(r, c, translator(source, { rows: 0, cols: c - minCol }));
+            }
+        }
+        return true;
+    });
+}
+/** Write one value into every cell of the selection. Excel's Ctrl+Enter. */
+export function fillSelection(cmd, value) {
+    const rect = targetRect(cmd);
+    if (!rect)
+        return false;
+    const [minRow, minCol, maxRow, maxCol] = rect;
+    return cmd.batch(() => {
+        for (let r = minRow; r <= maxRow; r += 1) {
+            for (let c = minCol; c <= maxCol; c += 1) {
+                if (writable(cmd, r, c))
+                    cmd.setCellValue(r, c, value);
+            }
+        }
+        return true;
+    });
+}
+/** Ctrl+; and Ctrl+Shift+;. ISO rather than locale-formatted, because the
+ *  value goes into the data and a column's own `format` decides how it reads;
+ *  stamping a localised string would put display text in the model. */
+export function stampNow(kind, now = new Date()) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const time = `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+    if (kind === 'date')
+        return date;
+    if (kind === 'time')
+        return time;
+    return `${date} ${time}`;
+}
+export function stampDate(cmd, kind, now) {
+    return fillSelection(cmd, stampNow(kind, now));
+}
+/**
+ * Ctrl+'. Copies the cell above VERBATIM - no reference translation, which is
+ * the whole point of the shortcut: it is how you get a copy of the formula
+ * above to edit, rather than one that has already shifted.
+ */
+export function copyFromAbove(cmd) {
+    const active = cmd.activeCell;
+    if (!active || active.rowIndex === 0)
+        return false;
+    if (!writable(cmd, active.rowIndex, active.colIndex))
+        return false;
+    const value = cmd.getCellValue(active.rowIndex - 1, active.colIndex);
+    cmd.setCellValue(active.rowIndex, active.colIndex, value);
+    return true;
+}
+/**
+ * Ctrl+Shift+". The VALUE of the cell above: what a formula there shows,
+ * not the formula, so a running total can be frozen as a number. With an
+ * engine attached the evaluated value is what goes in; without one there is
+ * nothing but the text, which is what Ctrl+' copies. An error above copies
+ * nothing.
+ */
+export function copyValueFromAbove(cmd) {
+    const active = cmd.activeCell;
+    if (!active || active.rowIndex === 0)
+        return false;
+    if (!writable(cmd, active.rowIndex, active.colIndex))
+        return false;
+    const probe = valueProbe;
+    const raw = cmd.getCellValue(active.rowIndex - 1, active.colIndex);
+    let value = raw;
+    if (probe) {
+        const shown = probe(active.rowIndex - 1, active.colIndex);
+        if (shown !== null && typeof shown === 'object')
+            return false;
+        if (shown !== undefined && shown !== null)
+            value = typeof shown === 'boolean' ? (shown ? 'TRUE' : 'FALSE') : String(shown);
+    }
+    cmd.setCellValue(active.rowIndex, active.colIndex, value);
+    return true;
+}
+/**
+ * Alt+=. The range Excel guesses for a SUM anchored at the active cell: the
+ * run of numbers directly above, or directly to the left when there is nothing
+ * above. Returns null when neither direction has numbers to add.
+ */
+export function guessSumRange(cmd, isNumeric = looksNumeric) {
+    const active = cmd.activeCell;
+    if (!active)
+        return null;
+    const { rowIndex: row, colIndex: col } = active;
+    // When an engine is attached the run is measured against evaluated values,
+    // so a column of SUM subtotals counts as numbers the way it does in Excel.
+    const numeric = valueProbe
+        ? (r, c) => numericAt(cmd, r, c)
+        : (r, c) => isNumeric(cmd.getCellValue(r, c));
+    let top = row;
+    while (top > 0 && numeric(top - 1, col))
+        top -= 1;
+    if (top < row)
+        return [top, col, row - 1, col];
+    let left = col;
+    while (left > 0 && numeric(row, left - 1))
+        left -= 1;
+    if (left < col)
+        return [row, left, row, col - 1];
+    return null;
+}
+let valueProbe = null;
+export function setSheetValueProbe(fn) {
+    valueProbe = fn;
+}
+export function getSheetValueProbe() {
+    return valueProbe;
+}
+/**
+ * The numeric test AutoSum should use for the cell at (row, col): the
+ * evaluated value when an engine is attached, the raw text otherwise.
+ */
+export function numericAt(cmd, row, col) {
+    const probe = valueProbe;
+    if (!probe)
+        return looksNumeric(cmd.getCellValue(row, col));
+    const value = probe(row, col);
+    // An engine reports an error as an object; that is not a number, and it
+    // should end the run rather than be counted as one.
+    if (value !== null && typeof value === 'object')
+        return false;
+    return looksNumeric(value);
+}
+/** Default numeric test for AutoSum: a finite number, or a string that parses
+ *  as one. A blank is not a number, so a gap ends the run. */
+export function looksNumeric(value) {
+    if (isBlankValue(value))
+        return false;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value === 'string') {
+        const n = Number(value.trim());
+        return value.trim() !== '' && Number.isFinite(n);
+    }
+    return false;
+}

package/dist/sheet/comments.d.ts

@@ -0,0 +1,63 @@
+import type { NotesMap } from './rects.js';
+export type { NotesMap } from './rects.js';
+/** One entry of a thread: its text, who wrote it and when (ISO 8601). */
+export type CommentEntry = {
+    text: string;
+    author?: string;
+    at?: string;
+};
+/** A cell's comment: the first entry, its replies, and whether it is done. */
+export type CommentThread = CommentEntry & {
+    replies?: CommentEntry[];
+    resolved?: boolean;
+};
+/** A note as saved before threads existed, or a thread. */
+export type CommentValue = string | CommentThread;
+/** `r4` -> `B` -> the comment; the document's own shape. */
+export type CommentsMap = Record<string, Record<string, CommentValue>>;
+/** Either shape as a thread; undefined for a blank note. */
+export declare function threadOf(value: CommentValue | undefined): CommentThread | undefined;
+/** The thread on (r, c), or undefined when there is none. */
+export declare function threadAt(comments: CommentsMap, r: number, c: number): CommentThread | undefined;
+/** The comment's first text on (r, c), or undefined when there is none. */
+export declare function commentAt(comments: CommentsMap, r: number, c: number): string | undefined;
+/** True when the thread carries more than a note's text: it is written as an object. */
+export declare function isThreaded(thread: CommentThread): boolean;
+/** The thread as the text a tooltip shows: each entry under its author. */
+export declare function threadText(thread: CommentThread): string;
+/**
+ * The map with (r, c) set to `thread`, or cleared when it is null or blank.
+ * A thread with nothing but a text is written as that text, so a document
+ * that never used threads reads as it always did. A new map, never the
+ * old one changed: the grid re-reads `notes` only when the object it is
+ * handed is a different one.
+ */
+export declare function withThread(comments: CommentsMap, r: number, c: number, thread: CommentThread | null): CommentsMap;
+/**
+ * The map with the first text of (r, c) set to `text`, or the comment
+ * removed when the text is blank. A thread keeps its author, replies and
+ * state; a note stays a note.
+ */
+export declare function withComment(comments: CommentsMap, r: number, c: number, text: string): CommentsMap;
+/** The grid's `notes`: the text of every comment, for the mark and the tooltip. */
+export declare function notesOf(comments: CommentsMap): NotesMap;
+/** Every comment, top to bottom then left to right, with its first text. */
+export declare function listComments(comments: CommentsMap): Array<{
+    row: number;
+    col: number;
+    text: string;
+    thread: CommentThread;
+}>;
+/**
+ * The comment after (or before) `from`, reading the sheet row by row and
+ * wrapping at the end, as Excel's Next Comment and Previous Comment do. The
+ * cell itself is skipped, so pressing Next on a commented cell moves on;
+ * null when the sheet has no comments at all.
+ */
+export declare function nextComment(comments: CommentsMap, from: {
+    row: number;
+    col: number;
+}, dir: 1 | -1): {
+    row: number;
+    col: number;
+} | null;

package/dist/sheet/comments.js

@@ -0,0 +1,131 @@
+/**
+ * Cell comments: Excel's notes and its threaded comments in one map. A
+ * note is a text on a cell, shown as a corner mark and read on hover; a
+ * thread is that text with an author and a time, replies under it, and a
+ * resolved flag. They live in the sheet document keyed the way the grid's
+ * `notes` are (`r4` -> `B` -> value), so the document moves them with an
+ * insert or delete (`remapNotes`) and the grid draws the mark and the
+ * tooltip from the text projection `notesOf` makes.
+ *
+ * A value is a plain string for a note (the shape every document saved so
+ * far carries) or a `CommentThread`; `threadOf` reads either. This module
+ * is the pure part: reading, writing, and walking them the way Review >
+ * Previous / Next do.
+ */
+import { colToLetters, lettersToCol } from './address.js';
+/** Either shape as a thread; undefined for a blank note. */
+export function threadOf(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value.trim() ? { text: value } : undefined;
+    return value.text.trim() || value.replies?.length ? value : undefined;
+}
+/** The thread on (r, c), or undefined when there is none. */
+export function threadAt(comments, r, c) {
+    return threadOf(comments[`r${r}`]?.[colToLetters(c)]);
+}
+/** The comment's first text on (r, c), or undefined when there is none. */
+export function commentAt(comments, r, c) {
+    return threadAt(comments, r, c)?.text;
+}
+/** True when the thread carries more than a note's text: it is written as an object. */
+export function isThreaded(thread) {
+    return Boolean(thread.author || thread.at || thread.replies?.length || thread.resolved);
+}
+/** The thread as the text a tooltip shows: each entry under its author. */
+export function threadText(thread) {
+    const line = (entry) => (entry.author ? `${entry.author}:\n${entry.text}` : entry.text);
+    return [line(thread), ...(thread.replies ?? []).map(line)].join('\n\n');
+}
+function copy(comments) {
+    const out = {};
+    for (const [id, line] of Object.entries(comments))
+        out[id] = { ...line };
+    return out;
+}
+/**
+ * The map with (r, c) set to `thread`, or cleared when it is null or blank.
+ * A thread with nothing but a text is written as that text, so a document
+ * that never used threads reads as it always did. A new map, never the
+ * old one changed: the grid re-reads `notes` only when the object it is
+ * handed is a different one.
+ */
+export function withThread(comments, r, c, thread) {
+    const rowId = `r${r}`;
+    const columnId = colToLetters(c);
+    const out = copy(comments);
+    const kept = thread ? threadOf(thread) : undefined;
+    if (kept) {
+        out[rowId] = { ...(out[rowId] ?? {}), [columnId]: isThreaded(kept) ? kept : kept.text };
+    }
+    else if (out[rowId]) {
+        delete out[rowId][columnId];
+        if (Object.keys(out[rowId]).length === 0)
+            delete out[rowId];
+    }
+    return out;
+}
+/**
+ * The map with the first text of (r, c) set to `text`, or the comment
+ * removed when the text is blank. A thread keeps its author, replies and
+ * state; a note stays a note.
+ */
+export function withComment(comments, r, c, text) {
+    if (!text.trim())
+        return withThread(comments, r, c, null);
+    const before = threadAt(comments, r, c);
+    return withThread(comments, r, c, before ? { ...before, text } : { text });
+}
+/** The grid's `notes`: the text of every comment, for the mark and the tooltip. */
+export function notesOf(comments) {
+    const out = {};
+    for (const [rowId, line] of Object.entries(comments)) {
+        for (const [columnId, value] of Object.entries(line)) {
+            const thread = threadOf(value);
+            if (!thread)
+                continue;
+            out[rowId] = { ...(out[rowId] ?? {}), [columnId]: threadText(thread) };
+        }
+    }
+    return out;
+}
+/** Every comment, top to bottom then left to right, with its first text. */
+export function listComments(comments) {
+    const out = [];
+    for (const [rowId, line] of Object.entries(comments)) {
+        const row = Number(rowId.slice(1));
+        if (!Number.isInteger(row) || row < 0)
+            continue;
+        for (const [columnId, value] of Object.entries(line)) {
+            const col = lettersToCol(columnId);
+            const thread = threadOf(value);
+            if (col < 0 || !thread)
+                continue;
+            out.push({ row, col, text: thread.text, thread });
+        }
+    }
+    return out.sort((a, b) => a.row - b.row || a.col - b.col);
+}
+/**
+ * The comment after (or before) `from`, reading the sheet row by row and
+ * wrapping at the end, as Excel's Next Comment and Previous Comment do. The
+ * cell itself is skipped, so pressing Next on a commented cell moves on;
+ * null when the sheet has no comments at all.
+ */
+export function nextComment(comments, from, dir) {
+    const all = listComments(comments);
+    if (!all.length)
+        return null;
+    const after = (a, b) => a.row > b.row || (a.row === b.row && a.col > b.col);
+    const at = (entry) => ({ row: entry.row, col: entry.col });
+    if (dir === 1) {
+        const hit = all.find((entry) => after(entry, from));
+        return at(hit ?? all[0]);
+    }
+    for (let i = all.length - 1; i >= 0; i -= 1) {
+        if (after(from, all[i]))
+            return at(all[i]);
+    }
+    return at(all[all.length - 1]);
+}

package/dist/sheet/conditional-formats.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Conditional formatting, Excel's: rules over cells that colour them by
+ * what they hold. Highlight Cells Rules (greater than, between, text that
+ * contains, duplicates), Top/Bottom Rules (top 10, above average), Data
+ * Bars, Color Scales and Icon Sets, each over rectangles that move with
+ * an insert or delete.
+ *
+ * Rules are evaluated over COMPUTED values (what a formula shows, not its
+ * text), which is why the model lives here beside the workbook rather than
+ * in the grid's own value-driven rules. The statistics a rule needs over
+ * its range (min, max, mean, rank, counts) are computed once per repaint by
+ * the shell and handed in, so a thousand cells cost one pass.
+ *
+ * Priority is array order, first rule first, as Excel's Manage Rules lists
+ * them: the first rule that decides a property wins it, and a rule with
+ * Stop If True stops the rules below it for the cells it matches.
+ */
+import { type CellValue } from './ast.js';
+import { type StructuralEdit } from './refs.js';
+import { type Rect } from './rects.js';
+import type { CellFormatEntry } from './format-store.js';
+export type CfStyle = Pick<CellFormatEntry, 'fill' | 'color' | 'bold' | 'italic' | 'underline' | 'strike' | 'numFmt'>;
+export type CfOperator = 'greater' | 'less' | 'between' | 'notBetween' | 'equal' | 'notEqual' | 'greaterOrEqual' | 'lessOrEqual';
+export type CfTextMatch = 'contains' | 'notContains' | 'beginsWith' | 'endsWith';
+export type CfIconSet = 'arrows' | 'traffic' | 'flags' | 'symbols';
+export type CfScaleColors = readonly [string, string] | readonly [string, string, string];
+export type CfRule = {
+    id: string;
+    rects: ReadonlyArray<Rect>;
+    stopIfTrue?: boolean;
+} & ({
+    kind: 'cellIs';
+    operator: CfOperator;
+    value1: string;
+    value2?: string;
+    style: CfStyle;
+} | {
+    kind: 'text';
+    match: CfTextMatch;
+    value: string;
+    style: CfStyle;
+} | {
+    kind: 'duplicates';
+    unique?: boolean;
+    style: CfStyle;
+} | {
+    kind: 'topBottom';
+    top: boolean;
+    rank: number;
+    percent?: boolean;
+    style: CfStyle;
+} | {
+    kind: 'average';
+    above: boolean;
+    style: CfStyle;
+}
+/** Excel's "Use a formula to determine which cells to format": written
+ *  for the rule's top-left cell and moved to each cell, TRUE formats. */
+ | {
+    kind: 'formula';
+    formula: string;
+    style: CfStyle;
+}
+/** `negativeColor` paints the bars left of the axis; without it a range
+ *  with negatives still draws them, in Excel's red. */
+ | {
+    kind: 'dataBar';
+    color: string;
+    negativeColor?: string;
+} | {
+    kind: 'colorScale';
+    colors: CfScaleColors;
+} | {
+    kind: 'iconSet';
+    set: CfIconSet;
+});
+export type CfKind = CfRule['kind'];
+/** A rule that carries a style: what the small dialogs make. */
+export type CfStyledRule = Extract<CfRule, {
+    style: CfStyle;
+}>;
+/** Omit that keeps a union a union, one member at a time. */
+type DistributiveOmit<T, K extends keyof never> = T extends unknown ? Omit<T, K> : never;
+/** Any rule without its id and rectangles: what a new rule is made from. */
+export type CfRuleBody = DistributiveOmit<CfRule, 'id' | 'rects'>;
+/** A styled rule without its id and rectangles: what the dialog hands back. */
+export type CfBody = DistributiveOmit<CfStyledRule, 'id' | 'rects'>;
+/** The small dialogs, one per ribbon entry. */
+export type CfPreset = 'greater' | 'less' | 'between' | 'equal' | 'text' | 'duplicates' | 'top10' | 'bottom10' | 'aboveAverage' | 'belowAverage' | 'formula';
+/** What one rule knows about the numbers in its rectangles. */
+export type CfStats = {
+    /** Numbers, sorted ascending. */
+    sorted: number[];
+    min: number;
+    max: number;
+    mean: number;
+    /** How often each display text occurs, for Duplicate Values. */
+    counts: Map<string, number>;
+};
+/** What the rules say about one cell. */
+export type CfResult = {
+    style?: CfStyle;
+    /**
+     * A bar across the cell: `ratio` of its width, starting `axis` of the
+     * way across (0 when the range has no negatives) and running right for a
+     * positive value, left for a negative one, which `negative` says.
+     */
+    dataBar?: {
+        ratio: number;
+        color: string;
+        axis: number;
+        negative: boolean;
+    };
+    /** The icon set and which of its three icons: 0 = the top one. */
+    icon?: {
+        set: CfIconSet;
+        index: 0 | 1 | 2;
+    };
+};
+/** How a rule reads the sheet: the shell wires the workbook in. */
+export type CfContext = {
+    /** A formula or a literal, evaluated in the sheet; `at` is the cell a
+     *  formula rule is being read for, so ROW() and COLUMN() work in it. */
+    evaluate(text: string, at?: {
+        row: number;
+        col: number;
+    }): CellValue;
+};
+/** The six "with" styles of Excel's Highlight Cells dialogs. */
+export declare const CF_PRESET_STYLES: ReadonlyArray<{
+    id: string;
+    label: string;
+    style: CfStyle;
+}>;
+export declare const DATA_BAR_COLOR = "#638EC6";
+/** Excel's colour for the bars left of the axis. */
+export declare const DATA_BAR_NEGATIVE_COLOR = "#FF0000";
+export declare const COLOR_SCALES: Record<'green-yellow-red' | 'red-yellow-green' | 'green-white' | 'white-red', CfScaleColors>;
+export declare function cfId(): string;
+/**
+ * The numbers and the texts a rule's rectangles hold. One pass; the shell
+ * caches the result per rule until the next repaint.
+ */
+export declare function ruleStats(rule: CfRule, valueAt: (r: number, c: number) => CellValue, displayAt: (r: number, c: number) => string): CfStats;
+/** The colour a scale gives a position 0..1. */
+export declare function scaleColor(colors: CfScaleColors, t: number): string;
+/** Which of an icon set's three icons a position 0..1 gets: Excel's thirds. */
+export declare function iconIndex(t: number): 0 | 1 | 2;
+/**
+ * What the rules say about (r, c). Array order is priority; the first rule
+ * that decides a property (the fill, the text colour, the bar, the icon)
+ * keeps it; a matching rule with Stop If True ends the walk.
+ */
+export declare function evaluateCf(rules: ReadonlyArray<CfRule>, r: number, c: number, value: CellValue, display: string, statsFor: (rule: CfRule) => CfStats, ctx: CfContext): CfResult | null;
+/** The rules after an insert or delete. */
+export declare function shiftCf(rules: ReadonlyArray<CfRule>, edit: StructuralEdit): CfRule[];
+/** The rules with the rectangles cut out of them: Clear Rules from Selected Cells. */
+export declare function removeCf(rules: ReadonlyArray<CfRule>, rects: ReadonlyArray<Rect>): CfRule[];
+/** The rules touching any of the rectangles. */
+export declare function cfIn(rules: ReadonlyArray<CfRule>, rects: ReadonlyArray<Rect>): CfRule[];
+/** A rule in words, the way Excel's Manage Rules lists it. */
+export declare function describeCf(rule: CfRule): string;
+/** Whether a rule carries a style the dialog can edit. */
+export declare function hasStyle(rule: CfRule): rule is Extract<CfRule, {
+    style: CfStyle;
+}>;
+export {};