@visuallyjs/browser-ui 1.0.2 → 1.1.0

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;

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;

package/types/ui/property-mappings/definitions.d.ts

@@ -2,6 +2,8 @@ import { EdgeMapping } from "../core";
 /**
  * A mapping of some property/properties to a set of appearance values. Currently only used by edges.
  * @typeParam D Identifies the type that each mapping has. For instance, for {@link EdgePropertyMappings}, this type is {@link EdgeDefinition}.
+ * @group UI
+ * @category Definitions
  */
 export interface PropertyMapping<D> {
     /**
@@ -15,10 +17,14 @@ export interface PropertyMapping<D> {
 }
 /**
  * A set of property mappings for edges.
+ * @group UI
+ * @category Definitions
  */
 export type EdgePropertyMappings = Array<PropertyMapping<EdgeMapping>>;
 /**
  * A set of {@link PropertyMapping}s - currently only edges are supported, but future versions will support nodes, groups and ports
+ * @group UI
+ * @category Definitions
  */
 export interface PropertyMappings {
     /**

package/types/ui/util/util.d.ts

@@ -6,7 +6,6 @@
  * @internal
  */
 import { PointXY, Size } from "../../core";
-export declare function filterList(list: Array<any> | string, value: any, missingIsFalse?: boolean): boolean;
 /**
  * Equivalent of Object.assign, which IE11 does not support.
  * @param o1
@@ -23,13 +22,6 @@ export interface RotatedPointXY extends PointXY {
     cr: number;
     sr: number;
 }
-/**
- * Internal method used to rotate an anchor orientation.
- * @param orientation
- * @param rotation
- * @internal
- */
-export declare function rotateAnchorOrientation(orientation: [number, number], rotation: any): [number, number];
 /**
  * Iterates through the given `obj` and applies the given function. if `obj` is not ArrayLike then the function is
  * executed directly on `obj`.
@@ -46,24 +38,19 @@ export declare function each(obj: any, fn: Function): void;
  * @internal
  */
 export declare function wrap(wrappedFunction: Function, newFunction: Function, returnOnThisValue?: any): () => any;
-/**
- * A copy of a concept from a later version of Typescript than jsPlumb can currently use.
- * @internal
- */
 /**
  * Defines a function that can be used to sort an array.
  * @internal
  */
 export type SortFunction<T> = (a: T, b: T) => number;
 /**
- * Definition of a function that can be used to constrain the movement of an element that is being dragged. The function is
- * given the "desiredLoc", which is the location the element would be moved to if not constrained, and it is expected to return
- * either some other value, meaning place the element at that position, or null, meaning for the given desired location there
- * is no preferred position and the element should not be moved.
+ * Definition of a function that can be used to constrain the movement of an element that is being dragged. The function is given the "desiredLoc", which is the location the element would be moved to if not constrained, and it is expected to return either some other value, meaning place the element at that position, or null, meaning for the given desired location there is no preferred position and the element should not be moved.
  *
  * @param desiredLoc - Position the element will be placed at if unconstrained
  * @param dragEl - the element that is being dragged
  * @param size - The size of the element being dragged
  * @param e - The event associated with this tick of the drag lifecycle.
+ * @group UI
+ * @category Definitions
  */
 export type ConstrainFunction<EL, E> = (desiredLoc: PointXY, dragEl: EL, constrainRect: Size, size: Size, currentPos: PointXY, e: E) => PointXY;

package/types/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.0.2";
+export declare const VERSION = "1.1.0";

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

@@ -1,100 +0,0 @@
-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;
-}