@floegence/floe-webapp-core 0.82.0 → 0.83.1

package/dist/components/graph/geometry.js

@@ -0,0 +1,35 @@
+function c(t) {
+  return t.map((h, a) => `${a ? "L" : "M"}${h.x},${h.y}`).join(" ");
+}
+function o(t, h, a = 48) {
+  const i = Math.max(
+    0.1,
+    Math.min(
+      1,
+      (h.width - a * 2) / Math.max(1, t.width),
+      (h.height - a * 2) / Math.max(1, t.height)
+    )
+  );
+  return {
+    x: (h.width - t.width * i) / 2 - t.x * i,
+    y: (h.height - t.height * i) / 2 - t.y * i,
+    scale: i
+  };
+}
+function f(t, h) {
+  const a = /* @__PURE__ */ new Set([h]), i = /* @__PURE__ */ new Map();
+  for (const e of t.nodes)
+    e.parentId && i.set(e.parentId, [...i.get(e.parentId) ?? [], e.id]);
+  const n = (e) => {
+    for (const r of i.get(e) ?? [])
+      a.has(r) || (a.add(r), n(r));
+  };
+  return n(h), new Set(
+    t.edges.filter((e) => a.has(e.source) || a.has(e.target)).map((e) => e.id)
+  );
+}
+export {
+  o as fitGraphViewport,
+  f as graphRelatedEdges,
+  c as graphSectionPath
+};

package/dist/components/graph/layout.d.ts

@@ -0,0 +1,5 @@
+import type { ELK } from 'elkjs/lib/elk-api';
+import type { GraphInput, GraphLayout, GraphLayoutOptions } from './types';
+export declare function validateGraphInput(input: GraphInput): void;
+/** Normalizes geometry around the supplied ELK engine; browser layout runs in its worker. */
+export declare function computeGraphLayout(input: GraphInput, options: GraphLayoutOptions, engine: Pick<ELK, 'layout'>): Promise<GraphLayout>;

package/dist/components/graph/layout.js

