entangle-ui 0.9.0 → 0.10.0

package/dist/esm/components/editor/NodeGraph/useNodeGraphEdgeInteraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeGraphEdgeInteraction.js","sources":["../../../../../../src/components/editor/NodeGraph/useNodeGraphEdgeInteraction.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAcA;;;;AAIG;AACI;AAEP;;;AAGG;AACH;AA6BA;;;;;;;AAOG;AACG;AAGJ;AASA;AACA;AACA;AAEA;AACE;AACA;AACE;;AAEJ;AAEA;;;AAGI;;AACA;AACA;AACE;;;AAGF;AACA;;AACA;AACE;AACA;AACA;;;;AAGA;;AAQA;AACA;AACE;;AAEJ;AACF;AAIF;AACE;AACE;AACA;;AAEF;AACA;AACF;AAEA;;;AAGI;;AACA;AACA;;AACA;AACA;AACA;;;AASA;;AACA;AACA;;AACA;AAKA;;;;AAGA;;;;;;;AAMA;AACA;AACF;;;;;;;AAQC;;;AAKD;AACE;AACE;;AAEJ;;AAGF;AACF;;"}

package/dist/esm/components/editor/NodeGraph/useNodeGraphGroupDrag.js

@@ -0,0 +1,392 @@
+"use client";
+import { useRef, useCallback, useEffect } from 'react';
+import '../../primitives/viewport/Viewport.js';
+import '../../primitives/viewport/ViewportLayer.js';
+import '../../primitives/viewport/ViewportWorld.js';
+import '../../primitives/viewport/ViewportOverlay.js';
+import { screenToWorld } from '../../primitives/viewport/viewportCoords.js';
+import '../../../utils/devWarn.js';
+import { useLatest } from '../../../hooks/useLatest/useLatest.js';
+import '../../../hooks/useBreakpoint/useBreakpoint.js';
+import './../../../assets/src/theme/lightTheme.css.ts.vanilla-Ct6f9Iym.css';
+import '../../../node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
+import './../../../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
+import 'react/jsx-runtime';
+import './../../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
+import '../../../hooks/useNavigationHistory/useNavigationHistory.js';
+import { rectsIntersect, snapDelta, applyGroupResize, getNodeBox, rectContains, toggleSelected } from './nodeGraphMath.js';
+import { useDragGesture } from './useDragGesture.js';
+
+const DRAG_START_THRESHOLD_PX = 3;
+/**
+ * Pointer-driven controller for group bodies and resize handles. Three
+ * gestures share the same session state machine:
+ *
+ * - **drag**: pointerdown on a group body → snap-aware translation that
+ *   carries fully-contained nodes along, refused on overlap with other
+ *   groups, click-selection fallback when below the drag threshold.
+ * - **resize**: pointerdown on a handle → eight-direction resize via
+ *   {@link applyGroupResize}, refused on overlap.
+ * - **click**: pointerup before the drag threshold → selection toggle.
+ *
+ * Document listeners are attached only while a gesture is in flight.
+ */
+function useNodeGraphGroupDrag(options) {
+    const { store, getTransform, localScreenPoint, snapToGrid, disabled, defaultNodeSize, emitGroupsChange, emitNodesChange, emitSelectionChange, } = options;
+    const snapToGridRef = useLatest(snapToGrid);
+    const disabledRef = useLatest(disabled);
+    const emitGroupsChangeRef = useLatest(emitGroupsChange);
+    const emitNodesChangeRef = useLatest(emitNodesChange);
+    const emitSelectionChangeRef = useLatest(emitSelectionChange);
+    const groupSessionRef = useRef(null);
+    /**
+     * True when applying `delta` to the dragged groups (`session.groupStartBounds`)
+     * would put any of them on top of a non-dragged group. Used by the
+     * pointermove handler for live visual feedback and by pointerup to
+     * refuse the commit.
+     */
+    const groupDragWouldOverlap = useCallback((groupStartBounds, delta) => {
+        const currentGroups = store.getData().groups;
+        for (const [draggedId, start] of groupStartBounds) {
+            const next = {
+                x: start.x + delta.x,
+                y: start.y + delta.y,
+                width: start.width,
+                height: start.height,
+            };
+            for (const other of currentGroups) {
+                if (groupStartBounds.has(other.id))
+                    continue;
+                // Skip self defensively — already covered by the line above.
+                if (other.id === draggedId)
+                    continue;
+                if (rectsIntersect(next, other.bounds))
+                    return true;
+            }
+        }
+        return false;
+    }, [store]);
+    /** True when the resized bounds would intersect any non-resized group. */
+    const groupResizeWouldOverlap = useCallback((groupId, nextBounds) => {
+        const currentGroups = store.getData().groups;
+        for (const other of currentGroups) {
+            if (other.id === groupId)
+                continue;
+            if (rectsIntersect(nextBounds, other.bounds))
+                return true;
+        }
+        return false;
+    }, [store]);
+    const gesture = useDragGesture();
+    // ── rAF-throttled interaction commits ──
+    //
+    // See `useNodeGraphNodeDrag` for the rationale — same coalescing pattern
+    // applied to the group drag + resize move stream. Buffer the latest
+    // interaction payload in a ref; an rAF callback drains it once per frame.
+    const pendingInteractionRef = useRef(null);
+    const rafRef = useRef(0);
+    const commitPending = useCallback(() => {
+        const pending = pendingInteractionRef.current;
+        if (!pending)
+            return;
+        pendingInteractionRef.current = null;
+        store.setInteraction(pending);
+    }, [store]);
+    const cancelRaf = useCallback(() => {
+        if (rafRef.current !== 0) {
+            cancelAnimationFrame(rafRef.current);
+            rafRef.current = 0;
+        }
+    }, []);
+    /** Synchronous flush — cancels any pending rAF and commits immediately. */
+    const flushPending = useCallback(() => {
+        cancelRaf();
+        commitPending();
+    }, [cancelRaf, commitPending]);
+    useEffect(() => {
+        return () => {
+            cancelRaf();
+            pendingInteractionRef.current = null;
+        };
+    }, [cancelRaf]);
+    const scheduleCommit = useCallback((next) => {
+        pendingInteractionRef.current = next;
+        if (rafRef.current !== 0)
+            return;
+        rafRef.current = requestAnimationFrame(() => {
+            rafRef.current = 0;
+            commitPending();
+        });
+    }, [commitPending]);
+    // Shared move handler for both the drag-groups and resize-group gestures.
+    // Reads the active session from the ref and pushes the live interaction
+    // delta into the store; the threshold-to-start gate lives here for drags.
+    const handleGroupMove = useCallback((e) => {
+        const session = groupSessionRef.current;
+        if (session?.pointerId !== e.pointerId)
+            return;
+        const current = localScreenPoint(e.clientX, e.clientY);
+        const dx = current.x - session.startScreen.x;
+        const dy = current.y - session.startScreen.y;
+        const transform = getTransform();
+        const worldDelta = {
+            x: dx / transform.zoom,
+            y: dy / transform.zoom,
+        };
+        const snapped = snapDelta(worldDelta, snapToGridRef.current);
+        if (session.kind === 'drag') {
+            if (!session.didDrag) {
+                if (Math.hypot(dx, dy) < DRAG_START_THRESHOLD_PX)
+                    return;
+                session.didDrag = true;
+            }
+            const ids = new Set(session.groupStartBounds.keys());
+            const blocked = groupDragWouldOverlap(session.groupStartBounds, snapped);
+            scheduleCommit({
+                kind: 'drag-groups',
+                groupIds: ids,
+                containedNodeIds: session.containedNodeIds,
+                startWorld: session.startWorld,
+                delta: snapped,
+                blocked,
+            });
+        }
+        else if (session.resizeStartBounds && session.handle) {
+            // `session.kind` is narrowed to 'resize' here (the `'drag'` branch
+            // above is the only other kind); we still guard the optional
+            // resize fields before using them.
+            const nextBounds = applyGroupResize(session.resizeStartBounds, session.handle, snapped);
+            const blocked = groupResizeWouldOverlap(session.clickedGroupId, nextBounds);
+            scheduleCommit({
+                kind: 'resize-group',
+                groupId: session.clickedGroupId,
+                handle: session.handle,
+                startBounds: session.resizeStartBounds,
+                delta: snapped,
+                blocked,
+            });
+        }
+    }, [
+        localScreenPoint,
+        getTransform,
+        snapToGridRef,
+        groupDragWouldOverlap,
+        groupResizeWouldOverlap,
+        scheduleCommit,
+    ]);
+    const handleGroupCancel = useCallback(() => {
+        cancelRaf();
+        pendingInteractionRef.current = null;
+        groupSessionRef.current = null;
+        store.setInteraction({ kind: 'idle' });
+    }, [store, cancelRaf]);
+    const onGroupBodyPointerDown = useCallback((event, group) => {
+        if (event.button !== 0)
+            return;
+        event.stopPropagation();
+        if (disabledRef.current)
+            return;
+        const additive = event.shiftKey || event.metaKey || event.ctrlKey;
+        const currentSelection = store.getSelection();
+        const alreadySelected = currentSelection.groups.includes(group.id);
+        let dragIds;
+        if (alreadySelected) {
+            dragIds = currentSelection.groups;
+        }
+        else if (!additive) {
+            dragIds = [group.id];
+        }
+        else {
+            dragIds = [...currentSelection.groups, group.id];
+        }
+        const startBounds = new Map();
+        for (const g of store.getData().groups) {
+            if (dragIds.includes(g.id)) {
+                startBounds.set(g.id, { ...g.bounds });
+            }
+        }
+        // Snapshot nodes that are fully inside any of the dragged groups —
+        // they ride along with the gesture so the visual grouping stays
+        // consistent.
+        const containedSet = new Set();
+        const nodeStartPositions = new Map();
+        const measuredFor = store.getMeasuredSize;
+        for (const n of store.getData().nodes) {
+            const nb = getNodeBox(n, measuredFor(n.id), defaultNodeSize);
+            for (const startRect of startBounds.values()) {
+                if (rectContains(startRect, nb)) {
+                    containedSet.add(n.id);
+                    nodeStartPositions.set(n.id, { ...n.position });
+                    break;
+                }
+            }
+        }
+        const containedNodeIds = containedSet;
+        const startScreen = localScreenPoint(event.clientX, event.clientY);
+        const startWorld = screenToWorld(startScreen, getTransform());
+        const pointerId = event.pointerId;
+        gesture.begin(event, {
+            onMove: handleGroupMove,
+            onCancel: handleGroupCancel,
+        });
+        groupSessionRef.current = {
+            kind: 'drag',
+            pointerId,
+            clickedGroupId: group.id,
+            handle: null,
+            startScreen,
+            startWorld,
+            selectionAtStart: currentSelection,
+            groupStartBounds: startBounds,
+            containedNodeIds,
+            nodeStartPositions,
+            resizeStartBounds: null,
+            additive,
+            didDrag: false,
+        };
+    }, [
+        disabledRef,
+        defaultNodeSize,
+        store,
+        localScreenPoint,
+        getTransform,
+        gesture,
+        handleGroupMove,
+        handleGroupCancel,
+    ]);
+    const onGroupHandlePointerDown = useCallback((event, group, handle) => {
+        if (event.button !== 0)
+            return;
+        event.stopPropagation();
+        event.preventDefault();
+        if (disabledRef.current)
+            return;
+        const startScreen = localScreenPoint(event.clientX, event.clientY);
+        const startWorld = screenToWorld(startScreen, getTransform());
+        const pointerId = event.pointerId;
+        gesture.begin(event, {
+            onMove: handleGroupMove,
+            onCancel: handleGroupCancel,
+        });
+        groupSessionRef.current = {
+            kind: 'resize',
+            pointerId,
+            clickedGroupId: group.id,
+            handle,
+            startScreen,
+            startWorld,
+            selectionAtStart: store.getSelection(),
+            groupStartBounds: new Map(),
+            containedNodeIds: new Set(),
+            nodeStartPositions: new Map(),
+            resizeStartBounds: { ...group.bounds },
+            additive: false,
+            didDrag: true,
+        };
+        // Immediately register the resize interaction so the canvas + overlay
+        // start tracking from delta=0 at the click point.
+        store.setInteraction({
+            kind: 'resize-group',
+            groupId: group.id,
+            handle,
+            startBounds: { ...group.bounds },
+            delta: { x: 0, y: 0 },
+            blocked: false,
+        });
+    }, [
+        disabledRef,
+        localScreenPoint,
+        getTransform,
+        store,
+        gesture,
+        handleGroupMove,
+        handleGroupCancel,
+    ]);
+    const onGroupBodyPointerUp = useCallback((event, group) => {
+        const session = groupSessionRef.current;
+        if (session?.pointerId !== event.pointerId)
+            return;
+        event.stopPropagation();
+        gesture.finish(event);
+        // Drain the rAF buffer so `store.getInteraction()` below reflects the
+        // last pointermove rather than the previous frame's commit.
+        flushPending();
+        const interaction = store.getInteraction();
+        if (session.kind === 'drag' && session.didDrag) {
+            if (interaction.kind === 'drag-groups' && !interaction.blocked) {
+                const delta = interaction.delta;
+                // Apply the delta to both groups and any nodes that were
+                // contained at gesture start, in a single set of state writes
+                // so consumers get one atomic onGroupsChange + onNodesChange.
+                const nextGroups = store.getData().groups.map(g => {
+                    const start = session.groupStartBounds.get(g.id);
+                    if (!start)
+                        return g;
+                    return {
+                        ...g,
+                        bounds: {
+                            ...start,
+                            x: start.x + delta.x,
+                            y: start.y + delta.y,
+                        },
+                    };
+                });
+                emitGroupsChangeRef.current(nextGroups);
+                if (session.nodeStartPositions.size > 0) {
+                    const nextNodes = store.getData().nodes.map(n => {
+                        const start = session.nodeStartPositions.get(n.id);
+                        if (!start)
+                            return n;
+                        return {
+                            ...n,
+                            position: { x: start.x + delta.x, y: start.y + delta.y },
+                        };
+                    });
+                    emitNodesChangeRef.current(nextNodes);
+                }
+            }
+            // If `blocked`, drop the gesture without committing — the overlay
+            // already snaps back to the start position when we clear the
+            // interaction state below.
+            store.setInteraction({ kind: 'idle' });
+        }
+        else if (session.kind === 'resize') {
+            if (interaction.kind === 'resize-group' &&
+                !interaction.blocked &&
+                session.resizeStartBounds &&
+                session.handle) {
+                const next = applyGroupResize(session.resizeStartBounds, session.handle, interaction.delta);
+                const nextGroups = store
+                    .getData()
+                    .groups.map(g => g.id === session.clickedGroupId ? { ...g, bounds: next } : g);
+                emitGroupsChangeRef.current(nextGroups);
+            }
+            store.setInteraction({ kind: 'idle' });
+        }
+        else {
+            // Plain click on group body → selection
+            const current = session.selectionAtStart;
+            emitSelectionChangeRef.current({
+                nodes: session.additive ? current.nodes : [],
+                edges: session.additive ? current.edges : [],
+                groups: toggleSelected(current.groups, group.id, session.additive),
+            });
+        }
+        groupSessionRef.current = null;
+    }, [
+        store,
+        emitGroupsChangeRef,
+        emitNodesChangeRef,
+        emitSelectionChangeRef,
+        gesture,
+        flushPending,
+    ]);
+    return {
+        onGroupBodyPointerDown,
+        onGroupHandlePointerDown,
+        onGroupBodyPointerUp,
+    };
+}
+
+export { useNodeGraphGroupDrag };
+//# sourceMappingURL=useNodeGraphGroupDrag.js.map

