@dou-ui/sheet 0.0.0-stage → 0.1.0-alpha.1

package/dist/types/core/transaction.d.ts

@@ -0,0 +1,470 @@
+import { type SheetBounds, type SheetPoint, type SheetRange } from './address';
+import { type SheetCell, type SheetCellInput, type SheetConditionalFormat, type SheetData, type SheetFilter, type SheetFilterRule, type SheetProtection, type SheetRow, type SheetStyle, type SheetTypeSetup, type SheetValidation, type SheetValue, type SheetWorkbook } from './model';
+import { type SheetFillMode } from './fill';
+import { type SheetSortKey } from './data';
+type Patch<T> = {
+    [K in keyof T]?: T[K] | undefined;
+};
+/** The parts of a sheet set with `updateSheet`. */
+export type SheetPatch = Patch<Omit<SheetData, 'cells' | 'rowSizes' | 'colSizes'>>;
+/** Changes to the workbook's own settings: those besides its sheets, styles and types. */
+export type SheetBookPatch = Patch<Omit<SheetWorkbook, 'sheets' | 'styles' | 'types'>>;
+/** Changes to a style: fields to set, and fields set to `undefined` to take off. */
+export type SheetStylePatch = Patch<SheetStyle>;
+/** A sheet: its index in the workbook, or its `id` or `name`. */
+export type SheetRef = number | string;
+/**
+ * A cell: `'B3'`, `'表 2'!B3` for another sheet, or a point with an
+ * optional `sheet`. Without a sheet it is on the transaction's sheet.
+ */
+export type SheetCellAt = string | (SheetPoint & {
+    sheet?: SheetRef;
+});
+/**
+ * A range, written like a cell: `'A1:C4'`, `'表 2'!B:B`, or a range or its
+ * bounds with an optional `sheet`.
+ */
+export type SheetRangeAt = string | ((SheetRange | SheetBounds) & {
+    sheet?: SheetRef;
+});
+/** Rows or columns. */
+export type SheetAxisName = 'row' | 'col';
+/**
+ * Rows or columns: a zero-based number, or as people write them, `'5'` or
+ * `'5:7'` for rows and `'C'` or `'B:C'` for columns.
+ */
+export type SheetLinesAt = number | string | {
+    from: number;
+    count: number;
+};
+/** What made a change, as the `change` and `transaction` events tell it. */
+export type SheetAction = 'input' | 'paste' | 'cut' | 'fill' | 'clear' | 'resize' | 'move' | 'insert' | 'delete' | 'hide' | 'merge' | 'group' | 'note' | 'comment' | 'sort' | 'filter' | 'format' | 'validation' | 'protect' | 'link' | 'style' | 'freeze' | 'sheet' | 'import' | 'restore' | 'replace' | 'undo' | 'redo' | 'api';
+/** What a step calls a sheet: its `id`, or its name when it has none. */
+export declare const sheetKey: (sheet: SheetData) => string;
+export type SheetStep = 
+/** Writes a cell; `cell` left out empties it. */
+{
+    type: 'setCell';
+    sheet: string;
+    row: number;
+    col: number;
+    cell?: SheetCellInput;
+}
+/** Sets a row's height or a column's width; `size` left out goes back to the default. */
+ | {
+    type: 'setSize';
+    sheet: string;
+    axis: 'row' | 'col';
+    index: number;
+    size?: number;
+} | {
+    type: 'updateSheet';
+    sheet: string;
+    patch: SheetPatch;
+}
+/** Changes the workbook's own settings, such as `protect`. */
+ | {
+    type: 'updateBook';
+    patch: SheetBookPatch;
+}
+/** Adds, replaces or (with `style` left out) removes a named style. */
+ | {
+    type: 'setStyle';
+    name: string;
+    style?: SheetStyle;
+}
+/** Adds, replaces or (with `setup` left out) removes a named cell type. */
+ | {
+    type: 'setType';
+    name: string;
+    setup?: SheetTypeSetup;
+}
+/**
+ * Adds `count` rows (or columns) before `index`, moving the rest down (or
+ * right). They are empty unless `cells` and `sizes` fill them: for rows,
+ * `cells` holds the rows; for columns, each row's cells in them.
+ */
+ | {
+    type: 'insertLines';
+    sheet: string;
+    axis: SheetAxisName;
+    index: number;
+    count: number;
+    cells?: (SheetRow | null)[];
+    sizes?: (number | null)[];
+}
+/** Removes `count` rows (or columns) from `index`, moving the rest up (or left). */
+ | {
+    type: 'removeLines';
+    sheet: string;
+    axis: SheetAxisName;
+    index: number;
+    count: number;
+}
+/**
+ * Moves `count` rows (or columns) from `from` to before `to`, both
+ * numbered as before the move.
+ */
+ | {
+    type: 'moveLines';
+    sheet: string;
+    axis: SheetAxisName;
+    from: number;
+    count: number;
+    to: number;
+}
+/** Adds a sheet at `index`, moving the ones from there on along. */
+ | {
+    type: 'insertSheet';
+    index: number;
+    data: SheetData;
+} | {
+    type: 'removeSheet';
+    sheet: string;
+}
+/** Moves a sheet to `index`, counted after it is taken out. */
+ | {
+    type: 'moveSheet';
+    sheet: string;
+    index: number;
+};
+export interface SheetTransactionMeta {
+    /** Keep out of the undo history, e.g. a change from another client. */
+    history?: boolean;
+    /** Consecutive transactions in the same group within a second undo as one. */
+    group?: string;
+    /** Who made the change, passed on to the `transaction` event. */
+    origin?: string;
+    /** What the change was; the grid sets it, a change made in code is `api`. */
+    action?: SheetAction;
+    /**
+     * With `false`, the grid doesn't hold the change to the protection of
+     * sheets and the workbook, e.g. for code that fills in a protected form.
+     * A change with `history: false`, such as undo, redo or another person's,
+     * isn't held either: it can't be cancelled.
+     */
+    protection?: boolean;
+}
+/**
+ * A batch of changes. Steps apply as they are added, so later calls see
+ * earlier ones; `doc` is the result. Cells and ranges without a sheet are
+ * on `sheet` (in the grid, the one shown).
+ */
+export declare class SheetTransaction {
+    readonly before: SheetWorkbook;
+    /** The sheet cells and ranges are on when they don't name one. */
+    readonly sheet: SheetRef;
+    readonly steps: SheetStep[];
+    /** What undoes each step, in the order the steps were made. */
+    private undoing;
+    private reversed;
+    /** The steps that undo this transaction, in the order to apply them. */
+    get inverse(): readonly SheetStep[];
+    meta: SheetTransactionMeta;
+    private book;
+    /** What this transaction has copied, so it copies each thing once. */
+    private own;
+    /** The sheets this transaction copied, and the rows it copied of each. */
+    private ownSheets;
+    private ownRows;
+    constructor(before: SheetWorkbook, 
+    /** The sheet cells and ranges are on when they don't name one. */
+    sheet?: SheetRef);
+    get doc(): SheetWorkbook;
+    /** Whether the change makes any change: it has steps and wasn't cancelled. */
+    get changed(): boolean;
+    private stopped;
+    /**
+     * Stops the change: none of it is applied or kept for undo, and the
+     * editor fires `transactionCancel` and says why. For an extension's `transaction`
+     * hook, e.g. to keep people from changing what they may not; hooks after
+     * it don't run. A change kept out of the history (`meta.history: false`),
+     * such as undo, redo or another person's, can't be cancelled and goes ahead.
+     */
+    cancel(reason?: string): this;
+    /** Whether `cancel` stopped it. */
+    get cancelled(): boolean;
+    /** What `cancel` was given, to tell people why. */
+    get cancelReason(): string | undefined;
+    setMeta(meta: SheetTransactionMeta): this;
+    /** The index of a sheet, by index, `id` or name; `-1` when there is none. */
+    indexOf(ref?: SheetRef): number;
+    /** A sheet as it is now in this transaction. */
+    getSheet(ref?: SheetRef): SheetData;
+    getCell(at: SheetCellAt): SheetCellInput;
+    step(step: SheetStep): this;
+    /** Replaces a cell; `undefined` empties it. */
+    setCell(at: SheetCellAt, cell: SheetCellInput): this;
+    /** Changes some of a cell's fields and keeps the rest. */
+    updateCell(at: SheetCellAt, patch: Patch<SheetCell>): this;
+    /** Writes a cell's value and keeps its style and format. */
+    setValue(at: SheetCellAt, value: SheetValue | undefined): this;
+    /** Empties the values in a range, keeping styles and formats. */
+    clearValues(at: SheetRangeAt): this;
+    /** Writes a cell's note; empty text or `undefined` takes it off. */
+    setNote(at: SheetCellAt, note: string | undefined): this;
+    /**
+     * Puts a comment thread on a cell, or takes it off with `undefined`. Use
+     * it with `{ history: false }`: a thread stays when the change before it
+     * is undone.
+     */
+    setComment(at: SheetCellAt, id: string | undefined): this;
+    /** Takes the notes off the cells in a range, keeping what they hold. */
+    clearNotes(at: SheetRangeAt): this;
+    /** Sets a row's height or a column's width in px; `undefined` for the default, `0` hides it. */
+    setSize(axis: 'row' | 'col', index: number, size: number | undefined, sheet?: SheetRef): this;
+    /** Changes a sheet's name, freeze, row or column count. */
+    updateSheet(patch: SheetPatch, sheet?: SheetRef): this;
+    /** Changes the workbook's own settings, such as `protect`. */
+    updateBook(patch: SheetBookPatch): this;
+    /**
+     * Protects a sheet, or with `false` stops protecting it: its locked cells
+     * (all but those whose style has `locked: false`) can't be changed, nor
+     * can the sheet's rows, columns and rules, except what `options` allows.
+     */
+    protectSheet(protect: boolean | SheetProtection, sheet?: SheetRef): this;
+    setStyle(name: string, style: SheetStyle | undefined): this;
+    /** Adds, replaces or (with `undefined`) removes a named cell type, such as a list to pick from. */
+    setType(name: string, setup: SheetTypeSetup | undefined): this;
+    /**
+     * Writes a block of cells with its top left corner at `at`, row by row.
+     * `undefined` in the block empties a cell; a shorter row leaves the cells
+     * past it as they are.
+     */
+    setCells(at: SheetCellAt, block: readonly (readonly SheetCellInput[])[]): this;
+    /**
+     * Fills `to` from `from`, the cells it extends down, up, right or left:
+     * each line of cells continues as the fill handle does (see
+     * `continueValues`), with the styles and formats of the cells it repeats.
+     * Formulas are copied with their references moved along. `mode` is
+     * `auto` as dragging does, `series` to count a single number up too, or
+     * `copy` to only repeat, as Ctrl+D does. With `keepStyle`, the filled
+     * cells keep their own styles and formats, as on a protected sheet.
+     */
+    fill(from: SheetRangeAt, to: SheetRangeAt, options?: {
+        mode?: SheetFillMode;
+        keepStyle?: boolean;
+    }): this;
+    /**
+     * Sorts the rows of a range by the values in `keys`' columns; the cells
+     * outside the range stay. `header` keeps the first row in place. Equal rows
+     * keep their order, and empty values go last either way. Formulas move
+     * with their rows and their references move along, as when copied.
+     * `valueAt` gives what a cell comes to, e.g. a formula's result; the value
+     * as written is used without it. Ranges with merged cells are not sorted.
+     */
+    sortRange(at: SheetRangeAt, keys: readonly SheetSortKey[], options?: {
+        header?: boolean;
+        valueAt?: (row: number, col: number) => unknown;
+        lang?: string;
+    }): this;
+    /**
+     * Puts a filter on a range, headings in its first row; `null` takes the
+     * filter off, showing the rows it hid. A new range drops the old rules.
+     */
+    setFilter(at: SheetRangeAt | null): this;
+    /**
+     * Sets which rows a column of the filter keeps; `undefined` keeps all.
+     * `sorted` marks the column the rows were sorted by, for its button.
+     */
+    filterColumn(col: number, rule: SheetFilterRule | undefined, sheet?: SheetRef): this;
+    /** Remembers the filter column the rows were sorted by, or forgets it with `undefined`. */
+    markSorted(sorted: SheetFilter['sorted'], sheet?: SheetRef): this;
+    /**
+     * Adds a conditional format after the sheet's others; where two give the
+     * same part of a cell's look, the earlier one wins. The format's `range`
+     * names cells of `sheet`.
+     */
+    addConditionalFormat(format: SheetConditionalFormat, sheet?: SheetRef): this;
+    /** Sets a sheet's conditional formats, in order, e.g. after moving one up; `[]` removes them all. */
+    setConditionalFormats(formats: readonly SheetConditionalFormat[], sheet?: SheetRef): this;
+    /**
+     * Removes the conditional formats whose cells overlap a range, such as
+     * the selection; without a range, all of the sheet's.
+     */
+    clearConditionalFormats(at?: SheetRangeAt): this;
+    /**
+     * Adds a validation rule after the sheet's others; where two cover a
+     * cell, the earlier one applies. The rule's `range` names cells of `sheet`.
+     */
+    addValidation(rule: SheetValidation, sheet?: SheetRef): this;
+    /** Sets a sheet's validation rules, in order; `[]` removes them all. */
+    setValidations(rules: readonly SheetValidation[], sheet?: SheetRef): this;
+    /**
+     * Removes the validation rules whose cells overlap a range, such as the
+     * selection; without a range, all of the sheet's.
+     */
+    clearValidations(at?: SheetRangeAt): this;
+    private addRule;
+    private setRules;
+    private clearRules;
+    /**
+     * Groups rows so they can be folded away: `groupRows('3:8')` or
+     * `groupRows(2, 6)`. A group may hold other groups, at most eight deep;
+     * one beside a group of the same level joins it, and one that would cross
+     * a group, or nest too deep, throws a `RangeError`.
+     */
+    groupRows(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /** Groups columns so they can be folded away: `groupCols('B:D')`. */
+    groupCols(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /**
+     * Takes rows out of their groups: the groups that lie within them go (the
+     * outer ones, when groups nest); without any, the rows leave the innermost
+     * group they are in, which may split it in two.
+     */
+    ungroupRows(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /** Takes columns out of their groups, as `ungroupRows` does rows. */
+    ungroupCols(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /** Folds a group away: `collapseGroup('3:8')`, `range` being the group's rows or columns. */
+    collapseGroup(range: string, sheet?: SheetRef): this;
+    /** Shows a folded group again: `expandGroup('3:8')`. */
+    expandGroup(range: string, sheet?: SheetRef): this;
+    private foldGroup;
+    /**
+     * Shows the groups of an axis down to a level, as the outline's level
+     * buttons do: level 1 folds every group, level 2 shows the outer groups
+     * with theirs folded, and one past the deepest shows them all.
+     */
+    showGroupLevel(axis: SheetAxisName, level: number, sheet?: SheetRef): this;
+    private groupLines;
+    private ungroupLines;
+    /** Rewrites a sheet's groups: each to itself, another, several or none. */
+    private setGroups;
+    /**
+     * Adds empty rows before `at`: `insertRows(4, 2)` or `insertRows('5:6')`
+     * both add two rows where row 5 was. Frozen rows and the row count grow
+     * with them, and formulas pointing below follow their cells.
+     */
+    insertRows(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /** Adds empty columns before `at`, `insertCols('C')` or `insertCols(2)`. */
+    insertCols(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /**
+     * Removes rows with their cells and heights: `deleteRows('5:7')` or
+     * `deleteRows(4, 3)`. Formulas pointing at them read `#REF!`.
+     */
+    deleteRows(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /** Removes columns with their cells and widths: `deleteCols('B:C')`. */
+    deleteCols(at: SheetLinesAt, count?: number, sheet?: SheetRef): this;
+    /**
+     * Moves rows to before row `to`, numbered as before the move:
+     * `moveRows('2:3', '6')` puts rows 2 and 3 above what was row 6.
+     * Formulas pointing at them follow.
+     */
+    moveRows(lines: SheetLinesAt, to: number | string, sheet?: SheetRef): this;
+    /** Moves columns to before column `to`: `moveCols('C', 'A')`. */
+    moveCols(lines: SheetLinesAt, to: number | string, sheet?: SheetRef): this;
+    /**
+     * Moves a block of cells so its top left corner is at `to`, as cutting
+     * and pasting does: the cells at `from` empty, those at `to` are
+     * replaced, and formulas pointing at the block follow it.
+     */
+    moveCells(from: SheetRangeAt, to: SheetCellAt): this;
+    private insertLines;
+    private deleteLines;
+    private moveLines;
+    /**
+     * After rows or columns of a sheet change: rewrites formulas pointing at
+     * it, and moves its merged cells, dropping those that are gone or now
+     * one cell.
+     */
+    private moveRanges;
+    /** Moves a sheet's rules with their cells; a rule goes when its cells do. */
+    private moveRules;
+    /** Moves a sheet's groups with their lines; a group goes when its lines do. */
+    private moveGroups;
+    /** Moves a sheet's filter with its rows and columns; it goes when its range does. */
+    private moveFilter;
+    /**
+     * Merges a range into one cell. Merges it touches are taken into it. The
+     * top left cell keeps its content; the values of the other cells are
+     * cleared, keeping their styles, unless `keep` leaves them hidden under the
+     * merge, to show again when it is split.
+     */
+    mergeCells(at: SheetRangeAt, options?: {
+        keep?: boolean;
+    }): this;
+    /** Splits the merged cells a range touches back into single cells. */
+    unmergeCells(at: SheetRangeAt): this;
+    /**
+     * Changes how the cells in a range look: each cell's style with `patch`
+     * laid over it, where a field set to `undefined` (or `false`, but for
+     * `locked`) is taken off; `null` takes the whole style off. Cells that end up looking the
+     * same share one style: one in `styles` that matches, or a new one named
+     * `s1`, `s2`…. Whole columns and rows stop at the sheet's edge.
+     */
+    styleCells(at: SheetRangeAt, patch: SheetStylePatch | null): this;
+    /**
+     * Sets the number or date format of the cells in a range (`undefined`
+     * for none), or changes each with a function of its format and value,
+     * such as `(format, value) => changeDecimals(format, value, 1)`.
+     */
+    formatCells(at: SheetRangeAt, format: string | undefined | ((format: string | undefined, value: SheetValue) => string | undefined)): this;
+    /** The name of a style that looks like `name`'s with `patch` laid over it. */
+    private styleFor;
+    /**
+     * Adds a sheet, at the end or at `index`. Its name must not be taken
+     * (`uniqueName` gives one that isn't); it is `Sheet1`, `Sheet2`… when
+     * left out, whatever the language. Returns the transaction; the new sheet
+     * is `tr.getSheet(name)`.
+     */
+    addSheet(sheet?: Partial<SheetData>, index?: number): this;
+    /**
+     * Removes a sheet. The last one stays: a workbook always has a sheet.
+     * Formulas on other sheets pointing at it read `#REF!`.
+     */
+    removeSheet(sheet?: SheetRef): this;
+    /** Moves a sheet to `index`, counted among the sheets without it. */
+    moveSheet(sheet: SheetRef, index: number): this;
+    /** Renames a sheet; formulas naming it follow. The name must not be taken. */
+    renameSheet(sheet: SheetRef, name: string): this;
+    /**
+     * Adds a copy of a sheet right after it, named `name` or the sheet's name
+     * with a number, such as `数据 (2)`. Formulas on the copy that name the
+     * sheet keep pointing at the original.
+     */
+    duplicateSheet(sheet?: SheetRef, name?: string): this;
+    /**
+     * `name` if no sheet has it, otherwise the name with the first free
+     * number: `门店 (2)`, `门店 (3)`…
+     */
+    uniqueName(name: string): string;
+    /** Passes every formula of the workbook through `rewrite`. */
+    private rewriteFormulas;
+    /**
+     * Rewrites the formulas of every sheet's rules: conditional formats' and
+     * validations' formulas, and the references of validation lists.
+     */
+    private rewriteRuleFormulas;
+    /** The first name `prefix` + a number, from the count of sheets on, that no sheet has. */
+    private freeName;
+    private checkName;
+    /** Rewrites the references to cells on sheet `name` in every formula of the workbook. */
+    private rewriteReferences;
+    private mustIndex;
+    private keyOf;
+    private cellAt;
+    private rangeAt;
+    /** A range kept inside its sheet, so whole columns and rows end at its edge. */
+    private rangeIn;
+    /** Applies a step, returning the step that undoes it, or `null` when nothing changes. */
+    private apply;
+    private insertAt;
+    private removeAt;
+    private moveAt;
+    private ownBook;
+    /** The list of sheets as an array this transaction may change. */
+    private ownList;
+    private ownSheet;
+    /** The row as an array this transaction may change. */
+    private row;
+}
+/** Where line `i` ends up when `count` lines from `from` move to before `to`. */
+export declare function movedIndex(from: number, count: number, to: number): (i: number) => number;
+/** Applies steps to a workbook, as one transaction. */
+export declare function applySheetSteps(doc: SheetWorkbook, steps: readonly SheetStep[]): SheetTransaction;
+/**
+ * The same changes in fewer steps: of several steps writing the same cell,
+ * size or style, keeps only the last, which is the one that counts.
+ */
+export declare function compactSheetSteps(steps: readonly SheetStep[]): SheetStep[];
+export {};

package/dist/types/core/validation.d.ts

@@ -0,0 +1,55 @@
+import type { SheetSelectOption, SheetValidation, SheetValue } from './model';
+import { type SheetMessages } from '../locale';
+/** Where the rules read cells and work out formulas, for the sheet they belong to. */
+export interface SheetCheckSource {
+    /** What a cell holds, its formula's result for a formula. */
+    valueAt: (row: number, col: number) => unknown;
+    /** How a cell shows. */
+    textAt: (row: number, col: number) => string;
+    /** Works out a formula on the sheet. */
+    evaluate: (formula: string) => unknown;
+    /** The values of the cells a list refers to, such as `'=$H$2:$H$9'`. */
+    listAt: (reference: string) => SheetValue[];
+    size: {
+        rows: number;
+        cols: number;
+    };
+    lang?: string;
+}
+/** Whether a rule reads other cells, so a cell's mark can change when they do. */
+export declare const readsOthers: (rule: SheetValidation) => boolean;
+/**
+ * The validation rules of a sheet. Make a new one when the workbook
+ * changes; it reads a list's cells once.
+ */
+export declare class SheetChecks {
+    private source;
+    private rules;
+    private collator;
+    constructor(validations: readonly SheetValidation[] | undefined, source: SheetCheckSource);
+    /** Whether there are any rules. */
+    get empty(): boolean;
+    /** Whether a rule covering the row reads other cells. */
+    readsOthersIn(row: number): boolean;
+    private entryAt;
+    /** The rule a cell must keep, or `undefined`. */
+    ruleAt(row: number, col: number): SheetValidation | undefined;
+    /** The options of the list rule a cell must keep, or `undefined` when it has none. */
+    optionsAt(row: number, col: number): SheetSelectOption[] | undefined;
+    private optionsOf;
+    /**
+     * Whether a value fits the rule of the cell at `row`, `col`; `text` is how
+     * it shows. Without a rule, anything fits.
+     */
+    fits(row: number, col: number, value: unknown, text: string): boolean;
+    /** The rule a cell breaks as it is now, or `undefined`. */
+    brokenAt(row: number, col: number): SheetValidation | undefined;
+    /** Every cell that breaks its rule, rule by rule. */
+    broken(): Generator<{
+        row: number;
+        col: number;
+        rule: SheetValidation;
+    }>;
+}
+/** A rule in words: its `message`, or what it asks for. */
+export declare function ruleMessage(rule: SheetValidation, messages: SheetMessages): string;

package/dist/types/core/versions.d.ts

@@ -0,0 +1,38 @@
+import { type SheetCellInput, type SheetWorkbook } from './model';
+import { type SheetTransaction } from './transaction';
+/** A cell that differs between two versions. */
+export interface SheetCellChange {
+    /** The sheet's key: its `id`, or its name. */
+    sheet: string;
+    row: number;
+    col: number;
+    /** The cell as people write it, e.g. `B3`. */
+    address: string;
+    before: SheetCellInput;
+    after: SheetCellInput;
+}
+export interface WorkbookDiff {
+    /** The cells that differ on the sheets in both versions, sheet by sheet, row by row. */
+    cells: SheetCellChange[];
+    /** The keys of the sheets only the newer version has. */
+    addedSheets: string[];
+    /** The keys of the sheets only the older version has. */
+    removedSheets: string[];
+    /** The keys of the sheets whose other settings (name, sizes, merges, rules, protection…) differ. */
+    changedSheets: string[];
+    /** The named styles (in `styles`) that differ, such as one now unlocking its cells. */
+    changedStyles: string[];
+    /** The named cell types (in `types`) that differ. */
+    changedTypes: string[];
+    /** Whether the workbook's own settings, such as `protect`, differ. */
+    bookChanged: boolean;
+}
+/** What changed from `before` to `after`. */
+export declare function diffWorkbooks(before: SheetWorkbook, after: SheetWorkbook): WorkbookDiff;
+/**
+ * Adds the steps that bring the workbook to `book`, writing only what
+ * differs: cells, sizes and settings of the sheets in both (protection
+ * too), sheets added and removed, their order, the workbook's settings,
+ * and the named styles and types.
+ */
+export declare function restoreWorkbook(tr: SheetTransaction, book: SheetWorkbook): SheetTransaction;

package/dist/types/export/color.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A computed color as `#rrggbb` or `rgba(…)`, which every SVG reader
+ * understands. A canvas converts most colors as it parses them; colors
+ * it keeps in another space (`oklab(…)`, `color(…)`) are painted on a
+ * pixel and read back.
+ */
+export declare function plainColor(color: string): string;

package/dist/types/export/draw.d.ts

@@ -0,0 +1,98 @@
+import type { Component } from 'vue';
+import type { SheetDrawContext, SheetDrawRect } from '../core/cell-type';
+/** The look of a cell's content, in plain colors. */
+export interface DrawLook {
+    color: string;
+    /** The fill, `null` for none. */
+    background: string | null;
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    align: 'left' | 'center' | 'right';
+    valign: 'top' | 'middle' | 'bottom';
+    wrap: boolean;
+    /** The cell's own grid line, where it isn't the sheet's, as on a fill. */
+    line: string | null;
+}
+/** A cell to draw, at its place among the lines drawn. */
+export interface DrawCell {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    look: DrawLook;
+    /** A conditional format's bar, as parts of the cell's width. */
+    bar?: {
+        from: number;
+        to: number;
+        color: string;
+    };
+    /** A checkbox cell's box. */
+    check?: boolean;
+    /** A merged cell, which hides the grid lines inside it. */
+    merged?: boolean;
+    /** A select cell's value as a soft tag. */
+    tag?: {
+        background: string;
+        color: string;
+        border: string;
+    };
+    /** A cell type's own drawing, as SVG markup in the cell's own coordinates. */
+    draw?: (draw: SheetDrawContext) => string;
+}
+/** The colors and font of the sheet, read from the page. */
+export interface DrawTheme {
+    fontFamily: string;
+    fontSize: number;
+    boldWeight: string;
+    surface: string;
+    line: string;
+    freezeLine: string;
+    headerBg: string;
+    headerText: string;
+    headerLine: string;
+    checkBorder: string;
+    checkBg: string;
+    checkOn: string;
+    checkOnBg: string;
+}
+export interface SheetDrawing {
+    /** The widths of the columns drawn, left to right. */
+    colWidths: number[];
+    /** The heights of the rows drawn, top to bottom. */
+    rowHeights: number[];
+    /** The column letters and row numbers, when the headers are drawn. */
+    colNames?: string[];
+    rowNames?: string[];
+    headerWidth: number;
+    headerHeight: number;
+    /** How many of the rows and columns drawn are frozen, with a firmer line after them. */
+    frozenRows: number;
+    frozenCols: number;
+    cells: DrawCell[];
+    gridlines: boolean;
+    background: boolean;
+    theme: DrawTheme;
+    /** Icons as SVG, for cell types' drawings; none without it. */
+    icon?: (icon: Component, box: SheetDrawRect, color: string) => string;
+    /** CSS colors as SVG takes them, for cell types' drawings; as they are without it. */
+    color?: (value: string) => string;
+}
+/** Measures text in a font, in px. */
+export type MeasureText = (text: string, font: string) => number;
+export declare const escapeXML: (text: string) => string;
+/**
+ * Breaks text into lines no wider than `width`: at spaces where it can,
+ * between any two characters of CJK text, and inside a word too long
+ * for a line.
+ */
+export declare function wrapLines(text: string, width: number, measure: (text: string) => number): string[];
+/** The sheet as an SVG document. */
+/** The size of the image a drawing makes, in CSS px. */
+export declare function drawingSize(drawing: SheetDrawing): {
+    width: number;
+    height: number;
+};
+export declare function drawSheet(drawing: SheetDrawing, measure: MeasureText): string;