@visuallyjs/browser-ui 1.0.0

package/types/browser-ui/connector-editor.d.ts

@@ -0,0 +1,65 @@
+import { Edge, Vertex, PointXY, ObjectAnchorSpec } from "../core";
+import { Connection, FullOverlaySpec } from "../ui";
+/**
+ * Base options for activating a path editor.
+ * @group Edges
+ * @category Path Editors
+ */
+export interface ConnectorEditorActivateParams<EL> {
+    /**
+     * If true, show a button the user can use to delete the edge. Defaults to false.
+     */
+    deleteButton?: boolean;
+    /**
+     * Classname to set on the delete button. Defaults to "vjs-edge-delete".
+     */
+    deleteButtonClass?: string;
+    /**
+     * Location on the path to put the delete button, as a measure of the length of the path. For instance,
+     * the default value of 0.1 means the delete button will be placed at a point that is 1/10th of the total length of the path.
+     * Note that you can supply an array of positions here and one delete button will be created for each entry.
+     */
+    deleteButtonLocation?: number | Array<number>;
+    /**
+     * Optional function allowing you to specify the location of the placeholder when the user
+     * is dragging anchor.
+     * @param el
+     * @param elxy
+     * @param vertex
+     */
+    anchorPositionFinder?: (el: EL, elxy: PointXY, vertex: Vertex) => ObjectAnchorSpec | null;
+    /**
+     * Optional array of allowed positions for anchors to be relocated to
+     */
+    anchorPositions?: Array<ObjectAnchorSpec>;
+    /**
+     * Optional interceptor to invoke when the user presses the delete button. If the user wishes to go ahead
+     * with the edge deletion, `doDelete` will be invoked.
+     * @param edge
+     * @param connection
+     * @param doDelete
+     */
+    onMaybeDelete?: (edge: Edge, connection: Connection<EL>, doDelete: (data: Record<string, any>) => any) => any;
+    /**
+     * Optional array of overlays to decorate the edge with while it is being edited.
+     */
+    overlays?: Array<FullOverlaySpec>;
+}
+/**
+ * @internal
+ */
+export interface ConnectorEditor<EL> {
+    reset(): void;
+    activate<T extends ConnectorEditorActivateParams<EL>>(edge: Edge, connection: Connection<EL>, params?: T): void;
+    deactivate(e?: Event): void;
+    /**
+     * Returns whether or not the editor has been activated.
+     */
+    isActive(): boolean;
+    /**
+     * Returns whether or not the editor is in the middle of an operation - the user
+     * is dragging a handle, typically.
+     */
+    isBusy(): boolean;
+    $supportsHoverMode: boolean;
+}

package/types/browser-ui/connector-editors/anchors.d.ts

@@ -0,0 +1,31 @@
+import { PointXY, RectangleXY, Vertex } from "../../core";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+import { BrowserElement } from "../util";
+import { AnchorPositionFinder, AnchorRecord, Connection, Face, LightweightAnchor, LightweightContinuousAnchor } from "../../ui";
+/**
+ * @internal
+ */
+export declare function relocateContinuousAnchor(anchor: LightweightContinuousAnchor, pos: PointXY, constrainRect: RectangleXY): [AnchorRecord, Face];
+/**
+ * Relocate the given dynamic anchor according to the given proximity of `pos` to each of the anchor's supported locations. the face is changed
+ * on the anchor itself (and the anchor is locked), and in this case we simply return the current value of `pos`, meaning the user sees the drag proxy
+ * under the mouse cursor, which is probably not where the anchor is now positioned, but it makes for a better UX. on drag stop, for all anchor types,
+ * the anchor proxy is relocated to the current value.
+ * @param anchor
+ * @param pos
+ * @param constrainRect
+ * @internal
+ */
+export declare function relocateDynamicAnchor(anchor: LightweightAnchor, pos: PointXY, constrainRect: RectangleXY): AnchorRecord;
+/**
+ * @internal
+ * @param anchor
+ * @param anchorPositionFinder
+ * @param actualElement
+ * @param proportionalPos
+ * @param vertex
+ * @param constrainRect
+ * @param connection
+ * @param instance
+ */
+export declare function relocateWithPositionFinder(anchor: LightweightAnchor, anchorPositionFinder: AnchorPositionFinder<BrowserElement>, actualElement: BrowserElement, proportionalPos: PointXY, vertex: Vertex, constrainRect: RectangleXY, connection: Connection<any>, instance: BrowserUI): AnchorRecord;

