@angflow/system 0.0.88 → 0.0.93

package/dist/umd/utils/edges/smoothstep-edge.d.ts

@@ -0,0 +1,66 @@
+import { Position } from '../../types';
+export interface GetSmoothStepPathParams {
+    /** The `x` position of the source handle. */
+    sourceX: number;
+    /** The `y` position of the source handle. */
+    sourceY: number;
+    /**
+     * The position of the source handle.
+     * @default Position.Bottom
+     */
+    sourcePosition?: Position;
+    /** The `x` position of the target handle. */
+    targetX: number;
+    /** The `y` position of the target handle. */
+    targetY: number;
+    /**
+     * The position of the target handle.
+     * @default Position.Top
+     */
+    targetPosition?: Position;
+    /** @default 5 */
+    borderRadius?: number;
+    centerX?: number;
+    centerY?: number;
+    /** @default 20 */
+    offset?: number;
+    /**
+     * Controls where the bend occurs along the path.
+     * 0 = at source, 1 = at target, 0.5 = midpoint
+     * @default 0.5
+     */
+    stepPosition?: number;
+}
+/**
+ * The `getSmoothStepPath` util returns everything you need to render a stepped path
+ * between two nodes. The `borderRadius` property can be used to choose how rounded
+ * the corners of those steps are.
+ * @public
+ * @returns A path string you can use in an SVG, the `labelX` and `labelY` position (center of path)
+ * and `offsetX`, `offsetY` between source handle and label.
+ *
+ * - `path`: the path to use in an SVG `<path>` element.
+ * - `labelX`: the `x` position you can use to render a label for this edge.
+ * - `labelY`: the `y` position you can use to render a label for this edge.
+ * - `offsetX`: the absolute difference between the source `x` position and the `x` position of the
+ * middle of this path.
+ * - `offsetY`: the absolute difference between the source `y` position and the `y` position of the
+ * middle of this path.
+ * @example
+ * ```js
+ *  const source = { x: 0, y: 20 };
+ *  const target = { x: 150, y: 100 };
+ *
+ *  const [path, labelX, labelY, offsetX, offsetY] = getSmoothStepPath({
+ *    sourceX: source.x,
+ *    sourceY: source.y,
+ *    sourcePosition: Position.Right,
+ *    targetX: target.x,
+ *    targetY: target.y,
+ *    targetPosition: Position.Left,
+ *  });
+ * ```
+ * @remarks This function returns a tuple (aka a fixed-size array) to make it easier to work with multiple edge paths at once.
+ */
+export declare function getSmoothStepPath({ sourceX, sourceY, sourcePosition, targetX, targetY, targetPosition, borderRadius, centerX, centerY, offset, stepPosition, }: GetSmoothStepPathParams): [path: string, labelX: number, labelY: number, offsetX: number, offsetY: number];
+//# sourceMappingURL=smoothstep-edge.d.ts.map

package/dist/umd/utils/edges/smoothstep-edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoothstep-edge.d.ts","sourceRoot":"","sources":["../../../src/utils/edges/smoothstep-edge.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAmB,MAAM,aAAa,CAAC;AAExD,MAAM,WAAW,uBAAuB;IACtC,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,iBAAiB;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAwMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,OAAO,EACP,OAAO,EACP,cAAgC,EAChC,OAAO,EACP,OAAO,EACP,cAA6B,EAC7B,YAAgB,EAChB,OAAO,EACP,OAAO,EACP,MAAW,EACX,YAAkB,GACnB,EAAE,uBAAuB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAoB5G"}

package/dist/umd/utils/edges/straight-edge.d.ts

