feat(ui): add type filter toggles

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

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"}

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

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"}

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

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,WA2Cf"}

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

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"}

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

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"}

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

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"}

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

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"}

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

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"}

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

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"}

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

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"}

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

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"}

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

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"}

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

@@ -0,0 +1,26 @@
+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): Pick<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[]): Pick<NodeType, 'id' | 'type' | 'data'>[];
+//# sourceMappingURL=useNodesData.d.ts.map

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":"AAIA,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,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC;AACjD,wBAAgB,YAAY,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI;AACvD,iDAAiD;AACjD,OAAO,EAAE,MAAM,EAAE,GAChB,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC"}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNodesEdgesState.d.ts","sourceRoot":"","sources":["../../src/hooks/useNodesEdgesState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AAGlF,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,IAAI,EACjD,YAAY,EAAE,QAAQ,EAAE,GACvB;IAED,KAAK,EAAE,QAAQ,EAAE;IACjB,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9C,aAAa,EAAE,aAAa,CAAC,QAAQ,CAAC;CACvC,CAQA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,aAAa,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EACxD,YAAY,EAAE,QAAQ,EAAE,GACvB;IAED,KAAK,EAAE,QAAQ,EAAE;IACjB,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9C,aAAa,EAAE,aAAa,CAAC,QAAQ,CAAC;CACvC,CAQA"}

node_modules/@xyflow/react/dist/umd/hooks/useNodesInitialized.d.ts

@@ -0,0 +1,39 @@
+export type UseNodesInitializedOptions = {
+    /** @default false */
+    includeHiddenNodes?: boolean;
+};
+/**
+ * This hook tells you whether all the nodes in a flow have been measured and given
+ *a width and height. When you add a node to the flow, this hook will return
+ *`false` and then `true` again once the node has been measured.
+ *
+ * @public
+ * @returns Whether or not the nodes have been initialized by the `<ReactFlow />` component and
+ * given a width and height.
+ *
+ * @example
+ * ```jsx
+ *import { useReactFlow, useNodesInitialized } from '@xyflow/react';
+ *import { useEffect, useState } from 'react';
+ *
+ *const options = {
+ *  includeHiddenNodes: false,
+ *};
+ *
+ *export default function useLayout() {
+ *  const { getNodes } = useReactFlow();
+ *  const nodesInitialized = useNodesInitialized(options);
+ *  const [layoutedNodes, setLayoutedNodes] = useState(getNodes());
+ *
+ *  useEffect(() => {
+ *    if (nodesInitialized) {
+ *      setLayoutedNodes(yourLayoutingFunction(getNodes()));
+ *    }
+ *  }, [nodesInitialized]);
+ *
+ *  return layoutedNodes;
+ *}
+ *```
+ */
+export declare function useNodesInitialized(options?: UseNodesInitializedOptions): boolean;
+//# sourceMappingURL=useNodesInitialized.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNodesInitialized.d.ts","sourceRoot":"","sources":["../../src/hooks/useNodesInitialized.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,0BAA0B,GAAG;IACvC,qBAAqB;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAoBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,0BAER,GACA,OAAO,CAIT"}

node_modules/@xyflow/react/dist/umd/hooks/useOnEdgesChangeMiddleware.d.ts

@@ -0,0 +1,10 @@
+import type { EdgeChange } from '@xyflow/system';
+import type { Edge } from '../types';
+/**
+ * Registers a middleware function to transform edge changes.
+ *
+ * @public
+ * @param fn - Middleware function. Should be memoized with useCallback to avoid re-registration.
+ */
+export declare function experimental_useOnEdgesChangeMiddleware<EdgeType extends Edge = Edge>(fn: (changes: EdgeChange<EdgeType>[]) => EdgeChange<EdgeType>[]): void;
+//# sourceMappingURL=useOnEdgesChangeMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnEdgesChangeMiddleware.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnEdgesChangeMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,KAAK,EAAE,IAAI,EAAQ,MAAM,UAAU,CAAC;AAE3C;;;;;GAKG;AACH,wBAAgB,uCAAuC,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAClF,EAAE,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,EAAE,KAAK,UAAU,CAAC,QAAQ,CAAC,EAAE,QAgBhE"}

node_modules/@xyflow/react/dist/umd/hooks/useOnInitHandler.d.ts

