@visuallyjs/browser-ui 1.0.0

package/types/ui/core/connector/connections.d.ts

@@ -0,0 +1,113 @@
+import { Connection } from "./connection-impl";
+import { OverlaySpec, Connector, ConnectorSpec } from "../../common";
+import { Overlay } from "../overlay/overlay";
+import { LabelOverlay } from "../overlay/label-overlay";
+import { CompiledTypeDescriptor } from "../type-descriptors";
+import { PointXY } from "../../../core";
+export declare const _internalSourceMarkerOverlayId = "___sourceMarker";
+export declare const _internalTargetMarkerOverlayId = "___targetMarker";
+export declare const _internalLabelOverlayId = "__label";
+export declare const _internalLabelOverlayClass = "vjs-default-label";
+export declare const TYPE_ITEM_OVERLAY = "overlay";
+export declare const LOCATION_ATTRIBUTE = "labelLocation";
+/**
+ * Add an overlay to the connection.  This method is not intended for use by users of the API. You must `revalidate` an associated element for this component if you call this method directly. Consider using the `addOverlay` method of `UICore` instead, which adds the overlay and then revalidates.
+ * @param overlay
+ * @internal
+ */
+export declare function $addOverlay<EL>(c: Connection<EL>, overlay: OverlaySpec): Overlay<EL>;
+/**
+ * Get the Overlay with the given ID. You can optionally provide a type parameter for this method in order to get
+ * a typed return value (such as `LabelOverlay`, `ArrowOverlay`, etc), since some overlays have methods that
+ * others do not.
+ * @param id ID of the overlay to retrieve.
+ * @internal
+ */
+export declare function $getOverlay<T extends Overlay<EL>, EL>(c: Connection<EL>, id: string): T;
+/**
+ * Gets all the overlays registered on this component.
+ * @internal
+ */
+export declare function $getOverlays<EL>(c: Connection<EL>): Record<string, Overlay<EL>>;
+/**
+ * Hide the overlay with the given id.
+ * @param id
+ * @internal
+ */
+export declare function $hideOverlay<EL>(c: Connection<EL>, id: string): void;
+/**
+ * Hide all overlays, or a specific set of overlays.
+ * @param ids optional list of ids to hide.
+ * @internal
+ */
+export declare function _hideOverlays<EL>(c: Connection<EL>, ...ids: Array<string>): void;
+/**
+ * Show a specific overlay (set it to be visible)
+ * @param id
+ * @internal
+ */
+export declare function _showOverlay<E>(c: Connection<E>, id: string): void;
+/**
+ * Show all overlays, or a specific set of overlays.
+ * @param ids optional list of ids to show.
+ * @internal
+ */
+export declare function _showOverlays<E>(c: Connection<E>, ...ids: Array<string>): void;
+/**
+ * Remove all overlays from this component.
+ * @internal
+ */
+export declare function _removeAllOverlays<E>(c: Connection<E>): void;
+/**
+ * Remove the overlay with the given id.
+ * @param overlayId
+ * @param dontCleanup This is an internal parameter. You are not encouraged to provide a value for this.
+ * @internal
+ */
+export declare function _removeOverlay<E>(c: Connection<E>, overlayId: string, dontCleanup?: boolean): void;
+/**
+ * Remove the given set of overlays, specified by their ids.
+ * @param overlays
+ * @internal
+ */
+export declare function _removeOverlays<E>(c: Connection<E>, ...overlays: string[]): void;
+/**
+ * @internal
+ */
+export declare function _getLabelOverlay<EL>(c: Connection<EL>): LabelOverlay<EL>;
+/**
+ * Set this component's label.
+ * @param l Either some text, or a function which returns some text, or an existing label overlay.
+ * @internal
+ */
+export declare function _setConnectionLabel<EL>(c: Connection<EL>, l: string | Function | LabelOverlay<EL>): void;
+export declare const ACTION_ADD = "add";
+export declare const ACTION_REMOVE = "remove";
+/**
+ * @internal
+ */
+export declare const TYPE_ITEM_ANCHORS = "anchors";
+/**
+ * @internal
+ */
+export declare const TYPE_ITEM_CONNECTOR = "connector";
+export declare function applyConnectionType<EL>(conn: Connection<EL>, t: CompiledTypeDescriptor, typeMap: any): void;
+/**
+ * Adds a class to a connection
+ * @param conn
+ * @param c
+ * @internal
+ */
+export declare function addConnectionClass<E>(conn: Connection<E>, c: string): void;
+export declare function removeConnectionClass<E>(conn: Connection<E>, c: string): void;
+export declare const Connections: {
+    /**
+     * @internal
+     */
+    getAbsoluteOverlayPosition<EL>(conn: Connection<EL>, overlay: Overlay<EL>): PointXY;
+    setPreparedConnector<EL>(conn: Connection<EL>, connector: Connector, doNotRepaint?: boolean, doNotChangeListenerComponent?: boolean, typeId?: string): void;
+    destroy(c: Connection<any>): void;
+    setVisible(c: Connection<any>, v: boolean): void;
+    _prepareConnector<E>(c: Connection<E>, connectorSpec: ConnectorSpec, typeId?: string): Connector;
+    _setConnector(conn: Connection<any>, connectorSpec: ConnectorSpec, doNotRepaint?: boolean, doNotChangeListenerComponent?: boolean, typeId?: string): void;
+};

