@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.10

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>;
@@ -37,14 +82,6 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     protected _toHtml(): Promise<string> | string;
     /** For easy overriding in subclass to implement ISnapshot */
     protected _toImage(): Promise<Blob> | Blob;
-    /** {@inheritDoc IMovable.setName} */
-    setName(name: string): this;
-    /** {@inheritDoc IMovable.getName} */
-    getName(): string | null;
-    /** {@inheritDoc IMovable.setDescription} */
-    setDescription(description: string): this;
-    /** {@inheritDoc IMovable.getDescription} */
-    getDescription(): string | null;
     /** {@inheritDoc IMovable.setHidden} */
     setHidden(hidden?: boolean): this;
     /** {@inheritDoc IMovable.isHidden} */
@@ -53,10 +90,24 @@ export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE exte
     setLockAspectRatio(lockAspectRatio: boolean): this;
     /** {@inheritDoc IMovable.isLockAspectRatio} */
     isLockAspectRatio(): 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 +120,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 +189,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 +261,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 +299,23 @@ 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;
     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,25 @@
-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 {
+import { InsertableCollection } from './_InsertableCollection';
+export declare class MovableCollection extends AbstractCollection<IMovable, IMovableCollection.GetItemsOptions> implements IMovableCollection, InsertableCollection {
     private _add;
-    private _getItems;
+    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(add: (options?: IMovableCollection.AddOptions) => Promise<IMovable>, 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, addPicture: (image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions) => Promise<IMovable>, 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._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 +28,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

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

@@ -0,0 +1,37 @@
+import { Bounds } from '@sheetxl/utils';
+/** Edges of a box in a movable's frame, in pixels; they may lie outside the frame. */
+export interface FrameRect {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+/**
+ * Content that can paint outside its frame (a shape: a callout's tail, its line).
+ *
+ * @remarks
+ * Answers synchronously from what it last evaluated, or `null` before it has; `onReady` is called
+ * when a newer answer is ready.
+ */
+export interface DrawnContent {
+    _getDrawnRect(width: number, height: number, onReady: () => void): FrameRect | null;
+}
+export declare const isDrawnContent: (content: unknown) => content is DrawnContent;
+/**
+ * The box a movable paints on the sheet: `rect` (its frame when absent), mirrored in the frame as
+ * `flip` states, placed in the unrotated `frame`, turned by `rotation` degrees clockwise about the
+ * frame's center.
+ */
+export declare const drawnBounds: (frame: Bounds, rect: FrameRect | null, rotation: number, flip?: {
+    horizontal: boolean;
+    vertical: boolean;
+}) => Bounds;
+/**
+ * How far `drawn` reaches past `anchor` on its farthest side, in pixels; `0` when it stays inside.
+ */
+export declare const overhang: (anchor: Bounds, drawn: Bounds) => number;
+/** Whether two boxes overlap or touch. */
+export declare const isBoundsIntersect: (a: Bounds, b: Bounds) => boolean;
+export declare const getDrawnVersion: () => number;
+export declare const bumpDrawnVersion: () => void;
+//# sourceMappingURL=_DrawnBounds.d.ts.map

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

@@ -0,0 +1,28 @@
+import { IMovable } from './IMovable';
+import { IMovableCollection } from './IMovableCollection';
+/**
+ * A movable collection that can insert without waiting, for a movable whose content kind is
+ * already loaded.
+ *
+ * @remarks
+ * {@link IMovableCollection.add} waits for the kind to load. An operation that frees a movable it
+ * already holds - a delete that dissolves a group - knows the kind is loaded and cannot wait: it
+ * runs inside a synchronous delete.
+ *
+ * @internal
+ */
+export interface InsertableCollection {
+    /** Inserts a movable as {@link IMovableCollection.add} does, once its kind is loaded. */
+    _insertNow(options: InsertableCollection.InsertOptions): IMovable;
+}
+export declare namespace InsertableCollection {
+    interface InsertOptions extends IMovableCollection.AddOptions {
+        /**
+         * Where in the collection's z-order the movable goes; those at and above it move up one.
+         *
+         * @defaultValue on top
+         */
+        zIndex?: number;
+    }
+}
+//# sourceMappingURL=_InsertableCollection.d.ts.map

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

@@ -1,4 +1,9 @@
 import { Point, Bounds } from '@sheetxl/utils';
 import { IMovableCollection } from './IMovableCollection';
+/**
+ * The shift that keeps a new movable from landing on one already there: while a movable's top-left
+ * is within {@link SAME_SPOT} px of the destination's, step down and right, so repeated inserts
+ * cascade instead of stacking.
+ */
 export declare function nonOverlappingOffset(movables: IMovableCollection, destination: Bounds, shiftX?: boolean, shiftY?: boolean): Point;
 //# sourceMappingURL=_MovableUtils.d.ts.map

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

@@ -0,0 +1,25 @@
+import { CustomElement } from './CustomElement';
+/**
+ * The stand-in a movable places while its content's kind is still loading
+ * ({@link MovableContentRegistry.Lazy}): positioned, named and saved as it was read, and
+ * read-only, so nothing done to it can be lost when the real content takes its place.
+ */
+export declare class PendingContent extends CustomElement {
+    constructor(options: CustomElement.ConstructorOptions & {
+        type: string;
+    });
+    /** {@inheritDoc IModel.isReadOnly} */
+    isReadOnly(): boolean;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+}
+/**
+ * Tracks a content load until it settles, so a reader can wait for every movable it made to hold
+ * its real content ({@link whenContentSettled}).
+ */
+export declare function trackContentLoad(promise: Promise<unknown>): void;
+/**
+ * Resolves once every content load in flight has settled, including any a settling load starts.
+ */
+export declare function whenContentSettled(): Promise<void>;
+//# sourceMappingURL=_PendingContent.d.ts.map