@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/linear-Bo0rJUSQ.js

@@ -0,0 +1,259 @@
+import { aM as j, aN as p, aO as w, aP as q, aQ as k } from "./cowboy-components-BcyXo9oX.js";
+import { i as D } from "./init-DjUOC4st.js";
+import { e as M, f as F, a as P, b as z } from "./defaultLocale-D7EN2tov.js";
+function g(n, r) {
+  return n == null || r == null ? NaN : n < r ? -1 : n > r ? 1 : n >= r ? 0 : NaN;
+}
+function B(n, r) {
+  return n == null || r == null ? NaN : r < n ? -1 : r > n ? 1 : r >= n ? 0 : NaN;
+}
+function R(n) {
+  let r, t, e;
+  n.length !== 2 ? (r = g, t = (o, c) => g(n(o), c), e = (o, c) => n(o) - c) : (r = n === g || n === B ? n : I, t = n, e = n);
+  function u(o, c, i = 0, h = o.length) {
+    if (i < h) {
+      if (r(c, c) !== 0) return h;
+      do {
+        const l = i + h >>> 1;
+        t(o[l], c) < 0 ? i = l + 1 : h = l;
+      } while (i < h);
+    }
+    return i;
+  }
+  function f(o, c, i = 0, h = o.length) {
+    if (i < h) {
+      if (r(c, c) !== 0) return h;
+      do {
+        const l = i + h >>> 1;
+        t(o[l], c) <= 0 ? i = l + 1 : h = l;
+      } while (i < h);
+    }
+    return i;
+  }
+  function a(o, c, i = 0, h = o.length) {
+    const l = u(o, c, i, h - 1);
+    return l > i && e(o[l - 1], c) > -e(o[l], c) ? l - 1 : l;
+  }
+  return { left: u, center: a, right: f };
+}
+function I() {
+  return 0;
+}
+function O(n) {
+  return n === null ? NaN : +n;
+}
+const V = R(g), $ = V.right;
+R(O).center;
+const x = Math.sqrt(50), Q = Math.sqrt(10), T = Math.sqrt(2);
+function v(n, r, t) {
+  const e = (r - n) / Math.max(0, t), u = Math.floor(Math.log10(e)), f = e / Math.pow(10, u), a = f >= x ? 10 : f >= Q ? 5 : f >= T ? 2 : 1;
+  let o, c, i;
+  return u < 0 ? (i = Math.pow(10, -u) / a, o = Math.round(n * i), c = Math.round(r * i), o / i < n && ++o, c / i > r && --c, i = -i) : (i = Math.pow(10, u) * a, o = Math.round(n / i), c = Math.round(r / i), o * i < n && ++o, c * i > r && --c), c < o && 0.5 <= t && t < 2 ? v(n, r, t * 2) : [o, c, i];
+}
+function C(n, r, t) {
+  if (r = +r, n = +n, t = +t, !(t > 0)) return [];
+  if (n === r) return [n];
+  const e = r < n, [u, f, a] = e ? v(r, n, t) : v(n, r, t);
+  if (!(f >= u)) return [];
+  const o = f - u + 1, c = new Array(o);
+  if (e)
+    if (a < 0) for (let i = 0; i < o; ++i) c[i] = (f - i) / -a;
+    else for (let i = 0; i < o; ++i) c[i] = (f - i) * a;
+  else if (a < 0) for (let i = 0; i < o; ++i) c[i] = (u + i) / -a;
+  else for (let i = 0; i < o; ++i) c[i] = (u + i) * a;
+  return c;
+}
+function y(n, r, t) {
+  return r = +r, n = +n, t = +t, v(n, r, t)[2];
+}
+function E(n, r, t) {
+  r = +r, n = +n, t = +t;
+  const e = r < n, u = e ? y(r, n, t) : y(n, r, t);
+  return (e ? -1 : 1) * (u < 0 ? 1 / -u : u);
+}
+function G(n, r) {
+  r || (r = []);
+  var t = n ? Math.min(r.length, n.length) : 0, e = r.slice(), u;
+  return function(f) {
+    for (u = 0; u < t; ++u) e[u] = n[u] * (1 - f) + r[u] * f;
+    return e;
+  };
+}
+function H(n) {
+  return ArrayBuffer.isView(n) && !(n instanceof DataView);
+}
+function J(n, r) {
+  var t = r ? r.length : 0, e = n ? Math.min(t, n.length) : 0, u = new Array(e), f = new Array(t), a;
+  for (a = 0; a < e; ++a) u[a] = d(n[a], r[a]);
+  for (; a < t; ++a) f[a] = r[a];
+  return function(o) {
+    for (a = 0; a < e; ++a) f[a] = u[a](o);
+    return f;
+  };
+}
+function K(n, r) {
+  var t = /* @__PURE__ */ new Date();
+  return n = +n, r = +r, function(e) {
+    return t.setTime(n * (1 - e) + r * e), t;
+  };
+}
+function L(n, r) {
+  var t = {}, e = {}, u;
+  (n === null || typeof n != "object") && (n = {}), (r === null || typeof r != "object") && (r = {});
+  for (u in r)
+    u in n ? t[u] = d(n[u], r[u]) : e[u] = r[u];
+  return function(f) {
+    for (u in t) e[u] = t[u](f);
+    return e;
+  };
+}
+function d(n, r) {
+  var t = typeof r, e;
+  return r == null || t === "boolean" ? j(r) : (t === "number" ? p : t === "string" ? (e = k(r)) ? (r = e, w) : q : r instanceof k ? w : r instanceof Date ? K : H(r) ? G : Array.isArray(r) ? J : typeof r.valueOf != "function" && typeof r.toString != "function" || isNaN(r) ? L : p)(n, r);
+}
+function U(n, r) {
+  return n = +n, r = +r, function(t) {
+    return Math.round(n * (1 - t) + r * t);
+  };
+}
+function W(n) {
+  return Math.max(0, -M(Math.abs(n)));
+}
+function X(n, r) {
+  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(M(r) / 3))) * 3 - M(Math.abs(n)));
+}
+function Y(n, r) {
+  return n = Math.abs(n), r = Math.abs(r) - n, Math.max(0, M(r) - M(n)) + 1;
+}
+function Z(n) {
+  return function() {
+    return n;
+  };
+}
+function _(n) {
+  return +n;
+}
+var A = [0, 1];
+function m(n) {
+  return n;
+}
+function N(n, r) {
+  return (r -= n = +n) ? function(t) {
+    return (t - n) / r;
+  } : Z(isNaN(r) ? NaN : 0.5);
+}
+function b(n, r) {
+  var t;
+  return n > r && (t = n, n = r, r = t), function(e) {
+    return Math.max(n, Math.min(r, e));
+  };
+}
+function nn(n, r, t) {
+  var e = n[0], u = n[1], f = r[0], a = r[1];
+  return u < e ? (e = N(u, e), f = t(a, f)) : (e = N(e, u), f = t(f, a)), function(o) {
+    return f(e(o));
+  };
+}
+function rn(n, r, t) {
+  var e = Math.min(n.length, r.length) - 1, u = new Array(e), f = new Array(e), a = -1;
+  for (n[e] < n[0] && (n = n.slice().reverse(), r = r.slice().reverse()); ++a < e; )
+    u[a] = N(n[a], n[a + 1]), f[a] = t(r[a], r[a + 1]);
+  return function(o) {
+    var c = $(n, o, 1, e) - 1;
+    return f[c](u[c](o));
+  };
+}
+function en(n, r) {
+  return r.domain(n.domain()).range(n.range()).interpolate(n.interpolate()).clamp(n.clamp()).unknown(n.unknown());
+}
+function tn() {
+  var n = A, r = A, t = d, e, u, f, a = m, o, c, i;
+  function h() {
+    var s = Math.min(n.length, r.length);
+    return a !== m && (a = b(n[0], n[s - 1])), o = s > 2 ? rn : nn, c = i = null, l;
+  }
+  function l(s) {
+    return s == null || isNaN(s = +s) ? f : (c || (c = o(n.map(e), r, t)))(e(a(s)));
+  }
+  return l.invert = function(s) {
+    return a(u((i || (i = o(r, n.map(e), p)))(s)));
+  }, l.domain = function(s) {
+    return arguments.length ? (n = Array.from(s, _), h()) : n.slice();
+  }, l.range = function(s) {
+    return arguments.length ? (r = Array.from(s), h()) : r.slice();
+  }, l.rangeRound = function(s) {
+    return r = Array.from(s), t = U, h();
+  }, l.clamp = function(s) {
+    return arguments.length ? (a = s ? !0 : m, h()) : a !== m;
+  }, l.interpolate = function(s) {
+    return arguments.length ? (t = s, h()) : t;
+  }, l.unknown = function(s) {
+    return arguments.length ? (f = s, l) : f;
+  }, function(s, S) {
+    return e = s, u = S, h();
+  };
+}
+function un() {
+  return tn()(m, m);
+}
+function an(n, r, t, e) {
+  var u = E(n, r, t), f;
+  switch (e = F(e ?? ",f"), e.type) {
+    case "s": {
+      var a = Math.max(Math.abs(n), Math.abs(r));
+      return e.precision == null && !isNaN(f = X(u, a)) && (e.precision = f), P(e, a);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      e.precision == null && !isNaN(f = Y(u, Math.max(Math.abs(n), Math.abs(r)))) && (e.precision = f - (e.type === "e"));
+      break;
+    }
+    case "f":
+    case "%": {
+      e.precision == null && !isNaN(f = W(u)) && (e.precision = f - (e.type === "%") * 2);
+      break;
+    }
+  }
+  return z(e);
+}
+function on(n) {
+  var r = n.domain;
+  return n.ticks = function(t) {
+    var e = r();
+    return C(e[0], e[e.length - 1], t ?? 10);
+  }, n.tickFormat = function(t, e) {
+    var u = r();
+    return an(u[0], u[u.length - 1], t ?? 10, e);
+  }, n.nice = function(t) {
+    t == null && (t = 10);
+    var e = r(), u = 0, f = e.length - 1, a = e[u], o = e[f], c, i, h = 10;
+    for (o < a && (i = a, a = o, o = i, i = u, u = f, f = i); h-- > 0; ) {
+      if (i = y(a, o, t), i === c)
+        return e[u] = a, e[f] = o, r(e);
+      if (i > 0)
+        a = Math.floor(a / i) * i, o = Math.ceil(o / i) * i;
+      else if (i < 0)
+        a = Math.ceil(a * i) / i, o = Math.floor(o * i) / i;
+      else
+        break;
+      c = i;
+    }
+    return n;
+  }, n;
+}
+function fn() {
+  var n = un();
+  return n.copy = function() {
+    return en(n, fn());
+  }, D.apply(n, arguments), on(n);
+}
+export {
+  en as a,
+  R as b,
+  un as c,
+  fn as l,
+  E as t
+};

