@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/graph-D9HS4Ahd.js

@@ -0,0 +1,247 @@
+import { aA as N, aB as j, aC as f, aD as b, aE as E } from "./cowboy-components-BcyXo9oX.js";
+import { a as v, c as P, k as _, f as g, d, i as l, v as p, r as D } from "./_baseUniq-C5Y4WFmx.js";
+var w = N(function(o) {
+  return v(P(o, 1, j, !0));
+}), F = "\0", a = "\0", O = "
";
+class L {
+  constructor(e = {}) {
+    this._isDirected = Object.prototype.hasOwnProperty.call(e, "directed") ? e.directed : !0, this._isMultigraph = Object.prototype.hasOwnProperty.call(e, "multigraph") ? e.multigraph : !1, this._isCompound = Object.prototype.hasOwnProperty.call(e, "compound") ? e.compound : !1, this._label = void 0, this._defaultNodeLabelFn = f(void 0), this._defaultEdgeLabelFn = f(void 0), this._nodes = {}, this._isCompound && (this._parent = {}, this._children = {}, this._children[a] = {}), this._in = {}, this._preds = {}, this._out = {}, this._sucs = {}, this._edgeObjs = {}, this._edgeLabels = {};
+  }
+  /* === Graph functions ========= */
+  isDirected() {
+    return this._isDirected;
+  }
+  isMultigraph() {
+    return this._isMultigraph;
+  }
+  isCompound() {
+    return this._isCompound;
+  }
+  setGraph(e) {
+    return this._label = e, this;
+  }
+  graph() {
+    return this._label;
+  }
+  /* === Node functions ========== */
+  setDefaultNodeLabel(e) {
+    return b(e) || (e = f(e)), this._defaultNodeLabelFn = e, this;
+  }
+  nodeCount() {
+    return this._nodeCount;
+  }
+  nodes() {
+    return _(this._nodes);
+  }
+  sources() {
+    var e = this;
+    return g(this.nodes(), function(t) {
+      return E(e._in[t]);
+    });
+  }
+  sinks() {
+    var e = this;
+    return g(this.nodes(), function(t) {
+      return E(e._out[t]);
+    });
+  }
+  setNodes(e, t) {
+    var s = arguments, i = this;
+    return d(e, function(r) {
+      s.length > 1 ? i.setNode(r, t) : i.setNode(r);
+    }), this;
+  }
+  setNode(e, t) {
+    return Object.prototype.hasOwnProperty.call(this._nodes, e) ? (arguments.length > 1 && (this._nodes[e] = t), this) : (this._nodes[e] = arguments.length > 1 ? t : this._defaultNodeLabelFn(e), this._isCompound && (this._parent[e] = a, this._children[e] = {}, this._children[a][e] = !0), this._in[e] = {}, this._preds[e] = {}, this._out[e] = {}, this._sucs[e] = {}, ++this._nodeCount, this);
+  }
+  node(e) {
+    return this._nodes[e];
+  }
+  hasNode(e) {
+    return Object.prototype.hasOwnProperty.call(this._nodes, e);
+  }
+  removeNode(e) {
+    if (Object.prototype.hasOwnProperty.call(this._nodes, e)) {
+      var t = (s) => this.removeEdge(this._edgeObjs[s]);
+      delete this._nodes[e], this._isCompound && (this._removeFromParentsChildList(e), delete this._parent[e], d(this.children(e), (s) => {
+        this.setParent(s);
+      }), delete this._children[e]), d(_(this._in[e]), t), delete this._in[e], delete this._preds[e], d(_(this._out[e]), t), delete this._out[e], delete this._sucs[e], --this._nodeCount;
+    }
+    return this;
+  }
+  setParent(e, t) {
+    if (!this._isCompound)
+      throw new Error("Cannot set parent in a non-compound graph");
+    if (l(t))
+      t = a;
+    else {
+      t += "";
+      for (var s = t; !l(s); s = this.parent(s))
+        if (s === e)
+          throw new Error("Setting " + t + " as parent of " + e + " would create a cycle");
+      this.setNode(t);
+    }
+    return this.setNode(e), this._removeFromParentsChildList(e), this._parent[e] = t, this._children[t][e] = !0, this;
+  }
+  _removeFromParentsChildList(e) {
+    delete this._children[this._parent[e]][e];
+  }
+  parent(e) {
+    if (this._isCompound) {
+      var t = this._parent[e];
+      if (t !== a)
+        return t;
+    }
+  }
+  children(e) {
+    if (l(e) && (e = a), this._isCompound) {
+      var t = this._children[e];
+      if (t)
+        return _(t);
+    } else {
+      if (e === a)
+        return this.nodes();
+      if (this.hasNode(e))
+        return [];
+    }
+  }
+  predecessors(e) {
+    var t = this._preds[e];
+    if (t)
+      return _(t);
+  }
+  successors(e) {
+    var t = this._sucs[e];
+    if (t)
+      return _(t);
+  }
+  neighbors(e) {
+    var t = this.predecessors(e);
+    if (t)
+      return w(t, this.successors(e));
+  }
+  isLeaf(e) {
+    var t;
+    return this.isDirected() ? t = this.successors(e) : t = this.neighbors(e), t.length === 0;
+  }
+  filterNodes(e) {
+    var t = new this.constructor({
+      directed: this._isDirected,
+      multigraph: this._isMultigraph,
+      compound: this._isCompound
+    });
+    t.setGraph(this.graph());
+    var s = this;
+    d(this._nodes, function(n, h) {
+      e(h) && t.setNode(h, n);
+    }), d(this._edgeObjs, function(n) {
+      t.hasNode(n.v) && t.hasNode(n.w) && t.setEdge(n, s.edge(n));
+    });
+    var i = {};
+    function r(n) {
+      var h = s.parent(n);
+      return h === void 0 || t.hasNode(h) ? (i[n] = h, h) : h in i ? i[h] : r(h);
+    }
+    return this._isCompound && d(t.nodes(), function(n) {
+      t.setParent(n, r(n));
+    }), t;
+  }
+  /* === Edge functions ========== */
+  setDefaultEdgeLabel(e) {
+    return b(e) || (e = f(e)), this._defaultEdgeLabelFn = e, this;
+  }
+  edgeCount() {
+    return this._edgeCount;
+  }
+  edges() {
+    return p(this._edgeObjs);
+  }
+  setPath(e, t) {
+    var s = this, i = arguments;
+    return D(e, function(r, n) {
+      return i.length > 1 ? s.setEdge(r, n, t) : s.setEdge(r, n), n;
+    }), this;
+  }
+  /*
+   * setEdge(v, w, [value, [name]])
+   * setEdge({ v, w, [name] }, [value])
+   */
+  setEdge() {
+    var e, t, s, i, r = !1, n = arguments[0];
+    typeof n == "object" && n !== null && "v" in n ? (e = n.v, t = n.w, s = n.name, arguments.length === 2 && (i = arguments[1], r = !0)) : (e = n, t = arguments[1], s = arguments[3], arguments.length > 2 && (i = arguments[2], r = !0)), e = "" + e, t = "" + t, l(s) || (s = "" + s);
+    var h = c(this._isDirected, e, t, s);
+    if (Object.prototype.hasOwnProperty.call(this._edgeLabels, h))
+      return r && (this._edgeLabels[h] = i), this;
+    if (!l(s) && !this._isMultigraph)
+      throw new Error("Cannot set a named edge when isMultigraph = false");
+    this.setNode(e), this.setNode(t), this._edgeLabels[h] = r ? i : this._defaultEdgeLabelFn(e, t, s);
+    var u = M(this._isDirected, e, t, s);
+    return e = u.v, t = u.w, Object.freeze(u), this._edgeObjs[h] = u, C(this._preds[t], e), C(this._sucs[e], t), this._in[t][h] = u, this._out[e][h] = u, this._edgeCount++, this;
+  }
+  edge(e, t, s) {
+    var i = arguments.length === 1 ? m(this._isDirected, arguments[0]) : c(this._isDirected, e, t, s);
+    return this._edgeLabels[i];
+  }
+  hasEdge(e, t, s) {
+    var i = arguments.length === 1 ? m(this._isDirected, arguments[0]) : c(this._isDirected, e, t, s);
+    return Object.prototype.hasOwnProperty.call(this._edgeLabels, i);
+  }
+  removeEdge(e, t, s) {
+    var i = arguments.length === 1 ? m(this._isDirected, arguments[0]) : c(this._isDirected, e, t, s), r = this._edgeObjs[i];
+    return r && (e = r.v, t = r.w, delete this._edgeLabels[i], delete this._edgeObjs[i], y(this._preds[t], e), y(this._sucs[e], t), delete this._in[t][i], delete this._out[e][i], this._edgeCount--), this;
+  }
+  inEdges(e, t) {
+    var s = this._in[e];
+    if (s) {
+      var i = p(s);
+      return t ? g(i, function(r) {
+        return r.v === t;
+      }) : i;
+    }
+  }
+  outEdges(e, t) {
+    var s = this._out[e];
+    if (s) {
+      var i = p(s);
+      return t ? g(i, function(r) {
+        return r.w === t;
+      }) : i;
+    }
+  }
+  nodeEdges(e, t) {
+    var s = this.inEdges(e, t);
+    if (s)
+      return s.concat(this.outEdges(e, t));
+  }
+}
+L.prototype._nodeCount = 0;
+L.prototype._edgeCount = 0;
+function C(o, e) {
+  o[e] ? o[e]++ : o[e] = 1;
+}
+function y(o, e) {
+  --o[e] || delete o[e];
+}
+function c(o, e, t, s) {
+  var i = "" + e, r = "" + t;
+  if (!o && i > r) {
+    var n = i;
+    i = r, r = n;
+  }
+  return i + O + r + O + (l(s) ? F : s);
+}
+function M(o, e, t, s) {
+  var i = "" + e, r = "" + t;
+  if (!o && i > r) {
+    var n = i;
+    i = r, r = n;
+  }
+  var h = { v: i, w: r };
+  return s && (h.name = s), h;
+}
+function m(o, e) {
+  return c(o, e.v, e.w, e.name);
+}
+export {
+  L as G
+};

