@visuallyjs/browser-ui 1.0.0

package/types/core/undo-redo/compound-action.d.ts

@@ -0,0 +1,19 @@
+import { UndoRedoAction } from "./undo-redo";
+import { Edge } from "../model/graph";
+/**
+ * Compounds a set of actions into one. An example of this is a node remove, in which all of its edges and ports are also removed.
+ * @internal
+ */
+export declare class CompoundAction implements UndoRedoAction {
+    private readonly actions?;
+    id: string;
+    type: string;
+    constructor(actions?: Array<UndoRedoAction>);
+    $mergeInto(target: CompoundAction): void;
+    addAction(action: UndoRedoAction, insertAtStartOfTransaction?: boolean): void;
+    undo(): void;
+    redo(): void;
+    edgeChange(previousId: string, newEdge: Edge): void;
+    hasDeltas(): boolean;
+    compress(): CompoundAction;
+}

package/types/core/undo-redo/edge-action.d.ts

@@ -0,0 +1,62 @@
+import { Edge, Vertex } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+import { UndoRedoManager, UndoRedoAction } from "./undo-redo";
+import { PointXY } from "../util";
+/**
+ * Superclass for edge add/remove.
+ * @internal
+ */
+export declare abstract class EdgeAction {
+    protected obj: Edge;
+    protected instance: VisuallyJsModel;
+    private manager;
+    edgeId: string;
+    source: string;
+    target: string;
+    private readonly _sourcePort;
+    private readonly _targetPort;
+    private readonly _geometry;
+    private readonly _sourceIsDummy;
+    private readonly _targetIsDummy;
+    private readonly _sourceDummyPosition;
+    private readonly _targetDummyPosition;
+    constructor(obj: Edge, instance: VisuallyJsModel, manager: UndoRedoManager);
+    generateSourceIdentifier(): string | PointXY;
+    generateTargetIdentifier(): string | PointXY;
+    protected _add(): void;
+    protected _remove(): void;
+    edgeChange(newEdge: Edge): void;
+}
+export declare class EdgeAddAction extends EdgeAction implements UndoRedoAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+    hasDeltas(): boolean;
+}
+export declare class EdgeRemoveAction extends EdgeAction implements UndoRedoAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+    hasDeltas(): boolean;
+}
+export declare abstract class EdgeSourceOrTargetChangedAction extends EdgeAction implements UndoRedoAction {
+    protected oldVertex: Vertex | PointXY;
+    protected newVertex: Vertex | PointXY;
+    abstract type: string;
+    constructor(instance: VisuallyJsModel, manager: UndoRedoManager, edge: Edge, oldVertex: Vertex | PointXY, newVertex: Vertex | PointXY);
+    abstract redo(): void;
+    abstract undo(): void;
+    private verticesAreTheSame;
+    private pointsAreTheSame;
+    hasDeltas(): boolean;
+}
+export declare class EdgeSourceChangedAction extends EdgeSourceOrTargetChangedAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+}
+export declare class EdgeTargetChangedAction extends EdgeSourceOrTargetChangedAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+}

package/types/core/undo-redo/group-action.d.ts

