@visuallyjs/browser-ui 1.0.0

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

@@ -0,0 +1,297 @@
+import { UICore } from "./core";
+import { PointXY, Size, Extents, LineXY, RectangleXY, Group, Vertex, Node } from "../../core";
+import { GroupMapping } from "./view";
+import { GroupContentAreaInfo } from "./definitions";
+import { Connection } from "./connector/connection-impl";
+/**
+ * Definition of some element's location and rotation in the viewport.
+ * @internal
+ */
+export interface ElementPosition extends PointXY {
+    width: number;
+    height: number;
+    r: number;
+    c: PointXY;
+    dirty: boolean;
+    ro: PointXY;
+}
+/**
+ * @internal
+ */
+export interface ElementBase extends ElementPosition {
+    x2: number;
+    y2: number;
+    id: string;
+}
+/**
+ * @internal
+ */
+export interface ViewportElement<E> extends ElementBase {
+    t: TranslatedViewportElement<E>;
+    el: E;
+    modelObject: Vertex;
+    timestamp?: string;
+    connections?: Array<Connection<E>>;
+    visible?: boolean;
+}
+export interface ViewportNodeElement<E> extends ViewportElement<E> {
+    modelObject: Node;
+}
+/**
+ * An element that tracks a Group
+ * @internal
+ */
+export interface ViewportGroupElement<E> extends ViewportElement<E>, GroupMapping<E> {
+    collapsed: boolean;
+    proxied: boolean;
+    enabled: boolean;
+    contentArea: E;
+    contentAreaOffset: PointXY;
+    lastExpandedSize?: Size;
+    modelObject: Group;
+}
+/**
+ * @internal
+ */
+export interface TranslatedViewportElementBase<E> extends ElementBase {
+    cr: number;
+    sr: number;
+}
+/**
+ * @internal
+ */
+export type TranslatedViewportElement<E> = Omit<TranslatedViewportElementBase<E>, "dirty">;
+/**
+ * @internal
+ * @constructor
+ */
+export declare function EMPTY_ELEMENT<E>(id: string): ViewportElement<E>;
+type SortedElement = {
+    id: string;
+    value: number;
+    otherBound: number;
+};
+/**
+ * Models the positions of the elements a given instance is tracking. Users of the API should not need to interact directly
+ * with a Viewport.
+ * @internal
+ */
+export declare class Viewport<EL> {
+    instance: UICore<EL, any>;
+    private getRenderedElement;
+    private _currentTransaction;
+    private rtree;
+    private _suspended;
+    private _boundsDirty;
+    constructor(instance: UICore<EL, any>, getRenderedElement: (id: string) => EL);
+    setSuspended(val: boolean): void;
+    /**
+     * @deprecated Use RectangleXY in future
+     */
+    getExtents(): Extents;
+    _sortedElements: Record<string, Array<SortedElement>>;
+    private _elementMap;
+    _transformedElementMap: Record<string, TranslatedViewportElement<EL>>;
+    _bounds: Extents;
+    private _updateBounds;
+    private _recalculateBounds;
+    recomputeBounds(): void;
+    /**
+     * Find all - or just one - viewport element(s) that cover the given point, optionally with a margin around each element.
+     * @param x X location to test
+     * @param y Y location to test
+     * @param margin Optional margin. Provide this if you want to avoid each vertex by some amount.
+     * @param greedy If true, the method will exit as soon as it finds one match. In some cases we want to know all the matches and in others we dont.
+     * @param ignoreIds
+     * @internal
+     */
+    findVerticesAtPoint(x: number, y: number, margin?: number, greedy?: boolean, ignoreIds?: Array<string>): Array<ViewportElement<any>>;
+    /**
+     * Returns vertices that intersect the given rectangle, optionally ignoring a set of vertex IDs when performing the calculation. This is used by the astar router and also the lasso.
+     * @param rect Rectangle to test
+     * @param margin optional margin to add around each vertex when testing for intersection.
+     * @param greedy When true, return from the method as soon as a single intersecting vertex is found.
+     * @param ignoreIds Optional list of vertex IDs to exclude from the test.
+     * @param ignoreBoundaryMatch If true, the rtree search will exclude hits where the search rectangle and the hit only share a boundary.
+     * @internal
+     */
+    findVerticesIntersectingWithRect(rect: RectangleXY, margin: number, greedy: boolean, ignoreIds: Array<string>, ignoreBoundaryMatch: boolean): Array<ViewportElement<any>>;
+    /**
+     * Returns vertices that are enclosed by the given rectangle, optionally ignoring a set of vertex IDs when performing the calculation.
+     * @param rect Rectangle to test
+     * @param margin optional margin to add around each vertex when testing for intersection.
+     * @param greedy When true, return from the method as soon as a single intersecting vertex is found.
+     * @param ignoreIds Optional list of vertex IDs to exclude from the test.
+     * @param ignoreBoundaryMatch If true, the rtree search will exclude hits where the search rectangle and the hit only share a boundary.
+     * @internal
+     */
+    findVerticesEnclosedByRect(rect: RectangleXY, margin: number, greedy: boolean, ignoreIds: Array<string>, ignoreBoundaryMatch: boolean): Array<ViewportElement<any>>;
+    /**
+     * Returns whether or not there are vertices that intersect the given rectangle, optionally ignoring a set of vertex IDs when performing the calculation. This is used by the astar router.
+     * @param rect Rectangle to test
+     * @param margin optional margin to add around each vertex when testing for intersection.
+     * @param ignoreIds Optional list of vertex IDs to exclude from the test.
+     * @param ignoreBoundaryMatch If true, the rtree search will exclude hits where the search rectangle and the hit only share a boundary.
+     * @internal
+     */
+    hasVerticesIntersectingWithRect(rect: RectangleXY, margin: number, ignoreIds: Array<string>, ignoreBoundaryMatch: boolean): boolean;
+    /**
+     * @internal
+     * @param l
+     * @param margin
+     * @param ignoreIds
+     */
+    hasLineOfSight(l: LineXY, margin: number, ignoreIds?: Array<string>): boolean;
+    private _finaliseUpdate;
+    /**
+     * Updates the element with the given id. Any of the provided values may be null, in which case they are ignored (we never overwrite an existing value with null).
+     * @param id
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @param rotation
+     * @param modelObject
+     * @param doNotRecalculateBounds Defaults to false. For internal use. If true, does not update viewport bounds after updating the element.
+     */
+    updateElement(id: string, x: number, y: number, width: number, height: number, rotation: number, modelObject: Vertex, doNotRecalculateBounds: boolean): ViewportElement<EL>;
+    $forEachElement(cb: (e: ViewportElement<any>) => any): void;
+    $refreshEveryElement(): void;
+    $refreshElement(elId: string, doNotRecalculateBounds?: boolean, pos?: PointXY, size?: Size, rotation?: number): ViewportElement<EL>;
+    /**
+     * Sets the rotation of the element with the given id, recalculating bounds afterwards.
+     * @param id
+     * @param rotation
+     * @internal
+     */
+    _setElementRotation(id: string, rotation: number): ViewportElement<EL>;
+    /**
+     * Gets the width of the content managed by the viewport, taking any rotated elements into account.
+     */
+    getBoundsWidth(): number;
+    /**
+     * Gets the height of the content managed by the viewport, taking any rotated elements into account.
+     */
+    getBoundsHeight(): number;
+    /**
+     * Gets the leftmost point of the content managed by the viewport, taking any rotated elements into account.
+     */
+    getX(): number;
+    /**
+     * Gets the topmost of the content managed by the viewport, taking any rotated elements into account.
+     */
+    getY(): number;
+    /**
+     * Sets the size of the element with the given ID, recalculating bounds.
+     * @param id
+     * @param w
+     * @param h
+     */
+    setSize(id: string, w: number, h: number): ViewportElement<EL>;
+    /**
+     * Sets the [x,y] position of the element with the given ID, recalculating bounds.
+     * @param id
+     * @param x
+     * @param y
+     * @internal
+     */
+    $_updatePosition(id: string, x: number, y: number): ViewportElement<EL>;
+    /**
+     * Sets the size position of the element with the given ID, recalculating bounds.
+     * @param id
+     * @param width
+     * @param height
+     * @internal
+     */
+    $_updateSize(id: string, width: number, height: number): ViewportElement<EL>;
+    /**
+     * Clears the internal state of the viewport, removing all elements.
+     */
+    reset(): void;
+    /**
+     * Remove the element with the given ID from the viewport.
+     * @param id
+     */
+    remove(id: string): void;
+    /**
+     * Compute the extents of all the child members of the given group
+     * @param trackedGroup
+     * @param relativeToCanvasOrigin Defaults to false, meaning the extents are calculated wrt to the group's origin, which is good for when you want to find the size of the group's children. Setting this to true will give you an answer in canvas coordinates.
+     * @param knownPositions
+     * @param knownSizes
+     * @param contentAreaInfo
+     * @internal
+     */
+    $computeGroupContentExtents(trackedGroup: Group, relativeToCanvasOrigin: boolean, knownPositions: Record<string, PointXY>, knownSizes: Record<string, Size>, contentAreaInfo: GroupContentAreaInfo<EL>): Extents;
+    /**
+     * For the given element ids, compute the extents
+     * @param elementIds
+     * @param originX
+     * @param originY
+     * @param knownPositions Optional map of positions already known.
+     * @param knownSizes Optional map of sizes already known.
+     * @internal
+     */
+    $computeExtentsForElementIds(elementIds: Array<string>, originX: number, originY: number, knownPositions: Record<string, PointXY>, knownSizes: Record<string, Size>): Extents;
+    /**
+     * Clear and bulk-load the rtree
+     * @internal
+     */
+    private _repopulateRTree;
+    /**
+     * 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.
+     * @param id
+     */
+    getPosition(id: string): ViewportElement<EL>;
+    /**
+     * Get all elements managed by the Viewport.
+     */
+    getElements(): Record<string, ViewportElement<EL>>;
+    /**
+     * Returns whether or not the viewport is empty.
+     */
+    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.
+     * @param id
+     */
+    getElement(id: string): ViewportElement<EL>;
+    /**
+     * gets the element's position in the viewport, null if not found.
+     * @param id
+     */
+    getElementPosition(id: string): PointXY;
+    /**
+     * gets the element's size in the viewport, null if not found.
+     * @param id
+     */
+    getElementSize(id: string): Size;
+    /**
+     * gets the element's position+size in the viewport, null if not found.
+     * @param id
+     */
+    getElementBounds(id: string): RectangleXY;
+    /**
+     * Convenience method for casting the return value of getElement to a tracked group element.
+     * @param id
+     * @internal
+     */
+    getGroupElement(id: string): ViewportGroupElement<EL>;
+    /**
+     * Convenience method for casting the return value of getElement to a tracked node element.
+     * @param id
+     * @internal
+     */
+    getNodeElement(id: string): ViewportNodeElement<EL>;
+    /**
+     * Adds a new element to the viewport. If the model object is a group, we find the content area and its offset, as well as setting a few group flags.
+     * @param elId
+     * @param el
+     * @param modelObject
+     * @param position
+     * @param size
+     * @param rotation
+     */
+    addElement(elId: string, el: EL, modelObject: Vertex, position: PointXY, size: Size, rotation: number): ViewportElement<any>;
+}
+export {};