package/dist/managers/drag-handler.d.ts

@@ -0,0 +1,28 @@
+export interface DragHost {
+    svgItem: SVGSVGElement | null;
+}
+export interface DragState {
+    grabbed: boolean;
+    isDragging: boolean;
+}
+export interface DragCallbacks {
+    onZoomUpdate?: (x: number, y: number, w: number, h: number) => void;
+}
+export declare class DragHandler {
+    private host;
+    private callbacks;
+    private startX;
+    private startY;
+    private dragStartViewBoxX;
+    private dragStartViewBoxY;
+    private pendingFrame;
+    private readonly dragThreshold;
+    grabbed: boolean;
+    isDragging: boolean;
+    constructor(host: DragHost, callbacks?: DragCallbacks);
+    mouseDown(evt: MouseEvent): void;
+    mouseMove(evt: MouseEvent): void;
+    mouseUp(): void;
+    getState(): DragState;
+    getCursor(): string;
+}

package/dist/managers/drag-handler.js

@@ -0,0 +1,64 @@
+export class DragHandler {
+    constructor(host, callbacks = {}) {
+        this.startX = 0;
+        this.startY = 0;
+        this.dragStartViewBoxX = 0;
+        this.dragStartViewBoxY = 0;
+        this.pendingFrame = false;
+        this.dragThreshold = 5;
+        this.grabbed = false;
+        this.isDragging = false;
+        this.host = host;
+        this.callbacks = callbacks;
+    }
+    mouseDown(evt) {
+        const { svgItem } = this.host;
+        if (!svgItem)
+            return;
+        this.grabbed = true;
+        const viewBox = svgItem.viewBox.baseVal;
+        this.startX = evt.clientX;
+        this.startY = evt.clientY;
+        this.dragStartViewBoxX = viewBox.x;
+        this.dragStartViewBoxY = viewBox.y;
+    }
+    mouseMove(evt) {
+        const { svgItem } = this.host;
+        if (!this.grabbed || !svgItem)
+            return;
+        const distanceMoved = Math.sqrt(Math.pow(evt.clientX - this.startX, 2) +
+            Math.pow(evt.clientY - this.startY, 2));
+        if (!this.isDragging && distanceMoved > this.dragThreshold) {
+            this.isDragging = true;
+        }
+        if (this.isDragging && !this.pendingFrame) {
+            this.pendingFrame = true;
+            const clientX = evt.clientX;
+            const clientY = evt.clientY;
+            requestAnimationFrame(() => {
+                this.pendingFrame = false;
+                const viewBox = svgItem.viewBox.baseVal;
+                const dx = (clientX - this.startX) * (viewBox.width / svgItem.clientWidth);
+                const dy = (clientY - this.startY) * (viewBox.height / svgItem.clientHeight);
+                viewBox.x = this.dragStartViewBoxX - dx;
+                viewBox.y = this.dragStartViewBoxY - dy;
+                if (this.callbacks.onZoomUpdate) {
+                    this.callbacks.onZoomUpdate(viewBox.x, viewBox.y, viewBox.width, viewBox.height);
+                }
+            });
+        }
+    }
+    mouseUp() {
+        this.grabbed = false;
+        this.isDragging = false;
+    }
+    getState() {
+        return {
+            grabbed: this.grabbed,
+            isDragging: this.isDragging
+        };
+    }
+    getCursor() {
+        return this.isDragging ? 'grabbing' : 'grab';
+    }
+}