package/types/ui/core/connector/connectors.d.ts

@@ -0,0 +1,205 @@
+import { ConnectorComputeParams, PaintGeometry } from "./abstract-connector";
+import { Connection } from "./connection-impl";
+import { Segment, Connector, ConnectorOptions } from "../../common";
+import { BoundingBox, PointXY, Geometry } from "../../../core";
+/**
+ * Definition of an object that can create instances of some connector type, and perform a few
+ * housekeeping tasks on connectors of that type.
+ * @internal
+ */
+export interface ConnectorHandler {
+    compute: (c: Connection<any>, geometry: PaintGeometry, params: ConnectorComputeParams) => Geometry;
+    update: (c: Connection<any>, geometry: PaintGeometry, params: ConnectorComputeParams, sourceMoved: boolean, targetMoved: boolean) => Geometry;
+    create: <T extends ConnectorOptions, E>(connection: Connection<E>, params: T) => Connector;
+    transformGeometry(g: Geometry, dx: number, dy: number): Geometry;
+}
+export declare const exportConnectorGeometry: (ac: Connector) => any;
+export declare const Connectors: {
+    /**
+     * Prepare a connector using the given name and args.
+     * @internal
+     * @param connection
+     * @param name
+     * @param params
+     */
+    get: <E>(connection: Connection<E>, name: string, params: any) => Connector;
+    register: (name: string, handler: ConnectorHandler) => void;
+    compute: (c: Connection<any>, geometry: PaintGeometry, params: ConnectorComputeParams) => Geometry;
+    update: (c: Connection<any>, geometry: PaintGeometry, params: ConnectorComputeParams, sourceMoved: boolean, targetMoved: boolean) => Geometry;
+    markEdited(connection: Connection<any>, g?: Geometry): void;
+    /**
+     * Import the given geometry, setting it on the connector, marking the connector persistToModel, and setting
+     * anchor locations to the values from the geometry, then locking them. This method does not write the
+     * geometry to the underlying edge, because it is called from contexts in which the edge geometry has been set,
+     * namely when rendering an edge that has geometry, and when the model posts a geometry updated event. This method is also
+     * called from the edge routing plugin, but there the edge is not updated, and I am unsure if it needs to be.
+     * @param connection
+     * @param g
+     */
+    importGeometry(connection: Connection<any>, g: Geometry): void;
+    /**
+     * Sets anchor locations from the given geometry and locks the anchors. for internal use only.
+     * @param connection
+     * @param g
+     * @internal
+     */
+    $_setAnchorsFromGeometry(connection: Connection<any>, g: Geometry): void;
+    transformGeometry(ac: Connector, g: Geometry, dx: number, dy: number): Geometry;
+    /**
+     * Writes geometry into a connector. If `internal` is false, also write the geometry to the edge and marks the
+     * connector as edited. This is called by the router's astar compute method (with internal true: only writes to
+     * the connector), and also the computeStraight/computeOrthogonal routines, for each of which the `internal` flag is
+     * computed based on the connector's state: if it is marked `persistToModel` and there is a valid geometry, internal is false.
+     * otherwise it is true.  `internal` really means "dont persist to model". why do call sites have to make this decision and it
+     * cannot be made here?
+     * @param connection
+     * @param g
+     * @param internal
+     */
+    setGeometry(connection: Connection<any>, g: Geometry, internal: boolean): void;
+};
+export declare function defaultExportGeometry(ac: Connector): Geometry;
+/**
+ * By default we just set the given geometry as the connector's internal representation.
+ * @internal
+ */
+export declare function defaultImportGeometry(ac: Connector, g: Geometry): boolean;
+/**
+ * @internal
+ * @param ac
+ * @param segment
+ */
+export declare function _updateConnectorBounds(ac: Connector, segment: Segment): void;
+export declare function _clearConnectorSegments(c: Connector): void;
+export declare function _addConnectorSegment(c: Connector, type: string, params: any): void;
+/**
+ * This abstraction exists to support using the various pointOnPath, pointAlongPath etc methods, without needing a Connector. The initial use case is to support ad-hoc drawing of edges, for such things as the edge type picker, but also this is really a step on the way to refactoring the paint code to make it less complex and more of a rubber-stamp operation.
+ * @internal
+ */
+export type ConnectorPath = {
+    internalSegments: Array<Segment>;
+    totalLength: number;
+    segmentProportions: Array<[number, number]>;
+    segmentProportionalLengths: Array<number>;
+    paintInfo: PaintGeometry;
+};
+/**
+* returns `[segment, proportion of travel in segment, segment index]` for the segment
+* that contains the point which is 'location' distance along the entire path, where
+* 'location' is a decimal between 0 and 1 inclusive. in this connector type, paths
+* are made up of a list of segments, each of which contributes some fraction to
+* the total length.
+* This also supports the 'absolute' property, which lets us specify a location
+* as the absolute distance in pixels, rather than a proportion of the total path.
+ * @internal
+*/
+export declare function _findConnectorSegmentForLocation(c: ConnectorPath, location: number, absolute?: boolean): {
+    segment: Segment;
+    proportion: number;
+    index: number;
+};
+/**
+ * @internal
+ * @param c
+ * @param location
+ * @param absolute
+ */
+export declare function _connectorPointOnPath(c: ConnectorPath, location: number, absolute?: boolean): PointXY;
+/**
+ * @internal
+ * @param c
+ * @param location
+ * @param absolute
+ * @private
+ */
+export declare function _connectorGradientAtPoint(c: ConnectorPath, location: number, absolute?: boolean): number;
+/**
+ * @internal
+ * @param c
+ * @param location
+ * @param distance
+ * @param absolute
+ * @private
+ */
+export declare function _connectorPointAlongPathFrom(c: ConnectorPath, location: number, distance: number, absolute?: boolean): PointXY;
+/**
+ * @internal
+ * @param c
+ * @private
+ */
+export declare function _updateConnectorSegmentProportions(c: ConnectorPath): void;
+export declare function _prepareCompute(c: Connector, params: ConnectorComputeParams): PaintGeometry;
+export declare function _computeConnector(connection: Connection<any>, params: ConnectorComputeParams): void;
+/**
+ * Clears the connection's geometry and marks it not persistToModel, meaning subsequent
+ * path computes for this connector will use the standard compute routine. Also clears out
+ * fixed location for connection anchors where the anchor has one or more default locations.
+ * @param c
+ * @internal
+ */
+export declare function _resetConnectorGeometry(c: Connection<any>): void;
+/**
+ * @internal
+ * @param c
+ */
+export declare function _resetConnectorBounds(c: Connector): void;
+/**
+ * @internal
+ */
+type SegmentForPoint = {
+    d: number;
+    s: Segment;
+    x: number;
+    y: number;
+    l: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    index: number;
+    connectorLocation: number;
+};
+/**
+ * Function: findSegmentForPoint
+ * Returns the segment that is closest to the given [x,y],
+ * null if nothing found.  This function returns a JS
+ * object with:
+ *
+ *   d   -   distance from segment
+ *   l   -   proportional location in segment
+ *   x   -   x point on the segment
+ *   y   -   y point on the segment
+ *   s   -   the segment itself.
+ *   @internal
+ */
+export declare function _findConnectorSegmentForPoint(c: Connector, x: number, y: number): SegmentForPoint;
+/**
+ * @internal
+ * @param x1
+ * @param y1
+ * @param x2
+ * @param y2
+ */
+export declare function _connectorLineIntersection(c: Connector, x1: number, y1: number, x2: number, y2: number): Array<PointXY>;
+/**
+ * @internal
+ * @param x
+ * @param y
+ * @param w
+ * @param h
+ */
+export declare function _connectorBoxIntersection(c: Connector, x: number, y: number, w: number, h: number): Array<PointXY>;
+/**
+ * @internal
+ * @param box
+ */
+export declare function _connectorBoundingBoxIntersection(c: Connector, box: BoundingBox): Array<PointXY>;
+export declare function isConnector(c: {
+    typeDescriptor: string;
+}): c is Connector;
+/**
+ * @internal
+ * @param connector
+ */
+export declare function $getConnectorPathData(connector: Connector): any;
+export {};

