@visuallyjs/browser-ui 1.0.0

package/types/ui/connector-bezier/bezier-connector.d.ts

@@ -0,0 +1,34 @@
+import { BezierConnectorBase, AbstractBezierOptions } from "./abstract-bezier-connector";
+import { Connection } from "../core/connector/connection-impl";
+/**
+ * Options for {@link CubicBezierConnector}
+ * @group Edges
+ * @category Connectors
+ */
+export interface BezierConnectorOptions extends AbstractBezierOptions {
+    /**
+     * Where to put the control point relative to the source/target. The number provided here should be a decimal, whose value defines the proportional distance between the source and target that the control point should be located at. The default value is 0.45. Larger values will make the Bezier curvier.
+     */
+    scale?: number;
+}
+/**
+ * Defines the Bezier connector type.
+ * @constant
+ * @group Edges
+ * @category Constants
+ */
+export declare const CONNECTOR_TYPE_CUBIC_BEZIER = "Bezier";
+/**
+ * A connector that draws a Bezier curve having two control points.
+ * @group Edges
+ * @category Connectors
+ */
+export interface CubicBezierConnector extends BezierConnectorBase {
+    scale: number;
+}
+/**
+ * @param connection
+ * @param params
+ * @internal
+ */
+export declare function _createCubicBezierConnector(connection: Connection<any>, params: BezierConnectorOptions): CubicBezierConnector;

package/types/ui/connector-bezier/bezier-segment.d.ts

@@ -0,0 +1,31 @@
+import { Curve } from "./bezier";
+import { Segment, SegmentHandler, SegmentParams } from "../common";
+import { PointXY } from "../../core/util";
+/**
+ * @internal
+ * @private
+ */
+export interface BezierSegmentParams extends SegmentParams {
+    cp1: PointXY;
+    cp2: PointXY;
+}
+/**
+ * @internal
+ * @private
+ */
+export declare const SEGMENT_TYPE_BEZIER = "Bezier";
+/**
+ * @internal
+ * @private
+ */
+export interface BezierSegment extends Segment {
+    curve: Curve;
+    cp1: PointXY;
+    cp2: PointXY;
+    length: number;
+}
+/**
+ * @internal
+ * @private
+ */
+export declare const BezierSegmentHandler: SegmentHandler<BezierSegment, BezierSegmentParams>;

package/types/ui/connector-bezier/bezier.d.ts

