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

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/AbstractMovableContent.d.ts

@@ -0,0 +1,182 @@
+import { IRange } from '@sheetxl/primitives';
+import { AbstractModel, IModel } from '../model';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { ICalculation } from '../calculation/ICalculation';
+import { IStyleCollection } from '../style';
+import { IMovable } from './IMovable';
+/**
+ * What every content shares: its name, its description, the movable that places it, and the
+ * cells it names.
+ *
+ * @remarks
+ * A kind that names cells - a chart's series, a control's linked cell - hands each formula to
+ * {@link _addWatch} and keeps the handle. The base does the rest: {@link getReferences} is the
+ * union of what the engine holds for every watch, {@link IMovable.ContentEvents.onReferencesChange}
+ * is announced each time the engine rewrites one, a delete releases every watch inside its own
+ * commit, and an undone delete holds them again. A kind with nothing to name calls nothing.
+ */
+export declare abstract class AbstractMovableContent<STATE extends AbstractMovableContent.State = AbstractMovableContent.State, JSON extends any = any, EVENTS extends IMovable.ContentEvents = IMovable.ContentEvents> extends AbstractModel<STATE, JSON, EVENTS> implements IMovable.IContent {
+    /** Numbers the default names: `Chart 3`. */
+    static instanceCounter: number;
+    private _getMovable;
+    private _addWatchOption;
+    private _getRangeOption;
+    private _watches;
+    /** The watches are out of the engine because the content is deleted; a restore holds them again. */
+    private _watchesReleased;
+    constructor(options: AbstractMovableContent.ConstructorOptions<JSON>);
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    abstract getTypeDescription(): string;
+    /** {@inheritDoc IMovable.IContent.getName} */
+    getName(): string | null;
+    /** {@inheritDoc IMovable.IContent.setName} */
+    setName(name: string): this;
+    /** {@inheritDoc IMovable.IContent.getDescription} */
+    getDescription(): string | null;
+    /** {@inheritDoc IMovable.IContent.setDescription} */
+    setDescription(description: string | null): this;
+    /** {@inheritDoc IMovable.IContent.getMovable} */
+    getMovable(): IMovable | null;
+    /** {@inheritDoc IMovable.IContent.getReferences} */
+    getReferences(): ICellRanges | null;
+    /**
+     * Hands a formula the content names to the calculation engine, which keeps its references on
+     * the cells they name through inserts, deletes, cuts, sheet renames and undo.
+     *
+     * @param formula The expression, or a formula - the one a watch delivered before, when the
+     *                content holds again what it had.
+     * @param callback Receives the engine's formula once it holds the body, and again after every
+     *                 change to its text; `event.formula.getExpression()` is the text as it reads now.
+     * @param options Where a relative endpoint is authored, and whether the body is evaluated.
+     *
+     * @returns Removes the watch. The handle is the watch's identity: a kind that maps a watch to a
+     *          field of its JSON keeps its own handle-to-field map.
+     *
+     * @remarks
+     * Without the seam (content outside a workbook) nothing is held: the callback is never called,
+     * and {@link getReferences} resolves the expression as given.
+     * @internal
+     */
+    protected _addWatch(formula: ICalculation.IFormula | string, callback?: (event: AbstractMovableContent.WatchEvent) => void, options?: AbstractMovableContent.WatchOptions): IListener.Remove;
+    /** The range `address` names in the content's workbook, or `null` when it names none or there is no workbook. @internal */
+    protected _resolveRange(address: string): ICellRange | null;
+    private _hold;
+    /**
+     * `expression` as one plain reference, for a content the engine holds nothing for. A bare
+     * address is on the content's own sheet.
+     */
+    private _parseReference;
+    private _notifyReferencesChange;
+    /** Inside the delete's own commit, so an undo brings the references back with the content. */
+    private _releaseWatches;
+    /** From what each watch last read: the formula the engine delivered, else the text as given. */
+    private _holdWatches;
+    /** @internal */
+    protected _processDelete(): void;
+    /** @internal */
+    protected _processRestoreOrRevert(state: STATE, commit: ITransaction.ICommit): void;
+    /**
+     * The id the file gave this content (`cNvPr/@id`), which a connector's glued ends name it by;
+     * `undefined` for content that has none yet. Kept on the content's `data`; a kind that keeps it
+     * elsewhere overrides this and {@link _ensureSourceId} together.
+     * @internal
+     */
+    _getSourceId(): number | undefined;
+    /**
+     * The id the file writes this content with, taking one from `next` when it has none yet: what a
+     * connector's end names it by, written as part of the open operation.
+     * @internal
+     */
+    _ensureSourceId(next: () => number): number;
+    /** @internal */
+    protected _protectionCheck(description: string): void;
+}
+/**
+ * Interfaces for creating movable content.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link AbstractMovableContent}
+ */
+export declare namespace AbstractMovableContent {
+    interface State extends AbstractModel.State {
+        name?: string | null;
+        description?: string | null;
+    }
+    /**
+     * What a watch delivers: see {@link ConstructorOptions.addWatch}.
+     */
+    interface WatchEvent {
+        /**
+         * The formula as the engine holds it. Its expression is the text as it reads now; its
+         * references are the cells it names now.
+         */
+        formula: ICalculation.IFormula;
+        /**
+         * The body's values, for a watch that evaluates ({@link WatchOptions.evaluate}).
+         */
+        values?: IRange;
+    }
+    /**
+     * Options for {@link ConstructorOptions.addWatch}.
+     */
+    interface WatchOptions {
+        /**
+         * Evaluate the body and deliver its values after every pass that changed them. Off, the
+         * watch is a hold: the body demands its first cell only, so holding a reference to a column
+         * costs one read a pass, not the column.
+         *
+         * @defaultValue `false`
+         */
+        evaluate?: boolean;
+        /**
+         * Where a relative endpoint of the formula is authored.
+         *
+         * @defaultValue The content's anchor top-left when the watch registers.
+         */
+        origin?: IRange.CellCoords;
+    }
+    /**
+     * Hands a formula the content names to the calculation engine; see
+     * {@link ConstructorOptions.addWatch}.
+     */
+    type AddWatch = (formula: ICalculation.IFormula | string, callback: (event: WatchEvent) => void, options?: WatchOptions) => IListener.Remove;
+    interface ConstructorOptions<J> extends IModel.ConstructorOptions<J> {
+        /**
+         * The name. Content that a movable places is given one when this is empty.
+         */
+        name?: string | null;
+        /**
+         * The alternative text.
+         */
+        description?: string | null;
+        /**
+         * Returns the movable that places the content. Not provided for content that has none.
+         */
+        getMovable?: () => IMovable | null;
+        /**
+         * Returns the styles the content's theme references resolve against. Not provided for
+         * content outside a workbook.
+         */
+        getStyles?: () => IStyleCollection | null;
+        /**
+         * Hands a formula the content names to the calculation engine, which keeps its references
+         * on the cells they name through inserts, deletes, cuts, sheet renames and undo, and calls
+         * back with the formula each time its text changes. The same contract as
+         * {@link ICellRanges.addWatch} without the range: a content has no location its formulas are
+         * evaluated over, only its anchor.
+         *
+         * Not provided for content outside a workbook; its references then read as set.
+         */
+        addWatch?: AddWatch;
+        /**
+         * Resolves an address against the workbook the content lives in. Not provided for content
+         * outside a workbook.
+         */
+        getRange?: (address: string) => ICellRange | null;
+    }
+}
+//# sourceMappingURL=AbstractMovableContent.d.ts.map

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

