entangle-ui 0.9.0 → 0.10.0

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

@@ -0,0 +1,50 @@
+import { NODE_GRAPH_SLOT } from './NodeGraph.types.js';
+
+/**
+ * Marker behind `<NodeGraph.Minimap>` — returns `null` and carries a Symbol
+ * the parent uses to identify it inside `children`. The actual minimap is
+ * mounted by `NodeGraph` itself as `<NodeGraphMinimapInner>`.
+ *
+ * Pure marker, no hooks — kept out of any `'use client'` boundary so RSC
+ * frameworks can keep the type-level slot identity on the server.
+ */
+const NodeGraphMinimapImpl = () => null;
+const NodeGraphMinimap = Object.assign(NodeGraphMinimapImpl, {
+    displayName: 'NodeGraph.Minimap',
+    [NODE_GRAPH_SLOT]: 'minimap',
+});
+/**
+ * Marker behind `<NodeGraph.Background>` — see {@link NodeGraphMinimap} for
+ * the rationale. The parent picks this up and mounts the background canvas
+ * layer in the correct position in the layer stack.
+ */
+const NodeGraphBackgroundImpl = () => null;
+const NodeGraphBackground = Object.assign(NodeGraphBackgroundImpl, {
+    displayName: 'NodeGraph.Background',
+    [NODE_GRAPH_SLOT]: 'background',
+});
+/**
+ * Marker behind `<NodeGraph.Toolbar>` — picked up from `<NodeGraph>` children
+ * and mounted into the viewport overlay layer at the requested
+ * placement. Children render via `<NodeGraphToolbarInner>` which keeps
+ * the toolbar positioned over the graph.
+ */
+const NodeGraphToolbarImpl = () => null;
+const NodeGraphToolbar = Object.assign(NodeGraphToolbarImpl, {
+    displayName: 'NodeGraph.Toolbar',
+    [NODE_GRAPH_SLOT]: 'toolbar',
+});
+/**
+ * Marker behind `<NodeGraph.SpawnPalette>` — picked up by the parent
+ * and mounted as a portal-rendered fuzzy-search palette. Auto-opens on
+ * right-click of empty / group targets via the store's spawn-request
+ * channel.
+ */
+const NodeGraphSpawnPaletteImpl = () => null;
+const NodeGraphSpawnPalette = Object.assign(NodeGraphSpawnPaletteImpl, {
+    displayName: 'NodeGraph.SpawnPalette',
+    [NODE_GRAPH_SLOT]: 'spawn-palette',
+});
+
+export { NodeGraphBackground, NodeGraphMinimap, NodeGraphSpawnPalette, NodeGraphToolbar };
+//# sourceMappingURL=NodeGraphSlots.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphSlots.js","sources":["../../../../../../src/components/editor/NodeGraph/NodeGraphSlots.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAUA;;;;;;;AAOG;AACH,MAAM,oBAAoB,GAA+C,MACvE,IAAI;MAEO,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,oBAAoB,EAAE;AAClE,IAAA,WAAW,EAAE,mBAAmB;IAChC,CAAC,eAAe,GAAG,SAAkB;AACtC,CAAA;AAGD;;;;AAIG;AACH,MAAM,uBAAuB,GAEjB,MAAM,IAAI;MAET,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,uBAAuB,EAAE;AACxE,IAAA,WAAW,EAAE,sBAAsB;IACnC,CAAC,eAAe,GAAG,YAAqB;AACzC,CAAA;AAGD;;;;;AAKG;AACH,MAAM,oBAAoB,GAA+C,MACvE,IAAI;MAEO,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,oBAAoB,EAAE;AAClE,IAAA,WAAW,EAAE,mBAAmB;IAChC,CAAC,eAAe,GAAG,SAAkB;AACtC,CAAA;AAGD;;;;;AAKG;AACH,MAAM,yBAAyB,GAEnB,MAAM,IAAI;MAET,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE;AAC5E,IAAA,WAAW,EAAE,wBAAwB;IACrC,CAAC,eAAe,GAAG,eAAwB;AAC5C,CAAA;;;;"}

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

