@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

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

@@ -0,0 +1,129 @@
+import { Bounds } from '@sheetxl/utils';
+import { ICollection } from '../type';
+import { IAnchored } from '../anchored';
+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.
+ */
+export interface IMovableCollection extends ICollection<IMovable>, IListener.ISource<IMovableCollection> {
+    /**
+     * Add a resource to the movable collection.
+     *
+     * @param options {@link IMovableCollection.AddOptions}
+     * @returns A new {@link IMovable}.
+     */
+    add(options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /**
+     * Returns movables that match the filter criteria.
+     *
+     * @param options {@link IMovableCollection.GetItemsOptions}
+     * @returns An Array of {@link IMovable}.
+     *
+     * @remarks
+     * If no filter criteria is provided, all items will be returned.
+     */
+    getItems(options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /**
+     * Update all of the selected movable in a single transaction
+     */
+    updateSelected(update: (movable: IMovable) => void, action?: string): void;
+    /**
+     * Add a picture to the current sheet.
+     * Returns an IMovable with an Picture that can be used to manipulate the picture or remove it.
+     *
+     * @param picture This can be either string to a url, a Resource or an IResource.AddOptions
+     * @param options {@link IMovableCollection.AddOptions}
+     * @returns A Promise that will resolve to the new Movable.
+     */
+    addPicture(picture: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+}
+/**
+ * {@inheritDoc IMovableCollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IMovableCollection}
+ */
+export declare namespace IMovableCollection {
+    /**
+     * Options for filtering a collection of movables.
+     */
+    interface GetItemsOptions extends ICollection.GetItemsOptions {
+        /**
+         * If provided, the search will be limited to items that intersect the range.
+         * @remarks
+        */
+        address?: ICellRange.Address;
+        /**
+         * Indicate if items that are in hidden headers or marked as hidden should be returned.
+         * @defaultValue false
+         */
+        ignoreHidden?: boolean;
+        /**
+         * The type to search for. If not provided all items will be returned.
+        */
+        type?: string | string[];
+        /**
+         * Only find items in this bounds.
+         * @defaultValue Search all
+         */
+        bounds?: Bounds;
+        /**
+         * Only return items that are completely contained with the search bounds.
+         * @defaultValue false
+         */
+        fullyContained?: boolean;
+    }
+    /**
+     * Options for adding a movable to the collection.
+     */
+    interface AddOptions<J = any> extends ITransaction.OperationOptions {
+        /**
+         * The type of movable to add.
+         */
+        type?: string;
+        /**
+         * Initial json value.
+         */
+        json?: J;
+        /**
+         * If a referenceId is provided then the movable will be linked to the resource.
+         * @param resourceId
+         * @returns IResource
+         */
+        fromResourceId?: (resourceId: number) => IResource;
+        /**
+         * The boundary for the movable object in pixels.
+         */
+        bounds?: Partial<Bounds>;
+        /**
+         * 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
+         * default cursor placement when no viewport responds (headless). Omit ⇒ default cursor placement.
+         */
+        autoPlace?: 'viewport';
+        /**
+         * The behavior of how the movable resizes as the anchor/cells change.
+         */
+        anchorType?: IAnchored.Type;
+        /**
+         * If unspecified no selection will occur.
+         *
+         * @remarks
+         * Overrides the default autoSelect to include {@link IMovable.SelectOptions} options.
+         */
+        autoSelect?: boolean | IMovable.SelectOptions;
+    }
+}
+//# sourceMappingURL=IMovableCollection.d.ts.map

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

@@ -0,0 +1,49 @@
+import { IListener } from '../listener';
+import { IMovable } from './IMovable';
+/**
+ * Manages a selection of `IMovable`s.
+ */
+export interface IMovableSelection extends IListener.ISource<IMovableSelection> {
+    /**
+     * The movable selection.
+     */
+    getMovableSelection(): readonly IMovable[];
+    /**
+     * Select a movable object.
+     *
+     * @param movables
+     * @param addToSelection
+     */
+    selectMovables(movables: readonly IMovable[], addToSelection?: boolean): this;
+    /**
+     * Returns the movable from the selection.
+     *
+     * @param movables
+     */
+    unselectMovables(movables: IMovable[]): this;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: IMovableSelection.IListeners, options?: IListener.Options): IListener.Remove;
+}
+/**
+ * {@inheritDoc IMovableSelection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IMovableSelection}
+ */
+export declare namespace IMovableSelection {
+    interface Events {
+        /**
+         * Called when the selection has changed.
+         */
+        onMovableSelectionChange?(source: IMovableSelection): void;
+    }
+    interface IListeners extends IListener.Callbacks<IMovableSelection, IMovableSelection.Events> {
+    }
+}
+//# sourceMappingURL=IMovableSelection.d.ts.map

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

@@ -0,0 +1,221 @@
+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 { IMovable } from './IMovable';
+import { AbstractAnchored } from '../anchored/AbstractAnchored';
+import { Anchored } from '../anchored/Anchored';
+export declare class Movable<J extends IMovable.JSON = IMovable.JSON, STATE extends State = State, VIEW extends CommitView = CommitView> extends AbstractAnchored<STATE, VIEW, IMovable.Events> {
+    static instanceCounter: number;
+    protected _content: Movable.Content;
+    private _optionsMovable;
+    constructor(options: Movable.ConstructorOptions<J>);
+    /** {@inheritDoc IMovable.getContent} */
+    getContent(): Movable.Content;
+    protected _processAfterStateChange(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
+    protected _processZIndex(): void;
+    protected _processContainerSelect(_selected: boolean, _first: boolean): IRange.Coords | void;
+    /** {@inheritDoc IMovable.isSelected} */
+    isSelected(): boolean;
+    /** {@inheritDoc IMovable.isSelected} */
+    scrollIntoView(options?: globalThis.ScrollIntoViewOptions | boolean): Promise<boolean>;
+    /** {@inheritDoc IMovable.select} */
+    select(options?: IMovable.SelectOptions): Promise<boolean>;
+    /** {@inheritDoc IMovable.unselect} */
+    unselect(): boolean;
+    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>;
+    /** 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} */
+    isHidden(): boolean;
+    /** {@inheritDoc IMovable.setLockAspectRatio} */
+    setLockAspectRatio(lockAspectRatio: boolean): this;
+    /** {@inheritDoc IMovable.isLockAspectRatio} */
+    isLockAspectRatio(): boolean;
+    /** {@inheritDoc IMovable.setRotation} */
+    setRotation(rotation?: number): this;
+    /** {@inheritDoc IMovable.getRotation} */
+    getRotation(): number;
+    /** {@inheritDoc IMovable.moveToBack} */
+    moveToBack(): this;
+    /** {@inheritDoc IMovable.moveBackward} */
+    moveBackward(): this;
+    /** {@inheritDoc IMovable.moveToFront} */
+    moveToFront(): this;
+    /** {@inheritDoc IMovable.moveForward} */
+    moveForward(): this;
+    /** {@inheritDoc IMovable.getZIndex} */
+    getZIndex(): number;
+    /** {@inheritDoc IMovable.setBounds} */
+    setBounds(bounds: Partial<Bounds>, options?: ITransaction.OperationOptions): this;
+    private _updateMovableLocation;
+    private _calcAbsoluteBounds;
+    /** {@inheritDoc IMovable.getBounds} */
+    getBounds(): 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;
+    protected _processContainerLayout(): void;
+    protected _processAnchorCoords(): void;
+    protected enrichOffset(offset: IMovable.OffsetCoords, x: number, y: number): IMovable.OffsetCoords;
+    protected _fromJSON(json: IMovable.JSON): void;
+    toJSON(toResourceId?: (resource: IResource) => number | null): IMovable.JSON;
+    /** {@inheritDoc IMovable.isIMovable} */
+    get isIMovable(): true;
+}
+/**
+ * Interfaces for creating `AnchoredMovable` items.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@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;
+        /**
+         * Create a json object.
+         */
+        toJSON(_toResourceId?: (resource: IResource) => number | null): J;
+    }
+    /**
+     * Options for creating a movable object and adding to a movable container.
+     */
+    interface ConstructorOptions<J = any> extends Anchored.ConstructorOptions {
+        /**
+         * The content of the movable.
+         */
+        content: Movable.Content<J>;
+        /**
+         * If provided the movable will be added to the resource manager.
+         */
+        /**
+         * 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>;
+        /**
+         * The initial JSON to load the movable from.
+         */
+        json?: IMovable.JSON<J>;
+        /**
+         * Returns the maximum bounds of the container. If not defined the container will be unbounded.
+         */
+        getMaxBounds?: () => Bounds;
+        /**
+         * Returns the bounds of a range of cells.
+         */
+        getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
+        /**
+         * Returns an anchor coords for the given bounds.
+         */
+        getCoordsAtBounds: (bounds: Bounds) => IRange.Coords;
+        /**
+         * Move movable to the back in the zIndex.
+         */
+        moveToBackOnContainer?: () => void;
+        /**
+         * Move movable backward one layer in the zIndex.
+         */
+        moveBackwardOnContainer?: () => void;
+        /**
+         * Move movable to the font in the zIndex.
+         */
+        moveToFrontOnContainer?: () => void;
+        /**
+         * Move movable forward one layer in the zIndex.
+         */
+        moveForwardOnContainer?: () => void;
+        /**
+         * Returns the z-index for the current Movable.
+         */
+        getZIndex?: () => number;
+        /**
+         * 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.
+         */
+        isSelected?: () => boolean;
+        /**
+         * Allow for the default lock aspect ratio to be overwritten.
+         */
+        defaultLockAspectRatio?: boolean;
+    }
+    interface ContainerCallbacks extends Anchored.ContainerCallbacks {
+        processZIndex: () => void;
+        processSelection: (selected: boolean, first: boolean) => IRange.Coords | void;
+    }
+}
+interface MovableOffsets {
+    tl: Point;
+    br: Point;
+}
+interface State extends AbstractAnchored.State {
+    /** Single rectangle — this type is never anchored to more than one range. */
+    anchorCoords: IRange.Coords;
+    name?: string | null;
+    description?: string | null;
+    hidden?: boolean;
+    rotation?: number;
+    lockAspectRatio?: boolean | null;
+    offsets?: MovableOffsets;
+    bounds?: Bounds | null;
+    contentListenerRemove: IListener.Remove;
+}
+interface CommitView extends AbstractAnchored.CommitView {
+}
+export {};
+//# sourceMappingURL=Movable.d.ts.map

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

@@ -0,0 +1,29 @@
+import { ICollection } 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;
+    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>);
+    /** {@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 IMovableCollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IMovableCollection.updateSelected} */
+    updateSelected(update: (movable: IMovable) => void, action?: string): void;
+    /** {@inheritDoc IMovableCollection.addListeners */
+    addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IMovableCollection.addPicture */
+    addPicture(image: string | IResource | IResourceCollection.AddOptions, options?: IMovableCollection.AddOptions): Promise<IMovable>;
+}
+//# sourceMappingURL=MovableCollection.d.ts.map

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