@@ -0,0 +1,60 @@
+import { UndoRedoAction } from "./undo-redo";
+import { Group, Node } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+import { VisuallyJsRenderer } from "../renderer";
+import { PointXY } from "../util";
+/**
+ * @internal
+ */
+declare abstract class GroupAction {
+    protected node: Node;
+    protected group: Group;
+    protected instance: VisuallyJsModel;
+    protected constructor(node: Node, group: Group, instance: VisuallyJsModel);
+    hasDeltas(): boolean;
+}
+export declare class AddGroupMemberAction extends GroupAction implements UndoRedoAction {
+    protected node: Node;
+    protected group: Group;
+    protected sourceGroup: Group;
+    private _originalMemberPosition;
+    private _memberPositionInGroup;
+    protected instance: VisuallyJsModel;
+    protected renderer: VisuallyJsRenderer<any>;
+    type: string;
+    constructor(node: Node, group: Group, sourceGroup: Group, _originalMemberPosition: PointXY, _memberPositionInGroup: PointXY, instance: VisuallyJsModel, renderer: VisuallyJsRenderer<any>);
+    redo(): void;
+    undo(): void;
+}
+export declare class RemoveGroupMemberAction extends GroupAction implements UndoRedoAction {
+    protected node: Node;
+    protected group: Group;
+    protected targetGroup: Group;
+    private _originalPosition;
+    private _newPosition;
+    protected instance: VisuallyJsModel;
+    protected renderer: VisuallyJsRenderer<any>;
+    type: string;
+    constructor(node: Node, group: Group, targetGroup: Group, _originalPosition: PointXY, _newPosition: PointXY, instance: VisuallyJsModel, renderer: VisuallyJsRenderer<any>);
+    redo(): void;
+    undo(): void;
+}
+export declare class GroupCollapseAction implements UndoRedoAction {
+    group: Group;
+    renderer: VisuallyJsRenderer<any>;
+    type: string;
+    constructor(group: Group, renderer: VisuallyJsRenderer<any>);
+    redo(): void;
+    undo(): void;
+    hasDeltas(): boolean;
+}
+export declare class GroupExpandAction implements UndoRedoAction {
+    group: Group;
+    renderer: VisuallyJsRenderer<any>;
+    type: string;
+    constructor(group: Group, renderer: VisuallyJsRenderer<any>);
+    redo(): void;
+    undo(): void;
+    hasDeltas(): boolean;
+}
+export {};

package/types/core/undo-redo/move-action.d.ts

@@ -0,0 +1,18 @@
+import { UndoRedoAction } from "./undo-redo";
+import { Node, Group } from "../model/graph";
+import { VisuallyJsRenderer } from "../renderer";
+import { PointXY } from "../util";
+/**
+ * @internal
+ */
+export declare class MoveAction implements UndoRedoAction {
+    obj: Node | Group;
+    protected originalPosition: PointXY;
+    pos: PointXY;
+    protected renderer: VisuallyJsRenderer<any>;
+    type: string;
+    constructor(obj: Node | Group, originalPosition: PointXY, pos: PointXY, renderer: VisuallyJsRenderer<any>);
+    redo(): void;
+    undo(): void;
+    hasDeltas(): boolean;
+}

package/types/core/undo-redo/node-group-action.d.ts

@@ -0,0 +1,62 @@
+import { RemoveAction, UndoRedoAction } from "./undo-redo";
+import { Group, Node } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+import { EdgeRemoveAction } from "./edge-action";
+import { GroupRemovedParams } from "../params";
+import { VisuallyJsRenderer } from "../renderer";
+import { Size } from "../util";
+/**
+ * @internal
+ */
+export declare abstract class NodeGroupAction<T extends Node = Node> {
+    protected obj: Node | Group;
+    protected instance: VisuallyJsModel;
+    constructor(obj: Node | Group, instance: VisuallyJsModel);
+    protected $add(): void;
+    protected _$remove(): void;
+    getTerminusId(): string;
+    hasDeltas(): boolean;
+}
+export declare class TerminusAddAction extends NodeGroupAction implements UndoRedoAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+}
+export declare class TerminusRemoveAction extends NodeGroupAction implements UndoRedoAction, RemoveAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+    isConnectedTo(edgeRemoveAction: EdgeRemoveAction): boolean;
+}
+export declare class GroupRemoveAction extends TerminusRemoveAction {
+    type: string;
+    childrenRemoved: boolean;
+    orphanedChildren: Array<Node | Group>;
+    constructor(params: GroupRemovedParams, t: VisuallyJsModel);
+    $add(): void;
+}
+export interface GroupSizeChangedParams {
+    group: Group;
+    originalGroupSize: Size;
+    newGroupSize: Size;
+    source: VisuallyJsRenderer<any>;
+}
+export interface GroupSizeUndoRedoParams {
+    group: Group;
+    sizeAfterUndo: Size;
+    sizeBeforeUndo: Size;
+    source: VisuallyJsRenderer<any>;
+}
+export declare class GroupSizeChangedAction implements UndoRedoAction {
+    group: Group;
+    private originalGroupSize;
+    newGroupSize: Size;
+    private instance;
+    private source;
+    type: string;
+    constructor(group: Group, originalGroupSize: Size, newGroupSize: Size, instance: VisuallyJsModel, source: VisuallyJsRenderer<any>);
+    hasDeltas(): boolean;
+    redo(): void;
+    undo(): void;
+    private _fire;
+}