@@ -0,0 +1,121 @@
+function k(n) {
+  const i = /* @__PURE__ */ new Set(), p = (e) => {
+    if (!e || i.has(e)) throw new Error(`Duplicate or empty graph ID: ${e}`);
+    i.add(e);
+  }, s = new Map(n.nodes.map((e) => [e.id, e]));
+  for (const e of n.nodes) {
+    if (p(e.id), ![e.width, e.height].every((r) => Number.isFinite(r) && r > 0))
+      throw new Error(`Invalid dimensions for graph node: ${e.id}`);
+    for (const r of e.ports ?? []) p(r.id);
+    const a = /* @__PURE__ */ new Set([e.id]);
+    let d = e.parentId;
+    for (; d !== void 0; ) {
+      const r = s.get(d);
+      if (!r || r.kind !== "group")
+        throw new Error(`Invalid parent for graph node: ${e.id}`);
+      if (a.has(d)) throw new Error(`Cyclic graph containment: ${e.id}`);
+      a.add(d), d = r.parentId;
+    }
+  }
+  for (const e of n.edges) {
+    p(e.id);
+    for (const [a, d] of [
+      [e.source, e.sourcePort],
+      [e.target, e.targetPort]
+    ]) {
+      const r = s.get(a);
+      if (!r || d !== void 0 && !r.ports?.some((c) => c.id === d))
+        throw new Error(`Invalid endpoint for graph edge: ${e.id}`);
+    }
+  }
+}
+async function N(n, i, p) {
+  k(n);
+  const s = i.groupPadding ?? { top: 64, right: 28, bottom: 28, left: 28 };
+  if (![...Object.values(s), i.spacing ?? 64].every((t) => Number.isFinite(t) && t >= 0))
+    throw new Error("Graph layout spacing must be finite and nonnegative");
+  const e = /* @__PURE__ */ new Map();
+  for (const t of n.nodes)
+    e.set(t.id, {
+      id: t.id,
+      width: t.width,
+      height: t.height,
+      ...t.kind === "group" ? { children: [] } : {},
+      ports: t.ports?.map((o) => ({
+        id: o.id,
+        width: 1,
+        height: 1,
+        layoutOptions: { "elk.port.side": o.side }
+      })),
+      layoutOptions: {
+        "elk.portConstraints": "FIXED_ORDER",
+        "elk.padding": `[top=${s.top},left=${s.left},bottom=${s.bottom},right=${s.right}]`
+      }
+    });
+  const a = [];
+  for (const t of n.nodes)
+    (t.parentId ? e.get(t.parentId).children : a).push(e.get(t.id));
+  const d = /* @__PURE__ */ new Set([
+    ...n.nodes.flatMap((t) => [t.id, ...(t.ports ?? []).map((o) => o.id)]),
+    ...n.edges.map((t) => t.id)
+  ]);
+  let r = "$graph";
+  for (; d.has(r); ) r += "$";
+  const c = await p.layout({
+    id: r,
+    children: a,
+    edges: n.edges.map((t) => ({
+      id: t.id,
+      sources: [t.sourcePort ?? t.source],
+      targets: [t.targetPort ?? t.target]
+    })),
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": i.direction ?? "RIGHT",
+      "elk.edgeRouting": "ORTHOGONAL",
+      "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+      "elk.spacing.nodeNode": String(i.spacing ?? 64),
+      "elk.layered.spacing.nodeNodeBetweenLayers": String(i.spacing ?? 64),
+      "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
+      "elk.randomSeed": "1"
+    }
+  }), f = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), I = (t) => {
+    for (const o of t.edges ?? []) {
+      const h = o.container ?? t.id, l = f.get(h) ?? { x: 0, y: 0 };
+      x.set(
+        o.id,
+        (o.sections ?? []).map(
+          (g) => [g.startPoint, ...g.bendPoints ?? [], g.endPoint].map((w) => ({
+            x: w.x + l.x,
+            y: w.y + l.y
+          }))
+        )
+      );
+    }
+    for (const o of t.children ?? []) I(o);
+  }, E = (t, o, h) => {
+    const l = o + (t.x ?? 0), g = h + (t.y ?? 0);
+    f.set(t.id, { x: l, y: g, width: t.width ?? 0, height: t.height ?? 0 });
+    for (const w of t.children ?? []) E(w, l, g);
+  };
+  for (const t of c.children ?? []) E(t, 0, 0);
+  I(c);
+  const y = i.anchor && f.get(i.anchor.nodeId), u = y ? i.anchor.position.x - y.x : 0, m = y ? i.anchor.position.y - y.y : 0;
+  return {
+    nodes: n.nodes.map((t) => {
+      const o = f.get(t.id);
+      return { ...t, ...o, x: o.x + u, y: o.y + m };
+    }),
+    edges: n.edges.map((t) => ({
+      ...t,
+      sections: (x.get(t.id) ?? []).map(
+        (o) => o.map((h) => ({ x: h.x + u, y: h.y + m }))
+      )
+    })),
+    bounds: { x: u, y: m, width: c.width ?? 0, height: c.height ?? 0 }
+  };
+}
+export {
+  N as computeGraphLayout,
+  k as validateGraphInput
+};

package/dist/components/graph/types.d.ts

@@ -0,0 +1,72 @@
+import type { InfiniteCanvasPoint } from '../ui/InfiniteCanvas';
+export interface GraphPoint {
+    x: number;
+    y: number;
+}
+export interface GraphBounds extends GraphPoint {
+    width: number;
+    height: number;
+}
+export type GraphViewport = InfiniteCanvasPoint;
+/** Port IDs, node IDs, and edge IDs share one namespace. */
+export interface GraphPort {
+    id: string;
+    side: 'NORTH' | 'EAST' | 'SOUTH' | 'WEST';
+}
+export interface GraphNode {
+    id: string;
+    label: string;
+    kind?: 'node' | 'group';
+    parentId?: string;
+    width: number;
+    height: number;
+    ports?: readonly GraphPort[];
+}
+export interface GraphEdge {
+    id: string;
+    label: string;
+    source: string;
+    target: string;
+    sourcePort?: string;
+    targetPort?: string;
+}
+export interface GraphInput {
+    nodes: readonly GraphNode[];
+    edges: readonly GraphEdge[];
+}
+export interface GraphLayoutNode extends GraphNode, GraphBounds {
+}
+export interface GraphLayoutEdge extends GraphEdge {
+    /** Separate sections preserve branches and self loops without inventing joins. */
+    sections: readonly (readonly GraphPoint[])[];
+}
+export interface GraphLayout {
+    nodes: readonly GraphLayoutNode[];
+    edges: readonly GraphLayoutEdge[];
+    bounds: GraphBounds;
+}
+export interface GraphLayoutOptions {
+    direction?: 'RIGHT' | 'DOWN' | 'LEFT' | 'UP';
+    spacing?: number;
+    groupPadding?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Keep the object under inspection at its previous world position after layout. */
+    anchor?: {
+        nodeId: string;
+        position: GraphPoint;
+    };
+}
+export type GraphObjectRef = {
+    kind: 'node' | 'edge';
+    id: string;
+};
+/** Client coordinates go directly to SurfaceFloatingLayer; never rescale them. */
+export interface GraphObjectEvent {
+    object: GraphObjectRef | null;
+    position: GraphPoint;
+    owner: Element;
+}