@@ -0,0 +1,70 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useState, useEffect, useMemo, useCallback } from 'react';
+import { CommandPalette } from '../../feedback/CommandPalette/CommandPalette.js';
+import { useNodeGraphStore } from './NodeGraphContext.js';
+import { generateNodeId } from './nodeGraphIds.js';
+
+/**
+ * Live renderer for `<NodeGraph.SpawnPalette>`. Mounted by the parent
+ * when the slot is present in `<NodeGraph>` children. Subscribes to the
+ * store's spawn-request channel — the main `NodeGraph` component fires
+ * the request when the user right-clicks empty space or a group, so
+ * the consumer doesn't need to wire context-menu state through React.
+ *
+ * Selection on a template:
+ *   1. Calls `template.build(worldPoint)` to get the node body
+ *   2. Assigns a unique id
+ *   3. Hands the full node to `onSpawn(node, ctx)` — typically appends
+ *      to the consumer's `nodes` state
+ *   4. Closes the palette
+ */
+function NodeGraphSpawnPaletteInner({ templates, onSpawn, placeholder = 'Search nodes…', recentKey, width = 400, maxHeight = 360, }) {
+    const store = useNodeGraphStore();
+    const [open, setOpen] = useState(false);
+    const [spawnAt, setSpawnAt] = useState(null);
+    // Listen for "user wants to spawn a node here" pings from the main
+    // NodeGraph component (fired from its handleContextMenu for empty /
+    // group targets). Multiple subscribers is fine — the store fans out.
+    useEffect(() => {
+        return store.subscribeSpawnRequest(info => {
+            setSpawnAt(info);
+            setOpen(true);
+        });
+    }, [store]);
+    const items = useMemo(() => {
+        return templates.map(t => ({
+            id: t.id,
+            label: t.title,
+            ...(t.subtitle !== undefined ? { description: t.subtitle } : {}),
+            ...(t.group !== undefined ? { group: t.group } : {}),
+            ...(t.keywords !== undefined ? { keywords: [...t.keywords] } : {}),
+            ...(t.icon !== undefined ? { icon: t.icon } : {}),
+        }));
+    }, [templates]);
+    const handleClose = useCallback(() => {
+        setOpen(false);
+        setSpawnAt(null);
+    }, []);
+    const handleSelect = useCallback((item) => {
+        const template = templates.find(t => t.id === item.id);
+        if (!template || !spawnAt)
+            return;
+        const worldPoint = spawnAt.worldPoint;
+        const draft = template.build(worldPoint);
+        const node = {
+            ...draft,
+            id: generateNodeId(template.id),
+        };
+        const ctx = {
+            worldPoint,
+            screenPoint: spawnAt.screenPoint,
+        };
+        onSpawn(node, ctx);
+        handleClose();
+    }, [templates, spawnAt, onSpawn, handleClose]);
+    return (jsx(CommandPalette, { open: open, onClose: handleClose, items: items, onSelect: handleSelect, placeholder: placeholder, ...(recentKey !== undefined ? { recentKey } : {}), width: width, maxHeight: maxHeight }));
+}
+
+export { NodeGraphSpawnPaletteInner };
+//# sourceMappingURL=NodeGraphSpawnPalette.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphSpawnPalette.js","sources":["../../../../../../src/components/editor/NodeGraph/NodeGraphSpawnPalette.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAiBA;;;;;;;;;;;;;AAaG;AACG;AAQJ;;;;;;;AAWE;;;AAGA;AACF;AAEA;;;;;;;;AAQG;AACH;AAEA;;;;AAKA;AAEI;AACA;;AACA;;AAEA;AACE;AACA;;AAEF;;;;AAIA;AACA;;;AAiBN;;"}

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

