@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.2

package/types/src/lib/file/file.browser.d.ts

@@ -11,7 +11,9 @@ import { AbstractBackingStore } from '../../io/AbstractBackingStore';
  * per-instance cache **keyed by the origin**, so a save to a bound origin can re-write silently.
  * This is an invisible optimization — a handle cannot be recreated from a string path, so holding
  * the object is the only way to re-save in place. Nothing about it is surfaced through any public
- * type; the origin's `canWrite()` reflects whether a handle is held.
+ * type; the origin's `canWrite()` reflects whether a handle is held — decided when the source is
+ * acquired, since holding the handle is the whole question. Write *permission* is a separate
+ * matter the platform only answers by prompting, which happens at save time.
  */
 export declare class BrowserBackingStore extends AbstractBackingStore {
     private _getWriteFormats;
@@ -19,14 +21,26 @@ export declare class BrowserBackingStore extends AbstractBackingStore {
     protected _defaultStringSourceType: "fetch";
     /** Writable FSA handles keyed by the Origin they back. */
     private _handleCache;
-    private _pendingOpenHandle;
     constructor(_getWriteFormats: () => Promise<IWorkbookIO.FormatType[]>, _getReadFormats?: (() => Promise<IWorkbookIO.FormatType[]>) | undefined);
-    /** @inheritdoc IWorkbookIO.IBackingStore.read */
-    read(request: IWorkbookIO.ReadRequest): Promise<IWorkbook | null>;
+    /**
+     * A File System Access handle (from an open picker, or a drop via `getAsFileSystemHandle`) can be
+     * written back to, so it reads as a writable source.
+     */
+    protected fileFromHandle(source: any): Promise<File | null>;
     /** @inheritdoc */
     protected resolveSource(): Promise<any>;
+    /**
+     * Browser sources have no real path — a picked file is identified by its handle — so a file is
+     * open when a handle held for an open workbook's origin is the same entry.
+     */
+    protected findOpenOrigin(acquired: any): Promise<IWorkbookIO.Origin | null>;
+    /**
+     * The origin of an open workbook, other than `except`, that saves back through a handle to the
+     * same file as `handle`, or `null`.
+     */
+    private _findOpenHandle;
     /** @inheritdoc */
-    protected onWorkbookRead(workbook: IWorkbook): Promise<void>;
+    protected onWorkbookRead(workbook: IWorkbook, source: any): Promise<void>;
     /** @inheritdoc */
     protected filePathToFile(filePath: string): Promise<File>;
     /** @inheritdoc IWorkbookIO.IBackingStore.write */

package/types/src/lib/file/file.node.d.ts

@@ -12,6 +12,11 @@ export declare class FSBackingStore extends AbstractBackingStore {
     protected filePathToFile(filePath: string): Promise<File>;
     /** @inheritdoc */
     protected _canWriteLocalPath(): boolean;
+    /**
+     * Both paths are already resolved to absolute ones (reads and writes resolve them); Windows file
+     * names are case-insensitive and take either slash.
+     */
+    protected isSamePath(a: string, b: string): boolean;
     /** @inheritdoc IWorkbookIO.IBackingStore.write */
     write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin | null>;
 }

package/types/src/lib/utils/_Utils.d.ts

@@ -12,6 +12,7 @@ export interface NodeFingerprint {
 export interface HostDetails {
     cpus?: number;
     memoryGB?: number;
+    protocol?: string | null;
     domain?: string | null;
     fingerprint?: NodeFingerprint;
 }
@@ -23,5 +24,15 @@ export interface HostDetails {
  */
 export declare function isPlaceholderLicenseKey(key: string | null | undefined): boolean;
 export declare function getBuildVersion(): string;
+/** When this build was made, as an ISO 8601 instant, or `''` when unstamped. */
 export declare function getBuildDate(): string;
+/**
+ * The build as a person reads it: the stamped version, or `local` plus the local build time.
+ *
+ * @remarks
+ * A stamped version already names its commit, so the time adds nothing to it. A workspace build
+ * has no identity except when it was built, and to the minute, because several rebuilds a day
+ * all look alike at date resolution.
+ */
+export declare function getBuildLabel(): string;
 //# sourceMappingURL=_Utils.d.ts.map

package/types/src/lib/utils/utils.browser.d.ts

@@ -1,10 +1,16 @@
 import { HostDetails } from './_Utils';
 import { LicenseDetails } from '../../license';
+/**
+ * What the license check sees of the page: the scheme it is served over (no colon) and its hostname.
+ * `domain` is `null` for the one dev case — loopback over http(s). The scheme is part of that test on
+ * purpose: `tauri://localhost` / `capacitor://localhost` are shipped apps that happen to use a loopback
+ * host, and are checked like production. Outside a window (a worker, node under test) both are `null`.
+ */
 export declare function getHostDetails(): Promise<HostDetails>;
 /**
- * Only the loopback host is a dev environment. A dev *build* served on any other host (a LAN IP,
- * a tunnel) is checked exactly like production: license domains apply and an evaluation shows
- * the watermark.
+ * Only the loopback host over http(s) is a dev environment. A dev *build* served on any other host
+ * (a LAN IP, a tunnel) — or under any other scheme — is checked exactly like production: license
+ * origins apply and an evaluation shows the watermark.
  */
 export declare function isDevEnv(): Promise<boolean>;
 /**

package/types/src/license/license-key.d.ts

@@ -19,6 +19,7 @@ export interface LicenseKeyDetails {
     type?: string;
     expiration?: string | null;
     developerCount?: number;
+    /** Licensed origins, `<protocol>://<host>` each (see `Origin`); a string is comma-separated. */
     domains?: string | string[];
     fingerprint?: string | null;
     cpuCount?: number | null;
@@ -29,5 +30,31 @@ export declare function rot(text: string, key: number, n?: number): string;
 export declare function deobs(str: string): Decoded;
 export declare function encodeLicenseKey(keyDetails: LicenseKeyDetails): LicenseAndKey;
 export declare function validateDomain(domain: string, allowDomain?: boolean): boolean;
+/**
+ * A licensed origin, `<protocol>://<host>`.
+ *
+ * The protocol is the scheme the page is served over — `https` on the web, `vscode-webview` in VS Code
+ * desktop, an app's own registered scheme in Electron — and is mandatory: a browser license names
+ * the runtime it was sold for, not just a hostname. The host is a domain (matched exactly or as a
+ * suffix — `acme.com` covers `app.acme.com`), `*` for any host (runtimes whose host is random, like
+ * VS Code's `v--<hash>`), or empty for schemes that carry no host (`file://`).
+ */
+export interface Origin {
+    protocol: string;
+    host: string;
+}
+/** Splits `<protocol>://<host>`; `null` when the entry has no protocol or a malformed one. */
+export declare function parseOrigin(entry: string): Origin | null;
+/**
+ * `true` when `entry` is a well-formed origin. Web hosts (`http`/`https`) must be a subdomain, or an
+ * apex when the license carries the `domain` feature (`allowDomain`) — the same rule `validateDomain`
+ * applies; any other scheme accepts a DNS-shaped host, `*`, or none.
+ */
+export declare function validateOrigin(entry: string, allowDomain?: boolean): boolean;
+/**
+ * `true` when the running page — `protocol` without its colon and `hostname`, as `location` reports
+ * them — is covered by `entry`. An entry with no protocol covers nothing.
+ */
+export declare function originMatches(entry: string, protocol: string, hostname: string): boolean;
 export declare function validateFingerprint(fingerprint: string | null): boolean;
 //# sourceMappingURL=license-key.d.ts.map

package/types/src/listener/IListener.d.ts

@@ -25,19 +25,24 @@ export declare namespace IListener {
          */
         once?: boolean;
         /**
-         * Determines if the listeners is part of the transaction.
+         * Whether the listener takes part in the operation that notifies it.
          *
-         * @defaultValue If the listener is added during a transaction this will be true.
+         * @defaultValue `true` when the listener is added during an operation - a listener added as a
+         * consequence of one is part of it - and `false` otherwise.
          *
          * @remarks
-         * There are subtle differences between a transactional listener and a non-transactional listener.
-         *
          * A transactional listener:
-         * * Will not be fire during undo/redo.
-         * * Will be reverted to it's original add/remove state during an undo/redo.
+         * * is told inline, inside the operation, so anything it writes joins that same commit, and
+         *   is told during an undo or a redo for the same reason;
+         * * hears nothing announced outside an operation;
+         * * is part of the document: the operation that added it removes it on undo and puts it back
+         *   on redo.
          *
          * A non-transactional listener:
-          * Will not be fire on any change.
+         * * is told once per operation, after it has landed, however many times the operation
+         *   notified, and not at all if the operation is rolled back;
+         * * is told at once when there is no operation, and at once during an undo or a redo;
+         * * survives an undo, since it is not part of the document.
          */
         transactional?: boolean;
     }

package/types/src/listener/ListenerEmitter.d.ts

@@ -3,16 +3,34 @@ import { IListener } from './IListener';
 export interface NotifyOptions<T = any> {
     params?: T | null;
     source?: any;
+    /**
+     * Collect what the listeners return. A notify that collects is a request, not an
+     * announcement, and is delivered at once wherever it is made.
+     */
     async?: boolean;
+    /**
+     * Deliver as if made inside (`true`) or outside (`false`) an operation, whatever the store
+     * says. `false` is for a signal that is not a change to the document (a dirty flag).
+     */
     transactional?: boolean;
 }
 /**
- * Manages Listeners
+ * Manages listeners.
  *
  * @remarks
- * A few rules to know:
+ * `transactional` ({@link IListener.Options}) says whether a listener takes part in the operation
+ * that notifies it. Unless the caller says, it is inferred from where the listener was added: one
+ * added as a consequence of an operation is part of it.
  *
- * * non-transactional listeners are fired after the commit end and are conflated.
+ * * A transactional listener is told inline, inside the operation, so what it writes joins that
+ *   commit; it is told during a restore's dispatch for the same reason. It is versioned with the
+ *   document - an undo removes the subscription, a redo restores it - and, being part of an
+ *   operation, it hears nothing announced outside one.
+ * * A non-transactional listener is told ONCE, after the operation has landed, with everything
+ *   the operation announced conflated by callback; a rollback drops it. Outside an operation, and
+ *   during a restore, it is told at once - a restore has no commit to wait for.
+ * * A request (`async`) is delivered at once wherever it is made and returns what the listeners
+ *   answered. A question is not an announcement, and deferring one would break every `await`.
  */
 export declare class ListenerEmitter<SOURCE, EVENTS> {
     protected _transactions: ITransaction.IStore;
@@ -22,10 +40,32 @@ export declare class ListenerEmitter<SOURCE, EVENTS> {
     protected _src: SOURCE;
     protected _listeners: EntrySet<SOURCE, EVENTS>;
     protected _pending: Pending<any, SOURCE>[] | null;
+    protected _landing: Pending<any, SOURCE>[] | null;
     constructor(src: SOURCE, transactions?: ITransaction.IStore);
+    /** DEBUG (temporary): names this emitter in the `__SXL_LOG_EVENTS` trace. Remove with it. */
+    protected _label(): string;
+    /**
+     * `true` while the store is mid-operation: a transaction is open, or a restore is being
+     * dispatched. What a listener added now is a consequence of, and what a notify made now belongs
+     * to.
+     */
+    protected _inOperation(): boolean;
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: IListener.Callbacks<SOURCE, EVENTS>, options?: IListener.Options): IListener.Remove;
+    /**
+     * Write the transactional listener set, copy-on-write, as a fold rather than a step.
+     *
+     * @remarks
+     * The set is document state, so a subscription made by an operation is removed by undoing it
+     * and put back by redoing it. A fold rather than a commit because a registration is not a step
+     * in the history: it adds no undo entry and announces nothing. Inside an open operation the
+     * flag is a no-op on the nested commit and the write simply joins that operation, which is
+     * where a listener added as a consequence of it belongs.
+     */
+    protected _updateEntries(mutate: (entries: EntrySet<SOURCE, EVENTS>) => void): void;
     protected _doNotify<T = unknown>(listeners: IListener.Callback<SOURCE>[], removes?: IListener.Remove[] | null, options?: NotifyOptions<T>, fired?: Set<IListener.Callback<SOURCE>>): Promise<any>;
+    /** The callbacks for `key` in a bucket, gathered first so a removal during delivery is safe. */
+    protected _collect(entries: EntrySet<SOURCE, EVENTS> | undefined, key: keyof EVENTS): Collected<SOURCE> | null;
     /**
      * Notify listeners.
      */
@@ -37,10 +77,11 @@ interface Entry<SOURCE, EVENTS> {
     listeners: IListener.Callbacks<SOURCE, EVENTS>;
 }
 type EntrySet<SOURCE = any, EVENTS = any> = Set<Entry<SOURCE, EVENTS>>;
-interface Pending<T, SOURCE> {
-    commitId: string;
+interface Collected<SOURCE> {
     listeners: IListener.Callback<SOURCE>[];
     removes: IListener.Remove[] | null;
+}
+interface Pending<T, SOURCE> extends Collected<SOURCE> {
     options?: NotifyOptions<T>;
 }
 export {};

package/types/src/model/AbstractModel.d.ts

@@ -5,7 +5,7 @@ import { ListenerEmitter } from '../listener/ListenerEmitter';
 /**
  * Abstract implement of `IModel`.
  */
-export declare abstract class AbstractModel<STATE extends AbstractModel.State = AbstractModel.State, JSON extends any = any, VIEW extends AbstractModel.CommitView = AbstractModel.CommitView, EVENTS extends IModel.Events = IModel.Events> implements IModel {
+export declare abstract class AbstractModel<STATE extends AbstractModel.State = AbstractModel.State, JSON extends any = any, EVENTS extends IModel.Events = IModel.Events> implements IModel {
     protected _emitter: ListenerEmitter<AbstractModel, EVENTS>;
     protected _options: IModel.ConstructorOptions<JSON>;
     protected _transactions: ITransaction.IStore;
@@ -38,16 +38,27 @@ export declare abstract class AbstractModel<STATE extends AbstractModel.State =
     /** @internal */
     protected _getTransactions(): ITransaction.IStore;
     /** @internal */
+    /** Write the state as a step in the history. */
     protected _updateState(updateState?: Partial<STATE>, //(prevState: STATE) => STATE,
     options?: ITransaction.StoreOperationOptions, events?: (keyof EVENTS)[]): this;
+    /**
+     * Write the state as a fold into the commit it starts from, rather than as a step.
+     *
+     * @remarks
+     * For a write that is not an edit - this model's own initialization, or bookkeeping derived
+     * from a change that already has a commit. It adds no undo entry and is undone with the commit
+     * it lands in. See {@link ITransaction.amend}.
+     */
+    protected _amendState(updateState?: Partial<STATE>, options?: ITransaction.StoreOperationOptions, events?: (keyof EVENTS)[]): this;
+    private _writeState;
     /** @internal */
     protected _getEmitter<SOURCE, E extends EVENTS>(): ListenerEmitter<SOURCE, E>;
     /** @internal */
     protected _processInit(): void;
     /** @internal */
-    protected _processAfterStateChange(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
+    protected _processAfterStateChange(_state: STATE, _commit: ITransaction.ICommit): void;
     /** @internal */
-    protected _processRestoreOrRevert(_state: STATE, _view: VIEW, _commit: ITransaction.ICommit): void;
+    protected _processRestoreOrRevert(_state: STATE, _commit: ITransaction.ICommit): void;
     delete(options?: ITransaction.OperationOptions): void;
     /** @internal */
     protected _delete(options?: ITransaction.OperationOptions): void;
@@ -84,7 +95,5 @@ export declare namespace AbstractModel {
     interface State extends ITransaction.StateRecord {
         isDeleted: boolean;
     }
-    interface CommitView {
-    }
 }
 //# sourceMappingURL=AbstractModel.d.ts.map

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

@@ -0,0 +1,57 @@
+import { IResource, IResourceCollection } from '../resource';
+import { IModel, AbstractModel } from '../model';
+import { IEmbeddedPart } from '../io';
+import { IControl } from './IControl';
+interface State extends AbstractModel.State {
+    data?: IControl.JSON;
+}
+/**
+ * Implementation for {@link IControl}.
+ */
+export declare class Control extends AbstractModel<State, IControl.JSON> implements IControl {
+    /**
+     * The part describing the control. Held beside {@link State.data} rather than in it because the
+     * resources it may carry are model references, not JSON, and have to be re-persisted per save.
+     */
+    protected _part: IEmbeddedPart | null;
+    constructor(options: Control.ConstructorOptions);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc IControl.getShapeId} */
+    getShapeId(): number | null;
+    /** {@inheritDoc IControl.getXML} */
+    getXML(): string | null;
+    /** {@inheritDoc Movable.Content.getDescription} */
+    getDescription(): string;
+    /** {@inheritDoc Movable.Content.toJSON} */
+    toJSON(toResourceId?: (resource: IResource) => number | null): IControl.JSON | null;
+    /** {@inheritDoc Movable.Content.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc IControl.isIControl} */
+    get isIControl(): true;
+}
+/**
+ * Interfaces for creating `Control` items.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link Control}
+ */
+export declare namespace Control {
+    /**
+     * Options for creating a Control.
+     */
+    interface ConstructorOptions extends IModel.ConstructorOptions<IControl.JSON> {
+        /**
+         * Returns an IResource from the resourceId or null if not found.
+         */
+        fromResourceId?: (resourceId: number) => IResource;
+        /**
+         * Useful for load/save/copying.
+         */
+        beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
+    }
+}
+export {};
+//# sourceMappingURL=Control.d.ts.map

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

@@ -0,0 +1,84 @@
+import { IListener } from '../listener';
+import { IResource } from '../resource';
+import { IModel } from '../model';
+import { IEmbeddedPart } from '../io';
+/**
+ * Interface for working with form controls — a button, a checkbox, a scrollbar placed on a sheet.
+ *
+ * **PLACEHOLDER** - This is under development and not made public yet.
+ */
+export interface IControl extends IModel {
+    /**
+     * Returns a description for assistive technologies.
+     */
+    getDescription(): string;
+    /**
+     * Returns the id of the shape that draws this control, or `null` if it has none.
+     *
+     * @remarks
+     * The shape lives in the sheet's legacy drawing, which is still opaque markup — this is the only
+     * link between the two, and it is what lets the shape be kept over the same cells as the control
+     * when rows and columns move.
+     */
+    getShapeId(): number | null;
+    /**
+     * Returns the markup of the part describing the control, or `null` if none was captured.
+     *
+     * @remarks
+     * Read-only, and the one escape hatch for what the control does not model yet: it is the
+     * `<formControlPr>` the control was read from — its kind, its linked cell, its macro. It will be
+     * removed when the control is modeled.
+     */
+    getXML(): string | null;
+    toJSON(toResourceId?: (resource: IResource) => number | null): IControl.JSON | null;
+    /** For runtime type checking. */
+    readonly isIControl: true;
+}
+/**
+ * {@inheritDoc IControl}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IControl}
+ */
+export declare namespace IControl {
+    interface JSON {
+        /**
+         * The id of the shape that draws this control.
+         *
+         * @see {@link IControl.getShapeId}
+         */
+        shapeId?: number;
+        /**
+         * The control's own properties, as they were read.
+         *
+         * @remarks
+         * Opaque. What they describe — a button's macro, a checkbox's linked cell — has no model yet,
+         * so they are held as they were read and written back unchanged. The position is *not* among
+         * them: it is the movable's own anchor, and is written from that.
+         */
+        props?: Record<string, string>;
+        /**
+         * Anything else the properties contained, as markup.
+         *
+         * @remarks
+         * Empty for every control this version has seen — a control's properties are attributes and an
+         * anchor, and the anchor is the movable's. Kept so a producer that writes more than that does
+         * not lose it.
+         */
+        xml?: string;
+        /**
+         * The part describing what kind of control this is and how it behaves.
+         *
+         * @remarks
+         * A control is drawn by a shape in the sheet's legacy drawing ({@link ISheet.LegacyDrawingJSON})
+         * and described by a part of its own; this is that part.
+         */
+        part?: IEmbeddedPart.JSON;
+    }
+    interface Events extends IModel.Events {
+    }
+    interface IListeners extends IListener.Callbacks<IControl, IControl.Events> {
+    }
+}
+//# sourceMappingURL=IControl.d.ts.map

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

@@ -29,7 +29,29 @@ export interface IMovable extends IAnchored, ITransaction.ITransactional, IHisto
      */
     getRange(options?: ICellRange.GetRangeOptions): ICellRange;
     /**
-     * Returns the content of the movable.
+     * Returns the content of the movable: what is drawn at this position.
+     *
+     * @remarks
+     * The content's `getType()` says which interface to read it as:
+     *
+     * | `getType()` | content |
+     * | --- | --- |
+     * | `'picture'` | {@link IPicture} |
+     * | `'chart'` | {@link IChart} |
+     * | `'shape'` | {@link IShape} — text boxes, callouts, connectors and groups |
+     * | `'slicer'` | {@link ISlicer} |
+     * | `'control'` | {@link IControl} — a form control |
+     *
+     * Anything else is content that is positioned and saved but not modeled; it answers
+     * `getType()` and nothing more.
+     *
+     * @example
+     * ```ts
+     * const content = movable.getContent();
+     * if (content.getType() === 'shape') {
+     *   const text = (content as IShape).getTextFrame()?.getText();
+     * }
+     * ```
      */
     getContent<T extends IModel>(): T;
     /**

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

@@ -47,6 +47,8 @@ export interface IMovableCollection extends ICollection<IMovable>, IListener.ISo
      * {@link IListener.ISource.addListeners}
      */
     addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** For runtime type checking. */
+    readonly isIMovableCollection: true;
 }
 /**
  * {@inheritDoc IMovableCollection}

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

@@ -1,7 +1,6 @@
 import { Bounds, Point, ReferenceableClipboard } from '@sheetxl/utils';
 import { IRange } from '@sheetxl/primitives';
 import { IHistory } from '../history';
-import { IListener } from '../listener';
 import { IResource, IResourceCollection } from '../resource';
 import { ITransaction } from '../transaction';
 import { IAnchored } from '../anchored';
@@ -9,14 +8,16 @@ import { IModel } from '../model';
 import { IMovable } from './IMovable';
 import { AbstractAnchored } from '../anchored/AbstractAnchored';
 import { Anchored } from '../anchored/Anchored';
-export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE extends State = State, VIEW extends CommitView = CommitView> extends AbstractAnchored<STATE, VIEW, IMovable.Events> {
+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;
     constructor(options: Movable.ConstructorOptions<J>);
     /** {@inheritDoc IMovable.getContent} */
     getContent(): Movable.Content;
-    protected _processAfterStateChange(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
+    protected _processAfterStateChange(state: STATE, commit: ITransaction.ICommit): void;
     protected _processZIndex(): void;
     protected _processContainerSelect(_selected: boolean, _first: boolean): IRange.Coords | void;
     /** {@inheritDoc IMovable.isSelected} */
@@ -213,9 +214,6 @@ interface State extends AbstractAnchored.State {
     lockAspectRatio?: boolean | null;
     offsets?: MovableOffsets;
     bounds?: Bounds | null;
-    contentListenerRemove: IListener.Remove;
-}
-interface CommitView extends AbstractAnchored.CommitView {
 }
 export {};
 //# sourceMappingURL=Movable.d.ts.map

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

@@ -1,11 +1,11 @@
-import { ICollection } from '../type';
+import { ICollection, AbstractCollection } from '../type';
 import { IListener } from '../listener';
 import { IResource, IResourceCollection } from '../resource';
 import { IMovable } from './IMovable';
 import { IMovableCollection } from './IMovableCollection';
-export declare class MovableCollection implements IMovableCollection {
+export declare class MovableCollection extends AbstractCollection<IMovable, IMovableCollection.GetItemsOptions> implements IMovableCollection {
     private _add;
-    private _getItems;
+    private _getItemsDelegate;
     private _getCount;
     private _updateSelected;
     private _addListeners;
@@ -13,10 +13,8 @@ export declare class MovableCollection implements IMovableCollection {
     constructor(add: (options?: IMovableCollection.AddOptions) => Promise<IMovable>, getItems: (options?: IMovableCollection.GetItemsOptions) => IMovable[], getCount: () => number, updateSelected: (update: (movable: IMovable) => void, action?: string) => void, addListeners: (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove, addPicture: (image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions) => Promise<IMovable>);
     /** {@inheritDoc IMovableCollection.add} */
     add(options?: IMovableCollection.AddOptions): Promise<IMovable>;
-    /** {@inheritDoc ICollection.[Symbol.iterator]} */
-    [Symbol.iterator](): IterableIterator<IMovable>;
-    /** {@inheritDoc IMovableCollection.getItems} */
-    getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
     /** {@inheritDoc IMovableCollection.getCount} */
     getCount(): number;
     /** {@inheritDoc IMovableCollection.updateSelected} */
@@ -25,5 +23,7 @@ export declare class MovableCollection implements IMovableCollection {
     addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
     /** {@inheritDoc IMovableCollection.addPicture */
     addPicture(image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /** {@inheritDoc IMovableCollection.isIMovableCollection} */
+    get isIMovableCollection(): true;
 }
 //# sourceMappingURL=MovableCollection.d.ts.map

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

@@ -1,3 +1,7 @@
+/**
+ * @hidden
+ */
+export * from './IControl';
 export * from './IMovable';
 export * from './IMovableCollection';
 export * from './IMovableSelection';

package/types/src/named/AbstractNamed.d.ts

@@ -13,7 +13,7 @@ export interface State extends AbstractModel.State {
 /**
  * Abstract implementation of `INamed`.
  */
-export declare abstract class AbstractNamed<T, S extends State, VIEW extends AbstractModel.CommitView = AbstractModel.CommitView, EVENTS extends IModel.Events = INamed.Events> extends AbstractModel<S, INamed.JSON, VIEW, EVENTS> implements INamed<T> {
+export declare abstract class AbstractNamed<T, S extends State, EVENTS extends IModel.Events = INamed.Events> extends AbstractModel<S, INamed.JSON, EVENTS> implements INamed<T> {
     /** {@inheritDoc INamed.select} */
     abstract select(options?: ITypes.SelectOptions): Promise<this>;
     /** {@inheritDoc INamed.getRanges} */

package/types/src/named/INamed.d.ts

@@ -67,6 +67,9 @@ export interface INamed<T = any> extends IModel {
      * A reference to a *part* of this item that the given coords designate exactly, or `null`.
      *
      * @param coords The coords to match, sheet-qualified (`scope`) and in row-first order.
+     * @param home The cell of the formula the reference is for, when there is one. A reference can be
+     *   written relative to it: `Sales[@Amount]` for a table cell in the formula's own row, and from
+     *   inside the table `[@Amount]` and `[Amount]`.
      *
      * @remarks
      * * Optional
@@ -79,7 +82,7 @@ export interface INamed<T = any> extends IModel {
      * Implemented by whatever owns the parts (a table), so the collection stays out of the business
      * of knowing what kinds of items have insides.
      */
-    getPartReference?(coords: readonly IRange.Coords[]): string | null;
+    getPartReference?(coords: readonly IRange.Coords[], home?: IRange.CellCoords | null): string | null;
     /**
      * If true then the name is not visible.
      *

package/types/src/named/INamedCollection.d.ts

@@ -1,3 +1,4 @@
+import { IRange } from '@sheetxl/primitives';
 import { ICollection } from '../type';
 import { IListener } from '../listener';
 import { ICellRanges } from '../cellRange';
@@ -152,6 +153,21 @@ export declare namespace INamedCollection {
          * single definition, and a listener that re-reads the collection is the intended response.
          */
         onCollectionChange?(source: INamedCollection): void;
+        /**
+         * Called when an undo or a redo has moved what this collection presents, and a consumer holding
+         * it needs to re-read.
+         *
+         * @remarks
+         * Separate from {@link onCollectionChange} because a restore is not a write, and some listeners
+         * treat the two very differently: the calculation engine recalculates on a change, and firing
+         * that for a restore would recalculate a second time on top of the one the restore already did.
+         * A consumer rendering a LIST wants both, and subscribes to both.
+         *
+         * A derived name is what makes this necessary. A table's name is read back off the table rather
+         * than stored here, so an undo of a rename moves no state of this collection's and a
+         * change-only listener hears nothing.
+         */
+        onInvalidated?(source: INamedCollection): void;
         /**
          * Transaction items have a close event.
          */
@@ -225,6 +241,16 @@ export declare namespace INamedCollection {
          * the same region.
          */
         includeParts?: boolean;
+        /**
+         * The cell of the formula a part reference is for.
+         *
+         * @remarks
+         * Only read with `includeParts`. A table cell in the formula's own row is a this-row reference
+         * (`Sales[@Amount]`), and inside the table a single column drops the table name (`[Amount]`,
+         * `[@Amount]`). Without it every part is qualified (`Sales[Amount]`) and a row's cells are
+         * addresses.
+         */
+        home?: IRange.CellCoords | null;
     }
 }
 //# sourceMappingURL=INamedCollection.d.ts.map