package/types/ui/index.d.ts

@@ -0,0 +1,9 @@
+export * from './copy-paste';
+export * from './common';
+export * from './connector-bezier';
+export * from './connector-orthogonal';
+export * from './connector-straight';
+export * from './core';
+export * from './plugins';
+export * from './property-mappings';
+export * from './util';

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

@@ -0,0 +1,118 @@
+import { Connection, GroupResizeResult, UICore, ViewportElement, ViewportGroupElement } from "../core";
+import { Vertex, Size, VertexUpdatedReason, Edge } from "../../core";
+/**
+ * Placeholder interface for plugin options.
+ * @group Plugins
+ * @category Definitions
+ */
+export interface UIPluginOptions {
+}
+/**
+ * A plugin for the UI. You don't need to worry about this class unless you're planning on writing your own plugin.
+ * @advanced
+ * @group Plugins
+ */
+export interface UIPlugin<EL, O extends UIPluginOptions, U extends UICore<EL, any>> {
+    id: string;
+    initialise(ui: U, options: O): boolean;
+    destroy(): void;
+    reset(): void;
+    /**
+     * Invoked when a group member has been removed
+     * @param element
+     */
+    $groupMemberRemoved: (element: ViewportElement<EL>) => any;
+    /**
+     * Invoked when a group member has been added
+     * @param element
+     */
+    $groupMemberAdded: (element: ViewportElement<EL>) => any;
+    /**
+     * Invoked when a group has been resized
+     * @param element
+     */
+    $groupResized: (params: GroupResizeResult<EL>) => any;
+    /**
+     * Invoked when a group has been collapsed
+     * @param element
+     */
+    $groupCollapsed: (element: ViewportGroupElement<EL>) => any;
+    /**
+     * Invoked when a group has been expanded
+     * @param element
+     */
+    $groupExpanded: (element: ViewportGroupElement<EL>) => any;
+    /**
+     * Invoked when a node has been removed
+     * @param element
+     */
+    $nodeRemoved: (element: ViewportElement<EL>) => void;
+    /**
+     * Invoked when a group has been removed
+     * @param element
+     */
+    $groupRemoved: (element: ViewportGroupElement<EL>) => void;
+    /**
+     * Invoked when an edge has been removed
+     * @param element
+     */
+    $edgeRemoved: (edge: Edge, connection: Connection<EL>) => void;
+    /**
+     * Invoked when an edge has been updated
+     * @param element
+     */
+    $edgeUpdated: (edge: Edge, connection: Connection<EL>) => void;
+    /**
+     * Invoked when a vertex has been resized
+     * @param element
+     */
+    $vertexRotated: (element: ViewportElement<EL>, rotationInDegrees: number) => void;
+    /**
+     * Invoked when a vertex has been rotated
+     * @param element
+     */
+    $vertexResized: (element: ViewportElement<EL>, width: number, height: number) => void;
+    /**
+     * Invoked when a vertex has been re-rendered (its type was changed and it was rerendered, which may have resulted in a different appearance)
+     * @param element
+     */
+    $vertexRerendered: (p: {
+        el: EL;
+        id: string;
+        vertex: Vertex;
+        size: Size;
+    }) => void;
+    /**
+     * Invoked when a vertex has been updated
+     * @param element
+     */
+    $vertexUpdated: (element: ViewportElement<EL>, reason: VertexUpdatedReason) => void;
+    /**
+     * Invoked when an element has been synced with the view and a repaint was requested.
+     * @param element
+     */
+    $vertexSynced: (element: ViewportElement<EL>) => void;
+}
+/**
+ * A full surface plugin spec - name and options.
+ * @group Plugins
+ * @category Definitions
+ * @typeParam O The options type for the specific plugin.
+ */
+export type FullPluginSpec<O extends UIPluginOptions> = {
+    /**
+     * Plugin type
+     */
+    type: string;
+    /**
+     * Options for the plugin
+     */
+    options: O;
+};
+/**
+ * A UI plugin spec - either just its name, or its name and options
+ * @group Plugins
+ * @category Definitions
+ * @typeParam O The options type for the specific plugin.
+ */
+export type UIPluginSpec<O extends UIPluginOptions> = string | FullPluginSpec<O>;

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