@@ -0,0 +1,4 @@
+import { Point, Bounds } from '@sheetxl/utils';
+import { IMovableCollection } from './IMovableCollection';
+export declare function nonOverlappingOffset(movables: IMovableCollection, destination: Bounds, shiftX?: boolean, shiftY?: boolean): Point;
+//# sourceMappingURL=_MovableUtils.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './IMovable';
+export * from './IMovableCollection';
+export * from './IMovableSelection';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,41 @@
+import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
+import { ICellRanges } from '../cellRange';
+import { INamed } from './INamed';
+import { IModel } from '../model';
+import { AbstractModel } from '../model/AbstractModel';
+export interface State extends AbstractModel.State {
+    name: string;
+    comment: string | null;
+    hidden: boolean;
+    scope: string | null;
+}
+/**
+ * Abstract implementation of `INamed`.
+ */
+export declare abstract class AbstractNamed<T, S extends State, VIEW extends AbstractModel.CommitView = AbstractModel.CommitView, EVENTS extends IModel.Events = INamed.Events> extends AbstractModel<S, INamed.JSON, VIEW, EVENTS> implements INamed<T> {
+    /** {@inheritDoc INamed.select} */
+    abstract select(options?: ITypes.SelectOptions): Promise<this>;
+    /** {@inheritDoc INamed.getRanges} */
+    abstract getRanges(): ICellRanges | null;
+    /** {@inheritDoc INamed.getValue} */
+    abstract getValue(): T;
+    /** {@inheritDoc INamed.getType} */
+    abstract getType(): string;
+    protected _fromJSON(json: INamed.JSON): void;
+    protected _toJSON(): INamed.JSON;
+    /** {@inheritDoc INamed.getValue} */
+    getName(): string;
+    /** {@inheritDoc INamed.setName} */
+    setName(name: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc INamed.getComment} */
+    getComment(): string | null;
+    /** {@inheritDoc INamed.setComment} */
+    setComment(comment: string | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc INamed.isHidden} */
+    isHidden(): boolean;
+    /** {@inheritDoc INamed.getScope} */
+    getScope(): string | null;
+    get isINamed(): true;
+}
+//# sourceMappingURL=AbstractNamed.d.ts.map