package/types/browser-ui/connector-editors/css-constants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Added to the element placed at the location of an anchor for a connection that is being edited, and to the candidate locations when the anchor is being dragged.
+ * @group Edges
+ * @category CSS Classes
+ * @cssClass
+ * @context edges, path-editors
+ */
+export declare const CLASS_ANCHOR_PLACEHOLDER = "vjs-anchor-placeholder";
+/**
+ * Added to the elements drawn to show where a certain anchor may be relocated to (only applicable for dynamic anchors)
+ * @group Edges
+ * @category CSS Classes
+ * @cssClass
+ * @context edges, path-editors
+ */
+export declare const CLASS_ANCHOR_CANDIDATE = "vjs-anchor-candidate";
+export declare const CLASS_CONNECTION_EDIT = "vjs-connection-edit";
+/**
+ * CSS class added to an edge guideline by a connector editor
+ * @group Edges
+ * @category CSS Classes
+ * @cssClass
+ * @context edges, path-editors
+ */
+export declare const CLASS_EDGE_GUIDELINE = "vjs-edge-guideline";
+/**
+ * Class applied to edge drag handles.
+ * @group Edges
+ * @category Path Editors
+ * @cssClass
+ * @context edges, path-editors
+ */
+export declare const EDGE_DRAG_HANDLE = "vjs-edge-handle";

package/types/browser-ui/connector-editors/definitions.d.ts

@@ -0,0 +1,74 @@
+import { Connection, LightweightAnchor, StraightConnectorSegment } from "../../ui";
+import { Edge, PointXY, Vertex } from "../../core";
+/**
+ * @internal
+ */
+export declare const ANCHOR_PLACEHOLDER_SELECTOR: string;
+/** @internal */
+export interface SegmentEditorInfo<HandleType, SegmentType = StraightConnectorSegment> {
+    el: HandleType;
+    segment: SegmentType;
+    edge: Edge;
+    connection: Connection<any>;
+}
+/**
+ * @internal
+ */
+export interface BaseEdgeEditorHandleElement<InfoType extends SegmentEditorInfo<any, any>> extends HTMLElement {
+    _vjsDragHandle: InfoType;
+}
+/**
+ * The default width and height of the buttons added by a path editor.
+ * @group Edges
+ * @category Path Editors
+ * @constant
+ */
+export declare const DEFAULT_CONNECTOR_EDITOR_BUTTON_SIZE = 12;
+/**
+ * The default width and height in pixels of the element used to show the current position of a dynamic anchor, and the positions to which it may be dragged.
+ * @group Edges
+ * @category Path Editors
+ * @constant
+ */
+export declare const DEFAULT_ANCHOR_PLACEHOLDER_SIZE = 15;
+/**
+ * Base options for a ConnectorEditor. The options for specific editors extend this interface.
+ * @group Edges
+ * @category Path Editors
+ */
+export interface ConnectorEditorOptions {
+    /**
+     * When true (which is the default), tells the EdgePathEditor to mark any new connection dragged with the mouse as "edited", ie. to fix the initial geometry. This is particularly beneficial when using an `anchorPositionFinder`: it results in every new edge having a 'geometry' object, so that if you export the dataset, you will get the anchor values you chose in your anchorPositionFinder. If an edge does not get exported with geometry for its path, next time it is loaded it will be assigned anchors automatically, which may or may not match the anchors you actually wanted.
+     */
+    activeMode?: boolean;
+    /**
+     * When true, the path editor is activated when the user hovers over an edge. For touch devices this is ignored, since there are no hover events.
+     */
+    hoverMode?: boolean;
+    /**
+     * The width and height in pixels of the element used to show the current position of a dynamic anchor, and the positions to which it may be dragged. Defaults to {@link DEFAULT_ANCHOR_PLACEHOLDER_SIZE}
+     */
+    anchorPlaceholderSize?: number;
+    /**
+     * The width and height of the buttons added by this editor.
+     */
+    buttonSize?: number;
+}
+/**
+ * @internal
+ */
+export type AnchorDragContext = {
+    rotation: number;
+    center: PointXY;
+};
+/**
+ * @internal
+ */
+export interface AnchorPlaceholderElement extends HTMLElement {
+    _vjsAnchor: {
+        anchor: LightweightAnchor;
+        vertex: Vertex;
+        idx: number;
+        edge: Edge;
+    };
+}