@@ -0,0 +1,41 @@
+export type GetStraightPathParams = {
+    /** The `x` position of the source handle. */
+    sourceX: number;
+    /** The `y` position of the source handle. */
+    sourceY: number;
+    /** The `x` position of the target handle. */
+    targetX: number;
+    /** The `y` position of the target handle. */
+    targetY: number;
+};
+/**
+ * Calculates the straight line path between two points.
+ * @public
+ * @returns A path string you can use in an SVG, the `labelX` and `labelY` position (center of path)
+ * and `offsetX`, `offsetY` between source handle and label.
+ *
+ * - `path`: the path to use in an SVG `<path>` element.
+ * - `labelX`: the `x` position you can use to render a label for this edge.
+ * - `labelY`: the `y` position you can use to render a label for this edge.
+ * - `offsetX`: the absolute difference between the source `x` position and the `x` position of the
+ * middle of this path.
+ * - `offsetY`: the absolute difference between the source `y` position and the `y` position of the
+ * middle of this path.
+ * @example
+ * ```js
+ *  const source = { x: 0, y: 20 };
+ *  const target = { x: 150, y: 100 };
+ *
+ *  const [path, labelX, labelY, offsetX, offsetY] = getStraightPath({
+ *    sourceX: source.x,
+ *    sourceY: source.y,
+ *    sourcePosition: Position.Right,
+ *    targetX: target.x,
+ *    targetY: target.y,
+ *    targetPosition: Position.Left,
+ *  });
+ * ```
+ * @remarks This function returns a tuple (aka a fixed-size array) to make it easier to work with multiple edge paths at once.
+ */
+export declare function getStraightPath({ sourceX, sourceY, targetX, targetY, }: GetStraightPathParams): [path: string, labelX: number, labelY: number, offsetX: number, offsetY: number];
+//# sourceMappingURL=straight-edge.d.ts.map

package/dist/umd/utils/edges/straight-edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"straight-edge.d.ts","sourceRoot":"","sources":["../../../src/utils/edges/straight-edge.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAAG;IAClC,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAAC,EAC9B,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,GACR,EAAE,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAS1G"}

package/dist/umd/utils/general.d.ts

