@svgrid/enterprise 3.0.1 → 3.0.2

package/dist/sheet/evaluate.js

@@ -0,0 +1,337 @@
+/**
+ * The evaluator.
+ *
+ * Errors travel as VALUES once evaluation finishes, but as thrown
+ * `FormulaError`s while it runs. That split is deliberate: a coercion buried
+ * three calls deep inside a function needs to abort the whole expression, and
+ * threading a result type through every branch of every builtin would swamp the
+ * table. The throw is caught here, at the one boundary, and becomes a value.
+ *
+ * Four functions never reach the table because they must NOT have every
+ * argument evaluated first: IF and IFS pick a branch, IFERROR needs to catch,
+ * and SWITCH matches before evaluating. Evaluating both branches of an IF is
+ * not just wasted work - `=IF(A1=0, 0, 100/A1)` would raise #DIV/0! from the
+ * branch it did not take.
+ */
+import { FormulaError, isError, err, } from './ast.js';
+import { toNumber, toBool, toText, looseEquals, compare } from './coerce.js';
+import { withCustomFunctions } from './functions.js';
+import { resolveTableRange, columnIndexOf, } from './tables.js';
+function rangeGrid(from, to, ctx) {
+    const sheet = from.sheet ?? to.sheet;
+    const r1 = Math.min(from.row ?? 0, to.row ?? from.row ?? 0);
+    const r2 = to.row === null || from.row === null
+        ? ctx.lastRow(sheet)
+        : Math.max(from.row, to.row);
+    const c1 = Math.min(from.col, to.col);
+    const c2 = Math.max(from.col, to.col);
+    const out = [];
+    for (let r = r1; r <= r2; r += 1) {
+        const row = [];
+        for (let c = c1; c <= c2; c += 1)
+            row.push(ctx.resolve(sheet, r, c));
+        out.push(row);
+    }
+    return out;
+}
+function binary(op, l, r) {
+    switch (op) {
+        case '+': return toNumber(l) + toNumber(r);
+        case '-': return toNumber(l) - toNumber(r);
+        case '*': return toNumber(l) * toNumber(r);
+        case '/': {
+            const d = toNumber(r);
+            return d === 0 ? err('#DIV/0!') : toNumber(l) / d;
+        }
+        case '^': return Math.pow(toNumber(l), toNumber(r));
+        case '&': return toText(l) + toText(r);
+        case '=': return looseEquals(l, r);
+        case '<>': return !looseEquals(l, r);
+        case '<': return compare(l, r) < 0;
+        case '>': return compare(l, r) > 0;
+        case '<=': return compare(l, r) <= 0;
+        case '>=': return compare(l, r) >= 0;
+        default: return err('#VALUE!');
+    }
+}
+/** Functions handled before the table, because their arguments must not all
+ *  be evaluated up front. */
+const SHORT_CIRCUIT = new Set(['IF', 'IFS', 'IFERROR', 'IFNA', 'SWITCH']);
+function evalNode(node, ctx) {
+    switch (node.k) {
+        case 'num': return node.v;
+        case 'str': return node.v;
+        case 'bool': return node.v;
+        case 'ref':
+            return ctx.resolve(node.ref.sheet, node.ref.row ?? 0, node.ref.col);
+        case 'range': {
+            // A range in scalar position collapses to its top-left cell, which is
+            // what Excel does outside an array context.
+            const grid = rangeGrid(node.from, node.to, ctx);
+            return grid[0]?.[0] ?? '';
+        }
+        case 'name': {
+            const target = nameTarget(node.name, ctx);
+            if (target)
+                return evalNode(target, ctx);
+            const v = ctx.resolveName?.(node.name);
+            return v === undefined ? err('#NAME?') : v;
+        }
+        case 'unary': {
+            const v = evalNode(node.arg, ctx);
+            if (isError(v))
+                return v;
+            if (node.op === '-')
+                return -toNumber(v);
+            if (node.op === '%')
+                return toNumber(v) / 100;
+            return toNumber(v);
+        }
+        case 'binary': {
+            const l = evalNode(node.left, ctx);
+            if (isError(l))
+                return l;
+            const r = evalNode(node.right, ctx);
+            if (isError(r))
+                return r;
+            return binary(node.op, l, r);
+        }
+        case 'table':
+            return evalTableRef(node, ctx);
+        case 'fn':
+            return evalCall(node, ctx);
+    }
+}
+/**
+ * Turn a structured reference into a rectangle and read it.
+ *
+ * Every failure here is #REF! rather than a throw, because a table reference
+ * naming a column that was renamed is an ordinary thing to find in a sheet,
+ * and one broken total should not take the rest of the workbook with it.
+ */
+function tableRectOf(node, ctx) {
+    const here = ctx.currentCell;
+    const table = node.table
+        ? ctx.findTable?.(node.table)
+        : here
+            ? ctx.tableAt?.(here.sheet, here.row, here.col)
+            : undefined;
+    if (!table)
+        return null;
+    const headerAt = (sheet, row, col) => {
+        const v = ctx.resolve(sheet, row, col);
+        return isError(v) ? '' : toText(v);
+    };
+    let columns = null;
+    if (node.column !== null) {
+        const from = columnIndexOf(table, node.column, headerAt);
+        if (from < 0)
+            return null;
+        const to = node.columnTo != null
+            ? columnIndexOf(table, node.columnTo, headerAt)
+            : from;
+        if (to < 0)
+            return null;
+        columns = { from: Math.min(from, to), to: Math.max(from, to) };
+    }
+    return resolveTableRange(table, node.specifier, columns, here ? here.row : null);
+}
+function evalTableRef(node, ctx) {
+    const rect = tableRectOf(node, ctx);
+    if (!rect)
+        return err('#REF!');
+    // Scalar position collapses to the top-left, the same as an A1 range.
+    return ctx.resolve(rect.sheet, rect.firstRow, rect.firstCol);
+}
+/** Every cell of a structured reference, for the aggregate functions. */
+function tableGrid(node, ctx) {
+    const rect = tableRectOf(node, ctx);
+    if (!rect)
+        return null;
+    const out = [];
+    for (let r = rect.firstRow; r <= rect.lastRow; r += 1) {
+        const line = [];
+        for (let c = rect.firstCol; c <= rect.lastCol; c += 1)
+            line.push(ctx.resolve(rect.sheet, r, c));
+        out.push(line);
+    }
+    return out;
+}
+/**
+ * The reference a defined name stands for, or null.
+ *
+ * A name may be defined as another name (`Sales` -> `Q3Sales`), so this
+ * follows the chain. It stops after a handful of hops rather than walking a
+ * circular definition forever: `A` -> `B` -> `A` is a mistake in the Name
+ * Manager, and the formula that used it reads #NAME? rather than hanging.
+ */
+function nameTarget(name, ctx) {
+    let node = ctx.resolveNameNode?.(name) ?? null;
+    for (let hops = 0; node && node.k === 'name'; hops += 1) {
+        if (hops >= 8)
+            return null;
+        node = ctx.resolveNameNode?.(node.name) ?? null;
+    }
+    return node;
+}
+/** Functions whose arguments must not all be evaluated up front. */
+function evalCall(node, ctx) {
+    const { name, args } = node;
+    // Every short-circuiting function below indexes its arguments directly.
+    // `=IF()` parses fine, so without this the index is undefined and the
+    // TypeError escapes the boundary this module promises never to throw past.
+    if (SHORT_CIRCUIT.has(name) && args.length === 0)
+        return err('#VALUE!');
+    if (name === 'IF') {
+        const cond = evalNode(args[0], ctx);
+        if (isError(cond))
+            return cond;
+        const branch = toBool(cond) ? args[1] : args[2];
+        if (!branch)
+            return toBool(cond);
+        return evalNode(branch, ctx);
+    }
+    if (name === 'IFERROR' || name === 'IFNA') {
+        try {
+            const v = evalNode(args[0], ctx);
+            if (!isError(v))
+                return v;
+            if (name === 'IFNA' && v.error !== '#N/A')
+                return v;
+        }
+        catch (e) {
+            if (!(e instanceof FormulaError))
+                throw e;
+            if (name === 'IFNA' && e.code !== '#N/A')
+                return err(e.code);
+        }
+        return args[1] ? evalNode(args[1], ctx) : err('#N/A');
+    }
+    if (name === 'IFS') {
+        for (let i = 0; i + 1 < args.length; i += 2) {
+            const cond = evalNode(args[i], ctx);
+            if (isError(cond))
+                return cond;
+            if (toBool(cond))
+                return evalNode(args[i + 1], ctx);
+        }
+        return err('#N/A');
+    }
+    if (name === 'SWITCH') {
+        const subject = evalNode(args[0], ctx);
+        if (isError(subject))
+            return subject;
+        let i = 1;
+        for (; i + 1 < args.length; i += 2) {
+            const candidate = evalNode(args[i], ctx);
+            if (isError(candidate))
+                return candidate;
+            if (looseEquals(subject, candidate))
+                return evalNode(args[i + 1], ctx);
+        }
+        // A trailing odd argument is the default.
+        return i < args.length ? evalNode(args[i], ctx) : err('#N/A');
+    }
+    const table = ctx.functions ?? withCustomFunctions(undefined);
+    const fn = table[name];
+    if (!fn)
+        return err('#NAME?');
+    // Evaluate every argument, keeping range shape for the lookups that need it.
+    const perArg = [];
+    const grids = [];
+    for (const given of args) {
+        // A name stands for whatever it was defined as. Substituting the node
+        // here, before the shape check, is what lets `Sales` in =SUM(Sales) be a
+        // whole column rather than the top-left cell a scalar read would give.
+        const arg = given.k === 'name' ? (nameTarget(given.name, ctx) ?? given) : given;
+        if (arg.k === 'range') {
+            const grid = rangeGrid(arg.from, arg.to, ctx);
+            grids.push(grid);
+            perArg.push(grid.flat());
+        }
+        else if (arg.k === 'table') {
+            // A structured reference expands exactly as a range does, which is
+            // what makes =SUM(Orders[Amount]) work.
+            const grid = tableGrid(arg, ctx);
+            if (!grid) {
+                grids.push(null);
+                perArg.push([err('#REF!')]);
+            }
+            else {
+                grids.push(grid);
+                perArg.push(grid.flat());
+            }
+        }
+        else {
+            grids.push(null);
+            perArg.push([evalNode(arg, ctx)]);
+        }
+    }
+    const flat = perArg.flat();
+    // An error anywhere in the arguments propagates, except for the counting
+    // functions, which Excel lets see errors in their range.
+    if (name !== 'COUNTA' && name !== 'COUNTBLANK') {
+        for (const v of flat)
+            if (isError(v))
+                return v;
+    }
+    const payload = { flat, args: perArg, grids };
+    return fn(payload);
+}
+/**
+ * Evaluate a parsed formula. Never throws: a `FormulaError` raised anywhere
+ * inside becomes the matching error value.
+ */
+/**
+ * The values a node stands for as a grid: a range, a reference (one cell),
+ * or a name that refers to either. Null for anything else, which is how a
+ * caller tells "a list source that is a range" from "a formula".
+ */
+export function rangeValues(node, ctx) {
+    try {
+        if (node.k === 'range')
+            return rangeGrid(node.from, node.to, ctx);
+        if (node.k === 'ref')
+            return [[ctx.resolve(node.ref.sheet, node.ref.row ?? 0, node.ref.col)]];
+        if (node.k === 'name') {
+            const target = nameTarget(node.name, ctx);
+            return target ? rangeValues(target, ctx) : null;
+        }
+        return null;
+    }
+    catch (e) {
+        if (e instanceof FormulaError)
+            return [[err(e.code)]];
+        throw e;
+    }
+}
+export function evaluate(node, ctx) {
+    try {
+        return evalNode(node, ctx);
+    }
+    catch (e) {
+        if (e instanceof FormulaError)
+            return err(e.code);
+        if (e instanceof RangeError)
+            return err('#NUM!');
+        // Last resort. This module promises callers it never throws, and a cell
+        // showing #VALUE! is recoverable where an exception out of a render pass
+        // is not.
+        if (e instanceof TypeError)
+            return err('#VALUE!');
+        throw e;
+    }
+}
+/** Render a computed value the way a cell shows it. */
+export function formatValue(v) {
+    if (isError(v))
+        return v.error;
+    if (typeof v === 'boolean')
+        return v ? 'TRUE' : 'FALSE';
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            return '#NUM!';
+        return String(v);
+    }
+    return String(v);
+}