@@ -0,0 +1,129 @@
+import { BoundingBox, LineXY, PointXY } from "../../core/util";
+export type Curve = Array<PointXY>;
+export type PointOnPath = {
+    point: PointXY;
+    location: number;
+};
+export type DistanceFromCurve = {
+    location: number;
+    distance: number;
+};
+export type AxisCoefficients = [number, number, number, number];
+/**
+ * Calculates the distance that the given point lies from the given Bezier.  Note that it is computed relative to the center of the Bezier,
+ * so if you have stroked the curve with a wide pen you may wish to take that into account!  The distance returned is relative to the values
+ * of the curve and the point - it will most likely be pixels.
+ *
+ * @param point - a point in the form {x:567, y:3342}
+ * @param curve - a Bezier curve: an Array of PointXY objects. Note that this is currently
+ * hardcoded to assume cubix beziers, but would be better off supporting any degree.
+ * @returns a JS object literal containing location and distance. Location is analogous to the location
+ * argument you pass to the pointOnPath function: it is a ratio of distance travelled along the curve.  Distance is the distance in pixels from
+ * the point to the curve.
+ * @internal
+ */
+export declare function distanceFromCurve(point: PointXY, curve: Curve): DistanceFromCurve;
+/**
+ * Calculates the nearest point to the given point on the given curve.  The return value of this is a JS object literal, containing both the point's coordinates and also the 'location' of the point (see above).
+ * @internal
+ */
+export declare function nearestPointOnCurve(point: PointXY, curve: Curve): {
+    point: PointXY;
+    location: number;
+};
+/**
+ *
+ * @internal
+ * @param curve
+ */
+export declare function computeBezierLength(curve: Curve): number;
+/**
+ * calculates a point on the curve, for a Bezier of arbitrary order.
+ * @param curve an array of control points, eg [{x:10,y:20}, {x:50,y:50}, {x:100,y:100}, {x:120,y:100}].  For a cubic bezier this should have four points.
+ * @param location a decimal indicating the distance along the curve the point should be located at.  this is the distance along the curve as it travels, taking the way it bends into account.  should be a number from 0 to 1, inclusive.
+ * @internal
+ */
+export declare function pointOnCurve(curve: Curve, location: number): PointXY;
+/**
+ *
+ * @internal
+ * @param p1
+ * @param p2
+ */
+export declare function dist(p1: PointXY, p2: PointXY): number;
+/**
+ *
+ * @internal
+ * @param curve
+ */
+export declare function isPoint(curve: Curve): boolean;
+/**
+ * finds the point that is 'distance' along the path from 'location'.  this method returns both the x,y location of the point and also
+ * its 'location' (proportion of travel along the path); the method below - _pointAlongPathFrom - calls this method and just returns the
+ * point.
+ *
+ * TODO The compute length functionality was made much faster recently, using a lookup table. is it possible to use that lookup table find
+ * a value for the point some distance along the curve from somewhere?
+ * @internal
+ */
+export declare function pointAlongPath(curve: Curve, location: number, distance: number): PointOnPath;
+/**
+ * finds the point that is 'distance' along the path from 'location'.
+ * @internal
+ */
+export declare function pointAlongCurveFrom(curve: Curve, location: number, distance: number): PointXY;
+/**
+ * finds the location that is 'distance' along the path from 'location'.
+ * @internal
+ */
+export declare function locationAlongCurveFrom(curve: Curve, location: number, distance: number): number;
+/**
+ * Calculates the gradient at the point on the given curve at the given location
+ * @returns a decimal between 0 and 1 inclusive.
+ * @internal
+ */
+export declare function gradientAtPoint(curve: Curve, location: number): number;
+/**
+ * Returns the gradient of the curve at the point which is 'distance' from the given location.
+ * if this point is greater than location 1, the gradient at location 1 is returned.
+ * if this point is less than location 0, the gradient at location 0 is returned.
+ * @returns a decimal between 0 and 1 inclusive.
+ * @internal
+ */
+export declare function gradientAtPointAlongPathFrom(curve: Curve, location: number, distance: number): number;
+/**
+ * calculates a line that is 'length' pixels long, perpendicular to, and centered on, the path at 'distance' pixels from the given location.
+ * if distance is not supplied, the perpendicular for the given location is computed (ie. we set distance to zero).
+ * @internal
+ */
+export declare function perpendicularToPathAt(curve: Curve, location: number, length: number, distance: number): LineXY;
+/**
+ * Calculates all intersections of the given line with the given curve.
+ * @param x1
+ * @param y1
+ * @param x2
+ * @param y2
+ * @param curve
+ * @returns Array of intersecting points.
+ * @internal
+ */
+export declare function bezierLineIntersection(x1: number, y1: number, x2: number, y2: number, curve: Curve): Array<PointXY>;
+/**
+ * Calculates all intersections of the given box with the given curve.
+ * @param x X position of top left corner of box
+ * @param y Y position of top left corner of box
+ * @param w width of box
+ * @param h height of box
+ * @param curve
+ * @returns Array of intersecting points.
+ * @internal
+ */
+export declare function boxIntersection(x: number, y: number, w: number, h: number, curve: Curve): Array<PointXY>;
+/**
+ * Calculates all intersections of the given bounding box with the given curve.
+ * @param boundingBox Bounding box to test for intersections.
+ * @param curve
+ * @returns Array of intersecting points.
+ * @internal
+ */
+export declare function boundingBoxIntersection(boundingBox: BoundingBox, curve: Curve): Array<PointXY>;

package/types/ui/connector-bezier/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./abstract-bezier-connector";
+export * from "./bezier";
+export * from "./bezier-segment";
+export * from "./bezier-connector";
+export * from "./quadratic-bezier-connector";
+export * from './operations';

package/types/ui/connector-bezier/operations.d.ts

@@ -0,0 +1,18 @@
+import { BezierConnectorGeometry } from "./abstract-bezier-connector";
+import { ConnectorComputeParams, PaintGeometry } from "../core/connector/abstract-connector";
+import { Connection } from "../core/connector/connection-impl";
+export declare function updateBezierConnector(connection: Connection<any>, paintInfo: PaintGeometry, p: ConnectorComputeParams, sourceMoved: boolean, targetMoved: boolean): BezierConnectorGeometry;
+/**
+ * @internal
+ * @param connection
+ * @param paintInfo
+ * @param p
+ */
+export declare function computeBezierConnector(connection: Connection<any>, paintInfo: PaintGeometry, p: ConnectorComputeParams): BezierConnectorGeometry;
+/**
+ * @internal
+ * @param g
+ * @param dx
+ * @param dy
+ */
+export declare function transformBezierGeometry(g: BezierConnectorGeometry, dx: number, dy: number): BezierConnectorGeometry;