@@ -0,0 +1,86 @@
+import type { Dimensions, XYPosition, CoordinateExtent, Box, Rect, NodeBase, NodeOrigin, SnapGrid, Transform, InternalNodeBase, NodeLookup, Padding } from '../types';
+import { type Viewport } from '../types';
+import { type AriaLabelConfig } from '../constants';
+export declare const clamp: (val: number, min?: number, max?: number) => number;
+export declare const clampPosition: (position: XYPosition | undefined, extent: CoordinateExtent, dimensions: Partial<Dimensions>) => {
+    x: number;
+    y: number;
+};
+export declare function clampPositionToParent<NodeType extends NodeBase>(childPosition: XYPosition, childDimensions: Dimensions, parent: InternalNodeBase<NodeType>): {
+    x: number;
+    y: number;
+};
+export declare const calcAutoPan: (pos: XYPosition, bounds: Dimensions, speed?: number, distance?: number) => number[];
+export declare const getBoundsOfBoxes: (box1: Box, box2: Box) => Box;
+export declare const rectToBox: ({ x, y, width, height }: Rect) => Box;
+export declare const boxToRect: ({ x, y, x2, y2 }: Box) => Rect;
+export declare const nodeToRect: (node: InternalNodeBase | NodeBase, nodeOrigin?: NodeOrigin) => Rect;
+export declare const nodeToBox: (node: InternalNodeBase | NodeBase, nodeOrigin?: NodeOrigin) => Box;
+export declare const getBoundsOfRects: (rect1: Rect, rect2: Rect) => Rect;
+export declare const getOverlappingArea: (rectA: Rect, rectB: Rect) => number;
+export declare const isRectObject: (obj: any) => obj is Rect;
+export declare const isNumeric: (n: any) => n is number;
+export declare const isDevEnv: () => boolean;
+export declare const devWarn: (id: string, message: string) => void;
+export declare const snapPosition: (position: XYPosition, snapGrid?: SnapGrid) => XYPosition;
+export declare const pointToRendererPoint: ({ x, y }: XYPosition, [tx, ty, tScale]: Transform, snapToGrid?: boolean, snapGrid?: SnapGrid) => XYPosition;
+export declare const rendererPointToPoint: ({ x, y }: XYPosition, [tx, ty, tScale]: Transform) => XYPosition;
+/**
+ * Returns a viewport that encloses the given bounds with padding.
+ * @public
+ * @remarks You can determine bounds of nodes with {@link getNodesBounds} and {@link getBoundsOfRects}
+ * @param bounds - Bounds to fit inside viewport.
+ * @param width - Width of the viewport.
+ * @param height  - Height of the viewport.
+ * @param minZoom - Minimum zoom level of the resulting viewport.
+ * @param maxZoom - Maximum zoom level of the resulting viewport.
+ * @param padding - Padding around the bounds.
+ * @returns A transformed {@link Viewport} that encloses the given bounds which you can pass to e.g. {@link setViewport}.
+ * @example
+ * const { x, y, zoom } = getViewportForBounds(
+ * { x: 0, y: 0, width: 100, height: 100},
+ * 1200, 800, 0.5, 2);
+ */
+export declare const getViewportForBounds: (bounds: Rect, width: number, height: number, minZoom: number, maxZoom: number, padding: Padding) => Viewport;
+export declare const isMacOs: () => boolean;
+export declare function isCoordinateExtent(extent?: CoordinateExtent | 'parent' | null): extent is CoordinateExtent;
+export declare function getNodeDimensions(node: {
+    measured?: {
+        width?: number;
+        height?: number;
+    };
+    width?: number;
+    height?: number;
+    initialWidth?: number;
+    initialHeight?: number;
+}): {
+    width: number;
+    height: number;
+};
+export declare function nodeHasDimensions<NodeType extends NodeBase = NodeBase>(node: NodeType): boolean;
+/**
+ * Convert child position to absolute position
+ *
+ * @internal
+ * @param position
+ * @param parentId
+ * @param nodeLookup
+ * @param nodeOrigin
+ * @returns an internal node with an absolute position
+ */
+export declare function evaluateAbsolutePosition(position: XYPosition, dimensions: {
+    width?: number;
+    height?: number;
+} | undefined, parentId: string, nodeLookup: NodeLookup, nodeOrigin: NodeOrigin): XYPosition;
+export declare function areSetsEqual(a: Set<string>, b: Set<string>): boolean;
+/**
+ * Polyfill for Promise.withResolvers until we can use it in all browsers
+ * @internal
+ */
+export declare function withResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+export declare function mergeAriaLabelConfig(partial?: Partial<AriaLabelConfig>): AriaLabelConfig;
+//# sourceMappingURL=general.d.ts.map

package/dist/umd/utils/general.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../src/utils/general.ts"],"names":[],"mappings":"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"}

package/dist/umd/utils/graph.d.ts