@@ -0,0 +1,8 @@
+import type { OnInit, Node, Edge } from '../types';
+/**
+ * Hook for calling onInit handler.
+ *
+ * @internal
+ */
+export declare function useOnInitHandler<NodeType extends Node = Node, EdgeType extends Edge = Edge>(onInit: OnInit<NodeType, EdgeType> | undefined): void;
+//# sourceMappingURL=useOnInitHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnInitHandler.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnInitHandler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,SAAS,IAAI,GAAG,IAAI,EACzF,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,SAAS,QAW/C"}

node_modules/@xyflow/react/dist/umd/hooks/useOnNodesChangeMiddleware.d.ts

@@ -0,0 +1,10 @@
+import type { NodeChange } from '@xyflow/system';
+import type { Node } from '../types';
+/**
+ * Registers a middleware function to transform node changes.
+ *
+ * @public
+ * @param fn - Middleware function. Should be memoized with useCallback to avoid re-registration.
+ */
+export declare function experimental_useOnNodesChangeMiddleware<NodeType extends Node = Node>(fn: (changes: NodeChange<NodeType>[]) => NodeChange<NodeType>[]): void;
+//# sourceMappingURL=useOnNodesChangeMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnNodesChangeMiddleware.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnNodesChangeMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,UAAU,CAAC;AAE3C;;;;;GAKG;AACH,wBAAgB,uCAAuC,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAClF,EAAE,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,EAAE,KAAK,UAAU,CAAC,QAAQ,CAAC,EAAE,QAgBhE"}

node_modules/@xyflow/react/dist/umd/hooks/useOnSelectionChange.d.ts

@@ -0,0 +1,43 @@
+import type { OnSelectionChangeFunc, Node, Edge } from '../types';
+export type UseOnSelectionChangeOptions<NodeType extends Node = Node, EdgeType extends Edge = Edge> = {
+    /** The handler to register. */
+    onChange: OnSelectionChangeFunc<NodeType, EdgeType>;
+};
+/**
+ * This hook lets you listen for changes to both node and edge selection. As the
+ *name implies, the callback you provide will be called whenever the selection of
+ *_either_ nodes or edges changes.
+ *
+ * @public
+ * @example
+ * ```jsx
+ *import { useState } from 'react';
+ *import { ReactFlow, useOnSelectionChange } from '@xyflow/react';
+ *
+ *function SelectionDisplay() {
+ *  const [selectedNodes, setSelectedNodes] = useState([]);
+ *  const [selectedEdges, setSelectedEdges] = useState([]);
+ *
+ *  // the passed handler has to be memoized, otherwise the hook will not work correctly
+ *  const onChange = useCallback(({ nodes, edges }) => {
+ *    setSelectedNodes(nodes.map((node) => node.id));
+ *    setSelectedEdges(edges.map((edge) => edge.id));
+ *  }, []);
+ *
+ *  useOnSelectionChange({
+ *    onChange,
+ *  });
+ *
+ *  return (
+ *    <div>
+ *      <p>Selected nodes: {selectedNodes.join(', ')}</p>
+ *      <p>Selected edges: {selectedEdges.join(', ')}</p>
+ *    </div>
+ *  );
+ *}
+ *```
+ *
+ * @remarks You need to memoize the passed `onChange` handler, otherwise the hook will not work correctly.
+ */
+export declare function useOnSelectionChange<NodeType extends Node = Node, EdgeType extends Edge = Edge>({ onChange, }: UseOnSelectionChangeOptions<NodeType, EdgeType>): void;
+//# sourceMappingURL=useOnSelectionChange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnSelectionChange.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnSelectionChange.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAElE,MAAM,MAAM,2BAA2B,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,SAAS,IAAI,GAAG,IAAI,IAAI;IACpG,+BAA+B;IAC/B,QAAQ,EAAE,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;CACrD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,EAC/F,QAAQ,GACT,EAAE,2BAA2B,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAYjD"}

node_modules/@xyflow/react/dist/umd/hooks/useOnViewportChange.d.ts