package/dist/sheet/find-replace.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Find and Replace.
+ *
+ * The grid already has find: a Ctrl+F overlay over displayed values, with
+ * next/prev. What it has no notion of is replacing, and the two differ in more
+ * than direction.
+ *
+ * Finding looks at what the user SEES. Replacing has to write what the user
+ * TYPED, which for a formula cell is the formula, not its result. Replacing
+ * "100" inside a cell showing `100` that actually holds `=B2*C2` would either
+ * do nothing or destroy the formula, depending on which text you reached for.
+ * Hence `lookIn`, and hence replace always writing through the raw text.
+ */
+import type { GridCommandContext } from '@svgrid/grid/shortcuts';
+export type FindOptions = {
+    matchCase?: boolean;
+    /** The cell must equal the search text, not merely contain it. */
+    matchEntireCell?: boolean;
+    /** Search the formula source, or the value a cell displays. Default 'values'. */
+    lookIn?: 'values' | 'formulas';
+    /** Restrict to the current selection. Default the whole sheet. */
+    scope?: 'sheet' | 'selection';
+};
+export type FindHit = {
+    rowIndex: number;
+    colIndex: number;
+};
+/** How a cell's text is obtained for each `lookIn` mode. */
+export type FindTarget = {
+    /** The raw text the user typed, formula included. */
+    getRaw(rowIndex: number, colIndex: number): string;
+    /** What the cell displays. Defaults to the raw text when not supplied. */
+    getDisplay?(rowIndex: number, colIndex: number): string;
+    setRaw(rowIndex: number, colIndex: number, text: string): void;
+    /** Whether a cell may be written. Read-only cells are skipped by replace
+     *  but still reported by find. */
+    isEditable?(rowIndex: number, colIndex: number): boolean;
+    onChange?(): void;
+};
+export declare function setFindTarget(next: FindTarget | null): void;
+export declare function getFindTarget(): FindTarget | null;
+/** Does `haystack` match `needle` under these options? */
+export declare function cellMatches(haystack: string, needle: string, opts?: FindOptions): boolean;
+/** Every cell matching, in reading order. */
+export declare function findAll(cmd: GridCommandContext, needle: string, opts?: FindOptions): FindHit[];
+/** The next hit after the active cell, wrapping. Null when there are none. */
+export declare function findNext(cmd: GridCommandContext, needle: string, opts?: FindOptions, direction?: 1 | -1): FindHit | null;
+/** Replace inside one string, honouring case sensitivity and whole-cell. */
+export declare function replaceInText(haystack: string, needle: string, replacement: string, opts?: FindOptions): string;
+/**
+ * Replace the active cell if it matches, then move to the next hit. Returns
+ * whether anything was written.
+ */
+export declare function replaceOne(cmd: GridCommandContext, needle: string, replacement: string, opts?: FindOptions): boolean;
+/**
+ * Replace every match. Returns how many cells changed.
+ *
+ * Runs inside `cmd.batch`, so a hundred replacements are ONE Ctrl+Z. Without
+ * that this would be the single worst thing in the feature set for undo: it is
+ * the one command that routinely writes more cells than the history can hold.
+ */
+export declare function replaceAll(cmd: GridCommandContext, needle: string, replacement: string, opts?: FindOptions): number;