package/types/ui/connector-bezier/quadratic-bezier-connector.d.ts

@@ -0,0 +1,35 @@
+import { BezierConnectorBase, AbstractBezierOptions } from "./abstract-bezier-connector";
+import { Connection } from "../core/connector/connection-impl";
+import { PointXY } from "../../core/util";
+/**
+ * Options for a {@link QuadraticBezierConnector}
+ * @group Edges
+ * @category Connectors
+ */
+export interface QuadraticBezierConnectorOptions extends AbstractBezierOptions {
+    /**
+     * A measure of how "curvy" the bezier is. In terms of maths what this translates to is how far from the midpoint of the curve the control points is positioned.
+     */
+    curviness?: number;
+}
+/**
+ * Defines the quadratic bezier connector type.
+ * @constant
+ * @group Edges
+ * @category Connectors
+ */
+export declare const CONNECTOR_TYPE_QUADRATIC_BEZIER = "QuadraticBezier";
+/**
+ * A connector that draws a Bezier curve with a single control point.
+ * @group Edges
+ * @category Connectors
+ */
+export interface QuadraticBezierConnector extends BezierConnectorBase {
+    _controlPoint: PointXY;
+}
+/**
+ * @param connection
+ * @param params
+ * @internal
+ */
+export declare function _createQuadraticBezierConnector(connection: Connection<any>, params: QuadraticBezierConnectorOptions): QuadraticBezierConnector;

package/types/ui/connector-orthogonal/default-orthogonal-path-compute.d.ts

@@ -0,0 +1,11 @@
+import { IOrthogonalConnector, OrthogonalSegment } from "./definitions";
+import { ConnectorComputeParams, PaintGeometry } from "../core/connector/abstract-connector";
+import { StraightConnector } from "../connector-straight/straight-connector";
+/**
+ * Default routine for computing an orthogonal path.
+ * @param oc
+ * @param paintInfo
+ * @param params
+ * @internal
+ */
+export declare function $defaultOrthogonalPathCompute(oc: IOrthogonalConnector | StraightConnector, paintInfo: PaintGeometry, params: ConnectorComputeParams): Array<OrthogonalSegment>;

package/types/ui/connector-orthogonal/definitions.d.ts

@@ -0,0 +1,120 @@
+import { Connector, ConnectorOptions } from "../common";
+import { OrthogonalAxis, Geometry } from "../../core";
+import { StraightConnectorSegment } from "../connector-straight";
+/**
+ * @internal
+ */
+export declare const ORIENTATION_PERPENDICULAR = "perpendicular";
+/**
+ * @internal
+ */
+export declare const ORIENTATION_ORTHOGONAL = "orthogonal";
+/**
+ * @internal
+ */
+export declare const ORIENTATION_OPPOSITE = "opposite";
+/**
+ * @internal
+ */
+export type Direction = -1 | 1;
+/**
+ * TODO just use one type in VJS. The `o` field may be null if the segment is not orthogonal.
+ * @internal
+ */
+export interface OrthogonalSegment extends StraightConnectorSegment {
+    o: OrthogonalAxis;
+}
+/**
+ * @internal
+ */
+export type SegmentContext = {
+    segment: OrthogonalSegment;
+    prev?: OrthogonalSegment;
+    next?: OrthogonalSegment;
+    index: number;
+    axis: OrthogonalAxis;
+    left?: [OrthogonalSegment, number];
+    right?: [OrthogonalSegment, number];
+};
+/**
+ * @internal
+ */
+export type SegmentMoveResult = {
+    ctx: SegmentContext;
+    segments: Array<OrthogonalSegment>;
+    index: number;
+};
+/**
+ * Options for an orthogonal connector.
+ * @group Edges
+ * @category Connectors
+ */
+export interface OrthogonalConnectorOptions extends ConnectorOptions {
+    /**
+     * The point to use as the halfway point between the source and target. Defaults to 0.5.
+     */
+    midpoint?: number;
+    /**
+     * Defaults to true, meaning always draw a stub of the desired length, even when the source and target elements are very close together.
+     */
+    alwaysRespectStubs?: boolean;
+    /**
+     * Optional curvature of the corners in the connector. Defaults to 0.
+     */
+    cornerRadius?: number;
+    /**
+     * For a loopback connection, the size of the loop.
+     */
+    loopbackRadius?: number;
+    /**
+     * If true, and a cornerRadius is set, the lines are drawn in such a way that they look slightly hand drawn.
+     */
+    slightlyWonky?: boolean;
+}
+/**
+ * The format used internally to store an orthogonal connector's geometry.
+ * @internal
+ */
+export interface InternalOrthogonalConnectorGeometry extends Geometry {
+    segments: Array<OrthogonalSegment>;
+    quadrant?: number;
+}
+/**
+ * Defines the Orthogonal connector type.
+ * @group Edges
+ * @category Connectors
+ * @constant
+ */
+export declare const CONNECTOR_TYPE_ORTHOGONAL = "Orthogonal";
+/**
+ * A Straight connector with bezier smoothing.
+ * @group Edges
+ * @category Connectors
+ * @constant
+ */
+export declare const CONNECTOR_TYPE_SMOOTH = "Smooth";
+/**
+ * Constant identifying the default stub length to use for orthogonal stubs
+ * @group Edges
+ * @category Connectors
+ * @internal
+ */
+export declare const DEFAULT_ORTHOGONAL_STUB = 30;
+/**
+ * An Orthogonal connector.
+ * @internal
+ */
+export interface IOrthogonalConnector extends Connector {
+    midpoint: number;
+    alwaysRespectStubs: boolean;
+    lastx: number;
+    lasty: number;
+    lastOrientation: number;
+    cornerRadius: number;
+    loopbackRadius: number;
+    isLoopbackCurrently: boolean;
+    geometry: InternalOrthogonalConnectorGeometry;
+    slightlyWonky: boolean;
+    $pathSegments: Array<OrthogonalSegment>;
+    vertexAvoidance: boolean;
+}