package/types/ui/core/connector/segments.d.ts

@@ -0,0 +1,24 @@
+import { PointNearPath, Segment, SegmentHandler, SegmentParams } from "../../common";
+import { BoundingBox, PointXY } from "../../../core/util";
+export declare function _registerSegmentHandler<S extends Segment, SP extends SegmentParams>(type: string, handler: SegmentHandler<S, SP>): void;
+export declare const Segments: {
+    lineIntersection(segment: Segment, x1: number, y1: number, x2: number, y2: number): Array<PointXY>;
+    boxIntersection(segment: Segment, x: number, y: number, w: number, h: number): Array<PointXY>;
+    boundingBoxIntersection(segment: Segment, box: BoundingBox): Array<PointXY>;
+    pointOnPath(segment: Segment, location: number, absolute?: boolean): PointXY;
+    gradientAtPoint(segment: Segment, location: number, absolute?: boolean): number;
+    pointAlongPathFrom(segment: Segment, location: number, distance: number, absolute?: boolean): PointXY;
+    findClosestPointOnPath(segment: Segment, x: number, y: number): PointNearPath;
+    getPath(segment: Segment, isFirstSegment: boolean): string;
+};
+/**
+ * @internal
+ * @param segment
+ * @private
+ */
+export declare function _getSegmentLength(segment: Segment): number;
+/**
+ * @internal
+ * @private
+ */
+export declare function _createSegment(type: string, params: SegmentParams): Segment;

