@visuallyjs/browser-ui 1.0.0

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

@@ -0,0 +1,223 @@
+import { ConnectorSpec, PaintStyle, OverlaySpec, AnchorSpec, LightweightAnchor } from "../common";
+import { Extents, PointXY, Size, Edge, Group, Node, VisuallyJsRenderer, AbstractLayout, GradientSpec } from "../../core";
+/**
+ * Options for the `connect` call on a UICore
+ * @internal
+ */
+export interface ConnectParams<E> {
+    /**
+     * If true, the router should try to route this connection around
+     * any vertices that lie in its path.
+     */
+    avoidVertices?: boolean;
+    /**
+     * Source element for the connection
+     */
+    source?: E;
+    /**
+     * target element for the connection
+     */
+    target?: E;
+    /**
+     * Whether or not the connection is detachable. Defaults to true.
+     */
+    detachable?: boolean;
+    /**
+     * Whether or not to delete the connection's endpoints when this connection is detached. Defaults to false. Does not
+     * delete endpoints if they have other connections.
+     */
+    deleteEndpointsOnDetach?: boolean;
+    /**
+     * Whether or not to delete any endpoints that were created by this connect call if at some
+     * point in the future the endpoint has no remaining connections. Defaults to false.
+     */
+    deleteEndpointsOnEmpty?: boolean;
+    /**
+     * Whether or not to reattach this connection automatically should it be detached via user intervention. Defaults to false.
+     */
+    reattach?: boolean;
+    /**
+     * Spec for the anchor to use for both source and target endpoints.
+     */
+    anchor?: AnchorSpec | LightweightAnchor;
+    /**
+     * Individual anchor specs for the source/target endpoints.
+     */
+    anchors?: [AnchorSpec | LightweightAnchor, AnchorSpec | LightweightAnchor];
+    /**
+     * Optional label to set on the connection. In the default browser UI implementation this is rendered as a `label` attribute on the SVG element representing the connection.
+     */
+    label?: string;
+    /**
+     * Spec for the connector used to paint the connection.
+     */
+    connector?: ConnectorSpec;
+    /**
+     * Optional list of overlays to attach to the connection.
+     */
+    overlays?: Array<OverlaySpec>;
+    sourceMarker: OverlaySpec;
+    targetMarker: OverlaySpec;
+    /**
+     * Type of the connection. Used in conjunction with the `registerConnectionType` method.
+     */
+    type?: string;
+    /**
+     * Paint style for the connector.
+     */
+    paintStyle?: PaintStyle;
+    /**
+     * Paint style for the connector when in hover mode.
+     */
+    hoverPaintStyle?: PaintStyle;
+    /**
+     * Whether or not the connection is considered to be 'directed'
+     */
+    directed?: boolean;
+    /**
+     * Cost of the connection. Defaults to 1.
+     */
+    cost?: number;
+    /**
+     * Optional extra parameters to associate with the connection
+     */
+    parameters?: Record<string, any>;
+    id?: string;
+    data?: any;
+    cssClass?: string;
+    hoverClass?: string;
+    outlineColor?: string;
+    outlineWidth?: number;
+    color?: string;
+    lineWidth?: number;
+    dashArray?: string;
+    gradient?: GradientSpec;
+    scope?: string;
+    labelLocation?: number;
+    useHTMLLabel?: boolean;
+    edge?: Edge;
+}
+/**
+ * Options for the UpdateOffset method
+ * @internal
+ */
+export interface UpdateOffsetOptions {
+    timestamp?: string;
+    recalc?: boolean;
+    elId?: string;
+    pos?: PointXY;
+    size?: Size;
+    rotation?: number;
+}
+export interface RelayoutParams<A extends AbstractLayout<any>> {
+    bounds: Extents;
+    positions: Record<string, PointXY>;
+    sizes: Record<string, Size>;
+    layout: A;
+}
+export interface GroupCollapsedParams<E> {
+    group: Group;
+}
+export interface GroupExpandedParams<E> {
+    group: Group;
+}
+/**
+ * Payload for a EVENT_GROUP_MEMBER_ADDED event from the ui
+ * @group Events
+ * @category UI Event Payloads
+ */
+export interface UIGroupMemberAddedParams<EL> {
+    /**
+     * Element representing the member that was added to the group
+     */
+    el: EL;
+    /**
+     * Element representing the group
+     */
+    groupEl: EL;
+    /**
+     * Vertex that was added to the group
+     */
+    vertex: Node | Group;
+    /**
+     * Group the vertex was added to
+     */
+    group: Group;
+    /**
+     * Optional new location for the vertex that was added
+     */
+    pos?: PointXY;
+    /**
+     * If a vertex being added to some group is currently a member of some other group, that group is provided here.
+     */
+    sourceGroup?: Group;
+    /**
+     * @internal
+     */
+    source?: VisuallyJsRenderer<any>;
+    /**
+     * Set to true if the vertex is also brand new, not copied from elsewhere in the dataset.
+     */
+    vertexIsNew?: boolean;
+    /**
+     * @internal
+     */
+    payload?: Record<string, any>;
+}
+/**
+ * Payload for a EVENT_GROUP_MEMBER_REMOVED event from the UI.
+ * @group Events
+ * @category UI Event Payloads
+ */
+export interface UIGroupMemberRemovedParams<EL> {
+    /**
+     * Element representing the member that was added to the group
+     */
+    el: EL;
+    /**
+     * DOM element representing the group
+     */
+    groupEl: EL;
+    /**
+     * Position the member that was removed was located at.
+     */
+    pos: PointXY;
+    /**
+     * Vertex that was removed from the group
+     */
+    vertex: Node | Group;
+    /**
+     * Group the vertex was removed from
+     */
+    group: Group;
+    /**
+     * @internal
+     */
+    source?: VisuallyJsRenderer<any>;
+    /**
+     * If the vertex is being moved to some other group, that group is provided here.
+     */
+    targetGroup?: Group;
+}
+/**
+ * Payload for an {@link EVENT_NODE_RENDERED} event from the UI.
+ * @group Events
+ * @category UI Event Payloads
+ */
+export interface NodeRenderedParams<EL> {
+    el: EL;
+    id: string;
+    vertex: Node;
+    size: Size;
+}
+/**
+ * Payload for an {@link EVENT_GROUP_RENDERED} event from the UI.
+ * @group Events
+ * @category UI Event Payloads
+ */
+export interface GroupRenderedParams<EL> {
+    el: EL;
+    id: string;
+    vertex: Group;
+    size: Size;
+}