@@ -0,0 +1,191 @@
+import { type Transform, type XYPosition, type Rect, type NodeOrigin, type NodeBase, type EdgeBase, type FitViewParamsBase, type FitViewOptionsBase, CoordinateExtent, OnError, OnBeforeDeleteBase, NodeLookup, InternalNodeBase, NodeDragItem } from '../types';
+/**
+ * Test whether an object is usable as an Edge
+ * @public
+ * @remarks In TypeScript this is a type guard that will narrow the type of whatever you pass in to Edge if it returns true
+ * @param element - The element to test
+ * @returns A boolean indicating whether the element is an Edge
+ */
+export declare const isEdgeBase: <EdgeType extends EdgeBase = EdgeBase>(element: any) => element is EdgeType;
+/**
+ * Test whether an object is usable as a Node
+ * @public
+ * @remarks In TypeScript this is a type guard that will narrow the type of whatever you pass in to Node if it returns true
+ * @param element - The element to test
+ * @returns A boolean indicating whether the element is an Node
+ */
+export declare const isNodeBase: <NodeType extends NodeBase = NodeBase>(element: any) => element is NodeType;
+export declare const isInternalNodeBase: <NodeType extends InternalNodeBase = InternalNodeBase>(element: any) => element is NodeType;
+/**
+ * This util is used to tell you what nodes, if any, are connected to the given node
+ * as the _target_ of an edge.
+ * @public
+ * @param node - The node to get the connected nodes from.
+ * @param nodes - The array of all nodes.
+ * @param edges - The array of all edges.
+ * @returns An array of nodes that are connected over edges where the source is the given node.
+ *
+ * @example
+ * ```ts
+ *import { getOutgoers } from '@xyflow/react';
+ *
+ *const nodes = [];
+ *const edges = [];
+ *
+ *const outgoers = getOutgoers(
+ *  { id: '1', position: { x: 0, y: 0 }, data: { label: 'node' } },
+ *  nodes,
+ *  edges,
+ *);
+ *```
+ */
+export declare const getOutgoers: <NodeType extends NodeBase = NodeBase, EdgeType extends EdgeBase = EdgeBase>(node: NodeType | {
+    id: string;
+}, nodes: NodeType[], edges: EdgeType[]) => NodeType[];
+/**
+ * This util is used to tell you what nodes, if any, are connected to the given node
+ * as the _source_ of an edge.
+ * @public
+ * @param node - The node to get the connected nodes from.
+ * @param nodes - The array of all nodes.
+ * @param edges - The array of all edges.
+ * @returns An array of nodes that are connected over edges where the target is the given node.
+ *
+ * @example
+ * ```ts
+ *import { getIncomers } from '@xyflow/react';
+ *
+ *const nodes = [];
+ *const edges = [];
+ *
+ *const incomers = getIncomers(
+ *  { id: '1', position: { x: 0, y: 0 }, data: { label: 'node' } },
+ *  nodes,
+ *  edges,
+ *);
+ *```
+ */
+export declare const getIncomers: <NodeType extends NodeBase = NodeBase, EdgeType extends EdgeBase = EdgeBase>(node: NodeType | {
+    id: string;
+}, nodes: NodeType[], edges: EdgeType[]) => NodeType[];
+export declare const getNodePositionWithOrigin: (node: NodeBase, nodeOrigin?: NodeOrigin) => XYPosition;
+export type GetNodesBoundsParams<NodeType extends NodeBase = NodeBase> = {
+    /**
+     * Origin of the nodes: `[0, 0]` for top-left, `[0.5, 0.5]` for center.
+     * @default [0, 0]
+     */
+    nodeOrigin?: NodeOrigin;
+    nodeLookup?: NodeLookup<InternalNodeBase<NodeType>>;
+};
+/**
+ * Returns the bounding box that contains all the given nodes in an array. This can
+ * be useful when combined with [`getViewportForBounds`](/api-reference/utils/get-viewport-for-bounds)
+ * to calculate the correct transform to fit the given nodes in a viewport.
+ * @public
+ * @remarks Useful when combined with {@link getViewportForBounds} to calculate the correct transform to fit the given nodes in a viewport.
+ * @param nodes - Nodes to calculate the bounds for.
+ * @returns Bounding box enclosing all nodes.
+ *
+ * @remarks This function was previously called `getRectOfNodes`
+ *
+ * @example
+ * ```js
+ *import { getNodesBounds } from '@xyflow/react';
+ *
+ *const nodes = [
+ *  {
+ *    id: 'a',
+ *    position: { x: 0, y: 0 },
+ *    data: { label: 'a' },
+ *    width: 50,
+ *    height: 25,
+ *  },
+ *  {
+ *    id: 'b',
+ *    position: { x: 100, y: 100 },
+ *    data: { label: 'b' },
+ *    width: 50,
+ *    height: 25,
+ *  },
+ *];
+ *
+ *const bounds = getNodesBounds(nodes);
+ *```
+ */
+export declare const getNodesBounds: <NodeType extends NodeBase = NodeBase>(nodes: (NodeType | InternalNodeBase<NodeType> | string)[], params?: GetNodesBoundsParams<NodeType>) => Rect;
+export type GetInternalNodesBoundsParams<NodeType> = {
+    useRelativePosition?: boolean;
+    filter?: (node: NodeType) => boolean;
+};
+/**
+ * Determines a bounding box that contains all given nodes in an array
+ * @internal
+ */
+export declare const getInternalNodesBounds: <NodeType extends InternalNodeBase | NodeDragItem>(nodeLookup: Map<string, NodeType>, params?: GetInternalNodesBoundsParams<NodeType>) => Rect;
+export declare const getNodesInside: <NodeType extends NodeBase = NodeBase>(nodes: Map<string, InternalNodeBase<NodeType>>, rect: Rect, [tx, ty, tScale]?: Transform, partially?: boolean, excludeNonSelectableNodes?: boolean) => InternalNodeBase<NodeType>[];
+/**
+ * This utility filters an array of edges, keeping only those where either the source or target
+ * node is present in the given array of nodes.
+ * @public
+ * @param nodes - Nodes you want to get the connected edges for.
+ * @param edges - All edges.
+ * @returns Array of edges that connect any of the given nodes with each other.
+ *
+ * @example
+ * ```js
+ *import { getConnectedEdges } from '@xyflow/react';
+ *
+ *const nodes = [
+ *  { id: 'a', position: { x: 0, y: 0 } },
+ *  { id: 'b', position: { x: 100, y: 0 } },
+ *];
+ *
+ *const edges = [
+ *  { id: 'a->c', source: 'a', target: 'c' },
+ *  { id: 'c->d', source: 'c', target: 'd' },
+ *];
+ *
+ *const connectedEdges = getConnectedEdges(nodes, edges);
+ * // => [{ id: 'a->c', source: 'a', target: 'c' }]
+ *```
+ */
+export declare const getConnectedEdges: <NodeType extends NodeBase = NodeBase, EdgeType extends EdgeBase = EdgeBase>(nodes: NodeType[], edges: EdgeType[]) => EdgeType[];
+export declare function fitViewport<Params extends FitViewParamsBase<NodeBase>, Options extends FitViewOptionsBase<NodeBase>>({ nodes, width, height, panZoom, minZoom, maxZoom }: Params, options?: Omit<Options, 'nodes' | 'includeHiddenNodes'>): Promise<boolean>;
+/**
+ * This function calculates the next position of a node, taking into account the node's extent, parent node, and origin.
+ *
+ * @internal
+ * @returns position, positionAbsolute
+ */
+export declare function calculateNodePosition<NodeType extends NodeBase>({ nodeId, nextPosition, nodeLookup, nodeOrigin, nodeExtent, onError, }: {
+    nodeId: string;
+    nextPosition: XYPosition;
+    nodeLookup: NodeLookup<InternalNodeBase<NodeType>>;
+    nodeOrigin?: NodeOrigin;
+    nodeExtent?: CoordinateExtent;
+    onError?: OnError;
+}): {
+    position: XYPosition;
+    positionAbsolute: XYPosition;
+};
+/**
+ * Pass in nodes & edges to delete, get arrays of nodes and edges that actually can be deleted
+ * @internal
+ * @param param.nodesToRemove - The nodes to remove
+ * @param param.edgesToRemove - The edges to remove
+ * @param param.nodes - All nodes
+ * @param param.edges - All edges
+ * @param param.onBeforeDelete - Callback to check which nodes and edges can be deleted
+ * @returns nodes: nodes that can be deleted, edges: edges that can be deleted
+ */
+export declare function getElementsToRemove<NodeType extends NodeBase = NodeBase, EdgeType extends EdgeBase = EdgeBase>({ nodesToRemove, edgesToRemove, nodes, edges, onBeforeDelete, }: {
+    nodesToRemove: Partial<NodeType>[];
+    edgesToRemove: Partial<EdgeType>[];
+    nodes: NodeType[];
+    edges: EdgeType[];
+    onBeforeDelete?: OnBeforeDeleteBase<NodeType, EdgeType>;
+}): Promise<{
+    nodes: NodeType[];
+    edges: EdgeType[];
+}>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/umd/utils/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/utils/graph.ts"],"names":[],"mappings":"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"}