package/types/browser-ui/connector-editors/editor-base.d.ts

@@ -0,0 +1,177 @@
+import { Edge, Group, Node } from "../../core";
+import { BrowserElement } from "../util";
+import { DragHandler2, Connector, Connection } from "../../ui";
+import { ConnectorEditorOptions } from "./definitions";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+import { ConnectorEditor, ConnectorEditorActivateParams } from "../connector-editor";
+import { EventManager } from "../event-manager";
+/**
+ * Base class for connector editors.  This isn't a class that users of the API will ordinarily need to interact
+ * directly with.
+ * @internal
+ */
+export declare abstract class EditorBase<ConnectorType extends Connector> implements ConnectorEditor<BrowserElement> {
+    ui: BrowserUI;
+    current: Connection<BrowserElement>;
+    currentConnector: ConnectorType;
+    protected currentEdge: Edge;
+    private _currentEdgeType;
+    private _currentEdgeTypeMapping;
+    $currentEdgeFrame: SVGElement;
+    $generatedGeometry: any;
+    $hasEdits: boolean;
+    private _anchorCandidates;
+    currentOverlays: Array<any>;
+    protected sourceDimensions: any;
+    protected targetDimensions: any;
+    private _sourceAnchorPlaceholder;
+    private _targetAnchorPlaceholder;
+    private _geometryAtStartOfAnchorDrag;
+    private _active;
+    private _$busy;
+    abstract $supportsHoverMode: boolean;
+    buttonSize: number;
+    private readonly _anchorPlaceholderSize;
+    private sourceAnchorPositionFinder;
+    private targetAnchorPositionFinder;
+    eventManager: EventManager;
+    private _currentAnchorPositionFinder;
+    private _anchorVertex;
+    private _dragHandlers;
+    private _anchorDragContext;
+    abstract $repaint(args?: any): void;
+    isBusy(): boolean;
+    private _repaint;
+    /**
+     * @internal
+     */
+    $cloneCurrentGeometry(): any;
+    /**
+     * For the given vertex type, retrieve its type definition and return any `anchorPositions` that were
+     * registered for it.
+     * @param vertex
+     * @private
+     */
+    private _resolveAnchorPositions;
+    protected constructor(ui: BrowserUI, options?: ConnectorEditorOptions);
+    private _attachOverlay;
+    private _attachOverlays;
+    private _detachOverlays;
+    private _attachDeleteButton;
+    /**
+     * Repaints the current connection, passing some arguments, optionally. These are retrieved inside `refresh`, and are ultimately handed off to the subclass's `repaint` method. Subclasses should call this on things like handle dragging, as the existence (and nature of ) args can subsequently be used by their `repaint` method to decide whether or not to redraw all the handles (such as you would in the event of an external paint event), or just to reposition the existing ones. During a drag, of course, blowing away the current handle would be bad.
+     * @internal
+     */
+    protected $repaintConnection(args?: any): void;
+    /**
+     * Updates the model with new geometry for the given edge.
+     * @internal
+     */
+    protected $updateModel(geometry: any, originalGeometry: any): void;
+    /**
+     * Redraw anchor placeholders and editor handles.
+     * @param args Optional args to pass to the subclass repaint method.
+     * @internal
+     */
+    private _refresh;
+    /**
+     * Draws, or repositions if they exist already, the anchor placeholders for the current connection.
+     * @internal
+     */
+    private _drawAnchorPlaceholders;
+    /**
+     * Removes anchor placeholders.
+     * @internal
+     */
+    private _cleanupAnchors;
+    /**
+     * @internal
+     */
+    private _clearGeometry;
+    /**
+     * @internal
+     */
+    reset(): void;
+    /**
+     * @internal
+     */
+    isActive(): boolean;
+    /**
+     * Sets the position of the handle where x,y identifies the desired location of the handle's center. This method
+     * gets the element size from the dom in order to adjust the handle location.
+     * @internal
+     * @param el
+     * @param x
+     * @param y
+     */
+    protected $setElementPosition(el: HTMLElement | SVGElement, x: number, y: number): void;
+    /**
+     * Activate the editor, with the given Connection.
+     * @param edge - Edge to edit.
+     * @param connection - Connection to activate the editor for.
+     * @param params - optional params for the activation. The type of this depends on the subclass.
+     * @internal
+     */
+    activate<T extends ConnectorEditorActivateParams<BrowserElement>>(edge: Edge, connection: Connection<BrowserElement>, params?: T): void;
+    /**
+     * Deactivates the editor, removing all editor handles and anchor placeholders etc. May be called directly by an
+     * API user but mostly calling this method is handled internally.
+     * @param e
+     */
+    deactivate(e?: Event): void;
+    /**
+     * @internal
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @param clazz
+     * @param visible
+     */
+    $makeAndAppendCircularHandle(x: number, y: number, width: number, height: number, clazz: string, visible?: boolean): SVGElement;
+    $makeAndAppendRectangularHandle(x: number, y: number, width: number, height: number, rx: number, ry: number, clazz: string, visible?: boolean): SVGElement;
+    $makeAndAppendDeleteHandle(x: number, y: number, width: number, height: number, clazz: string, visible?: boolean): SVGElement;
+    protected $addDragHandler(o: DragHandler2<BrowserElement>): void;
+    /**
+     * An element is being dragged.
+     * @param vertex
+     * @internal
+     */
+    private _elementDragging;
+    private _elementDragged;
+    /**
+     * Abstract method for subclasses to implement. This method is expected to clear everything out of the DOM that the
+     * editor has drawn.
+     * @private
+     * @internal
+     */
+    abstract $clearHandles(): void;
+    /**
+     * Abstract method for subclasses to implement.
+     * @param conn
+     * @param params
+     * @internal
+     */
+    abstract $activate(conn: Connection<BrowserElement>, params?: any): void;
+    /**
+     * Notification that an element has just been dragged. Subclasses should implement.
+     * The orthogonal editor trims the edge in response to this. The other editors dont do
+     * anything.
+     * @param vertex
+     * @internal
+     */
+    abstract $elementDragged(vertex: Node | Group): void;
+    /**
+     * Notification that an element is being dragged. Subclasses should implement.
+     * Typically they just repaint.
+     * @param vertex
+     * @internal
+     */
+    abstract $elementDragging(vertex: Node | Group): void;
+    /**
+     * Returns whether the given vertex is either the source or target of the current edge, or if it is the parent vertex for the source or target of the current edge, where the source/target is a port
+     * @param vertex
+     * @internal
+     */
+    private _isEdgeVertexOrParent;
+}