@@ -0,0 +1,2 @@
+export * from "./definitions";
+export * from "./plugins";

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

@@ -0,0 +1,7 @@
+import { UIPlugin } from "./definitions";
+import { Constructable } from "../../core";
+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;
+};
+export declare function registerPlugin(pluginName: string): (constructor: Constructable<any>) => void;

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

@@ -0,0 +1,28 @@
+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}.
+ */
+export interface PropertyMapping<D> {
+    /**
+     * Property or properties to map. If an array is provided, values are matched against all properties in the order given.
+     */
+    property: string | Array<string>;
+    /**
+     * A map whose keys are expected values for the given property (or a space-separated string of values if an array of properties was provided), and the values are the type to apply.
+     */
+    mappings: Record<string, D>;
+}
+/**
+ * A set of property mappings for edges.
+ */
+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
+ */
+export interface PropertyMappings {
+    /**
+     * Edge property mappings.
+     */
+    edgeMappings: EdgePropertyMappings;
+}

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

@@ -0,0 +1,2 @@
+export * from './definitions';
+export * from './property-mapper';

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

@@ -0,0 +1,16 @@
+import { EdgePropertyMappings, PropertyMappings } from "./definitions";
+import { ObjectData } from "../../core";
+import { UICore } from "../core";
+export declare class PropertyMapper {
+    private surface;
+    private _$_edgeMappings;
+    private _$_originalEdgeTypeFunction;
+    constructor(surface: UICore<any>, mappings: PropertyMappings);
+    computeTypes(o: ObjectData): string;
+    private _$_init;
+    /**
+     * Gets the list of edge property mappings
+     * @internal
+     */
+    getPropertyMappings(): EdgePropertyMappings;
+}

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

