@visuallyjs/browser-ui 1.2.3 → 1.2.5

package/types/core/layout/bowtie/bowtie-layout.d.ts

@@ -0,0 +1,69 @@
+import { AbstractLayout, InternalLayoutOptions, LayoutParameters } from "../abstract-layout";
+import { HasIdAndType, Vertex } from "../../model/graph";
+import { PointXY, Size } from "../../util";
+import { DataSource } from "../../datasource";
+import { CircularLayoutParameters } from "../circular";
+/**
+ * Bowtie layout type.
+ * @group Layouts
+ * @category Bowtie
+ */
+export declare const LAYOUT_TYPE_BOWTIE = "Bowtie";
+/**
+ * Options for the Bowtie layout
+ * @group Layouts
+ * @category Hierarchy
+ */
+export interface BowtieLayoutParameters extends LayoutParameters {
+    /**
+     * Whether to draw the layout horizontally or vertically. Defaults to "horizontal".
+     */
+    axis?: "horizontal" | "vertical";
+    /**
+     * Optional node to use as the root. You must provide this or `getRootNode`.
+     */
+    rootNode?: Vertex | string;
+    /**
+     * Optional function you can provide that will dynamically be invoked to get the root node to use. You must provide this or `rootNode`.
+     */
+    getRootNode?: (dataSource: DataSource) => Vertex | string;
+    /**
+     * Gets immediate upstream nodes for the focus vertex. Only invoked with the focus vertex.
+     * @param dataSource
+     * @param vertex
+     */
+    getUpstream: (dataSource: DataSource, vertex: HasIdAndType) => Array<HasIdAndType>;
+    /**
+     * Gets immediate downstream nodes for the focus vertex. Only invoked with the focus vertex.
+     * @param dataSource
+     * @param vertex
+     */
+    getDownstream: (dataSource: DataSource, vertex: HasIdAndType) => Array<HasIdAndType>;
+    /**
+     * Optional function to invoke on any non-focus vertex, to get the vertex's children. Will not be invoked with the focus vertex. If this function returns the focus vertex in its set it will be filtered out. When you do not provide this function, VisuallyJs will find all vertices that are targets of edges for which this vertex is a source.
+     */
+    childVerticesFunction?: (node: HasIdAndType, dataSource: DataSource) => Array<HasIdAndType>;
+}
+/**
+ * Places the focus vertex in the center of the canvas and then branches out to the left and right - or top and bottom - with children of the focus. You are expected to supply a `getUpstream` and `getDownstream` function for this layout, as well as either `getRootNode` or `rootNode`. `getUpstream` is used to get the immediate children of the focus vertex that will be painted to the left or above, depending on axis. `getDownstream` is used to get the immediate children of the focus vertex that will be painted to the right or below. By default this layout will draw horizontally, which you can change by setting `axis:"vertical"`.
+ * @group Layouts
+ * @category Bowtie
+ */
+export declare class BowtieLayout extends AbstractLayout<BowtieLayoutParameters> {
+    focusVertex: Vertex;
+    static type: string;
+    readonly type = "Bowtie";
+    private readonly _getRootNode;
+    private readonly _rootNode;
+    private _axis;
+    private _getUpstreamVertices;
+    private _getDownstreamVertices;
+    private _childVerticesFunction;
+    private _defaultGetDownstream;
+    constructor(params: InternalLayoutOptions<BowtieLayoutParameters>);
+    begin(dataSource: DataSource, positionGetter: (id: string) => PointXY, positionSetter: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: CircularLayoutParameters): void;
+    end(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: BowtieLayoutParameters): void;
+    getDefaultParameters(): BowtieLayoutParameters;
+    reset(): void;
+    step(dataSource: DataSource, getPosition: (id: string) => PointXY, setPosition: (id: string, x: number, y: number) => void, sizes: Record<string, Size>, parameters: BowtieLayoutParameters): void;
+}

package/types/core/layout/bowtie/index.d.ts