package/types/browser-ui/connector-editors/index.d.ts

@@ -0,0 +1,52 @@
+import { Edge, Constructable } from "../../core";
+import { BrowserElement } from "../util";
+import { ConnectorEditor, ConnectorEditorActivateParams } from "../connector-editor";
+import { ConnectorEditorOptions } from "./definitions";
+import { Connection } from "../../ui";
+import { Surface } from "../surface-renderer";
+export declare const editors: Map<string, Constructable<ConnectorEditor<BrowserElement>>>;
+export * from "./editor-base";
+export * from './css-constants';
+export * from './definitions';
+export * from './util';
+export * from './anchors';
+/**
+ * Editor for edge paths. Supports all connector types.
+ * @group Edges
+ */
+export declare class EdgePathEditor {
+    readonly ui: Surface;
+    private readonly _options?;
+    private _connectorEditors;
+    private readonly _hoverMode;
+    private _suspended;
+    private _currentEdge;
+    private _activeEditor;
+    constructor(ui: Surface, _options?: ConnectorEditorOptions);
+    /**
+     * Start editing the given edge or connection, optionally with the given edit parameters.
+     * @param edgeOrConnection
+     * @param params
+     */
+    startEditing<T extends ConnectorEditorActivateParams<BrowserElement>>(edgeOrConnection: Edge | Connection<BrowserElement>, params?: T): void;
+    /**
+     * Stop editing any connector paths.
+     *
+     */
+    stopEditing(): void;
+    /**
+     * Clear the edits for the given connection, returning its path to the automatically computed path.
+     * @param edgeOrConnection
+     */
+    clearEdits(edgeOrConnection: string | Edge | Connection<BrowserElement>): boolean;
+    /**
+     * Resolves a `Connection` from the given input, which can be an edge id, Edge, or Connection.
+     * @param edgeOrConnection ID of an Edge, Edge, or Connection
+     * @internal
+     */
+    private _resolveConnection;
+    /**
+     * Destroy the path editor - clears the internal map of editors and released held memory.
+     */
+    destroy(): void;
+}