package/types/core/undo-redo/port-action.d.ts

@@ -0,0 +1,29 @@
+import { UndoRedoAction, RemoveAction } from "./undo-redo";
+import { Port, Group, Node } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+import { EdgeRemoveAction } from "./edge-action";
+/**
+ * @internal
+ */
+export declare abstract class PortAction {
+    protected obj: Port;
+    private _parent;
+    protected instance: VisuallyJsModel;
+    constructor(obj: Port, _parent: Node | Group, instance: VisuallyJsModel);
+    _add(): void;
+    _remove(): void;
+    getTerminusId(): string;
+}
+export declare class PortAddAction extends PortAction implements UndoRedoAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+    hasDeltas(): boolean;
+}
+export declare class PortRemoveAction extends PortAction implements RemoveAction {
+    type: string;
+    undo(): void;
+    redo(): void;
+    isConnectedTo(edgeRemoveAction: EdgeRemoveAction): boolean;
+    hasDeltas(): boolean;
+}

package/types/core/undo-redo/renderer-vertex-removed-action.d.ts

@@ -0,0 +1,17 @@
+import { Group, Node } from "../model/graph";
+import { VisuallyJsRenderer } from "../renderer";
+import { UndoRedoAction } from "./undo-redo";
+import { PointXY } from "../util";
+/**
+ * @internal
+ */
+export declare class VisuallyJsRendererVertexRemovedAction implements UndoRedoAction {
+    private _renderer;
+    vertex: Node | Group;
+    pos: PointXY;
+    type: string;
+    constructor(_renderer: VisuallyJsRenderer<any>, vertex: Node | Group, pos: PointXY);
+    redo(): void;
+    undo(): void;
+    hasDeltas(): boolean;
+}

package/types/core/undo-redo/set-type-action.d.ts

@@ -0,0 +1,14 @@
+import { UndoRedoAction } from "./undo-redo";
+import { Edge, Group, Node, Port } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+export declare class SetTypeAction implements UndoRedoAction {
+    obj: Node | Port | Group | Edge;
+    previousType: string;
+    newType: string;
+    protected instance: VisuallyJsModel;
+    type: string;
+    constructor(obj: Node | Port | Group | Edge, previousType: string, newType: string, instance: VisuallyJsModel);
+    hasDeltas(): boolean;
+    redo(): void;
+    undo(): void;
+}

package/types/core/undo-redo/undo-redo.d.ts