@@ -1,17 +1,16 @@
 import { IResource, IResourceCollection } from '../resource';
-import { IModel, AbstractModel } from '../model';
 import { ICustomElement } from './ICustomElement';
-interface State extends AbstractModel.State {
+import { AbstractMovableContent } from './AbstractMovableContent';
+interface State extends AbstractMovableContent.State {
     data?: any;
     type: string;
 }
 /**
  * Implementation for {@link ICustomElement}.
  */
-export declare class CustomElement extends AbstractModel<State, ICustomElement.JSON> implements ICustomElement {
+export declare class CustomElement extends AbstractMovableContent<State, ICustomElement.JSON> implements ICustomElement {
     constructor(options: CustomElement.ConstructorOptions);
     getType(): string;
-    getDescription(): string;
     toJSON(_toResourceId?: (resource: IResource) => number | null): ICustomElement.JSON | null;
     getTypeDescription(): string;
 }
@@ -27,7 +26,7 @@ export declare namespace CustomElement {
     /**
      * Options for creating a Custom Element.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<ICustomElement.JSON> {
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<ICustomElement.JSON> {
         /**
          * Returns an IResource from the resourceId or null if not found.
          */

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

@@ -0,0 +1,49 @@
+import { IErrorContent } from './IErrorContent';
+import { CustomElement } from './CustomElement';
+/**
+ * Implementation for {@link IErrorContent}: the content's JSON as it was read, kept for the save,
+ * and the reason the content could not be made.
+ */
+export declare class ErrorContent extends CustomElement implements IErrorContent {
+    private readonly _error;
+    private readonly _originalType;
+    constructor(options: ErrorContent.ConstructorOptions);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc IErrorContent.getError} */
+    getError(): unknown;
+    /** {@inheritDoc IErrorContent.getOriginalType} */
+    getOriginalType(): string;
+    /**
+     * The type the movable saves this content under: the original, so a save writes back what was
+     * read.
+     * @internal
+     */
+    _getSavedType(): string;
+    /** {@inheritDoc IModel.isReadOnly} */
+    isReadOnly(): boolean;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc IErrorContent.isIErrorContent} */
+    get isIErrorContent(): true;
+}
+/**
+ * Interfaces for creating `ErrorContent`.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link ErrorContent}
+ */
+export declare namespace ErrorContent {
+    /**
+     * Options for creating an error content.
+     */
+    interface ConstructorOptions extends CustomElement.ConstructorOptions {
+        /** The type of the content that could not be made. */
+        type: string;
+        /** Why it could not be made. */
+        error: unknown;
+    }
+}
+//# sourceMappingURL=ErrorContent.d.ts.map

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

@@ -0,0 +1,285 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ITransaction } from '../transaction';
+import { IResource } from '../resource';
+import { ICellRange } from '../cellRange';
+import { IFormControl, ICaptioned, ILinked, IButton, ICheckBox, IOptionButton, IGroupBox, ILabel, IRangedControl, IScrollBar, ISpinner, IListControl, IListBox, IDropDown } from './IFormControl';
+import { AbstractMovableContent } from './AbstractMovableContent';
+/** The fields that name cells: held by the engine, so they follow the cells they name. */
+declare const REFERENCE_FIELDS: readonly ["linkedCell", "listFillRange"];
+type ReferenceField = typeof REFERENCE_FIELDS[number];
+interface State<J extends IFormControl.JSON> extends AbstractMovableContent.State {
+    data?: J;
+}
+/**
+ * Implementation for {@link IFormControl}: what every kind shares. On its own it is the kinds with
+ * nothing of their own (edit box, dialog, and a kind this version does not know), told apart by
+ * the type they are created with.
+ */
+export declare class FormControl<J extends IFormControl.JSON = IFormControl.JSON> extends AbstractMovableContent<State<J>, J> implements IFormControl {
+    private readonly _type;
+    private readonly _typeDescription;
+    /**
+     * Every reference ever set on a field, one per text. A reference no field reads is released
+     * but kept: its formula still reads the engine's grid, which an undo brings back with the value
+     * it puts back, so the field answers right away and the reference is held again from it.
+     */
+    private readonly _references;
+    constructor(options: FormControl.ConstructorOptions<J>);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc IFormControl.getShapeId} */
+    getShapeId(): number | null;
+    /** A control's twin is numbered by the control's shape id, as Excel numbers it. @internal */
+    _getSourceId(): number | undefined;
+    /** @internal */
+    _ensureSourceId(next: () => number): number;
+    /** {@inheritDoc IFormControl.getMacro} */
+    getMacro(): string | null;
+    /** {@inheritDoc IFormControl.setMacro} */
+    setMacro(macro: string | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc Movable.Content.toJSON} */
+    toJSON(_toResourceId?: (resource: IResource) => number | null): J | null;
+    /** {@inheritDoc IFormControl.isIFormControl} */
+    get isIFormControl(): true;
+    protected _data(): J | null;
+    /**
+     * A reference field as it reads now: the engine's copy once something has moved the cells it
+     * names, else the text as set.
+     */
+    protected _reference(field: ReferenceField): string | null;
+    /**
+     * The range a reference names — by default the linked cell — or `null` when there is none or
+     * it no longer resolves. An unqualified reference is on the control's own sheet.
+     */
+    protected _linkedRange(address?: string | null): ICellRange | null;
+    /** The linked cell's value, or `undefined` when the control mirrors none. */
+    protected _linkedValue(): Scalar | undefined;
+    /**
+     * The fields of the control's state as its linked cell says them, or `null` when it mirrors
+     * none. A field answered `undefined` is cleared.
+     */
+    protected _linkedState(): Partial<J> | null;
+    private _referenceOf;
+    /**
+     * Brings the watches in line with the reference fields: what a field reads is held, what no
+     * field reads any more is released.
+     */
+    private _reconcileReferences;
+    /** Held from the engine's own formula when it has one, so a reference an undo put back is held as it reads now. */
+    private _watch;
+    /** @internal */
+    protected _processRestoreOrRevert(state: State<J>, commit: ITransaction.ICommit): void;
+    /**
+     * Writes fields into the control's data as one operation. A field set to `undefined` is
+     * removed, so the JSON only ever says what differs from the default.
+     */
+    protected _set(fields: Partial<J>, message: string, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * The kinds that show text ({@link ICaptioned}): a button, a group box, a label.
+ */
+export declare abstract class CaptionedControl<J extends IFormControl.JSON & ICaptioned.JSON> extends FormControl<J> implements ICaptioned {
+    /** {@inheritDoc ICaptioned.getCaption} */
+    getCaption(): string | null;
+    /** {@inheritDoc ICaptioned.setCaption} */
+    setCaption(caption: string | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICaptioned.getFont} */
+    getFont(): ICaptioned.Font | null;
+}
+/**
+ * The kinds a cell mirrors ({@link ILinked}) that show no text: scroll bars, spinners, lists.
+ */
+export declare abstract class LinkedControl<J extends IFormControl.JSON & ILinked.JSON> extends FormControl<J> implements ILinked {
+    /** {@inheritDoc ILinked.getLinkedCell} */
+    getLinkedCell(): string | null;
+    /** {@inheritDoc ILinked.getLinkedRange} */
+    getLinkedRange(): ICellRange | null;
+    /** {@inheritDoc ILinked.setLinkedCell} */
+    setLinkedCell(address: string | null, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * The kinds that both show text and are mirrored by a cell: a check box, an option button.
+ */
+export declare abstract class CaptionedLinkedControl<J extends IFormControl.JSON & ICaptioned.JSON & ILinked.JSON> extends CaptionedControl<J> implements ILinked {
+    /** {@inheritDoc ILinked.getLinkedCell} */
+    getLinkedCell(): string | null;
+    /** {@inheritDoc ILinked.getLinkedRange} */
+    getLinkedRange(): ICellRange | null;
+    /** {@inheritDoc ILinked.setLinkedCell} */
+    setLinkedCell(address: string | null, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * Implementation for {@link IButton}.
+ */
+export declare class Button extends CaptionedControl<IButton.JSON> implements IButton {
+    constructor(options: FormControl.KindOptions<IButton.JSON>);
+}
+/**
+ * Implementation for {@link IGroupBox}.
+ */
+export declare class GroupBox extends CaptionedControl<IGroupBox.JSON> implements IGroupBox {
+    constructor(options: FormControl.KindOptions<IGroupBox.JSON>);
+}
+/**
+ * Implementation for {@link ILabel}.
+ */
+export declare class Label extends CaptionedControl<ILabel.JSON> implements ILabel {
+    constructor(options: FormControl.KindOptions<ILabel.JSON>);
+}
+/**
+ * Implementation for {@link ICheckBox}.
+ */
+export declare class CheckBox extends CaptionedLinkedControl<ICheckBox.JSON> implements ICheckBox {
+    constructor(options: FormControl.KindOptions<ICheckBox.JSON>);
+    /** {@inheritDoc ICheckBox.isChecked} */
+    isChecked(): boolean;
+    /** {@inheritDoc ICheckBox.setChecked} */
+    setChecked(checked: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICheckBox.isMixed} */
+    isMixed(): boolean;
+    /** {@inheritDoc ICheckBox.setMixed} */
+    setMixed(mixed: boolean, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    protected _linkedState(): Partial<ICheckBox.JSON> | null;
+}
+/**
+ * Implementation for {@link IOptionButton}.
+ */
+export declare class OptionButton extends CaptionedLinkedControl<IOptionButton.JSON> implements IOptionButton {
+    constructor(options: FormControl.KindOptions<IOptionButton.JSON>);
+    /**
+     * {@inheritDoc ILinked.getLinkedCell}
+     *
+     * @remarks
+     * A group has one linked cell, written on its first button; every button in the group answers
+     * it.
+     */
+    getLinkedCell(): string | null;
+    /** {@inheritDoc IOptionButton.isChecked} */
+    isChecked(): boolean;
+    /** {@inheritDoc IOptionButton.setChecked} */
+    setChecked(checked: boolean, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    protected _linkedState(): Partial<IOptionButton.JSON> | null;
+    /** The link this button carries itself, shifted as it reads now. */
+    private _ownLinkedCell;
+    /**
+     * The buttons of this one's group, in sheet order: a group runs from a button marked as its
+     * first (`firstButton`, as the file marks it) to the next, and the buttons before any mark are
+     * one group.
+     */
+    private _group;
+}
+/**
+ * What {@link ScrollBar} and {@link Spinner} share.
+ */
+export declare abstract class RangedControl<J extends IRangedControl.JSON> extends LinkedControl<J> implements IRangedControl {
+    /** {@inheritDoc IRangedControl.getValue} */
+    getValue(): number | null;
+    /** {@inheritDoc IRangedControl.setValue} */
+    setValue(value: number | null, options?: ITransaction.OperationOptions): this;
+    /**
+     * @internal
+     * The cell's number, held to the control's range as Excel holds it; anything else leaves the
+     * value as stored.
+     */
+    protected _linkedState(): Partial<J> | null;
+    /** {@inheritDoc IRangedControl.getMin} */
+    getMin(): number | null;
+    /** {@inheritDoc IRangedControl.setMin} */
+    setMin(min: number | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IRangedControl.getMax} */
+    getMax(): number | null;
+    /** {@inheritDoc IRangedControl.setMax} */
+    setMax(max: number | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IRangedControl.getIncrement} */
+    getIncrement(): number | null;
+    /** {@inheritDoc IRangedControl.setIncrement} */
+    setIncrement(increment: number | null, options?: ITransaction.OperationOptions): this;
+}
+/**
+ * Implementation for {@link IScrollBar}.
+ */
+export declare class ScrollBar extends RangedControl<IScrollBar.JSON> implements IScrollBar {
+    constructor(options: FormControl.KindOptions<IScrollBar.JSON>);
+    /** {@inheritDoc IScrollBar.getPageIncrement} */
+    getPageIncrement(): number | null;
+    /** {@inheritDoc IScrollBar.setPageIncrement} */
+    setPageIncrement(increment: number | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IScrollBar.isHorizontal} */
+    isHorizontal(): boolean;
+    /** {@inheritDoc Movable.Content.toJSON} */
+    toJSON(toResourceId?: (resource: IResource) => number | null): IScrollBar.JSON | null;
+}
+/**
+ * Implementation for {@link ISpinner}.
+ */
+export declare class Spinner extends RangedControl<ISpinner.JSON> implements ISpinner {
+    constructor(options: FormControl.KindOptions<ISpinner.JSON>);
+}
+/**
+ * What {@link ListBox} and {@link DropDown} share.
+ */
+export declare abstract class ListControl<J extends IListControl.JSON> extends LinkedControl<J> implements IListControl {
+    /** {@inheritDoc IListControl.getItems} */
+    getItems(): readonly string[];
+    /** {@inheritDoc IListControl.setItems} */
+    setItems(items: readonly string[], options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IListControl.getListItems} */
+    getListItems(): readonly string[];
+    /** {@inheritDoc IListControl.getListFillRange} */
+    getListFillRange(): string | null;
+    /** {@inheritDoc IListControl.getListSourceRange} */
+    getListSourceRange(): ICellRange | null;
+    /** {@inheritDoc IListControl.setListFillRange} */
+    setListFillRange(address: string | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IListControl.getSelectedIndex} */
+    getSelectedIndex(): number | null;
+    /** {@inheritDoc IListControl.setSelectedIndex} */
+    setSelectedIndex(index: number | null, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    protected _linkedState(): Partial<J> | null;
+}
+/**
+ * Implementation for {@link IListBox}.
+ */
+export declare class ListBox extends ListControl<IListBox.JSON> implements IListBox {
+    constructor(options: FormControl.KindOptions<IListBox.JSON>);
+}
+/**
+ * Implementation for {@link IDropDown}.
+ */
+export declare class DropDown extends ListControl<IDropDown.JSON> implements IDropDown {
+    constructor(options: FormControl.KindOptions<IDropDown.JSON>);
+    /** {@inheritDoc IDropDown.getDropStyle} */
+    getDropStyle(): IDropDown.DropStyle | null;
+    /** {@inheritDoc IDropDown.getDropLines} */
+    getDropLines(): number | null;
+}
+/**
+ * Interfaces for creating form controls.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link FormControl}
+ */
+export declare namespace FormControl {
+    /**
+     * Options for creating a kind of form control, which knows its own type.
+     */
+    type KindOptions<J extends IFormControl.JSON> = AbstractMovableContent.ConstructorOptions<J>;
+    /**
+     * Options for creating a form control of a kind with nothing of its own.
+     */
+    interface ConstructorOptions<J extends IFormControl.JSON> extends KindOptions<J> {
+        /** The content type ({@link IFormControl.Type}). */
+        type: string;
+        /** What the kind is called to a person: `Edit Box`. */
+        typeDescription?: string;
+    }
+}
+export {};
+//# sourceMappingURL=FormControl.d.ts.map

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

@@ -0,0 +1,87 @@
+import { Bounds } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { IAnchored } from '../anchored';
+import { IMovable } from './IMovable';
+import { Movable } from './Movable';
+/**
+ * A movable inside a group.
+ *
+ * @remarks
+ * Its container is the group, not the canvas. What it keeps is its placement in the group's
+ * child space, as the file states it; what it answers is where it is drawn, through the mapping
+ * the group handed it when it was made, and what it is told is where it is drawn, taken back
+ * through the inverse. The cells it is over are its root's, and so is its protection. Its
+ * z-order is its place among the group's members.
+ */
+export declare class GroupMember extends Movable {
+    protected _optionsMember: GroupMember.ConstructorOptions;
+    constructor(options: GroupMember.ConstructorOptions);
+    /** {@inheritDoc IMovable.getParent} */
+    getParent(): IMovable | null;
+    /** {@inheritDoc IMovable.getRange} */
+    getRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc IAnchored.getRanges} */
+    getRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc IAnchored.isDeleted} */
+    isDeleted(): boolean;
+    /** {@inheritDoc IAnchored.getAnchorType} */
+    getAnchorType(): IAnchored.Type;
+    /**
+     * {@inheritDoc IMovable.setAnchorType}
+     *
+     * @remarks
+     * A member is placed in its group's child space, where there are no cells to anchor to; the
+     * group's own movable takes the anchor type. Nothing changes.
+     */
+    setAnchorType(_type: IAnchored.Type): this;
+    /**
+     * The placement kept: in the child space of the group that holds this member.
+     * @internal
+     */
+    _getLocalPlacement(): Movable.Placement | null;
+    /** Where the member is drawn; `null` before it or its group is laid out. */
+    private _getDrawnPlacement;
+    /** {@inheritDoc IMovable.getBounds} */
+    getBounds(): Bounds | null;
+    /** {@inheritDoc IMovable.getRotation} */
+    getRotation(): number;
+    /** {@inheritDoc IMovable.getFlip} */
+    getFlip(): IMovable.Flip;
+    /**
+     * {@inheritDoc IMovable.setRotation}
+     *
+     * @remarks
+     * The member keeps the size it is drawn at, as Excel keeps it: under an uneven scale a turn
+     * into or out of a quarter turn restates its frame in the child space with the other factors.
+     * The group fits itself to its members afterwards.
+     */
+    setRotation(rotation?: number): this;
+    /** {@inheritDoc IMovable.setFlip} */
+    setFlip(flip: Partial<IMovable.Flip>, options?: ITransaction.OperationOptions): this;
+    /** The box the member occupies as drawn, as rotated. */
+    protected _getAnchorBounds(): Bounds | null;
+    protected _setAnchorBounds(anchorBounds: Bounds): void;
+    /** Where the member is drawn changed: no cells to find again, only listeners to tell. */
+    protected _processContainerLayout(): void;
+    protected _fromJSON(json: IMovable.JSON): void;
+    /** @internal */
+    _getAnchorJSON(): IMovable.AnchorOffset;
+    toJSON(toResourceId?: Parameters<Movable['toJSON']>[0]): IMovable.JSON;
+}
+export declare namespace GroupMember {
+    interface ConstructorOptions extends Movable.ConstructorOptions {
+        /** The movable of the group that holds this member. */
+        getParent: () => IMovable;
+        /**
+         * Where a placement in the group's child space is drawn; `null` while the group is not laid
+         * out.
+         */
+        place: (local: Movable.Placement) => Movable.Placement | null;
+        /** The placement in the child space that is drawn at `drawn`; `null` as {@link place}. */
+        unplace: (drawn: Movable.Placement) => Movable.Placement | null;
+        /** The member's frame or rotation changed, as part of the open operation: the group refits. */
+        onMemberPlacementChange?: () => void;
+    }
+}
+//# sourceMappingURL=GroupMember.d.ts.map