package/dist/helpers/event-wiring.d.ts

@@ -0,0 +1,72 @@
+import type { EventRegistrationManager } from '../managers/event-registration-manager.js';
+export interface EventWiringControllers {
+    specController: {
+        specChanged(event: Event): void;
+        specClicked(event: Event): void;
+    };
+    problemController: {
+        problemClicked(event: Event): void;
+    };
+    docsController: {
+        handleDrawerRequest(event: Event): void;
+    };
+    diagramatronController: {
+        handleDiagramRequest(event: Event): void;
+    };
+    ruleController: {
+        ruleGroupClicked(event: Event): void;
+        customRulesetEnabled(event: Event): void;
+        rulesetSaved(event: Event): void;
+        ruleClicked(event: Event): void;
+    };
+    nodeClickerController: {
+        modelTreeNodeClicked(event: Event): void;
+        rolodexTreeNodeClicked(event: Event): void;
+        explorerReferenceClicked(event: Event): void;
+        explorerNodeClicked(event: Event): void;
+        documentReferenceClicked(event: Event): void;
+    };
+    rolodexController: {
+        rolodexRootFileSelected(event: Event): void;
+    };
+}
+export interface EventWiringHost {
+    addToastEvent(event: Event): void;
+    creditStreamUpdated(event: Event): void;
+    handleTimelineViolationsLoaded(event: Event): void;
+    exportRuleset(event: Event): void;
+    builtInRulesetSelected(event: Event): void;
+    fetchUrl(event: Event): void;
+    filterTreeModel(event: Event): void;
+    restoreFullTree(event: Event): void;
+    nukeWorkspaceHandler(event: Event): void;
+    platformUnavailable(event: Event): void;
+    openSettings(): void;
+    creditEmpty(event: Event): void;
+    socketDisconnected(event: Event): void;
+    loadRenderedNodeIntoInspector(event: Event): void;
+    reboot(event: Event): void;
+    handleImportRequested(): void;
+    handleNukeRequested(): void;
+    handleUrlOverlayDismissed(): void;
+    handleSidebarTabChanged(event: Event): void;
+    handleSidebarCollapseToggled(event: Event): void;
+    handleToolsCompare(event: Event): void;
+    handleNavigatorTabChanged(event: Event): void;
+    handleNavigatorRolodexDivider(event: Event): void;
+    handleEditorTabChanged(event: Event): void;
+    runDiagnostics(): void;
+    minimapToggled(): void;
+}
+export interface EventWiringComponents {
+    explorer: {
+        equalizer: EventTarget;
+    };
+    nukeWorkspace: EventTarget;
+    authController: EventTarget;
+    timeVortex: {
+        historyPicker: EventTarget;
+    };
+}
+export declare function wireHostEvents(manager: EventRegistrationManager, host: EventTarget & EventWiringHost, controllers: EventWiringControllers): void;
+export declare function wireComponentEvents(manager: EventRegistrationManager, host: EventWiringHost, components: EventWiringComponents): void;

