@sheetxl/sdk 0.8.0-beta.5 → 0.8.0-beta.6

package/types/src/sheet/Sheet.d.ts

@@ -22,6 +22,7 @@ import { INamedCollection } from '../named';
 import { IModuleCollection } from '../scripting';
 import { ModuleCollection } from '../scripting/ModuleCollection';
 import { IMovable, IMovableCollection } from '../movable';
+import { Movable } from '../movable/Movable';
 import { IChartCollection } from '../chart';
 import { IPicture } from '../picture';
 import { Chart } from '../chart/Chart';
@@ -40,6 +41,8 @@ import { IDataValidationCollection, IDataValidation } from '../dataValidation';
 import { DataValidation } from '../dataValidation/DataValidation';
 import { ProtectedRange } from '../protectedRange/ProtectedRange';
 import { Comment } from '../comment/Comment';
+import { NoteMovable } from '../comment/NoteMovable';
+import { NoteLayout } from '../comment/_NoteBox';
 import { ISheetProtection } from '../sheetProtection';
 import { ISheetHeader } from '../sheetHeader';
 import { ISheetView } from '../sheetView';
@@ -51,7 +54,7 @@ import { EventCategory, SheetEvents } from './_SheetEvents';
 import { SheetHeader } from '../sheetHeader/SheetHeader';
 import { SheetDirectStyle } from './style/SheetDirectStyle';
 import { IUsedRangeSpatialMap } from './style/UsedRangeSpatialMap';
-import { RangeState, CellState, State, MovableEntry, InternalTupleUpdate } from './_SheetStateTypes';
+import { RangeState, CellState, State, MovableEntry, MovableIndex, InternalTupleUpdate } from './_SheetStateTypes';
 import { CellBuffer } from './_CellBuffer';
 import { SheetReadContext, GetTypedRangeOptions, OverFlowsAndStops } from './_SheetStateReader';
 import { AutoFillProjection, AutoFillPreviewCache } from './_SheetAutoFillUtils';
@@ -247,6 +250,15 @@ export declare class Sheet implements ISheet {
     protected _rowHeadersRemoveListener: IListener.Remove | null;
     protected _rowHeadersHiddenRemoveListener: IListener.Remove | null;
     protected _isAdjustHeaders: boolean;
+    /** Built by the movables moved in the shift under way, and taken by it when it writes. */
+    protected _shiftedMovableModels: Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+    /** The same for the note boxes, which shift as their own index. */
+    protected _shiftedNoteModels: Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+    /** The placed movables' index and the note boxes' index, as the entry builder addresses them. */
+    protected _placedIndex: MovableIndex;
+    protected _noteIndex: MovableIndex;
+    /** What every comment on this sheet places its note's box through. */
+    protected _noteBoxes: Comment.Boxes;
     protected _emptyCell: ICell;
     protected _cellOptions: SheetCellOptions;
     protected _closed: boolean;
@@ -319,6 +331,7 @@ export declare class Sheet implements ISheet {
         filter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions) => Promise<IRange.Coords>;
         evalFilter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined) => Promise<_SheetFilterUtils.FilterRuns>;
         applyFilterRuns: (runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions) => void;
+        filteredTables: () => ITable[];
         setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
         setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
         getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