package/dist/esm/components/editor/NodeGraph/useNodeGraphGroupDrag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeGraphGroupDrag.js","sources":["../../../../../../src/components/editor/NodeGraph/useNodeGraphGroupDrag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAkCA;AAiEA;;;;;;;;;;;;AAYG;AACG;;AAeJ;AACA;AACA;AACA;AACA;AAEA;AAEA;;;;;AAKG;;;;AAKG;AACE;AACA;;;;AAIF;AACE;;;AAEA;;AACA;AAAwC;;;AAG5C;AACF;;;;AAQE;AACE;;AACA;AAA8C;;AAEhD;AACF;AAIF;;;;;;AAOA;AACA;AAEA;AACE;AACA;;AACA;AACA;AACF;AAEA;AACE;AACE;AACA;;;;AAKJ;AACE;AACA;AACF;;AAGE;AACE;AACA;AACF;AACF;AAEA;AAEI;AACA;;AACA;AACE;AACA;AACF;AACF;;;;AAOF;AAEI;AACA;;AACA;;;AAGA;AACA;AACE;AACA;;;AAIF;AACE;;;AAEE;;AAEF;;AAOA;AACE;AACA;;;AAGA;;AAED;;;;;;AAKD;;AASA;AACE;;;;AAIA;;AAED;;AAEL;;;;;;;AAQC;AAGH;AACE;AACA;AACA;;AAEF;;AAOI;;;;;AAIA;AACA;AACA;AAEA;;AAEE;;;AAEA;;;;;AAKF;;;AAGI;;;;;;AAOJ;AACA;AACA;;AAEE;;AAEE;AACE;AACA;;;;;;AAON;;AAEA;AACA;AACE;AACA;AACD;;AAGC;;;AAGA;;;AAGA;AACA;;;AAGA;;AAEA;;AAEJ;;;;;;;;;AAUC;;AASC;;;;;;AAKA;;AAEA;AACA;AACE;AACA;AACD;;AAGC;;;;;;AAMA;;;;AAIA;AACA;AACA;;;;;AAKA;;;AAGA;;AAEA;AACD;AACH;;;;;;;;AASC;;AAQC;AACA;;;AAEA;;;AAIA;AAEA;;;AAII;;;;AAIA;AACE;AACA;AAAY;;AAEV;AACA;AACE;AACA;AACA;AACD;;AAEL;AACA;;AAEE;AACE;AACA;AAAY;;AAEV;;;AAGJ;AACA;;;;;;;;AAOC;AACL;;AAGE;;AAGA;;AAMG;AACA;AAGH;;;;;;AAKF;;AAEE;AACA;AACA;AACD;;AAGH;AACF;;;;;;;AAQC;;;;;;AAQL;;"}