package/types/ui/core/router/astar-path-finder.d.ts

@@ -0,0 +1,29 @@
+import { AStarPath, AStarPathConstrainment, DistanceHeuristic } from "../../../core/astar/definitions";
+import { Viewport } from "../viewport";
+import { PointXY } from "../../../core/util";
+import { AStarGrid } from "../../../core/astar/astar-util";
+/**
+ * Run the A* path finding algorithm using a Viewport as the datasource.
+ * @param source
+ * @param target
+ * @param sourceId
+ * @param targetId
+ * @param sourceOrientation
+ * @param targetOrientation
+ * @param viewport
+ * @param gridCellSize
+ * @param constrain
+ * @param distanceHeuristic
+ * @param vertexBorder
+ * @param vertexBuffer
+ * @param grid
+ * @param pathId
+ * @internal
+ */
+export declare function astarFromViewport(source: PointXY, target: PointXY, sourceId: string, targetId: string, sourceOrientation: {
+    ox: 1 | 0 | -1;
+    oy: 1 | 0 | -1;
+}, targetOrientation: {
+    ox: 1 | 0 | -1;
+    oy: 1 | 0 | -1;
+}, viewport: Viewport<any>, gridCellSize: number, constrain: AStarPathConstrainment, distanceHeuristic: DistanceHeuristic, vertexBorder: number, vertexBuffer: number, grid?: AStarGrid, pathId?: string): AStarPath;

package/types/ui/core/router/base-router.d.ts