package/dist/managers/event-registration-manager.d.ts

@@ -0,0 +1,17 @@
+export interface TrackedListener {
+    target: EventTarget;
+    event: string;
+    handler: EventListener;
+}
+export declare class EventRegistrationManager {
+    private listeners;
+    add(target: EventTarget, event: string, handler: EventListener): void;
+    addMultiple(target: EventTarget, registrations: Array<{
+        event: string;
+        handler: EventListener;
+    }>): void;
+    remove(target: EventTarget, event: string): void;
+    removeAll(): void;
+    get count(): number;
+    has(target: EventTarget, event: string): boolean;
+}

package/dist/managers/event-registration-manager.js

@@ -0,0 +1,34 @@
+export class EventRegistrationManager {
+    constructor() {
+        this.listeners = [];
+    }
+    add(target, event, handler) {
+        target.addEventListener(event, handler);
+        this.listeners.push({ target, event, handler });
+    }
+    addMultiple(target, registrations) {
+        for (const { event, handler } of registrations) {
+            this.add(target, event, handler);
+        }
+    }
+    remove(target, event) {
+        const index = this.listeners.findIndex((l) => l.target === target && l.event === event);
+        if (index !== -1) {
+            const listener = this.listeners[index];
+            listener.target.removeEventListener(listener.event, listener.handler);
+            this.listeners.splice(index, 1);
+        }
+    }
+    removeAll() {
+        for (const { target, event, handler } of this.listeners) {
+            target.removeEventListener(event, handler);
+        }
+        this.listeners = [];
+    }
+    get count() {
+        return this.listeners.length;
+    }
+    has(target, event) {
+        return this.listeners.some((l) => l.target === target && l.event === event);
+    }
+}