package/dist/umd/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './connections';
+export * from './dom';
+export * from './edges';
+export * from './graph';
+export * from './general';
+export * from './marker';
+export * from './node-toolbar';
+export * from './edge-toolbar';
+export * from './store';
+export * from './types';
+export * from './shallow-node-data';
+//# sourceMappingURL=index.d.ts.map

package/dist/umd/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC"}

package/dist/umd/utils/marker.d.ts

@@ -0,0 +1,9 @@
+import type { EdgeBase, EdgeMarkerType, MarkerProps } from '../types';
+export declare function getMarkerId(marker: EdgeMarkerType | undefined, id?: string | null): string;
+export declare function createMarkerIds(edges: EdgeBase[], { id, defaultColor, defaultMarkerStart, defaultMarkerEnd, }: {
+    id?: string | null;
+    defaultColor?: string | null;
+    defaultMarkerStart?: EdgeMarkerType;
+    defaultMarkerEnd?: EdgeMarkerType;
+}): MarkerProps[];
+//# sourceMappingURL=marker.d.ts.map

package/dist/umd/utils/marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker.d.ts","sourceRoot":"","sources":["../../src/utils/marker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAc,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAElF,wBAAgB,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAe1F;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,EAAE,EACjB,EACE,EAAE,EACF,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,GACjB,EAAE;IACD,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,kBAAkB,CAAC,EAAE,cAAc,CAAC;IACpC,gBAAgB,CAAC,EAAE,cAAc,CAAC;CACnC,iBAmBF"}