package/types/ui/connector-orthogonal/index.d.ts

@@ -0,0 +1,7 @@
+export * from './definitions';
+export * from './utils';
+export * from './vertex-avoidance';
+export * from './operations';
+export * from './default-orthogonal-path-compute';
+export * from "./modern-source-target-relocator";
+export * from "./stub-calculators";

package/types/ui/connector-orthogonal/modern-source-target-relocator.d.ts

@@ -0,0 +1,37 @@
+import { ConnectorComputeParams, PaintGeometry } from "../core/connector/abstract-connector";
+import { IOrthogonalConnector, OrthogonalSegment } from "./definitions";
+/**
+ * Rewrite orthogonal connectors
+ * @internal
+ * @param oc
+ * @param paintInfo
+ * @param params
+ */
+export declare function $rewriteOrthogonalConnector(oc: IOrthogonalConnector, paintInfo: PaintGeometry, params: ConnectorComputeParams): void;
+/**
+ * @internal
+ * @param oc
+ * @param segments
+ * @private
+ *
+ * Removes segments that are smaller than the connector's stub and which lie between two segments of the other orientation - basically the bottom edge of a U shape.
+ * this only applies for segments which are not attached to one of the stubs, and it's only U shape:
+ *
+ * |
+ * --------------------
+ *                     |
+ *     ----------------
+ *     |
+ *
+ * Here we'd rewrite to
+ *
+ * |
+ * ----
+ *     |
+ *     |
+ *
+ *
+ *
+ */
+export declare function _removeShortSegments(oc: IOrthogonalConnector, segments: Array<OrthogonalSegment>): Array<OrthogonalSegment>;
+export declare function stubRelocator(index: 0 | 1, oc: IOrthogonalConnector, paintInfo: PaintGeometry, params: ConnectorComputeParams): void;

package/types/ui/connector-orthogonal/operations.d.ts