package/dist/managers/expansion-manager.d.ts

@@ -0,0 +1,58 @@
+import { Node } from '../model/graph.js';
+export interface ExpansionCallbacks {
+    getNodeMap: () => Map<string, Node>;
+    getGraphResponseNodes: () => Node[] | undefined;
+    buildGraph: () => Promise<any>;
+    moveToNode: (node: Node) => void;
+    getActiveNode: () => Node | undefined;
+    setActiveNode: (node: Node) => void;
+    setPreviousActiveNodeId: (id: string | null) => void;
+    getNodeScreenOffset: (nodeId: string) => {
+        x: number;
+        y: number;
+    } | null;
+    restoreNodeScreenPosition: (nodeId: string, offset: {
+        x: number;
+        y: number;
+    }) => void;
+    preservePositions: () => void;
+}
+export interface ExpansionState {
+    expandedNodes: Set<string>;
+    visibleChildrenCount: Map<string, number>;
+    pathRevealNodes: Set<string>;
+    pathRevealTarget: string | null;
+}
+export declare class ExpansionManager {
+    private callbacks;
+    private childrenMapCache;
+    readonly expandedNodes: Set<string>;
+    readonly visibleChildrenCount: Map<string, number>;
+    readonly pathRevealNodes: Set<string>;
+    pathRevealTarget: string | null;
+    private pendingExpansionNodeId;
+    private expansionNodeScreenOffset;
+    readonly CHILD_BATCH_SIZE = 10;
+    constructor(callbacks: ExpansionCallbacks);
+    toggleNodeExpansion(nodeId: string): void;
+    loadMoreChildren(parentId: string): void;
+    isNodeExpanded(nodeId: string): boolean;
+    isNodeCurrentlyVisible(nodeId: string): boolean;
+    ensureNodesVisible(nodes: Node[]): void;
+    revealPathToNode(nodeId: string, povMode: boolean): void;
+    clearPathReveal(): void;
+    hasPathReveal(): boolean;
+    invalidateChildrenCache(): void;
+    getChildrenMapCache(): Map<string, Node[]> | null;
+    setChildrenMapCache(cache: Map<string, Node[]> | null): void;
+    buildChildrenMapCache(): void;
+    getState(): ExpansionState;
+    saveState(): {
+        expandedNodes: Set<string>;
+        visibleChildrenCount: Map<string, number>;
+    };
+    restoreState(state: {
+        expandedNodes: Set<string>;
+        visibleChildrenCount: Map<string, number>;
+    }): void;
+}