@@ -0,0 +1,543 @@
+const EMPTY_DATA = {
+    nodes: [],
+    edges: [],
+    groups: [],
+    defaultNodeSize: { width: 180, height: 80 },
+};
+const EMPTY_SELECTION = {
+    nodes: [],
+    edges: [],
+    groups: [],
+};
+const EMPTY_HOVER = {
+    hoveredNodeId: null,
+    hoveredEdgeId: null,
+    hoveredPort: null,
+};
+const IDLE = { kind: 'idle' };
+/**
+ * Hot-path runtime state for `<NodeGraph>` — graph data, selection,
+ * interaction, hover. Each slice carries its own subscribe/get pair so
+ * subscribers re-render only on relevant changes (e.g. the edge canvas
+ * subscribes to data + interaction, individual node bodies subscribe only
+ * to selection + drag delta for their own id).
+ *
+ * Mirrors `ViewportStore` / `MinimapStore` in structure.
+ */
+class NodeGraphStore {
+    constructor() {
+        this.data = EMPTY_DATA;
+        this.selection = EMPTY_SELECTION;
+        this.interaction = IDLE;
+        this.hover = EMPTY_HOVER;
+        // `Map<id, NodeGraphNode>` mirror of `data.nodes` — rebuilt in `setData`.
+        // Enables O(1) `getNodeById` lookups for hot paths (edge drawing,
+        // pointer-driven drag handlers) that previously did O(n) `nodes.find`
+        // per call.
+        this.nodeIndex = new Map();
+        // Set of `"${node}\0${port}"` keys for every port referenced by an edge
+        // endpoint — recomputed in `setData` only when the edges reference
+        // changes. Lets `<NodeGraph.Port>` slots auto-derive their "connected"
+        // visual state without the consumer threading a parallel index down
+        // through `renderNode`.
+        this.connectedPorts = new Set();
+        // Map<nodeId, Map<portId, NodeGraphPortPosition>>.
+        // Mutated in place by `<NodeGraph.Port>` slots on mount/resize. Listeners
+        // are notified whenever any port's position, side, or dataType changes.
+        this.portPositions = new Map();
+        // Map<nodeId, NodeGraphMeasuredSize>. Populated by NodeGraphNodeView's
+        // ResizeObserver — used by getNodeBox when node.width/height are absent.
+        this.measuredSizes = new Map();
+        this.dataListeners = new Set();
+        this.connectedPortsListeners = new Set();
+        this.selectionListeners = new Set();
+        this.interactionListeners = new Set();
+        // Per-node interaction subscriptions. Each `<NodeGraphNodeView>` registers
+        // for its own id and is woken only when the interaction state changes in
+        // a way that could affect that node's drag delta — i.e. the node was, or
+        // now is, part of the active drag set. This cuts the notify fan-out from
+        // O(all-nodes) to O(dragged-nodes) per pointermove flush, which is the
+        // dominant cost when dragging a single node out of a large graph.
+        this.nodeInteractionListeners = new Map();
+        this.hoverListeners = new Set();
+        this.portPositionListeners = new Set();
+        this.measuredSizeListeners = new Set();
+        // Monotonic counters used as `useSyncExternalStore` snapshots for the
+        // notify-only port-positions / measured-sizes channels. A stable null
+        // snapshot would let React skip the update via `Object.is(prev, next)`,
+        // even when the subscription fired.
+        this.portPositionsVersion = 0;
+        this.measuredSizesVersion = 0;
+        this.spawnRequestListeners = new Set();
+        // ── Public read API ──
+        this.getData = () => this.data;
+        this.getSelection = () => this.selection;
+        this.getInteraction = () => this.interaction;
+        this.getHover = () => this.hover;
+        /**
+         * The set of `"${node}\0${port}"` keys that are referenced by at least
+         * one edge endpoint. Reference is stable until the membership actually
+         * changes, so it can back a `useSyncExternalStore` snapshot directly.
+         */
+        this.getConnectedPorts = () => this.connectedPorts;
+        /** True when the given port is referenced by at least one edge endpoint. */
+        this.isPortConnected = (nodeId, portId) => {
+            return this.connectedPorts.has(portKey(nodeId, portId));
+        };
+        /**
+         * O(1) node lookup by id, backed by an internal Map rebuilt on each
+         * `setData`. Use this from hot paths instead of `data.nodes.find(...)`.
+         */
+        this.getNodeById = (id) => {
+            return this.nodeIndex.get(id);
+        };
+        /**
+         * Read the registered position of a single port. Returns `null` when the
+         * port hasn't yet been measured (e.g. on first paint before
+         * `useLayoutEffect` has run, or after the slot unmounted).
+         */
+        this.getPortPosition = (nodeId, portId) => {
+            return this.portPositions.get(nodeId)?.get(portId) ?? null;
+        };
+        /** Read the measured DOM size of a node wrapper. */
+        this.getMeasuredSize = (nodeId) => {
+            return this.measuredSizes.get(nodeId) ?? null;
+        };
+        /**
+         * Monotonic snapshot of the port-positions channel — pass to
+         * `useSyncExternalStore` alongside `subscribePortPositions` so React
+         * actually re-renders consumers on every real change. Incremented
+         * whenever a port position is added, updated, removed, or GC'd by
+         * `setData`. Skipped on no-op writes.
+         */
+        this.getPortPositionsVersion = () => this.portPositionsVersion;
+        /**
+         * Monotonic snapshot of the measured-sizes channel — same role as
+         * `getPortPositionsVersion`, for `subscribeMeasuredSizes`.
+         */
+        this.getMeasuredSizesVersion = () => this.measuredSizesVersion;
+        // ── Subscriptions ──
+        this.subscribeData = (cb) => {
+            this.dataListeners.add(cb);
+            return () => {
+                this.dataListeners.delete(cb);
+            };
+        };
+        /**
+         * Subscribe to the connected-ports channel — fires only when the set of
+         * edge-referenced ports actually changes membership (not on every node
+         * move). Backs the auto-`connected` state on `<NodeGraph.Port>`.
+         */
+        this.subscribeConnectedPorts = (cb) => {
+            this.connectedPortsListeners.add(cb);
+            return () => {
+                this.connectedPortsListeners.delete(cb);
+            };
+        };
+        this.subscribeSelection = (cb) => {
+            this.selectionListeners.add(cb);
+            return () => {
+                this.selectionListeners.delete(cb);
+            };
+        };
+        this.subscribeInteraction = (cb) => {
+            this.interactionListeners.add(cb);
+            return () => {
+                this.interactionListeners.delete(cb);
+            };
+        };
+        /**
+         * Subscribe to interaction changes that affect a specific node id. The
+         * callback fires only when the node enters or leaves the active drag set
+         * (drag-nodes `nodeIds`, drag-groups `containedNodeIds`) — every other
+         * tick where the drag set is unchanged for this id is filtered out at the
+         * store layer instead of waking the subscriber for a no-op compare.
+         *
+         * Use this from per-node React subscribers; the global
+         * {@link subscribeInteraction} channel stays in place for canvas layers
+         * and other consumers that care about every interaction change.
+         */
+        this.subscribeNodeInteraction = (nodeId, cb) => {
+            let set = this.nodeInteractionListeners.get(nodeId);
+            if (!set) {
+                set = new Set();
+                this.nodeInteractionListeners.set(nodeId, set);
+            }
+            set.add(cb);
+            return () => {
+                const current = this.nodeInteractionListeners.get(nodeId);
+                if (!current)
+                    return;
+                current.delete(cb);
+                if (current.size === 0) {
+                    this.nodeInteractionListeners.delete(nodeId);
+                }
+            };
+        };
+        this.subscribeHover = (cb) => {
+            this.hoverListeners.add(cb);
+            return () => {
+                this.hoverListeners.delete(cb);
+            };
+        };
+        this.subscribePortPositions = (cb) => {
+            this.portPositionListeners.add(cb);
+            return () => {
+                this.portPositionListeners.delete(cb);
+            };
+        };
+        this.subscribeMeasuredSizes = (cb) => {
+            this.measuredSizeListeners.add(cb);
+            return () => {
+                this.measuredSizeListeners.delete(cb);
+            };
+        };
+        // ── Spawn-palette request channel ──
+        //
+        // Notification-only channel used by `<NodeGraph.SpawnPalette>` to
+        // listen for "user wants to spawn a node here" events without forcing
+        // the consumer to wire context-menu state through their own React
+        // tree. The main `NodeGraph` component pumps this channel from its
+        // `handleContextMenu` when the right-click target is `empty` or
+        // `group` (i.e. a place where it makes sense to drop a new node).
+        this.subscribeSpawnRequest = (cb) => {
+            this.spawnRequestListeners.add(cb);
+            return () => {
+                this.spawnRequestListeners.delete(cb);
+            };
+        };
+    }
+    requestSpawn(info) {
+        this.spawnRequestListeners.forEach(cb => {
+            cb(info);
+        });
+    }
+    // ── Mutators ──
+    setData(next) {
+        if (next.nodes === this.data.nodes &&
+            next.edges === this.data.edges &&
+            next.groups === this.data.groups &&
+            next.defaultNodeSize.width === this.data.defaultNodeSize.width &&
+            next.defaultNodeSize.height === this.data.defaultNodeSize.height) {
+            return;
+        }
+        const edgesChanged = next.edges !== this.data.edges;
+        const prevNodeIds = new Set(this.data.nodes.map(n => n.id));
+        // Rebuild the id → node lookup in the same pass that collects the
+        // next-frame id set, so GC and the index stay in sync without a
+        // second iteration.
+        this.nodeIndex.clear();
+        const nextNodeIds = new Set();
+        for (const n of next.nodes) {
+            nextNodeIds.add(n.id);
+            this.nodeIndex.set(n.id, n);
+        }
+        // Garbage-collect port positions + measured sizes for nodes that have
+        // been removed from the data. Slot unmount effects normally clear their
+        // own entries, but if the node disappears in a single render tick (drop
+        // from controlled state) the unmount and the data swap can race.
+        let didMutatePortPositions = false;
+        let didMutateMeasuredSizes = false;
+        for (const id of prevNodeIds) {
+            if (nextNodeIds.has(id))
+                continue;
+            if (this.portPositions.delete(id))
+                didMutatePortPositions = true;
+            if (this.measuredSizes.delete(id))
+                didMutateMeasuredSizes = true;
+        }
+        this.data = next;
+        this.dataListeners.forEach(cb => {
+            cb();
+        });
+        // Recompute the connected-ports index when edges changed, and notify
+        // its dedicated channel only if the membership actually differs — an
+        // edges array that was replaced but carries the same endpoints (e.g.
+        // a label edit) leaves port "connected" state untouched.
+        if (edgesChanged) {
+            const nextConnected = computeConnectedPorts(next.edges);
+            if (!connectedSetsEqual(nextConnected, this.connectedPorts)) {
+                this.connectedPorts = nextConnected;
+                this.connectedPortsListeners.forEach(cb => {
+                    cb();
+                });
+            }
+        }
+        if (didMutatePortPositions) {
+            this.portPositionsVersion++;
+            this.portPositionListeners.forEach(cb => {
+                cb();
+            });
+        }
+        if (didMutateMeasuredSizes) {
+            this.measuredSizesVersion++;
+            this.measuredSizeListeners.forEach(cb => {
+                cb();
+            });
+        }
+    }
+    setSelection(next) {
+        if (selectionEqual(next, this.selection))
+            return;
+        this.selection = next;
+        this.selectionListeners.forEach(cb => {
+            cb();
+        });
+    }
+    setInteraction(next) {
+        if (interactionEqual(next, this.interaction))
+            return;
+        const prev = this.interaction;
+        this.interaction = next;
+        // Global listeners: canvas layers, the main NodeGraph component (for
+        // layer invalidation), and any consumer hook that wants every change.
+        this.interactionListeners.forEach(cb => {
+            cb();
+        });
+        // Per-node listeners: notify ids that are in the next or the prev drag
+        // set. A node that *leaves* the drag set needs to clear its local
+        // delta, so previously-affected ids must fire too even when they're no
+        // longer in `next`.
+        const prevIds = getDragAffectedNodeIds(prev);
+        const nextIds = getDragAffectedNodeIds(next);
+        if (prevIds.size === 0 && nextIds.size === 0)
+            return;
+        for (const id of nextIds) {
+            this.nodeInteractionListeners.get(id)?.forEach(cb => {
+                cb();
+            });
+        }
+        for (const id of prevIds) {
+            // Dedupe — already notified above when the node is in both sets.
+            if (nextIds.has(id))
+                continue;
+            this.nodeInteractionListeners.get(id)?.forEach(cb => {
+                cb();
+            });
+        }
+    }
+    setHover(next) {
+        if (hoverEqual(next, this.hover))
+            return;
+        this.hover = next;
+        this.hoverListeners.forEach(cb => {
+            cb();
+        });
+    }
+    /**
+     * Register a port's measured position. Called by `<NodeGraph.Port>` from
+     * a `useLayoutEffect` + `ResizeObserver`. No-ops when the incoming
+     * position is identical to the cached one — protects edge layer from
+     * redraw storms when nodes resize without porting any pin movement.
+     */
+    setPortPosition(nodeId, portId, next) {
+        let perNode = this.portPositions.get(nodeId);
+        if (!perNode) {
+            perNode = new Map();
+            this.portPositions.set(nodeId, perNode);
+        }
+        const prev = perNode.get(portId);
+        if (prev?.x === next.x &&
+            prev.y === next.y &&
+            prev.side === next.side &&
+            prev.dataType === next.dataType) {
+            return;
+        }
+        perNode.set(portId, next);
+        this.portPositionsVersion++;
+        this.portPositionListeners.forEach(cb => {
+            cb();
+        });
+    }
+    /** Remove a port registration. Called by `<NodeGraph.Port>` cleanup. */
+    removePortPosition(nodeId, portId) {
+        const perNode = this.portPositions.get(nodeId);
+        if (!perNode)
+            return;
+        if (!perNode.delete(portId))
+            return;
+        if (perNode.size === 0)
+            this.portPositions.delete(nodeId);
+        this.portPositionsVersion++;
+        this.portPositionListeners.forEach(cb => {
+            cb();
+        });
+    }
+    /**
+     * Register / refresh the measured DOM size of a node wrapper. No-ops on
+     * identical width+height.
+     */
+    setMeasuredSize(nodeId, next) {
+        const prev = this.measuredSizes.get(nodeId);
+        if (prev?.width === next.width && prev.height === next.height) {
+            return;
+        }
+        this.measuredSizes.set(nodeId, next);
+        this.measuredSizesVersion++;
+        this.measuredSizeListeners.forEach(cb => {
+            cb();
+        });
+    }
+    /** Clear the measured size of a node (called on unmount). */
+    clearMeasuredSize(nodeId) {
+        if (!this.measuredSizes.delete(nodeId))
+            return;
+        this.measuredSizesVersion++;
+        this.measuredSizeListeners.forEach(cb => {
+            cb();
+        });
+    }
+    // ── Convenience selection helpers ──
+    /** True when a node id is currently selected. */
+    isNodeSelected(id) {
+        return this.selection.nodes.includes(id);
+    }
+    /** True when an edge id is currently selected. */
+    isEdgeSelected(id) {
+        return this.selection.edges.includes(id);
+    }
+    /** True when a group id is currently selected. */
+    isGroupSelected(id) {
+        return this.selection.groups.includes(id);
+    }
+}
+// ─── Connected-ports index ───
+/**
+ * Key for the connected-ports set. Uses a NUL separator so node / port ids
+ * containing dots or dashes can't collide (`"a.b" + "c"` vs `"a" + "b.c"`).
+ */
+function portKey(node, port) {
+    return `${node}\u0000${port}`;
+}
+/** Build the set of `"${node}\0${port}"` keys referenced by any edge. */
+function computeConnectedPorts(edges) {
+    const set = new Set();
+    for (const edge of edges) {
+        set.add(portKey(edge.source.node, edge.source.port));
+        set.add(portKey(edge.target.node, edge.target.port));
+    }
+    return set;
+}
+function connectedSetsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.size !== b.size)
+        return false;
+    for (const key of a) {
+        if (!b.has(key))
+            return false;
+    }
+    return true;
+}
+// ─── Equality helpers (shallow, identity-aware) ───
+function arrEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function setEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+const EMPTY_NODE_ID_SET = new Set();
+/**
+ * Node ids whose drag delta could be affected by the given interaction
+ * state — used by `setInteraction` to fan out per-node notifications.
+ * Idle / connect / marquee / resize-group don't move nodes, so they
+ * return the empty set (no per-node subscriber needs waking).
+ */
+function getDragAffectedNodeIds(state) {
+    if (state.kind === 'drag-nodes')
+        return state.nodeIds;
+    if (state.kind === 'drag-groups')
+        return state.containedNodeIds;
+    return EMPTY_NODE_ID_SET;
+}
+function selectionEqual(a, b) {
+    return (arrEqual(a.nodes, b.nodes) &&
+        arrEqual(a.edges, b.edges) &&
+        arrEqual(a.groups, b.groups));
+}
+function pointEqual(a, b) {
+    return a.x === b.x && a.y === b.y;
+}
+function portRefEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.node === b.node && a.port === b.port;
+}
+function interactionEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'idle':
+            return true;
+        case 'drag-nodes': {
+            const bx = b;
+            return (setEqual(a.nodeIds, bx.nodeIds) &&
+                pointEqual(a.startWorld, bx.startWorld) &&
+                pointEqual(a.delta, bx.delta));
+        }
+        case 'drag-groups': {
+            const bx = b;
+            return (setEqual(a.groupIds, bx.groupIds) &&
+                setEqual(a.containedNodeIds, bx.containedNodeIds) &&
+                pointEqual(a.startWorld, bx.startWorld) &&
+                pointEqual(a.delta, bx.delta) &&
+                a.blocked === bx.blocked);
+        }
+        case 'resize-group': {
+            const bx = b;
+            return (a.groupId === bx.groupId &&
+                a.handle === bx.handle &&
+                a.startBounds.x === bx.startBounds.x &&
+                a.startBounds.y === bx.startBounds.y &&
+                a.startBounds.width === bx.startBounds.width &&
+                a.startBounds.height === bx.startBounds.height &&
+                pointEqual(a.delta, bx.delta) &&
+                a.blocked === bx.blocked);
+        }
+        case 'connect': {
+            const bx = b;
+            return (portRefEqual(a.source, bx.source) &&
+                pointEqual(a.currentWorld, bx.currentWorld) &&
+                portRefEqual(a.candidate, bx.candidate) &&
+                a.invalid === bx.invalid &&
+                a.reconnectEdgeId === bx.reconnectEdgeId &&
+                a.reconnectEnd === bx.reconnectEnd);
+        }
+        case 'marquee': {
+            const bx = b;
+            return (pointEqual(a.startWorld, bx.startWorld) &&
+                pointEqual(a.currentWorld, bx.currentWorld) &&
+                a.additive === bx.additive);
+        }
+        default:
+            return false;
+    }
+}
+function hoverEqual(a, b) {
+    return (a.hoveredNodeId === b.hoveredNodeId &&
+        a.hoveredEdgeId === b.hoveredEdgeId &&
+        portRefEqual(a.hoveredPort, b.hoveredPort));
+}
+
+export { NodeGraphStore };
+//# sourceMappingURL=NodeGraphStore.js.map