@@ -0,0 +1,100 @@
+import { AnchorPlacement, Geometry, Edge } from "../../../core";
+import { ConnectionDetachedParams } from "../callbacks";
+import { RedrawResult, Router } from "./router";
+import { Connection } from "../connector/connection-impl";
+import { UICore } from "../core";
+import { ViewportElement } from "../viewport";
+import { AnchorSpec, Connector, AnchorComputeParams, LightweightAnchor, LightweightContinuousAnchor } from "../../common";
+import { AStarGrid } from "../../../core";
+import { ConnectorComputeParams } from "../connector/abstract-connector";
+import { AnchorLists } from "./router-utils";
+/**
+ * Base router options. Placeholder interface for subclasses.
+ * @internal
+ */
+export interface BaseRouterOptions {
+    gridCellSize?: number;
+    avoidVertices?: boolean;
+    vertexBuffer?: number;
+    vertexBorder?: number;
+}
+/**
+ * @internal
+ */
+export declare abstract class BaseRouter<EL> implements Router<EL, LightweightAnchor> {
+    instance: UICore<any, any>;
+    anchorLists: Map<string, AnchorLists>;
+    protected _avoidVertices: boolean;
+    protected _gridCellSize: number;
+    protected _vertexBuffer: number;
+    protected _vertexBorder: number;
+    protected _grid: AStarGrid;
+    protected constructor(instance: UICore<any, any>, options?: BaseRouterOptions);
+    /**
+     * Notification that a connection was removed.
+     * @param params
+     */
+    $connectionRemoved(params: ConnectionDetachedParams<any>): void;
+    elementRemoved(el: ViewportElement<EL>): void;
+    private _removeConnection;
+    $connectionDetachedFromElement(connection: Connection<EL>, el: ViewportElement<any>): void;
+    /**
+     * Sets the current anchor index in an anchor that has more than one location
+     * @internal
+     * @param anchor
+     * @param idx
+     * @param connection
+     */
+    $setCurrentLocation(anchor: LightweightAnchor, idx: number, connection?: Connection<any>): void;
+    /**
+     * Computes the position for an anchor that is neither floating nor continuous, or is currently fixed. This case
+     * covers what was previously both DynamicAnchor and Anchor, since those concepts have now been folded into
+     * a single concept - any given anchor has one or more locations.
+     * @param anchor
+     * @param params
+     */
+    private _defaultAnchorCompute;
+    private _placeContinuousAnchors;
+    private _updateContinuousAnchorList;
+    /**
+     * Remove the given anchor from the continuous anchor lists. This method is invoked when a connection is detached.
+     * @param elementId
+     * @param anchor
+     * @private
+     * @internal
+     */
+    $_removeAnchorFromAnchorLists(elementId: string, anchor: LightweightContinuousAnchor): void;
+    computeAnchorLocation(anchor: LightweightAnchor, params: AnchorComputeParams): AnchorPlacement;
+    computePath(connection: Connection<any>, timestamp: string): void;
+    abstract _doComputePath(connection: Connection<EL>, connector: Connector, params: ConnectorComputeParams, timestamp: string): Geometry;
+    abstract _doUpdatePath(connection: Connection<EL>, connector: Connector, params: ConnectorComputeParams, timestamp: string, sourceMoved: boolean, targetMoved: boolean): Geometry;
+    prepareAnchor(params: AnchorSpec | Array<AnchorSpec>): LightweightAnchor;
+    private _orientationCache;
+    private _orientationCacheTimestamp;
+    /**
+     * @internal
+     * @param c
+     * @private
+     */
+    protected _computeObstaclePadding(c: Connector): number;
+    private _calculateOrientation;
+    /**
+     * Redraws every connection. Does not update element positions.
+     * @internal
+     */
+    $redrawEveryConnection(): RedrawResult;
+    $redrawConnection(edge: Edge, timestamp?: string): RedrawResult;
+    /**
+     * Redraws connections for the given element. Does not update element positions.
+     * @internal
+     */
+    $redraw(viewportElement: ViewportElement<EL>, timestamp?: string): RedrawResult;
+    /**
+     * Redraws a list of connections. Does not update element positions.
+     * @internal
+     */
+    private _redrawConnections;
+    reset(): void;
+    setConnectionAnchors(conn: Connection<any>, anchors: [LightweightAnchor, LightweightAnchor]): void;
+    private _anchorSelector;
+}

package/types/ui/core/router/default-router.d.ts

@@ -0,0 +1,38 @@
+import { Connection } from "../connector/connection-impl";
+import { BaseRouter, BaseRouterOptions } from "./base-router";
+import { Connector } from "../../common";
+import { ConnectorComputeParams } from "../connector/abstract-connector";
+import { Geometry, AnchorPlacement } from "../../../core";
+import { UICore } from "../core";
+/**
+ * @internal
+ */
+export interface DefaultRouterOptions extends BaseRouterOptions {
+}
+/**
+ * Adjust the given anchor placement for the specified gap amount.
+ * @internal
+ * @param pos
+ * @param gap
+ */
+export declare function _adjustForGap(pos: AnchorPlacement, gap: number): {
+    curX: number;
+    curY: number;
+    ox: import("../../../core").AnchorOrientationHint;
+    oy: import("../../../core").AnchorOrientationHint;
+    x: number;
+    y: number;
+};
+/**
+ * @internal
+ */
+export declare class DefaultRouter<EL> extends BaseRouter<EL> {
+    instance: UICore<EL, any>;
+    static type: string;
+    protected _timestamp: string;
+    constructor(instance: UICore<EL, any>, options?: DefaultRouterOptions);
+    _doComputePath(connection: Connection<EL>, c: Connector, params: ConnectorComputeParams, timestamp: string): Geometry;
+    _doUpdatePath(connection: Connection<EL>, c: Connector, params: ConnectorComputeParams, timestamp: string, sourceMoved: boolean, targetMoved: boolean): Geometry;
+    private _doComputePathDefault;
+    private _doComputePathAStar;
+}

