groove-dev 0.8.0 → 0.8.2

package/node_modules/@xyflow/react/dist/umd/container/Pane/index.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import type { ReactFlowProps } from '../../types';
+type PaneProps = {
+    isSelecting: boolean;
+    selectionKeyPressed: boolean;
+    children: ReactNode;
+    paneClickDistance: number;
+} & Partial<Pick<ReactFlowProps, 'selectionMode' | 'panOnDrag' | 'onSelectionStart' | 'onSelectionEnd' | 'onPaneClick' | 'onPaneContextMenu' | 'onPaneScroll' | 'onPaneMouseEnter' | 'onPaneMouseMove' | 'onPaneMouseLeave' | 'selectionOnDrag'>>;
+export declare function Pane({ isSelecting, selectionKeyPressed, selectionMode, panOnDrag, paneClickDistance, selectionOnDrag, onSelectionStart, onSelectionEnd, onPaneClick, onPaneContextMenu, onPaneScroll, onPaneMouseEnter, onPaneMouseMove, onPaneMouseLeave, children, }: PaneProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@xyflow/react/dist/umd/container/Pane/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/container/Pane/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AASf,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,aAAa,CAAC;AAElE,KAAK,SAAS,GAAG;IACf,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,QAAQ,EAAE,SAAS,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CACT,IAAI,CACF,cAAc,EACZ,eAAe,GACf,WAAW,GACX,kBAAkB,GAClB,gBAAgB,GAChB,aAAa,GACb,mBAAmB,GACnB,cAAc,GACd,kBAAkB,GAClB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,CACpB,CACF,CAAC;AAqBF,wBAAgB,IAAI,CAAC,EACnB,WAAW,EACX,mBAAmB,EACnB,aAAkC,EAClC,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,QAAQ,GACT,EAAE,SAAS,2CAuNX"}

package/node_modules/@xyflow/react/dist/umd/container/ReactFlow/Wrapper.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from 'react';
+import type { Node, Edge, FitViewOptions } from '../../types';
+import { CoordinateExtent, NodeOrigin, ZIndexMode } from '@xyflow/system';
+export declare function Wrapper({ children, nodes, edges, defaultNodes, defaultEdges, width, height, fitView, fitViewOptions, minZoom, maxZoom, nodeOrigin, nodeExtent, zIndexMode, }: {
+    children: ReactNode;
+    nodes?: Node[];
+    edges?: Edge[];
+    defaultNodes?: Node[];
+    defaultEdges?: Edge[];
+    width?: number;
+    height?: number;
+    fitView?: boolean;
+    fitViewOptions?: FitViewOptions;
+    minZoom?: number;
+    maxZoom?: number;
+    nodeOrigin?: NodeOrigin;
+    nodeExtent?: CoordinateExtent;
+    zIndexMode?: ZIndexMode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Wrapper.d.ts.map

package/node_modules/@xyflow/react/dist/umd/container/ReactFlow/Wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wrapper.d.ts","sourceRoot":"","sources":["../../../src/container/ReactFlow/Wrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAInD,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE1E,wBAAgB,OAAO,CAAC,EACtB,QAAQ,EACR,KAAK,EACL,KAAK,EACL,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,MAAM,EACN,OAAO,EACP,cAAc,EACd,OAAO,EACP,OAAO,EACP,UAAU,EACV,UAAU,EACV,UAAU,GACX,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,2CA8BA"}

package/node_modules/@xyflow/react/dist/umd/container/ReactFlow/index.d.ts

@@ -0,0 +1,24 @@
+import type { Edge, Node, ReactFlowProps } from '../../types';
+/**
+ * The `<ReactFlow />` component is the heart of your React Flow application.
+ * It renders your nodes and edges and handles user interaction
+ *
+ * @public
+ *
+ * @example
+ * ```tsx
+ *import { ReactFlow } from '@xyflow/react'
+ *
+ *export default function Flow() {
+ *  return (<ReactFlow
+ *    nodes={...}
+ *    edges={...}
+ *    onNodesChange={...}
+ *    ...
+ *  />);
+ *}
+ *```
+ */
+declare const _default: <NodeType extends Node = Node, EdgeType extends Edge = Edge>(props: ReactFlowProps<NodeType, EdgeType> & import("react").RefAttributes<HTMLDivElement>) => import("react").JSX.Element;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@xyflow/react/dist/umd/container/ReactFlow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/container/ReactFlow/index.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA2T9D;;;;;;;;;;;;;;;;;;;GAmBG;yBAlUgB,QAAQ,SAAS,IAAI,SAAS,QAAQ,SAAS,IAAI;AAmUtE,wBAA0C"}

package/node_modules/@xyflow/react/dist/umd/container/ReactFlow/init-values.d.ts

@@ -0,0 +1,4 @@
+import { type NodeOrigin, Viewport } from '@xyflow/system';
+export declare const defaultNodeOrigin: NodeOrigin;
+export declare const defaultViewport: Viewport;
+//# sourceMappingURL=init-values.d.ts.map

package/node_modules/@xyflow/react/dist/umd/container/ReactFlow/init-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-values.d.ts","sourceRoot":"","sources":["../../../src/container/ReactFlow/init-values.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE3D,eAAO,MAAM,iBAAiB,EAAE,UAAmB,CAAC;AACpD,eAAO,MAAM,eAAe,EAAE,QAAkC,CAAC"}

package/node_modules/@xyflow/react/dist/umd/container/Viewport/index.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+type ViewportProps = {
+    children: ReactNode;
+};
+export declare function Viewport({ children }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@xyflow/react/dist/umd/container/Viewport/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/container/Viewport/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAOvC,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,SAAS,CAAC;CACrB,CAAC;AAEF,wBAAgB,QAAQ,CAAC,EAAE,QAAQ,EAAE,EAAE,aAAa,2CAQnD"}

package/node_modules/@xyflow/react/dist/umd/container/ZoomPane/index.d.ts

@@ -0,0 +1,7 @@
+import type { FlowRendererProps } from '../FlowRenderer';
+type ZoomPaneProps = Omit<FlowRendererProps, 'deleteKeyCode' | 'selectionKeyCode' | 'multiSelectionKeyCode' | 'noDragClassName' | 'disableKeyboardA11y'> & {
+    isControlledViewport: boolean;
+};
+export declare function ZoomPane({ onPaneContextMenu, zoomOnScroll, zoomOnPinch, panOnScroll, panOnScrollSpeed, panOnScrollMode, zoomOnDoubleClick, panOnDrag, defaultViewport, translateExtent, minZoom, maxZoom, zoomActivationKeyCode, preventScrolling, children, noWheelClassName, noPanClassName, onViewportChange, isControlledViewport, paneClickDistance, selectionOnDrag, }: ZoomPaneProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@xyflow/react/dist/umd/container/ZoomPane/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/container/ZoomPane/index.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGzD,KAAK,aAAa,GAAG,IAAI,CACvB,iBAAiB,EACjB,eAAe,GAAG,kBAAkB,GAAG,uBAAuB,GAAG,iBAAiB,GAAG,qBAAqB,CAC3G,GAAG;IACF,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAQF,wBAAgB,QAAQ,CAAC,EACvB,iBAAiB,EACjB,YAAmB,EACnB,WAAkB,EAClB,WAAmB,EACnB,gBAAsB,EACtB,eAAsC,EACtC,iBAAwB,EACxB,SAAgB,EAChB,eAAe,EACf,eAAe,EACf,OAAO,EACP,OAAO,EACP,qBAAqB,EACrB,gBAAuB,EACvB,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,GAChB,EAAE,aAAa,2CA4Gf"}

package/node_modules/@xyflow/react/dist/umd/contexts/NodeIdContext.d.ts

@@ -0,0 +1,34 @@
+export declare const NodeIdContext: import("react").Context<string | null>;
+export declare const Provider: import("react").Provider<string | null>;
+export declare const Consumer: import("react").Consumer<string | null>;
+/**
+ * You can use this hook to get the id of the node it is used inside. It is useful
+ * if you need the node's id deeper in the render tree but don't want to manually
+ * drill down the id as a prop.
+ *
+ * @public
+ * @returns The id for a node in the flow.
+ *
+ * @example
+ *```jsx
+ *import { useNodeId } from '@xyflow/react';
+ *
+ *export default function CustomNode() {
+ *  return (
+ *    <div>
+ *      <span>This node has an id of </span>
+ *      <NodeIdDisplay />
+ *    </div>
+ *  );
+ *}
+ *
+ *function NodeIdDisplay() {
+ *  const nodeId = useNodeId();
+ *
+ *  return <span>{nodeId}</span>;
+ *}
+ *```
+ */
+export declare const useNodeId: () => string | null;
+export default NodeIdContext;
+//# sourceMappingURL=NodeIdContext.d.ts.map

package/node_modules/@xyflow/react/dist/umd/contexts/NodeIdContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeIdContext.d.ts","sourceRoot":"","sources":["../../src/contexts/NodeIdContext.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,wCAAqC,CAAC;AAChE,eAAO,MAAM,QAAQ,yCAAyB,CAAC;AAC/C,eAAO,MAAM,QAAQ,yCAAyB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS,QAAO,MAAM,GAAG,IAGrC,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/node_modules/@xyflow/react/dist/umd/contexts/StoreContext.d.ts

@@ -0,0 +1,4 @@
+declare const StoreContext: import("react").Context<import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<import("..").ReactFlowState>> | null>;
+export declare const Provider: import("react").Provider<import("zustand/traditional").UseBoundStoreWithEqualityFn<import("zustand").StoreApi<import("..").ReactFlowState>> | null>;
+export default StoreContext;
+//# sourceMappingURL=StoreContext.d.ts.map

package/node_modules/@xyflow/react/dist/umd/contexts/StoreContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoreContext.d.ts","sourceRoot":"","sources":["../../src/contexts/StoreContext.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,YAAY,oJAA6D,CAAC;AAEhF,eAAO,MAAM,QAAQ,qJAAwB,CAAC;AAC9C,eAAe,YAAY,CAAC"}

package/node_modules/@xyflow/react/dist/umd/hooks/useColorModeClass.d.ts

@@ -0,0 +1,9 @@
+import type { ColorMode, ColorModeClass } from '@xyflow/system';
+/**
+ * Hook for receiving the current color mode class 'dark' or 'light'.
+ *
+ * @internal
+ * @param colorMode - The color mode to use ('dark', 'light' or 'system')
+ */
+export declare function useColorModeClass(colorMode: ColorMode): ColorModeClass;
+//# sourceMappingURL=useColorModeClass.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useColorModeClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useColorModeClass.d.ts","sourceRoot":"","sources":["../../src/hooks/useColorModeClass.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAUhE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,CAuBtE"}

package/node_modules/@xyflow/react/dist/umd/hooks/useConnection.d.ts

@@ -0,0 +1,33 @@
+import { ConnectionState } from '@xyflow/system';
+import type { InternalNode, Node } from '../types';
+/**
+ * The `useConnection` hook returns the current connection when there is an active
+ * connection interaction. If no connection interaction is active, it returns null
+ * for every property. A typical use case for this hook is to colorize handles
+ * based on a certain condition (e.g. if the connection is valid or not).
+ *
+ * @public
+ * @param connectionSelector - An optional selector function used to extract a slice of the
+ * `ConnectionState` data. Using a selector can prevent component re-renders where data you don't
+ * otherwise care about might change. If a selector is not provided, the entire `ConnectionState`
+ * object is returned unchanged.
+ * @example
+ *
+ * ```tsx
+ *import { useConnection } from '@xyflow/react';
+ *
+ *function App() {
+ *  const connection = useConnection();
+ *
+ *  return (
+ *    <div> {connection ? `Someone is trying to make a connection from ${connection.fromNode} to this one.` : 'There are currently no incoming connections!'}
+ *
+ *   </div>
+ *   );
+ * }
+ * ```
+ *
+ * @returns ConnectionState
+ */
+export declare function useConnection<NodeType extends Node = Node, SelectorReturn = ConnectionState<InternalNode<NodeType>>>(connectionSelector?: (connection: ConnectionState<InternalNode<NodeType>>) => SelectorReturn): SelectorReturn;
+//# sourceMappingURL=useConnection.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConnection.d.ts","sourceRoot":"","sources":["../../src/hooks/useConnection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAwB,MAAM,gBAAgB,CAAC;AAGvE,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAkB,MAAM,UAAU,CAAC;AAqBnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,cAAc,GAAG,eAAe,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,EAClH,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,KAAK,cAAc,GAC3F,cAAc,CAGhB"}

package/node_modules/@xyflow/react/dist/umd/hooks/useDrag.d.ts

@@ -0,0 +1,18 @@
+import { type RefObject } from 'react';
+type UseDragParams = {
+    nodeRef: RefObject<HTMLDivElement>;
+    disabled?: boolean;
+    noDragClassName?: string;
+    handleSelector?: string;
+    nodeId?: string;
+    isSelectable?: boolean;
+    nodeClickDistance?: number;
+};
+/**
+ * Hook for calling XYDrag helper from @xyflow/system.
+ *
+ * @internal
+ */
+export declare function useDrag({ nodeRef, disabled, noDragClassName, handleSelector, nodeId, isSelectable, nodeClickDistance, }: UseDragParams): boolean;
+export {};
+//# sourceMappingURL=useDrag.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useDrag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDrag.d.ts","sourceRoot":"","sources":["../../src/hooks/useDrag.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAMpE,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,EACtB,OAAO,EACP,QAAgB,EAChB,eAAe,EACf,cAAc,EACd,MAAM,EACN,YAAY,EACZ,iBAAiB,GAClB,EAAE,aAAa,WA4Cf"}

package/node_modules/@xyflow/react/dist/umd/hooks/useEdges.d.ts

@@ -0,0 +1,21 @@
+import type { Edge } from '../types';
+/**
+ * This hook returns an array of the current edges. Components that use this hook
+ * will re-render **whenever any edge changes**.
+ *
+ * @public
+ * @returns An array of all edges currently in the flow.
+ *
+ * @example
+ * ```tsx
+ *import { useEdges } from '@xyflow/react';
+ *
+ *export default function () {
+ *  const edges = useEdges();
+ *
+ *  return <div>There are currently {edges.length} edges!</div>;
+ *}
+ *```
+ */
+export declare function useEdges<EdgeType extends Edge = Edge>(): EdgeType[];
+//# sourceMappingURL=useEdges.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useEdges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEdges.d.ts","sourceRoot":"","sources":["../../src/hooks/useEdges.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,UAAU,CAAC;AAIrD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,EAAE,CAInE"}

package/node_modules/@xyflow/react/dist/umd/hooks/useGlobalKeyHandler.d.ts

@@ -0,0 +1,11 @@
+import type { KeyCode } from '@xyflow/system';
+/**
+ * Hook for handling global key events.
+ *
+ * @internal
+ */
+export declare function useGlobalKeyHandler({ deleteKeyCode, multiSelectionKeyCode, }: {
+    deleteKeyCode: KeyCode | null;
+    multiSelectionKeyCode: KeyCode | null;
+}): void;
+//# sourceMappingURL=useGlobalKeyHandler.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useGlobalKeyHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGlobalKeyHandler.d.ts","sourceRoot":"","sources":["../../src/hooks/useGlobalKeyHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAW9C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,aAAa,EACb,qBAAqB,GACtB,EAAE;IACD,aAAa,EAAE,OAAO,GAAG,IAAI,CAAC;IAC9B,qBAAqB,EAAE,OAAO,GAAG,IAAI,CAAC;CACvC,GAAG,IAAI,CAkBP"}

package/node_modules/@xyflow/react/dist/umd/hooks/useHandleConnections.d.ts

@@ -0,0 +1,23 @@
+import { Connection, HandleConnection, HandleType } from '@xyflow/system';
+type UseHandleConnectionsParams = {
+    /** What type of handle connections do you want to observe? */
+    type: HandleType;
+    /** The handle id (this is only needed if the node has multiple handles of the same type). */
+    id?: string | null;
+    /** If node id is not provided, the node id from the `NodeIdContext` is used. */
+    nodeId?: string;
+    /** Gets called when a connection is established. */
+    onConnect?: (connections: Connection[]) => void;
+    /** Gets called when a connection is removed. */
+    onDisconnect?: (connections: Connection[]) => void;
+};
+/**
+ * Hook to check if a <Handle /> is connected to another <Handle /> and get the connections.
+ *
+ * @public
+ * @deprecated Use `useNodeConnections` instead.
+ * @returns An array with handle connections.
+ */
+export declare function useHandleConnections({ type, id, nodeId, onConnect, onDisconnect, }: UseHandleConnectionsParams): HandleConnection[];
+export {};
+//# sourceMappingURL=useHandleConnections.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useHandleConnections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHandleConnections.d.ts","sourceRoot":"","sources":["../../src/hooks/useHandleConnections.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,UAAU,EAGX,MAAM,gBAAgB,CAAC;AAKxB,KAAK,0BAA0B,GAAG;IAChC,8DAA8D;IAC9D,IAAI,EAAE,UAAU,CAAC;IACjB,6FAA6F;IAC7F,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,SAAS,CAAC,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,IAAI,CAAC;IAChD,gDAAgD;IAChD,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,EAAE,EACF,MAAM,EACN,SAAS,EACT,YAAY,GACb,EAAE,0BAA0B,GAAG,gBAAgB,EAAE,CA2BjD"}

package/node_modules/@xyflow/react/dist/umd/hooks/useInternalNode.d.ts

@@ -0,0 +1,30 @@
+import type { InternalNode, Node } from '../types';
+/**
+ * This hook returns the internal representation of a specific node.
+ * Components that use this hook will re-render **whenever the node changes**,
+ * including when a node is selected or moved.
+ *
+ * @public
+ * @param id - The ID of a node you want to observe.
+ * @returns The `InternalNode` object for the node with the given ID.
+ *
+ * @example
+ * ```tsx
+ *import { useInternalNode } from '@xyflow/react';
+ *
+ *export default function () {
+ *  const internalNode = useInternalNode('node-1');
+ *  const absolutePosition = internalNode.internals.positionAbsolute;
+ *
+ *  return (
+ *    <div>
+ *      The absolute position of the node is at:
+ *      <p>x: {absolutePosition.x}</p>
+ *      <p>y: {absolutePosition.y}</p>
+ *    </div>
+ *  );
+ *}
+ *```
+ */
+export declare function useInternalNode<NodeType extends Node = Node>(id: string): InternalNode<NodeType> | undefined;
+//# sourceMappingURL=useInternalNode.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useInternalNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInternalNode.d.ts","sourceRoot":"","sources":["../../src/hooks/useInternalNode.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,SAAS,CAO5G"}

package/node_modules/@xyflow/react/dist/umd/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+export declare const useIsomorphicLayoutEffect: typeof useEffect;
+//# sourceMappingURL=useIsomorphicLayoutEffect.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useIsomorphicLayoutEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsomorphicLayoutEffect.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsomorphicLayoutEffect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAmB,MAAM,OAAO,CAAC;AAGnD,eAAO,MAAM,yBAAyB,kBAA8D,CAAC"}

package/node_modules/@xyflow/react/dist/umd/hooks/useKeyPress.d.ts

@@ -0,0 +1,53 @@
+import { type KeyCode } from '@xyflow/system';
+export type UseKeyPressOptions = {
+    /**
+     * Listen to key presses on a specific element.
+     * @default document
+     */
+    target?: Window | Document | HTMLElement | ShadowRoot | null;
+    /**
+     * You can use this flag to prevent triggering the key press hook when an input field is focused.
+     * @default true
+     */
+    actInsideInputWithModifier?: boolean;
+    preventDefault?: boolean;
+};
+/**
+ * This hook lets you listen for specific key codes and tells you whether they are
+ * currently pressed or not.
+ *
+ * @public
+ * @param options - Options
+ *
+ * @example
+ * ```tsx
+ *import { useKeyPress } from '@xyflow/react';
+ *
+ *export default function () {
+ *  const spacePressed = useKeyPress('Space');
+ *  const cmdAndSPressed = useKeyPress(['Meta+s', 'Strg+s']);
+ *
+ *  return (
+ *    <div>
+ *     {spacePressed && <p>Space pressed!</p>}
+ *     {cmdAndSPressed && <p>Cmd + S pressed!</p>}
+ *    </div>
+ *  );
+ *}
+ *```
+ */
+export declare function useKeyPress(
+/**
+ * The key code (string or array of strings) specifies which key(s) should trigger
+ * an action.
+ *
+ * A **string** can represent:
+ * - A **single key**, e.g. `'a'`
+ * - A **key combination**, using `'+'` to separate keys, e.g. `'a+d'`
+ *
+ * An  **array of strings** represents **multiple possible key inputs**. For example, `['a', 'd+s']`
+ * means the user can press either the single key `'a'` or the combination of `'d'` and `'s'`.
+ * @default null
+ */
+keyCode?: KeyCode | null, options?: UseKeyPressOptions): boolean;
+//# sourceMappingURL=useKeyPress.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useKeyPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyPress.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeyPress.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAM9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,IAAI,CAAC;IAC7D;;;OAGG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW;AACzB;;;;;;;;;;;GAWG;AACH,OAAO,GAAE,OAAO,GAAG,IAAW,EAC9B,OAAO,GAAE,kBAA6E,GACrF,OAAO,CAuGT"}

package/node_modules/@xyflow/react/dist/umd/hooks/useMoveSelectedNodes.d.ts

@@ -0,0 +1,12 @@
+import { type XYPosition } from '@xyflow/system';
+/**
+ * Hook for updating node positions by passing a direction and factor
+ *
+ * @internal
+ * @returns function for updating node positions
+ */
+export declare function useMoveSelectedNodes(): (params: {
+    direction: XYPosition;
+    factor: number;
+}) => void;
+//# sourceMappingURL=useMoveSelectedNodes.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useMoveSelectedNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMoveSelectedNodes.d.ts","sourceRoot":"","sources":["../../src/hooks/useMoveSelectedNodes.ts"],"names":[],"mappings":"AACA,OAAO,EAAuC,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAQtF;;;;;GAKG;AACH,wBAAgB,oBAAoB,aAGa;IAAE,SAAS,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,UAiDzF"}

package/node_modules/@xyflow/react/dist/umd/hooks/useNodeConnections.d.ts

@@ -0,0 +1,38 @@
+import { type NodeConnection, type HandleType, type HandleConnection } from '@xyflow/system';
+type UseNodeConnectionsParams = {
+    /** ID of the node, filled in automatically if used inside custom node. */
+    id?: string;
+    /** What type of handle connections do you want to observe? */
+    handleType?: HandleType;
+    /** Filter by handle id (this is only needed if the node has multiple handles of the same type). */
+    handleId?: string;
+    /** Gets called when a connection is established. */
+    onConnect?: (connections: HandleConnection[]) => void;
+    /** Gets called when a connection is removed. */
+    onDisconnect?: (connections: HandleConnection[]) => void;
+};
+/**
+ * This hook returns an array of connections on a specific node, handle type ('source', 'target') or handle ID.
+ *
+ * @public
+ * @returns An array with connections.
+ *
+ * @example
+ * ```jsx
+ *import { useNodeConnections } from '@xyflow/react';
+ *
+ *export default function () {
+ *  const connections = useNodeConnections({
+ *    handleType: 'target',
+ *    handleId: 'my-handle',
+ *  });
+ *
+ *  return (
+ *    <div>There are currently {connections.length} incoming connections!</div>
+ *  );
+ *}
+ *```
+ */
+export declare function useNodeConnections({ id, handleType, handleId, onConnect, onDisconnect, }?: UseNodeConnectionsParams): NodeConnection[];
+export {};
+//# sourceMappingURL=useNodeConnections.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useNodeConnections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeConnections.d.ts","sourceRoot":"","sources":["../../src/hooks/useNodeConnections.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAOxB,KAAK,wBAAwB,GAAG;IAC9B,0EAA0E;IAC1E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,SAAS,CAAC,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,KAAK,IAAI,CAAC;IACtD,gDAAgD;IAChD,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,KAAK,IAAI,CAAC;CAC1D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,EAAE,EACF,UAAU,EACV,QAAQ,EACR,SAAS,EACT,YAAY,GACb,GAAE,wBAA6B,GAAG,cAAc,EAAE,CA8BlD"}

package/node_modules/@xyflow/react/dist/umd/hooks/useNodes.d.ts

@@ -0,0 +1,22 @@
+import type { Node } from '../types';
+/**
+ * This hook returns an array of the current nodes. Components that use this hook
+ * will re-render **whenever any node changes**, including when a node is selected
+ * or moved.
+ *
+ * @public
+ * @returns An array of all nodes currently in the flow.
+ *
+ * @example
+ * ```jsx
+ *import { useNodes } from '@xyflow/react';
+ *
+ *export default function() {
+ *  const nodes = useNodes();
+ *
+ *  return <div>There are currently {nodes.length} nodes!</div>;
+ *}
+ *```
+ */
+export declare function useNodes<NodeType extends Node = Node>(): NodeType[];
+//# sourceMappingURL=useNodes.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodes.d.ts","sourceRoot":"","sources":["../../src/hooks/useNodes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,UAAU,CAAC;AAIrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,EAAE,CAInE"}

package/node_modules/@xyflow/react/dist/umd/hooks/useNodesData.d.ts

@@ -0,0 +1,27 @@
+import { DistributivePick } from '@xyflow/system';
+import type { Node } from '../types';
+/**
+ * This hook lets you subscribe to changes of a specific nodes `data` object.
+ *
+ * @public
+ * @returns An object (or array of object) with `id`, `type`, `data` representing each node.
+ *
+ * @example
+ *```jsx
+ *import { useNodesData } from '@xyflow/react';
+ *
+ *export default function() {
+ *  const nodeData = useNodesData('nodeId-1');
+ *  const nodesData = useNodesData(['nodeId-1', 'nodeId-2']);
+ *
+ *  return null;
+ *}
+ *```
+ */
+export declare function useNodesData<NodeType extends Node = Node>(
+/** The id of the node to get the data from. */
+nodeId: string): DistributivePick<NodeType, 'id' | 'type' | 'data'> | null;
+export declare function useNodesData<NodeType extends Node = Node>(
+/** The ids of the nodes to get the data from. */
+nodeIds: string[]): DistributivePick<NodeType, 'id' | 'type' | 'data'>[];
+//# sourceMappingURL=useNodesData.d.ts.map

package/node_modules/@xyflow/react/dist/umd/hooks/useNodesData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodesData.d.ts","sourceRoot":"","sources":["../../src/hooks/useNodesData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAmB,MAAM,gBAAgB,CAAC;AAGnE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI;AACvD,+CAA+C;AAC/C,MAAM,EAAE,MAAM,GACb,gBAAgB,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC;AAC7D,wBAAgB,YAAY,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI;AACvD,iDAAiD;AACjD,OAAO,EAAE,MAAM,EAAE,GAChB,gBAAgB,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC"}

package/node_modules/@xyflow/react/dist/umd/hooks/useNodesEdgesState.d.ts

@@ -0,0 +1,105 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import type { Node, Edge, OnNodesChange, OnEdgesChange } from '../types';
+/**
+ * This hook makes it easy to prototype a controlled flow where you manage the
+ * state of nodes and edges outside the `ReactFlowInstance`. You can think of it
+ * like React's `useState` hook with an additional helper callback.
+ *
+ * @public
+ * @returns
+ * - `nodes`: The current array of nodes. You might pass this directly to the `nodes` prop of your
+ * `<ReactFlow />` component, or you may want to manipulate it first to perform some layouting,
+ * for example.
+ * - `setNodes`: A function that you can use to update the nodes. You can pass it a new array of
+ * nodes or a callback that receives the current array of nodes and returns a new array of nodes.
+ * This is the same as the second element of the tuple returned by React's `useState` hook.
+ * - `onNodesChange`: A handy callback that can take an array of `NodeChanges` and update the nodes
+ * state accordingly. You'll typically pass this directly to the `onNodesChange` prop of your
+ * `<ReactFlow />` component.
+ * @example
+ *
+ *```tsx
+ *import { ReactFlow, useNodesState, useEdgesState } from '@xyflow/react';
+ *
+ *const initialNodes = [];
+ *const initialEdges = [];
+ *
+ *export default function () {
+ *  const [nodes, setNodes, onNodesChange] = useNodesState(initialNodes);
+ *  const [edges, setEdges, onEdgesChange] = useEdgesState(initialEdges);
+ *
+ *  return (
+ *    <ReactFlow
+ *      nodes={nodes}
+ *      edges={edges}
+ *      onNodesChange={onNodesChange}
+ *      onEdgesChange={onEdgesChange}
+ *    />
+ *  );
+ *}
+ *```
+ *
+ * @remarks This hook was created to make prototyping easier and our documentation
+ * examples clearer. Although it is OK to use this hook in production, in
+ * practice you may want to use a more sophisticated state management solution
+ * like Zustand {@link https://reactflow.dev/docs/guides/state-management/} instead.
+ *
+ */
+export declare function useNodesState<NodeType extends Node>(initialNodes: NodeType[]): [
+    nodes: NodeType[],
+    setNodes: Dispatch<SetStateAction<NodeType[]>>,
+    onNodesChange: OnNodesChange<NodeType>
+];
+/**
+ * This hook makes it easy to prototype a controlled flow where you manage the
+ * state of nodes and edges outside the `ReactFlowInstance`. You can think of it
+ * like React's `useState` hook with an additional helper callback.
+ *
+ * @public
+ * @returns
+ * - `edges`: The current array of edges. You might pass this directly to the `edges` prop of your
+ * `<ReactFlow />` component, or you may want to manipulate it first to perform some layouting,
+ * for example.
+ *
+ * - `setEdges`: A function that you can use to update the edges. You can pass it a new array of
+ * edges or a callback that receives the current array of edges and returns a new array of edges.
+ * This is the same as the second element of the tuple returned by React's `useState` hook.
+ *
+ * - `onEdgesChange`: A handy callback that can take an array of `EdgeChanges` and update the edges
+ * state accordingly. You'll typically pass this directly to the `onEdgesChange` prop of your
+ * `<ReactFlow />` component.
+ * @example
+ *
+ *```tsx
+ *import { ReactFlow, useNodesState, useEdgesState } from '@xyflow/react';
+ *
+ *const initialNodes = [];
+ *const initialEdges = [];
+ *
+ *export default function () {
+ *  const [nodes, setNodes, onNodesChange] = useNodesState(initialNodes);
+ *  const [edges, setEdges, onEdgesChange] = useEdgesState(initialEdges);
+ *
+ *  return (
+ *    <ReactFlow
+ *      nodes={nodes}
+ *      edges={edges}
+ *      onNodesChange={onNodesChange}
+ *      onEdgesChange={onEdgesChange}
+ *    />
+ *  );
+ *}
+ *```
+ *
+ * @remarks This hook was created to make prototyping easier and our documentation
+ * examples clearer. Although it is OK to use this hook in production, in
+ * practice you may want to use a more sophisticated state management solution
+ * like Zustand {@link https://reactflow.dev/docs/guides/state-management/} instead.
+ *
+ */
+export declare function useEdgesState<EdgeType extends Edge = Edge>(initialEdges: EdgeType[]): [
+    edges: EdgeType[],
+    setEdges: Dispatch<SetStateAction<EdgeType[]>>,
+    onEdgesChange: OnEdgesChange<EdgeType>
+];
+//# sourceMappingURL=useNodesEdgesState.d.ts.map