@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/structure.js

@@ -0,0 +1,166 @@
+import { fixupReferences } from './refs.js';
+let target = null;
+/** Attach what the insert / delete commands operate on. */
+export function setStructureTarget(next) {
+    target = next;
+}
+export function getStructureTarget() {
+    return target;
+}
+/**
+ * Rewrite every formula on the sheet for one structural edit.
+ *
+ * Walks the whole grid rather than consulting the dependency graph, because
+ * the graph indexes what a formula READS and this needs every formula that
+ * MENTIONS a moved coordinate, including ones whose precedents were never
+ * resolved (a `#REF!` today may become valid after an insert).
+ */
+export function rewriteFormulas(cmd, t, edit) {
+    let changed = 0;
+    for (let r = 0; r < cmd.rowCount; r += 1) {
+        for (let c = 0; c < cmd.colCount; c += 1) {
+            const text = t.getRaw(r, c);
+            if (!text.startsWith('='))
+                continue;
+            const next = fixupReferences(text, edit);
+            if (typeof next === 'string' && next !== text) {
+                t.setRaw(r, c, next);
+                changed += 1;
+            }
+        }
+    }
+    if (t.names) {
+        for (const entry of t.names.list()) {
+            const next = fixupReferences(entry.refersTo, edit);
+            if (typeof next === 'string' && next !== entry.refersTo) {
+                t.names.define(entry.name, next);
+                changed += 1;
+            }
+        }
+    }
+    return changed;
+}
+/**
+ * Drop format entries for rows or columns the edit removes.
+ *
+ * Nothing needs SHIFTING. The store keys on row and column IDS, and an id
+ * travels with the thing it names: inserting a column at B does not rename
+ * what was B, it just puts a new id before it, so every existing entry still
+ * points at the right cell. That is the payoff for keying on ids instead of
+ * indices, and it is the same property that makes the store survive a sort.
+ *
+ * A DELETE is different: those ids are gone, and their entries would sit in
+ * the map for the life of the session. Hence this.
+ */
+function forgetDeleted(t, edit, cmd) {
+    const format = t.format;
+    if (!format)
+        return;
+    const rows = edit.kind === 'deleteRows';
+    const cols = edit.kind === 'deleteCols';
+    if (!rows && !cols)
+        return;
+    const limit = rows ? cmd.rowCount : cmd.colCount;
+    for (let i = edit.at; i < Math.min(edit.at + edit.count, limit); i += 1) {
+        const id = rows ? format.lookup.rowIdAt(i) : format.lookup.columnIdAt(i);
+        if (id === null)
+            continue;
+        if (rows)
+            format.store.forgetRow(id);
+        else
+            format.store.forgetColumn(id);
+    }
+}
+function run(cmd, edit) {
+    const t = target;
+    if (!t)
+        return false;
+    if (edit.count <= 0)
+        return false;
+    if (t.canApply?.(edit) === false) {
+        t.refused?.();
+        return false;
+    }
+    return cmd.batch(() => {
+        const before = t.snapshot?.();
+        // Order matters: the rewrite and the cleanup both read the OLD geometry.
+        if (!t.rewritesReferences)
+            rewriteFormulas(cmd, t, edit);
+        forgetDeleted(t, edit, cmd);
+        t.apply(edit);
+        t.onChange?.();
+        // Recorded LAST, so undo runs it first: the whole state comes back, and
+        // the rewrite steps recorded above then re-apply their own "before"
+        // texts, which the snapshot already holds. Redo runs them the other way
+        // round to the same end.
+        const restore = t.restore;
+        if (before !== undefined && restore) {
+            const after = t.snapshot?.();
+            cmd.recordUndo?.(() => { restore(before); t.onChange?.(); }, () => { restore(after); t.onChange?.(); });
+        }
+        return true;
+    });
+}
+/** The span the active selection covers, as whole rows or whole columns. */
+function spanOf(cmd, axis) {
+    const rect = cmd.ranges[cmd.ranges.length - 1];
+    if (rect) {
+        const [minRow, minCol, maxRow, maxCol] = rect;
+        return axis === 'rows'
+            ? { at: minRow, count: maxRow - minRow + 1 }
+            : { at: minCol, count: maxCol - minCol + 1 };
+    }
+    const active = cmd.activeCell;
+    if (!active)
+        return null;
+    return axis === 'rows'
+        ? { at: active.rowIndex, count: 1 }
+        : { at: active.colIndex, count: 1 };
+}
+export function insertRows(cmd, at, count = 1) {
+    const span = at === undefined ? spanOf(cmd, 'rows') : { at, count };
+    if (!span)
+        return false;
+    return run(cmd, { kind: 'insertRows', at: span.at, count: span.count });
+}
+export function deleteRows(cmd, at, count = 1) {
+    const span = at === undefined ? spanOf(cmd, 'rows') : { at, count };
+    if (!span)
+        return false;
+    return run(cmd, { kind: 'deleteRows', at: span.at, count: span.count });
+}
+export function insertColumns(cmd, at, count = 1) {
+    const span = at === undefined ? spanOf(cmd, 'cols') : { at, count };
+    if (!span)
+        return false;
+    return run(cmd, { kind: 'insertCols', at: span.at, count: span.count });
+}
+export function deleteColumns(cmd, at, count = 1) {
+    const span = at === undefined ? spanOf(cmd, 'cols') : { at, count };
+    if (!span)
+        return false;
+    return run(cmd, { kind: 'deleteCols', at: span.at, count: span.count });
+}
+/**
+ * Which axis a bare Ctrl+Plus / Ctrl+Minus acts on.
+ *
+ * Excel opens a dialog when the selection is not a whole row or column. That
+ * dialog is a design decision, so this reports what it would ask about and
+ * lets the consumer decide: a selection spanning every column is a row
+ * operation, every row is a column operation, anything else is ambiguous.
+ */
+export function axisForSelection(cmd) {
+    const rect = cmd.ranges[cmd.ranges.length - 1];
+    if (!rect)
+        return 'rows';
+    const [minRow, minCol, maxRow, maxCol] = rect;
+    const spansAllCols = minCol === 0 && maxCol >= cmd.colCount - 1;
+    const spansAllRows = minRow === 0 && maxRow >= cmd.rowCount - 1;
+    if (spansAllCols && !spansAllRows)
+        return 'rows';
+    if (spansAllRows && !spansAllCols)
+        return 'cols';
+    if (spansAllCols && spansAllRows)
+        return 'rows';
+    return 'ambiguous';
+}