package/dist/helpers/event-wiring.js

@@ -0,0 +1,58 @@
+import { EditorUpdated, EditorClicked, ProblemClicked, OpenDrawer, DiagramRequested, RuleViolationClicked, CustomRulesetEnabled, RulesetSaved, AddToast, CreditStreamUpdated, TimelineViolationsLoaded, ExportRuleset, RuleClicked, BuiltInRulesetChanged, ModelTreeNodeClicked, RolodexTreeNodeClicked, NodeReferenceClicked, ExplorerNodeClicked, DocumentReferenceClicked, RolodexRootFileSelected, ArchiveURLRequested, ExplorerEqualizerChanged, ExplorerEqualizerFiltered, ExplorerPovModeExit, NukeWorkspaceEvent, StartSessionFailed, OpenSettings, CreditEmpty, SocketDisconnected, LoadRenderedNodeIntoInspector, Reboot } from '../events/doctor.js';
+import { ImportRequested, NukeRequested } from '../components/the-doctor/doctor-controls-panel.js';
+import { UrlOverlayDismissed } from '../components/the-doctor/doctor-url-overlay.js';
+import { SidebarTabChanged, SidebarCollapseToggled } from '../components/the-doctor/doctor-sidebar-panel.js';
+import { NavigatorTabChanged, NavigatorRolodexDividerChanged } from '../components/the-doctor/doctor-navigator-panel.js';
+import { EditorTabChanged, DiagnoseRequested, MinimapToggled, SettingsRequested } from '../components/the-doctor/doctor-editor-panel.js';
+export function wireHostEvents(manager, host, controllers) {
+    manager.addMultiple(host, [
+        { event: EditorUpdated, handler: controllers.specController.specChanged.bind(controllers.specController) },
+        { event: EditorClicked, handler: controllers.specController.specClicked.bind(controllers.specController) },
+        { event: ProblemClicked, handler: controllers.problemController.problemClicked.bind(controllers.problemController) },
+        { event: OpenDrawer, handler: controllers.docsController.handleDrawerRequest.bind(controllers.docsController) },
+        { event: DiagramRequested, handler: controllers.diagramatronController.handleDiagramRequest.bind(controllers.diagramatronController) },
+        { event: RuleViolationClicked, handler: controllers.ruleController.ruleGroupClicked.bind(controllers.ruleController) },
+        { event: CustomRulesetEnabled, handler: controllers.ruleController.customRulesetEnabled.bind(controllers.ruleController) },
+        { event: RulesetSaved, handler: controllers.ruleController.rulesetSaved.bind(controllers.ruleController) },
+        { event: AddToast, handler: host.addToastEvent.bind(host) },
+        { event: CreditStreamUpdated, handler: host.creditStreamUpdated.bind(host) },
+        { event: TimelineViolationsLoaded, handler: host.handleTimelineViolationsLoaded.bind(host) },
+        { event: ExportRuleset, handler: host.exportRuleset.bind(host) },
+        { event: RuleClicked, handler: controllers.ruleController.ruleClicked.bind(controllers.ruleController) },
+        { event: BuiltInRulesetChanged, handler: host.builtInRulesetSelected.bind(host) },
+        { event: ModelTreeNodeClicked, handler: controllers.nodeClickerController.modelTreeNodeClicked.bind(controllers.nodeClickerController) },
+        { event: RolodexTreeNodeClicked, handler: controllers.nodeClickerController.rolodexTreeNodeClicked.bind(controllers.nodeClickerController) },
+        { event: NodeReferenceClicked, handler: controllers.nodeClickerController.explorerReferenceClicked.bind(controllers.nodeClickerController) },
+        { event: ExplorerNodeClicked, handler: controllers.nodeClickerController.explorerNodeClicked.bind(controllers.nodeClickerController) },
+        { event: DocumentReferenceClicked, handler: controllers.nodeClickerController.documentReferenceClicked.bind(controllers.nodeClickerController) },
+        { event: RolodexRootFileSelected, handler: controllers.rolodexController.rolodexRootFileSelected.bind(controllers.rolodexController) },
+        { event: ArchiveURLRequested, handler: host.fetchUrl.bind(host) },
+        { event: SocketDisconnected, handler: host.socketDisconnected.bind(host) },
+        { event: LoadRenderedNodeIntoInspector, handler: host.loadRenderedNodeIntoInspector.bind(host) },
+        { event: Reboot, handler: host.reboot.bind(host) },
+        { event: ImportRequested, handler: host.handleImportRequested.bind(host) },
+        { event: NukeRequested, handler: host.handleNukeRequested.bind(host) },
+        { event: UrlOverlayDismissed, handler: host.handleUrlOverlayDismissed.bind(host) },
+        { event: SidebarTabChanged, handler: host.handleSidebarTabChanged.bind(host) },
+        { event: SidebarCollapseToggled, handler: host.handleSidebarCollapseToggled.bind(host) },
+        { event: 'doctor-tools-compare', handler: host.handleToolsCompare.bind(host) },
+        { event: NavigatorTabChanged, handler: host.handleNavigatorTabChanged.bind(host) },
+        { event: NavigatorRolodexDividerChanged, handler: host.handleNavigatorRolodexDivider.bind(host) },
+        { event: EditorTabChanged, handler: host.handleEditorTabChanged.bind(host) },
+        { event: DiagnoseRequested, handler: host.runDiagnostics.bind(host) },
+        { event: MinimapToggled, handler: host.minimapToggled.bind(host) },
+        { event: SettingsRequested, handler: host.openSettings.bind(host) }
+    ]);
+}
+export function wireComponentEvents(manager, host, components) {
+    manager.addMultiple(components.explorer.equalizer, [
+        { event: ExplorerEqualizerChanged, handler: host.filterTreeModel.bind(host) },
+        { event: ExplorerEqualizerFiltered, handler: host.filterTreeModel.bind(host) },
+        { event: ExplorerPovModeExit, handler: host.restoreFullTree.bind(host) }
+    ]);
+    manager.add(components.nukeWorkspace, NukeWorkspaceEvent, host.nukeWorkspaceHandler.bind(host));
+    manager.add(components.authController, NukeWorkspaceEvent, host.nukeWorkspaceHandler.bind(host));
+    manager.add(components.authController, StartSessionFailed, host.platformUnavailable.bind(host));
+    manager.add(components.authController, CreditEmpty, host.creditEmpty.bind(host));
+    manager.add(components.timeVortex.historyPicker, OpenSettings, host.openSettings.bind(host));
+}