package/dist/sheet/find-replace.js

@@ -0,0 +1,152 @@
+let target = null;
+export function setFindTarget(next) {
+    target = next;
+}
+export function getFindTarget() {
+    return target;
+}
+function textOf(t, r, c, lookIn) {
+    if (lookIn === 'formulas')
+        return t.getRaw(r, c);
+    return t.getDisplay ? t.getDisplay(r, c) : t.getRaw(r, c);
+}
+/** Does `haystack` match `needle` under these options? */
+export function cellMatches(haystack, needle, opts = {}) {
+    if (needle === '')
+        return false;
+    const a = opts.matchCase ? haystack : haystack.toLowerCase();
+    const b = opts.matchCase ? needle : needle.toLowerCase();
+    return opts.matchEntireCell ? a === b : a.includes(b);
+}
+/** Every cell matching, in reading order. */
+export function findAll(cmd, needle, opts = {}) {
+    const t = target;
+    if (!t || needle === '')
+        return [];
+    const lookIn = opts.lookIn ?? 'values';
+    const bounds = opts.scope === 'selection' ? cmd.ranges : null;
+    const hits = [];
+    const inScope = (r, c) => {
+        if (!bounds)
+            return true;
+        return bounds.some(([minRow, minCol, maxRow, maxCol]) => r >= minRow && r <= maxRow && c >= minCol && c <= maxCol);
+    };
+    for (let r = 0; r < cmd.rowCount; r += 1) {
+        for (let c = 0; c < cmd.colCount; c += 1) {
+            if (!inScope(r, c))
+                continue;
+            if (cellMatches(textOf(t, r, c, lookIn), needle, opts))
+                hits.push({ rowIndex: r, colIndex: c });
+        }
+    }
+    return hits;
+}
+/** The next hit after the active cell, wrapping. Null when there are none. */
+export function findNext(cmd, needle, opts = {}, direction = 1) {
+    const hits = findAll(cmd, needle, opts);
+    if (hits.length === 0)
+        return null;
+    const active = cmd.activeCell;
+    if (!active)
+        return hits[0];
+    const key = (h) => h.rowIndex * cmd.colCount + h.colIndex;
+    const here = active.rowIndex * cmd.colCount + active.colIndex;
+    if (direction === 1) {
+        return hits.find((h) => key(h) > here) ?? hits[0];
+    }
+    // Reverse: the last hit strictly before the active cell, else wrap to the end.
+    for (let i = hits.length - 1; i >= 0; i -= 1) {
+        if (key(hits[i]) < here)
+            return hits[i];
+    }
+    return hits[hits.length - 1];
+}
+/** Replace inside one string, honouring case sensitivity and whole-cell. */
+export function replaceInText(haystack, needle, replacement, opts = {}) {
+    if (needle === '')
+        return haystack;
+    if (opts.matchEntireCell) {
+        return cellMatches(haystack, needle, opts) ? replacement : haystack;
+    }
+    if (opts.matchCase)
+        return haystack.split(needle).join(replacement);
+    // Case-insensitive substring replace, without a regex: the needle is user
+    // input and escaping it correctly is more code than scanning for it.
+    const lowerHay = haystack.toLowerCase();
+    const lowerNeedle = needle.toLowerCase();
+    let out = '';
+    let i = 0;
+    for (;;) {
+        const at = lowerHay.indexOf(lowerNeedle, i);
+        if (at < 0) {
+            out += haystack.slice(i);
+            break;
+        }
+        out += haystack.slice(i, at) + replacement;
+        i = at + needle.length;
+    }
+    return out;
+}
+/**
+ * Replace the active cell if it matches, then move to the next hit. Returns
+ * whether anything was written.
+ */
+export function replaceOne(cmd, needle, replacement, opts = {}) {
+    const t = target;
+    const active = cmd.activeCell;
+    if (!t || !active || needle === '')
+        return false;
+    const { rowIndex: r, colIndex: c } = active;
+    const lookIn = opts.lookIn ?? 'values';
+    const editable = t.isEditable?.(r, c) ?? true;
+    let wrote = false;
+    if (editable && cellMatches(textOf(t, r, c, lookIn), needle, opts)) {
+        // Always write through the RAW text: replacing inside a displayed value
+        // would overwrite a formula with its own result.
+        const raw = t.getRaw(r, c);
+        const next = replaceInText(raw, needle, replacement, opts);
+        if (next !== raw) {
+            t.setRaw(r, c, next);
+            t.onChange?.();
+            wrote = true;
+        }
+    }
+    const following = findNext(cmd, needle, opts);
+    if (following) {
+        cmd.setActiveCell(following.rowIndex, following.colIndex);
+        cmd.setSelection(following.rowIndex, following.colIndex);
+        cmd.scrollIntoView(following.rowIndex, following.colIndex);
+    }
+    return wrote;
+}
+/**
+ * Replace every match. Returns how many cells changed.
+ *
+ * Runs inside `cmd.batch`, so a hundred replacements are ONE Ctrl+Z. Without
+ * that this would be the single worst thing in the feature set for undo: it is
+ * the one command that routinely writes more cells than the history can hold.
+ */
+export function replaceAll(cmd, needle, replacement, opts = {}) {
+    const t = target;
+    if (!t || needle === '')
+        return 0;
+    const hits = findAll(cmd, needle, opts);
+    if (hits.length === 0)
+        return 0;
+    return cmd.batch(() => {
+        let changed = 0;
+        for (const { rowIndex: r, colIndex: c } of hits) {
+            if (!(t.isEditable?.(r, c) ?? true))
+                continue;
+            const raw = t.getRaw(r, c);
+            const next = replaceInText(raw, needle, replacement, opts);
+            if (next === raw)
+                continue;
+            t.setRaw(r, c, next);
+            changed += 1;
+        }
+        if (changed > 0)
+            t.onChange?.();
+        return changed;
+    });
+}