package/types/ui/core/connector/straight-segment.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @internal
+ */
+import { Segment, SegmentHandler, SegmentParams } from "../../common";
+export type StraightSegmentCoordinates = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+/**
+ * @internal
+ */
+export interface StraightSegmentParams extends SegmentParams {
+}
+/**
+ * Constant identifying a Straight segment.
+ * @internal
+ */
+export declare const SEGMENT_TYPE_STRAIGHT = "Straight";
+/**
+ * @internal
+ */
+export interface StraightSegment extends Segment {
+    length: number;
+    m: number;
+    m2: number;
+}
+/**
+ * @internal
+ */
+export declare const StraightSegmentHandler: SegmentHandler<StraightSegment, StraightSegmentParams>;

package/types/ui/core/constants.d.ts

@@ -0,0 +1,181 @@
+export declare const PX = "px";
+/**
+ * @internal
+ */
+export declare const NOMINAL_SIZE = "50px";
+export declare const BLOCK = "block";
+export declare const NONE = "none";
+export declare const SOURCE_INDEX = 0;
+export declare const TARGET_INDEX = 1;
+export declare const ABSOLUTE = "absolute";
+export declare const FIXED = "fixed";
+export declare const STATIC = "static";
+export declare const POSITION_RELATIVE = "relative";
+export declare const ATTRIBUTE_GROUP = "data-vjs-group";
+/**
+ * Written by the UI when the DOM element is being managed. Does not necessarily mean the DOM element represents part of the model.
+ * @internal
+ */
+export declare const ATTRIBUTE_MANAGED = "data-vjs-managed";
+/**
+ * This attribute can be written onto DOM elements by node/group renderers to instruct VisuallyJs that the given vertex is not draggable.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context element-dragging
+ */
+export declare const ATTRIBUTE_NOT_DRAGGABLE = "data-vjs-not-draggable";
+/**
+ * Written by the Surface when `elementsDraggable` is provided as a constructor option. The value of this attribute will match what you provide for `elementsDraggable`, but it's really only of any use if you set it to `false`, as `true` is the default.
+ * @internal
+ */
+export declare const ATTRIBUTE_ELEMENTS_DRAGGABLE = "data-vjs-elements-draggable";
+export declare const ATTRIBUTE_TABINDEX = "tabindex";
+/** @internal */
+export declare const KEY_OVERLAYS = "overlays";
+/**
+ * Written by VisuallyJs onto an element that represents some vertex (a node, group or port)
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context ui
+ */
+export declare const ATTRIBUTE_VJS_VERTEX = "data-vjs-vertex";
+/**
+ * This attribute indicates that the given element is the specific DOM element to which connections for the given port should be attached. It is distinct from `data-vjs-port-id` in that this attribute is a "physical" presence of a port. Connections to/from the associated port are attached to this DOM element, and not to the element representing the vertex to which the port belongs.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_PORT = "data-vjs-port";
+/**
+ * This attribute indicates the ID of the logical port that the element represents. A logical port is one which exists in the data model, but connections to/from the port in the UI are shown as being attached to the vertex to which the port belongs. Don't confuse this with the `data-vjs-port` attribute. When you drag a connection to/from some DOM element with this attribute set, you are instructing VisuallyJs to associate the source/target of the new edge with a port with the specified ID, but that the edge should be connected visually to the DOM element representing the vertex.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_PORT_ID = "data-vjs-port-id";
+/**
+ * Optional attribute used to tell VisuallyJs the type of the port represented by the given element. Maps to a port type defined in your view.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_PORT_TYPE = "data-vjs-port-type";
+/**
+ * Optional attribute used to tell VisuallyJs what `type` to use from some element that has `data-vjs-source="true"` set.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_EDGE_TYPE = "data-vjs-edge-type";
+/**
+ * Indicates the given DOM element acts as a source for edges dragged with the mouse/touch events. Any element with this attribute set will automatically be excluded from instigating a drag of the vertex on which the element resides
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_SOURCE = "data-vjs-source";
+/**
+ * Indicates the given DOM element acts as a target for edges dragged with the mouse/touch events. Elements with this attribute set are not excluded from instigating a drag of the vertex on which the element resides.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_TARGET = "data-vjs-target";
+/**
+ * Indicates the it should be possible to drag loopback connections from this element to itself.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_ALLOW_LOOPBACK = "data-vjs-allow-loopback";
+/**
+ * Indicates the ID of the logical port that the element represents when it is acting as an edge source. In some situations you might want to use the same element as a source and target, but have the data model use different logical ports.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @advanced
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_SOURCE_PORT_ID = "data-vjs-source-port-id";
+/**
+ * Indicates the ID of the logical port that the element represents when it is acting as an edge target.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @advanced
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_TARGET_PORT_ID = "data-vjs-target-port-id";
+/**
+ * Indicates the ID of the physical port that the element represents when it is acting as an edge source. In some situations you might want to use the same element as a source and target, but have the data model use different ports ids. See discussion for `data-vjs-port` to read about how this differs from `data-vjs-source-port-id`
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @see {@link ATTRIBUTE_VJS_PORT}
+ * @advanced
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_SOURCE_PORT = "data-vjs-source-port";
+/**
+ * Indicates the ID of the physical port represented by this element when the element is acting as the target of some edge. See discussion at `data-vjs-port` to read about how this differs from `data-vjs-target-port-id`
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @see {@link ATTRIBUTE_VJS_PORT}
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_TARGET_PORT = "data-vjs-target-port";
+/**
+ * Indicates the type of the port represented by this element when the element is acting as the source of some edge. Maps to a port type defined in your view. In some situations you might want to use the same element as a source and target, but have the data model use different ports types.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @advanced
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_SOURCE_PORT_TYPE = "data-vjs-source-port-type";
+/**
+ * Indicates the type of the port represented by this element when the element is acting as the target of some edge. Maps to a port type defined in your view.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @advanced
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_TARGET_PORT_TYPE = "data-vjs-target-port-type";
+/**
+ * Indicates the element acts as a magnet, when edge snapping is turned on.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_MAGNET = "data-vjs-magnet";
+/**
+ * Attribute written by VisuallyJs to store edge id on its visual representation.
+ * @group Edges
+ * @category DOM Attributes
+ * @internal
+ */
+export declare const ATTRIBUTE_VJS_EDGE = "data-vjs-edge";
+/**
+ * Attribute written by VisuallyJs to store overlay id on its visual representation.
+ * @group Edges
+ * @category DOM Attributes
+ * @internal
+ */
+export declare const ATTRIBUTE_VJS_OVERLAY_ID = "data-vjs-overlay-id";
+/**
+ * Constant representing the wildcard used in several places in the API.
+ * @group Constants
+ */
+export declare const WILDCARD = "*";