@@ -0,0 +1 @@
+export * from "./bowtie-layout";

package/types/core/layout/hierarchy/definitions.d.ts

@@ -1,5 +1,4 @@
 import { AbstractEdgeTerminus, Edge, Group, HasId, HasIdAndType, Node } from "../../model/graph";
-import { VisuallyJsModel } from "../../toolkit";
 import { AbsoluteBackedLayoutParameters } from "../absolute-layout";
 import { PlacementStageStrategy } from "./placement-stage";
 import { HierarchyLayout } from "./hierarchy-layout";
@@ -7,6 +6,7 @@ import { VertexSet } from "./vertex-set";
 import { LayoutLayerEntry, LayoutLayerOrdering } from "../abstract-layout";
 import { GatedPath } from "../../router";
 import { PointXY, Size } from "../../util";
+import { DataSource } from "../../datasource";
 /**
  * @internal
  */
@@ -21,7 +21,7 @@ export declare const VERTEX = "vertex";
  * @category Hierarchy
  * @typeParam T Defines the type of the object from which child vertices will be retrieved, and the type of the child vertices.
  */
-export type ChildVerticesFunction<T extends HasId> = (node: T, layer: number, instance: VisuallyJsModel) => Array<T>;
+export type ChildVerticesFunction<T extends HasId> = (node: T, layer: number, instance: DataSource) => Array<T>;
 /**
  * Axis types for a {@link HierarchyLayout}
  * @group Layouts

package/types/core/layout/hierarchy/parent-relative-placement.d.ts

@@ -1,7 +1,7 @@
 import { ParentRelativePlacementStrategyOptions } from "./definitions";
 import { HasIdAndType } from "../../model/graph";
 import { PointXY } from "../../util";
-import { VisuallyJsModel } from "../../toolkit";
+import { DataSource } from "../../datasource";
 /**
  * Places elements with respect to their parents, aligning them at parent start/end/center depending on the value of `alignment`.
  * @internal
@@ -34,7 +34,7 @@ export declare class ParentRelativePlacementStrategy<T extends HasIdAndType> {
     private readonly _getSize;
     private readonly _getChildVertices;
     private readonly _absolutePositionFunction;
-    constructor(model: VisuallyJsModel, parameters: ParentRelativePlacementStrategyOptions<T>);
+    constructor(model: DataSource, parameters: ParentRelativePlacementStrategyOptions<T>);
     execute(): Map<string, {
         position: PointXY;
         layer: number;

package/types/core/layout/index.d.ts

@@ -8,3 +8,4 @@ export * from './grid';
 export * from './force-directed';
 export * from './hierarchical';
 export * from './hierarchy';
+export * from './bowtie';

package/types/core/model/graph.d.ts

@@ -202,8 +202,8 @@ export interface InternalAddEdgeOptions {
     directed?: boolean;
     transient?: boolean;
     anchors?: {
-        source?: ObjectAnchorSpec;
-        target?: ObjectAnchorSpec;
+        source?: any;
+        target?: any;
     };
 }
 /**
@@ -836,6 +836,8 @@ export declare abstract class Vertex extends Base implements AbstractEdgeTerminu
      * Gets all Edges where this Vertex is the target.
      */
     getTargetEdges(): Array<Edge>;
+    getAllSourceEdges(): Edge[];
+    getAllTargetEdges(): Edge[];
     /**
      * Adds an Edge to the vertex.
      * @param edge The Edge to add.
@@ -1043,6 +1045,10 @@ export declare class Group extends Node {
      * @internal
      */
     _memberMap: Record<string, Node>;
