@svgrid/enterprise 3.0.2 → 3.0.3

package/dist/sheet/deps.js

@@ -48,7 +48,25 @@ export function precedentsOf(ast, self, lastRow,
  * `Tax` leaves the formula showing its old value until something else
  * forces a recalculation.
  */
-resolveName, depth = 0) {
+resolveName, 
+/**
+ * The rectangle behind a structured reference (`Orders[Amount]`,
+ * `[@Qty]`). Without it a formula over a table records no precedents, so
+ * editing a cell in the table leaves every total reading it stale until
+ * something forces a full recalculation.
+ */
+resolveTable, 
+/**
+ * The rectangle a spilled-range operator (`A1#`) currently covers. The
+ * anchor cell is always recorded regardless, so a formula reading `A1#`
+ * recalculates whenever the array is re-typed and picks up the new extent;
+ * the covered cells are added on top so a change anywhere in the spill
+ * reaches it too.
+ */
+resolveSpill, 
+/** The sheets a 3D reference spans, so it recalculates when the cell on any
+ *  of them changes. */
+resolveSheets, depth = 0) {
     const out = [];
     visit(ast, (n) => {
         if (n.k === 'name') {
@@ -56,7 +74,46 @@ resolveName, depth = 0) {
             // after a few hops rather than recursing forever.
             const target = depth < 8 ? resolveName?.(n.name) : null;
             if (target)
-                out.push(...precedentsOf(target, self, lastRow, resolveName, depth + 1));
+                out.push(...precedentsOf(target, self, lastRow, resolveName, resolveTable, resolveSpill, resolveSheets, depth + 1));
+            return;
+        }
+        if (n.k === 'ref3d') {
+            const sheets = resolveSheets?.(n.sheetFrom, n.sheetTo);
+            if (!sheets)
+                return;
+            const r1 = Math.min(n.from.row ?? 0, n.to.row ?? 0);
+            const r2 = Math.max(n.from.row ?? 0, n.to.row ?? 0);
+            const c1 = Math.min(n.from.col, n.to.col);
+            const c2 = Math.max(n.from.col, n.to.col);
+            for (const s of sheets) {
+                for (let r = r1; r <= r2; r += 1) {
+                    for (let c = c1; c <= c2; c += 1)
+                        out.push(cellKey(s, r, c));
+                }
+            }
+            return;
+        }
+        if (n.k === 'spill') {
+            // The anchor always: retyping the array changes the anchor cell, so
+            // this makes the reader recalculate and re-derive the extent below.
+            out.push(cellKey(n.ref.sheet ?? self.sheet, n.ref.row ?? 0, n.ref.col));
+            const rect = resolveSpill?.(n);
+            if (rect) {
+                for (let r = rect.r1; r <= rect.r2; r += 1) {
+                    for (let c = rect.c1; c <= rect.c2; c += 1)
+                        out.push(cellKey(rect.sheet ?? self.sheet, r, c));
+                }
+            }
+            return;
+        }
+        if (n.k === 'table') {
+            const rect = resolveTable?.(n);
+            if (!rect)
+                return;
+            for (let r = rect.firstRow; r <= rect.lastRow; r += 1) {
+                for (let c = rect.firstCol; c <= rect.lastCol; c += 1)
+                    out.push(cellKey(rect.sheet, r, c));
+            }
             return;
         }
         if (n.k === 'ref' && n.ref.row !== null) {
@@ -79,6 +136,21 @@ resolveName, depth = 0) {
     });
     return out;
 }
+/**
+ * Functions whose result can change without any precedent changing: a
+ * reference built from text, a range built from arithmetic, the clock, a
+ * random number. A cell holding one is recomputed on every edit, as Excel
+ * recomputes its volatile cells, rather than trusting the graph.
+ */
+export const VOLATILE_FUNCTIONS = new Set(['INDIRECT', 'OFFSET', 'RAND', 'RANDBETWEEN', 'NOW', 'TODAY']);
+export function isVolatile(ast) {
+    let found = false;
+    visit(ast, (n) => {
+        if (n.k === 'fn' && VOLATILE_FUNCTIONS.has(n.name))
+            found = true;
+    });
+    return found;
+}
 export function createDependencyGraph() {
     /** cell -> what it reads. */
     const precedents = new Map();
@@ -188,6 +260,9 @@ export function createDependencyGraph() {
             }
             return out;
         },
+        precedentsOf(cell) {
+            return [...(precedents.get(cell) ?? [])];
+        },
         dependentsOf(cell) {
             return [...(dependents.get(cell) ?? [])];
         },

package/dist/sheet/document.d.ts

@@ -21,10 +21,20 @@ import { type Workbook, type SheetData } from './workbook.js';
 import { type SheetFormatStore, type CellFormatEntry } from './format-store.js';
 import type { FreezeState } from './freeze.js';
 import type { StructuralEdit } from './refs.js';
-import { type NotesMap, type Rect } from './rects.js';
+import { type Rect } from './rects.js';
+import type { CommentsMap } from './comments.js';
+import { type SheetProtection } from './protection.js';
+import { type PageSetup } from './page-setup.js';
+import { type SheetObject } from './objects.js';
+import { type SparklineGroup } from './sparklines.js';
+import { type SheetPivot } from './pivot-range.js';
+import { type LinksMap } from './links.js';
 import { type ValidationRule } from './validation.js';
 import { type CfRule } from './conditional-formats.js';
 import { type AutoFilterState } from './auto-filter.js';
+import { type CellTypeRegion } from './cell-types.js';
+import { type GridSheetSpec, type SheetKind } from './sheet-kinds.js';
+import { type OutlineState } from './outline.js';
 /** Why the document changed. A listener gets every reason since its last call. */
 export type SheetChangeReason = {
     kind: 'cells';
@@ -46,6 +56,27 @@ export type SheetChangeReason = {
     kind: 'conditional-formats';
 } | {
     kind: 'protection';
+} | {
+    kind: 'page-setup';
+} | {
+    kind: 'objects';
+} | {
+    kind: 'sparklines';
+} | {
+    kind: 'pivots';
+} | {
+    kind: 'links';
+} | {
+    kind: 'tables';
+}
+/**
+ * The workbook's own parts rather than a sheet's: its defined names and
+ * its calculation settings. They belong to no sheet, so nothing keyed by
+ * sheet can carry them, and a listener that mirrors a document elsewhere
+ * has to hear about them separately.
+ */
+ | {
+    kind: 'workbook';
 } | {
     kind: 'merges';
 } | {
@@ -68,15 +99,48 @@ export type PerSheetState = {
         rows: Set<number>;
         cols: Set<number>;
     };
+    /** Data > Group: the outline level of each row and column, and which
+     *  summary lines are collapsed. Lines a collapsed group hides are kept
+     *  apart from `hidden`, so expanding a group does not un-hide a row the
+     *  user hid by hand. */
+    outline: {
+        rows: OutlineState;
+        cols: OutlineState;
+    };
     freeze: FreezeState;
-    /** Cell comments in the grid's `notes` shape: `r4` -> `B` -> text. */
-    notes: NotesMap;
+    /** Cell comments keyed like the grid's `notes`: `r4` -> `B` -> a note's text or a thread. */
+    notes: CommentsMap;
     protected: boolean;
+    /** What stays allowed while protected, and the ranges that take an edit anyway. */
+    protection: SheetProtection;
+    /** Page Layout: orientation, paper, margins, print area, title rows, gridlines, headings, scale. */
+    pageSetup: PageSetup;
+    /** Charts and pictures anchored over the cells, back to front. */
+    objects: SheetObject[];
+    sparklines: SparklineGroup[];
+    pivots: SheetPivot[];
+    /** Hyperlinks by cell, keyed like the comments: `r4` -> `B` -> the link. */
+    links: LinksMap;
+    /** Excel's Hide Sheet: the tab is not shown and the shortcuts skip it. */
+    sheetHidden: boolean;
+    /**
+     * What this tab is: a cell grid, or a table bound to records.
+     *
+     * A `grid` sheet keeps its records in `grid` and projects them into the
+     * workbook's cells, so a formula on any other sheet reads it the way it
+     * reads a cell sheet. See `sheet-kinds.ts`.
+     */
+    kind: SheetKind;
+    /** The records and columns of a `grid` sheet; absent on a cell sheet. */
+    grid?: GridSheetSpec;
     merges: Rect[];
     /** Data validation rules, in order; the last one covering a cell applies. */
     validation: ValidationRule[];
     /** Conditional formatting rules, in priority order: the first one decides. */
     conditionalFormats: CfRule[];
+    /** Cells drawn as a control rather than as text: a checkbox, a button,
+     *  a radio group. The cell's value stays the truth. */
+    cellTypes: CellTypeRegion[];
     /** Excel's AutoFilter over a region, or null when the arrows are off. */
     autoFilter: AutoFilterState | null;
     /** The rows the AutoFilter hides right now; worked out, never saved. */
@@ -91,12 +155,37 @@ export type SheetStateEntry = {
         rows: number[];
         cols: number[];
     };
+    /** Absent in documents saved before outlining existed. */
+    outline?: {
+        rows: OutlineState;
+        cols: OutlineState;
+    };
     freeze: FreezeState;
-    comments: NotesMap;
+    /** `r4` -> `B` -> a note's text, or a thread with its author, replies and state. */
+    comments: CommentsMap;
     protected: boolean;
+    /** Absent in documents saved before the allow list and edit ranges existed. */
+    protection?: SheetProtection;
+    /** Absent in documents saved before Page Layout existed. */
+    pageSetup?: PageSetup;
+    /** Absent in documents saved before objects existed. */
+    objects?: SheetObject[];
+    /** Absent in documents saved before sparklines existed. */
+    sparklines?: SparklineGroup[];
+    /** Absent in documents saved before pivots existed. */
+    pivots?: SheetPivot[];
+    /** Absent in documents saved before hyperlinks existed. */
+    links?: LinksMap;
+    /** Absent in documents saved before hidden sheets existed. */
+    sheetHidden?: boolean;
+    /** Absent in documents saved before sheet kinds existed; reads as 'cells'. */
+    kind?: SheetKind;
+    grid?: GridSheetSpec;
     merges: Array<[number, number, number, number]>;
     validation: ValidationRule[];
     conditionalFormats: CfRule[];
+    /** Absent in documents saved before cell types existed. */
+    cellTypes?: CellTypeRegion[];
     autoFilter: AutoFilterState | null;
 };
 /**
@@ -116,6 +205,12 @@ export type SheetDocument = {
     has(name: string): boolean;
     rename(from: string, to: string): void;
     remove(name: string): void;
+    /**
+     * Excel's Move or Copy > Create a copy: a new sheet after `from` with
+     * its cells and everything this document keeps beside them, named `to`
+     * or "Name (2)". Returns the new name, or null when it could not.
+     */
+    duplicate(from: string, to?: string): string | null;
     /** The sheets that have state, in no particular order. */
     names(): string[];
     /**
@@ -135,6 +230,13 @@ export type SheetDocument = {
     setState(state: SheetState): void;
     /** Hear about changes, once per tick with every reason since the last call. */
     subscribe(listener: (reasons: ReadonlyArray<SheetChangeReason>) => void): () => void;
+    /**
+     * Put back only the parts `entry` names, leaving the rest of the sheet as
+     * it is: what a delta from another user applies, and what a host that
+     * wants to set one feature calls. Reports the change, so the shell
+     * repaints; wrap it in `mute` where it should not.
+     */
+    patch(name: string, entry: Partial<SheetStateEntry>): void;
     /** Record a change. Coalesced per microtask; silent while muted. */
     changed(reason: SheetChangeReason): void;
     /** Run `fn` without reporting changes: restores and mount-time seeding. */

package/dist/sheet/document.js

@@ -20,29 +20,89 @@
 import { createWorkbook } from './workbook.js';
 import { createFormatStore } from './format-store.js';
 import { lineShift, remapNotes, shiftRect } from './rects.js';
+import { copyProtection, defaultProtection } from './protection.js';
+import { copyPageSetup, defaultPageSetup, shiftPageSetup } from './page-setup.js';
+import { copyObject, objectId, shiftObjects } from './objects.js';
+import { copySparkline, shiftSparklines, sparklineId } from './sparklines.js';
+import { copyPivot, pivotId, shiftPivots } from './pivot-range.js';
+import { copyLinks, shiftLinks } from './links.js';
+import { releaseFilteredRows } from './filter-files.js';
 import { colToLetters, lettersToCol } from './address.js';
 import { shiftValidation } from './validation.js';
 import { shiftCf } from './conditional-formats.js';
 import { shiftAutoFilter } from './auto-filter.js';
+import { copyCellType, shiftCellTypes } from './cell-types.js';
+import { copyGridSheet } from './sheet-kinds.js';
+import { emptyOutline, shiftOutline } from './outline.js';
+/** A deep copy of one axis's outline, absent reading as an empty one. */
+const copyOutline = (o) => (o ? { levels: { ...o.levels }, collapsed: [...o.collapsed] } : emptyOutline());
+/** Which change a patched part of a sheet counts as, so listeners hear it. */
+function reasonsForEntry(entry) {
+    const out = [];
+    if (entry.formats !== undefined)
+        out.push({ kind: 'formats' });
+    if (entry.columnWidths !== undefined || entry.rowHeights !== undefined)
+        out.push({ kind: 'sizes' });
+    if (entry.hidden !== undefined || entry.sheetHidden !== undefined)
+        out.push({ kind: 'hidden' });
+    if (entry.freeze !== undefined)
+        out.push({ kind: 'freeze' });
+    if (entry.comments !== undefined)
+        out.push({ kind: 'comments' });
+    if (entry.protected !== undefined || entry.protection !== undefined)
+        out.push({ kind: 'protection' });
+    if (entry.pageSetup !== undefined)
+        out.push({ kind: 'page-setup' });
+    if (entry.objects !== undefined)
+        out.push({ kind: 'objects' });
+    if (entry.sparklines !== undefined)
+        out.push({ kind: 'sparklines' });
+    if (entry.pivots !== undefined)
+        out.push({ kind: 'pivots' });
+    if (entry.links !== undefined)
+        out.push({ kind: 'links' });
+    if (entry.merges !== undefined)
+        out.push({ kind: 'merges' });
+    if (entry.validation !== undefined)
+        out.push({ kind: 'validation' });
+    if (entry.conditionalFormats !== undefined)
+        out.push({ kind: 'conditional-formats' });
+    if (entry.autoFilter !== undefined)
+        out.push({ kind: 'filter' });
+    return out;
+}
 function emptySheetState() {
     return {
         formats: createFormatStore(),
         widths: {},
         heights: new Map(),
         hidden: { rows: new Set(), cols: new Set() },
+        outline: { rows: emptyOutline(), cols: emptyOutline() },
         freeze: { rows: 0, cols: 0 },
         notes: {},
         protected: false,
+        protection: defaultProtection(),
+        pageSetup: defaultPageSetup(),
+        objects: [],
+        sparklines: [],
+        pivots: [],
+        links: {},
+        sheetHidden: false,
+        kind: 'cells',
         merges: [],
         validation: [],
         conditionalFormats: [],
+        cellTypes: [],
         autoFilter: null,
         filterHidden: new Set(),
     };
 }
 export function createSheetDocument(init = {}) {
     const workbook = init.workbook ??
-        createWorkbook(init.state ? init.state.workbook.sheets.map((s) => ({ name: s.name, cells: s.cells })) : (init.sheets ? [...init.sheets] : [{ name: 'Sheet1', cells: [] }]));
+        createWorkbook(init.state ? init.state.workbook.sheets.map((s) => ({ name: s.name, cells: s.cells })) : (init.sheets ? [...init.sheets] : [{ name: 'Sheet1', cells: [] }]), {
+            ...(init.state?.workbook.tables?.length ? { tables: init.state.workbook.tables } : {}),
+            ...(init.state?.workbook.iteration ? { iteration: init.state.workbook.iteration } : {}),
+        });
     const entries = new Map();
     const listeners = new Set();
     let pending = [];
@@ -77,29 +137,121 @@ export function createSheetDocument(init = {}) {
         scheduled = true;
         queueMicrotask(flush);
     }
+    /** A row of comments copied deep enough that a saved thread is not the live one. */
+    function copyLine(line) {
+        const out = {};
+        for (const [c, v] of Object.entries(line))
+            out[c] = typeof v === 'string' ? v : { ...v, ...(v.replies ? { replies: v.replies.map((r) => ({ ...r })) } : {}) };
+        return out;
+    }
     function serializeEntry(state) {
         return {
             formats: state.formats.serialize(),
             columnWidths: { ...state.widths },
             rowHeights: [...state.heights].map(([r, h]) => [r, h]),
             hidden: { rows: [...state.hidden.rows], cols: [...state.hidden.cols] },
+            outline: { rows: copyOutline(state.outline.rows), cols: copyOutline(state.outline.cols) },
             freeze: { ...state.freeze },
-            comments: Object.fromEntries(Object.entries(state.notes).map(([r, line]) => [r, { ...line }])),
+            comments: Object.fromEntries(Object.entries(state.notes).map(([r, line]) => [r, copyLine(line)])),
             protected: state.protected,
+            protection: copyProtection(state.protection),
+            pageSetup: copyPageSetup(state.pageSetup),
+            objects: state.objects.map(copyObject),
+            sparklines: state.sparklines.map(copySparkline),
+            pivots: state.pivots.map(copyPivot),
+            links: copyLinks(state.links),
+            sheetHidden: state.sheetHidden,
+            kind: state.kind,
+            ...(state.grid ? { grid: copyGridSheet(state.grid) } : {}),
             merges: state.merges.map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]),
             validation: state.validation.map((rule) => ({ ...rule, rects: rule.rects.map((r) => [...r]), alert: { ...rule.alert } })),
             conditionalFormats: state.conditionalFormats.map((rule) => ({ ...rule, rects: rule.rects.map((r) => [...r]) })),
+            cellTypes: state.cellTypes.map(copyCellType),
             autoFilter: state.autoFilter ? { range: [...state.autoFilter.range], filters: { ...state.autoFilter.filters } } : null,
         };
     }
+    /**
+     * Put back only the parts an entry names, leaving the rest as they are.
+     * `hydrateEntry` below is the whole-sheet version, which resets what is
+     * absent to its default; this one is what a delta applies, since a delta
+     * carries the one feature that changed.
+     */
+    function patchEntry(state, entry) {
+        if (entry.formats !== undefined)
+            state.formats.hydrate(entry.formats);
+        if (entry.columnWidths !== undefined)
+            state.widths = { ...entry.columnWidths };
+        if (entry.rowHeights !== undefined)
+            state.heights = new Map(entry.rowHeights);
+        if (entry.hidden !== undefined)
+            state.hidden = { rows: new Set(entry.hidden.rows ?? []), cols: new Set(entry.hidden.cols ?? []) };
+        if (entry.outline !== undefined)
+            state.outline = { rows: copyOutline(entry.outline.rows), cols: copyOutline(entry.outline.cols) };
+        if (entry.freeze !== undefined)
+            state.freeze = { rows: entry.freeze.rows ?? 0, cols: entry.freeze.cols ?? 0 };
+        if (entry.comments !== undefined)
+            state.notes = Object.fromEntries(Object.entries(entry.comments).map(([r, line]) => [r, copyLine(line)]));
+        if (entry.protected !== undefined)
+            state.protected = entry.protected;
+        if (entry.protection !== undefined)
+            state.protection = copyProtection({ allow: entry.protection.allow ?? {}, ranges: entry.protection.ranges ?? [] });
+        if (entry.pageSetup !== undefined)
+            state.pageSetup = copyPageSetup({ ...defaultPageSetup(), ...entry.pageSetup });
+        if (entry.objects !== undefined)
+            state.objects = entry.objects.map(copyObject);
+        if (entry.sparklines !== undefined)
+            state.sparklines = entry.sparklines.map(copySparkline);
+        if (entry.pivots !== undefined)
+            state.pivots = entry.pivots.map(copyPivot);
+        if (entry.links !== undefined)
+            state.links = copyLinks(entry.links);
+        if (entry.sheetHidden !== undefined)
+            state.sheetHidden = entry.sheetHidden;
+        if (entry.kind !== undefined)
+            state.kind = entry.kind;
+        if (entry.grid !== undefined)
+            state.grid = copyGridSheet(entry.grid);
+        if (entry.merges !== undefined)
+            state.merges = entry.merges.map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]);
+        if (entry.validation !== undefined) {
+            state.validation = entry.validation.map((rule) => ({
+                ...rule,
+                rects: rule.rects.map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]),
+                alert: { ...rule.alert },
+            }));
+        }
+        if (entry.conditionalFormats !== undefined) {
+            state.conditionalFormats = entry.conditionalFormats.map((rule) => ({
+                ...rule,
+                rects: rule.rects.map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]),
+            }));
+        }
+        if (entry.cellTypes !== undefined)
+            state.cellTypes = entry.cellTypes.map(copyCellType);
+        if (entry.autoFilter !== undefined) {
+            const af = entry.autoFilter;
+            state.autoFilter = af ? { range: [af.range[0], af.range[1], af.range[2], af.range[3]], filters: { ...af.filters } } : null;
+            state.filterHidden = new Set();
+        }
+    }
     function hydrateEntry(state, entry) {
         state.formats.hydrate(entry.formats ?? {});
         state.widths = { ...(entry.columnWidths ?? {}) };
         state.heights = new Map(entry.rowHeights ?? []);
         state.hidden = { rows: new Set(entry.hidden?.rows ?? []), cols: new Set(entry.hidden?.cols ?? []) };
+        state.outline = { rows: copyOutline(entry.outline?.rows), cols: copyOutline(entry.outline?.cols) };
         state.freeze = { rows: entry.freeze?.rows ?? 0, cols: entry.freeze?.cols ?? 0 };
-        state.notes = Object.fromEntries(Object.entries(entry.comments ?? {}).map(([r, line]) => [r, { ...line }]));
+        state.notes = Object.fromEntries(Object.entries(entry.comments ?? {}).map(([r, line]) => [r, copyLine(line)]));
         state.protected = entry.protected ?? false;
+        state.protection = entry.protection ? copyProtection({ allow: entry.protection.allow ?? {}, ranges: entry.protection.ranges ?? [] }) : defaultProtection();
+        state.pageSetup = entry.pageSetup ? copyPageSetup({ ...defaultPageSetup(), ...entry.pageSetup }) : defaultPageSetup();
+        state.objects = (entry.objects ?? []).map(copyObject);
+        state.sparklines = (entry.sparklines ?? []).map(copySparkline);
+        state.pivots = (entry.pivots ?? []).map(copyPivot);
+        state.links = copyLinks(entry.links ?? {});
+        state.sheetHidden = entry.sheetHidden ?? false;
+        state.kind = entry.kind ?? 'cells';
+        state.grid = entry.grid ? copyGridSheet(entry.grid) : undefined;
         state.merges = (entry.merges ?? []).map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]);
         state.validation = (entry.validation ?? []).map((rule) => ({
             ...rule,
@@ -110,6 +262,7 @@ export function createSheetDocument(init = {}) {
             ...rule,
             rects: rule.rects.map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]),
         }));
