@svgrid/enterprise 3.0.1 → 3.0.2

package/dist/sheet/coerce.js

@@ -0,0 +1,122 @@
+/**
+ * Value coercions, shared by the evaluator and the function table.
+ *
+ * Excel's rules, not JavaScript's. The differences that matter:
+ *   - An empty cell is 0 in arithmetic but is NOT counted by COUNT or averaged
+ *     by AVERAGE, so "coerce to number" and "is a number" are separate tests.
+ *   - Text that does not parse as a number is `#VALUE!`, not NaN. Returning NaN
+ *     would let a bad cell poison a total silently.
+ *   - Text comparison is case-insensitive: `="a"="A"` is TRUE.
+ *   - Booleans are 1 and 0 in arithmetic but are skipped by numeric aggregates.
+ */
+import { FormulaError, isError } from './ast.js';
+export function toNumber(v) {
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    if (typeof v === 'string') {
+        if (v.trim() === '')
+            return 0;
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+        throw new FormulaError('#VALUE!');
+    }
+    if (isError(v))
+        throw new FormulaError(v.error);
+    return 0;
+}
+export function toBool(v) {
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    if (typeof v === 'string') {
+        const upper = v.trim().toUpperCase();
+        if (upper === 'TRUE')
+            return true;
+        if (upper === 'FALSE')
+            return false;
+        return v.length > 0;
+    }
+    if (isError(v))
+        throw new FormulaError(v.error);
+    return false;
+}
+export function toText(v) {
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'boolean')
+        return v ? 'TRUE' : 'FALSE';
+    if (typeof v === 'number')
+        return String(v);
+    if (isError(v))
+        throw new FormulaError(v.error);
+    return '';
+}
+/** Excel's `=` between two values. Text compares case-insensitively; a number
+ *  never equals the text that looks like it. */
+export function looseEquals(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a === b;
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.toLowerCase() === b.toLowerCase();
+    }
+    if (typeof a === 'boolean' && typeof b === 'boolean')
+        return a === b;
+    if (isError(a) || isError(b))
+        return false;
+    return false;
+}
+/** Ordering for `<` and friends. Excel orders number < text < boolean. */
+export function compare(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a < b ? -1 : a > b ? 1 : 0;
+    if (typeof a === 'string' && typeof b === 'string') {
+        const x = a.toLowerCase();
+        const y = b.toLowerCase();
+        return x < y ? -1 : x > y ? 1 : 0;
+    }
+    return toNumber(a) < toNumber(b) ? -1 : toNumber(a) > toNumber(b) ? 1 : 0;
+}
+/** The numeric members of a flattened argument list. Blanks, text and booleans
+ *  are skipped, which is what makes AVERAGE of a column with a header work. */
+export function numericOnly(values) {
+    const out = [];
+    for (const v of values) {
+        if (typeof v === 'number' && Number.isFinite(v))
+            out.push(v);
+    }
+    return out;
+}
+/** Is this cell empty for COUNTA / COUNTBLANK purposes. */
+export function isBlank(v) {
+    return v === '' || v === null || v === undefined;
+}
+/**
+ * An Excel criterion: a bare value matches by equality, a string starting with
+ * an operator compares (`">100"`, `"<>x"`). Used by SUMIF / COUNTIF / their
+ * plural forms, which all share this grammar.
+ */
+export function matchesCriterion(value, criterion) {
+    if (typeof criterion === 'string') {
+        const m = /^(<=|>=|<>|<|>|=)(.*)$/.exec(criterion.trim());
+        if (m) {
+            const opText = m[1];
+            const rest = m[2].trim();
+            const n = Number(rest);
+            const operand = rest !== '' && Number.isFinite(n) ? n : rest;
+            switch (opText) {
+                case '=': return looseEquals(value, operand);
+                case '<>': return !looseEquals(value, operand);
+                case '<': return compare(value, operand) < 0;
+                case '>': return compare(value, operand) > 0;
+                case '<=': return compare(value, operand) <= 0;
+                case '>=': return compare(value, operand) >= 0;
+                default: break;
+            }
+        }
+    }
+    return looseEquals(value, criterion);
+}

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,29 @@
+import type { NotesMap } from './rects.js';
+export type { NotesMap } from './rects.js';
+/** The comment on (r, c), or undefined when there is none. */
+export declare function commentAt(notes: NotesMap, r: number, c: number): string | undefined;
+/**
+ * The map with (r, c) set to `text`, or cleared when the text is blank.
+ * 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 withComment(notes: NotesMap, r: number, c: number, text: string): NotesMap;
+/** Every comment, top to bottom then left to right. */
+export declare function listComments(notes: NotesMap): Array<{
+    row: number;
+    col: number;
+    text: string;
+}>;
+/**
+ * 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(notes: NotesMap, from: {
+    row: number;
+    col: number;
+}, dir: 1 | -1): {
+    row: number;
+    col: number;
+} | null;

package/dist/sheet/comments.js

@@ -0,0 +1,73 @@
+/**
+ * Cell comments, Excel's notes: a text on a cell, shown as a corner mark
+ * and read on hover. They live in the sheet document in the grid's own
+ * `notes` shape (`r4` -> `B` -> text), so the grid draws the mark and the
+ * tooltip and the document moves them with an insert or delete
+ * (`remapNotes`). This module is the pure part: reading, writing, and
+ * walking them the way Review > Previous / Next do.
+ */
+import { colToLetters, lettersToCol } from './address.js';
+/** The comment on (r, c), or undefined when there is none. */
+export function commentAt(notes, r, c) {
+    const text = notes[`r${r}`]?.[colToLetters(c)];
+    return text && text.trim() ? text : undefined;
+}
+/**
+ * The map with (r, c) set to `text`, or cleared when the text is blank.
+ * 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 withComment(notes, r, c, text) {
+    const rowId = `r${r}`;
+    const columnId = colToLetters(c);
+    const out = {};
+    for (const [id, line] of Object.entries(notes))
+        out[id] = { ...line };
+    if (text.trim()) {
+        out[rowId] = { ...(out[rowId] ?? {}), [columnId]: text };
+    }
+    else if (out[rowId]) {
+        delete out[rowId][columnId];
+        if (Object.keys(out[rowId]).length === 0)
+            delete out[rowId];
+    }
+    return out;
+}
+/** Every comment, top to bottom then left to right. */
+export function listComments(notes) {
+    const out = [];
+    for (const [rowId, line] of Object.entries(notes)) {
+        const row = Number(rowId.slice(1));
+        if (!Number.isInteger(row) || row < 0)
+            continue;
+        for (const [columnId, text] of Object.entries(line)) {
+            const col = lettersToCol(columnId);
+            if (col < 0 || !text || !text.trim())
+                continue;
+            out.push({ row, col, text });
+        }
+    }
+    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(notes, from, dir) {
+    const all = listComments(notes);
+    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,144 @@
+/**
+ * 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;
+} | {
+    kind: 'dataBar';
+    color: 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';
+/** 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, 0..1 of its width. */
+    dataBar?: {
+        ratio: number;
+        color: string;
+    };
+    /** 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. */
+    evaluate(text: string): 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";
+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 {};