package/dist/sheet/format-store.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Per-cell formats and styles, keyed so they survive the grid moving rows
+ * around.
+ *
+ * Demo 27 keys its format map by DISPLAY row index. Sort the grid and every
+ * bold cell moves to whatever row now sits at that index, which is the kind of
+ * bug that looks like a rendering glitch and is actually lost data. This keys
+ * by `rowId:columnId`, the same shape the grid already uses for `notes`, so
+ * sorting, filtering, column reordering and pagination all leave it alone.
+ *
+ * Storage is sparse: a sheet of ten thousand cells with three bold ones holds
+ * three entries. Most cells have no entry at all and cost nothing.
+ */
+import type { BorderSpec } from '@svgrid/grid';
+/** One cell's formatting. Every field optional; absent means inherit. */
+/** The boolean fields `toggle` can flip. Every one of them is a plain
+ *  on/off attribute of a cell, which is what makes Excel's all-on-turns-off
+ *  rule the right one for all of them. */
+export type ToggleableField = 'bold' | 'italic' | 'underline' | 'strike' | 'wrap';
+export type CellFormatEntry = {
+    /** Excel number-format string, e.g. '#,##0.00'. */
+    numFmt?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    /** Text colour, any CSS colour. */
+    color?: string;
+    /** Background fill. */
+    fill?: string;
+    align?: 'left' | 'center' | 'right';
+    fontFamily?: string;
+    fontSize?: number;
+    wrap?: boolean;
+    indent?: number;
+    border?: {
+        top?: BorderSpec;
+        right?: BorderSpec;
+        bottom?: BorderSpec;
+        left?: BorderSpec;
+    };
+    /**
+     * Excel's Locked flag from Format Cells > Protection. Every cell is locked
+     * unless told otherwise, so only `false` is ever stored; the flag means
+     * nothing until the sheet is protected, when a locked cell refuses edits.
+     */
+    locked?: boolean;
+};
+export type Rect = readonly [minRow: number, minCol: number, maxRow: number, maxCol: number];
+/** Translates a display position to the stable ids the store keys on. */
+export type CellAddressLookup = {
+    rowIdAt(rowIndex: number): string | null;
+    columnIdAt(colIndex: number): string | null;
+};
+export type SheetFormatStore = {
+    get(rowId: string, columnId: string): CellFormatEntry | undefined;
+    /** Merge `patch` into every cell of every rect. A field set to `undefined`
+     *  is REMOVED, which is how you clear one attribute without clearing the
+     *  cell; `clear` removes the whole entry. An entry left with no fields is
+     *  dropped rather than kept as an empty object. */
+    set(rects: ReadonlyArray<Rect>, patch: CellFormatEntry, at: CellAddressLookup): void;
+    /** Remove all formatting from every cell of every rect. */
+    clear(rects: ReadonlyArray<Rect>, at: CellAddressLookup): void;
+    /** Toggle one boolean field across a range. Excel's rule: if EVERY cell in
+     *  the range already has it, turn it off; otherwise turn it on. */
+    toggle(rects: ReadonlyArray<Rect>, field: ToggleableField, at: CellAddressLookup): void;
+    /** Drop every entry for a row. Call when a row is deleted, or the store
+     *  leaks an entry per removed row for the life of the session. */
+    forgetRow(rowId: string): void;
+    forgetColumn(columnId: string): void;
+    /** How many cells carry formatting. For tests and diagnostics. */
+    readonly size: number;
+    serialize(): Record<string, CellFormatEntry>;
+    hydrate(entries: Record<string, CellFormatEntry>): void;
+    clearAll(): void;
+    /**
+     * Rename every row id at once; `fn` returns the new id, or null to drop
+     * the row's entries. For a store keyed on record ids this is never
+     * needed - an id travels with its record - but a SHEET keys rows by
+     * position (`r4` is the fifth row and nothing else), so inserting a row
+     * above the fifth has to move its formats to `r5`, or the band stays on
+     * row five while the cells it belonged to move down.
+     */
+    remapRows(fn: (rowId: string) => string | null): void;
+    /** The same for column ids. */
+    remapColumns(fn: (columnId: string) => string | null): void;
+};
+export declare function createFormatStore(initial?: Record<string, CellFormatEntry>): SheetFormatStore;
+/** Turn an entry into inline style text for a cell renderer. */
+export declare function entryToStyle(entry: CellFormatEntry | undefined): string;
+/**
+ * Cell borders as inset shadows, one per side.
+ *
+ * The cell span fills its td edge to edge, so an inset shadow along one
+ * edge is a border that costs no layout: a real border would push the text
+ * and change the cell's size, and a bordered cell next to a plain one would
+ * misalign. Shadows stack, so a cell can carry any combination of sides.
+ */
+export declare function borderShadows(border: CellFormatEntry['border']): string;