package/dist/umd/utils/node-toolbar.d.ts

@@ -0,0 +1,3 @@
+import { Position, type Rect, type Viewport, type Align } from '../';
+export declare function getNodeToolbarTransform(nodeRect: Rect, viewport: Viewport, position: Position, offset: number, align: Align): string;
+//# sourceMappingURL=node-toolbar.d.ts.map

package/dist/umd/utils/node-toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-toolbar.d.ts","sourceRoot":"","sources":["../../src/utils/node-toolbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,KAAK,CAAC;AAErE,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,IAAI,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,GACX,MAAM,CA0CR"}

package/dist/umd/utils/shallow-node-data.d.ts

@@ -0,0 +1,5 @@
+import { NodeBase } from '../types';
+type NodeData = Pick<NodeBase, 'id' | 'type' | 'data'>;
+export declare function shallowNodeData(a: NodeData | NodeData[] | null, b: NodeData | NodeData[] | null): boolean;
+export {};
+//# sourceMappingURL=shallow-node-data.d.ts.map

package/dist/umd/utils/shallow-node-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallow-node-data.d.ts","sourceRoot":"","sources":["../../src/utils/shallow-node-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,KAAK,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC;AAEvD,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE,GAAG,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE,GAAG,IAAI,WAmB/F"}

package/dist/umd/utils/store.d.ts