@@ -0,0 +1,33 @@
+import type { OnViewportChange } from '@xyflow/system';
+export type UseOnViewportChangeOptions = {
+    /** Gets called when the viewport starts changing. */
+    onStart?: OnViewportChange;
+    /** Gets called when the viewport changes. */
+    onChange?: OnViewportChange;
+    /** Gets called when the viewport stops changing. */
+    onEnd?: OnViewportChange;
+};
+/**
+ * The `useOnViewportChange` hook lets you listen for changes to the viewport such
+ * as panning and zooming. You can provide a callback for each phase of a viewport
+ * change: `onStart`, `onChange`, and `onEnd`.
+ *
+ * @public
+ * @example
+ * ```jsx
+ *import { useCallback } from 'react';
+ *import { useOnViewportChange } from '@xyflow/react';
+ *
+ *function ViewportChangeLogger() {
+ *  useOnViewportChange({
+ *    onStart: (viewport: Viewport) => console.log('start', viewport),
+ *    onChange: (viewport: Viewport) => console.log('change', viewport),
+ *    onEnd: (viewport: Viewport) => console.log('end', viewport),
+ *  });
+ *
+ *  return null;
+ *}
+ *```
+ */
+export declare function useOnViewportChange({ onStart, onChange, onEnd }: UseOnViewportChangeOptions): void;
+//# sourceMappingURL=useOnViewportChange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnViewportChange.d.ts","sourceRoot":"","sources":["../../src/hooks/useOnViewportChange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIvD,MAAM,MAAM,0BAA0B,GAAG;IACvC,qDAAqD;IACrD,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,oDAAoD;IACpD,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,0BAA0B,QAc3F"}

node_modules/@xyflow/react/dist/umd/hooks/useReactFlow.d.ts

@@ -0,0 +1,30 @@
+import type { ReactFlowInstance, Node, Edge } from '../types';
+/**
+ * This hook returns a ReactFlowInstance that can be used to update nodes and edges, manipulate the viewport, or query the current state of the flow.
+ *
+ * @public
+ * @example
+ * ```jsx
+ *import { useCallback, useState } from 'react';
+ *import { useReactFlow } from '@xyflow/react';
+ *
+ *export function NodeCounter() {
+ *  const reactFlow = useReactFlow();
+ *  const [count, setCount] = useState(0);
+ *  const countNodes = useCallback(() => {
+ *    setCount(reactFlow.getNodes().length);
+ *    // you need to pass it as a dependency if you are using it with useEffect or useCallback
+ *    // because at the first render, it's not initialized yet and some functions might not work.
+ *  }, [reactFlow]);
+ *
+ *  return (
+ *    <div>
+ *      <button onClick={countNodes}>Update count</button>
+ *      <p>There are {count} nodes in the flow.</p>
+ *    </div>
+ *  );
+ *}
+ *```
+ */
+export declare function useReactFlow<NodeType extends Node = Node, EdgeType extends Edge = Edge>(): ReactFlowInstance<NodeType, EdgeType>;
+//# sourceMappingURL=useReactFlow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useReactFlow.d.ts","sourceRoot":"","sources":["../../src/hooks/useReactFlow.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EACV,iBAAiB,EACjB,IAAI,EACJ,IAAI,EAKL,MAAM,UAAU,CAAC;AAIlB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,SAAS,IAAI,GAAG,IAAI,KAAK,iBAAiB,CAC3G,QAAQ,EACR,QAAQ,CACT,CA8PA"}

node_modules/@xyflow/react/dist/umd/hooks/useResizeHandler.d.ts

@@ -0,0 +1,8 @@
+import { type MutableRefObject } from 'react';
+/**
+ * Hook for handling resize events.
+ *
+ * @internal
+ */
+export declare function useResizeHandler(domNode: MutableRefObject<HTMLDivElement | null>): void;
+//# sourceMappingURL=useResizeHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useResizeHandler.d.ts","sourceRoot":"","sources":["../../src/hooks/useResizeHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAKzD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,IAAI,CAiCvF"}

node_modules/@xyflow/react/dist/umd/hooks/useStore.d.ts