package/dist/components/ui/InfiniteCanvas.d.ts

@@ -14,7 +14,7 @@ export interface InfiniteCanvasContextMenuEvent {
     worldY: number;
 }
 export interface InfiniteCanvasProps {
-    children: JSX.Element;
+    children: JSX.Element | ((viewport: Accessor<InfiniteCanvasPoint>) => JSX.Element);
     overlay?: (viewport: Accessor<InfiniteCanvasPoint>) => JSX.Element;
     viewport: InfiniteCanvasPoint;
     onViewportChange?: (viewport: InfiniteCanvasPoint) => void;

package/dist/components/ui/InfiniteCanvas.js

@@ -1,38 +1,41 @@
-import { spread as B, mergeProps as j, insert as T, effect as q, className as G, setStyleProperty as J, template as K, use as Q } from "solid-js/web";
-import { createSignal as b, untrack as x, createEffect as A, onCleanup as D } from "solid-js";
-import { cn as I } from "../../utils/cn.js";
-import { startHotInteraction as y } from "../../utils/hotInteraction.js";
-import { resolveSurfaceInteractionTargetRole as ee, resolveSurfaceWheelRouting as te, DEFAULT_CANVAS_WHEEL_INTERACTIVE_SELECTOR as ne } from "./localInteractionSurface.js";
-import { startPointerSession as re } from "./pointerSession.js";
-import { clientToCanvasLocal as R, localToCanvasWorld as oe, createViewportFromZoomAnchor as ae } from "./canvasGeometry.js";
-import { SURFACE_PORTAL_LAYER_ATTR as ie } from "./dialogSurfaceScope.js";
-var ce = /* @__PURE__ */ K('<div><div style="transform-origin:0 0">');
-const le = 1, se = 0.45, ue = 2.2, de = 14e-4, fe = '[data-floe-canvas-pan-surface="true"]', Y = 3;
-function me(t, s, c) {
-  return Math.max(s, Math.min(c, t));
+import { spread as j, mergeProps as q, insert as T, effect as G, className as J, setStyleProperty as K, template as Q, use as ee } from "solid-js/web";
+import { createSignal as b, untrack as x, createMemo as te, createEffect as A, onCleanup as D } from "solid-js";
+import { cn as y } from "../../utils/cn.js";
+import { startHotInteraction as I } from "../../utils/hotInteraction.js";
+import { resolveSurfaceInteractionTargetRole as ne, resolveSurfaceWheelRouting as re, DEFAULT_CANVAS_WHEEL_INTERACTIVE_SELECTOR as oe } from "./localInteractionSurface.js";
+import { startPointerSession as ae } from "./pointerSession.js";
+import { clientToCanvasLocal as R, localToCanvasWorld as ie, createViewportFromZoomAnchor as ce } from "./canvasGeometry.js";
+import { SURFACE_PORTAL_LAYER_ATTR as le } from "./dialogSurfaceScope.js";
+var se = /* @__PURE__ */ Q('<div><div style="transform-origin:0 0">');
+const ue = 1, de = 0.45, fe = 2.2, me = 14e-4, we = '[data-floe-canvas-pan-surface="true"]', Y = 3;
+function Se(t, s, i) {
+  return Math.max(s, Math.min(i, t));
 }
 function k(t) {
   return {
     x: Number.isFinite(t.x) ? t.x : 0,
     y: Number.isFinite(t.y) ? t.y : 0,
-    scale: Number.isFinite(t.scale) && t.scale > 0 ? t.scale : le
+    scale: Number.isFinite(t.scale) && t.scale > 0 ? t.scale : ue
   };
 }
-function we(t, s) {
+function ve(t, s) {
   return t.deltaMode === 1 ? t.deltaY * 16 : t.deltaMode === 2 ? t.deltaY * (s?.clientHeight ?? window.innerHeight) : t.deltaY;
 }
-function Le(t) {
+function Te(t) {
   let s = !1;
-  const [c, S] = b(x(() => k(t.viewport))), [w, v] = b(null);
+  const [i, S] = b(x(() => k(t.viewport))), [w, v] = b(null), M = te(() => {
+    const e = t.children;
+    return typeof e == "function" ? e(i) : e;
+  });
   let l, d, f, m = !1, u;
-  const M = () => t.interactiveSelector ?? '[data-floe-canvas-interactive="true"]', X = () => t.panSurfaceSelector ?? fe, F = () => t.wheelInteractiveSelector ?? ne, V = () => t.minScale ?? se, N = () => t.maxScale ?? ue, H = () => t.wheelZoomSpeed ?? de, U = () => {
+  const X = () => t.interactiveSelector ?? '[data-floe-canvas-interactive="true"]', F = () => t.panSurfaceSelector ?? we, V = () => t.wheelInteractiveSelector ?? oe, N = () => t.minScale ?? de, H = () => t.maxScale ?? fe, U = () => t.wheelZoomSpeed ?? me, W = () => {
     const e = w();
     return e ? e.startedFromPanSurface ? e.moved : !0 : !1;
   }, p = () => {
     f !== void 0 && (window.clearTimeout(f), f = void 0);
   }, g = () => {
     m = !1, u !== void 0 && (window.clearTimeout(u), u = void 0);
-  }, W = () => {
+  }, Z = () => {
     if (typeof window > "u") {
       m = !1;
       return;
@@ -42,7 +45,7 @@ function Le(t) {
     }, 0);
   }, E = (e) => {
     x(() => t.onViewportChange?.(e));
-  }, Z = (e) => {
+  }, O = (e) => {
     if (typeof window > "u") {
       E(e);
       return;
@@ -50,16 +53,16 @@ function Le(t) {
     p(), f = window.setTimeout(() => {
       f = void 0, E(e);
     }, 90);
-  }, C = (e) => (t.resolveTargetRole ?? ee)({
+  }, C = (e) => (t.resolveTargetRole ?? ne)({
     target: e,
-    interactiveSelector: M(),
-    panSurfaceSelector: X()
-  }), O = () => {
+    interactiveSelector: X(),
+    panSurfaceSelector: F()
+  }), $ = () => {
     const e = w();
     if (!e) return;
     e.stopInteraction?.();
-    const n = c();
-    v(null), d = void 0, e.startedFromPanSurface && e.moved && (m = !0, W()), E(n);
+    const n = i();
+    v(null), d = void 0, e.startedFromPanSurface && e.moved && (m = !0, Z()), E(n);
   };
   A(() => {
     w() || S(k(t.viewport));
@@ -74,13 +77,13 @@ function Le(t) {
       s = !1;
     };
     document.addEventListener("keydown", a), document.addEventListener("keyup", r), window.addEventListener("blur", r);
-    const i = (o) => {
+    const c = (o) => {
       (o.button === 1 || o.button === 0 && s) && h(o);
     };
-    e.addEventListener("pointerdown", i, !0), e.addEventListener("click", n, !0), e.addEventListener("wheel", P, {
+    e.addEventListener("pointerdown", c, !0), e.addEventListener("click", n, !0), e.addEventListener("wheel", P, {
       passive: !1
     }), D(() => {
-      document.removeEventListener("keydown", a), document.removeEventListener("keyup", r), window.removeEventListener("blur", r), e.removeEventListener("pointerdown", i, !0), e.removeEventListener("click", n, !0), e.removeEventListener("wheel", P);
+      document.removeEventListener("keydown", a), document.removeEventListener("keyup", r), window.removeEventListener("blur", r), e.removeEventListener("pointerdown", c, !0), e.removeEventListener("click", n, !0), e.removeEventListener("wheel", P);
     });
   }), D(() => {
     p(), d?.stop({
@@ -102,23 +105,23 @@ function Le(t) {
       pointerId: e.pointerId,
       startClientX: e.clientX,
       startClientY: e.clientY,
-      startViewport: c(),
+      startViewport: i(),
       moved: !1,
       startedFromPanSurface: r,
-      stopInteraction: r ? void 0 : y({
+      stopInteraction: r ? void 0 : I({
         kind: "drag",
         cursor: "grabbing"
       })
-    }), d = re({
+    }), d = ae({
       pointerEvent: e,
       captureEl: l ?? null,
       capturePointer: !r,
-      onMove: $,
+      onMove: z,
       onEnd: () => {
-        O();
+        $();
       }
     }));
-  }, $ = (e) => {
+  }, z = (e) => {
     const n = w();
     if (!n || n.pointerId !== e.pointerId) return;
     const a = e.clientX - n.startClientX, r = e.clientY - n.startClientY;
@@ -132,31 +135,31 @@ function Le(t) {
     n.moved || v({
       ...n,
       moved: !0,
-      stopInteraction: n.stopInteraction ?? y({
+      stopInteraction: n.stopInteraction ?? I({
         kind: "drag",
         cursor: "grabbing"
       })
     }), S(o);
   }, P = (e) => {
     const n = l?.getBoundingClientRect();
-    if (!n || (t.resolveWheelRouting ?? te)({
+    if (!n || (t.resolveWheelRouting ?? re)({
       target: e.target,
       disablePanZoom: !!t.disablePanZoom,
-      wheelInteractiveSelector: F()
+      wheelInteractiveSelector: V()
     }).kind !== "canvas_zoom") return;
     e.preventDefault(), t.onViewportInteractionStart?.("wheel");
-    const r = c(), i = R(n, {
+    const r = i(), c = R(n, {
       clientX: e.clientX,
       clientY: e.clientY
-    }), o = we(e, l), L = me(r.scale * Math.exp(-o * H()), V(), N());
+    }), o = ve(e, l), L = Se(r.scale * Math.exp(-o * U()), N(), H());
     if (Math.abs(L - r.scale) < 1e-4) return;
-    const _ = ae({
+    const _ = ce({
       viewport: r,
-      localPoint: i,
+      localPoint: c,
       nextScale: L
     });
-    S(_), Z(_);
-  }, z = (e) => {
+    S(_), O(_);
+  }, B = (e) => {
     if (C(e.target) !== "canvas") return;
     const n = l?.getBoundingClientRect();
     if (!n) return;
@@ -164,33 +167,33 @@ function Le(t) {
     const a = R(n, {
       clientX: e.clientX,
       clientY: e.clientY
-    }), r = c(), i = oe(r, a);
+    }), r = i(), c = ie(r, a);
     t.onCanvasContextMenu?.({
       clientX: e.clientX,
       clientY: e.clientY,
       localX: a.localX,
       localY: a.localY,
-      worldX: i.worldX,
-      worldY: i.worldY
+      worldX: c.worldX,
+      worldY: c.worldY
     });
   };
   return (() => {
-    var e = ce(), n = e.firstChild, a = l;
-    return typeof a == "function" ? Q(a, e) : l = e, B(e, j({
+    var e = se(), n = e.firstChild, a = l;
+    return typeof a == "function" ? ee(a, e) : l = e, j(e, q({
       get class() {
-        return I("floe-infinite-canvas", U() && "is-panning", t.disablePanZoom && "is-locked", t.class);
+        return y("floe-infinite-canvas", W() && "is-panning", t.disablePanZoom && "is-locked", t.class);
       }
     }, {
-      [ie]: "true"
+      [le]: "true"
     }, {
       onPointerDown: h,
-      onContextMenu: z,
+      onContextMenu: B,
       get "aria-label"() {
         return t.ariaLabel ?? "Infinite canvas";
       }
-    }), !1, !0), T(n, () => t.children), T(e, () => t.overlay?.(c), null), q((r) => {
-      var i = I("floe-infinite-canvas__viewport", t.contentClass), o = `translate(${c().x}px, ${c().y}px) scale(${c().scale})`;
-      return i !== r.e && G(n, r.e = i), o !== r.t && J(n, "transform", r.t = o), r;
+    }), !1, !0), T(n, M), T(e, () => t.overlay?.(i), null), G((r) => {
+      var c = y("floe-infinite-canvas__viewport", t.contentClass), o = `translate(${i().x}px, ${i().y}px) scale(${i().scale})`;
+      return c !== r.e && J(n, r.e = c), o !== r.t && K(n, "transform", r.t = o), r;
     }, {
       e: void 0,
       t: void 0
@@ -198,5 +201,5 @@ function Le(t) {
   })();
 }
 export {
-  Le as InfiniteCanvas
+  Te as InfiniteCanvas
 };

package/dist/graph.css

@@ -0,0 +1,93 @@
+/* Domain colors and card content belong to the consumer. These tokens are theme-neutral. */
+.floe-graph {
+  position: relative;
+  isolation: isolate;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+  background-color: var(--graph-background, var(--background));
+  background-image: radial-gradient(
+    circle,
+    var(--graph-dot, color-mix(in srgb, var(--foreground) 12%, transparent)) 0.65px,
+    transparent 0.8px
+  );
+  background-size: 22px 22px;
+  color: var(--foreground);
+}
+.floe-graph .floe-infinite-canvas {
+  width: 100%;
+  height: 100%;
+}
+.floe-graph__node,
+.floe-graph__group {
+  position: absolute;
+  box-sizing: border-box;
+  user-select: none;
+}
+.floe-graph__node {
+  z-index: 2;
+}
+.floe-graph__group {
+  z-index: 0;
+}
+.floe-graph__node > *,
+.floe-graph__group > * {
+  box-sizing: border-box;
+}
+.floe-graph__edges {
+  position: absolute;
+  inset: 0;
+  overflow: visible;
+  z-index: 1;
+  pointer-events: none;
+}
+.floe-graph__edge {
+  fill: none;
+  stroke: var(--graph-edge, var(--muted-foreground));
+  stroke-width: 1.3px;
+  opacity: 0.32;
+  vector-effect: non-scaling-stroke;
+  stroke-linejoin: round;
+}
+.floe-graph__edge-target {
+  fill: none;
+  stroke: transparent;
+  stroke-width: 14px;
+  vector-effect: non-scaling-stroke;
+  pointer-events: stroke;
+  cursor: pointer;
+}
+.floe-graph__edges [data-emphasized='true'] .floe-graph__edge,
+.floe-graph__edges [data-selected='true'] .floe-graph__edge {
+  stroke: var(--graph-edge-active, var(--foreground));
+  stroke-width: 2px;
+  opacity: 0.95;
+}
+.floe-graph__edge-target:focus-visible {
+  outline: none;
+  stroke: var(--graph-edge-active, var(--foreground));
+  stroke-width: 3px;
+}
+.floe-graph__node:focus-visible,
+.floe-graph__group:focus-visible {
+  outline: 2px solid var(--ring);
+  outline-offset: 4px;
+  border-radius: 8px;
+}
+@media (forced-colors: active) {
+  .floe-graph {
+    background: Canvas;
+  }
+  .floe-graph__edge {
+    stroke: CanvasText;
+    opacity: 1;
+  }
+  .floe-graph__edges [data-emphasized='true'] .floe-graph__edge {
+    stroke: Highlight;
+  }
+  .floe-graph__node:focus-visible,
+  .floe-graph__group:focus-visible {
+    outline-color: Highlight;
+  }
+}

package/dist/graph.d.ts

@@ -0,0 +1,4 @@
+export * from './components/graph/types';
+export * from './components/graph/geometry';
+export * from './components/graph/engine';
+export * from './components/graph/GraphCanvas';

package/dist/graph.js

@@ -0,0 +1,10 @@
+import { fitGraphViewport as e, graphRelatedEdges as t, graphSectionPath as o } from "./components/graph/geometry.js";
+import { createGraphLayoutEngine as h } from "./components/graph/engine.js";
+import { GraphCanvas as g } from "./components/graph/GraphCanvas.js";
+export {
+  g as GraphCanvas,
+  h as createGraphLayoutEngine,
+  e as fitGraphViewport,
+  t as graphRelatedEdges,
+  o as graphSectionPath
+};