package/types/ui/core/router/index.d.ts

@@ -0,0 +1,5 @@
+export * from './router';
+export * from './router-utils';
+export * from './base-router';
+export * from './default-router';
+export * from './astar-path-finder';

package/types/ui/core/router/router-utils.d.ts

@@ -0,0 +1,118 @@
+import { SortFunction } from "../../util";
+import { ViewportElement } from "../viewport";
+import { Connection } from "../connector/connection-impl";
+import { PointXY, RectangleXY, Size, AnchorPlacement } from "../../../core";
+import { AnchorComputeParams, AnchorRecord, Face, LightweightAnchor, LightweightContinuousAnchor } from "../../common";
+/**
+ * @internal
+ */
+export declare const edgeSortFunctions: Record<string, SortFunction<AnchorListEntry>>;
+/**
+ * @internal
+ */
+export interface ConnectionFacade {
+    placeholder?: boolean;
+    sourceId: string;
+    targetId: string;
+    anchors: {
+        source: LightweightAnchor;
+        target: LightweightAnchor;
+    };
+    id: string;
+}
+/**
+ * @internal
+ */
+export interface OrientationResult {
+    orientation?: string;
+    a: [Face, Face];
+    theta?: number;
+    theta2?: number;
+}
+/**
+ * @internal
+ */
+export type AnchorListEntry = {
+    theta: number;
+    order: number;
+    c: ConnectionFacade;
+    elId: string;
+    anchor: LightweightAnchor;
+};
+/**
+ * @internal
+ */
+export type AnchorLists = {
+    top: Array<AnchorListEntry>;
+    right: Array<AnchorListEntry>;
+    bottom: Array<AnchorListEntry>;
+    left: Array<AnchorListEntry>;
+};
+/**
+ * @internal
+ */
+export type ContinuousAnchorPlacement = {
+    x: number;
+    y: number;
+    xLoc: number;
+    yLoc: number;
+    c: ConnectionFacade;
+    a: LightweightAnchor;
+};
+/**
+ * @internal
+ */
+export declare function _placeAnchorsOnLine<E>(element: ViewportElement<E>, connections: Array<AnchorListEntry>, horizontal: boolean, otherMultiplier: number, reverse: boolean): Array<ContinuousAnchorPlacement>;
+/**
+ * @internal
+ * @param a
+ */
+export declare function _isContinuousAnchor(a: LightweightAnchor): a is LightweightContinuousAnchor;
+/**
+ * @internal
+ * @param anchor
+ */
+export declare function _getCurrentAnchorLocation(anchor: LightweightAnchor): [number, AnchorRecord];
+/**
+ * Create a padded rectangle around the given point. The point lies on one edge of the resulting rectangle: it is not
+ * in the center. The rectangle represents whitespace around some anchor point but does not spill over into the vertex
+ * on which the anchor resides.
+ * @param point
+ * @param face
+ * @param size
+ * @internal
+ */
+export declare function _padPointForFace(point: PointXY, face: Face, size: number): RectangleXY;
+export declare function _padPointForFace2(point: PointXY, face: Face, size: number): RectangleXY;
+/**
+ * Create a padded rectangle around the given point. The point lies on one edge of the resulting rectangle: it is not
+ * in the center. The rectangle represents whitespace around some anchor point but does not spill over into the vertex
+ * on which the anchor resides.
+ * @param point
+ * @param ox Orientation in X
+ * @param oy Orientation in Y
+ * @param mainAxisSize Size of the rectangle in the main axis
+ * @param otherAxisSize Size of the rectangle in the axis orthogonal to main axis
+ * @internal
+ */
+export declare function _padPoint(point: PointXY, ox: number, oy: number, mainAxisSize: number, otherAxisSize: number): RectangleXY;
+/**
+ * For the given anchor point, constructs a padded box around it to use to check if the anchor is too
+ * close to some other element, and a different anchor location might be preferred. If the connection has no
+ * connector registered it means it is still being created, so we just pass back a 1x1 rectangle with the given point
+ * as origin.
+ * @param p
+ * @param ox
+ * @param oy
+ * @param connection
+ * @internal
+ */
+export declare function _padAnchorPoint(p: PointXY, ox: -1 | 0 | 1, oy: -1 | 0 | 1, connection: Connection<any>): RectangleXY;
+/**
+ * @internal
+ * @param loc
+ * @param xy
+ * @param wh
+ * @param params
+ */
+export declare function _computeSingleLocation(loc: AnchorRecord, xy: PointXY, wh: Size, params: AnchorComputeParams): AnchorPlacement;

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