package/dist/managers/expansion-manager.js

@@ -0,0 +1,189 @@
+export class ExpansionManager {
+    constructor(callbacks) {
+        this.childrenMapCache = null;
+        this.expandedNodes = new Set(['root']);
+        this.visibleChildrenCount = new Map();
+        this.pathRevealNodes = new Set();
+        this.pathRevealTarget = null;
+        this.pendingExpansionNodeId = null;
+        this.expansionNodeScreenOffset = null;
+        this.CHILD_BATCH_SIZE = 10;
+        this.callbacks = callbacks;
+    }
+    toggleNodeExpansion(nodeId) {
+        this.callbacks.preservePositions();
+        this.pendingExpansionNodeId = nodeId;
+        this.expansionNodeScreenOffset = this.callbacks.getNodeScreenOffset(nodeId);
+        if (this.expandedNodes.has(nodeId)) {
+            this.expandedNodes.delete(nodeId);
+        }
+        else {
+            this.expandedNodes.add(nodeId);
+        }
+        this.callbacks.buildGraph().then(() => {
+            if (this.pendingExpansionNodeId && this.expansionNodeScreenOffset) {
+                this.callbacks.restoreNodeScreenPosition(this.pendingExpansionNodeId, this.expansionNodeScreenOffset);
+            }
+            this.pendingExpansionNodeId = null;
+            this.expansionNodeScreenOffset = null;
+        });
+    }
+    loadMoreChildren(parentId) {
+        this.callbacks.preservePositions();
+        this.pendingExpansionNodeId = parentId;
+        this.expansionNodeScreenOffset = this.callbacks.getNodeScreenOffset(parentId);
+        const current = this.visibleChildrenCount.get(parentId) || this.CHILD_BATCH_SIZE;
+        this.visibleChildrenCount.set(parentId, current + this.CHILD_BATCH_SIZE);
+        this.callbacks.buildGraph().then(() => {
+            if (this.pendingExpansionNodeId && this.expansionNodeScreenOffset) {
+                this.callbacks.restoreNodeScreenPosition(this.pendingExpansionNodeId, this.expansionNodeScreenOffset);
+            }
+            this.pendingExpansionNodeId = null;
+            this.expansionNodeScreenOffset = null;
+        });
+    }
+    isNodeExpanded(nodeId) {
+        return this.expandedNodes.has(nodeId);
+    }
+    isNodeCurrentlyVisible(nodeId) {
+        if (nodeId === 'root')
+            return true;
+        const nodeMap = this.callbacks.getNodeMap();
+        const node = nodeMap.get(nodeId);
+        if (!node)
+            return false;
+        const parentId = node.parentId || 'root';
+        if (!this.expandedNodes.has(parentId))
+            return false;
+        if (!this.childrenMapCache)
+            return true;
+        const children = this.childrenMapCache.get(parentId);
+        if (!children)
+            return true;
+        const limit = this.visibleChildrenCount.get(parentId) || this.CHILD_BATCH_SIZE;
+        const nodeIndex = children.findIndex(n => n.id === nodeId);
+        return nodeIndex >= 0 && nodeIndex < limit;
+    }
+    ensureNodesVisible(nodes) {
+        this.buildChildrenMapCache();
+        for (const node of nodes) {
+            const parentId = node.parentId || 'root';
+            this.expandedNodes.add(parentId);
+            const children = this.childrenMapCache.get(parentId);
+            if (!children)
+                continue;
+            const nodeIndex = children.findIndex(n => n.id === node.id);
+            if (nodeIndex < 0) {
+                children.push(node);
+                const newIndex = children.length;
+                const currentLimit = this.visibleChildrenCount.get(parentId) || this.CHILD_BATCH_SIZE;
+                if (newIndex >= currentLimit) {
+                    this.visibleChildrenCount.set(parentId, newIndex + 1);
+                }
+            }
+            else {
+                const currentLimit = this.visibleChildrenCount.get(parentId) || this.CHILD_BATCH_SIZE;
+                if (nodeIndex >= currentLimit) {
+                    this.visibleChildrenCount.set(parentId, nodeIndex + 1);
+                }
+            }
+        }
+    }
+    revealPathToNode(nodeId, povMode) {
+        if (povMode)
+            return;
+        const nodeMap = this.callbacks.getNodeMap();
+        const path = [];
+        let currentId = nodeId;
+        while (currentId && currentId !== 'root') {
+            const node = nodeMap.get(currentId);
+            if (!node)
+                break;
+            if (this.isNodeCurrentlyVisible(currentId) || this.pathRevealNodes.has(currentId)) {
+                break;
+            }
+            path.push(currentId);
+            currentId = node.parentId || 'root';
+        }
+        const targetNode = nodeMap.get(nodeId);
+        if (path.length === 0) {
+            if (targetNode) {
+                this.callbacks.setPreviousActiveNodeId(this.callbacks.getActiveNode()?.id || null);
+                this.callbacks.setActiveNode(targetNode);
+                this.callbacks.moveToNode(targetNode);
+            }
+            return;
+        }
+        path.reverse();
+        for (const pathNodeId of path) {
+            this.pathRevealNodes.add(pathNodeId);
+        }
+        this.pathRevealTarget = nodeId;
+        if (targetNode) {
+            this.callbacks.setPreviousActiveNodeId(this.callbacks.getActiveNode()?.id || null);
+            this.callbacks.setActiveNode(targetNode);
+        }
+        this.callbacks.buildGraph().then(() => {
+            if (targetNode) {
+                this.callbacks.moveToNode(targetNode);
+            }
+        });
+    }
+    clearPathReveal() {
+        if (this.pathRevealNodes.size > 0) {
+            this.pathRevealNodes.clear();
+            this.pathRevealTarget = null;
+        }
+    }
+    hasPathReveal() {
+        return this.pathRevealNodes.size > 0;
+    }
+    invalidateChildrenCache() {
+        this.childrenMapCache = null;
+    }
+    getChildrenMapCache() {
+        return this.childrenMapCache;
+    }
+    setChildrenMapCache(cache) {
+        this.childrenMapCache = cache;
+    }
+    buildChildrenMapCache() {
+        if (this.childrenMapCache)
+            return;
+        this.childrenMapCache = new Map();
+        const nodes = this.callbacks.getGraphResponseNodes() || [];
+        for (const node of nodes) {
+            if (node.id === 'root')
+                continue;
+            const parentId = node.parentId || 'root';
+            if (!this.childrenMapCache.has(parentId)) {
+                this.childrenMapCache.set(parentId, []);
+            }
+            this.childrenMapCache.get(parentId).push(node);
+        }
+    }
+    getState() {
+        return {
+            expandedNodes: this.expandedNodes,
+            visibleChildrenCount: this.visibleChildrenCount,
+            pathRevealNodes: this.pathRevealNodes,
+            pathRevealTarget: this.pathRevealTarget
+        };
+    }
+    saveState() {
+        return {
+            expandedNodes: new Set(this.expandedNodes),
+            visibleChildrenCount: new Map(this.visibleChildrenCount)
+        };
+    }
+    restoreState(state) {
+        this.expandedNodes.clear();
+        for (const id of state.expandedNodes) {
+            this.expandedNodes.add(id);
+        }
+        this.visibleChildrenCount.clear();
+        for (const [key, value] of state.visibleChildrenCount) {
+            this.visibleChildrenCount.set(key, value);
+        }
+    }
+}