package/dist/helpers/file-size-formatter.d.ts

@@ -0,0 +1,3 @@
+export declare class FileSizeFormatter {
+    static formatBytes(bytes: number): string;
+}

package/dist/helpers/file-size-formatter.js

@@ -0,0 +1,15 @@
+export class FileSizeFormatter {
+    static formatBytes(bytes) {
+        if (bytes < 1000) {
+            return `${bytes}b`;
+        }
+        else if (bytes < 1000000) {
+            const kb = bytes / 1000;
+            return `${kb.toFixed(2)}KB`;
+        }
+        else {
+            const mb = bytes / 1000000;
+            return `${mb.toFixed(2)}MB`;
+        }
+    }
+}

package/dist/helpers/filename-colorizer.d.ts

@@ -0,0 +1,5 @@
+import { TemplateResult } from "lit";
+export declare class FilenameColorizer {
+    static renderOpenAPIFile(filePath: string, content: TemplateResult): TemplateResult;
+    private static splitFilePath;
+}

package/dist/helpers/filename-colorizer.js

@@ -0,0 +1,30 @@
+import { html } from "lit";
+export class FilenameColorizer {
+    static renderOpenAPIFile(filePath, content) {
+        const { pathPart, name, extension } = this.splitFilePath(filePath);
+        return html `
+            <span style="margin-left: 5px;">
+                <sl-tooltip class="filename-info" style="--max-width: 400px; font-size: 2rem">
+                    <div slot="content">
+                        ${content}
+                    </div>
+                    ${pathPart}<span style="color: var(--secondary-color); font-family: var(--font-stack-bold);">${name}</span><span style="color: var(--secondary-color);">${extension}</span>
+                </sl-tooltip>
+            </span>
+        `;
+    }
+    static splitFilePath(filePath) {
+        const lastSlashIndex = filePath.lastIndexOf('/');
+        const filename = lastSlashIndex === -1 ? filePath : filePath.substring(lastSlashIndex + 1);
+        const pathPart = lastSlashIndex === -1 ? '' : filePath.substring(0, lastSlashIndex + 1);
+        const lastDotIndex = filename.lastIndexOf('.');
+        if (lastDotIndex === -1) {
+            return { pathPart, name: filename, extension: '' };
+        }
+        return {
+            pathPart,
+            name: filename.substring(0, lastDotIndex),
+            extension: filename.substring(lastDotIndex)
+        };
+    }
+}