@@ -0,0 +1,49 @@
+import { ConnectorComputeParams, PaintGeometry } from "../core/connector/abstract-connector";
+import { IOrthogonalConnector, OrthogonalSegment, SegmentMoveResult } from "./definitions";
+import { PointXY, AnchorPlacement } from "../../core";
+import { StraightConnector } from "../connector-straight/straight-connector";
+import { Connection } from "../core";
+/**
+ * Updates an orthogonal connector that has user path edits, if the source or target position for this connector has changed since
+ * it was last painted.
+ * @param sp
+ * @param tp
+ * @param oc
+ * @param paintInfo
+ * @param params
+ * @internal
+ */
+export declare function updateEditedOrthogonalConnector(sp: AnchorPlacement, tp: AnchorPlacement, oc: IOrthogonalConnector, paintInfo: PaintGeometry, params: ConnectorComputeParams, sourceMoved: boolean, targetMoved: boolean): void;
+/**
+ * @internal
+ * @param oc
+ * @param segment
+ * @param pos
+ * @param sourceInfo
+ * @param targetInfo
+ * @param doNotRunVertexAvoidance
+ * @private
+ */
+export declare function _setOrthogonalSegmentPosition(conn: Connection<any>, oc: IOrthogonalConnector, segment: OrthogonalSegment, pos: PointXY, doNotRunVertexAvoidance?: boolean): SegmentMoveResult;
+export declare function _trimOrthogonalSegments(segments: Array<OrthogonalSegment>): Array<OrthogonalSegment>;
+/**
+ * @internal
+ * @param oc
+ * @private
+ */
+export declare function _trimOrthogonalConnector(oc: IOrthogonalConnector): void;
+/**
+ * @internal
+ * @private
+ * @param oc
+ * @param segments
+ * @param paintInfo
+ */
+/**
+ * @internal
+ * @param oc
+ * @param idx
+ * @param orientation
+ * @private
+ */
+export declare function _setOrthogonalAnchorOrientation(oc: IOrthogonalConnector | StraightConnector, idx: number, orientation: number[]): void;

package/types/ui/connector-orthogonal/stub-calculators.d.ts

@@ -0,0 +1,12 @@
+import { X, Y, PointXY } from "../../core";
+import { ConnectorComputeParams, PaintGeometry } from "../core";
+type StubCalculator = (paintInfo: PaintGeometry, alwaysRespectStubs: boolean) => number[];
+/**
+ * @internal
+ */
+export declare const stubCalculators: Map<string, StubCalculator>;
+/**
+ * @internal
+ */
+export declare const lineCalculators: Map<string, (p: PaintGeometry, params: ConnectorComputeParams, axis: typeof X | typeof Y, startStub: number, otherStartStub: number, endStub: number, otherEndStub: number, midx: number, midy: number, maxStub: number) => Array<PointXY>>;
+export {};

package/types/ui/connector-orthogonal/utils.d.ts