@@ -0,0 +1,3 @@
+export * from "./util";
+export * from './svg-constants';
+export * from './property-tracker';

package/types/ui/util/property-tracker.d.ts

@@ -0,0 +1,8 @@
+import { ObjectData, VisuallyJsModel } from "../../core";
+export declare class PropertyTracker {
+    $properties: Array<string>;
+    $values: ObjectData;
+    constructor(model: VisuallyJsModel, initialValues: ObjectData);
+    getValue(key: string, defaultValue?: any): any;
+    getValues(): ObjectData;
+}

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

@@ -0,0 +1,111 @@
+/**
+ * @internal
+ */
+export declare const FILL = "fill";
+/**
+ * @internal
+ */
+export declare const STROKE = "stroke";
+/**
+ * @internal
+ */
+export declare const STROKE_WIDTH = "stroke-width";
+/**
+ * @internal
+ */
+export declare const LINE_WIDTH = "strokeWidth";
+/**
+ * @internal
+ */
+export declare const ELEMENT_SVG = "svg";
+/**
+ * @internal
+ */
+export declare const ELEMENT_DEFS = "defs";
+/**
+ * @internal
+ */
+export declare const ELEMENT_PATH = "path";
+/**
+ * @internal
+ */
+export declare const ELEMENT_CIRCLE = "circle";
+/**
+ * @internal
+ */
+export declare const ELEMENT_ELLIPSE = "ellipse";
+/**
+ * @internal
+ */
+export declare const ELEMENT_TEXT = "text";
+/**
+ * @internal
+ */
+export declare const ELEMENT_TSPAN = "tspan";
+/**
+ * @internal
+ */
+export declare const ELEMENT_RECT = "rect";
+/**
+ * @internal
+ */
+export declare const ELEMENT_G = "g";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_VERSION = "version";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_XMLNS = "xmlns";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_FILL = "fill";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_DASHARRAY = "stroke-dasharray";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_LINEJOIN = "stroke-linejoin";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_LINECAP = "stroke-linecap";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_MITERLIMIT = "stroke-miterlimit";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_DASHOFFSET = "stroke-dashoffset";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_OPACITY = "stroke-opacity";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE = "stroke";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_STROKE_WIDTH = "stroke-width";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_VECTOR_EFFECT = "vector-effect";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_VALUE_NON_SCALING_STROKE = "non-scaling-stroke";
+/**
+ * @internal
+ */
+export declare const ATTRIBUTE_TEXT_ANCHOR = "text-anchor";
+export declare const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+export declare const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+export declare const XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml";

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