@@ -0,0 +1,30 @@
+import { Connection } from '../connector/connection-impl';
+import { AnchorComputeParams, LightweightAnchor, AnchorSpec } from "../../common";
+import { PointXY, AnchorPlacement, Edge } from "../../../core";
+import { ConnectionDetachedParams } from "../callbacks";
+import { ViewportElement } from "../viewport";
+export interface RedrawResult {
+    c: Set<Connection<any>>;
+}
+export declare function EmptyRedrawResult(): RedrawResult;
+export interface Router<EL, A> {
+    reset(): void;
+    elementRemoved(el: ViewportElement<EL>): void;
+    $redrawConnection(edge: Edge, timestamp?: string): RedrawResult;
+    $redrawEveryConnection(): RedrawResult;
+    $redraw(viewportElement: ViewportElement<EL>, timestamp?: string, offsetToUI?: PointXY): RedrawResult;
+    computePath(connection: Connection<EL>, timestamp: string): void;
+    computeAnchorLocation(anchor: A, params: AnchorComputeParams): AnchorPlacement;
+    prepareAnchor(params: AnchorSpec | Array<AnchorSpec>): A;
+    setConnectionAnchors(conn: Connection<EL>, anchors: [A, A]): void;
+    $setCurrentLocation(anchor: LightweightAnchor, idx: number, connection?: Connection<any>): void;
+    /**
+     * Notification that a connection was detached from some element. The connection itself
+     * is not being removed; it is being reconnected elsewhere.
+     * @param connection
+     * @param el
+     * @param index
+     */
+    $connectionDetachedFromElement(connection: Connection<EL>, el: ViewportElement<any>): void;
+    $connectionRemoved(params: ConnectionDetachedParams): void;
+}

package/types/ui/core/type-descriptors.d.ts

@@ -0,0 +1,83 @@
+import { AnchorSpec, OverlaySpec, PaintStyle, ConnectorSpec, FullOverlaySpec } from "../common";
+/**
+ * Base interface for vertex/edge types. This interface contains parameters that are common between the two types, and is shared by internal methods and public methods.
+ */
+export interface TypeDescriptorBase {
+    /**
+     * CSS class to add to the given component's representation in the UI
+     */
+    cssClass?: string;
+    /**
+     * Paint style to use for the component.
+     */
+    paintStyle?: PaintStyle;
+    /**
+     * Paint style to use for the component when the pointer is hovering over it.
+     */
+    hoverPaintStyle?: PaintStyle;
+    /**
+     * Optional set of parameters to store on the component that is generated from this type.
+     */
+    parameters?: Record<string, any>;
+    /**
+     * [source, target] anchor specs for edges.
+     */
+    anchors?: [AnchorSpec, AnchorSpec];
+    /**
+     * Spec for the anchor to use for both source and target.
+     */
+    anchor?: AnchorSpec;
+    /**
+     * Provides a simple means for controlling connectivity in the UI.
+     */
+    scope?: string;
+    /**
+     * When merging a type description into its parent(s), values in the child for `connector`, `anchor` and `anchors` will always overwrite any such values in the parent. But other values, such as `overlays`, will be merged with their parent's entry for that key. You can force a child's type to override _every_ corresponding value in its parent by setting `mergeStrategy:'override'`.
+     */
+    mergeStrategy?: string;
+    /**
+     * Paint style for connectors created for this type.
+     */
+    connectorStyle?: PaintStyle;
+    /**
+     * Paint style for connectors created for this type when pointer is hovering over the component.
+     */
+    connectorHoverStyle?: PaintStyle;
+    /**
+     * Spec for connectors created for this type.
+     */
+    connector?: ConnectorSpec;
+    /**
+     * Class to add to any connectors created for this type.
+     */
+    connectorClass?: string;
+    /**
+     * Optional overlay to use as source marker.
+     */
+    sourceMarker?: OverlaySpec;
+    /**
+     * Optional overlay to use as target marker.
+     */
+    targetMarker?: OverlaySpec;
+    /**
+     * Array of overlays to add.
+     */
+    overlays?: Array<OverlaySpec>;
+    /**
+     * Whether or not connections of this type should be detachable with the mouse. Defaults to true.
+     */
+    detachable?: boolean;
+    /**
+     * Whether or not when a user detaches a connection of this type it should be automatically reattached. Defaults to false.
+     */
+    reattach?: boolean;
+}
+/**
+ * Used internally to track connection types - concrete types that have been populated.
+ * @internal
+ */
+export interface CompiledTypeDescriptor extends Omit<TypeDescriptorBase, 'overlays' | 'sourceMarker' | 'targetMarker'> {
+    overlays?: Record<string, FullOverlaySpec>;
+    sourceMarker?: FullOverlaySpec;
+    targetMarker?: FullOverlaySpec;
+}

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