@@ -0,0 +1,134 @@
+import { Direction, OrthogonalSegment } from "./definitions";
+import { ORTHOGONAL_AXIS_HORIZONTAL, ORTHOGONAL_AXIS_VERTICAL, OrthogonalAxis, AnchorPlacement } from "../../core";
+import { PaintGeometry } from "../core/connector/abstract-connector";
+/**
+ * Returns whether or not the given value lies between v1 and v2.
+ * @param value Value to compare
+ * @param v1 One bound of the range. This method orders the bounds as needed.
+ * @param v2 Other bound of the range. This method orders the bounds as needed.
+ * @param inclusive If true, value can also equal v1 or v2 (ie the range is inclusive)
+ * @internal
+ */
+export declare function valueInRange(value: number, v1: number, v2: number, inclusive?: boolean): boolean;
+/**
+ * from some given vertical segment, find the next horizontal segment, gathering any other vertical segments found along the way. Searches as far as the end stub.
+ * @param currentSegment
+ * @param currentSegmentIndex
+ * @param segments
+ * @internal
+ */
+export declare function _findNextHorizontalSegment(currentSegment: OrthogonalSegment, currentSegmentIndex: number, segments: Array<OrthogonalSegment>): {
+    segment: OrthogonalSegment;
+    index: number;
+    others: Array<OrthogonalSegment>;
+};
+/**
+ * @internal
+ * @param currentSegment
+ * @param currentSegmentIndex
+ * @param segments
+ * @private
+ */
+export declare function _findPreviousHorizontalSegment(currentSegment: OrthogonalSegment, currentSegmentIndex: number, segments: Array<OrthogonalSegment>): {
+    segment: OrthogonalSegment;
+    index: number;
+    others: Array<OrthogonalSegment>;
+};
+/**
+ * @internal
+ * from some given horizontal segment, find the next vertical segment, gathering any other horizontal segments found along the way. Searches as far as the end stub.
+ * @param currentSegment
+ * @param currentSegmentIndex
+ * @param segments
+ * @private
+ */
+export declare function _findNextVerticalSegment(currentSegment: OrthogonalSegment, currentSegmentIndex: number, segments: Array<OrthogonalSegment>): {
+    segment: OrthogonalSegment;
+    index: number;
+    others: Array<OrthogonalSegment>;
+};
+/**
+ * @internal
+ * @param currentSegment
+ * @param currentSegmentIndex
+ * @param segments
+ * @private
+ */
+export declare function _findPreviousVerticalSegment(currentSegment: OrthogonalSegment, currentSegmentIndex: number, segments: Array<OrthogonalSegment>): {
+    segment: OrthogonalSegment;
+    index: number;
+    others: Array<OrthogonalSegment>;
+};
+/**
+ * @internal
+ * @param currentIndex
+ * @param type
+ * @param segments
+ * @param increment
+ * @private
+ */
+export declare function _findNextSegmentOfType(currentIndex: number, type: OrthogonalAxis, segments: Array<OrthogonalSegment>, increment: 1 | -1): {
+    segment: OrthogonalSegment;
+    index: number;
+    others: Array<OrthogonalSegment>;
+};
+/**
+ * Finds a segment with the given orientation in the given direction from some start point.
+ * If `segment` is provided we use its index as the start point. Otherwise we use either the
+ * 1st segment (the one after the start stub) or the second last segment (the one before the target
+ * stub), depending on the value of `dir`. The start and end stubs are excluded from the search.
+ * @internal
+ * @private
+ * @param segments
+ * @param dir
+ * @param axis
+ * @param segment
+ */
+export declare function findSegment(segments: Array<OrthogonalSegment>, dir: Direction, axis: OrthogonalAxis, segment?: OrthogonalSegment): [OrthogonalSegment, number];
+/**
+ * Looks for a segment of the given axis, in the given direction, that is immediately adjacent to the given `ref` segment. This
+ * method will return null even it finds a segment with the appropriate axis unless that segment
+ * is immediately adjacent.
+ * @param segments
+ * @param dir
+ * @param axis
+ * @param ref
+ * @internal
+ */
+export declare function findAdjacentSegment(segments: Array<OrthogonalSegment>, dir: Direction, axis: OrthogonalAxis, ref: OrthogonalSegment): [OrthogonalSegment, number];
+/**
+ * @internal
+ * @param segment
+ */
+export declare function aSegmentDirections(segment: OrthogonalSegment): {
+    [ORTHOGONAL_AXIS_HORIZONTAL]: number;
+    [ORTHOGONAL_AXIS_VERTICAL]: number;
+};
+/**
+ * @internal
+ * @private
+ * @param segment
+ */
+export declare function segmentDirections(segment: OrthogonalSegment): [number, number];
+/**
+ * @internal
+ * @private
+ * @param p1
+ * @param p2
+ */
+export declare function anchorPlacementEquals(p1: AnchorPlacement, p2: AnchorPlacement): boolean;
+/**
+ * @internal
+ * @private
+ * @param connector
+ * @param x
+ * @param y
+ * @param paintInfo
+ * @param dx
+ * @param dy
+ */
+export declare function addSegment(connector: {
+    lastx: number;
+    lasty: number;
+    orthogonalSegments: Array<OrthogonalSegment>;
+}, x: number, y: number, paintInfo: PaintGeometry, dx: number, dy: number): void;

package/types/ui/connector-orthogonal/vertex-avoidance.d.ts

@@ -0,0 +1,29 @@
+import { IOrthogonalConnector, OrthogonalSegment } from "./definitions";
+import { ViewportElement } from "../core";
+/**
+ * @internal
+ * @param segments
+ * @param sourceInfo
+ * @param vertexPadding
+ */
+export declare function sourceVertexAvoidance(segments: Array<OrthogonalSegment>, sourceInfo: ViewportElement<any>, vertexPadding: number): boolean;
+/**
+ * @internal
+ * @param segments
+ * @param targetInfo
+ * @param vertexPadding
+ */
+export declare function targetVertexAvoidance(segments: Array<OrthogonalSegment>, targetInfo: ViewportElement<any>, vertexPadding: number): boolean;
+/**
+ * @internal
+ * @param oc
+ * @param segments
+ * @param sourceInfo
+ * @param targetInfo
+ * @param targetFirst
+ */
+export declare function vertexAvoidance(oc: IOrthogonalConnector, segments: Array<OrthogonalSegment>, sourceInfo: ViewportElement<any>, targetInfo: ViewportElement<any>, targetFirst: boolean): {
+    sourceAdjusted: boolean;
+    targetAdjusted: boolean;
+    segments: Array<OrthogonalSegment>;
+};

package/types/ui/connector-straight/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./straight-connector";
+export * from "./operations";