@@ -0,0 +1,69 @@
+/**
+ * Internal method used to filter lists, supporting wildcards.
+ * @param list
+ * @param value
+ * @param missingIsFalse
+ * @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
+ * @param o2
+ * @param keys Optional list of keys to use to copy values from `o2` to `o1`. If this is not provided, all values are copied.
+ * @internal
+ */
+export declare function extend<T>(o1: T, o2: T, keys?: string[]): T;
+/**
+ * Extension of PointXY used internally to track extra information about the rotation.
+ * @internal
+ */
+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`.
+ * @param obj
+ * @param fn
+ * @internal
+ */
+export declare function each(obj: any, fn: Function): void;
+/**
+ * Wraps one function with another, creating a placeholder for the wrapped function if it was null. This is used to wrap the various drag/drop event functions - to allow VisuallyJs to be notified of important lifecycle events without imposing itself on the user's drag/drop functionality.
+ * @param wrappedFunction - original function to wrap; may be null.
+ * @param newFunction - function to wrap the original with.
+ * @param returnOnThisValue - Optional. Indicates that the wrappedFunction should not be executed if the newFunction returns a value matching 'returnOnThisValue'. note that this is a simple comparison and only works for primitives right now.
+ * @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.
+ *
+ * @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.
+ */
+export type ConstrainFunction<EL, E> = (desiredLoc: PointXY, dragEl: EL, constrainRect: Size, size: Size, currentPos: PointXY, e: E) => PointXY;

package/types/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "1.0.0";