package/types/browser-ui/connector-editors/util.d.ts

@@ -0,0 +1,33 @@
+import { BrowserElement } from "../util";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+/**
+ * @internal
+ * @param radius
+ * @param clazz
+ * @param visible
+ */
+export declare function $makeCircularHandle(radius: number, clazz: string, atts: Record<string, any>, visible?: boolean): SVGElement;
+export declare function $makeRectangularHandle(width: number, height: number, rx: number, ry: number, clazz: string, atts: Record<string, any>, visible?: boolean): SVGElement;
+export declare function $makeSvgAnchorPlaceholder<E extends HTMLElement>(ui: BrowserUI, parent: BrowserElement, x: number, y: number, width: number, height: number, clazz: string, visible?: boolean): E;
+/**
+ * Make a circular svg handle, appends it to the tools layer for the given surface, then returns the element.
+ * @param ui
+ * @param x
+ * @param y
+ * @param width
+ * @param clazz
+ * @param visible
+ * @internal
+ */
+export declare function $makeAndAppendCircularHandle(ui: BrowserUI, x: number, y: number, width: number, clazz: string, atts: Record<string, any>, visible?: boolean): SVGElement;
+/**
+ * Make a rectangular svg handle, appends it to the tools layer for the given surface, then returns the element.
+ * @param ui
+ * @param x
+ * @param y
+ * @param width
+ * @param clazz
+ * @param visible
+ * @internal
+ */
+export declare function $makeAndAppendRectangularHandle(ui: BrowserUI, x: number, y: number, width: number, height: number, rx: number, ry: number, clazz: string, atts: Record<string, any>, visible?: boolean): SVGElement;

package/types/browser-ui/connector-editors-bezier/bezier-editor.d.ts

@@ -0,0 +1,82 @@
+import { EditorBase } from "../connector-editors/editor-base";
+import { Group, Node } from "../../core";
+import { ConnectorEditorOptions } from "../connector-editors/definitions";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+import { BrowserElement } from "../util";
+import { Connection, CubicBezierConnector } from "../../ui";
+/**
+ * Options for a bezier path editor.
+ * @group Edges
+ * @category Path Editors
+ */
+export interface BezierEditorOptions extends ConnectorEditorOptions {
+    /**
+     * What size to use for handles. Defaults to 12 pixels.
+     */
+    handleSize?: number;
+}
+/**
+ * @internal
+ */
+interface BezierEditorHandleElement extends HTMLElement {
+    idx: 0 | 1;
+}
+/**
+ * @internal
+ */
+interface BezierEditorGuidelineElement extends SVGElement {
+}
+/**
+ * Path editor for Bezier connectors.
+ * @group Edges
+ * @category Path Editors
+ */
+export declare class BezierEditor extends EditorBase<CubicBezierConnector> {
+    static type: string;
+    $supportsHoverMode: boolean;
+    /** @internal */
+    h1: BezierEditorHandleElement;
+    /** @internal */
+    h2: BezierEditorHandleElement;
+    /** @internal */
+    l1: BezierEditorGuidelineElement;
+    /** @internal */
+    l2: BezierEditorGuidelineElement;
+    /** @internal */
+    lockHandles: boolean;
+    private readonly _handleSize;
+    private _cp1;
+    private _cp2;
+    private _sp;
+    private _tp;
+    private _cp1AtDragStart;
+    private _cp2AtDragStart;
+    /** @internal */
+    constructor(ui: BrowserUI, params: BezierEditorOptions);
+    $activate(conn: Connection<BrowserElement>, params?: {
+        guidelines?: boolean;
+    }): void;
+    $clearHandles(): void;
+    $elementDragged(vertex: Node | Group): void;
+    $elementDragging(vertex: Node | Group): void;
+    $repaint(args?: any): void;
+    private _makeHandles;
+    private _updateHandlePositions;
+    private _makeGuideline;
+    private _updateGuidelines;
+    private _updateGuideline;
+    private _updateControlPoints;
+    private _updateSourceAndTargetPoints;
+}
+/**
+ * Path editor for QuadraticBezier connectors.
+ * @group Edges
+ * @category Path Editors
+ */
+export declare class QuadraticBezierEditor extends BezierEditor {
+    /** @internal */
+    static type: string;
+    /** @internal */
+    constructor(ui: BrowserUI, params: any);
+}
+export {};