@@ -0,0 +1,45 @@
+import type { Edge, Node, ReactFlowState } from '../types';
+/**
+ * This hook can be used to subscribe to internal state changes of the React Flow
+ * component. The `useStore` hook is re-exported from the [Zustand](https://github.com/pmndrs/zustand)
+ * state management library, so you should check out their docs for more details.
+ *
+ * @public
+ * @param selector - A selector function that returns a slice of the flow's internal state.
+ * Extracting or transforming just the state you need is a good practice to avoid unnecessary
+ * re-renders.
+ * @param equalityFn - A function to compare the previous and next value. This is incredibly useful
+ * for preventing unnecessary re-renders. Good sensible defaults are using `Object.is` or importing
+ * `zustand/shallow`, but you can be as granular as you like.
+ * @returns The selected state slice.
+ *
+ * @example
+ * ```ts
+ * const nodes = useStore((state) => state.nodes);
+ * ```
+ *
+ * @remarks This hook should only be used if there is no other way to access the internal
+ * state. For many of the common use cases, there are dedicated hooks available
+ * such as {@link useReactFlow}, {@link useViewport}, etc.
+ */
+declare function useStore<StateSlice = unknown>(selector: (state: ReactFlowState) => StateSlice, equalityFn?: (a: StateSlice, b: StateSlice) => boolean): StateSlice;
+/**
+ * In some cases, you might need to access the store directly. This hook returns the store object which can be used on demand to access the state or dispatch actions.
+ *
+ * @returns The store object.
+ * @example
+ * ```ts
+ * const store = useStoreApi();
+ * ```
+ *
+ * @remarks This hook should only be used if there is no other way to access the internal
+ * state. For many of the common use cases, there are dedicated hooks available
+ * such as {@link useReactFlow}, {@link useViewport}, etc.
+ */
+declare function useStoreApi<NodeType extends Node = Node, EdgeType extends Edge = Edge>(): {
+    getState: () => ReactFlowState<NodeType, EdgeType>;
+    setState: (partial: ReactFlowState<NodeType, EdgeType> | Partial<ReactFlowState<NodeType, EdgeType>> | ((state: ReactFlowState<NodeType, EdgeType>) => ReactFlowState<NodeType, EdgeType> | Partial<ReactFlowState<NodeType, EdgeType>>), replace?: boolean | undefined) => void;
+    subscribe: (listener: (state: ReactFlowState<NodeType, EdgeType>, prevState: ReactFlowState<NodeType, EdgeType>) => void) => () => void;
+};
+export { useStore, useStoreApi };
+//# sourceMappingURL=useStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useStore.d.ts","sourceRoot":"","sources":["../../src/hooks/useStore.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iBAAS,QAAQ,CAAC,UAAU,GAAG,OAAO,EACpC,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,UAAU,EAC/C,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,KAAK,OAAO,cASvD;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,WAAW,CAAC,QAAQ,SAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,SAAS,IAAI,GAAG,IAAI;;;;EAiB9E;AAED,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

node_modules/@xyflow/react/dist/umd/hooks/useUpdateNodeInternals.d.ts

@@ -0,0 +1,48 @@
+import type { UpdateNodeInternals } from '@xyflow/system';
+/**
+ * When you programmatically add or remove handles to a node or update a node's
+ * handle position, you need to let React Flow know about it using this hook. This
+ * will update the internal dimensions of the node and properly reposition handles
+ * on the canvas if necessary.
+ *
+ * @public
+ * @returns Use this function to tell React Flow to update the internal state of one or more nodes
+ * that you have changed programmatically.
+ *
+ * @example
+ * ```jsx
+ *import { useCallback, useState } from 'react';
+ *import { Handle, useUpdateNodeInternals } from '@xyflow/react';
+ *
+ *export default function RandomHandleNode({ id }) {
+ *  const updateNodeInternals = useUpdateNodeInternals();
+ *  const [handleCount, setHandleCount] = useState(0);
+ *  const randomizeHandleCount = useCallback(() => {
+ *   setHandleCount(Math.floor(Math.random() * 10));
+ *    updateNodeInternals(id);
+ *  }, [id, updateNodeInternals]);
+ *
+ *  return (
+ *    <>
+ *      {Array.from({ length: handleCount }).map((_, index) => (
+ *        <Handle
+ *          key={index}
+ *          type="target"
+ *          position="left"
+ *          id={`handle-${index}`}
+ *        />
+ *      ))}
+ *
+ *      <div>
+ *        <button onClick={randomizeHandleCount}>Randomize handle count</button>
+ *        <p>There are {handleCount} handles on this node.</p>
+ *      </div>
+ *    </>
+ *  );
+ *}
+ *```
+ * @remarks This hook can only be used in a component that is a child of a
+ *{@link ReactFlowProvider} or a {@link ReactFlow} component.
+ */
+export declare function useUpdateNodeInternals(): UpdateNodeInternals;
+//# sourceMappingURL=useUpdateNodeInternals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateNodeInternals.d.ts","sourceRoot":"","sources":["../../src/hooks/useUpdateNodeInternals.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAsB,MAAM,gBAAgB,CAAC;AAI9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,sBAAsB,IAAI,mBAAmB,CAkB5D"}

