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

package/types/src/movable/Movable.d.ts

@@ -4,19 +4,23 @@ import { IHistory } from '../history';
 import { IResource, IResourceCollection } from '../resource';
 import { ITransaction } from '../transaction';
 import { IAnchored } from '../anchored';
-import { IModel } from '../model';
 import { IMovable } from './IMovable';
+import { IMovableCollection } from './IMovableCollection';
 import { AbstractAnchored } from '../anchored/AbstractAnchored';
 import { Anchored } from '../anchored/Anchored';
 export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE extends State = State> extends AbstractAnchored<STATE, IMovable.Events> {
-    static instanceCounter: number;
     protected _content: Movable.Content;
-    /** Detaches the content's delete listener; removed before the content is deleted so the delete does not recurse. */
-    private _contentListenerRemove;
-    private _optionsMovable;
+    protected _optionsMovable: Movable.ConstructorOptions<J>;
     constructor(options: Movable.ConstructorOptions<J>);
     /** {@inheritDoc IMovable.getContent} */
-    getContent(): Movable.Content;
+    getContent<T extends IMovable.IContent = IMovable.IContent>(): T;
+    /** {@inheritDoc IMovable.delete} */
+    delete(options?: ITransaction.OperationOptions): void;
+    /**
+     * Removes this movable because its content is being deleted.
+     * @internal
+     */
+    _deleteFromContent(): void;
     protected _processAfterStateChange(state: STATE, commit: ITransaction.ICommit): void;
     protected _processZIndex(): void;
     protected _processContainerSelect(_selected: boolean, _first: boolean): IRange.Coords | void;
@@ -38,14 +42,6 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     protected _toHtml(): Promise<string> | string;
     /** For easy overriding in subclass to implement ISnapshot */
     protected _toImage(): Promise<Blob> | Blob;
-    /** {@inheritDoc IMovable.setName} */
-    setName(name: string): this;
-    /** {@inheritDoc IMovable.getName} */
-    getName(): string | null;
-    /** {@inheritDoc IMovable.setDescription} */
-    setDescription(description: string): this;
-    /** {@inheritDoc IMovable.getDescription} */
-    getDescription(): string | null;
     /** {@inheritDoc IMovable.setHidden} */
     setHidden(hidden?: boolean): this;
     /** {@inheritDoc IMovable.isHidden} */
@@ -77,12 +73,31 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     /** {@inheritDoc IMovable.setAnchorType} */
     setAnchorType(type: IAnchored.Type): this;
     protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
-    protected _invalidateBounds(): void;
-    protected _processContainerDelete(): void;
+    /**
+     * Where this goes when a shift removes every cell it was anchored to, or `null` to delete the
+     * content with its cells, which is what a picture or a chart does.
+     */
+    protected _processContainerRemoved(): IMovable.AnchorOffset | null;
+    /**
+     * The cells and offsets of an anchor that names a cell for both corners.
+     */
+    private _locationFromAnchor;
+    /**
+     * The rows or columns under this movable changed size.
+     *
+     * @remarks
+     * A movable that sizes with its cells has nothing to store: its bounds are read from its cells.
+     * One that does not is placed in pixels, so the cells those pixels fall on are found again.
+     */
     protected _processContainerLayout(): void;
     protected _processAnchorCoords(): void;
     protected enrichOffset(offset: IMovable.OffsetCoords, x: number, y: number): IMovable.OffsetCoords;
     protected _fromJSON(json: IMovable.JSON): void;
+    /**
+     * The anchor as it is saved: the cells of both corners and any non-zero offsets into them.
+     * @internal
+     */
+    _getAnchorJSON(): IMovable.AnchorOffset;
     toJSON(toResourceId?: (resource: IResource) => number | null): IMovable.JSON;
     /** {@inheritDoc IMovable.isIMovable} */
     get isIMovable(): true;
@@ -96,19 +111,10 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
  * {@link Movable}
  */
 export declare namespace Movable {
-    interface Content<J = any> extends IModel {
-        /**
-         * A description for the type.
-         */
-        getTypeDescription(): string;
-        /**
-         * Movable content must be deletable; the movable deletes its content when it is removed.
-         */
-        delete(options?: ITransaction.OperationOptions): void;
-        /**
-         * A description for the instance.
-         */
-        getDescription?(): string;
+    /**
+     * What a movable needs of its content beyond {@link IMovable.IContent}.
+     */
+    interface Content<J = any> extends IMovable.IContent {
         /**
          * Create a json object.
          */
@@ -199,6 +205,15 @@ export declare namespace Movable {
         processZIndex: () => void;
         processSelection: (selected: boolean, first: boolean) => IRange.Coords | void;
     }
+    /**
+     * What a copy hands to the collection it is copied to.
+     */
+    interface AddOptions<J = any> extends IMovableCollection.AddOptions<J> {
+        /**
+         * The alternative text of the content.
+         */
+        altText?: string;
+    }
 }
 interface MovableOffsets {
     tl: Point;
@@ -207,13 +222,19 @@ interface MovableOffsets {
 interface State extends AbstractAnchored.State {
     /** Single rectangle — this type is never anchored to more than one range. */
     anchorCoords: IRange.Coords;
-    name?: string | null;
-    description?: string | null;
     hidden?: boolean;
     rotation?: number;
     lockAspectRatio?: boolean | null;
     offsets?: MovableOffsets;
-    bounds?: Bounds | null;
+    /**
+     * Where a movable that does not size with its cells is placed, in pixels. `null` for one that
+     * does: its bounds are read from its cells and offsets.
+     *
+     * @remarks
+     * An absolute movable is placed by all of it. A movable that moves with its cells is placed by
+     * its cell, and only the size is read from here.
+     */
+    pixelBounds?: Bounds | null;
 }
 export {};
 //# sourceMappingURL=Movable.d.ts.map

package/types/src/numFmt/_FormatCell.d.ts

@@ -3,6 +3,15 @@ import { IColor } from '../color';
 import { IStyle } from '../style';
 import { NumberFormatRef } from './BuiltInFormats';
 import { Parsed, ParserOptions } from './NumberFormatParser';
+/**
+ * The text a value shows under a number format: the `displayText` of {@link parseNumberFormat}
+ * without a cell or its style.
+ *
+ * @remarks
+ * For a reader of many cells that wants only their text (a filter judging a column): what a cell
+ * shows follows from its value and its format, and a run of cells shares the format.
+ */
+export declare function formatDisplayText(runtime: IRuntime, value: Scalar, numberFormat: NumberFormatRef): string;
 export declare function parseNumberFormat(runtime: IRuntime, value: Scalar, style: IStyle, type: ScalarType, numberFormat: NumberFormatRef, parseColor: (val: any) => IColor): Parsed;
 /**
  * The unformatted text for a number.

package/types/src/person/index.d.ts

@@ -1,3 +1,4 @@
 export * from './IPerson';
 export * from './IPersonCollection';
+export { PersonCollection } from './PersonCollection';
 //# sourceMappingURL=index.d.ts.map

package/types/src/picture/IPicture.d.ts

@@ -1,12 +1,18 @@
 import { Size } from '@sheetxl/utils';
 import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
 import { IModel } from '../model';
+import { IMovable } from '../movable';
 /**
  * Interface for working with Pictures (both Images and SVG).
  */
-export interface IPicture extends IModel {
+export interface IPicture extends IModel, IMovable.IContent {
     toJSON(toResourceId?: (resource: IResource) => number | null): IPicture.JSON;
+    /**
+     * Deletes the picture, and with it the movable that places it.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * Returns the resource associated with this picture.
      */

package/types/src/picture/Picture.d.ts

@@ -1,19 +1,20 @@
 import { IResource } from '../resource';
-import { AbstractModel, IModel } from '../model';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { IPicture } from './IPicture';
-interface State extends AbstractModel.State {
+interface State extends AbstractMovableContent.State {
     effects?: string[];
 }
 /**
  * Implementation for {@link IPicture}.
  */
-export declare class Picture extends AbstractModel<State, IPicture.JSON> implements IPicture {
+export declare class Picture extends AbstractMovableContent<State, IPicture.JSON> implements IPicture {
     private _resource;
     private _details?;
     private _dataUrl?;
     constructor(options: Picture.ConstructorOptions);
     /** {@inheritDoc IPicture.getType} */ getType(): string;
     toJSON(toResourceId?: (resource: IResource) => number | null): IPicture.JSON;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
     getTypeDescription(): string;
     /** @internal */
     protected _asDataUrl(): Promise<string>;
@@ -50,7 +51,7 @@ export declare namespace Picture {
     /**
      * Options for creating an IPicture.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<IPicture.JSON> {
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<IPicture.JSON> {
         resource?: IResource;
         /**
          * Returns an IResource from the resourceId or null if not found.

package/types/src/primitives/Range.d.ts

@@ -53,7 +53,11 @@ export declare class Range<T extends Scalar = Scalar> implements IRange<T> {
     choose<TS extends Scalar = T>(from: (IRange<TS> | TS)[], selectFn: (value: TS, coords: IRange.CellCoords, range: IRange<T>) => MaybeError<number>, options?: IRange.ValuesOptions): this;
     /** @inheritdoc IRange.clear */
     clear(): this;
-    /** @inheritdoc IRange.clone */
+    /**
+     * @inheritdoc IRange.clone
+     * @param options Read options for the clone, over this range's own: a `processRowSkip` here is
+     * a clone that reads without those rows.
+     */
     clone(options?: IRange.IteratorOptions, isLiteral?: boolean, isDirectScalar?: boolean): this;
     /** @inheritdoc IRange.compute */
     compute(fn: (range: IRange) => IRange): this;
@@ -258,6 +262,32 @@ export declare class Range<T extends Scalar = Scalar> implements IRange<T> {
      * (`SUMPRODUCT(--ISNUMBER(SEARCH(...)))` → 0).
      */
     protected _untyped(): this;
+    /** This range's options without its skips: for a result whose cells are laid out anew. */
+    protected _optionsFresh(): Omit<IRange.IteratorOptions, 'axis'> & {
+        axis?: IRange.Axis;
+    };
+    /**
+     * This range's options for a result over the same grid at `coords`: its skips count from this
+     * range's origin and cover its shape, so a result whose origin moved (a slice) asks them with
+     * the difference, and one that grew (a resize) asks them for the cells it had and leaves the
+     * rest alone. `null` coords - a result laid out anew - carry no skip.
+     *
+     * @remarks
+     * The rule the skips follow: a result whose cells sit where this range's do (a slice, a fill, a
+     * resize, a map) keeps them, since it is written over a copy of this grid and the cells the skip
+     * left alone still hold what the source does; one laid out anew (`empty()`, a compaction, a
+     * reflow) drops them ({@link _optionsFresh}).
+     */
+    protected _optionsAt(coords: IRange.Coords | null): Omit<IRange.IteratorOptions, 'axis'> & {
+        axis?: IRange.Axis;
+    };
+    /** Whether this range's own options skip anything. */
+    protected _hasSkips(): boolean;
+    /**
+     * Iterator options with their skips asked in the GRID's indexes rather than this range's: what
+     * the grid's own iterators take. The options themselves when they skip nothing.
+     */
+    protected _skipsOnGrid<O extends IRange.IteratorOptions>(options: O): O;
     protected _createBuilder(axis?: IRange.Axis): Tuple.IBuilder;
     /**
      * Writes `region` into `values`: its clears first, unless `fresh` (a grid that stores nothing

package/types/src/primitives/RangeStats.d.ts

@@ -9,6 +9,11 @@ export declare class RangeStats implements IRangeStats {
     protected _iteratorOptions?: IRange.IteratorOptions;
     protected _segmentCache: AggSegmentCache;
     protected _ZoneSizeMinor: number;
+    /**
+     * The first row and column of the range whose options these are, which its `processRowSkip` /
+     * `processColumnSkip` count from; `undefined` when the options skip nothing.
+     */
+    protected _skipOrigin: IRange.CellCoords | undefined;
     protected _sortedNumbers: SortedNumbers | undefined;
     protected _aggregates: IRangeStats.Aggregates | undefined;
     protected _typedCounts: Readonly<Record<ScalarType, number>> | undefined;
@@ -25,7 +30,7 @@ export declare class RangeStats implements IRangeStats {
     protected _frequencies: Readonly<IRangeStats.IFrequency> | undefined;
     protected _ranked: readonly Scalar[] | undefined;
     protected _lastNumber: number | null | undefined;
-    constructor(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords?: readonly (IRange.Coords | null)[], options?: IRange.IteratorOptions, segmentCache?: AggSegmentCache, zoneSizeMinor?: number);
+    constructor(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords?: readonly (IRange.Coords | null)[], options?: IRange.IteratorOptions, segmentCache?: AggSegmentCache, zoneSizeMinor?: number, skipOrigin?: IRange.CellCoords);
     /**
      * The values grid this instance measures. Its owner re-points the cache when the map is
      * replaced, which a clone of the map is.
@@ -40,13 +45,13 @@ export declare class RangeStats implements IRangeStats {
     getCoords(): IRange.Coords | null;
     /** @inheritdoc IRangeStats.getSize */
     getSize(): number;
-    /** @inheritdoc IRangeStats.getCount */
     /**
      * The instance's one walk (see `_raw`), taken with errors as population — the contract of
      * every consumer that counts. Reused by the aggregate path when the instance's own error
      * policy has no side effect to replay.
      */
     protected _walk(): AggResults | null;
+    /** @inheritdoc IRangeStats.getCount */
     getCount(): number;
     /** @inheritdoc IRangeStats.getAggregates */
     getAggregates(options?: IRange.IteratorOptions): Readonly<IRangeStats.Aggregates>;

package/types/src/primitives/ReferenceRange.d.ts

@@ -44,6 +44,8 @@ export declare class ReferenceRange extends Range implements IReferenceRange {
     hasError(): boolean;
     /** @inheritdoc IRange.slice */
     slice(coords: Partial<IRange.Coords>): this;
+    /** @inheritdoc Range.clone */
+    clone(options?: IRange.IteratorOptions, isLiteral?: boolean, isDirectScalar?: boolean): this;
     /**
      * @internal
      * The reference DEMOTED to its values: a plain `Range` over the same grid and coords, with no

package/types/src/primitives/stats/AggregateStats.d.ts

@@ -37,8 +37,52 @@ export type AggResults = {
 export type AggSegmentCache = {
     coerce: unknown;
     byRun: WeakMap<IListLike<Scalar>, AggResults[]>;
+    /**
+     * The segments of a walk that SKIPS cells (`IRange.IteratorOptions.processRowSkip`), by the
+     * skip and the origin it counts from: a segment's content then depends on which cells the skip
+     * leaves out, and a caller that keeps one skip (the engine's, per hidden set) keeps its zones.
+     */
+    bySkip: WeakMap<SkipProcessor, Map<number, WeakMap<IListLike<Scalar>, AggResults[]>>>;
 };
 export declare const createAggSegmentCache: () => AggSegmentCache;
+/** A skip as `IRange.IteratorOptions.processRowSkip` gives one: the index to read at or past `index`. */
+export type SkipProcessor = (index: number, reverse?: boolean) => number;
+/**
+ * A skip a walk honors, on one axis of the grid: the range's callback, which counts from the
+ * range's origin on that axis, asked with a grid index less that origin.
+ */
+export interface WalkSkip {
+    readonly skip: SkipProcessor;
+    readonly origin: number;
+}
+/** The skips of a walk, by the grid's axes. */
+export interface WalkSkips {
+    /** The skip along the grid's major axis: a run it skips is left out whole. */
+    readonly major: WalkSkip | null;
+    /** The skip along the grid's minor axis: the cells of a run it skips. */
+    readonly minor: WalkSkip | null;
+}
+/**
+ * The skips `options` ask for, by the grid's axes; `null` when it asks for none.
+ *
+ * @param origin The range's first row and column on the grid, which its callbacks count from.
+ */
+export declare function resolveSkips(options: IRange.IteratorOptions | undefined, isColumn: boolean, origin: IRange.CellCoords | undefined): WalkSkips | null;
+/** Whether the skip leaves out the grid index. */
+export declare const isSkipped: (skip: WalkSkip, index: number) => boolean;
+/**
+ * The grid index to read at or past `index` (at or before, when `reverse`): `index` itself when
+ * the skip reads it. A walk moves straight to it, so a hidden block costs one call, not one per
+ * cell.
+ */
+export declare const nextRead: (skip: WalkSkip, index: number, reverse?: boolean) => number;
+/**
+ * How many cells of `coords` a read under `options` takes in: the population blanks are counted
+ * from. A skipped cell is outside it, so it is never a blank.
+ *
+ * @param origin As {@link resolveSkips}.
+ */
+export declare function countReadCells(options: IRange.IteratorOptions | undefined, coords: IRange.Coords, origin: IRange.CellCoords | undefined): number;
 export declare const resolveAggSegmentCache: (grid: ISparseGrid<Scalar>, inherit?: AggSegmentCache) => AggSegmentCache;
 /**
  * The default minor zone size for segment caching.
@@ -61,13 +105,13 @@ export declare const EmptyAggregates: Readonly<IRangeStats.Aggregates>;
  *
  * @remarks
  * Results are built using a segment cache keyed by run identity (`segmentsByRun`).
- * The cache is shared across all coord shapes that derive from the same root `RangeStats`
- * instance (via `toLocalCoords`), so segment aggregates computed for one shape are reused
- * by any other shape that overlaps the same run segments.
+ * The cache is grid-scoped (see `resolveAggSegmentCache`), so segment aggregates computed for
+ * one coord shape are reused by any other shape over the same grid lineage that overlaps the
+ * same run segments.
  *
  * Returns `null` when the grid is empty.
  */
-export declare function iterateAndCollectStats(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords: readonly (IRange.Coords | null)[], optionsIterator: IRange.IteratorOptions | undefined, segmentCache: AggSegmentCache, zoneSizeMinor: number): AggResults | null;
+export declare function iterateAndCollectStats(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords: readonly (IRange.Coords | null)[], optionsIterator: IRange.IteratorOptions | undefined, segmentCache: AggSegmentCache, zoneSizeMinor: number, skipOrigin?: IRange.CellCoords): AggResults | null;
 /**
  * The value Excel added LAST — the final numeric member in ROW-major order, which is the
  * traversal Excel's accumulators use (measured: `probe-sum-cancel-order.ps1`, two mirrored 2-D
@@ -87,7 +131,7 @@ export declare function iterateAndCollectStats(runtime: IRuntime, grid: ISparseG
  * `(row, col)` is used rather than reverse iteration because the grid's run iterator has no
  * reverse, and this way the result is independent of the grid's axis.
  */
-export declare function findLastNumber(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords: readonly (IRange.Coords | null)[], optionsIterator: IRange.IteratorOptions | undefined): number | undefined;
+export declare function findLastNumber(runtime: IRuntime, grid: ISparseGrid<Scalar>, range: IRange | null, localCoords: readonly (IRange.Coords | null)[], optionsIterator: IRange.IteratorOptions | undefined, skipOrigin?: IRange.CellCoords): number | undefined;
 /**
  * Resolves an iterator's `coerce` option into the callable pair the scans use.
  *
@@ -106,14 +150,4 @@ export declare function resolveCoerce(runtime: IRuntime, optionsIterator: IRange
  * Computes derived fields (average, variance, stdDev) and normalizes missing-number fields to null.
  */
 export declare function buildAggregates(raw: AggResults | null): Readonly<IRangeStats.Aggregates>;
-/**
- * Calculates an optimal zone size for a given grid minor dimension.
- *
- * @remarks
- * Strategy: target ~128 segments per full column/row to balance cache granularity
- * (smaller = better reuse for small queries) vs. iteration overhead (fewer = faster
- * full-column scans). Result is rounded up to the nearest power of 2 and clamped to
- * [256, 16384].
- */
-export declare function calculateZoneSize(maxMinorDimension: number): number;
 //# sourceMappingURL=AggregateStats.d.ts.map

package/types/src/primitives/stats/FrequencyStats.d.ts

@@ -79,7 +79,7 @@ export declare class FrequencyStats implements IRangeStats.IFrequency {
      * (a custom `filterFn` restricts the population in a way nothing else already counts) and the
      * scan's own `visitedCount` is used — exact when not truncated, an undercount when truncated.
      */
-    static fromGrid(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, options: IRangeStats.GetFrequenciesOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number, blankCount: number, totalCount: number | undefined): FrequencyStats;
+    static fromGrid(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, options: IRangeStats.GetFrequenciesOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number, blankCount: number, totalCount: number | undefined, skipOrigin?: IRange.CellCoords): FrequencyStats;
     /**
      * Builds an instance directly from an already-merged group map — used by
      * {@link CompositeRangeStats}, which merges its children's own (already-scanned) frequencies

package/types/src/primitives/stats/Ranked.d.ts

@@ -10,7 +10,7 @@ import { ISparseGrid } from '../../collections';
  * `includeBlanks` is handled separately: one synthetic `null` candidate is offered per blank
  * cell, capped at `limit` offers (any beyond that can never displace a kept member).
  */
-export declare function collectRanked(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, options: IRangeStats.GetRankedOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number): readonly Scalar[];
+export declare function collectRanked(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, options: IRangeStats.GetRankedOptions | undefined, defaultCompareFn: (a: Scalar, b: Scalar) => number, skipOrigin?: IRange.CellCoords): readonly Scalar[];
 /**
  * Merges each child's own top-`limit` into the composite's true top-`limit`.
  *

package/types/src/primitives/stats/SortedNumbers.d.ts

@@ -22,7 +22,7 @@ export declare class SortedNumbers implements IRangeStats.ISortedNumbers {
      * Collects the numeric values within `localCoords` from the grid and returns an instance
      * over them (sorted ascending).
      */
-    static fromGrid(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined): SortedNumbers;
+    static fromGrid(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, skipOrigin?: IRange.CellCoords): SortedNumbers;
     /** @inheritdoc IRangeStats.ISortedNumbers.getLarge */
     getLarge(k: number): number | null;
     /** @inheritdoc IRangeStats.ISortedNumbers.getSmall */
@@ -45,6 +45,6 @@ export declare class SortedNumbers implements IRangeStats.ISortedNumbers {
      * Collects all numeric values from the range coords and returns them sorted ascending.
      * Called at most once per instance lifetime (result is cached on `_sortedNumbers`).
      */
-    protected static _collectNumbers(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined): readonly number[];
+    protected static _collectNumbers(grid: ISparseGrid, localCoords: readonly (IRange.Coords | null)[], iteratorOptions: IRange.IteratorOptions | undefined, skipOrigin?: IRange.CellCoords): readonly number[];
 }
 //# sourceMappingURL=SortedNumbers.d.ts.map

package/types/src/shape/IShape.d.ts

@@ -1,7 +1,9 @@
 import { Point, Rectangle } from '@sheetxl/utils';
 import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
 import { IModel } from '../model';
+import { IMovable } from '../movable';
 import { IHyperlink } from '../hyperlink';
 import { IFill } from '../fill';
 import { IStroke } from '../fill/IStroke';
@@ -17,16 +19,16 @@ import { ITextFrame } from '../text/ITextFrame';
  * Reading only: a shape's preset and its text. An imported shape is otherwise kept as the source
  * wrote it and saved back unchanged.
  */
-export interface IShape extends IModel {
+export interface IShape extends IModel, IMovable.IContent {
     toJSON(toResourceId?: (resource: IResource) => number | null): IShape.JSON | null;
     /**
      * Returns the name of the shape.
      */
-    getName(): string;
+    getName(): string | null;
     /**
-     * Returns the description of the shape.
+     * Deletes the shape, and with it the movable that places it.
      */
-    getDescription(): string;
+    delete(options?: ITransaction.OperationOptions): void;
     /**
      * Returns the kind of shape this is: its preset geometry.
      *

package/types/src/shape/Shape.d.ts

@@ -1,24 +1,20 @@
 import { IResource, IResourceCollection } from '../resource';
-import { IModel, AbstractModel } from '../model';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { ITextFrame } from '../text/ITextFrame';
 import { IShape } from './IShape';
-interface State extends AbstractModel.State {
+interface State extends AbstractMovableContent.State {
     data?: any;
 }
 /**
  * Implementation for {@link IShape}.
  */
-export declare class Shape extends AbstractModel<State, IShape.JSON> implements IShape {
+export declare class Shape extends AbstractMovableContent<State, IShape.JSON> implements IShape {
     /** The state `_facts` was read from; a new state object is a new read. */
     private _factsSource;
     private _facts;
     constructor(options: Shape.ConstructorOptions);
     /** {@inheritDoc IModel.getType} */
     getType(): string;
-    /** {@inheritDoc IShape.getName} */
-    getName(): string;
-    /** {@inheritDoc Movable.Content.getDescription} */
-    getDescription(): string;
     /** {@inheritDoc IShape.getShapeType} */
     getShapeType(): string;
     /** {@inheritDoc IShape.getTextFrame} */
@@ -27,7 +23,7 @@ export declare class Shape extends AbstractModel<State, IShape.JSON> implements
     private _getFacts;
     /** {@inheritDoc Movable.Content.toJSON} */
     toJSON(_toResourceId?: (resource: IResource) => number | null): IShape.JSON | null;
-    /** {@inheritDoc Movable.Content.getTypeDescription} */
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
     getTypeDescription(): string;
     get [Symbol.toStringTag](): string;
     toString(): string;
@@ -44,7 +40,7 @@ export declare namespace Shape {
     /**
      * Options for creating a shape.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<IShape.JSON> {
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<IShape.JSON> {
         /**
          * Returns an IResource from the resourceId or null if not found.
          */
@@ -57,7 +53,6 @@ export declare namespace Shape {
          * Allow for the default lock aspect ratio to be overwritten.
          */
         defaultLockAspectRatio?: boolean;
-        getName(): string;
     }
 }
 export {};

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

@@ -369,14 +369,15 @@ export interface ISheet extends ITransaction.ITransactional, IListener.ISource<I
      *
      * @param update Cell Update
      * @param coords Optional CellCoord
+     * @param options How the update is read. See {@link ICell.CreateCellOptions}.
      * @returns A detached ICell
      *
      * @remarks
-     * * Useful for previewing values such as tooltip.
+     * * Useful for previewing values such as tooltip, or what typed text would be entered as.
      * * Does not add to the sheet but provides a standalone ICell.
      * * If the coords are passed it will return disconnect cell update for that value.
      */
-    createCell(update: ICell.Update, coords?: IRange.FixableCellCoords): ICell;
+    createCell(update: ICell.Update, coords?: IRange.FixableCellCoords, options?: ICell.CreateCellOptions): ICell;
     /**
      * Parses a formula expression and returns a *transient* formula object anchored to this sheet.
      *