@@ -0,0 +1,34 @@
+import { ZIndexMode } from '..';
+import { NodeBase, CoordinateExtent, InternalNodeUpdate, NodeOrigin, PanZoomInstance, Transform, XYPosition, ConnectionLookup, EdgeBase, EdgeLookup, InternalNodeBase, NodeLookup, NodeDimensionChange, NodePositionChange, ParentLookup } from '../types';
+import { ParentExpandChild } from './types';
+export declare function updateAbsolutePositions<NodeType extends NodeBase>(nodeLookup: NodeLookup<InternalNodeBase<NodeType>>, parentLookup: ParentLookup<InternalNodeBase<NodeType>>, options?: UpdateNodesOptions<NodeType>): void;
+type UpdateNodesOptions<NodeType extends NodeBase> = {
+    nodeOrigin?: NodeOrigin;
+    nodeExtent?: CoordinateExtent;
+    elevateNodesOnSelect?: boolean;
+    defaults?: Partial<NodeType>;
+    zIndexMode?: ZIndexMode;
+    checkEquality?: boolean;
+};
+export declare function isManualZIndexMode(zIndexMode?: ZIndexMode): boolean;
+type AdoptUserNodesReturn = {
+    nodesInitialized: boolean;
+    hasSelectedNodes: boolean;
+};
+export declare function adoptUserNodes<NodeType extends NodeBase>(nodes: NodeType[], nodeLookup: NodeLookup<InternalNodeBase<NodeType>>, parentLookup: ParentLookup<InternalNodeBase<NodeType>>, options?: UpdateNodesOptions<NodeType>): AdoptUserNodesReturn;
+export declare function handleExpandParent(children: ParentExpandChild[], nodeLookup: NodeLookup, parentLookup: ParentLookup, nodeOrigin?: NodeOrigin): (NodeDimensionChange | NodePositionChange)[];
+export declare function updateNodeInternals<NodeType extends InternalNodeBase>(updates: Map<string, InternalNodeUpdate>, nodeLookup: NodeLookup<NodeType>, parentLookup: ParentLookup<NodeType>, domNode: HTMLElement | null, nodeOrigin?: NodeOrigin, nodeExtent?: CoordinateExtent, zIndexMode?: ZIndexMode): {
+    changes: (NodeDimensionChange | NodePositionChange)[];
+    updatedInternals: boolean;
+};
+export declare function panBy({ delta, panZoom, transform, translateExtent, width, height, }: {
+    delta: XYPosition;
+    panZoom: PanZoomInstance | null;
+    transform: Transform;
+    translateExtent: CoordinateExtent;
+    width: number;
+    height: number;
+}): Promise<boolean>;
+export declare function updateConnectionLookup(connectionLookup: ConnectionLookup, edgeLookup: EdgeLookup, edges: EdgeBase[]): void;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/umd/utils/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/utils/store.ts"],"names":[],"mappings":"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"}

package/dist/umd/utils/types.d.ts