package/dist/managers/layout-filter-manager.d.ts

@@ -0,0 +1,31 @@
+import { Node, Edge } from '../model/graph.js';
+import { ElkNode } from 'elkjs';
+export interface FilterResult {
+    nodes: Node[];
+    edges: Edge[];
+    hasMoreChildren: Map<string, number>;
+}
+export interface LayoutFilterCallbacks {
+    getExpandedNodes: () => Set<string>;
+    getVisibleChildrenCount: () => Map<string, number>;
+    getPathRevealNodes: () => Set<string>;
+    getChildBatchSize: () => number;
+}
+export declare class LayoutFilterManager {
+    private callbacks;
+    private childrenMapCache;
+    private positionCache;
+    constructor(callbacks: LayoutFilterCallbacks);
+    filterGraphByExpansion(allNodes: Node[], allEdges: Edge[], povMode: boolean): FilterResult;
+    preservePositions(graph: ElkNode | null): void;
+    applyPositionHints(nodes: Node[]): void;
+    invalidateChildrenCache(): void;
+    getChildrenMapCache(): Map<string, Node[]> | null;
+    setChildrenMapCache(cache: Map<string, Node[]> | null): void;
+    private buildChildrenMapCache;
+    clearPositionCache(): void;
+    getPositionCache(): Map<string, {
+        x: number;
+        y: number;
+    }>;
+}