@visuallyjs/browser-ui 1.2.10 → 1.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visuallyjs/browser-ui",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "license": "Commercial",
   "main": "js/visuallyjs.browser-ui.cjs.js",
   "module": "js/visuallyjs.browser-ui.esm.js",

package/types/browser-ui/browser-visuallyjs-instance.d.ts

@@ -318,6 +318,8 @@ export declare abstract class BrowserUI<EVT = any> extends UICore<BrowserElement
      * @param spec If `ctx` is an element, this is the selector
      */
     $getSelector(ctx: string | Element, spec?: string): Array<VisuallyJSDOMElement>;
+    /** @internal Prepare screen bounds for a vertex drag. Other renderers retain DOM measurement. */
+    $prepareDragElementBounds(element: ViewportNodeElement<BrowserElement>): () => DOMRect;
     $setViewportElementPosition(el: ViewportElement<BrowserElement>, p: PointXY): void;
     /**
      * Sets whether or not the given element, or element representing the given vertex, is draggable.

package/types/browser-ui/drag-element-bounds.d.ts

@@ -0,0 +1,19 @@
+import { PointXY, Rotations } from "../core";
+import { ViewportNodeElement } from "../ui";
+import { BrowserElement } from "./util";
+/**
+ * Screen bounds for a translated/rotated HTML vertex. The measured reference accounts for
+ * template offsets; subsequent bounds use the applied geometry without a layout read.
+ * @internal
+ */
+export declare class DragElementBounds {
+    private element;
+    private mapPoint;
+    private getRotations;
+    private offset;
+    private supported;
+    constructor(element: ViewportNodeElement<BrowserElement>, mapPoint: (point: PointXY) => PointXY, getRotations: () => Rotations);
+    private rotation;
+    private calculate;
+    get(): DOMRect;
+}

package/types/browser-ui/element-drag-handler-2.d.ts