@@ -0,0 +1,65 @@
+import { PointXY, DataModel, ObjectAnchorSpec, DataSource, Vertex } from "../../core";
+import { EdgeMapping, GroupMapping, NodeMapping, PortMapping, ViewSpec, VertexMapping } from "./view";
+import { UICore } from "./core";
+import { ViewportElement } from "./viewport";
+export declare const DEFAULT_LABEL_LOCATION_ATTRIBUTE = "labelLocation";
+type ModelDefinitionMap = {
+    nodes: Map<string, NodeMapping<any>>;
+    edges: Map<string, EdgeMapping>;
+    groups: Map<string, GroupMapping<any>>;
+    ports: Map<string, PortMapping<any>>;
+};
+declare const DEFAULT_MERGE_PARENT_ATTRIBUTE = "parent";
+/**
+ * Extract the definition(s) with the given type and merge them,
+ * @param type Type, or types, to extract. If a single type is specified that is what will be returned. If an array of
+ *     types are specified they will all be merged together.
+ * @param map Map from which to retrieve individual types
+ * @internal
+ */
+export declare function mergeWithParents<T extends {
+    mergeStrategy?: string;
+    [DEFAULT_MERGE_PARENT_ATTRIBUTE]?: string | Array<string>;
+}>(type: Array<string> | string, map: Record<string, T>): any;
+/**
+ * A function that returns an anchor definition from the given element, position on the element, and vertex.
+ */
+export type AnchorPositionFinder<EL> = (el: EL, pos: PointXY, vertex: Vertex, vertexDefinition: VertexMapping<any, any>) => ObjectAnchorSpec | null;
+/**
+ * @internal
+ */
+export declare function createFinderFromAnchorPositions<EL>(positions: Array<ObjectAnchorSpec>): AnchorPositionFinder<EL>;
+/**
+ * A UIModel describes the appearance and behaviour of a set of Nodes, Edges, Ports and Groups. This is an internal class that library users do not directly interact with.
+ *
+ * @internal
+ */
+export declare class UIModel<EL> {
+    private model;
+    viewOptions: ViewSpec<EL>;
+    defMap: ModelDefinitionMap;
+    private readonly nodes;
+    private readonly edges;
+    private readonly groups;
+    private readonly ports;
+    /**
+     */
+    constructor(model: DataSource, dataModel: DataModel, viewOptions: ViewSpec<EL>, uicore: UICore<EL, any>);
+    getEdgeDefinition(typeId: string): EdgeMapping;
+    getNodeDefinition(typeId: string): NodeMapping<EL>;
+    getPortDefinition(typeId: string): PortMapping<EL>;
+    getGroupDefinition(typeId: string): GroupMapping<EL>;
+    getTypeDefinition<T extends Vertex>(obj: Vertex): NodeMapping<EL> | PortMapping<EL>;
+}
+/**
+ * Return value from the UI's getObjectInfo method.
+ */
+export interface UIObjectInfo<T, E> {
+    el: E;
+    uiOnly?: boolean;
+    managedElement: ViewportElement<E>;
+    type: string;
+    obj: T;
+    id: string;
+}
+export {};