package/dist/sheet/table-styles.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The table styles gallery: Excel's presets, by the names Excel stores.
+ *
+ * A table's look is drawn rather than written into the cells, which is what
+ * lets a row typed under the last one arrive already banded. That drawing
+ * needs colours, and "the theme's accent" is one look rather than a gallery,
+ * so this is the set to pick from.
+ *
+ * The ids are Excel's own (`TableStyleMedium2`), and the colours are the
+ * Office theme's accents, so a table saved here opens in Excel wearing the
+ * same style rather than something approximate. A style is three tones of
+ * one accent: Light tints the header, Medium fills it, Dark fills it with a
+ * deeper shade, exactly as Excel's three families do.
+ */
+export type TableStyleTone = 'light' | 'medium' | 'dark';
+export type TableStyle = {
+    /** Excel's name for it, which is what goes in the file. */
+    id: string;
+    /** The colour's name, for the gallery. */
+    colour: string;
+    tone: TableStyleTone;
+    /** The Office theme accent it is built from. */
+    accent: string;
+};
+/**
+ * Eighteen styles: six accents in three tones. Excel numbers each family
+ * from 1, with 1 reserved for the black-and-white variant, so the accents
+ * start at 2 and this maps one for one onto the built-in names.
+ */
+export declare const TABLE_STYLES: ReadonlyArray<TableStyle>;
+/** What a table wears unless it is given something else: Excel's own default. */
+export declare const DEFAULT_TABLE_STYLE = "TableStyleMedium2";
+/** No style at all: the cells keep whatever formats they carry. */
+export declare const NO_TABLE_STYLE = "None";
+export declare function findTableStyle(id: string | undefined): TableStyle | undefined;
+/**
+ * Black or white over a fill, whichever can be read.
+ *
+ * Excel paints a header's text white whatever the fill, which on its gold
+ * and sky accents is about 2:1: legible to some people, not to others, and
+ * flagged by every checker. Picking the readable one keeps Excel's colours
+ * and drops the part of Excel's behaviour that fails.
+ */
+export declare function readableOn(fill: string): string;
+/**
+ * The fill a filled header takes: the accent, darkened only when neither
+ * black nor white can be read on it.
+ *
+ * Mid grey is the one accent where that happens: white is 4.0 against it
+ * and near-black 4.3, so both sit under the 4.5 a checker asks for. A few
+ * steps darker keeps it recognisably the same grey and lets the white text
+ * clear it, which is a smaller lie than a header nobody can read.
+ */
+export declare function headerFill(accent: string): string;
+export type TableStyleColours = {
+    /** The header row's fill, and the colour its text needs to stay readable. */
+    header: string;
+    headerText: string;
+    /** Every other data row. */
+    band: string;
+    /** The totals row, and the line over it. */
+    totals: string;
+    border: string;
+};
+/**
+ * A style as CSS colours.
+ *
+ * `color-mix` rather than fixed hexes for the tints, so a table keeps its
+ * colour over a dark sheet as well as a light one: the accent is mixed with
+ * the surface underneath rather than painted over it.
+ */
+export declare function tableStyleColours(style: TableStyle | string | undefined): TableStyleColours | null;
+/** "Blue, Medium", for the gallery's tooltip and for a screen reader. */
+export declare function tableStyleLabel(style: TableStyle): string;