package/dist/helpers/navigation-helper.d.ts

@@ -0,0 +1,54 @@
+import { Node } from "../model/graph.js";
+export interface ExplorerNodeLike {
+    id: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    filtered?: boolean;
+    parentId?: string;
+}
+export interface NavigationHost {
+    svgItem: SVGSVGElement | null;
+    graph: {
+        children?: ExplorerNodeLike[];
+    } | null;
+    nodeMap: Map<string, Node>;
+    activeNode: Node | null;
+    previousActiveNodeId: string | null;
+    povMode: boolean;
+    expandedNodes: Set<string>;
+    visibleChildrenCount: Map<string, number>;
+    childrenMapCache: Map<string, Node[]> | null;
+    CHILD_BATCH_SIZE: number;
+}
+export interface NavigationCallbacks {
+    animateViewBox: (targetX: number, targetY: number, duration: number) => void;
+    snapViewBox: (targetX: number, targetY: number) => void;
+    buildGraph: () => Promise<void>;
+    setActiveNode: (node: Node) => void;
+    setPreviousActiveNodeId: (id: string | null) => void;
+}
+export declare class NavigationHelper {
+    private host;
+    private callbacks;
+    pathRevealNodes: Set<string>;
+    pathRevealTarget: string | null;
+    constructor(host: NavigationHost, callbacks: NavigationCallbacks);
+    moveToNode(node: Node, _first?: boolean, snap?: boolean): void;
+    private moveToRoot;
+    centerOnRoot(): void;
+    snapToRoot(): void;
+    getNodeScreenOffset(nodeId: string): {
+        x: number;
+        y: number;
+    } | null;
+    restoreNodeScreenPosition(nodeId: string, targetOffset: {
+        x: number;
+        y: number;
+    }): void;
+    isNodeCurrentlyVisible(nodeId: string): boolean;
+    revealPathToNode(nodeId: string): void;
+    clearPathReveal(): void;
+    hasPathReveal(): boolean;
+}