@@ -123,6 +123,7 @@ export declare class ElementDragHandler2 {
      * This is the current element (and associated model object) that is being dragged.
      */
     private _dragContext;
+    private _getDragElementBounds;
     /**
      * This is the parent group of the current drag object. This is only set if the drag object was in a group at the start of the drag
      */

package/types/browser-ui/pan-zoom.d.ts

@@ -37,6 +37,7 @@ export declare class PanZoom {
     private readonly _doWheelZoom;
     eventManager: EventManager;
     pinchListener: PinchListener;
+    private _dragViewportOffset;
     position: PointXY;
     zoom: number;
     transformOrigin: PointXY;
@@ -471,6 +472,8 @@ export declare class PanZoom {
      * @param y - Position of the Y coordinate of the transform origin.
      */
     setTransformOrigin(x: number, y: number): void;
+    /** @internal Maps using the viewport measurement already made for the current pointer event. */
+    $toWindowLocationForDrag(point: PointXY): PointXY;
     /**
      * Maps the given page location to a value relative to the viewport origin, allowing for zoom and pan of the canvas. This takes into account the offset of the viewport in the page so that what you get back is the mapped position relative to the target element's [left,top] corner.
      * @param left X location

package/types/browser-ui/surface-renderer/diagrams/definitions.d.ts

@@ -1,7 +1,7 @@
 import { LabelBackgroundOptions, LabelPosition, ShapeSet } from "../../shape-library";
 import { Group, ObjectData, PointXY, Size, Vertex, Node, BeforeConnectInterceptor } from "../../../core";
 import { DiagramCell } from "./diagram-cell";
-import { GridOptions, UIExportOptions, UICoreDefaults, EdgeEventOptions, OverlaySpec, ConnectorSpec, NodeEventOptions, GroupMapping, NodeMapping, AnchorSpec, EdgePropertyMappings, MagnetizeOptions, PaintStyle, OverlayVisibility, EdgeDeleteConfirmationFunction, LabelBackgroundStyle, FontSpec } from "../../../ui";
+import { GridOptions, UIExportOptions, UICoreDefaults, EdgeEventOptions, OverlaySpec, ConnectorSpec, NodeEventOptions, GroupMapping, NodeMapping, AnchorSpec, EdgePropertyMappings, MagnetizeOptions, PaintStyle, OverlayVisibility, EdgeDeleteConfirmationFunction, LabelBackgroundStyle, FontSpec, LineStyle } from "../../../ui";
 import type { BindableViewEvent } from "../../../ui";
 import { SurfaceSaveData } from "../definitions";
 import { BrowserElement } from "../../util";
@@ -150,6 +150,20 @@ export interface DiagramOptions {
          * Defaults to false. If true, edges will attempt to avoid vertices wherever possible.
          */
         avoidVertices?: boolean;
+        /**
+         * Size of each cell in the grid that the AStar routine uses to calculate paths that avoid vertices. This defaults to 10 pixels.If you do change it, keep in mind that a) a smaller grid size increases the runtime of the routine, and b) a large grid size will render the UI unusable.
+         */
+        astarGridCellSize?: number;
+        /**
+         * Number of cells to pad each vertex with that act as its border: edges will be routed around the border wherever possible. Defaults to 2
+         *
+         */
+        astarVertexBorder?: number;
+        /**
+         * Number of cells to pad each vertex with that act as its buffer: edges will be routed around the buffer wherever possible. Defaults to 2 - but note this value is added the vertex border, whose default is 2, so the computed default is 4 grid cells.
+         *
+         */
+        astarVertexBuffer?: number;
         /**
          * Defaults to true - edges are editable when the user taps on them.
          */
@@ -259,32 +273,7 @@ export interface DiagramOptions {
         /**
          * Optional default styles for edges. These are overwritten by edges that have values in their backing data.
          */
-        lineStyle?: {
-            /**
-             * Width of the edge path
-             */
-            lineWidth?: number;
-            /**
-             * Width to draw the edge's outline path
-             */
-            outlineWidth?: number;
-            /**
-             * Color to paint the edge's path
-             */
-            color?: string;
-            /**
-             * Color to paint the edge's outline path
-             */
-            outlineColor?: string;
-            /**
-             * Definition of dash pattern to use to draw the edge path
-             */
-            dashArray?: string;
-            /**
-             * An array of color stops to use as a linear gradient for the edge path. When this is set, `color` is ignored.
-             */
-            gradient?: Array<[number, string]>;
-        };
+        lineStyle?: Omit<LineStyle, "label" | "labelLocation" | "fontSize" | "fontStyle" | "fontFamily">;
     };
     /**
      * Defaults to #FFFFFF

package/types/browser-ui/surface-renderer/surface.d.ts

@@ -600,6 +600,8 @@ export declare class Surface extends BrowserUI<SurfaceEvents> implements Support
      * @returns The mapped location, as a PointXY object.
      */
     toPageLocation(left: number, top: number): PointXY;
+    /** @internal */
+    $prepareDragElementBounds(element: ViewportNodeElement<BrowserElement>): () => DOMRect;
     /**
      * Maps the given canvas location to a point, in page coordinates, relative to the surface container's origin. A return value of [0,0] from this method indicates the top left corner of the surface's container as seen by the user; negative values for x and/or y mean that the point is not in the visible viewport. Similarly, values for x greater the container width, or y greater than the container height, indicate that the point is not in the visible viewport.
      *

package/types/browser-ui/svg-element-connector.d.ts

@@ -8,6 +8,7 @@ export interface SvgConnector extends Connector {
     canvas: SVGElement;
     path?: SVGElement;
     bgPath?: SVGElement;
+    outlinePaths?: Array<SVGElement>;
     classesToAddWhenRendered?: Array<string>;
     sourceZone: SVGElement;
     targetZone: SVGElement;

package/types/browser-ui/svg-util.d.ts

@@ -5,6 +5,11 @@ import { LabelPosition } from "./shape-library";
 export type ElementAttributes = Record<string, string | number | object>;
 export declare function $attr(node: BrowserElement, attributes: ElementAttributes): void;
 export declare function $svgNode(name: string, attributes?: ElementAttributes, style?: Record<string, any>, clazz?: string): SVGElement;
+/**
+ * Release resources owned by a painted path before removing it.
+ * @internal
+ */
+export declare function $removeSvgPathGradient(connector: SvgConnector, node: SVGElement): void;
 /**
  * Creates a lineargradient from the given spec.
  * @param x1

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

@@ -16,14 +16,15 @@ import { HasId, HasWidthHeight, HasXY } from "../model/graph";
  * @param distanceHeuristic The heuristic to use when estimating the distance between two cells in the grid.
  * @param vertexBorder Number of cells to pad around each vertex to establish its 'border' - the vertex and the border
  * region are considered as obstacles.
- * @param vertexBuffer Number of cells to pad around each vertex's border to use as the buffer zone, through which paths
- * may traverse. Although with taking out the line of sight finder this concept is probably redundant now.
+ * @param vertexBuffer Additional search clearance in grid cells. Generated paths
+ * may enter this buffer while respecting vertexBorder.
  * @param getObstacles
  * @param getObstaclesRect
  * @param getAdjacentCells
  * @param hasLineOfSight
  * @param grid
  * @param pathId
+ * @param maxIterations Maximum heading states examined; independent of endpoint distance.
  * @internal
  */
 export declare function astar(source: PointXY, target: PointXY, sourceId: string, targetId: string, sourceOrientation: {
@@ -32,6 +33,6 @@ export declare function astar(source: PointXY, target: PointXY, sourceId: string
 }, targetOrientation: {
     ox: 1 | 0 | -1;
     oy: 1 | 0 | -1;
-}, gridCellSize: number, constrain: AStarPathConstrainment, distanceHeuristic: DistanceHeuristic, vertexBorder: number, vertexBuffer: number, getObstacles: (x: number, y: number, margin?: number) => Array<AStarObstacle>, getObstaclesRect: (rect: RectangleXY, margin?: number) => Array<AStarObstacle>, getAdjacentCells: AdjacentCellsFinder, hasLineOfSight: (grid: AStarGrid, l: LineXY) => boolean, grid?: AStarGrid, pathId?: string): AStarPath;
+}, gridCellSize: number, constrain: AStarPathConstrainment, distanceHeuristic: DistanceHeuristic, vertexBorder: number, vertexBuffer: number, getObstacles: (x: number, y: number, margin?: number) => Array<AStarObstacle>, getObstaclesRect: (rect: RectangleXY, margin?: number) => Array<AStarObstacle>, getAdjacentCells: AdjacentCellsFinder, hasLineOfSight: (grid: AStarGrid, l: LineXY) => boolean, grid?: AStarGrid, pathId?: string, maxIterations?: number): AStarPath;
 export interface AStarObstacle extends HasId, HasXY, HasWidthHeight {
 }

package/types/core/astar/astar-util.d.ts

@@ -1,8 +1,8 @@
 import { DirectionFromParent, ParentAxis, PathFinderGridCell } from "./definitions";
 import { AStarObstacle } from "./astar-path-finder";
-import { PointXY, RectangleXY } from "../util";
+import { LineXY, PointXY, RectangleXY } from "../util";
 /**
- * Grid for an A* path search. Access to grid cells is via the `getCell` method, which lazy loads cell entries. This implementation uses an object in the back end, whose keys are in the form `${x}_${y}`. The advantage of this is that no storage has to be allocated at the start, and the size of the content does not need to be known. It would be good to be able to reuse this grid...somehow.
+ * Grid for an A* path search. Access to grid cells is via the `getCell` method, which lazy loads cell entries. This implementation uses an object in the back end, whose keys are in the form `${x}_${y}`. Cached obstacle membership is independent of endpoint exemptions so the grid can be reused for searches against the same viewport state.
  * @internal
  */
 export declare class AStarGrid {
@@ -11,6 +11,7 @@ export declare class AStarGrid {
     vertexBuffer: number;
     private getCoincidentObstacles;
     private _grid;
+    private _states;
     private _canvasOrigin;
     private readonly _obstaclePadding;
     constructor(source: PointXY, target: PointXY, gridCellSize: number, vertexBorder: number, vertexBuffer: number, getCoincidentObstacles: (canvasX: number, canvasY: number, padding: number) => Array<AStarObstacle>);
@@ -29,16 +30,25 @@ export declare class AStarGrid {
     targetObstacles: Array<string>;
     sourceBuffers: Array<string>;
     targetBuffers: Array<string>;
+    private _endpointPositions;
     sourceAxis: ParentAxis;
     sourceDirection: DirectionFromParent;
     targetAxis: ParentAxis;
     targetDirection: DirectionFromParent;
     makeKey(x: number, y: number): string;
+    /** Search scores belong to an arrival heading; obstacle membership is shared. */
+    getState(x: number, y: number, axis: ParentAxis, direction: DirectionFromParent): PathFinderGridCell;
     private _shouldIgnoreObstacle;
+    /** Apply this search's endpoint exemptions without changing cached occupancy. */
+    isCellBlocked(cell: PathFinderGridCell): boolean;
+    /** Check the complete segment, including space between adjacent grid samples. */
+    isLineClear(line: LineXY, padding: number, getObstaclesRect: (rect: RectangleXY, margin?: number) => Array<AStarObstacle>): boolean;
     private _getCell;
     setSourceCell(id: string, x: number, y: number, ax: number, ay: number, axis: ParentAxis, direction: DirectionFromParent): PathFinderGridCell;
     setTargetCell(id: string, x: number, y: number, ax: number, ay: number, axis: ParentAxis, direction: DirectionFromParent): PathFinderGridCell;
     get sourceAndTargetObstacles(): string[];
+    /** Whole-vertex exemptions for the current connection, including endpoint buffers. */
+    get sourceAndTargetExemptions(): Array<string>;
     /**
      * Gets a cell from the grid, lazy loading it if it does not exist.
      * @param x Grid X
@@ -48,7 +58,7 @@ export declare class AStarGrid {
      */
     getCell(x: number, y: number, ax: number, ay: number): PathFinderGridCell;
     /**
-     * reinit the grid, which means to reset f,g and h values (and parent refs/axis etc), but NOT to clear out any edges. also we want to leave `occupied` but for that to be reusable it should contain a list of vertex ids, not just a boolean: we have to take into account source/target obstacles when deciding whether a cell should be excluded.
+     * Reset search state and endpoint exemptions, retaining raw obstacle membership.
      */
     reinitialize(): void;
 }

package/types/core/astar/candidate-sorter.d.ts

@@ -1,10 +1,16 @@
 import { PathFinderGridCell } from "./definitions";
+import { PointXY } from "../util";
 /**
- * Sorter for path candidates.
+ * Stable priority ordering: estimated total cost, remaining cost, exact endpoint
+ * distance, then discovery order. Comparisons never depend on the focus node.
  * @internal
  */
 export declare class CandidateSorter {
-    node: PathFinderGridCell;
-    constructor();
-    sort(n1: PathFinderGridCell, n2: PathFinderGridCell): 0 | 1 | -1;
+    private readonly _sequence;
+    private _nextSequence;
+    private readonly _target;
+    constructor(target?: PointXY);
+    /** Register a cell once, before adding it to the queue. Updates retain its order. */
+    register(cell: PathFinderGridCell): void;
+    sort(n1: PathFinderGridCell, n2: PathFinderGridCell): number;
 }

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

@@ -1,5 +1,7 @@
 import { DiagonalAxis, OrthogonalAxis, PATH_CONSTRAIN_DIAGONAL, PATH_CONSTRAIN_MANHATTAN, PATH_CONSTRAIN_METRO, PATH_CONSTRAIN_NONE, PATH_CONSTRAIN_ORTHOGONAL } from "../constants";
 export type DistanceHeuristic = (x1: number, y1: number, x2: number, y2: number) => number;
+/** Default maximum number of heading states examined by one search. @internal */
+export declare const DEFAULT_ASTAR_MAX_ITERATIONS = 10000;
 /**
  * A segment in an a* path
  * @internal
@@ -24,7 +26,8 @@ export interface AStarPath {
     isEmpty: boolean;
 }
 /**
- * A cell in an A* grid.
+ * A grid location or search state. Heading-specific states share the location's
+ * obstacle arrays but have independent scores, parents and open/closed flags.
  * @internal
  */
 export interface PathFinderGridCell {

package/types/core/geom.d.ts

@@ -114,6 +114,13 @@ export declare function lineRectangleIntersection(line: LineXY, r: RectangleXY):
  * @internal
  */
 export declare function lineIntersectsOrIsEnclosedByRectangle(line: LineXY, r: RectangleXY): boolean;
+/**
+ * Whether a segment enters the interior of a rectangle expanded by `padding`.
+ * Contact with the clearance boundary is permitted. Unlike offset-line tests,
+ * this also detects small obstacles and segments entirely inside an obstacle.
+ * @internal
+ */
+export declare function lineIntersectsRectangleInterior(line: LineXY, r: RectangleXY, padding?: number): boolean;
 /**
  * Calculates whether or not r2 is completely enclosed by r1.
  * @param r1 First rectangle

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

@@ -4,6 +4,7 @@ import { RectangleXY } from "../util";
  */
 export declare const HilbertCurves: {
     sortRect: <T extends RectangleXY>(listOfRectangles: Array<T>) => Array<T>;
-    toHilbertCoordinates: (maxCoordinate: number, x: number, y: number) => number;
+    /** Convert integer coordinates on a 2^order square to an unsigned Hilbert key (orders 1–16). */
+    toHilbertCoordinates: (order: number, x: number, y: number) => number;
     hilbertInterleaveBits: (odd: number, even: number) => number;
 };

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

@@ -87,7 +87,8 @@ export declare class RTree<DataPayload extends ObjectData = ObjectData> {
      */
     searchById(id: string): RTreeRegion;
     /**
-     * Update the position of the given record. Internally this just removes the record and re-inserts it.
+     * Update the position of the given record without condensing nonempty branches.
+     * Only the updated record is reinserted; its old ancestor bounds are refitted once.
      * @param id
      * @param x
      * @param y

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

@@ -8,6 +8,12 @@ export declare function _growToFit(rectToGrow: RTreeRegion, otherRect: RTreeRegi
  * @private
  */
 export declare function _updateRTreeRegionBounds(rect: RTreeRegion): void;
+/**
+ * Refit only this region to its immediate children. Empty regions use the same
+ * bounds as `_emptyRTreeRegion`; callers prune empty branches before refitting parents.
+ * @internal
+ */
+export declare function _refitRTreeRegionBounds(rect: RTreeRegion): void;
 export declare function _areaIfGrownBy(rectToGrow: RTreeRegion, otherRect: RTreeRegion): number;
 export declare function splitIntoSiblings(r: RTreeRegion): [RTreeRegion, RTreeRegion];
 /**

package/types/ui/common/paint-style.d.ts

@@ -4,7 +4,7 @@ import { LineStyle } from "../core";
  * @group UI
  * @category Definitions
  */
-export interface PaintStyle {
+export interface StrokePaintStyle {
     /**
      * Stroke color for the edge
      */
@@ -17,6 +17,30 @@ export interface PaintStyle {
      * Width of the stroke
      */
     strokeWidth?: number;
+    /**
+     * Definition for stroke pattern
+     */
+    dashArray?: string;
+    /**
+     * Definition of a linear gradient to apply. Each entry is [offset, color].
+     */
+    gradient?: Array<[number, string]>;
+    opacity?: number;
+    strokeOpacity?: number;
+    "stroke-linejoin"?: string;
+    "stroke-dashoffset"?: string | number;
+    "stroke-linecap"?: string;
+}
+/** An outline's width increment is added to each side of the preceding stroke. */
+export interface ConnectorOutline extends Omit<StrokePaintStyle, "strokeWidth"> {
+    outlineWidth: number;
+}
+/** Edge-facing outline settings. Width is added on each side of the preceding stroke. */
+export interface EdgeOutlineStyle extends Omit<StrokePaintStyle, "stroke" | "strokeWidth"> {
+    width: number;
+    color?: string;
+}
+export interface PaintStyle extends StrokePaintStyle {
     /**
      * Color for the outline path
      */
@@ -26,13 +50,10 @@ export interface PaintStyle {
      */
     outlineWidth?: number;
     /**
-     * Definition for stroke pattern
-     */
-    dashArray?: string;
-    /**
-     * Definition of a linear gradient to apply. Each entry is [offset, color].
+     * Low-level decorative layers, innermost first. Replaces legacy outline settings
+     * when supplied; [] disables decorative outlines. Layers do not change on hover.
      */
-    gradient?: Array<[number, string]>;
+    outlines?: Array<ConnectorOutline>;
 }
 /**
  * @internal

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, SingleAnchorSpec } from "../common";
+import { AnchorSpec, LightweightAnchor, FullOverlaySpec, OverlaySpec, Connector, PaintStyle, ConnectorSpec, SingleAnchorSpec, EdgeOutlineStyle } 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";
@@ -82,6 +82,8 @@ export interface LineStyle {
      * An array of color stops to use as a linear gradient for the edge path. When this is set, `color` is ignored.
      */
     gradient?: Array<[number, string]>;
+    /** Ordered outline layers. Each width increment is added to each side. */
+    outlines?: Array<EdgeOutlineStyle>;
     /**
      * Label to show on the edge
      */

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

@@ -92,6 +92,12 @@ export interface UIEdgeOptions {
      * Size of each cell in the grid that the AStar routine uses to calculate paths that avoid vertices. This defaults to 10 pixels and is not something you'll really need to change. If you do change it, keep in mind that a) a smaller grid size increases the runtime of the routine, and b) a large grid size will render the UI unusable.
      */
     astarGridCellSize?: number;
+    /**
+     * Maximum heading states examined per vertex-avoidance search. Defaults to
+     * 10000, regardless of endpoint distance. Must be a positive integer.
+     * Exhaustion uses the normal connector fallback.
+     */
+    astarMaxIterations?: number;
     /**
      * Number of cells to pad each vertex with that act as its border: edges will be routed around the border wherever possible. Defaults to 2
      *

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

@@ -18,6 +18,7 @@ import { AStarGrid } from "../../../core/astar/astar-util";
  * @param vertexBuffer
  * @param grid
  * @param pathId
+ * @param maxIterations Maximum heading states examined by this search.
  * @internal
  */
 export declare function astarFromViewport(source: PointXY, target: PointXY, sourceId: string, targetId: string, sourceOrientation: {
@@ -26,4 +27,4 @@ export declare function astarFromViewport(source: PointXY, target: PointXY, sour
 }, 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;
+}, viewport: Viewport<any>, gridCellSize: number, constrain: AStarPathConstrainment, distanceHeuristic: DistanceHeuristic, vertexBorder: number, vertexBuffer: number, grid?: AStarGrid, pathId?: string, maxIterations?: number): AStarPath;

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

@@ -13,6 +13,7 @@ export interface DefaultRouterOptions {
     avoidVertices?: boolean;
     vertexBuffer?: number;
     vertexBorder?: number;
+    maxIterations?: number;
 }
 /**
  * The default router paints edges with anchor computation. This class manages continuous anchors and offers A* vertex avoidance.
@@ -26,6 +27,7 @@ export declare class DefaultRouter<EL> implements Router<EL> {
     private _gridCellSize;
     private _vertexBuffer;
     private _vertexBorder;
+    private _maxIterations;
     private _orientationCache;
     private _orientationCacheTimestamp;
     private _grid;

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

@@ -1,4 +1,4 @@
-import { AnchorSpec, OverlaySpec, PaintStyle, ConnectorSpec, FullOverlaySpec, InternalOverlaySpec } from "../common";
+import { AnchorSpec, OverlaySpec, PaintStyle, ConnectorSpec, FullOverlaySpec, InternalOverlaySpec, EdgeOutlineStyle } 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
@@ -13,6 +13,8 @@ export interface TypeDescriptorBase {
      * Paint style to use for the component.
      */
     paintStyle?: PaintStyle;
+    /** Edge outline layers. When supplied, replaces the existing edge outline array. */
+    outlines?: Array<EdgeOutlineStyle>;
     /**
      * Paint style to use for the component when the pointer is hovering over it.
      */

package/types/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.2.10";
+export declare const VERSION = "1.2.12";