package/types/ui/core/context.d.ts

@@ -0,0 +1,26 @@
+import { OptimisticEventGenerator } from "../../core";
+export declare class VjsContext extends OptimisticEventGenerator {
+    /**
+     * @internal
+     */
+    $context: Record<string, any>;
+    constructor(initialContext: Record<string, any>);
+    /**
+     * Gets the named object from the context. May return null. If you want to ensure
+     * the context has a certain value, use {@link ensureContext} instead of this method.
+     * @param key
+     */
+    getFromContext<T = any>(key: string): T;
+    /**
+     * Either get the named object from the context, or create it, set it, and then return it.
+     * @param name
+     * @param generator
+     */
+    ensureContext<T>(name: string, generator: () => T): T;
+    /**
+     * Update the context with the given value for the given key.
+     * @param key
+     * @param value
+     */
+    updateContext(key: string, value: any): void;
+}

package/types/ui/core/core-events.d.ts

@@ -0,0 +1,7 @@
+import { EVENT_DESTROY, EVENT_EDGE_GEOMETRY, EVENT_EDGE_REMOVED, EVENT_GROUP_MOVE, EVENT_GROUP_MOVE_END, EVENT_GROUP_MOVE_START, EVENT_GROUP_REMOVED, EVENT_NODE_MOVE, EVENT_NODE_MOVE_END, EVENT_NODE_MOVE_START, EVENT_NODE_REMOVED } from "../../core";
+import { EVENT_GROUP_COLLAPSE, EVENT_GROUP_EXPAND, EVENT_INTERNAL_CONNECTION, EVENT_RENDER_END, EVENT_RENDER_START, EVENT_ZOOM, EVENT_AFTER_LAYOUT_REFRESH, //EVENT_CONNECTION_MOUSEOVER,
+EVENT_GROUP_RELAYOUT, EVENT_GROUP_RENDERED, EVENT_INTERNAL_VERTEX_UPDATED, EVENT_NODE_RENDERED, EVENT_NODE_VISIBILITY, EVENT_PLUGIN_ADDED, EVENT_RELAYOUT, EVENT_PLUGIN_REMOVED, EVENT_ADHOC_LAYOUT } from "./event-constants";
+/**
+ * An event that the UI core may fire - meaning subclasses too.
+ */
+export type CoreUIEvent = typeof EVENT_NODE_MOVE_END | typeof EVENT_NODE_MOVE | typeof EVENT_NODE_MOVE_START | typeof EVENT_RENDER_START | typeof EVENT_GROUP_REMOVED | typeof EVENT_GROUP_MOVE | typeof EVENT_GROUP_MOVE_END | typeof EVENT_GROUP_MOVE_START | typeof EVENT_RENDER_END | typeof EVENT_DESTROY | typeof EVENT_RELAYOUT | typeof EVENT_GROUP_COLLAPSE | typeof EVENT_AFTER_LAYOUT_REFRESH | typeof EVENT_GROUP_EXPAND | typeof EVENT_NODE_VISIBILITY | typeof EVENT_GROUP_RENDERED | typeof EVENT_NODE_REMOVED | typeof EVENT_INTERNAL_VERTEX_UPDATED | typeof EVENT_INTERNAL_CONNECTION | typeof EVENT_NODE_RENDERED | typeof EVENT_EDGE_REMOVED | typeof EVENT_ZOOM | typeof EVENT_GROUP_RELAYOUT | typeof EVENT_PLUGIN_ADDED | typeof EVENT_PLUGIN_REMOVED | typeof EVENT_EDGE_GEOMETRY | typeof EVENT_ADHOC_LAYOUT;