package/types/browser-ui/connector-editors-bezier/css-constants.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CSS class added to all handles used by the bezier edge editor.
+ * @group Edges
+ * @category Path Editors
+ */
+export declare const CLASS_BEZIER_HANDLE = "vjs-bezier-handle";
+/**
+ * CSS class assigned to a control point handle in the bezier edge editor
+ * @group Edges
+ * @category Path Editors
+ */
+export declare const CLASS_BEZIER_HANDLE_CONTROL_POINT = "vjs-bezier-handle-control-point";
+/**
+ * CSS class assigned to the first control point handle in the bezier edge editor
+ * @group Edges
+ * @category Path Editors
+ */
+export declare const CLASS_BEZIER_HANDLE_CONTROL_POINT_1 = "vjs-bezier-handle-control-point-1";
+/**
+ * CSS class assigned to the second control point handle in the bezier edge editor
+ * @group Edges
+ * @category Path Editors
+ */
+export declare const CLASS_BEZIER_HANDLE_CONTROL_POINT_2 = "vjs-bezier-handle-control-point-2";
+/**
+ * @internal
+ */
+export declare const CLASS_BEZIER_SECONDARY_HANDLE = "vjs-bezier-handle-secondary";
+/**
+ * @internal
+ */
+export declare const CLASS_BEZIER_SECONDARY_SOURCE_HANDLE = "vjs-bezier-handle-secondary-source";
+/**
+ * @internal
+ */
+export declare const CLASS_BEZIER_SECONDARY_TARGET_HANDLE = "vjs-bezier-handle-secondary-target";
+/**
+ * CSS class assigned to the guidelines linking the anchor points with the control point markers in the bezier edge editor.
+ * @group Edges
+ * @category Path Editors
+ */
+export declare const CLASS_BEZIER_GUIDELINE = "vjs-bezier-guideline";

package/types/browser-ui/connector-editors-bezier/index.d.ts

@@ -0,0 +1,9 @@
+export * from './css-constants';
+export * from "./bezier-editor";
+/**
+ * Register the bezier/quadratic bezier editors with the connector editors modules. It is not necessary for
+ * library users to manually call this method.
+ * @group Factory Methods
+ * @internal
+ */
+export declare function initializeBezierConnectorEditors(): void;

package/types/browser-ui/connector-editors-orthogonal/css-constants.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Assigned to all handles in the orthogonal editor
+ * @group Edges
+ * @category Path Editors
+ * @constant
+ */
+export declare const CLASS_ORTHOGONAL_HANDLE: string;
+/**
+ * Assigned to segment drag handles in the orthogonal editor
+ * @group Edges
+ * @category Path Editors
+ * @constant
+ */
+export declare const CLASS_ORTHOGONAL_SEGMENT_DRAG_HANDLE: string;
+/**
+ * Assigned to segment drag handles on horizontal segments in the orthogonal editor. Indicates a segment can be dragged in the Y axis
+ * @group Edges
+ * @category Path Editors
+ * @constant
+ */
+export declare const CLASS_ORTHOGONAL_SEGMENT_DRAG_HANDLE_VERTICAL: string;
+/**
+ * Assigned to segment drag handles on vertical segments in the orthogonal editor. Indicates a segment can be dragged in the X axis
+ * @group Edges
+ * @category Path Editors
+ * @constant
+ */
+export declare const CLASS_ORTHOGONAL_SEGMENT_DRAG_HANDLE_HORIZONTAL: string;

package/types/browser-ui/connector-editors-orthogonal/index.d.ts

@@ -0,0 +1,9 @@
+export * from './css-constants';
+export * from "./orthogonal-editor";
+/**
+ * Register the orthogonal editor with the connector editors modules. It is not necessary for
+ * library users to manually call this method.
+ * @group Factory Methods
+ * @internal
+ */
+export declare function initializeOrthogonalConnectorEditors(): void;