+        state.cellTypes = (entry.cellTypes ?? []).map(copyCellType);
         const af = entry.autoFilter;
         state.autoFilter = af ? { range: [af.range[0], af.range[1], af.range[2], af.range[3]], filters: { ...af.filters } } : null;
         state.filterHidden = new Set();
@@ -117,6 +270,11 @@ export function createSheetDocument(init = {}) {
     const document = {
         workbook,
         get,
+        patch(name, entry) {
+            patchEntry(get(name), entry);
+            for (const reason of reasonsForEntry(entry))
+                changed(reason);
+        },
         has: (name) => entries.has(key(name)),
         rename(from, to) {
             const moved = entries.get(key(from));
@@ -127,6 +285,24 @@ export function createSheetDocument(init = {}) {
         remove(name) {
             entries.delete(key(name));
         },
+        duplicate(from, to) {
+            const made = workbook.copySheet(from, to);
+            if (made === null)
+                return null;
+            // Through the JSON shape, so nothing is shared between the two.
+            const copy = JSON.parse(JSON.stringify(serializeEntry(get(from))));
+            copy.sheetHidden = false;
+            // The copy's chart, picture, sparkline and pivot are its own, so they
+            // get their own ids the way Excel's Move or Copy does. Sharing them
+            // would mean a shell that tracks the selected object by id following
+            // the copy's one across a sheet switch, and deleting it there.
+            copy.objects = copy.objects?.map((object) => ({ ...object, id: objectId() }));
+            copy.sparklines = copy.sparklines?.map((group) => ({ ...group, id: sparklineId() }));
+            copy.pivots = copy.pivots?.map((pivot) => ({ ...pivot, id: pivotId() }));
+            hydrateEntry(get(made), copy);
+            changed({ kind: 'sheets' });
+            return made;
+        },
         names: () => [...entries.keys()],
         shift(name, edit) {
             const state = get(name);
@@ -175,12 +351,25 @@ export function createSheetDocument(init = {}) {
                         hiddenCols.add(next);
                 }
                 state.hidden = { rows: state.hidden.rows, cols: hiddenCols };
+                state.outline = { rows: state.outline.rows, cols: shiftOutline(state.outline.cols, edit.at, edit.count * (edit.kind === 'deleteCols' ? -1 : 1)) };
                 state.notes = remapNotes(state.notes, 'cols', shift);
             }
             state.merges = state.merges.map((m) => shiftRect(m, edit)).filter((m) => m !== null);
             state.validation = shiftValidation(state.validation, edit);
             state.conditionalFormats = shiftCf(state.conditionalFormats, edit);
+            state.cellTypes = shiftCellTypes(state.cellTypes, edit);
             state.autoFilter = shiftAutoFilter(state.autoFilter, edit);
+            state.pageSetup = shiftPageSetup(state.pageSetup, edit);
+            state.objects = shiftObjects(state.objects, edit);
+            state.sparklines = shiftSparklines(state.sparklines, edit);
+            state.pivots = shiftPivots(state.pivots, edit);
+            state.links = shiftLinks(state.links, edit);
+            state.protection = {
+                allow: state.protection.allow,
+                ranges: state.protection.ranges
+                    .map((range) => ({ ...range, rects: range.rects.map((r) => shiftRect(r, edit)).filter((r) => r !== null) }))
+                    .filter((range) => range.rects.length > 0),
+            };
         },
         getState() {
             const sheets = {};
@@ -220,6 +409,14 @@ export function createSheetDocument(init = {}) {
                     }
                 }
                 workbook.names.hydrate(state.workbook.names ?? {});
+                // Tables are workbook-wide, and the registry is what a structured
+                // reference resolves through: put back exactly the saved set.
+                workbook.tables.clear();
+                for (const table of state.workbook.tables ?? [])
+                    workbook.tables.define({ ...table });
+                // Iterative calculation is workbook-wide too, and absent in a saved
+                // document that never turned it on, which means off.
+                workbook.setIteration(state.workbook.iteration ?? { enabled: false });
                 if (workbook.sheets.some((s) => key(s) === key(state.workbook.active)))
                     workbook.setActive(state.workbook.active);
                 // Entries are hydrated in place, never replaced: a format store the
@@ -231,6 +428,8 @@ export function createSheetDocument(init = {}) {
                         entries.delete(name);
                 for (const name of workbook.sheets)
                     hydrateEntry(get(name), state.sheets?.[name] ?? {});
+                for (const name of workbook.sheets)
+                    releaseFilteredRows(document, name);
             });
             changed({ kind: 'restore' });
         },
@@ -258,6 +457,8 @@ export function createSheetDocument(init = {}) {
                 workbook.setActive(init.state.workbook.active);
             for (const [name, entry] of Object.entries(init.state.sheets ?? {}))
                 hydrateEntry(get(name), entry);
+            for (const name of workbook.sheets)
+                releaseFilteredRows(document, name);
         });
     }
     return document;