@@ -0,0 +1,203 @@
+import { Edge } from "../model/graph";
+import { VisuallyJsModel } from "../toolkit";
+import { CompoundAction } from "./compound-action";
+import { MoveAction } from './move-action';
+import { GroupSizeChangedAction } from "./node-group-action";
+import { UpdateAction } from "./update-action";
+import { EdgeRemoveAction } from "./edge-action";
+/**
+ * @internal
+ */
+export interface UndoRedoAction {
+    undo(): void;
+    redo(): void;
+    hasDeltas(): boolean;
+    type: string;
+}
+/**
+ * @internal
+ */
+export interface TerminusAction extends UndoRedoAction {
+    getTerminusId(): string;
+}
+/**
+ * @internal
+ */
+export interface RemoveAction extends TerminusAction {
+    isConnectedTo(edgeRemoveAction: EdgeRemoveAction): boolean;
+}
+/**
+ * @internal
+ */
+export type OnChangeFunction = (undoRedo: UndoRedoManager, undoStackSize: number, redoStackSize: number) => void;
+/**
+ * Constructor params for an UndoRedoManager.
+ * @internal
+ */
+export type UndoRedoParams = {
+    /**
+     * model instance to attach to
+     */
+    instance: VisuallyJsModel;
+    /**
+     * Maximum size of stack. Defaults to 50.
+     */
+    maximumSize?: number;
+    /**
+     * Optional function to call when a change occurs. This is invoked for any change at all, ie. all programmatic events, outside of the user involvement.
+     */
+    onChange?: OnChangeFunction;
+};
+/**
+ * Manager for undo/redo operations on a VisuallyJsModel instance. An instance of VisuallyJsModel creates one of these automatically so
+ * there is no need for library users to instantiate one.
+ * @internal
+ */
+export declare class UndoRedoManager {
+    private readonly _instance;
+    private readonly _maximumSize;
+    private _suspend;
+    private readonly _onChange;
+    readonly undoStack: Array<UndoRedoAction>;
+    readonly redoStack: Array<UndoRedoAction>;
+    private __callbacks;
+    private __currentTransaction;
+    private _appendStack;
+    constructor(params: UndoRedoParams);
+    private _setSuspended;
+    dataLoadStart(): void;
+    dataAppendStart(): void;
+    dataLoadEnd(): void;
+    dataAppendEnd(): void;
+    /**
+     * Bind listeners to the events in the Toolkit we are interested in.
+     * @internal
+     */
+    private _bindListeners;
+    /**
+     * Fire the on change event, if there's a listener registered.
+     * @internal
+     */
+    private _fireUpdate;
+    /**
+     * add a command to the undo stack, clearing the redo stack.
+     * @param action
+     * @internal
+     */
+    private command;
+    /**
+     * Notification that some edge has been replaced with a copy. This occurs when an edge removed is undone or an edge add is
+     * redone. we need to update all references to the previous edge with this new one, as the toolkit no longer knows about
+     * the old edge. This is not a method that should be called from outside of the undo manager.
+     * @param previousId
+     * @param newEdge
+     * @internal
+     */
+    edgeChange(previousId: string, newEdge: Edge): void;
+    /**
+     * Execute undo on the last command in the undo stack, if it isn't empty.
+     */
+    undo(): void;
+    /**
+     * Re-execute the last command in the redo stack, if it isn't empty.
+     */
+    redo(): void;
+    /**
+     * Clears both stacks and fires an update event.
+     */
+    clear(): void;
+    /**
+     * Run a series of operations as a single transaction in the undo stack, meaning that they will all be undone/redone at once.
+     * @param fn - Series of operations to run as a transaction.
+     * @param cleanupAction - Optional directive specifying what to do if there is a current transaction when this method is called.
+     *
+     */
+    transaction(fn: (...args: any[]) => any, cleanupAction?: TransactionCleanupAction, canRunOutsideTransaction?: boolean): string | false;
+    mergeTransaction(fn: () => any): string | false;
+    private _mergePriorAction;
+    private _createNewTransaction;
+    /**
+     * Open a new transaction. If a transaction is currently open this method will check the value of the `cleanupAction` parameter. If it is null, an error will be thrown. Otherwise the appropriate action will be taken (see {@link TransactionCleanupAction}).
+     * @param cleanupAction
+     */
+    openTransaction(cleanupAction?: TransactionCleanupAction): string;
+    /**
+     * Rollback the current transaction, if there is one.
+     *
+     */
+    rollbackTransaction(): void;
+    /**
+     * Commit the current transaction.
+     *
+     */
+    commitTransaction(commitAll?: boolean): void;
+    /**
+     * Checks the last action in the stack to see if it was a compound action, and if so, pushes this
+     * action onto it. If it wasn't a compound action, a new compound action is created with the original stack head as its
+     * first action, and then this action is pushed into it. That new compound action then replaces the head of the stack.
+     * @param action
+     * @internal
+     */
+    _attach(action: UndoRedoAction): void;
+    /**
+     * Run the given code the next time there is no transaction in progress - which might be right now, or it might be when a current
+     * transaction is committed.
+     * @param fn
+     * @private
+     * @internal
+     */
+    _doWhenNoCurrentTransaction(fn: () => any): void;
+    /**
+     * Push a callback to the queue. Then maybe flush the queue, it depends if there is a current transaction
+     * @param fn
+     * @internal
+     */
+    private __enqueueCallback;
+    /**
+     * If there's no current transaction, run all the functions in the __callbacks list, then empty it out. This method
+     * is invoked by __enqueueCallback and also by the commitTransaction method, but NOT by the rollback method. The
+     * rollback method just clears the callback list.
+     * @private
+     */
+    private __maybeFlushCallbacks;
+}
+/**
+ * Directive to commit the current transaction if a new one has been opened before the current one has been closed.
+ * @group Model
+ * @category Transaction Support
+ */
+export declare const COMMIT_CURRENT = "commitCurrent";
+/**
+ * Directive to rollback the current transaction if a new one has been opened before the current one has been closed.
+ * @group Model
+ * @category Transaction Support
+ */
+export declare const ROLLBACK_CURRENT = "rollbackCurrent";
+/**
+ * Directive to append the operations in the new transaction to the current transaction, if a new one has been opened before the current one has been closed.
+ * @group Model
+ * @category Transaction Support
+ */
+export declare const APPEND_TO_CURRENT = "appendToCurrent";
+/**
+ * Defines the available actions in response to a new transaction being opened when one is currently open.
+ * @group Model
+ * @category Transaction Support
+ */
+export type TransactionCleanupAction = typeof COMMIT_CURRENT | typeof ROLLBACK_CURRENT | typeof APPEND_TO_CURRENT;
+/**
+ * @internal
+ * @param a
+ */
+export declare function $isCompoundAction(a: UndoRedoAction): a is CompoundAction;
+/**
+ * @internal
+ * @param a
+ */
+export declare function $isUpdateAction(a: UndoRedoAction): a is UpdateAction<any>;
+/**
+ * @internal
+ * @param a
+ */
+export declare function $isMoveAction(a: UndoRedoAction): a is MoveAction;
+export declare function $isGroupSizeChangedAction(a: UndoRedoAction): a is GroupSizeChangedAction;