@@ -381,6 +394,10 @@ export declare class Sheet implements ISheet {
         protectionCheck: (check?: ProtectionCheck | null, coords?: Readonly<IRange.Coords> | readonly IRange.Coords[] | null, action?: string | null) => void;
         getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
         processLayoutChange: () => void;
+        /** The movables' by-model index as a shift left it, or `null` if the shift moved none. */
+        takeShiftedMovableModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+        /** The same for the note boxes' index. */
+        takeShiftedNoteModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
         markColumnHeaderTableNames: () => void;
         commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
         readonly styles: IStyleCollection;
@@ -422,7 +439,7 @@ export declare class Sheet implements ISheet {
         cellStateIterator: (options?: CellState.IteratorOptions) => CellState.Iterator;
         rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
         getCell: (address?: ICell.Address) => ICell;
-        createCell: (update: ICell.Update, coords?: IRange.CellCoords | null) => ICell;
+        createCell: (update: ICell.Update, coords?: IRange.CellCoords | null, options?: ICell.CreateCellOptions) => ICell;
         getAutoFillPreviewCache: () => AutoFillPreviewCache | null;
         setAutoFillPreviewCache: (cache: AutoFillPreviewCache) => void;
     };
@@ -492,6 +509,7 @@ export declare class Sheet implements ISheet {
             filter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions) => Promise<IRange.Coords>;
             evalFilter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined) => Promise<_SheetFilterUtils.FilterRuns>;
             applyFilterRuns: (runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions) => void;
+            filteredTables: () => ITable[];
             setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
             setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
             getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
