@focus.matters/diagrams 0.0.7

package/dist/Diagrams/store/elements/Events.d.ts

@@ -0,0 +1,244 @@
+import { MouseEvent as ME, KeyboardEvent as KE } from 'react';
+import { Element } from './Element';
+import { Coordinates } from '../primitives/Coordinates';
+import { Node } from './Node';
+import { Edge } from './Edge';
+import { Midpoint } from '../../components/objects/RenderEdge';
+import { MouseInformation } from './EventsMouseInformation';
+import { Dimensions } from '../primitives/Dimensions';
+export type AnyMouseEvent = ME | MouseEvent;
+export type AnyKeyboardEvent = KE | KeyboardEvent;
+export declare abstract class DEvent {
+    src: Element;
+    protected abstract readonly __brand: void;
+    private _cancellable;
+    private _cancelled;
+    private _bubbles;
+    private _spreads;
+    constructor(src: Element);
+    get bubbles(): boolean;
+    get cancelled(): boolean;
+    /**
+     * If false, all emitters in the same level must be skipped
+     */
+    get spreads(): boolean;
+    cancellable(c: boolean): this;
+    cancel(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+export declare abstract class DUIEvent extends DEvent {
+    protected readonly __brand: void;
+}
+export declare abstract class DMouseEvent extends DUIEvent {
+    src: Element;
+    originalEvent: AnyMouseEvent;
+    protected readonly __brand: void;
+    mouse: MouseInformation;
+    constructor(src: Element, originalEvent: AnyMouseEvent);
+    get ctrl(): boolean;
+    get edge(): Edge | undefined;
+    get node(): Node<import('../types').TOrientation> | undefined;
+    get shift(): boolean;
+    get target(): HTMLElement;
+}
+export declare class DClickEvent extends DMouseEvent {
+    protected readonly __brand: void;
+}
+export declare class DDoubleClickEvent extends DMouseEvent {
+    protected readonly __brand: void;
+}
+export declare class DMouseDownEvent extends DMouseEvent {
+    protected readonly __brand: void;
+}
+export declare class DMouseUpEvent extends DMouseEvent {
+    protected readonly __brand: void;
+}
+export declare class DMouseMoveEvent extends DMouseEvent {
+    protected readonly __brand: void;
+}
+export declare class DWheelEvent extends DMouseEvent {
+    originalEvent: WheelEvent;
+    protected readonly __brand: void;
+    constructor(src: Element, originalEvent: WheelEvent);
+    get directionX(): "right" | "left" | "none";
+    get directionY(): "up" | "down" | "none";
+}
+export declare abstract class DKeyboardEvent extends DUIEvent {
+    originalEvent: AnyKeyboardEvent;
+    protected readonly __brand: void;
+    constructor(src: Element, originalEvent: AnyKeyboardEvent);
+    get code(): string;
+    get alt(): boolean;
+    get ctrl(): boolean;
+    get shift(): boolean;
+}
+export declare class DKeyDownEvent extends DKeyboardEvent {
+    originalEvent: AnyKeyboardEvent;
+    protected readonly __brand: void;
+    constructor(src: Element, originalEvent: AnyKeyboardEvent);
+}
+export declare class DKeyUpEvent extends DKeyboardEvent {
+    originalEvent: AnyKeyboardEvent;
+    protected readonly __brand: void;
+    constructor(src: Element, originalEvent: AnyKeyboardEvent);
+}
+export declare class DKeyPressEvent extends DKeyboardEvent {
+    orignalEvent: AnyKeyboardEvent;
+    protected readonly __brand: void;
+    constructor(src: Element, orignalEvent: AnyKeyboardEvent);
+}
+export declare abstract class DCanvasEvent extends DUIEvent {
+    protected readonly __brand: void;
+}
+/** We can add the events DDisplaceEvent, DResizeEvent extends DCanvasEvent */
+export declare class DScaleEvent extends DCanvasEvent {
+    displacement: Coordinates;
+    newScale: number;
+    previousScale: number;
+    protected readonly __brand: void;
+    constructor(src: Element, displacement: Coordinates, newScale: number, previousScale: number);
+}
+export declare class DDisplaceEvent extends DCanvasEvent {
+    previousDisplacement: Coordinates;
+    displacement: Coordinates;
+    protected readonly __brand: void;
+    constructor(src: Element, previousDisplacement: Coordinates, displacement: Coordinates);
+}
+export declare abstract class DChangeEvent extends DEvent {
+    protected readonly __brand: void;
+}
+export declare class DResetGraphEvent extends DChangeEvent {
+    protected readonly __brand: void;
+    constructor(src: Element, getResolver: (cb: () => Promise<boolean>) => unknown);
+    private callbacks;
+    /**
+     * The defer method allows to introduce a wait condition before the graph resets
+     * the current state. It can be used for persistence or confirmation request.
+     *
+     * Everyone that listens to this event can add a new wait condition, the state
+     * will only be reseted if all the conditions return true.
+     *
+     * If any promise is not resolved, the action can be delayed forever.
+     */
+    defer(cb: () => Promise<boolean>): void;
+    private resolve;
+}
+export declare abstract class DNodesConnectionEvent extends DChangeEvent {
+    protected readonly __brand: void;
+}
+/**
+ * This event is fired when a connection is started by the user.
+ */
+export declare class DNodeConnectionIntentEvent extends DNodesConnectionEvent {
+    origin: Node<any>;
+    protected readonly __brand: void;
+    constructor(src: Element, origin: Node<any>);
+}
+/**
+ * This event is fired when a connection is finishd after the mouse up
+ * by the user.
+ */
+export declare class DNodesConnectActionEvent extends DNodesConnectionEvent {
+    origin: Node<any>;
+    target: Node<any>;
+    protected readonly __brand: void;
+    constructor(src: Element, origin: Node<any>, target: Node<any>);
+}
+export declare class DNodeChangeTypeEvent extends DChangeEvent {
+    protected readonly __brand: void;
+}
+export declare class DDeleteNodeEvent extends DChangeEvent {
+    src: Element;
+    node: Node<any>;
+    protected readonly __brand: void;
+    constructor(src: Element, node: Node<any>);
+}
+export declare class DDeleteEdgeEvent extends DChangeEvent {
+    src: Element;
+    edge: Edge;
+    protected readonly __brand: void;
+    constructor(src: Element, edge: Edge);
+}
+export declare abstract class DSelectionEvent extends DUIEvent {
+    src: Element;
+    selected: boolean;
+    protected readonly __brand: void;
+    constructor(src: Element, selected: boolean);
+}
+export declare class DNodeSelectionEvent extends DSelectionEvent {
+    src: Node<any>;
+    protected readonly __brand: void;
+    constructor(src: Node<any>, selected: boolean);
+}
+export declare class DEdgeSelectionEvent extends DSelectionEvent {
+    src: Edge;
+    protected readonly __brand: void;
+    constructor(src: Edge, selected: boolean);
+}
+export declare abstract class DDragEvent extends DChangeEvent {
+    src: Element;
+    originalEvent: AnyMouseEvent;
+    protected readonly __brand: void;
+    constructor(src: Element, originalEvent: AnyMouseEvent);
+}
+export declare class DEdgeDragStartEvent extends DDragEvent {
+    src: Edge;
+    midPoint: Midpoint;
+    originalEvent: AnyMouseEvent;
+    protected readonly __brand: void;
+    constructor(src: Edge, midPoint: Midpoint, originalEvent: AnyMouseEvent);
+}
+export declare class DEdgeEndpointDragStartEvent extends DDragEvent {
+    src: Edge;
+    endpoint: 'from' | 'to';
+    originalEvent: AnyMouseEvent;
+    protected readonly __brand: void;
+    constructor(src: Edge, endpoint: 'from' | 'to', originalEvent: AnyMouseEvent);
+}
+export declare class NodePositionProposal {
+    readonly node: Node<any>;
+    newBox: Dimensions;
+    private _cancelled;
+    private _updated;
+    private _lockX;
+    private _lockY;
+    constructor(node: Node<any>, newBox: Dimensions);
+    cancel(): void;
+    get current(): Dimensions;
+    get cancelled(): boolean;
+    get(): Dimensions;
+    lockX(): void;
+    lockY(): void;
+    update(box: Dimensions): void;
+    updateX(x: number): void;
+    updateY(y: number): void;
+}
+export declare class DDragNodeEvent extends DDragEvent {
+    src: Element;
+    proposals: NodePositionProposal[];
+    protected readonly __brand: void;
+    constructor(src: Element, proposals: NodePositionProposal[], originalEvent: AnyMouseEvent);
+}
+export declare class EdgePointPositionProposal {
+    readonly point: Coordinates;
+    readonly movedAxis: 'x' | 'y';
+    private _updated;
+    private _lockX;
+    private _lockY;
+    constructor(point: Coordinates, movedAxis: 'x' | 'y');
+    get current(): Coordinates;
+    get(): Coordinates;
+    lockX(): void;
+    lockY(): void;
+    update(point: Coordinates): void;
+    updateX(x: number): void;
+    updateY(y: number): void;
+}
+export declare class DDragEdgeSegmentEvent extends DDragEvent {
+    src: Element;
+    proposals: EdgePointPositionProposal[];
+    movedAxis: 'x' | 'y';
+    protected readonly __brand: void;
+    constructor(src: Element, proposals: EdgePointPositionProposal[], movedAxis: 'x' | 'y', originalEvent: AnyMouseEvent);
+}

package/dist/Diagrams/store/elements/EventsMouseInformation.d.ts

@@ -0,0 +1,10 @@
+import { Coordinates } from '../primitives/Coordinates';
+import { AnyMouseEvent } from './Events';
+export declare class MouseInformation {
+    protected originalEvent: AnyMouseEvent;
+    constructor(originalEvent: AnyMouseEvent);
+    get button(): "right" | "left" | "none" | "middle" | "back" | "forward";
+    get position(): Coordinates;
+    get x(): number;
+    get y(): number;
+}

package/dist/Diagrams/store/elements/Gateway.d.ts

@@ -0,0 +1,57 @@
+import { TGatewayState } from '../types';
+import { Edge } from './Edge';
+import { Node } from './Node';
+import { Coordinates } from '../primitives/Coordinates';
+import { Element } from './Element';
+export declare class Gateway extends Element {
+    parent: Node<any>;
+    state: TGatewayState;
+    constructor(parent: Node<any>, state: Pick<TGatewayState, 'maxIncomingConnections' | 'maxOutgoingConnections' | 'orientation' | 'id'> & Partial<TGatewayState>);
+    addIncomingEdge(edge: Edge): void;
+    addOutgoingEdge(edge: Edge): void;
+    canConnect(from: Gateway): boolean;
+    connectionDisplacement(c: Coordinates): Coordinates;
+    connectionDistance(c: Coordinates): number;
+    removeIncomingEdge(edge: Edge): void;
+    removeOutgoingEdge(edge: Edge): void;
+    get coordinates(): Coordinates;
+    get fill(): string | undefined;
+    get diagram(): import('../Diagram').Diagram;
+    get incomingEdges(): Edge[];
+    get outgoingEdges(): Edge[];
+    get radius(): number;
+    get relativePosition(): Coordinates;
+    get stroke(): string | undefined;
+    get strokeWidth(): number;
+    get id(): string;
+    get direction(): "horizontal" | "vertical";
+    get orientation(): import('../types').TOrientation;
+    recomputeConnectedEdge(edge: Edge, _movedSide: 'from' | 'to'): void;
+    updateEdges(): void;
+    get remainingSlots(): number;
+    deserialize(c: ReturnType<(typeof this)['serialize']>): void;
+    serialize(): {
+        coordinates: [number, number];
+        fill: string | undefined;
+        id: string;
+        orientation: import('../types').TOrientation;
+        radius: number;
+        stroke: string | undefined;
+        strokeWidth: number;
+        outEdges: {
+            arrowHeadEnd: import('../types').EdgeArrowHead | undefined;
+            arrowHeadStart: import('../types').EdgeArrowHead | undefined;
+            displacementEnd: [number, number] | undefined;
+            displacementStart: [number, number] | undefined;
+            lineStyle: import('../types').EdgeLineStyle | undefined;
+            pathType: import('../types').EdgePathType | undefined;
+            steps: import('./EdgePoint').TSerializedEdgePoint[];
+            stroke: string | undefined;
+            strokeWidth: number | undefined;
+            to: string;
+            toParentId: string;
+            class: string;
+        }[];
+        class: string;
+    };
+}

package/dist/Diagrams/store/elements/Node.d.ts

@@ -0,0 +1,73 @@
+import { TOrientation, TNodeState } from '../types';
+import { Dimensions } from '../primitives/Dimensions';
+import { Coordinates } from '../primitives/Coordinates';
+import { Diagram } from '../Diagram';
+import { Gateway } from './Gateway';
+import { Element } from './Element';
+import { ClassList } from '../../util/ClassList';
+import { FC } from 'react';
+export type TNodeConstructorProps = Pick<TNodeState, 'id' | 'label'> & Partial<TNodeState>;
+export declare class Node<Gateways = TOrientation> extends Element {
+    protected _gateways: Map<Gateways, Gateway>;
+    state: TNodeState;
+    readonly classList: ClassList;
+    get selected(): boolean | undefined;
+    constructor(parent: Element | null, state: TNodeConstructorProps);
+    canSelect(): boolean;
+    canUnselect(): boolean;
+    setDiagram(d: Diagram): void;
+    setState<K extends keyof TNodeState>(prop: K, value: TNodeState[K]): void;
+    protected initializeGateways(): void;
+    get box(): Dimensions;
+    get coordinates(): Coordinates;
+    displace(howMuch: Coordinates): void;
+    get id(): string;
+    get gateways(): Gateway[];
+    protected dragEventMouseStartPosition: Coordinates | null;
+    protected dragEventStartPosition: Coordinates | null;
+    getGateway(which: Gateways): Gateway | undefined;
+    setDimentions(c: Coordinates | [number, number]): void;
+    private updateConnectedEdges;
+    setPosition(c: Coordinates, options?: {
+        updateConnectedEdges?: boolean;
+    }): void;
+    deserialize(o: ReturnType<(typeof this)['serialize']>): void;
+    serialize(): {
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../types').EdgeLineStyle | undefined;
+                pathType: import('../types').EdgePathType | undefined;
+                steps: import('./EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    Renderer: FC | null;
+}

package/dist/Diagrams/store/elements/TextNode.d.ts

@@ -0,0 +1,4 @@
+import { Node } from './Node';
+export declare class TextNode extends Node {
+    protected initializeGateways(): void;
+}

package/dist/Diagrams/store/extensions/Creator.d.ts

@@ -0,0 +1,9 @@
+import { DClickEvent } from '../elements/Events';
+import { DiagramExtension } from './DiagramExtension';
+export type TCreationMode = 'none' | 'text';
+export declare class Creator extends DiagramExtension {
+    creationMode: TCreationMode;
+    init(): void;
+    protected getId(): string;
+    handleClick(ev: DClickEvent): void;
+}

package/dist/Diagrams/store/extensions/Debugger.d.ts

@@ -0,0 +1,6 @@
+export declare class Debugger {
+    data: string;
+    constructor();
+    set(what: string): void;
+}
+export declare const debug: Debugger;

package/dist/Diagrams/store/extensions/DiagramExtension.d.ts

@@ -0,0 +1,13 @@
+import { Diagram } from '../Diagram';
+import { Element } from '../elements/Element';
+export declare abstract class DiagramExtension extends Element {
+    parent: Diagram;
+    constructor(parent: Diagram);
+    abstract init(): void;
+    get diagram(): Diagram;
+    protected _enable: boolean;
+    get enabled(): boolean;
+    disable(): void;
+    enable(): void;
+    toggle(newValue?: boolean): void;
+}

package/dist/Diagrams/store/extensions/DistancesBalancer.d.ts

@@ -0,0 +1,13 @@
+import { DiagramExtension } from './DiagramExtension';
+import { Coordinates } from '../primitives/Coordinates';
+type Proposal = {
+    from: Coordinates;
+    to: Coordinates;
+};
+export declare class DistancesBalancer extends DiagramExtension {
+    private gridSize;
+    proposals: Proposal[];
+    clear(): void;
+    init(): void;
+}
+export {};

package/dist/Diagrams/store/extensions/Dragger.d.ts

@@ -0,0 +1,46 @@
+import { Diagram } from '../Diagram';
+import { Node } from '../elements/Node';
+import { Coordinates } from '../primitives/Coordinates';
+import { DMouseDownEvent, DMouseMoveEvent, DScaleEvent } from '../elements/Events';
+import { DiagramExtension } from './DiagramExtension';
+/**
+ * Conditions for dragging:
+ *
+ * - The mouse down must have been done in a node
+ * - The selection mode isn't enabled
+ * - The mouse button is the left click
+ */
+/**
+ */
+export declare class Dragger extends DiagramExtension {
+    private dragThreshold;
+    /**
+     * childId -> parentId, built at drag start for grouped nodes.
+     */
+    private groupedChildren;
+    init(): void;
+    constructor(parent: Diagram);
+    protected draggingNodes: Map<string, {
+        node: Node<any>;
+        startPoint: Coordinates;
+    }>;
+    protected startPoint: Coordinates;
+    protected startPointScaled: Coordinates;
+    protected mousePoint: Coordinates;
+    protected unsubscribe: () => void;
+    startDrag(node: Node, mousePoint?: Coordinates): void;
+    protected originalEvent: DMouseDownEvent | null;
+    protected handleMouseDown(ev: DMouseDownEvent): void;
+    protected handleMouseMove(ev: DMouseMoveEvent): void;
+    protected handleDragAction(): void;
+    private calcDisplacement;
+    private isFullyContained;
+    private collectConnectedEdges;
+    private translateEdge;
+    private updateEdgesAfterBatchMove;
+    private applyNodePositionProposals;
+    private includeGroupedChildren;
+    protected handleDragInterval(): void;
+    protected handleMouseUp(): void;
+    protected handleScale(_ev: DScaleEvent): void;
+}

package/dist/Diagrams/store/extensions/EdgesDragger.d.ts

@@ -0,0 +1,101 @@
+import { Coordinates } from '../primitives/Coordinates';
+import { Midpoint } from '../../components/objects/RenderEdge';
+import { EdgePoint } from '../elements/EdgePoint';
+import { Edge } from '../elements/Edge';
+import { AnyMouseEvent, DEdgeDragStartEvent, DEdgeEndpointDragStartEvent } from '../elements/Events';
+import { DiagramExtension } from './DiagramExtension';
+type DragContext = {
+    edge: Edge;
+    midpoint: Midpoint;
+    pointA: EdgePoint;
+    pointB: EdgePoint;
+    movedAxis: 'x' | 'y';
+    startMouseCanvas: Coordinates;
+    startPointA: Coordinates;
+    startPointB: Coordinates;
+    originalSteps: EdgePoint[];
+    sourceLeadAdjacent: boolean;
+    targetLeadAdjacent: boolean;
+    staticBoundaryGuarded: boolean;
+    changed: boolean;
+};
+type EndpointDragContext = {
+    edge: Edge;
+    endpoint: 'from' | 'to';
+};
+type EdgeEndSide = 'from' | 'to';
+type PreparedSegment = {
+    pointA: EdgePoint;
+    pointB: EdgePoint;
+    movedAxis: 'x' | 'y';
+};
+export declare class EdgesDragger extends DiagramExtension {
+    protected drag: DragContext | null;
+    protected endpointDrag: EndpointDragContext | null;
+    protected uns: () => void;
+    init(): void;
+    protected almostEqual(a: number, b: number): boolean;
+    protected pointMatches(a: Coordinates, b: Coordinates): boolean;
+    protected axisAligned(a: Coordinates, b: Coordinates): boolean;
+    protected pointsNear(a: Coordinates, b: Coordinates, epsilon?: number): boolean;
+    protected isActivePoint(point: EdgePoint): boolean;
+    protected getGridSize(): number;
+    protected orientationVector(orientation: 'up' | 'down' | 'left' | 'right'): {
+        x: number;
+        y: number;
+    };
+    protected axisPerpendicularToGateway(orientation: 'up' | 'down' | 'left' | 'right'): 'x' | 'y';
+    protected expectedLeadPoint(edge: Edge, side: EdgeEndSide): Coordinates;
+    protected leadMatchesGatewaySide(endpoint: Coordinates, lead: Coordinates, orientation: 'up' | 'down' | 'left' | 'right'): boolean;
+    protected endpointLeadPoint(edge: Edge, side: EdgeEndSide): Coordinates | EdgePoint;
+    protected ensureEndpointLeadPoint(edge: Edge, side: EdgeEndSide): number;
+    protected ensureEndpointLeads(edge: Edge): void;
+    protected isProtectedLeadPoint(edge: Edge, index: number): boolean;
+    protected segmentMovedAxis(a: Coordinates, b: Coordinates): 'x' | 'y';
+    protected segmentDirection(a: Coordinates, b: Coordinates): "horizontal" | "vertical" | null;
+    protected segmentIsParallelToDraggedAxis(a: Coordinates, b: Coordinates): boolean;
+    protected perpendicularAxis(axis: 'x' | 'y'): 'x' | 'y';
+    protected pointAxis(point: Coordinates, axis: 'x' | 'y'): number;
+    protected setPointAxis(point: Coordinates, axis: 'x' | 'y', value: number): void;
+    protected crossesStaticBoundary(orientation: 'up' | 'down' | 'left' | 'right', movedAxis: 'x' | 'y', point: Coordinates, boundary: Coordinates, threshold?: number): boolean;
+    protected copyAsManual(point: EdgePoint, axis?: 'x' | 'y' | 'both'): EdgePoint;
+    protected markManual(point: EdgePoint, axis?: 'x' | 'y' | 'both'): void;
+    protected clampPointPastLead(point: EdgePoint, lead: Coordinates, orientation: 'up' | 'down' | 'left' | 'right'): void;
+    protected movedAxisMatchesOrientation(movedAxis: 'x' | 'y', orientation: 'up' | 'down' | 'left' | 'right'): boolean;
+    protected edgePointAt(edge: Edge, x: number, y: number, mode?: 'auto' | 'manual' | 'static'): EdgePoint;
+    protected guardCoordinate(edge: Edge, side: EdgeEndSide, lead: Coordinates, oppositePoint: Coordinates, perpendicularAxis: 'x' | 'y'): number;
+    protected makeGuardCorner(edge: Edge, lead: Coordinates, guardCoordinate: number, movedAxis: 'x' | 'y'): EdgePoint;
+    protected insertStaticBoundaryGuard(side: EdgeEndSide): boolean;
+    protected insertStaticBoundaryGuards(): boolean;
+    protected clampDraggedSegmentAgainstEndpointLeads(): void;
+    protected mergeDraggedSegmentWithManualNeighbors(): boolean;
+    protected rebaseDraggedEndpointFixedAxis(side: 'pointA' | 'pointB', point: EdgePoint): void;
+    protected replaceDraggedEndpointWithProtectedLeadDuplicate(side: 'pointA' | 'pointB', lead: EdgePoint, replacedIndex: number): void;
+    protected absorbCollinearSegmentsIntoDraggedSegment(): boolean;
+    protected removeAdjacentDuplicates(preserveActivePoints: boolean): boolean;
+    protected coordinateAnchorForPair(a: EdgePoint, b: EdgePoint, axis: 'x' | 'y', aIndex: number): number;
+    protected snapNearlyAlignedDraggedPairs(): boolean;
+    protected chooseOrthogonalCorner(from: EdgePoint, to: EdgePoint, previous?: EdgePoint, next?: EdgePoint): EdgePoint;
+    protected ensureOrthogonalAdjacency(): boolean;
+    protected normalizeDraggedEdge(): boolean;
+    protected finalizeDraggedEdge(): void;
+    protected prepareStraightLeadSegment(edge: Edge, movedAxis: 'x' | 'y'): {
+        pointA: EdgePoint;
+        pointB: EdgePoint;
+        movedAxis: "x" | "y";
+    };
+    protected prepareSourceSegment(edge: Edge): PreparedSegment | null;
+    protected prepareTargetSegment(edge: Edge): PreparedSegment | null;
+    protected prepareSegmentAfterProtectedSourceLead(edge: Edge, leadIndex: number): PreparedSegment | null;
+    protected prepareSegmentBeforeProtectedTargetLead(edge: Edge, leadIndex: number): PreparedSegment | null;
+    protected prepareInteriorSegment(edge: Edge, pointA: EdgePoint, pointB: EdgePoint, fallbackSegmentIndex: number): PreparedSegment | null;
+    protected restoreOriginalSteps(edge: Edge, steps: EdgePoint[]): void;
+    startDrag(ev: DEdgeDragStartEvent): void;
+    startEndpointDrag(ev: DEdgeEndpointDragStartEvent): void;
+    protected scheduleEndpointRecompute(): void;
+    protected handleEndpointMouseMove(ev: AnyMouseEvent): void;
+    protected moveDraggedSegment(ev: AnyMouseEvent): void;
+    protected handleMouseMove(ev: AnyMouseEvent): void;
+    protected handleMouseUp(): void;
+}
+export {};

package/dist/Diagrams/store/extensions/GridSnap.d.ts

@@ -0,0 +1,5 @@
+import { DiagramExtension } from './DiagramExtension';
+export declare class GridSnap extends DiagramExtension {
+    gridSize: number;
+    init(): void;
+}

package/dist/Diagrams/store/extensions/History.d.ts

@@ -0,0 +1,15 @@
+import { DiagramExtension } from './DiagramExtension';
+export declare class History extends DiagramExtension {
+    private readonly windowTime;
+    private readonly maxSize;
+    private index;
+    private snapshots;
+    private avoidEvents;
+    unbind: () => void;
+    private window;
+    redo(): void;
+    undo(): void;
+    get hasNext(): boolean;
+    get hasPrevious(): boolean;
+    init(): void;
+}

package/dist/Diagrams/store/extensions/Hotkeys.d.ts

@@ -0,0 +1,22 @@
+import { DKeyDownEvent } from '../elements/Events';
+import { DiagramExtension } from './DiagramExtension';
+import { Callback } from '../elements/Element';
+export type THotKey = Partial<{
+    code: string;
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+}> & {
+    cb: Callback<DKeyDownEvent>;
+};
+export declare class Hotkeys extends DiagramExtension {
+    hotkeys: THotKey[];
+    private isEditableTarget;
+    private shouldIgnoreHotkeys;
+    private get measurer();
+    private get selector();
+    private match;
+    init(): void;
+    register(hotkey: THotKey): () => void;
+    protected revertHotkey: Map<string, () => unknown>;
+}

package/dist/Diagrams/store/extensions/Measurer.d.ts

@@ -0,0 +1,17 @@
+import { Coordinates } from '../primitives/Coordinates';
+import { AnyMouseEvent, DMouseDownEvent } from '../elements/Events';
+import { DiagramExtension } from './DiagramExtension';
+export declare class Measurer extends DiagramExtension {
+    init(): void;
+    protected _enabled: boolean;
+    toggle(): void;
+    get enabled(): boolean;
+    protected endPoint: Coordinates | null;
+    protected startPoint: Coordinates | null;
+    get(): Coordinates[];
+    getMeassurement(): number | undefined;
+    u: () => void;
+    protected handleMouseDown(ev: DMouseDownEvent): void;
+    protected handleMouseMove(ev: AnyMouseEvent): void;
+    protected handleMouseUp(): void;
+}

package/dist/Diagrams/store/extensions/NodesAligner.d.ts

@@ -0,0 +1,19 @@
+import { DiagramExtension } from './DiagramExtension';
+type Proposal = {
+    type: 'v';
+    y: number;
+    range: [number, number];
+    id: string;
+} | {
+    type: 'h';
+    x: number;
+    range: [number, number];
+    id: string;
+};
+export declare class NodesAligner extends DiagramExtension {
+    private gridSize;
+    proposals: Proposal[];
+    clear(): void;
+    init(): void;
+}
+export {};