package/dist/helpers/navigation-helper.js

@@ -0,0 +1,159 @@
+export class NavigationHelper {
+    constructor(host, callbacks) {
+        this.pathRevealNodes = new Set();
+        this.pathRevealTarget = null;
+        this.host = host;
+        this.callbacks = callbacks;
+    }
+    moveToNode(node, _first = false, snap = false) {
+        const { svgItem, graph } = this.host;
+        if (!svgItem || !graph?.children)
+            return;
+        const viewBox = svgItem.viewBox.baseVal;
+        const found = graph.children.find((n) => n.id === node.id);
+        if (found && found.x !== undefined && found.y !== undefined && !found.filtered) {
+            const width = found.width || 0;
+            const height = found.height || 0;
+            const targetX = found.x - (viewBox.width / 2) + (width / 2);
+            const targetY = found.y - (viewBox.height / 2) + (height / 2);
+            if (snap) {
+                this.callbacks.snapViewBox(targetX, targetY);
+            }
+            else {
+                this.callbacks.animateViewBox(targetX, targetY, 200);
+            }
+        }
+    }
+    moveToRoot(snap) {
+        const { svgItem, graph } = this.host;
+        if (!svgItem || !graph?.children)
+            return;
+        const rootNode = graph.children.find((n) => n.id === 'root');
+        if (!rootNode || rootNode.x === undefined || rootNode.y === undefined)
+            return;
+        const viewBox = svgItem.viewBox.baseVal;
+        const targetX = rootNode.x - (viewBox.width / 2) + ((rootNode.width || 0) / 2);
+        const targetY = rootNode.y - (viewBox.height / 2) + ((rootNode.height || 0) / 2);
+        if (snap) {
+            this.callbacks.snapViewBox(targetX, targetY);
+        }
+        else {
+            this.callbacks.animateViewBox(targetX, targetY, 200);
+        }
+        const nodeFromMap = this.host.nodeMap.get('root');
+        if (nodeFromMap) {
+            this.callbacks.setActiveNode(nodeFromMap);
+        }
+    }
+    centerOnRoot() {
+        this.moveToRoot(false);
+    }
+    snapToRoot() {
+        this.moveToRoot(true);
+    }
+    getNodeScreenOffset(nodeId) {
+        const { svgItem, graph } = this.host;
+        const viewBox = svgItem?.viewBox?.baseVal;
+        if (!viewBox || !graph?.children)
+            return null;
+        const node = graph.children.find((n) => n.id === nodeId);
+        if (!node || node.x === undefined || node.y === undefined)
+            return null;
+        const nodeWidth = node.width || 0;
+        const nodeHeight = node.height || 0;
+        const nodeCenterX = node.x + nodeWidth / 2;
+        const nodeCenterY = node.y + nodeHeight / 2;
+        const viewportCenterX = viewBox.x + viewBox.width / 2;
+        const viewportCenterY = viewBox.y + viewBox.height / 2;
+        return {
+            x: nodeCenterX - viewportCenterX,
+            y: nodeCenterY - viewportCenterY
+        };
+    }
+    restoreNodeScreenPosition(nodeId, targetOffset) {
+        const { svgItem, graph } = this.host;
+        const viewBox = svgItem?.viewBox?.baseVal;
+        if (!viewBox || !graph?.children)
+            return;
+        const node = graph.children.find((n) => n.id === nodeId);
+        if (!node || node.x === undefined || node.y === undefined)
+            return;
+        const nodeWidth = node.width || 0;
+        const nodeHeight = node.height || 0;
+        const nodeCenterX = node.x + nodeWidth / 2;
+        const nodeCenterY = node.y + nodeHeight / 2;
+        const newViewportCenterX = nodeCenterX - targetOffset.x;
+        const newViewportCenterY = nodeCenterY - targetOffset.y;
+        const newViewBoxX = newViewportCenterX - viewBox.width / 2;
+        const newViewBoxY = newViewportCenterY - viewBox.height / 2;
+        this.callbacks.snapViewBox(newViewBoxX, newViewBoxY);
+    }
+    isNodeCurrentlyVisible(nodeId) {
+        const { nodeMap, expandedNodes, childrenMapCache, visibleChildrenCount, CHILD_BATCH_SIZE } = this.host;
+        if (nodeId === 'root')
+            return true;
+        const node = nodeMap.get(nodeId);
+        if (!node)
+            return false;
+        const parentId = node.parentId || 'root';
+        if (!expandedNodes.has(parentId))
+            return false;
+        if (!childrenMapCache)
+            return true;
+        const children = childrenMapCache.get(parentId);
+        if (!children)
+            return true;
+        const limit = visibleChildrenCount.get(parentId) || CHILD_BATCH_SIZE;
+        const nodeIndex = children.findIndex(n => n.id === nodeId);
+        return nodeIndex >= 0 && nodeIndex < limit;
+    }
+    revealPathToNode(nodeId) {
+        const { nodeMap, povMode, activeNode } = this.host;
+        if (povMode)
+            return;
+        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(activeNode?.id || null);
+                this.callbacks.setActiveNode(targetNode);
+                this.moveToNode(targetNode);
+            }
+            return;
+        }
+        path.reverse();
+        for (const pathNodeId of path) {
+            this.pathRevealNodes.add(pathNodeId);
+        }
+        this.pathRevealTarget = nodeId;
+        if (targetNode) {
+            this.callbacks.setPreviousActiveNodeId(activeNode?.id || null);
+            this.callbacks.setActiveNode(targetNode);
+        }
+        this.callbacks.buildGraph().then(() => {
+            if (targetNode) {
+                this.moveToNode(targetNode);
+            }
+        });
+    }
+    clearPathReveal() {
+        if (this.pathRevealNodes.size > 0) {
+            this.pathRevealNodes.clear();
+            this.pathRevealTarget = null;
+        }
+    }
+    hasPathReveal() {
+        return this.pathRevealNodes.size > 0;
+    }
+}

package/dist/helpers/typed-events.d.ts

@@ -0,0 +1 @@
+export declare function typedEventHandler<T = unknown>(handler: (event: CustomEvent<T>) => void): EventListener;

package/dist/helpers/typed-events.js

@@ -0,0 +1,3 @@
+export function typedEventHandler(handler) {
+    return handler;
+}

package/dist/info-NVLQJR56-Bpi6I8up.js

@@ -0,0 +1,5 @@
+import { I as r, c as a } from "./mermaid-parser.core-BPror82d.js";
+export {
+  r as InfoModule,
+  a as createInfoServices
+};