@@ -760,6 +778,18 @@ export declare class Sheet implements ISheet {
     addAutoTable(address?: ICellRange.Address, options?: ICellRange.AddAutoTableOptions): ITable;
     /** {@inheritDoc ISheet.getAutoTable} */
     getAutoTable(): ITable | null;
+    /**
+     * The tables on this sheet that hold a filter condition: the AutoTable, then the tables. What
+     * makes the sheet "filtered" ({@link ISheetHeader.getFilteredRanges}).
+     */
+    private _filteredTables;
+    /**
+     * Tells the grid whether this sheet is filtered now ({@link _filteredTables}), from
+     * inside the operation that may have changed it: a table's condition set or cleared, a table
+     * added or deleted. The grid writes only a different answer, so telling it more often than it
+     * changes costs a walk of the tables. A restore is not told, as {@link _tellHidden}.
+     */
+    protected _tellFiltered(): void;
     /** @internal */
     protected _getDefaultShiftAxis(coords?: IRange.Coords): IRange.Axis;
     /** @internal */
@@ -876,6 +906,13 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _registerWatch(coords: IRange.Coords, expression: string, authoredAt: IRange.CellCoords, handlers: WatchAnchor.Handlers, arrayFirstCell: boolean): IListener.Remove;
+    /**
+     * A watch's body is a grid the engine holds once, for every snapshot, so a watch is made and
+     * removed against the commit the store is at. Inside an amend of any other commit its node and
+     * its grid's maps would land in that snapshot alone: the engine would hold a grid the current
+     * snapshot has no record of, and removing it later would leave the engine its body.
+     */
+    protected _ensureWatchAtCurrent(action: 'added' | 'removed'): void;
     /**
      * Hold formulas that belong to no cell - a chart's series - in the calculation engine.
      *
@@ -913,22 +950,6 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _moveReferences(from: IRange.Coords, to: IRange.Coords): void;
-    /**
-     * Carries the tables a same-sheet cut moved to where the cut put them, as the same instances.
-     *
-     * @remarks
-     * A table moved this way is never deleted, so a handle to it, its name and the structured
-     * references to it all stay as they were, and one undo puts it back. Called after
-     * {@link _moveReferences}: the node a table watches its header through travels with the cut
-     * there, and the table re-registers what did not travel (the ring outside it) from where it now
-     * is. Each table is re-anchored by itself, so a table the cut does not carry is never split.
-     *
-     * @param tables The tables the cut encloses and moves.
-     * @param from The cut's source.
-     * @param to Where the cut's source lands.
-     * @internal
-     */
-    protected _moveTables(tables: readonly ITable[], from: IRange.Coords, to: IRange.Coords): void;
     /**
      * Drop a node from the current snapshot.
      *
@@ -990,6 +1011,8 @@ export declare class Sheet implements ISheet {
      */
     protected _notifyConditionalFormatsChange(): void;
     /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyTablesChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
     protected _notifyDataValidationsChange(): void;
     /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
     protected _notifyProtectedRangesChange(): void;
@@ -1390,8 +1413,26 @@ export declare class Sheet implements ISheet {
     getTransactions(): ITransaction.IStore;
     /** {@inheritDoc ISheet.getStrings} */
     getStrings(): IStringCollection;
-    /** @internal */
+    /**
+     * The sheet's movables: those placed on it, then the boxes of its notes.
+     * @internal
+     */
     protected _searchMovables(options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /**
+     * Places a note's box among the sheet's movables. See {@link Comment.Boxes.add}.
+     * @internal
+     */
+    protected _addNoteBox(comment: Comment, anchor: IMovable.AnchorOffset | null, hidden: boolean): NoteMovable;
+    /**
+     * The cell geometry a note's box is placed with.
+     * @internal
+     */
+    protected _noteLayout(): NoteLayout;
+    /**
+     * The movables of one index that match the filter, in z-order.
+     * @internal
+     */
+    protected _searchMovableIndex(spatial: ISpatialMap<MovableEntry>, options?: IMovableCollection.GetItemsOptions): IMovable[];
     /** @internal */
     /**
      * @param description A COMPLETE undo description (callers pass a `messageKey`). It used to be a
@@ -1503,7 +1544,7 @@ export declare class Sheet implements ISheet {
      */
     protected _addComment(address: ICellRange.Address, content: IComment.Content, options?: ICommentCollection.AddOptions): IComment;
     /** {@inheritDoc ISheet.createCell} */
-    createCell(update: ICell.Update, coords?: IRange.CellCoords | null): ICell;
+    createCell(update: ICell.Update, coords?: IRange.CellCoords | null, options?: ICell.CreateCellOptions): ICell;
     /** @internal */
     protected _getBoundsAtCoords(coords: IRange.Coords): Bounds;
     /** @internal */
@@ -1587,6 +1628,17 @@ export declare class Sheet implements ISheet {
     protected _getStyle(ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: IStyle.Update, options?: IStyle.UpdateOptions) => void): IStyle;
     /** @internal */
     protected _initHeadersState(jsonColumns?: ISheetHeader.JSON, jsonRows?: ISheetHeader.JSON): void;
+    /**
+     * Tells the grid which rows or columns are hidden now, from inside the operation that changed
+     * them: the formulas that skip hidden cells recalculate under that operation.
+     *
+     * @remarks
+     * A restore is heard here too, with no operation open, and is not told: the grid's record of
+     * the set is restored with the sheet's, and the engine's with its own history
+     * (DESIGN-CALC-SERVICE §7.5). Telling it as well would land the restored set under the snapshot
+     * being left.
+     */
+    protected _tellHidden(axis: IRange.Axis): void;
     /**
      * Drop every read-through cache that a data change can invalidate.
      *
@@ -1633,7 +1685,7 @@ export declare class Sheet implements ISheet {
      */
     protected _newCommentJSON(modifiers: IComment.Modifiers): IComment.JSON;
     /** @internal */
-    protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource): ISpatialMap.Entry<MovableEntry>;
+    protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource, index?: MovableIndex, contentGiven?: Movable.Content): ISpatialMap.Entry<MovableEntry>;
     /** @internal */
     protected _fromJSON(json: ISheet.JSON | undefined, disableLoadAutoFit?: boolean): void;
     /** {@inheritDoc ITransaction.ITransactional.getId} */

package/types/src/sheet/SheetCell.d.ts

@@ -321,7 +321,7 @@ export declare class SheetCell implements ICell {
     /** {@inheritDoc ICell.getStyle} */
     getStyle(direct?: boolean): IStyle;
     /** {@inheritDoc ICell.createCell} */
-    createCell(update: ICell.Update): ICell;
+    createCell(update: ICell.Update, options?: ICell.CreateCellOptions): ICell;
     /**
      * A copy of this cell that reports `coords` as its merge.
      *

package/types/src/sheet/_SheetFilterUtils.d.ts

@@ -2,7 +2,24 @@ import { IRange } from '@sheetxl/primitives';
 import { RunCoords } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { ICondition } from '../condition';
+import { NumberFormatRef } from '../numFmt/BuiltInFormats';
+import { ISheet } from './ISheet';
 import { Sheet } from './Sheet';
+/** A run of one column's rows that show their values under the same number format. */
+export interface TextFormatRun {
+    rowStart: number;
+    rowEnd: number;
+    format: NumberFormatRef;
+}
+/**
+ * The rows of a column by the number format they show their values under, ascending and
+ * covering `coords`; adjacent rows of one format are one run.
+ *
+ * @remarks
+ * What a cell shows follows from its value and its number format. The formats lie in few runs
+ * whatever the number of rows, so a reader of the column's text formats values and builds no cell.
+ */
+export declare function getTextFormatRuns(sheet: ISheet, coords: Readonly<IRange.Coords>): TextFormatRun[];
 /**
  * What a filter evaluation settles: on one axis, the runs that stay visible and the runs that hide.
  *

package/types/src/sheet/_SheetStateTypes.d.ts

@@ -359,6 +359,18 @@ export interface MovableEntry extends Anchored.Entry<IMovable> {
     callbacks: Movable.ContainerCallbacks;
     zIndex: number;
 }
+/**
+ * One of the sheet's movable indexes: the placed movables, or the note boxes. Names the state
+ * keys the index lives under, what its z-order starts above, and what it builds.
+ * @internal
+ */
+export interface MovableIndex {
+    spatial: 'movableSpatial' | 'noteSpatial';
+    byModel: 'movableMapModel' | 'noteMapModel';
+    /** What the index's lowest movable is drawn above. */
+    zIndexBase: () => number;
+    create: (options: Movable.ConstructorOptions) => Movable;
+}
 /**
  * The versioned per-sheet state record held in the transaction store (see `Sheet._getState`).
  * A pure data record: sparse grids, spatial maps, and anchored maps. Behaviour lives beside it in
@@ -375,6 +387,12 @@ export interface State {
     hyperlinkSpatial: ISpatialMap<IHyperlink.Properties>;
     movableSpatial: ISpatialMap<MovableEntry>;
     movableMapModel: Map<IMovable, ISpatialMap.Entry<MovableEntry>>;
+    /**
+     * The boxes of the sheet's notes: movables whose content is a comment, kept apart from the
+     * placed ones so they draw above them and are saved with their comments, not as movables.
+     */
+    noteSpatial: ISpatialMap<MovableEntry>;
+    noteMapModel: Map<IMovable, ISpatialMap.Entry<MovableEntry>>;
     picture?: IPicture | null;
     autoTables: IAnchoredMap<ITable, ITable.JSON>;
     tables: IAnchoredMap<ITable, ITable.JSON>;

package/types/src/sheet/_SheetUtils.d.ts

@@ -99,6 +99,21 @@ export declare function createCellModifiersFromString(runtime: IRuntime, strValu
 export declare function calcAccountingBottomInset(style: IStyle): number;
 /** @internal */
 export declare function getHiddenRuns(header: ISheetHeader): readonly RunCoords[];
+/**
+ * A skip (`IRange.IteratorOptions.processRowSkip` / `processColumnSkip`) over the indexes the
+ * header hides, asked with sheet indexes; `null` when none of `min..max` is hidden.
+ *
+ * @remarks
+ * One per hidden set, kept: the statistics cache their zones by the skip they were walked under,
+ * and a set that changed is a new array and so a new skip.
+ * @internal
+ */
+export declare function getHiddenSkip(header: ISheetHeader, min: number, max: number): ((index: number, reverse?: boolean) => number) | null;
+/**
+ * One skip that leaves out what either does; `hidden` itself when the caller brought none.
+ * @internal
+ */
+export declare function composeSkips(own: ((index: number, reverse?: boolean) => number) | undefined, hidden: (index: number, reverse?: boolean) => number): (index: number, reverse?: boolean) => number;
 /**
  * Merges an array of rangeStateIntersections into a single RangeStateIntersection.
  *

package/types/src/sheetHeader/ISheetHeader.d.ts

@@ -139,6 +139,23 @@ export interface ISheetHeader extends ITransaction.ITransactional, IListener.ISo
      * Returns true if any of the headers have the isHidden flag set to true or if any sizes are 0.
      */
     hasHidden(): boolean;
+    /**
+     * Returns the ranges of headers a filter holds a condition over: on the row axis, the data rows
+     * of the AutoTable and of every table whose {@link ITable.getActiveFilters} is not empty; on
+     * the column axis none, as nothing filters columns.
+     *
+     * @param coords Only the ranges that meet this run, when given (a viewport).
+     *
+     * @remarks
+     * A sheet with any is "filtered", as Excel has it: `SUBTOTAL` 1-11 leave out every hidden row
+     * of a filtered sheet, hand-hidden ones included, and count them all on an unfiltered one; the
+     * visible headers of these ranges are the ones drawn as filtered. A condition counts whether
+     * or not it hides a row.
+     *
+     * A row hidden by hand and a row hidden by a filter are the same hidden row; nothing records
+     * which, and clearing a filter shows both ({@link ITable.deleteFilters}).
+     */
+    getFilteredRanges(coords?: Readonly<RunCoords>): readonly ICellHeaderRange[];
     /**
      * Returns true if header has a max selection at the given index.
      */

package/types/src/sheetHeader/SheetHeader.d.ts

@@ -88,6 +88,8 @@ export declare class SheetHeader implements ISheetHeader {
     } | void;
     /** {@inheritDoc ISheetHeader.getRange} */
     getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /** {@inheritDoc ISheetHeader.getFilteredRanges} */
+    getFilteredRanges(coords?: Readonly<RunCoords>): readonly ICellHeaderRange[];
     /** {@inheritDoc ISheetHeader.getRanges} */
     getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
     /** {@inheritDoc ISheetHeader.getSelectedRange} */
@@ -245,6 +247,15 @@ export declare namespace SheetHeader {
          * @param amount
          */
         setContainerShiftedCallback?: (callback: ShiftCallback) => void;
+        /**
+         * Called when the set of hidden headers changes, as it changes: inside the operation that
+         * changed it, or with none open for an undo or a redo.
+         *
+         * @remarks
+         * The `onHiddenChange` listener hears of the same change once the operation has closed. This
+         * is for an owner that has to act within the operation.
+         */
+        hiddenChanged?: () => void;
         /**
          * JSON state to load.
          */

package/types/src/slicer/ISlicer.d.ts

@@ -1,5 +1,7 @@
+import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
 import { IModel } from '../model';
+import { IMovable } from '../movable';
 /**
  * ISplicer
  *
@@ -9,9 +11,12 @@ import { IModel } from '../model';
  * @hidden
  * @internal
  */
-export interface ISlicer extends IModel {
+export interface ISlicer extends IModel, IMovable.IContent {
     toJSON(toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
-    getDescription(): string;
+    /**
+     * Deletes the slicer, and with it the movable that places it.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
     /** For runtime type checking. */
     readonly isISlicer: true;
 }

package/types/src/slicer/Slicer.d.ts

@@ -1,18 +1,16 @@
 import { IResource } from '../resource';
-import { IModel, AbstractModel } from '../model';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { ISlicer } from './ISlicer';
 /**
  * Implementation for {@link ISlicer}.
  */
-export declare class Slicer extends AbstractModel<State, ISlicer.JSON> implements ISlicer {
+export declare class Slicer extends AbstractMovableContent<State, ISlicer.JSON> implements ISlicer {
     constructor(options: Slicer.ConstructorOptions);
     /** {@inheritDoc IModel.getType} */
     getType(): string;
-    /** {@inheritDoc Movable.Content.getDescription} */
-    getDescription(): string;
     /** {@inheritDoc Movable.Content.toJSON} */
     toJSON(_toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
-    /** {@inheritDoc Movable.Content.getTypeDescription} */
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
     getTypeDescription(): string;
     get [Symbol.toStringTag](): string;
     toString(): string;
@@ -31,13 +29,11 @@ export declare namespace Slicer {
     /**
      * Options for creating a chart.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<ISlicer.JSON> {
-        name: string;
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<ISlicer.JSON> {
     }
 }
-interface State extends AbstractModel.State {
+interface State extends AbstractMovableContent.State {
     data?: any;
-    name?: string;
 }
 export {};
 //# sourceMappingURL=Slicer.d.ts.map

package/types/src/table/AnchoredTable.d.ts

@@ -37,6 +37,7 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
     private _stylePropsCache;
     private _processTableUpdate;
     private _symbolsChanged;
+    private _filteredChanged;
     private _setContainerName;
     private _releaseReferences;
     private _refitBodyRows;
@@ -62,6 +63,12 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
     protected initializeColumnCreator(table: ITable, getProps: (id: number | string) => ColumnPropertiesState, updateProps: (id: number | string, update: Partial<ITable.ColumnProperties> | null, options?: string | ITransaction.OperationOptions) => void, deleteColumn: (id: number | string, options?: ITransaction.OperationOptions) => void, getTotals?: (id: number | string) => _Utils.ColumnTotals, getCalculated?: (id: number | string) => string | null): (id: number | string) => ITable.IColumn;
     protected initializeSortCreator(table: ITable, getProps: (id: number | string) => SortPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState): (id: number | string) => ISort;
     protected initializeFilterCreator(table: ITable, getProps: (id: number | string) => FilterPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState): (id: number | string) => IFilter;
+    /**
+     * The rows the filter levels hide, as sheet row runs, evaluated without the level on column
+     * `exceptIndex` (every level when `null`); empty when no level is left. Read-only: the rows
+     * are judged by the levels, whatever is hidden now.
+     */
+    private _hiddenByLevels;
     protected _initialize(options: AnchoredTable.ConstructorOptions): void;
     /** {@inheritDoc ITable.getNamed} */
     getNamed(): INamed | null;
@@ -126,6 +133,25 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
     protected _calcVisible(): void;
     /** {@inheritDoc ITable.getSnapshot} */
     getSnapshot(options?: ReferenceableClipboard.CopyOptions): ITable.ISnapshot;
+    /**
+     * This table has just been made by a paste, as a copy of the table `fromName`.
+     *
+     * @remarks
+     * Everything the paste writes is part of making the copy, the cells that came across beside it
+     * included: none of it was typed next to a table, so none of it is an auto expansion or a
+     * column fill. The whole sheet is recorded as the table's own write for the paste's commit.
+     */
+    private _adoptPaste;
+    /**
+     * Re-point the formulas in this table's cells that name the table `fromName` at this table.
+     *
+     * @remarks
+     * For a table pasted as a copy, once its cells are across. A copied formula keeps the table it
+     * referenced, as it keeps a defined name; inside a copy of that table the reference was to the
+     * table the formula sits in, so Excel re-points it: the copy of `Table1`'s totals row totals
+     * `Table2`. A formula outside the copy keeps naming the original.
+     */
+    private _retargetCopiedFormulas;
     /** {@inheritDoc ITable.getAnchorType} */
     getAnchorType(): IAnchored.Type;
     /** {@inheritDoc ITable.getStyle} */
@@ -361,15 +387,15 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
      */
     private _syncListenersToAnchor;
     /**
-     * The sheet has moved this table whole, as a same-sheet cut does.
+     * Move this table whole to `coords`, as a same-sheet cut does once its cells are across.
      *
      * @remarks
-     * The listener nodes the cut enclosed moved with it; the rest stayed where the table was, so the
-     * subscription is brought in line with the new anchor.
-     *
-     * @internal
+     * The table is never deleted, so a handle to it, its name and the structured references to it
+     * all stay as they were, and one undo puts it back. The listener nodes the cut enclosed moved
+     * with it; the rest stayed where the table was, so the subscription is brought in line with the
+     * new anchor.
      */
-    _processAfterMove(): void;
+    private _moveTo;
     /** @internal */
     protected _processAnchorCoords(): void;
     /**
@@ -513,6 +539,9 @@ export declare class AnchoredTable extends AbstractAnchored<State, ITable.Events
     private _fillColumn;
     /**
      * Write what columns remember as their formula. `null` forgets.
+     *
+     * @param syncHeld `false` writes the columns alone and leaves the watches as they are: for a
+     * write that lands in a snapshot other than the one the store is at.
      */
     private _rememberCalculated;
     /**
@@ -878,12 +907,23 @@ export declare namespace AnchoredTable {
          * If this is true then this will sync header and footers if they are visible on load.
          */
         syncSheet?: boolean;
+        /**
+         * With `syncSheet`: the coords already end with the totals row the JSON asks for, so its cells
+         * are the table's totals and no row is added.
+         */
+        hasTotals?: boolean;
         processTableUpdate?: () => void;
         /**
          * Called, inside the operation, when the table's name or its columns are set - and once when
          * it is created - for whoever keeps a copy of them (the calculation's replica).
          */
         symbolsChanged?: (table: ITable) => void;
+        /**
+         * Called, inside the operation, when the table starts or stops holding a filter condition
+         * (see {@link ISheet.getFilteredRanges}). A change of condition that leaves one held is not
+         * a change here.
+         */
+        filteredChanged?: (table: ITable) => void;
         /**
          * Called before {@link ITable.delete} (`'error'`) or {@link ITable.convertToRange} (`'address'`)
          * removes the table, while it still exists, so the formulas that reference it can be rewritten.

package/types/src/table/ITable.d.ts

@@ -354,11 +354,20 @@ export declare namespace ITable {
      */
     interface SnapshotDestination {
         tables: ITableCollection;
+        /** Where the table lands: its top-left is used, its size is the table's own. */
         range: IRange.Coords;
     }
     interface ISnapshot extends IHistory.ISnapshot<ITable.SnapshotDestination, ITable, IRange.Coords> {
         /**
-         * Called when the table is copied to a new collection.
+         * Copies, or moves, the table to the destination.
+         *
+         * @remarks
+         * The table's cells are expected at the destination already: the table takes its header,
+         * body and totals rows from what is there.
+         *
+         * With `isCut` the source table is moved. Within its own sheet it is the same table at a new
+         * place, so its name and the references to it stay as they are; anywhere else it is removed
+         * and added again under its name.
          */
         copyTo(destination: ITable.SnapshotDestination, options?: ReferenceableClipboard.CopyOptions): Promise<IRange.Coords>;
     }

package/types/src/table/ITableCollection.d.ts

@@ -53,8 +53,18 @@ export declare namespace ITableCollection {
          * A default value of false will create a new row.
          */
         hasHeader?: boolean;
+        /**
+         * Whether the range already ends with the totals row the `properties` ask for. The table then
+         * takes those cells as its totals row rather than adding one below the range.
+         *
+         * @defaultValue false
+         */
+        hasTotals?: boolean;
         /**
          * Properties to set on the table when created.
+         *
+         * @remarks
+         * With `headerRowCount: 0` the range has no header row: all of it is data.
          */
         properties?: ITable.Properties;
         /**

package/types/src/table/_FilterField.d.ts

@@ -1,3 +1,4 @@
+import { RunCoords } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { ICellRange } from '../cellRange';
 import { ICondition } from '../condition';
@@ -9,7 +10,12 @@ export declare class FilterField implements IFilter {
     private _id;
     private _getProps;
     private _getColumnProps;
-    constructor(table: ITable, id: number | string, getProps: (id: number | string) => FilterPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState);
+    /**
+     * The sheet rows the table's filter levels hide, evaluated without the level on column
+     * `exceptIndex`; with every level when `null`.
+     */
+    private _getHiddenByLevels;
+    constructor(table: ITable, id: number | string, getProps: (id: number | string) => FilterPropertiesState, getColumnProps: (id: number | string) => ColumnPropertiesState, getHiddenByLevels: (exceptIndex: number | null) => Promise<readonly RunCoords[]>);
     /** {@inheritDoc IFilter.IFilterable.filter} */
     filter(condition?: ICondition.Input | null, options?: ITransaction.OperationOptions): Promise<this>;
     /** {@inheritDoc IFilter.getCondition} */
@@ -22,6 +28,8 @@ export declare class FilterField implements IFilter {
     getIndex(): number;
     /** {@inheritDoc IFilter.getRange} */
     getRange(): ICellRange;
+    /** {@inheritDoc IFilter.getItems} */
+    getItems(options?: IFilter.GetItemsOptions): Promise<IFilter.Items>;
     /** {@inheritDoc IFilter.getLevel} */
     getLevel(): number;
     /** {@inheritDoc IFilter.delete} */

package/types/src/text/richtext/IRichText.d.ts

@@ -0,0 +1,36 @@
+import { IStyledFont } from './IStyledFont';
+/**
+ * Text with formatting: a list of {@link IRichText.Run | runs}, each a span of text with the font
+ * properties it sets.
+ *
+ * @remarks
+ * A run records only what it sets. Everything it leaves out is inherited from the font of whatever
+ * holds the text (a note's default, a cell's style).
+ */
+export declare namespace IRichText {
+    /**
+     * One formatted span.
+     */
+    interface Run {
+        /**
+         * The text of the span.
+         */
+        text: string;
+        /**
+         * The font properties this span sets, or nothing when it has none of its own.
+         *
+         * @remarks
+         * The same properties a cell's font has, so a bold span is `{ weight: 700 }`, italic is
+         * `{ style: 'italic' }`. The color is any string a font's color takes; one read from a file keeps
+         * its theme or indexed color that way.
+         */
+        font?: IStyledFont.JSON;
+    }
+    /**
+     * The serialized form: the runs, in order.
+     */
+    interface JSON {
+        runs: Run[];
+    }
+}
+//# sourceMappingURL=IRichText.d.ts.map

package/types/src/text/richtext/index.d.ts

@@ -1,2 +1,3 @@
 export * from './IStyledFont';
+export * from './IRichText';
 //# sourceMappingURL=index.d.ts.map

package/types/src/transaction/ITransaction.d.ts

@@ -367,6 +367,17 @@ export declare namespace ITransaction {
          * needs to know that the change it is hearing about is a restore, not an operation.
          */
         isRestoring(): boolean;
+        /**
+         * Returns `true` while the open operation is an {@link amend} of a commit other than the one
+         * the store is at.
+         *
+         * @remarks
+         * Its writes land in that commit's snapshot alone, and the current state does not change. So
+         * anything made inside it that is not versioned by this store - a resource held outside it,
+         * once for every snapshot - would exist where the current snapshot has no record of it. Code
+         * that makes such a thing asks this first.
+         */
+        isAmendingOtherCommit(): boolean;
         /**
          * The root transaction of the operation that is open.
          *

package/types/src/transaction/Transaction.d.ts

@@ -90,6 +90,8 @@ export declare class TransactionStore implements ITransaction.IStore {
     isOpenTransaction(): boolean;
     /** {@inheritDoc ITransaction.IStore.isRestoring} */
     isRestoring(): boolean;
+    /** {@inheritDoc ITransaction.IStore.isAmendingOtherCommit} */
+    isAmendingOtherCommit(): boolean;
     /** {@inheritDoc ITransaction.IStore.getPendingTransaction} */
     getPendingTransaction(): ITransaction | null;
     /** {@inheritDoc ITransaction.IStore.getCurrentTransaction} */