package/types/core/undo-redo/update-action.d.ts

@@ -0,0 +1,20 @@
+import { UndoRedoAction } from "./undo-redo";
+import { VisuallyJsModel } from "../toolkit";
+import { Edge, Group, Port, Node } from "../model/graph";
+/**
+ * One update action for all types
+ * @internal
+ */
+export declare class UpdateAction<ReasonType> implements UndoRedoAction {
+    obj: Node | Port | Group | Edge;
+    protected instance: VisuallyJsModel;
+    type: string;
+    readonly $nd: any;
+    protected readonly $od: any;
+    private readonly reason;
+    constructor(obj: Node | Port | Group | Edge, originalData: any, instance: VisuallyJsModel, reason: ReasonType);
+    private _do;
+    undo(): void;
+    redo(): void;
+    hasDeltas(): boolean;
+}

package/types/core/undo-redo/vertex-update-action.d.ts

@@ -0,0 +1,12 @@
+import { VisuallyJsModel, VertexUpdatedReason } from "../toolkit";
+import { Edge, Group, Port, Node } from "../model/graph";
+import { UpdateAction } from "./update-action";
+/**
+ * @internal
+ */
+export declare class VertexUpdateAction extends UpdateAction<VertexUpdatedReason> {
+    obj: Node | Port | Group | Edge;
+    protected instance: VisuallyJsModel;
+    type: string;
+    constructor(obj: Node | Port | Group | Edge, originalData: any, instance: VisuallyJsModel, reason: VertexUpdatedReason);
+}