@@ -0,0 +1,8 @@
+import { Rect } from '../types';
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type ParentExpandChild = {
+    id: string;
+    parentId: string;
+    rect: Rect;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/umd/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE9E,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC"}

package/dist/umd/xydrag/XYDrag.d.ts

@@ -0,0 +1,55 @@
+import type { NodeBase, NodeDragItem, EdgeBase, CoordinateExtent, NodeOrigin, OnError, SnapGrid, Transform, PanBy, OnSelectionDrag, UpdateNodePositions, InternalNodeBase } from '../types';
+export type OnDrag = (event: MouseEvent, dragItems: Map<string, NodeDragItem>, node: NodeBase, nodes: NodeBase[]) => void;
+type StoreItems<OnNodeDrag> = {
+    nodes: NodeBase[];
+    nodeLookup: Map<string, InternalNodeBase>;
+    edges: EdgeBase[];
+    nodeExtent: CoordinateExtent;
+    snapGrid: SnapGrid;
+    snapToGrid: boolean;
+    nodeOrigin: NodeOrigin;
+    multiSelectionActive: boolean;
+    domNode?: Element | null;
+    transform: Transform;
+    autoPanOnNodeDrag: boolean;
+    nodesDraggable: boolean;
+    selectNodesOnDrag: boolean;
+    nodeDragThreshold: number;
+    panBy: PanBy;
+    unselectNodesAndEdges: (params?: {
+        nodes?: NodeBase[];
+        edges?: EdgeBase[];
+    }) => void;
+    onError?: OnError;
+    onNodeDragStart?: OnNodeDrag;
+    onNodeDrag?: OnNodeDrag;
+    onNodeDragStop?: OnNodeDrag;
+    onSelectionDragStart?: OnSelectionDrag;
+    onSelectionDrag?: OnSelectionDrag;
+    onSelectionDragStop?: OnSelectionDrag;
+    updateNodePositions: UpdateNodePositions;
+    autoPanSpeed?: number;
+};
+export type XYDragParams<OnNodeDrag> = {
+    getStoreItems: () => StoreItems<OnNodeDrag>;
+    onDragStart?: OnDrag;
+    onDrag?: OnDrag;
+    onDragStop?: OnDrag;
+    onNodeMouseDown?: (id: string) => void;
+    autoPanSpeed?: number;
+};
+export type XYDragInstance = {
+    update: (params: DragUpdateParams) => void;
+    destroy: () => void;
+};
+export type DragUpdateParams = {
+    noDragClassName?: string;
+    handleSelector?: string;
+    isSelectable?: boolean;
+    nodeId?: string;
+    domNode: Element;
+    nodeClickDistance?: number;
+};
+export declare function XYDrag<OnNodeDrag extends (e: any, nodes: any, node: any) => void | undefined>({ onNodeMouseDown, getStoreItems, onDragStart, onDrag, onDragStop, }: XYDragParams<OnNodeDrag>): XYDragInstance;
+export {};
+//# sourceMappingURL=XYDrag.d.ts.map

package/dist/umd/xydrag/XYDrag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XYDrag.d.ts","sourceRoot":"","sources":["../../src/xydrag/XYDrag.ts"],"names":[],"mappings":"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"}

package/dist/umd/xydrag/index.d.ts

@@ -0,0 +1,2 @@
+export * from './XYDrag';
+//# sourceMappingURL=index.d.ts.map

package/dist/umd/xydrag/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/xydrag/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/umd/xydrag/utils.d.ts

@@ -0,0 +1,24 @@
+import { type NodeDragItem, type XYPosition, InternalNodeBase, NodeBase, NodeLookup, SnapGrid } from '../types';
+export declare function isParentSelected<NodeType extends NodeBase>(node: NodeType, nodeLookup: NodeLookup): boolean;
+export declare function hasSelector(target: Element | EventTarget | null, selector: string, domNode: Element): boolean;
+export declare function getDragItems<NodeType extends NodeBase>(nodeLookup: Map<string, InternalNodeBase<NodeType>>, nodesDraggable: boolean, mousePos: XYPosition, nodeId?: string): Map<string, NodeDragItem>;
+export declare function getEventHandlerParams<NodeType extends InternalNodeBase>({ nodeId, dragItems, nodeLookup, dragging, }: {
+    nodeId?: string;
+    dragItems: Map<string, NodeDragItem>;
+    nodeLookup: Map<string, NodeType>;
+    dragging?: boolean;
+}): [NodeBase, NodeBase[]];
+/**
+ * If a selection is being dragged we want to apply the same snap offset to all nodes in the selection.
+ * This function calculates the snap offset based on the first node in the selection.
+ */
+export declare function calculateSnapOffset({ dragItems, snapGrid, x, y, }: {
+    dragItems: Map<string, NodeDragItem>;
+    snapGrid: SnapGrid;
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+} | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/umd/xydrag/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/xydrag/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGhH,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAgB3G;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAU7G;AAGD,wBAAgB,YAAY,CAAC,QAAQ,SAAS,QAAQ,EACpD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC,EACnD,cAAc,EAAE,OAAO,EACvB,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE,MAAM,GACd,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAoC3B;AAOD,wBAAgB,qBAAqB,CAAC,QAAQ,SAAS,gBAAgB,EAAE,EACvE,MAAM,EACN,SAAS,EACT,UAAU,EACV,QAAe,GAChB,EAAE;IACD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACrC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CA+BzB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,SAAS,EACT,QAAQ,EACR,CAAC,EACD,CAAC,GACF,EAAE;IACD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACrC,QAAQ,EAAE,QAAQ,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;;;SAiBA"}

package/dist/umd/xyhandle/XYHandle.d.ts

@@ -0,0 +1,3 @@
+import { XYHandleInstance } from './types';
+export declare const XYHandle: XYHandleInstance;
+//# sourceMappingURL=XYHandle.d.ts.map

package/dist/umd/xyhandle/XYHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XYHandle.d.ts","sourceRoot":"","sources":["../../src/xyhandle/XYHandle.ts"],"names":[],"mappings":"AAkBA,OAAO,EAA8C,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAuTvF,eAAO,MAAM,QAAQ,EAAE,gBAGtB,CAAC"}

package/dist/umd/xyhandle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './XYHandle';
+//# sourceMappingURL=index.d.ts.map

package/dist/umd/xyhandle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/xyhandle/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}