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

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

@@ -5,7 +5,6 @@ import { IResource, IResourceCollection } from '../resource';
 import { IListener } from '../listener';
 import { ICellRange } from '../cellRange';
 import { IMovable } from './IMovable';
-import { ITransaction } from '../transaction';
 /**
  * Holds a collection of IMovables.
  */
@@ -40,6 +39,19 @@ export interface IMovableCollection extends ICollection<IMovable>, IListener.ISo
      * @returns A Promise that will resolve to the new Movable.
      */
     addPicture(picture: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /**
+     * Groups movables of this collection into one: a new movable whose content is an `IGroup`
+     * holding them as members, in their z-order, at the union of the boxes they occupy.
+     *
+     * @param movables Two or more movables of this collection.
+     * @param options {@link IMovableCollection.GroupOptions}
+     * @returns The group's movable.
+     *
+     * @remarks
+     * One undo step. The group's child space equals its frame, so each member keeps the size it
+     * had. `IGroup.ungroup` is the inverse.
+     */
+    group(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
     /**
      * Add Listeners.
      *
@@ -47,6 +59,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}
@@ -84,11 +98,45 @@ export declare namespace IMovableCollection {
          * @defaultValue false
          */
         fullyContained?: boolean;
+        /**
+         * Also return the members of every group found, each after its group, nested groups
+         * included. The type filter applies to members too.
+         * @defaultValue false
+         */
+        deep?: boolean;
+        /**
+         * Match {@link address} against what each movable paints rather than the cells it is anchored
+         * to: its rotation, a drawing that reaches outside its frame (a callout's tail) and its line.
+         * Use it to find the movables visible in a range.
+         *
+         * @remarks
+         * A shape's drawing is known once its geometry has been evaluated, which the search starts;
+         * until then it is matched by its frame, and the collection notifies a change when the answer
+         * is ready. Ignored with {@link fullyContained}.
+         * @defaultValue false
+         */
+        drawn?: boolean;
+    }
+    /**
+     * Options for {@link IMovableCollection.group}.
+     */
+    interface GroupOptions extends IMovable.OperationOptions {
+        /**
+         * The name of the group.
+         *
+         * @defaultValue A name made from the type, such as `Group 3`.
+         */
+        name?: string;
+        /**
+         * Whether the group is selected once made.
+         * @defaultValue true
+         */
+        autoSelect?: boolean | IMovable.SelectOptions;
     }
     /**
      * Options for adding a movable to the collection.
      */
-    interface AddOptions<J = any> extends ITransaction.OperationOptions {
+    interface AddOptions<J = any> extends IMovable.OperationOptions {
         /**
          * The type of movable to add.
          */
@@ -97,6 +145,12 @@ export declare namespace IMovableCollection {
          * Initial json value.
          */
         json?: J;
+        /**
+         * The name of the content.
+         *
+         * @defaultValue A name made from the type, such as `Chart 3`.
+         */
+        name?: string;
         /**
          * If a referenceId is provided then the movable will be linked to the resource.
          * @param resourceId
@@ -104,12 +158,18 @@ export declare namespace IMovableCollection {
          */
         fromResourceId?: (resourceId: number) => IResource;
         /**
-         * The boundary for the movable object in pixels.
+         * The movable's unrotated frame in pixels (see {@link IMovable.getBounds}).
          */
         bounds?: Partial<Bounds>;
+        /**
+         * The rotation in degrees, clockwise about the frame's center.
+         *
+         * @defaultValue 0
+         */
+        rotation?: number;
         /**
          * Placement hint used only when {@link bounds} is omitted. `'viewport'` centers the (default-sized)
-         * movable in the visible viewport via {@link ISheet.IListeners.onRequestViewport}, falling back to the
+         * movable in the visible viewport via {@link IWorksheet.IListeners.onRequestViewport}, falling back to the
          * default cursor placement when no viewport responds (headless). Omit ⇒ default cursor placement.
          */
         autoPlace?: 'viewport';

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

@@ -1,27 +1,72 @@
 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';
-import { IModel } from '../model';
+import { ICellRanges } from '../cellRange';
 import { IMovable } from './IMovable';
+import { IMovableCollection } from './IMovableCollection';
+import { IMovableSelection } from '../selection';
 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> {
-    static instanceCounter: number;
+export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE extends State = State> extends AbstractAnchored<STATE, IMovable.Events> {
     protected _content: Movable.Content;
-    private _optionsMovable;
+    /** Set while someone waits on {@link whenContentLoaded}; settled by {@link _replaceContent}. */
+    private _contentLoaded;
+    protected _optionsMovable: Movable.ConstructorOptions<J>;
     constructor(options: Movable.ConstructorOptions<J>);
     /** {@inheritDoc IMovable.getContent} */
-    getContent(): Movable.Content;
-    protected _processAfterStateChange(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
+    getContent<T extends IMovable.IContent = IMovable.IContent>(): T;
+    /** {@inheritDoc IMovable.getReferences} */
+    getReferences(): ICellRanges | null;
+    /** {@inheritDoc IMovable.isContentLoaded} */
+    isContentLoaded(): boolean;
+    /** The type the content is saved and copied as: an error content's is the one that failed. */
+    private _savedType;
+    /** {@inheritDoc IMovable.whenContentLoaded} */
+    whenContentLoaded(): Promise<IMovable.IContent>;
+    /**
+     * Puts the loaded content in place of the stand-in, or settles the wait with the stand-in when
+     * the load failed (`content` is `null`).
+     * @internal
+     */
+    _replaceContent(content: Movable.Content | null): void;
+    /** {@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;
+    /**
+     * Every movable the content holds is drawn elsewhere: this movable moved, turned, mirrored or
+     * resized, or the content's child space changed. Each member is told as a movable on a sheet is
+     * told its rows changed size; a member that holds movables tells on.
+     * @internal
+     */
+    _forwardLayout(): void;
+    /**
+     * Where this movable, or something in it, is drawn changed as part of the open operation, so
+     * whatever is placed relative to it can follow in the same operation. A movable nobody listens
+     * to tells the movable that holds it, which is drawn as a whole.
+     * @internal
+     */
+    _notifyPlacementChange(translated?: boolean): void;
     protected _processZIndex(): void;
     protected _processContainerSelect(_selected: boolean, _first: boolean): IRange.Coords | void;
+    /**
+     * The view's selection changed for this movable. The sheet reaches a root through the callbacks
+     * it holds for it and a member of a group through this.
+     * @internal
+     */
+    _processSelection(selected: boolean, first: boolean): IRange.Coords | void;
+    /** The selection of the view of the sheet this movable is on; `null` before it is placed. */
+    protected _viewSelection(): IMovableSelection | null;
     /** {@inheritDoc IMovable.isSelected} */
     isSelected(): boolean;
-    /** {@inheritDoc IMovable.isSelected} */
+    /** {@inheritDoc IMovable.scrollIntoView} */
     scrollIntoView(options?: globalThis.ScrollIntoViewOptions | boolean): Promise<boolean>;
     /** {@inheritDoc IMovable.select} */
     select(options?: IMovable.SelectOptions): Promise<boolean>;
@@ -30,21 +75,18 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     protected _clone(): Movable;
     /** {@inheritDoc IHistory.ISnapshotSource.getSnapshot} */
     getSnapshot(bounds: Bounds, options?: ReferenceableClipboard.CopyOptions): IHistory.ISnapshot<IMovable.SnapshotDestination, IMovable, Bounds>;
-    protected _doCopy(destination: IMovable.SnapshotDestination, options?: IMovable.CopyOptions): Promise<void>;
+    /**
+     * Places a copy of this movable in `destination`, inside the caller's transaction: the kind is
+     * loaded already (the snapshot's `prepare`), and the bounds are given, so there is nothing to wait
+     * for.
+     */
+    protected _doCopy(destination: IMovable.SnapshotDestination, options?: IMovable.CopyOptions): void;
     /** For easy overriding in subclass to implement ISnapshot */
     protected _toText(): Promise<string> | string;
     /** For easy overriding in subclass to implement ISnapshot */
     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} */
@@ -53,10 +95,28 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     setLockAspectRatio(lockAspectRatio: boolean): this;
     /** {@inheritDoc IMovable.isLockAspectRatio} */
     isLockAspectRatio(): boolean;
+    /** {@inheritDoc IMovable.setPrintObject} */
+    setPrintObject(printObject: boolean): this;
+    /** {@inheritDoc IMovable.isPrintObject} */
+    isPrintObject(): boolean;
+    /** What the content says when the movable states no aspect lock of its own. */
+    protected _isDefaultLockAspectRatio(): boolean;
+    /** {@inheritDoc IMovable.getConnectionSites} */
+    getConnectionSites(placement?: IMovable.PlacementPreview): IMovable.ConnectionSite[] | null;
+    /** {@inheritDoc IMovable.getGluedConnectors} */
+    getGluedConnectors(): IMovable[];
     /** {@inheritDoc IMovable.setRotation} */
     setRotation(rotation?: number): this;
     /** {@inheritDoc IMovable.getRotation} */
     getRotation(): number;
+    /** {@inheritDoc IMovable.setFlip} */
+    setFlip(flip: Partial<IMovable.Flip>, options?: ITransaction.OperationOptions): this;
+    /** The rotation the content takes for `rotation`, or `null` when it cannot be turned. */
+    protected _acceptRotation(rotation: number): number | null;
+    /** The flip the content takes for `flip`, or `null` when it cannot be mirrored. */
+    protected _acceptFlip(flip: IMovable.Flip): IMovable.Flip | null;
+    /** {@inheritDoc IMovable.getFlip} */
+    getFlip(): IMovable.Flip;
     /** {@inheritDoc IMovable.moveToBack} */
     moveToBack(): this;
     /** {@inheritDoc IMovable.moveBackward} */
@@ -69,19 +129,62 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     getZIndex(): number;
     /** {@inheritDoc IMovable.setBounds} */
     setBounds(bounds: Partial<Bounds>, options?: ITransaction.OperationOptions): this;
+    /**
+     * Places the movable so that the box it occupies on the sheet as rotated is `anchorBounds`.
+     */
+    protected _setAnchorBounds(anchorBounds: Bounds): void;
     private _updateMovableLocation;
     private _calcAbsoluteBounds;
     /** {@inheritDoc IMovable.getBounds} */
     getBounds(): Bounds | null;
+    /** {@inheritDoc IMovable.getParent} */
+    getParent(): IMovable | null;
+    /** {@inheritDoc IMovable.getMovables} */
+    getMovables(): IMovableCollection | null;
+    /**
+     * The box the movable's anchor states and the box it paints, in pixels: its content's drawing,
+     * which can reach past the frame, turned with the frame. `null` before it is laid out.
+     *
+     * @param onReady Called when the content has a newer answer than the one returned.
+     * @internal
+     */
+    _getDrawnBounds(onReady: () => void): {
+        anchor: Bounds;
+        drawn: Bounds;
+    } | null;
+    /**
+     * The box the movable occupies on the sheet as rotated, which its anchor states; the frame is
+     * this box with its sides swapped within 45° of a quarter turn.
+     */
+    protected _getAnchorBounds(): Bounds | null;
     /** {@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;
@@ -95,23 +198,18 @@ 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;
+    /** {@inheritDoc IMovable.Placement} */
+    type Placement = IMovable.Placement;
+    /**
+     * What a movable needs of its content beyond {@link IMovable.IContent}.
+     */
+    interface Content<J = any> extends IMovable.IContent {
         /**
          * Create a json object.
          */
         toJSON(_toResourceId?: (resource: IResource) => number | null): J;
+        /** {@inheritDoc MovableContentRegistry.Content.getMovables} */
+        getMovables?(): IMovableCollection;
     }
     /**
      * Options for creating a movable object and adding to a movable container.
@@ -172,32 +270,36 @@ export declare namespace Movable {
          * Movable specific container callbacks.
          */
         setContainerCallbacks?(callbacks?: Movable.ContainerCallbacks): void;
-        /**
-         * Returns a boolean indicating if the select was successful.
-         * @see {@link IMovable.select}
-         */
-        select?: (options?: IMovable.SelectOptions) => Promise<boolean>;
-        /**
-         * @see {@link IMovable.unselect}
-         */
-        unselect?: () => boolean;
         /**
          * Scroll the movable into view.
          */
         scrollIntoView?: (options?: globalThis.ScrollIntoViewOptions | boolean) => Promise<boolean>;
         /**
-         * Returns the a flag if the movable is selected.
+         * Answers {@link IMovable.isSelected} in place of the view's selection: for a copy, which is on
+         * no view.
          */
         isSelected?: () => boolean;
         /**
-         * Allow for the default lock aspect ratio to be overwritten.
+         * The movable's frame, turn or mirror changed, or its content's connection sites did, as part
+         * of the open operation: whatever is placed relative to it follows (a connector glued to it).
+         * `translated` when the frame only moved, its size, turn and mirror kept. A movable without
+         * one tells the movable that holds it.
          */
-        defaultLockAspectRatio?: boolean;
+        onPlacementChange?: (movable: IMovable, translated: boolean) => void;
     }
     interface ContainerCallbacks extends Anchored.ContainerCallbacks {
         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;
@@ -206,16 +308,25 @@ 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;
+    flipH?: boolean;
+    flipV?: boolean;
     lockAspectRatio?: boolean | null;
+    /** Edit locks by the file's own names, kept as read. */
+    locks?: Record<string, boolean> | null;
+    noPrint?: boolean;
+    unlocked?: boolean;
     offsets?: MovableOffsets;
-    bounds?: Bounds | null;
-    contentListenerRemove: IListener.Remove;
-}
-interface CommitView extends AbstractAnchored.CommitView {
+    /**
+     * 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/movable/MovableCollection.d.ts

@@ -1,22 +1,29 @@
-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 {
-    private _add;
-    private _getItems;
+import { InsertableCollection } from './_InsertableCollection';
+export declare class MovableCollection extends AbstractCollection<IMovable, IMovableCollection.GetItemsOptions> implements IMovableCollection, InsertableCollection {
+    private _prepareDelegate;
+    private _preparePictureDelegate;
+    private _insert;
+    private _getItemsDelegate;
     private _getCount;
     private _updateSelected;
     private _addListeners;
-    private _addPicture;
-    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>);
+    private _group;
+    constructor(prepare: (options: IMovableCollection.AddOptions) => Promise<InsertableCollection.InsertOptions>, preparePicture: (image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions) => Promise<InsertableCollection.InsertOptions>, insert: (options: InsertableCollection.InsertOptions) => 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, group: (movables: readonly IMovable[], options?: IMovableCollection.GroupOptions) => 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 InsertableCollection._prepare} */
+    _prepare(options: IMovableCollection.AddOptions): Promise<InsertableCollection.InsertOptions>;
+    /** {@inheritDoc InsertableCollection._preparePicture} */
+    _preparePicture(image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<InsertableCollection.InsertOptions>;
+    /** {@inheritDoc InsertableCollection._insertNow} */
+    _insertNow(options: InsertableCollection.InsertOptions): IMovable;
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
     /** {@inheritDoc IMovableCollection.getCount} */
     getCount(): number;
     /** {@inheritDoc IMovableCollection.updateSelected} */
@@ -25,5 +32,9 @@ 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.group} */
+    group(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
+    /** {@inheritDoc IMovableCollection.isIMovableCollection} */
+    get isIMovableCollection(): true;
 }
 //# sourceMappingURL=MovableCollection.d.ts.map

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

@@ -0,0 +1,113 @@
+import { IResource, IResourceCollection } from '../resource';
+import { ICellRange } from '../cellRange';
+import { IMovable } from './IMovable';
+import { IMovableCollection } from './IMovableCollection';
+import { AbstractMovableContent } from './AbstractMovableContent';
+/**
+ * The kinds of content a movable can place, by type, and how each is created.
+ *
+ * @remarks
+ * A sheet creates a movable's content from its JSON by looking the content's `type` up here. The
+ * built-in kinds (picture, chart, shape, slicer, the form controls) are registered when the SDK
+ * loads; a host registers its own the same way, and from then on a workbook that carries that
+ * type creates the host's content, saves it through its `toJSON`, and offers it to the UI under
+ * the same type (`registerMovableRenderer` in `@sheetxl/react`).
+ *
+ * A type nobody has registered still loads and saves: it becomes an unmodeled content that
+ * carries its JSON as it was.
+ *
+ * A kind can be registered with a loader instead ({@link Lazy}), so its implementation is fetched
+ * only when a workbook first holds one, or ahead of use by `LazyModules.prefetch` from
+ * `@sheetxl/utils`. Until it arrives the movable places a stand-in that is named, positioned and
+ * saved as it was read; see {@link IMovable.isContentLoaded}.
+ */
+export declare namespace MovableContentRegistry {
+    /**
+     * What a movable's content is given when created.
+     */
+    interface CreateOptions extends AbstractMovableContent.ConstructorOptions<any> {
+        /** The content's type, as registered. */
+        type: string;
+        /** The content's JSON, as saved. */
+        json?: any;
+        /** 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>;
+        /** {@inheritDoc AbstractMovableContent.ConstructorOptions.getRange} */
+        getRange: (address: string) => ICellRange | null;
+        /** {@inheritDoc AbstractMovableContent.ConstructorOptions.addWatch} */
+        addWatch: AbstractMovableContent.AddWatch;
+    }
+    /**
+     * What a movable needs of its content: {@link IMovable.IContent}, and that it can be saved.
+     */
+    interface Content extends IMovable.IContent {
+        toJSON(toResourceId?: (resource: IResource) => number | null): any;
+        /**
+         * The movables this content holds, for content that holds any (a group); absent, none. The
+         * movable answers it as {@link IMovable.getMovables}. Content that holds movables states them
+         * in its JSON as `members`, so the kinds a tree needs are loaded before it is built.
+         */
+        getMovables?(): IMovableCollection;
+    }
+    /**
+     * Creates the content of one kind.
+     */
+    type Factory = (options: CreateOptions) => Content;
+    /**
+     * A kind whose implementation is loaded the first time a workbook needs it.
+     *
+     * @example
+     * ```ts
+     * MovableContentRegistry.register('map', { load: () => import('./MapContent'), select: (m) => m.createMap });
+     * ```
+     */
+    interface Lazy<M = any> {
+        /**
+         * Imports the kind's module. It must resolve to the module itself, with the factory picked by
+         * {@link select}: after a failed fetch, the module is imported again without this loader. A
+         * load that fails is asked again the next time it is needed.
+         */
+        load: () => Promise<M>;
+        /**
+         * Picks the factory from the module.
+         *
+         * @defaultValue the module itself, for a loader that resolves to the factory
+         */
+        select?: (module: M) => Factory;
+        /**
+         * Whether the kind may be loaded ahead of use (`LazyModules.prefetch` in `@sheetxl/utils`).
+         *
+         * @defaultValue true
+         */
+        prefetch?: boolean;
+    }
+    /**
+     * Registers how a kind of content is created, replacing any earlier registration.
+     *
+     * @param type The content type (`IMovable.IContent.getType()`).
+     * @param factory The factory, or a {@link Lazy} that loads it when first needed.
+     * @returns A function that removes the registration.
+     */
+    function register<M>(type: string, factory: Factory | Lazy<M>): () => void;
+    /**
+     * The factory for a kind of content, or `undefined` if none is registered or it has not loaded
+     * yet ({@link load}).
+     */
+    function get(type: string): Factory | undefined;
+    /**
+     * Whether a kind is registered, loaded or not.
+     */
+    function has(type: string): boolean;
+    /**
+     * Loads a kind's factory if it is registered with a loader, and answers it once it is ready.
+     * Resolves `undefined` for a kind nobody registered.
+     */
+    function load(type: string): Promise<Factory | undefined>;
+    /**
+     * The registered types, loaded or not.
+     */
+    function getTypes(): string[];
+}
+//# sourceMappingURL=MovableContentRegistry.d.ts.map

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

@@ -0,0 +1,14 @@
+import { MovableContentRegistry } from './MovableContentRegistry';
+/**
+ * Registers the kinds of content the SDK ships. Called by the registry before its first use.
+ *
+ * @remarks
+ * A call, not an import for its effect: the package declares no side effects, so a bundler drops
+ * a module imported only for one, and every built-in kind with it.
+ *
+ * A picture is the sheet's own (its background is one), so it is here from the start. Every other
+ * kind is loaded the first time a workbook holds one: a workbook with no chart never fetches the
+ * chart model.
+ */
+export declare function registerBuiltInContents(register: typeof MovableContentRegistry.register): void;
+//# sourceMappingURL=_BuiltInContents.d.ts.map

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

@@ -0,0 +1,35 @@
+import { MovableContentRegistry } from './MovableContentRegistry';
+import { Movable } from './Movable';
+/**
+ * What a container gives the factory beyond the content's own options.
+ */
+export interface ContentHost {
+    /** The movable the content is for, once it is built; `undefined` before. */
+    getMovable: () => Movable | undefined;
+    /**
+     * Runs `callback` folded into the current commit: a loaded kind replacing its stand-in is not an
+     * edit, and there is nothing for an undo to take back.
+     */
+    amend: <R>(callback: () => R) => R;
+    /** Whether the container is gone, so a late load has nothing to replace. */
+    isClosed: () => boolean;
+}
+/**
+ * Loads the kinds a content and the movables it holds need, so a movable made from `json` holds
+ * its real content from the start. A load that fails is left to the stand-in.
+ *
+ * @remarks
+ * Content that holds movables states them in its JSON as `members` ({@link IMovable.ContentJSON}).
+ */
+export declare function loadContentKinds(content: {
+    type: string;
+    json?: any;
+} | undefined): Promise<void>;
+/**
+ * Creates the content of a movable from its type, as the sheet does for a placed movable and a
+ * group does for a member: the kind's own content when its factory is here, a stand-in that is
+ * swapped for the real content when the kind loads ({@link MovableContentRegistry.Lazy}), or an
+ * unmodeled content for a kind nobody registered.
+ */
+export declare function createMovableContent(type: string, options: MovableContentRegistry.CreateOptions, host: ContentHost): Movable.Content;
+//# sourceMappingURL=_ContentFactory.d.ts.map