+    /**
+     * @internal
+     */
+    locked: boolean;
     constructor(graph: Graph, data?: any, idFunction?: IdFunction);
     /**
      * @internal

package/types/core/model/group-template.d.ts

@@ -8,8 +8,10 @@ export interface GroupTemplate {
         groupTemplate?: string | GroupTemplate;
     }>;
     edges?: Array<{
-        source: string;
-        target: string;
+        source?: string;
+        sourcePort?: string;
+        target?: string;
+        targetPort?: string;
         data?: ObjectData;
     }>;
 }

package/types/core/params.d.ts

@@ -3,7 +3,7 @@ import { VisuallyJsRenderer } from "./renderer";
 import { PointXY } from "./util";
 import { EdgeUpdatedReason, VertexUpdatedReason } from "./toolkit";
 import { VisuallyJsSelection } from "./selection";
-import { ObjectAnchorSpec } from "./model/anchor";
+import { LineStyle, SingleAnchorSpec } from "../ui";
 /**
  * Defines the payload for a node added event.
  * @group Events
@@ -495,7 +495,7 @@ export interface AddEdgeOptions {
     /**
      * Optional backing data for the edge.
      */
-    data?: any;
+    data?: ObjectData & LineStyle;
     /**
      * Optional edge cost. Defaults to 1.
      */
@@ -512,7 +512,7 @@ export interface AddEdgeOptions {
      * Optional anchors for the edge.
      */
     anchors?: {
-        source?: ObjectAnchorSpec;
-        target?: ObjectAnchorSpec;
+        source?: SingleAnchorSpec;
+        target?: SingleAnchorSpec;
     };
 }

package/types/core/rtree/definitions.d.ts

@@ -4,10 +4,10 @@ import { RectangleXY } from "../util";
  * Base region used by RTree
  * @internal
  */
