@visuallyjs/browser-ui 1.0.3 → 1.1.1

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

@@ -18,6 +18,8 @@ export declare function isFullOverlaySpec(o: OverlaySpec): o is FullOverlaySpec;
 export declare function convertToFullOverlaySpec(spec: string | OverlaySpec): InternalOverlaySpec;
 /**
  * Events that can be bound on an overlay in a view.
+ * @group Edges
+ * @category Overlays
  */
 export type OverlayEvents = typeof EVENT_CLICK;
 /**
@@ -61,7 +63,7 @@ export declare function setOverlayLocation(o: Overlay<any>, l: number | string):
  * @internal
  */
 export declare abstract class Overlay<EL> {
-    component: Connection<EL>;
+    connection: Connection<EL>;
     id: string;
     abstract type: string;
     cssClass: string;
@@ -75,11 +77,11 @@ export declare abstract class Overlay<EL> {
      * types system.
      * @internal
      * @param instance
-     * @param component
+     * @param connection
      * @param p
      */
     ignoreTypes: boolean;
-    constructor(component: Connection<EL>, p: OverlayOptions);
+    constructor(connection: Connection<EL>, p: OverlayOptions);
     abstract updateFrom(opts: any, context: ObjectData): void;
     abstract isSimpleShape: boolean;
 }

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

@@ -1,13 +1,12 @@
 import { ConnectorSpec, PaintStyle, OverlaySpec, AnchorSpec, LightweightAnchor } from "../common";
-import { Extents, PointXY, Size, Edge, Group, Node, VisuallyJsRenderer, AbstractLayout, GradientSpec } from "../../core";
+import { Extents, PointXY, Size, Edge, Group, Node, 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.
+     * If true, the router should try to route this connection around any vertices that lie in its path.
      */
     avoidVertices?: boolean;
     /**
@@ -22,32 +21,26 @@ export interface ConnectParams<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.
+     * Spec for the anchor to use for both source and target locations.
      */
     anchor?: AnchorSpec | LightweightAnchor;
     /**
-     * Individual anchor specs for the source/target endpoints.
+     * Individual anchor specs for the source/target locations.
      */
     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;
+    /**
+     * When true, the label will be rotated so that it is at the same angle as the slope of the connector at the point at which the label is located.
+     */
+    labelsRotatable?: boolean;
     /**
      * Spec for the connector used to paint the connection.
      */
@@ -97,107 +90,27 @@ export interface ConnectParams<E> {
     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
+ * Payload for a {@link EVENT_GROUP_COLLAPSED}event.
  * @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
-     */
+export interface GroupCollapsedParams {
     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.
+ * Payload for a {@link EVENT_GROUP_EXPANDED}event.
  * @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
-     */
+export interface GroupExpandedParams {
     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.

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

@@ -1,13 +1,97 @@
+import { AnchorPlacement } from "../../../core";
+import { ConnectionDetachedParams } from "../callbacks";
+import { RedrawResult, Router } from "./router";
 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";
+import { ViewportElement } from "../viewport";
 /**
+ * Default router options.
  * @internal
  */
-export interface DefaultRouterOptions extends BaseRouterOptions {
+export interface DefaultRouterOptions {
+    gridCellSize?: number;
+    avoidVertices?: boolean;
+    vertexBuffer?: number;
+    vertexBorder?: number;
+}
+/**
+ * The default router paints edges with anchor computation. This class manages continuous anchors and offers A* vertex avoidance.
+ * @internal
+ */
+export declare class DefaultRouter<EL> implements Router<EL> {
+    instance: UICore<any, any>;
+    private _timestamp;
+    private $anchorLists;
+    private _avoidVertices;
+    private _gridCellSize;
+    private _vertexBuffer;
+    private _vertexBorder;
+    private _orientationCache;
+    private _orientationCacheTimestamp;
+    private _grid;
+    static type: string;
+    constructor(instance: UICore<any, any>, options?: DefaultRouterOptions);
+    $computePath(connection: Connection<any>, timestamp: string): void;
+    $connectionDetachedFromElement(connection: Connection<EL>, el: ViewportElement<any>): void;
+    /**
+     * Notification that a connection was removed. We remove it from continuous anchor lists.
+     * @param params
+     * @internal
+     */
+    $connectionRemoved(params: ConnectionDetachedParams<any>): void;
+    /**
+     * Called by the UI when it has unloaded an element from the canvas. We cleanup the element from continuous anchor lists.
+     * @param el
+     */
+    $elementRemoved(el: ViewportElement<EL>): void;
+    /**
+     * Redraws a list of connections. Does not update element positions.
+     * @internal
+     */
+    $redrawConnections(conns: Array<Connection<EL>>, timestamp?: string): RedrawResult;
+    /**
+     * Reset the router. Called by the UI's own reset method.
+     */
+    $reset(): void;
+    private _removeConnection;
+    /**
+     * 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
+     */
+    private _removeAnchorFromAnchorLists;
+    private _computeAnchorLocation;
+    private _doComputePath;
+    private _doUpdatePath;
+    /**
+     * Default path compute uses the connector's path computation.
+     * @param connection
+     * @param c
+     * @param params
+     * @private
+     */
+    private _doComputePathDefault;
+    /**
+     * A* path compute uses A* path finder algorithm
+     * @param connection
+     * @param c
+     * @param params
+     * @param timestamp
+     * @private
+     */
+    private _doComputePathAStar;
+    private _calculateOrientation;
+    private _anchorSelector;
 }
 /**
  * Adjust the given anchor placement for the specified gap amount.
@@ -23,16 +107,3 @@ export declare function _adjustForGap(pos: AnchorPlacement, gap: number): {
     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

@@ -1,5 +1,4 @@
 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

@@ -1,6 +1,5 @@
 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";
 /**
@@ -73,17 +72,6 @@ export declare function _isContinuousAnchor(a: LightweightAnchor): a is Lightwei
  * @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
@@ -96,18 +84,6 @@ export declare function _padPointForFace2(point: PointXY, face: Face, size: numb
  * @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

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

@@ -1,30 +1,39 @@
 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;
+export type RedrawResult = Set<Connection<any>>;
+export declare function EmptyRedrawResult(): Set<Connection<any>>;
+export interface Router<EL> {
+    /**
+     * Called by the UI's own reset() method.
+     */
+    $reset(): void;
     /**
-     * Notification that a connection was detached from some element. The connection itself
-     * is not being removed; it is being reconnected elsewhere.
+     * Called by the UI when it has unloaded an element from the canvas.
+     * @param el
+     */
+    $elementRemoved(el: ViewportElement<EL>): void;
+    /**
+     * Redraw a list of connections
+     * @param c
+     * @param timestamp
+     */
+    $redrawConnections(c: Array<Connection<any>>, timestamp?: string): RedrawResult;
+    /**
+     * Called by the UI when it wants to paint a connection.
+     * @param connection
+     * @param timestamp
+     */
+    $computePath(connection: Connection<EL>, timestamp: string): void;
+    /**
+     * Notification from the UI 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;
+    /**
+     * Called by the UI when a connection has been removed the canvas.
+     * @param params
+     */
     $connectionRemoved(params: ConnectionDetachedParams): void;
 }

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

@@ -1,6 +1,8 @@
 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.
+ * @group UI
+ * @category Definitions
  */
 export interface TypeDescriptorBase {
     /**

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

@@ -23,6 +23,7 @@ export declare function mergeWithParents<T extends {
 }>(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.
+ * @group UI
  */
 export type AnchorPositionFinder<EL> = (el: EL, pos: PointXY, vertex: Vertex, vertexDefinition: VertexMapping<any, any>) => ObjectAnchorSpec | null;
 /**
@@ -53,6 +54,8 @@ export declare class UIModel<EL> {
 }
 /**
  * Return value from the UI's getObjectInfo method.
+ * @group UI
+ * @category Definitions
  */
 export interface UIObjectInfo<T, E> {
     el: E;

package/types/ui/core/view/edge-options.d.ts

@@ -7,6 +7,7 @@ import { LineStyle } from "../core";
 import { FontSpec } from "../../../browser-ui";
 /**
  * Definition of the function you can provide as `deleteConfirm` on an edge definition. VisuallyJs gives you the edge to be possibly deleted and the pointer event that instigated the deletion. If you wish to delete the edge you must invoke the `proceed()` function.
+ * @group Edges
  */
 export type EdgeDeleteConfirmationFunction = (params: {
     edge: Edge;
@@ -78,6 +79,10 @@ export interface EdgeMapping extends BaseViewObjectMapping, LineStyle {
      * Optional spec for label font. Will use browser defaults if not specified (or CSS, but remember that CSS is not taken into account when you export an SVG from a diagram or an app using an SVG container)
      */
     labelFont?: FontSpec;
+    /**
+     * When true, the label will be rotated so that it is at the same angle as the slope of the connector at the point at which the label is located.
+     */
+    labelsRotatable?: boolean;
     /**
      * Optional width of the edge's outline. Defaults to 0.
      */

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

@@ -5,15 +5,19 @@ import { Connection } from "../connector/connection-impl";
 /**
  * Events that can be bound in UI render options.
  * @group Events
+ * @category UI Events
  */
 export type BindableRenderEvent = typeof EVENT_VERTEX_CLICK | typeof EVENT_VERTEX_DBLCLICK | typeof EVENT_VERTEX_CONTEXTMENU | typeof EVENT_VERTEX_DBLTAP | typeof EVENT_VERTEX_MOUSEMOVE | typeof EVENT_VERTEX_MOUSEOUT | typeof EVENT_VERTEX_MOUSEOVER | typeof EVENT_VERTEX_TAP | typeof EVENT_EDGE_CLICK | typeof EVENT_EDGE_DBLCLICK | typeof EVENT_EDGE_TAP | typeof EVENT_EDGE_DBLTAP | typeof EVENT_EDGE_MOUSEDOWN | typeof EVENT_EDGE_MOUSEUP | typeof EVENT_EDGE_MOUSEOVER | typeof EVENT_EDGE_MOUSEOUT | typeof EVENT_CANVAS_CLICK | typeof EVENT_CANVAS_DBLCLICK | typeof EVENT_PAN | typeof EVENT_NODE_MOVE_END | typeof EVENT_GROUP_MOVE_END | typeof EVENT_NODE_MOVE_START | typeof EVENT_GROUP_MOVE_START;
 /**
  * Events that can be bound in a view.
  * @group Events
+ * @category UI Events
  */
 export type BindableViewEvent = typeof EVENT_CLICK | typeof EVENT_DBLCLICK | typeof EVENT_TAP | typeof EVENT_DBLTAP | typeof EVENT_CONTEXTMENU | typeof EVENT_MOUSEDOWN | typeof EVENT_MOUSEOUT | typeof EVENT_MOUSEUP | typeof EVENT_MOUSEOVER | typeof EVENT_MOUSEMOVE;
 /**
  * The payload passed to a {@link NodeEventCallback}
+ * @group Events
+ * @category UI Events
  */
 export interface NodeEventCallbackPayload<EL> {
     /**
@@ -39,6 +43,8 @@ export interface NodeEventCallbackPayload<EL> {
 }
 /**
  * The payload passed to a {@link GroupEventCallback}
+ * @group Events
+ * @category UI Events
  */
 export interface GroupEventCallbackPayload<EL> {
     /**
@@ -64,6 +70,8 @@ export interface GroupEventCallbackPayload<EL> {
 }
 /**
  * The payload passed to a {@link PortEventCallback}
+ * @group Events
+ * @category UI Events
  */
 export interface PortEventCallbackPayload<EL> {
     /**
@@ -89,6 +97,8 @@ export interface PortEventCallbackPayload<EL> {
 }
 /**
  * The payload passed to an {@link EdgeEventCallback}
+ * @group Events
+ * @category UI Events
  */
 export interface EdgeEventCallbackPayload {
     /**
@@ -115,23 +125,32 @@ export interface EdgeEventCallbackPayload {
 export default EdgeEventCallbackPayload;
 /**
  * The definition of a callback function for an edge event mapped in a view.
+ * @group Events
+ * @category UI Events
  */
 export type EdgeEventCallback = (p: EdgeEventCallbackPayload) => any;
 /**
  * The definition of a callback function for a node event mapped in a view.
+ * @group Events
+ * @category UI Events
  */
 export type NodeEventCallback<EL> = (p: NodeEventCallbackPayload<EL>) => any;
 /**
  * The definition of a callback function for a port event mapped in a view.
+ * @group Events
+ * @category UI Events
  */
 export type PortEventCallback<EL> = (p: PortEventCallbackPayload<EL>) => any;
 /**
  * The definition of a callback function for a group event mapped in a view.
+ * @group Events
+ * @category UI Events
  */
 export type GroupEventCallback<EL> = (p: GroupEventCallbackPayload<EL>) => any;
 /**
  * Events that can be mapped in a node definition in a view.
  * @group Events
+ * @category UI Events
  */
 export type NodeEventOptions<EL> = {
     [K in BindableViewEvent]?: NodeEventCallback<EL>;
@@ -139,6 +158,7 @@ export type NodeEventOptions<EL> = {
 /**
  * Events that can be mapped in a group definition in a view.
  * @group Events
+ * @category UI Events
  */
 export type GroupEventOptions<EL> = {
     [K in BindableViewEvent]?: GroupEventCallback<EL>;
@@ -146,6 +166,7 @@ export type GroupEventOptions<EL> = {
 /**
  * Events that can be mapped in a port definition in a view.
  * @group Events
+ * @category UI Events
  */
 export type PortEventOptions<EL> = {
     [K in BindableViewEvent]?: PortEventCallback<EL>;
@@ -153,6 +174,7 @@ export type PortEventOptions<EL> = {
 /**
  * Events that can be mapped in an edge definition in a view.
  * @group Events
+ * @category UI Events
  */
 export type EdgeEventOptions = {
     [K in BindableViewEvent]?: EdgeEventCallback;

package/types/ui/core/view/node-or-port-options.d.ts

@@ -1,4 +1,6 @@
+import { ObjectData, Vertex, VisuallyJsModel } from "../../../core";
 import { VertexMapping } from "./vertex-options";
+import { UICore } from "../core";
 /**
  * Base view mapping for nodes and ports (and groups, since they extend nodes)
  * @group Components
@@ -13,6 +15,10 @@ export interface NodeOrPortMapping<E, N, EVT> extends VertexMapping<N, EVT> {
      * ID of the template to use for a vertex of this type. This is only for 'vanilla' VisuallyJs: if you are using an integration such as React/Angular/Vue, you will not need to provide this. This parameter is distinct from `template` in that when you provide `templateId` you are expecting VisuallyJs to resolve the template for you, either from a `templates` block in a `render` call, or by looking for a script element in the DOM with the appropriate ID. If you provide this and also `template`, `template` will take precedence.
      */
     templateId?: string;
+    /**
+     * A function that can resolve the ID of the template to use for the given vertex. This is an advanced configuration that is not often needed, and is only for 'vanilla' VisuallyJs. This function will take precedence over both `template` and `templateId`.
+     */
+    templateIdResolver?: (data: ObjectData, ui: UICore<E>, model: VisuallyJsModel, object: Vertex) => string;
     /**
      * Template to use for a vertex of this type. This is only for 'vanilla' VisuallyJs: if you are using an integration such as React/Angular/Vue/Svelte, you will not need to provide this. If you provide this and also `templateId`, this will take precedence.
      */

package/types/ui/core/view/vertex-options.d.ts

@@ -3,6 +3,8 @@ import { VertexDefinition, ObjectAnchorSpec } from "../../../core";
 import { AnchorPositionFinder } from "../ui-model";
 /**
  * Base mapping for nodes, groups and ports.
+ * @group UI
+ * @category Definitions
  */
 export interface VertexMapping<O, EVT> extends BaseViewObjectMapping, VertexDefinition {
     /**

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

@@ -252,8 +252,9 @@ export declare class Viewport<EL> {
      */
     isEmpty(): boolean;
     /**
-     * Gets the position of the element. This returns both the original position, and also the translated position of the element. Certain internal methods, such as the anchor calculation code, use the unrotated position and then subsequently apply the element's rotation to any calculated positions. Other parts of the codebase - the Toolkit's magnetizer or pan/zoom widget, for instance - are interested in the rotated position. If the element is marked 'dirty' it is first refreshed.
+     * Gets the position of the element. This returns both the original position, and also the translated position of the element. Certain internal methods, such as the anchor calculation code, use the unrotated position and then subsequently apply the element's rotation to any calculated positions. Other parts of the codebase - the magnetizer or pan/zoom widget, for instance - are interested in the rotated position. If the element is marked 'dirty' it is first refreshed.
      * @param id
+     * @internal
      */
     getElement(id: string): ViewportElement<EL>;
     /**
@@ -293,5 +294,10 @@ export declare class Viewport<EL> {
      * @param rotation
      */
     addElement(elId: string, el: EL, modelObject: Vertex, position: PointXY, size: Size, rotation: number): ViewportElement<any>;
+    /**
+     * Calculates the extents of only the top-level elements.
+     * @internal
+     */
+    getTopLevelExtents(): Extents;
 }
 export {};

package/types/ui/plugins/definitions.d.ts

@@ -1,4 +1,4 @@
-import { Connection, GroupResizeResult, UICore, ViewportElement, ViewportGroupElement } from "../core";
+import { Connection, ConnectionEstablishedParams, GroupResizeResult, UICore, ViewportElement, ViewportGroupElement } from "../core";
 import { Vertex, Size, VertexUpdatedReason, Edge } from "../../core";
 /**
  * Placeholder interface for plugin options.
@@ -62,6 +62,11 @@ export interface UIPlugin<EL, O extends UIPluginOptions, U extends UICore<EL, an
      * @param element
      */
     $edgeUpdated: (edge: Edge, connection: Connection<EL>) => void;
+    /**
+     * Notification that an edge was rendered
+     * @param p
+     */
+    $edgeRendered: (p: ConnectionEstablishedParams) => void;
     /**
      * Invoked when a vertex has been resized
      * @param element

package/types/ui/plugins/plugins.d.ts

@@ -4,4 +4,8 @@ export declare const UIPlugins: {
     get: <P extends UIPlugin<any, any, any> = UIPlugin<any, any, any>>(name: string) => P;
     register: <P extends UIPlugin<any, any, any> = UIPlugin<any, any, any>>(name: string, sp: Constructable<P>) => void;
 };
+/**
+ * Decorator function that can be used to register a plugin.
+ * @param pluginName
+ */
 export declare function registerPlugin(pluginName: string): (constructor: Constructable<any>) => void;