package/dist/sheet/table-styles.js

@@ -0,0 +1,152 @@
+/**
+ * The table styles gallery: Excel's presets, by the names Excel stores.
+ *
+ * A table's look is drawn rather than written into the cells, which is what
+ * lets a row typed under the last one arrive already banded. That drawing
+ * needs colours, and "the theme's accent" is one look rather than a gallery,
+ * so this is the set to pick from.
+ *
+ * The ids are Excel's own (`TableStyleMedium2`), and the colours are the
+ * Office theme's accents, so a table saved here opens in Excel wearing the
+ * same style rather than something approximate. A style is three tones of
+ * one accent: Light tints the header, Medium fills it, Dark fills it with a
+ * deeper shade, exactly as Excel's three families do.
+ */
+/** The Office theme's six accents, in Excel's order. */
+const ACCENTS = [
+    { name: 'Blue', hex: '#4472c4' },
+    { name: 'Orange', hex: '#ed7d31' },
+    { name: 'Grey', hex: '#7f7f7f' },
+    { name: 'Gold', hex: '#ffc000' },
+    { name: 'Sky', hex: '#5b9bd5' },
+    { name: 'Green', hex: '#70ad47' },
+];
+const TONES = [
+    { tone: 'light', family: 'Light' },
+    { tone: 'medium', family: 'Medium' },
+    { tone: 'dark', family: 'Dark' },
+];
+/**
+ * Eighteen styles: six accents in three tones. Excel numbers each family
+ * from 1, with 1 reserved for the black-and-white variant, so the accents
+ * start at 2 and this maps one for one onto the built-in names.
+ */
+export const TABLE_STYLES = TONES.flatMap(({ tone, family }) => ACCENTS.map((accent, i) => ({
+    id: `TableStyle${family}${i + 2}`,
+    colour: accent.name,
+    tone,
+    accent: accent.hex,
+})));
+/** What a table wears unless it is given something else: Excel's own default. */
+export const DEFAULT_TABLE_STYLE = 'TableStyleMedium2';
+/** No style at all: the cells keep whatever formats they carry. */
+export const NO_TABLE_STYLE = 'None';
+export function findTableStyle(id) {
+    if (!id || id === NO_TABLE_STYLE)
+        return undefined;
+    return TABLE_STYLES.find((s) => s.id.toLowerCase() === id.toLowerCase());
+}
+/** A hex colour as its three channels, 0 to 255. */
+function channels(hex) {
+    const value = hex.trim().replace('#', '');
+    const full = value.length === 3 ? value.split('').map((c) => c + c).join('') : value;
+    const n = Number.parseInt(full.slice(0, 6), 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+/** Relative luminance, the way WCAG defines it. */
+function luminance(hex) {
+    const [r, g, b] = channels(hex).map((c) => {
+        const s = c / 255;
+        return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrast(a, b) {
+    const [x, y] = [luminance(a), luminance(b)].sort((p, q) => q - p);
+    return (x + 0.05) / (y + 0.05);
+}
+/**
+ * Black or white over a fill, whichever can be read.
+ *
+ * Excel paints a header's text white whatever the fill, which on its gold
+ * and sky accents is about 2:1: legible to some people, not to others, and
+ * flagged by every checker. Picking the readable one keeps Excel's colours
+ * and drops the part of Excel's behaviour that fails.
+ */
+export function readableOn(fill) {
+    const dark = '#0f172a';
+    const light = '#ffffff';
+    return contrast(fill, light) >= contrast(fill, dark) ? light : dark;
+}
+/**
+ * The fill a filled header takes: the accent, darkened only when neither
+ * black nor white can be read on it.
+ *
+ * Mid grey is the one accent where that happens: white is 4.0 against it
+ * and near-black 4.3, so both sit under the 4.5 a checker asks for. A few
+ * steps darker keeps it recognisably the same grey and lets the white text
+ * clear it, which is a smaller lie than a header nobody can read.
+ */
+export function headerFill(accent) {
+    const best = Math.max(contrast(accent, '#ffffff'), contrast(accent, '#0f172a'));
+    if (best >= 4.5)
+        return accent;
+    for (let percent = 92; percent >= 60; percent -= 8) {
+        const darker = mixWithBlack(accent, percent);
+        if (contrast(darker, '#ffffff') >= 4.5)
+            return darker;
+    }
+    return mixWithBlack(accent, 60);
+}
+/** The colour a mix of an accent with black comes out as, for the dark tone. */
+function mixWithBlack(hex, percent) {
+    const mixed = channels(hex).map((c) => Math.round((c * percent) / 100));
+    return `#${mixed.map((c) => c.toString(16).padStart(2, '0')).join('')}`;
+}
+/**
+ * A style as CSS colours.
+ *
+ * `color-mix` rather than fixed hexes for the tints, so a table keeps its
+ * colour over a dark sheet as well as a light one: the accent is mixed with
+ * the surface underneath rather than painted over it.
+ */
+export function tableStyleColours(style) {
+    const found = typeof style === 'string' || style === undefined ? findTableStyle(style) : style;
+    if (!found)
+        return null;
+    const accent = found.accent;
+    const mix = (percent, into = 'transparent') => `color-mix(in srgb, ${accent} ${percent}%, ${into})`;
+    if (found.tone === 'light') {
+        return {
+            header: mix(18),
+            headerText: 'inherit',
+            band: mix(8),
+            totals: mix(14),
+            border: mix(50),
+        };
+    }
+    if (found.tone === 'dark') {
+        return {
+            header: `color-mix(in srgb, ${accent} 65%, #000)`,
+            headerText: readableOn(mixWithBlack(accent, 65)),
+            band: mix(22),
+            totals: mix(30),
+            border: mix(70),
+        };
+    }
+    const fill = headerFill(accent);
+    return {
+        header: fill,
+        // White where white can be read, near-black where it cannot: Excel's
+        // gold and sky headers are about 2:1 against white.
+        headerText: readableOn(fill),
+        band: mix(13),
+        totals: mix(20),
+        border: mix(55),
+    };
+}
+/** "Blue, Medium", for the gallery's tooltip and for a screen reader. */
+export function tableStyleLabel(style) {
+    const tone = style.tone === 'light' ? 'Light' : style.tone === 'dark' ? 'Dark' : 'Medium';
+    return `${style.colour}, ${tone}`;
+}

package/dist/sheet/tables.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Tables: a named region with a header row, so a formula can say
+ * `Orders[Amount]` instead of `D2:D57` and keep meaning it after rows are
+ * added.
+ *
+ * The point is not shorter text. A1 references are positional, so a total
+ * under a table has to be re-pointed every time the table grows, and a
+ * reference typed against 57 rows silently stops covering row 58. A
+ * structured reference names the COLUMN, and the range it resolves to is
+ * whatever the table currently is.
+ *
+ * This module is the model; the grammar that reads `Orders[Amount]` lives in
+ * the tokenizer, and resolving one to a range happens at evaluation, because
+ * the range depends on the table's size at that moment rather than at parse
+ * time.
+ */
+import type { StructuralEdit } from './refs.js';
+export type TableRegion = {
+    name: string;
+    sheet: string;
+    /** Row of the header. The data starts on the next one. */
+    headerRow: number;
+    /** First and last column, inclusive. */
+    firstCol: number;
+    lastCol: number;
+    /** Last row of the DATA, not counting a totals row. */
+    lastRow: number;
+    /** Whether the row after `lastRow` is a totals row. */
+    hasTotals: boolean;
+    /**
+     * The look, by Excel's name for it (`TableStyleMedium2`), or `'None'` for
+     * cells that keep whatever formats they carry. Absent means the default,
+     * which is Excel's default too.
+     */
+    style?: string;
+};
+/** Which part of a table a structured reference asks for. */
+export type TableSpecifier = '#All' | '#Data' | '#Headers' | '#Totals' | '#ThisRow';
+export type TableRange = {
+    sheet: string;
+    firstRow: number;
+    lastRow: number;
+    firstCol: number;
+    lastCol: number;
+};
+export type TableRegistry = {
+    define(table: TableRegion): void;
+    remove(name: string): boolean;
+    get(name: string): TableRegion | undefined;
+    list(): TableRegion[];
+    /** The table containing a cell, if any. This is what makes an unqualified
+     *  `[@Amount]` work: it only means something inside a table. */
+    at(sheet: string, row: number, col: number): TableRegion | undefined;
+    /** Grow a table to include a row written just below it, the way Excel's
+     *  auto-expand does. Returns whether anything changed. */
+    growToInclude(sheet: string, row: number, col: number): boolean;
+    clear(): void;
+};
+/** Excel's rules for a table name are the same as for a defined name. */
+export declare function isValidTableName(name: string): boolean;
+export declare function createTableRegistry(initial?: ReadonlyArray<TableRegion>): TableRegistry;
+/** Column index for a header name, or -1. Case-insensitive, as Excel is. */
+export declare function columnIndexOf(table: TableRegion, header: string, headerAt: (sheet: string, row: number, col: number) => string): number;
+/**
+ * Resolve a structured reference to a rectangle.
+ *
+ * `currentRow` is where the formula lives, which is the only way `[@Amount]`
+ * can mean anything: "this row" is relative to the formula, not the table.
+ * A `#ThisRow` reference from outside the table has no answer, so it returns
+ * null and the evaluator reports #VALUE!, which is what Excel does.
+ */
+export declare function resolveTableRange(table: TableRegion, specifier: TableSpecifier, columns: {
+    from: number;
+    to: number;
+} | null, currentRow: number | null): TableRange | null;
+/** How many data rows a table holds. */
+export declare function rowCountOf(table: TableRegion): number;
+/**
+ * A table after an insert or delete on its own sheet: its header row, its
+ * columns and its last row move with the cells. Null when the edit took the
+ * header row, or every column, which is what deleting a table looks like.
+ *
+ * A totals row sits on `lastRow + 1`, so it moves with the rest; an insert
+ * INSIDE the table grows it, which is what Excel does when a row is added
+ * in the middle of one.
+ */
+export declare function shiftTable(table: TableRegion, sheet: string, edit: StructuralEdit): TableRegion | null;
+/** Every table after an edit, the gone ones dropped. */
+export declare function shiftTables(tables: ReadonlyArray<TableRegion>, sheet: string, edit: StructuralEdit): TableRegion[];

package/dist/sheet/tables.js

@@ -0,0 +1,178 @@
+/**
+ * Tables: a named region with a header row, so a formula can say
+ * `Orders[Amount]` instead of `D2:D57` and keep meaning it after rows are
+ * added.
+ *
+ * The point is not shorter text. A1 references are positional, so a total
+ * under a table has to be re-pointed every time the table grows, and a
+ * reference typed against 57 rows silently stops covering row 58. A
+ * structured reference names the COLUMN, and the range it resolves to is
+ * whatever the table currently is.
+ *
+ * This module is the model; the grammar that reads `Orders[Amount]` lives in
+ * the tokenizer, and resolving one to a range happens at evaluation, because
+ * the range depends on the table's size at that moment rather than at parse
+ * time.
+ */
+import { shiftRect } from './rects.js';
+/** Excel's rules for a table name are the same as for a defined name. */
+export function isValidTableName(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name))
+        return false;
+    if (name.length > 255)
+        return false;
+    if (/^\$?[A-Za-z]{1,3}\$?\d+$/.test(name))
+        return false;
+    if (/^[RC]$/i.test(name))
+        return false;
+    return true;
+}
+export function createTableRegistry(initial = []) {
+    const byName = new Map();
+    const registry = {
+        define(table) {
+            if (!isValidTableName(table.name)) {
+                throw new Error(`"${table.name}" is not a valid table name`);
+            }
+            byName.set(table.name.toLowerCase(), { ...table });
+        },
+        remove(name) {
+            return byName.delete(name.toLowerCase());
+        },
+        get(name) {
+            return byName.get(name.toLowerCase());
+        },
+        list() {
+            return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+        },
+        at(sheet, row, col) {
+            for (const table of byName.values()) {
+                if (table.sheet !== sheet)
+                    continue;
+                if (col < table.firstCol || col > table.lastCol)
+                    continue;
+                const bottom = table.hasTotals ? table.lastRow + 1 : table.lastRow;
+                if (row < table.headerRow || row > bottom)
+                    continue;
+                return table;
+            }
+            return undefined;
+        },
+        growToInclude(sheet, row, col) {
+            for (const table of byName.values()) {
+                if (table.sheet !== sheet)
+                    continue;
+                if (col < table.firstCol || col > table.lastCol)
+                    continue;
+                // Only the row immediately after the data extends it. A write five
+                // rows below is a separate thing the user put there, and swallowing
+                // it would be worse than not expanding.
+                if (row !== table.lastRow + 1)
+                    continue;
+                // A totals row occupies that slot already; Excel inserts above it,
+                // which is a structural edit rather than a grow.
+                if (table.hasTotals)
+                    continue;
+                table.lastRow = row;
+                return true;
+            }
+            return false;
+        },
+        clear() {
+            byName.clear();
+        },
+    };
+    for (const table of initial)
+        registry.define(table);
+    return registry;
+}
+/** Column index for a header name, or -1. Case-insensitive, as Excel is. */
+export function columnIndexOf(table, header, headerAt) {
+    const wanted = header.trim().toLowerCase();
+    for (let c = table.firstCol; c <= table.lastCol; c += 1) {
+        if (headerAt(table.sheet, table.headerRow, c).trim().toLowerCase() === wanted)
+            return c;
+    }
+    return -1;
+}
+/**
+ * Resolve a structured reference to a rectangle.
+ *
+ * `currentRow` is where the formula lives, which is the only way `[@Amount]`
+ * can mean anything: "this row" is relative to the formula, not the table.
+ * A `#ThisRow` reference from outside the table has no answer, so it returns
+ * null and the evaluator reports #VALUE!, which is what Excel does.
+ */
+export function resolveTableRange(table, specifier, columns, currentRow) {
+    const firstCol = columns ? columns.from : table.firstCol;
+    const lastCol = columns ? columns.to : table.lastCol;
+    if (firstCol < 0 || lastCol < 0)
+        return null;
+    const totalsRow = table.hasTotals ? table.lastRow + 1 : null;
+    switch (specifier) {
+        case '#Headers':
+            return { sheet: table.sheet, firstRow: table.headerRow, lastRow: table.headerRow, firstCol, lastCol };
+        case '#Totals':
+            return totalsRow === null
+                ? null
+                : { sheet: table.sheet, firstRow: totalsRow, lastRow: totalsRow, firstCol, lastCol };
+        case '#All':
+            return {
+                sheet: table.sheet,
+                firstRow: table.headerRow,
+                lastRow: totalsRow ?? table.lastRow,
+                firstCol, lastCol,
+            };
+        case '#ThisRow': {
+            if (currentRow === null)
+                return null;
+            // Outside the table's data rows, "this row" is meaningless.
+            if (currentRow <= table.headerRow || currentRow > table.lastRow)
+                return null;
+            return { sheet: table.sheet, firstRow: currentRow, lastRow: currentRow, firstCol, lastCol };
+        }
+        case '#Data':
+        default: {
+            const firstRow = table.headerRow + 1;
+            // An empty table has no data rows. Returning the header row instead
+            // would make =SUM(Orders[Amount]) add the word "Amount".
+            if (firstRow > table.lastRow)
+                return null;
+            return { sheet: table.sheet, firstRow, lastRow: table.lastRow, firstCol, lastCol };
+        }
+    }
+}
+/** How many data rows a table holds. */
+export function rowCountOf(table) {
+    return Math.max(0, table.lastRow - table.headerRow);
+}
+/**
+ * A table after an insert or delete on its own sheet: its header row, its
+ * columns and its last row move with the cells. Null when the edit took the
+ * header row, or every column, which is what deleting a table looks like.
+ *
+ * A totals row sits on `lastRow + 1`, so it moves with the rest; an insert
+ * INSIDE the table grows it, which is what Excel does when a row is added
+ * in the middle of one.
+ */
+export function shiftTable(table, sheet, edit) {
+    if (table.sheet.toLowerCase() !== sheet.toLowerCase())
+        return table;
+    const rows = edit.kind === 'insertRows' || edit.kind === 'deleteRows';
+    const rect = rows
+        ? [table.headerRow, table.firstCol, table.lastRow + (table.hasTotals ? 1 : 0), table.lastCol]
+        : [table.headerRow, table.firstCol, table.lastRow + (table.hasTotals ? 1 : 0), table.lastCol];
+    const moved = shiftRect(rect, edit);
+    if (!moved)
+        return null;
+    const [r1, c1, r2, c2] = moved;
+    // A table with no data rows left is gone, as is one whose header went.
+    const lastRow = r2 - (table.hasTotals ? 1 : 0);
+    if (lastRow < r1 + 1)
+        return null;
+    return { ...table, headerRow: r1, firstCol: c1, lastCol: c2, lastRow };
+}
+/** Every table after an edit, the gone ones dropped. */
+export function shiftTables(tables, sheet, edit) {
+    return tables.map((t) => shiftTable(t, sheet, edit)).filter((t) => t !== null);
+}