-export interface RTreeRegion extends RectangleXY {
-    data?: ObjectData;
-    children: Array<RTreeRegion>;
-    parent?: RTreeRegion;
+export interface RTreeRegion<DataPayload extends ObjectData = ObjectData> extends RectangleXY {
+    data?: DataPayload;
+    children: Array<RTreeRegion<DataPayload>>;
+    parent?: RTreeRegion<DataPayload>;
     id?: string;
 }
 /**
@@ -19,6 +19,6 @@ export declare const RTREE_DEFAULT_MAX_CHILD_ENTRIES = 4;
  * A data node in an RTree
  * @internal
  */
-export interface RTreeDataNode extends RTreeRegion {
+export interface RTreeDataNode<DataPayload extends ObjectData = ObjectData> extends RTreeRegion<DataPayload> {
     id: string;
 }

package/types/core/rtree/rtree.d.ts

@@ -23,7 +23,7 @@ export interface RTreeSearchOptions {
  * An RTree. Used internally to facilitate fast spatial querying.
  * @internal
  */
-export declare class RTree {
+export declare class RTree<DataPayload extends ObjectData = ObjectData> {
     private readonly _maxNodes;
     private _root;
     private _dataNodes;
@@ -33,7 +33,7 @@ export declare class RTree {
      * @param searchBoundary
      * @param options
      */
-    search(searchBoundary: RectangleXY, options?: RTreeSearchOptions): Array<RTreeDataNode>;
+    search(searchBoundary: RectangleXY, options?: RTreeSearchOptions): Array<RTreeDataNode<DataPayload>>;
     /**
      * Search the tree and find all entries that intersect the given rectangle, then rank them by the amount they overlap.
      * @param searchBoundary

package/types/core/rtree/util.d.ts

@@ -1,4 +1,5 @@
 import { RTreeRegion } from "./definitions";
+import { ObjectData } from "../model/graph";
 export declare function _growToFit(rectToGrow: RTreeRegion, otherRect: RTreeRegion): void;
 /**
  * Adjust the bounds of `rect` so that they fit the bounds of its children, then if the rect has a parent, traverse up to the parent
@@ -14,7 +15,7 @@ export declare function splitIntoSiblings(r: RTreeRegion): [RTreeRegion, RTreeRe
  * @private
  * @internal
  */
-export declare function _emptyRTreeRegion(id?: string): RTreeRegion;
+export declare function _emptyRTreeRegion<DataPayload extends ObjectData = ObjectData>(id?: string): RTreeRegion<DataPayload>;
 /**
  * Return whether or not the given region is a leaf
  * @param r

package/types/core/toolkit.d.ts

@@ -16,6 +16,7 @@ import { PointXY, Geometry } from "./util";
 import { OptimisticEventGenerator } from "./event-generator";
 import { ProxyLocation } from "./constants";
 import { GroupTemplate } from "./model/group-template";
+import { SingleAnchorSpec } from "../ui";
 /**
  * Definition of a function to use as a beforeConnect interceptor.
  * @param source The source vertex for the new edge
@@ -550,11 +551,11 @@ export declare abstract class VisuallyJsModel extends OptimisticEventGenerator i
      */
     getDescendants(vertex: Group): Array<Node | Group>;
     /**
-     * Gets a list of groups that are ancestors of the given node/group. The list of ancestors is ordered in terms of their proximity to the focus, ie. the first entry is the focus vertex's immediate parent.
+     * Gets a list of groups that are ancestors of the given node/group (or port, for which we first resolve the node/group it resides on). The list of ancestors is ordered in terms of their proximity to the focus, ie. the first entry is the focus vertex's immediate parent.
      * @param vertex
      *
      */
-    getAncestors(vertex: Node | Group): Array<Group>;
+    getAncestors(vertex: Vertex): Array<Group>;
     /**
      * Returns whether or not `possibleAncestor` is in fact an ancestor of the given focus node/group
      * @param focus Vertex to test
@@ -722,7 +723,10 @@ export declare abstract class VisuallyJsModel extends OptimisticEventGenerator i
      * @param context
      * @internal
      */
-    $addTransientEdge(renderer: VisuallyJsRenderer<any>, source: Vertex, target: Vertex, data?: ObjectData, geometry?: Geometry, context?: Record<string, any>): Edge;
+    $addTransientEdge(renderer: VisuallyJsRenderer<any>, source: string | Vertex, target: string | Vertex, data?: ObjectData, geometry?: Geometry, context?: Record<string, any>, anchors?: {
+        source?: SingleAnchorSpec;
+        target?: SingleAnchorSpec;
+    }): Edge;
     /**
      * Adds a Group by type, running the data generation for the node through the current GroupFactory.  This is different from `addGroup` in that with `addGroup` you are supplying the final data and your GroupFactory is not called. This method can be called with one, two or three arguments. A single argument is considered to be the new Group's `type`, and a backing data object will be created with this set, and no callback will occur. If you provide two arguments the second argument may be either the new Group's backing data OR a callback to hit with the newly created Group. With three arguments the second argument is the Group's backing data and the third is a callback to hit with the newly created Group.
      * @param type Required. Type of the object to create. `type` will be passed as the first argument to your group factory.

package/types/test-support/test-support.d.ts

@@ -41,6 +41,8 @@ export interface SynthesizedEvent {
     pageX: number;
     pageY: number;
 }
+declare function _createMouseEventWithPageLoc(el: Element, evt: string, pageLoc: PointXY, metaKeys?: Record<string, boolean>, button?: number): void;
+declare function _createKeyboardEvent(el: Element, type: string, key: string, modifiers?: Record<string, boolean>): void;
 /**
  * Callbacks you can provide to connection drag methods in the TestHarness to interrupt the process
  * and inspect what's going on.
@@ -62,6 +64,37 @@ export interface DragEventHandlers {
     afterMove?: Function;
     afterUp?: Function;
 }
+/**
+ * Hadlers you can pass as an argument to palette drag handlers,
+ */
+export interface PaletteEventHandlers {
+    /**
+     * Fired before the mousedown event is posted
+     */
+    beforeDown?: Function;
+    /**
+     * Fired before an initial move event is posted
+     */
+    beforeMove?: Function;
+    /**
+     * fired after the initial move event is posted and before the 2nd move event is posted
+     */
+    afterMove?: Function;
+    /**
+     * Fired after the 2nd move event, before the up event
+     */
+    beforeUp?: Function;
+    /**
+     * Fired after the operation has been completed
+     */
+    after?: Function;
+}
+export type PaletteDragHarness = {
+    start: () => any;
+    move: () => any;
+    up: () => any;
+    end: () => any;
+};
 /**
  * Synthesize an event
  * @param l
@@ -97,6 +130,8 @@ export declare const VisuallyJsTestSupport: {
     nudgeEvent: typeof _nudgeEvent;
     getEdgeCanvas: typeof getEdgeCanvas;
     defaultEventManager: EventManager;
+    createMouseEventWithPageLoc: typeof _createMouseEventWithPageLoc;
+    keyEvent: typeof _createKeyboardEvent;
     /**
      * Drag any DOM element around, not just elements managed by the surface.
      * @param el
@@ -459,6 +494,14 @@ export declare class TestHarness {
      * @param data
      */
     triggerEventAt(el: HTMLElement, eventName: string, x: number, y: number, data?: Record<string, any>): void;
+    /**
+     * Dispatch a keyboard event of the given type on the given element, with the given key code.
+     * @param el Element to dispatch the event on.
+     * @param type Type of event, e.g. "keydown", "keyup", "keypress".
+     * @param key
+     * @param modifiers Optional modifiers for the event.
+     */
+    keyEvent(el: Element, type: string, key: string, modifiers?: Record<string, boolean>): void;
     /**
      * Synthesize an event for the given object. This method is used by other parts of the test harness class
      * and is not something a user of the API will necessarily need to make use of.
@@ -742,8 +785,11 @@ export declare class TestHarness {
      * @param edgeOrEdgeId
      */
     dblTapOnEdge(edgeOrEdgeId: string | Edge): void;
+    private _addFromPaletteInit;
     private _addFromPalette;
-    dragFromPalette(palette: Palette<any>, selector: string, options?: any): void;
+    private _addFromPaletteASync;
+    dragFromPalette(palette: Palette<any>, selector: string, options?: any, metaKeys?: Record<string, boolean>): void;
+    dragFromPaletteAsync(palette: Palette<any>, selector: string, options?: any, metaKeys?: Record<string, boolean>): PaletteDragHarness;
     tapFromPalette(palette: Palette<any>, selector: string, options?: any): void;
     /**
      * Trigger a mousedown event on the edge with the given id.

package/types/ui/common/anchor.d.ts

@@ -1,7 +1,3 @@
-/**
- * Common options for anchors.
- *
- */
 import { PointXY, Size, Rotations, AnchorOrientationHint, ObjectAnchorSpec } from "../../core";
 import { Connection } from "../core";
 export type Orientation = Record<"y" | "x", AnchorOrientationHint>;

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

@@ -1,6 +1,7 @@
 import { PaintStyle } from './paint-style';
 import { OverlayEvents, OverlayVisibility } from "../core/overlay/overlay";
 import { FontSpec } from "../../browser-ui";
+import { Edge } from "../../core";
 /**
  * Base options for an overlay.
  * @group Edges
@@ -111,7 +112,18 @@ export type FullOverlaySpec = {
      */
     options: OverlayOptions;
 };
-export type InternalOverlaySpec = FullOverlaySpec & {
+export interface InternalOverlayOptions extends OverlayOptions {
+    shouldAddToEdge?: (e: Edge) => boolean;
+}
+export type InternalOverlaySpec = {
+    /**
+     * Overlay type
+     */
+    type: string;
+    /**
+     * Options for the overlay
+     */
+    options: InternalOverlayOptions;
     sourceMarker?: boolean;
     targetMarker?: boolean;
 };

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

@@ -163,6 +163,30 @@ export declare const ATTRIBUTE_VJS_TARGET_PORT_TYPE = "data-vjs-target-port-type
  * @context edge-dragging
  */
 export declare const ATTRIBUTE_VJS_MAGNET = "data-vjs-magnet";
+/**
+ * Specifies the anchor to use for both source and target of an edge connected to some element, when an edge is dragged from that element as the source.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_ANCHOR = "data-vjs-anchor";
+/**
+ * Specifies the anchor to use for the source of an edge connected to some element, when an edge is dragged from that element.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_SOURCE_ANCHOR = "data-vjs-source-anchor";
+/**
+ * Specifies the anchor to use for the target of an edge connected to some element, when an edge is dragged from that element.
+ * @group Nodes and Groups
+ * @category DOM Attributes
+ * @domAttribute
+ * @context edge-dragging
+ */
+export declare const ATTRIBUTE_VJS_TARGET_ANCHOR = "data-vjs-target-anchor";
 /**
  * Attribute written by VisuallyJs to store edge id on its visual representation.
  * @group Edges

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

@@ -6,7 +6,7 @@ import { ConnectionEstablishedParams } from "./callbacks";
 import { Viewport, ViewportElement, ViewportGroupElement, ViewportNodeElement } from "./viewport";
 import { ComponentBase } from './component/component';
 import { LabelOverlay } from './overlay/label-overlay';
-import { AnchorSpec, LightweightAnchor, FullOverlaySpec, OverlaySpec, Connector, PaintStyle, ConnectorSpec } from "../common";
+import { AnchorSpec, LightweightAnchor, FullOverlaySpec, OverlaySpec, Connector, PaintStyle, ConnectorSpec, SingleAnchorSpec } from "../common";
 import { GroupRelayoutReason } from './event-constants';
 import { Connection } from "./connector/connection-impl";
 import { Base, Edge, Group, Node, ObjectData, Port, Vertex, IntersectingVertex, PortRemovedParams, PortAddedParams, ProxyLocation, ObjectAnchorSpec } from "../../core";
@@ -15,7 +15,7 @@ import { GroupMapping, NodeMapping, NodeOrGroupMapping, PortMapping, VertexMappi
 import { Magnetizer, MagnetizeResult } from "../../core/magnetizer";
 import { AbstractLayout, LayoutParameters, LayoutResultSet } from "../../core/layout/abstract-layout";
 import { DataSource, EdgeAddedParams, EdgeRemovedParams, EdgeSourceChangedParams, EdgeTargetChangedParams, Extents, FilterableDataset, Grid, GroupAddedParams, GroupMemberAddedParams, GroupMemberRemovedParams, GroupRemovedParams, NodeAddedParams, NodeRemovedParams, OptimisticEventGenerator, PointXY, RectangleXY, VisuallyJsSelection, Size, VisuallyJsRenderer, VertexUpdatedParams, VisuallyJsModel, SaveOptions, Rotations, AbstractLayoutAdapter } from "../../core";
-import { DataHook, ElementType, EnclosedVerticesOptions, GroupContentAreaInfo, GroupResizeResult, IntersectingVerticesOptions, UIExportOptions, UISaveData, ViewportBounds, ZoomToElementsOptions, ZoomToFitIfNecessaryOptions, ZoomToFitOptions } from "./definitions";
+import { DataHook, ElementType, EnclosedVerticesOptions, GroupContentAreaInfo, GroupResizeResult, IntersectingVerticesOptions, UICapabilities, UIExportOptions, UISaveData, ViewportBounds, ZoomToElementsOptions, ZoomToFitIfNecessaryOptions, ZoomToFitOptions } from "./definitions";
 import { GridProfile } from "./grid-profile";
 import { MagnetizeProfile } from "./magnetize-profile";
 import { UIPlugin, UIPluginOptions, UIPluginSpec } from "../plugins/definitions";
@@ -109,6 +109,8 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
     $_discardEdgeEditsOnDrag: boolean;
     $_vertexBuffer: number;
     $_vertexBorder: number;
+    private _installedCapabilities;
+    private _installedCapabilitiesConfigurationProviders;
     private _$_edgesAvoidVertices;
     readonly viewport: Viewport<EL>;
     readonly router: Router<EL>;
@@ -128,6 +130,17 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
      * @internal
      */
     protected $isInMotion: boolean;
+    /**
+     * Mark a group as "locked" : edges inside of it cannot be detached, removed or have their paths edited, edges cannot be established to child vertices.
+     * @param groupIdOrGroup
+     */
+    lockGroup(groupIdOrGroup: string | Group): void;
+    $isGroupDefinedAsLocked(g: Group): boolean;
+    /**
+     * Unlock a group.
+     * @param groupIdOrGroup
+     */
+    unlockGroup(groupIdOrGroup: string | Group): void;
     magnetizerProfile: MagnetizeProfile;
     protected magnetizer: Magnetizer<Vertex>;
     /**
@@ -244,6 +257,22 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
      * @param size
      */
     abstract $setGroupElementSize(group: Group, size: Size): void;
+    /**
+     * Test whether the specific capability is available on this instance of the UI.
+     * @param c
+     */
+    $hasCapability(c: UICapabilities): boolean;
+    /**
+     * Gets the config for some capability. May be an empty object. A capability provider may be registered at the point that a capability is registered - the function is provided by the code that registers the capability.
+     * @param c
+     */
+    $getCapabilityConfig(c: UICapabilities): Record<string, any>;
+    /**
+     * For subclasses/plugins/component to use to register that a specific capability is available. It is not possible for external code to say a capability is _not_ available, only that one is.
+     * @param c
+     * @internal
+     */
+    $setCapabilityAvailable(c: UICapabilities, configProvider?: () => Record<string, any>): void;
     /**
      * Notification from the model that the target for some edge has changed.
      * @param data
@@ -373,8 +402,7 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
      */
     private $flushUnrenderedEdges;
     /**
-     * Check to see if an edge can be rendered (ie. there is an element available for both its source and target), and
-     * if so, render it.
+     * Check to see if an edge can be rendered (ie. there is an element available for both its source and target), and if so, render it.
      * @internal
      */
     private _maybeRenderEdge;
@@ -642,7 +670,7 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
      * @param _doNotRepaint - For internal use.
      * @internal
      */
-    private _rotateElement;
+    $rotateElement(vertex: Vertex | string, rotation: number, _doNotRepaint: boolean, animate: boolean): void;
     abstract $isTouchDevice(): boolean;
     abstract $syncManagedElementWithView(mel: ViewportElement<EL>, andThenRepaint: boolean): void;
     /**
@@ -1559,11 +1587,12 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
      * @param style
      * @param clazz
      * @param atts
+     * @param EL the element to use, instead of creating one.
      * @internal
      */
-    $addTransientVertex(position: PointXY, size: Size, data?: ObjectData, style?: Record<string, any>, clazz?: string, atts?: Record<string, string>): {
+    $addTransientVertex(position: PointXY, size: Size, data?: ObjectData, style?: Record<string, any>, clazz?: string, atts?: Record<string, string>, element?: EL): {
         vertex: Node;
-        el: ViewportElement<EL>;
+        el: ViewportNodeElement<EL>;
     };
     /**
      * Renders a dummy vertex. The model calls this at various points in the lifecycle.
@@ -1587,7 +1616,10 @@ export declare abstract class UICore<EL, EVT = CoreUIEvent> extends OptimisticEv
      * @param data
      * @internal
      */
-    $addTransientEdge(source: Vertex, target: Vertex, data?: ObjectData, context?: Record<string, any>): Edge;
+    $addTransientEdge(source: Vertex, target: Vertex, data?: ObjectData, context?: Record<string, any>, anchors?: {
+        source?: SingleAnchorSpec;
+        target?: SingleAnchorSpec;
+    }): Edge;
     /**
      * Tests if the given edge type may be unattached at its source and/or target. An edge type might mandate some
      * preference for that, or it may have been set via the `allowUnattached` flag in the edges defaults.

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

@@ -1,10 +1,7 @@
 import { ViewportElement, ViewportGroupElement } from "./viewport";
-import { Extents, PointXY, Size, Group, Node, Vertex } from "../../core";
-import { ExportOptions, VisuallyJsModel } from "../../core/toolkit";
+import { Extents, PointXY, Size, Group, Node, Vertex, BOTTOM, CENTER, LEFT, RIGHT, TOP, ExportOptions, VisuallyJsModel, MagnetizeResult } from "../../core";
 import { MagnetizeProfile } from "./magnetize-profile";
-import { MagnetizeResult } from "../../core/magnetizer";
-import { ConstrainFunction } from "../util/util";
-import { BOTTOM, CENTER, LEFT, RIGHT, TOP } from "../../core";
+import { ConstrainFunction } from "../util";
 import { UICore } from "./core";
 export type ElementSelectionSpecifier<E> = E | Array<E> | '*';
 export type SelectionList = '*' | Array<string>;
@@ -571,4 +568,14 @@ export declare enum ElementTypes {
  * @internal
  */
 export type ElementType = keyof typeof ElementTypes;
+/**
+ * Definition of capabilities that may have been added to a UI. This is an internal concept, managed by this class, its subclasses, and plugins/components. It provides a central place to store knowledge about the capabilities of the UI, without disparate parts needing to know about each other. For instance, if the ResizingToolsPlugin is installed and rotation is enabled, that plugin will set `vertexResize` and `vertexRotate` as available capabilities. The palette can then discover these are available, and support rotate while dragging - without needing to know about the implementation details. Similarly, the element dragging functionality can offer rotate by testing if the capability is available.
+ * @internal
+ */
+export declare enum UICapabilities {
+    vertexDrag = "vertexDrag",
+    vertexRotate = "vertexRotate",
+    vertexResize = "vertexResize",
+    vertexDrawing = "vertexDrawing"
+}
 export {};

package/types/ui/core/factory/anchor-record-factory.d.ts

@@ -1,5 +1,5 @@
 import { AnchorRecord, AnchorSpec, LightweightAnchor } from "../../common";
-import { PointXY } from "../../../core";
+import { ObjectAnchorSpec, PointXY } from "../../../core";
 /**
  * @internal
  * @param type
@@ -8,6 +8,11 @@ import { PointXY } from "../../../core";
  * @private
  */
 export declare function _createAnchor(type: string, locations: Array<AnchorRecord>, params: Record<string, any>, fixedLocation: AnchorRecord): LightweightAnchor;
+/**
+ * @internal
+ * @param oa
+ */
+export declare function isObjectAnchorSpec(oa: any): oa is ObjectAnchorSpec;
 export declare function makeLightweightAnchorFromArraySpec(specs: Array<AnchorSpec>, selectedAnchor?: number, currentPosition?: PointXY): LightweightAnchor;
 /**
  * @internal

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

@@ -1,4 +1,4 @@
-import { AnchorSpec, OverlaySpec, PaintStyle, ConnectorSpec, FullOverlaySpec } from "../common";
+import { AnchorSpec, OverlaySpec, PaintStyle, ConnectorSpec, FullOverlaySpec, InternalOverlaySpec } 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
@@ -79,7 +79,7 @@ export interface TypeDescriptorBase {
  * @internal
  */
 export interface CompiledTypeDescriptor extends Omit<TypeDescriptorBase, 'overlays' | 'sourceMarker' | 'targetMarker'> {
-    overlays?: Record<string, FullOverlaySpec>;
+    overlays?: Record<string, InternalOverlaySpec>;
     sourceMarker?: FullOverlaySpec;
     targetMarker?: FullOverlaySpec;
 }

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

@@ -72,4 +72,8 @@ export interface GroupMapping<EL> extends NodeOrGroupMapping<Group, EL, GroupEve
      * The size to use for this group type when it is collapsed.
      */
     collapsedSize?: Size;
+    /**
+     * Whether or not the group is locked.
+     */
+    locked?: boolean;
 }

package/types/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.2.3";
+export declare const VERSION = "1.2.5";