package/dist/esm/components/editor/NodeGraph/useNodeGraphKeyboard.js

@@ -0,0 +1,164 @@
+"use client";
+import { useCallback } from 'react';
+import '../../../utils/devWarn.js';
+import { useLatest } from '../../../hooks/useLatest/useLatest.js';
+import '../../../hooks/useBreakpoint/useBreakpoint.js';
+import './../../../assets/src/theme/lightTheme.css.ts.vanilla-Ct6f9Iym.css';
+import '../../../node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
+import './../../../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
+import 'react/jsx-runtime';
+import './../../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
+import '../../../hooks/useNavigationHistory/useNavigationHistory.js';
+
+const NUDGE_STEP_DEFAULT = 1;
+const NUDGE_STEP_SHIFT = 10;
+/**
+ * Keyboard interaction model for `<NodeGraph>`:
+ *
+ * | Keys                | Action                                       |
+ * | ------------------- | -------------------------------------------- |
+ * | Arrow keys          | Nudge selected nodes by 1 grid step (or 1 unit) |
+ * | Shift + Arrow keys  | Nudge by 10× the base step                    |
+ * | Delete / Backspace  | Emit `onDelete(selection)` (non-empty)       |
+ * | Enter               | Emit `onActivate(node)` when exactly one node selected |
+ * | Cmd/Ctrl + A        | Select all nodes                              |
+ * | Escape              | Clear selection (or cancel active gesture)    |
+ */
+function useNodeGraphKeyboard(options) {
+    const { store, emitNodesChange, emitSelectionChange, onDelete, onActivate, snapToGrid, disabled, } = options;
+    const emitNodesChangeRef = useLatest(emitNodesChange);
+    const emitSelectionChangeRef = useLatest(emitSelectionChange);
+    const onDeleteRef = useLatest(onDelete);
+    const onActivateRef = useLatest(onActivate);
+    const snapToGridRef = useLatest(snapToGrid);
+    const disabledRef = useLatest(disabled);
+    const nudgeSelected = useCallback((dx, dy) => {
+        const data = store.getData();
+        const selection = store.getSelection();
+        if (selection.nodes.length === 0)
+            return false;
+        const selectedIds = new Set(selection.nodes);
+        const next = data.nodes.map(node => {
+            if (!selectedIds.has(node.id))
+                return node;
+            return {
+                ...node,
+                position: { x: node.position.x + dx, y: node.position.y + dy },
+            };
+        });
+        emitNodesChangeRef.current(next);
+        return true;
+    }, [store, emitNodesChangeRef]);
+    const onKeyDown = useCallback((event) => {
+        if (disabledRef.current)
+            return;
+        // Don't steal input focus — if the event originated in an editable
+        // element inside a node body, leave it alone.
+        const target = event.target;
+        if (target &&
+            (target.isContentEditable ||
+                target.tagName === 'INPUT' ||
+                target.tagName === 'TEXTAREA' ||
+                target.tagName === 'SELECT')) {
+            return;
+        }
+        const grid = snapToGridRef.current;
+        const baseStep = grid === false || grid <= 0 ? NUDGE_STEP_DEFAULT : grid;
+        const step = event.shiftKey ? baseStep * NUDGE_STEP_SHIFT : baseStep;
+        // Dispatch on `event.code` so character keys are matched by physical
+        // location (e.g. `KeyA` for Ctrl+A), not by the printed character
+        // — which would otherwise differ on non-QWERTY / non-Latin layouts.
+        // For special keys (`ArrowUp`, `Delete`, `Backspace`, `Enter`,
+        // `Escape`) `event.code` equals `event.key`, so existing cases keep
+        // working unchanged.
+        switch (event.code) {
+            case 'ArrowUp':
+                if (nudgeSelected(0, -step))
+                    event.preventDefault();
+                return;
+            case 'ArrowDown':
+                if (nudgeSelected(0, step))
+                    event.preventDefault();
+                return;
+            case 'ArrowLeft':
+                if (nudgeSelected(-step, 0))
+                    event.preventDefault();
+                return;
+            case 'ArrowRight':
+                if (nudgeSelected(step, 0))
+                    event.preventDefault();
+                return;
+            case 'Delete':
+            case 'Backspace': {
+                const selection = store.getSelection();
+                if (selection.nodes.length === 0 &&
+                    selection.edges.length === 0 &&
+                    selection.groups.length === 0) {
+                    return;
+                }
+                onDeleteRef.current?.(selection);
+                event.preventDefault();
+                return;
+            }
+            case 'Enter': {
+                const selection = store.getSelection();
+                if (selection.nodes.length !== 1)
+                    return;
+                const id = selection.nodes[0];
+                const node = id != null ? store.getNodeById(id) : undefined;
+                if (node) {
+                    onActivateRef.current?.(node);
+                    event.preventDefault();
+                }
+                return;
+            }
+            // `event.code` is layout-independent — matches the physical "A"
+            // key regardless of the user's keyboard layout (Polish, Cyrillic,
+            // Dvorak, etc., would otherwise fire a different `event.key`).
+            case 'KeyA': {
+                if (!(event.metaKey || event.ctrlKey))
+                    return;
+                const data = store.getData();
+                emitSelectionChangeRef.current({
+                    nodes: data.nodes.map(n => n.id),
+                    edges: [],
+                    groups: [],
+                });
+                event.preventDefault();
+                return;
+            }
+            case 'Escape': {
+                // Cancel an in-flight connection first; otherwise clear selection.
+                const interaction = store.getInteraction();
+                if (interaction.kind !== 'idle') {
+                    store.setInteraction({ kind: 'idle' });
+                    event.preventDefault();
+                    return;
+                }
+                const selection = store.getSelection();
+                if (selection.nodes.length === 0 &&
+                    selection.edges.length === 0 &&
+                    selection.groups.length === 0) {
+                    return;
+                }
+                emitSelectionChangeRef.current({ nodes: [], edges: [], groups: [] });
+                event.preventDefault();
+                return;
+            }
+            default:
+                return;
+        }
+    }, [
+        store,
+        nudgeSelected,
+        onDeleteRef,
+        onActivateRef,
+        emitSelectionChangeRef,
+        snapToGridRef,
+        disabledRef,
+    ]);
+    return { onKeyDown };
+}
+
+export { useNodeGraphKeyboard };
+//# sourceMappingURL=useNodeGraphKeyboard.js.map

package/dist/esm/components/editor/NodeGraph/useNodeGraphKeyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeGraphKeyboard.js","sources":["../../../../../../src/components/editor/NodeGraph/useNodeGraphKeyboard.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAyBA;AACA;AAEA;;;;;;;;;;;AAWG;AACG;AAGJ;AAUA;AACA;AACA;AACA;AACA;AACA;;AAII;AACA;AACA;AAAkC;;;;AAGD;;AAE7B;;;AAGJ;AACA;AACA;AACF;AAIF;;;;;AAKI;AACA;;;;AAKI;;;AAKJ;AACA;AACA;;;;;;;AAQA;AACE;AACE;;;AAEF;AACE;;;AAEF;AACE;;;AAEF;AACE;;;AAEF;;AAEE;AACA;AAEE;AACA;;;AAIF;;;;;AAKA;AACA;;;AAEA;;AAEE;;;;;;;;;;;AAUF;;AAEE;AACA;AACA;AACD;;;;;;AAMD;AACA;;;;;AAKA;AACA;AAEE;AACA;;;AAIF;;;;AAIF;;;AAGJ;;;;;;;;AASC;;AAIL;;"}