package/dist/sheet/engine.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The seam between the workbook and whatever works a formula out.
+ *
+ * The built-in engine (the tokenizer, parser and evaluator beside this
+ * file) is the one the sheet ships with and the one it is tested against.
+ * The seam is here for an application that has its own evaluator to put
+ * behind the same sheet: `createWorkbook(sheets, { engine: mine })`.
+ *
+ * What an engine is asked for is narrow on purpose: a formula's value in
+ * a cell, and the grid it spills when it has one. The workbook keeps
+ * everything else, because none of it is the engine's to decide. The
+ * dependency graph, the volatile set, the value cache, cycle detection
+ * and the spill ranges are all read off the reference grammar, which is
+ * Excel's whatever evaluates it, so they stay correct for any engine and
+ * an engine cannot get them wrong.
+ *
+ * `load` and `write` are the lifecycle an engine with a copy of the cells
+ * needs: `load` when the workbook is built and whenever its cells change
+ * wholesale (a structural edit, a sheet added or renamed, a restore),
+ * `write` on a single cell. An engine that reads through `host` on demand,
+ * as the built-in does, leaves both off.
+ */
+import type { CellValue, Node } from './ast.js';
+import type { EvalContext } from './evaluate.js';
+import type { SheetData } from './workbook.js';
+/** Where a formula sits. */
+export type SheetEngineCell = {
+    sheet: string;
+    row: number;
+    col: number;
+};
+export type SheetEngineHost = {
+    /**
+     * The context the built-in evaluator uses for this cell: `resolve` reads
+     * through the workbook's cache and cycle detection, so an engine that
+     * wants a precedent's value asks here rather than reading raw text.
+     */
+    context: EvalContext;
+    /** The workbook's parse cache: one parse per distinct formula text, null when it does not parse. */
+    parse(text: string): Node | null;
+};
+export type SheetEngineResult = {
+    value: CellValue;
+    /**
+     * The grid the formula spills, or null / absent for a plain value. The
+     * workbook lays it over the cells below and to the right, refuses it
+     * with `#SPILL!` where something is in the way, and moves it with an
+     * insert or delete.
+     */
+    spill?: CellValue[][] | null;
+};
+export type SheetEngine = {
+    /** For the docs and an error message; the built-in is `'builtin'`. */
+    name?: string;
+    /** Every sheet's raw text, at creation and after a wholesale change. */
+    load?(sheets: ReadonlyArray<SheetData>): void;
+    /** One cell's raw text changed. */
+    write?(sheet: string, row: number, col: number, text: string): void;
+    /** What the formula is worth here. `text` keeps its leading `=`. */
+    evaluate(text: string, at: SheetEngineCell, host: SheetEngineHost): SheetEngineResult;
+};
+/**
+ * The engine the sheet ships with: the parser and evaluator in this
+ * folder, which read the workbook's own cells through the host's context
+ * and so need no copy of anything.
+ */
+export declare function builtinEngine(): SheetEngine;

package/dist/sheet/engine.js

@@ -0,0 +1,19 @@
+import { evaluate, evaluateSpill } from './evaluate.js';
+/**
+ * The engine the sheet ships with: the parser and evaluator in this
+ * folder, which read the workbook's own cells through the host's context
+ * and so need no copy of anything.
+ */
+export function builtinEngine() {
+    return {
+        name: 'builtin',
+        evaluate(text, _at, host) {
+            const ast = host.parse(text);
+            if (!ast)
+                return { value: { error: '#PARSE!' } };
+            const value = evaluate(ast, host.context);
+            const spill = typeof value === 'object' && value !== null && 'error' in value ? null : evaluateSpill(ast, host.context);
+            return { value, spill };
+        },
+    };
+}