node_modules/@xyflow/react/dist/umd/hooks/useViewport.d.ts

@@ -0,0 +1,32 @@
+import type { Viewport } from '@xyflow/system';
+/**
+ * The `useViewport` hook is a convenient way to read the current state of the
+ * {@link Viewport} in a component. Components that use this hook
+ * will re-render **whenever the viewport changes**.
+ *
+ * @public
+ * @returns The current viewport.
+ *
+ * @example
+ *
+ *```jsx
+ *import { useViewport } from '@xyflow/react';
+ *
+ *export default function ViewportDisplay() {
+ *  const { x, y, zoom } = useViewport();
+ *
+ *  return (
+ *    <div>
+ *      <p>
+ *        The viewport is currently at ({x}, {y}) and zoomed to {zoom}.
+ *      </p>
+ *    </div>
+ *  );
+ *}
+ *```
+ *
+ * @remarks This hook can only be used in a component that is a child of a
+ *{@link ReactFlowProvider} or a {@link ReactFlow} component.
+ */
+export declare function useViewport(): Viewport;
+//# sourceMappingURL=useViewport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useViewport.d.ts","sourceRoot":"","sources":["../../src/hooks/useViewport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAW/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAItC"}

node_modules/@xyflow/react/dist/umd/hooks/useViewportHelper.d.ts

@@ -0,0 +1,10 @@
+import type { ViewportHelperFunctions } from '../types';
+/**
+ * Hook for getting viewport helper functions.
+ *
+ * @internal
+ * @returns viewport helper functions
+ */
+declare const useViewportHelper: () => ViewportHelperFunctions;
+export default useViewportHelper;
+//# sourceMappingURL=useViewportHelper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useViewportHelper.d.ts","sourceRoot":"","sources":["../../src/hooks/useViewportHelper.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;GAKG;AACH,QAAA,MAAM,iBAAiB,QAAO,uBAsG7B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

node_modules/@xyflow/react/dist/umd/hooks/useViewportSync.d.ts

@@ -0,0 +1,9 @@
+import type { Viewport } from '@xyflow/system';
+/**
+ * Hook for syncing the viewport with the panzoom instance.
+ *
+ * @internal
+ * @param viewport
+ */
+export declare function useViewportSync(viewport?: Viewport): null;
+//# sourceMappingURL=useViewportSync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useViewportSync.d.ts","sourceRoot":"","sources":["../../src/hooks/useViewportSync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAO/C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,QAAQ,QAYlD"}

node_modules/@xyflow/react/dist/umd/hooks/useVisibleEdgeIds.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook for getting the visible edge ids from the store.
+ *
+ * @internal
+ * @param onlyRenderVisible
+ * @returns array with visible edge ids
+ */
+export declare function useVisibleEdgeIds(onlyRenderVisible: boolean): string[];
+//# sourceMappingURL=useVisibleEdgeIds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useVisibleEdgeIds.d.ts","sourceRoot":"","sources":["../../src/hooks/useVisibleEdgeIds.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,iBAAiB,EAAE,OAAO,GAAG,MAAM,EAAE,CAuCtE"}

node_modules/@xyflow/react/dist/umd/hooks/useVisibleNodeIds.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook for getting the visible node ids from the store.
+ *
+ * @internal
+ * @param onlyRenderVisible
+ * @returns array with visible node ids
+ */
+export declare function useVisibleNodeIds(onlyRenderVisible: boolean): string[];
+//# sourceMappingURL=useVisibleNodeIds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useVisibleNodeIds.d.ts","sourceRoot":"","sources":["../../src/hooks/useVisibleNodeIds.ts"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,iBAAiB,EAAE,OAAO,YAI3D"}