@floegence/floe-webapp-core 0.86.5 → 0.86.7

package/dist/components/graph/packing.js

@@ -1,5 +1,6 @@
-import { applyGraphPositions as b, routeGraphGeometry as G } from "./positions.js";
-async function O(d, n, k) {
+import { applyGraphPositions as b } from "./positions.js";
+import { routeGraphGeometry as G } from "./routing.js";
+async function N(d, n, k) {
   const a = new Map(d.nodes.map((e) => [e.id, { ...e, x: 0, y: 0 }])), r = /* @__PURE__ */ new Map();
   for (const e of a.values()) {
     const i = r.get(e.parentId) ?? [];
@@ -14,22 +15,22 @@ async function O(d, n, k) {
   const g = n.groupPadding ?? { top: 64, right: 28, bottom: 28, left: 28 }, p = (e, i, o) => {
     e.x += i, e.y += o;
     for (const c of r.get(e.id) ?? []) p(c, i, o);
-  }, y = (e, i) => {
+  }, m = (e, i) => {
     let o = a.get(e);
     for (; o && o.parentId !== i; )
       o = o.parentId ? a.get(o.parentId) : void 0;
     return o;
-  }, m = async (e) => {
+  }, y = async (e) => {
     const i = r.get(e) ?? [];
     for (const t of i) {
       if (!r.has(t.id)) continue;
-      const s = await m(t.id);
+      const s = await y(t.id);
       t.width = Math.max(t.width, s.width), t.height = Math.max(t.height, s.height);
     }
     if (!i.length) return { width: 0, height: 0 };
     const o = /* @__PURE__ */ new Map();
     for (const t of d.edges) {
-      const s = y(t.source, e), h = y(t.target, e);
+      const s = m(t.source, e), h = m(t.target, e);
       if (!s || !h || s.id === h.id) continue;
       const w = JSON.stringify([s.id, h.id]);
       o.has(w) || o.set(w, { id: t.id, sources: [s.id], targets: [h.id] });
@@ -57,7 +58,7 @@ async function O(d, n, k) {
       p(s, (t.x ?? 0) - s.x, (t.y ?? 0) - s.y);
     }
     return { width: c.width ?? 0, height: c.height ?? 0 };
-  }, S = await m(), f = !n.positions?.length && n.anchor && a.get(n.anchor.nodeId);
+  }, S = await y(), f = !n.positions?.length && n.anchor && a.get(n.anchor.nodeId);
   if (f) {
     const e = n.anchor.position.x - f.x, i = n.anchor.position.y - f.y;
     for (const o of r.get(void 0) ?? []) p(o, e, i);
@@ -70,5 +71,5 @@ async function O(d, n, k) {
   return n.positions?.length ? b(u, n, d.nodes) : G(u);
 }
 export {
-  O as computePackedGraphLayout
+  N as computePackedGraphLayout
 };

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

@@ -1,5 +1,4 @@
 import type { GraphLayout, GraphLayoutOptions, GraphNode } from './types';
+export { routeGraphGeometry } from './routing';
 /** Apply explicit fixed or preferred positions, then route the resulting geometry once. */
-export declare function applyGraphPositions(layout: GraphLayout, options: GraphLayoutOptions, input: readonly GraphNode[]): GraphLayout;
-/** Shared routing and bounds for explicit positions and packed compound geometry. */
-export declare function routeGraphGeometry(layout: GraphLayout): GraphLayout;
+export declare function applyGraphPositions(layout: GraphLayout, options: GraphLayoutOptions, input: readonly GraphNode[]): GraphLayout | Promise<GraphLayout>;

package/dist/components/graph/positions.js

@@ -1,174 +1,75 @@
-const T = (r, a = 0) => ({
-  left: r.x - a,
-  top: r.y - a,
-  right: r.x + r.width + a,
-  bottom: r.y + r.height + a
-}), S = (r, a) => r.x > a.left && r.x < a.right && r.y > a.top && r.y < a.bottom, O = (r, a, w) => !w.some(
-  (c) => r.x === a.x ? r.x > c.left && r.x < c.right && Math.max(r.y, a.y) > c.top && Math.min(r.y, a.y) < c.bottom : r.y > c.top && r.y < c.bottom && Math.max(r.x, a.x) > c.left && Math.min(r.x, a.x) < c.right
-);
-function P(r, a, w) {
-  if (w.some((e) => S(r, e) || S(a, e)))
-    throw new Error("Pinned graph positions obstruct an edge endpoint");
-  const c = [
-    .../* @__PURE__ */ new Set([r.x, a.x, ...w.flatMap((e) => [e.left, e.right])])
-  ].sort((e, i) => e - i), m = [
-    .../* @__PURE__ */ new Set([r.y, a.y, ...w.flatMap((e) => [e.top, e.bottom])])
-  ].sort((e, i) => e - i), l = (e) => ({ x: c[e % c.length], y: m[Math.floor(e / c.length)] }), g = m.indexOf(r.y) * c.length + c.indexOf(r.x), n = m.indexOf(a.y) * c.length + c.indexOf(a.x), M = /* @__PURE__ */ new Map([[g, 0]]), d = /* @__PURE__ */ new Map(), t = [], u = (e) => {
-    let i = t.length;
-    for (t.push(e); i > 0; ) {
-      const x = i - 1 >> 1;
-      if (t[x].score <= e.score) break;
-      t[i] = t[x], i = x;
-    }
-    t[i] = e;
-  }, I = () => {
-    const e = t[0], i = t.pop();
-    if (t.length) {
-      let x = 0;
-      for (; x * 2 + 1 < t.length; ) {
-        let h = x * 2 + 1;
-        if (h + 1 < t.length && t[h + 1].score < t[h].score && h++, t[h].score >= i.score) break;
-        t[x] = t[h], x = h;
-      }
-      t[x] = i;
-    }
-    return e;
-  };
-  u({ id: g, score: 0, cost: 0 });
-  let v = 0;
-  for (; t.length && v++ < 5e4; ) {
-    const e = I();
-    if (e.cost !== M.get(e.id)) continue;
-    if (e.id === n) {
-      const y = [l(n)];
-      let o = n;
-      for (; o !== g; )
-        o = d.get(o), y.push(l(o));
-      return y.reverse(), y.filter((p, f) => {
-        const E = y[f - 1], b = y[f + 1];
-        return !E || !b || !(E.x === p.x && p.x === b.x || E.y === p.y && p.y === b.y);
-      });
-    }
-    const i = l(e.id), x = e.id % c.length, h = Math.floor(e.id / c.length), s = [
-      x ? e.id - 1 : -1,
-      x + 1 < c.length ? e.id + 1 : -1,
-      h ? e.id - c.length : -1,
-      h + 1 < m.length ? e.id + c.length : -1
-    ];
-    for (const y of s) {
-      if (y < 0) continue;
-      const o = l(y), p = e.cost + Math.abs(i.x - o.x) + Math.abs(i.y - o.y);
-      p >= (M.get(y) ?? 1 / 0) || !O(i, o, w) || (M.set(y, p), d.set(y, e.id), u({ id: y, cost: p, score: p + Math.abs(o.x - a.x) + Math.abs(o.y - a.y) }));
-    }
-  }
-  throw new Error("Pinned graph positions cannot be routed within the layout budget");
-}
-function k(r, a, w) {
-  if (!a.positions?.length) return r;
-  const c = new Map(r.nodes.map((t) => [t.id, { ...t }])), m = /* @__PURE__ */ new Map();
-  for (const t of a.positions) {
-    if (!c.has(t.nodeId) || m.has(t.nodeId) || !Number.isFinite(t.x) || !Number.isFinite(t.y))
+import { routeGraphGeometry as G } from "./routing.js";
+function E(d, c, v) {
+  if (!c.positions?.length) return d;
+  const f = new Map(d.nodes.map((t) => [t.id, { ...t }])), l = /* @__PURE__ */ new Map();
+  for (const t of c.positions) {
+    if (!f.has(t.nodeId) || l.has(t.nodeId) || !Number.isFinite(t.x) || !Number.isFinite(t.y))
       throw new Error(`Invalid graph position: ${t.nodeId}`);
-    m.set(t.nodeId, t);
+    l.set(t.nodeId, t);
   }
-  const l = /* @__PURE__ */ new Map();
-  for (const t of c.values())
+  const y = /* @__PURE__ */ new Map();
+  for (const t of f.values())
     if (t.parentId) {
-      const u = l.get(t.parentId) ?? [];
-      u.push(t), l.set(t.parentId, u);
+      const m = y.get(t.parentId) ?? [];
+      m.push(t), y.set(t.parentId, m);
     }
-  const g = a.groupPadding ?? { top: 64, left: 28, right: 28, bottom: 28 }, n = a.positionMode === "preferred", M = new Map(w.map((t) => [t.id, t])), d = (t, u, I) => {
-    const v = { x: t.x, y: t.y }, e = m.get(t.id);
-    t.x = e?.x ?? t.x + u, t.y = e?.y ?? t.y + I;
-    const i = l.get(t.id) ?? [];
-    for (const o of i) d(o, t.x - v.x, t.y - v.y);
-    if (!i.length || n) return;
-    const x = Math.min(...i.map((o) => o.x)) - g.left, h = Math.min(...i.map((o) => o.y)) - g.top;
-    if (e && (x < t.x || h < t.y))
+  const x = c.groupPadding ?? { top: 64, left: 28, right: 28, bottom: 28 }, u = c.positionMode === "preferred", I = new Map(v.map((t) => [t.id, t])), b = (t, m, M) => {
+    const g = { x: t.x, y: t.y }, p = l.get(t.id);
+    t.x = p?.x ?? t.x + m, t.y = p?.y ?? t.y + M;
+    const i = y.get(t.id) ?? [];
+    for (const a of i) b(a, t.x - g.x, t.y - g.y);
+    if (!i.length || u) return;
+    const o = Math.min(...i.map((a) => a.x)) - x.left, h = Math.min(...i.map((a) => a.y)) - x.top;
+    if (p && (o < t.x || h < t.y))
       throw new Error(`Pinned child lies outside group content: ${t.id}`);
     const s = Math.max(
       t.x + t.width,
-      ...i.map((o) => o.x + o.width + g.right)
-    ), y = Math.max(
+      ...i.map((a) => a.x + a.width + x.right)
+    ), n = Math.max(
       t.y + t.height,
-      ...i.map((o) => o.y + o.height + g.bottom)
+      ...i.map((a) => a.y + a.height + x.bottom)
     );
-    e || (t.x = Math.min(t.x, x), t.y = Math.min(t.y, h)), t.width = s - t.x, t.height = y - t.y;
+    p || (t.x = Math.min(t.x, o), t.y = Math.min(t.y, h)), t.width = s - t.x, t.height = n - t.y;
   };
-  for (const t of c.values()) t.parentId || d(t, 0, 0);
-  if (n) {
-    const t = Math.max(16, a.spacing ?? 64), u = (i, x, h) => {
-      i.x += x, i.y += h;
-      for (const s of l.get(i.id) ?? []) u(s, x, h);
-    }, I = (i) => {
-      const x = [];
+  for (const t of f.values()) t.parentId || b(t, 0, 0);
+  if (u) {
+    const t = Math.max(16, c.spacing ?? 64), m = (i, o, h) => {
+      i.x += o, i.y += h;
+      for (const s of y.get(i.id) ?? []) m(s, o, h);
+    }, M = (i) => {
+      const o = [];
       for (const h of [...i].sort(
-        (s, y) => s.y - y.y || s.x - y.x || s.id.localeCompare(y.id)
+        (s, n) => s.y - n.y || s.x - n.x || s.id.localeCompare(n.id)
       )) {
         const s = { x: h.x, y: h.y };
-        for (const p of [...x].sort((f, E) => f.x - E.x))
-          h.y < p.y + p.height + t && h.y + h.height + t > p.y && s.x < p.x + p.width + t && s.x + h.width + t > p.x && (s.x = p.x + p.width + t);
-        const y = { x: h.x, y: h.y };
-        for (const p of [...x].sort((f, E) => f.y - E.y))
-          h.x < p.x + p.width + t && h.x + h.width + t > p.x && y.y < p.y + p.height + t && y.y + h.height + t > p.y && (y.y = p.y + p.height + t);
-        const o = s.x - h.x < y.y - h.y ? s : y;
-        u(h, o.x - h.x, o.y - h.y), x.push(h);
+        for (const r of [...o].sort((e, w) => e.x - w.x))
+          h.y < r.y + r.height + t && h.y + h.height + t > r.y && s.x < r.x + r.width + t && s.x + h.width + t > r.x && (s.x = r.x + r.width + t);
+        const n = { x: h.x, y: h.y };
+        for (const r of [...o].sort((e, w) => e.y - w.y))
+          h.x < r.x + r.width + t && h.x + h.width + t > r.x && n.y < r.y + r.height + t && n.y + h.height + t > r.y && (n.y = r.y + r.height + t);
+        const a = s.x - h.x < n.y - h.y ? s : n;
+        m(h, a.x - h.x, a.y - h.y), o.push(h);
       }
-    }, v = (i) => {
-      const x = l.get(i.id) ?? [];
-      if (!x.length) return;
-      for (const f of x) v(f);
-      I(x);
-      const h = Math.max(12, g.left), s = Math.max(12, g.top), y = Math.max(12, g.right), o = Math.max(12, g.bottom), p = m.get(i.id);
-      i.x = Math.min(p?.x ?? 1 / 0, Math.min(...x.map((f) => f.x)) - h), i.y = Math.min(p?.y ?? 1 / 0, Math.min(...x.map((f) => f.y)) - s), i.width = Math.max(
-        M.get(i.id).width,
-        Math.max(...x.map((f) => f.x + f.width)) + y - i.x
+    }, g = (i) => {
+      const o = y.get(i.id) ?? [];
+      if (!o.length) return;
+      for (const e of o) g(e);
+      M(o);
+      const h = Math.max(12, x.left), s = Math.max(12, x.top), n = Math.max(12, x.right), a = Math.max(12, x.bottom), r = l.get(i.id);
+      i.x = Math.min(r?.x ?? 1 / 0, Math.min(...o.map((e) => e.x)) - h), i.y = Math.min(r?.y ?? 1 / 0, Math.min(...o.map((e) => e.y)) - s), i.width = Math.max(
+        I.get(i.id).width,
+        Math.max(...o.map((e) => e.x + e.width)) + n - i.x
       ), i.height = Math.max(
-        M.get(i.id).height,
-        Math.max(...x.map((f) => f.y + f.height)) + o - i.y
+        I.get(i.id).height,
+        Math.max(...o.map((e) => e.y + e.height)) + a - i.y
       );
-    }, e = [...c.values()].filter((i) => !i.parentId);
-    for (const i of e) v(i);
-    I(e);
+    }, p = [...f.values()].filter((i) => !i.parentId);
+    for (const i of p) g(i);
+    M(p);
   }
-  return N({ ...r, nodes: [...c.values()] });
-}
-function N(r) {
-  if (!r.nodes.length) return r;
-  const a = new Map(r.nodes.map((n) => [n.id, n])), w = r.edges.map((n) => {
-    const M = a.get(n.source), d = a.get(n.target), t = (s, y, o) => s.ports?.find((p) => p.id === y)?.side ?? o, u = M.x + M.width / 2 <= d.x + d.width / 2, I = (s, y) => {
-      const o = { x: s.x + s.width / 2, y: s.y + s.height / 2 };
-      return y === "NORTH" ? [
-        { x: o.x, y: s.y },
-        { x: o.x, y: s.y - 8 }
-      ] : y === "SOUTH" ? [
-        { x: o.x, y: s.y + s.height },
-        { x: o.x, y: s.y + s.height + 8 }
-      ] : y === "WEST" ? [
-        { x: s.x, y: o.y },
-        { x: s.x - 8, y: o.y }
-      ] : [
-        { x: s.x + s.width, y: o.y },
-        { x: s.x + s.width + 8, y: o.y }
-      ];
-    }, [v, e] = I(M, t(M, n.sourcePort, u ? "EAST" : "WEST")), [i, x] = I(
-      d,
-      t(d, n.targetPort, M === d ? "NORTH" : u ? "WEST" : "EAST")
-    ), h = [...a.values()].filter((s) => s.kind !== "group").map((s) => T(s, 4));
-    return { ...n, sections: [[v, ...P(e, x, h), i]] };
-  }), c = [...a.values()], m = w.flatMap((n) => n.sections.flat()), l = Math.min(...c.map((n) => n.x), ...m.map((n) => n.x)), g = Math.min(...c.map((n) => n.y), ...m.map((n) => n.y));
-  return {
-    nodes: c,
-    edges: w,
-    bounds: {
-      x: l,
-      y: g,
-      width: Math.max(...c.map((n) => n.x + n.width), ...m.map((n) => n.x)) - l,
-      height: Math.max(...c.map((n) => n.y + n.height), ...m.map((n) => n.y)) - g
-    }
-  };
+  return G({ ...d, nodes: [...f.values()] });
 }
 export {
-  k as applyGraphPositions,
-  N as routeGraphGeometry
+  E as applyGraphPositions,
+  G as routeGraphGeometry
 };

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

@@ -0,0 +1,3 @@
+import type { GraphLayout } from './types';
+/** Joint orthogonal routing through the final rectangular geometry. */
+export declare function routeGraphGeometry(layout: GraphLayout): Promise<GraphLayout>;

package/dist/components/graph/routing.js

@@ -0,0 +1,165 @@
+import { AvoidLib as H } from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/index.js";
+import _ from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/libavoid.wasm.js";
+let U;
+const F = { NORTH: 1, SOUTH: 2, WEST: 4, EAST: 8 }, v = ["NORTH", "EAST", "SOUTH", "WEST"], m = (s) => s.delete();
+async function L(s) {
+  if (!s.nodes.length) return s;
+  if (!s.edges.length) return W(s);
+  await (U ??= H.load(_).catch((g) => {
+    throw U = void 0, g;
+  }));
+  const n = H.getInstance(), x = new Map(s.nodes.map((g) => [g.id, g])), S = (g) => {
+    const y = [];
+    for (let a = x.get(g).parentId; a; a = x.get(a).parentId)
+      y.push(a);
+    return y;
+  }, i = /* @__PURE__ */ new Map();
+  for (const g of s.edges) {
+    const y = /* @__PURE__ */ new Set([...S(g.source), ...S(g.target)]), a = JSON.stringify([...y].sort()), O = i.get(a) ?? { open: y, edges: [] };
+    O.edges.push(g), i.set(a, O);
+  }
+  const k = /* @__PURE__ */ new Map();
+  for (const { open: g, edges: y } of i.values()) {
+    const a = new n.Router(2);
+    try {
+      a.setRoutingParameter(n.RoutingParameter.shapeBufferDistance, 4), a.setRoutingParameter(n.RoutingParameter.idealNudgingDistance, 8), a.setRoutingParameter(n.RoutingParameter.crossingPenalty, 80), a.setRoutingParameter(n.RoutingParameter.fixedSharedPathPenalty, 120), a.setRoutingParameter(n.RoutingParameter.portDirectionPenalty, 0), a.setRoutingOption(n.RoutingOption.nudgeOrthogonalSegmentsConnectedToShapes, !1), a.setRoutingOption(n.RoutingOption.nudgeSharedPathsWithCommonEndPoint, !0);
+      const O = new Map(
+        s.nodes.filter((t) => !g.has(t.id) && S(t.id).every((r) => g.has(r))).map((t) => {
+          const r = new n.Point(t.x, t.y), c = new n.Point(t.x + t.width, t.y + t.height), h = new n.Rectangle(r, c), o = new n.ShapeRef(a, h);
+          return m(r), m(c), m(h), [t.id, o];
+        })
+      );
+      for (const t of s.nodes) {
+        const r = O.get(t.id);
+        if (!r) continue;
+        const c = y.flatMap(
+          (e) => e.source === t.id ? [x.get(e.target)] : e.target === t.id ? [x.get(e.source)] : []
+        );
+        if (!c.length) continue;
+        const h = (e, f, p, M) => {
+          const T = Math.max(e, p), R = Math.min(e + f, p + M), A = Math.min(8, f / 4);
+          return T < R ? (T + R) / 2 : Math.max(e + A, Math.min(e + f - A, p + M / 2));
+        }, o = (e, f) => {
+          const p = Math.min(8, e / 4);
+          return [
+            .../* @__PURE__ */ new Set([
+              e / 2,
+              p,
+              e - p,
+              ...f.flatMap(
+                (M) => Array.from(
+                  { length: c.length + 1 },
+                  (T, R) => Math.max(p, Math.min(e - p, M + (R - c.length / 2) * 8))
+                )
+              )
+            ])
+          ];
+        }, u = o(
+          t.width,
+          c.map((e) => h(t.x, t.width, e.x, e.width) - t.x)
+        ), w = o(
+          t.height,
+          c.map((e) => h(t.y, t.height, e.y, e.height) - t.y)
+        ), l = (t.ports ?? []).map((e) => E(t, e.side)), P = y.some((e) => e.source === t.id && e.target === t.id), C = [
+          ...l,
+          ...P ? [
+            { x: t.x + t.width, y: t.y + t.height / 3 },
+            { x: t.x + t.width, y: t.y + t.height * 2 / 3 }
+          ] : []
+        ], b = (e, f, p, M, T) => {
+          const R = new n.ShapeConnectionPin(
+            r,
+            e,
+            f / t.width,
+            p / t.height,
+            !0,
+            0,
+            M
+          );
+          R.setExclusive(T), R.setConnectionCost(
+            t.width / 2 + t.height / 2 - Math.abs(f - t.width / 2) - Math.abs(p - t.height / 2)
+          );
+        }, d = (e, f, p) => {
+          C.some((M) => M.x === t.x + e && M.y === t.y + f) || b(1, e, f, p, !0);
+        };
+        for (const e of u)
+          d(e, 0, 1), d(e, t.height, 2);
+        for (const e of w)
+          d(0, e, 4), d(t.width, e, 8);
+        for (const e of new Set(t.ports?.map((f) => f.side))) {
+          const { x: f, y: p } = E(t, e);
+          b(v.indexOf(e) + 2, f - t.x, p - t.y, F[e], !1);
+        }
+        P && (b(6, t.width, t.height / 3, 8, !1), b(7, t.width, t.height * 2 / 3, 8, !1));
+      }
+      const N = (t, r, c, h) => {
+        const o = x.get(t), u = O.get(t);
+        if (u)
+          return new n.ConnEnd(
+            u,
+            r ? v.indexOf(o.ports.find((d) => d.id === r).side) + 2 : t === c ? h ? 7 : 6 : 1
+          );
+        const w = x.get(c), l = v.map((d) => E(o, d));
+        l.sort((d, e) => B(d, w) - B(e, w));
+        const P = r ? E(o, o.ports.find((d) => d.id === r).side) : l[0], C = new n.Point(P.x, P.y), b = new n.ConnEnd(C);
+        return m(C), b;
+      }, G = y.map((t) => {
+        const r = N(t.source, t.sourcePort, t.target, !1), c = N(t.target, t.targetPort, t.source, !0), h = new n.ConnRef(a, r, c);
+        if (m(r), m(c), t.source === t.target) {
+          const o = x.get(t.source), u = new n.CheckpointVector();
+          for (const w of [o.y + o.height / 3, o.y + o.height * 2 / 3]) {
+            const l = new n.Point(o.x + o.width + 24, w), P = new n.Checkpoint(l);
+            u.push_back(P), m(l), m(P);
+          }
+          h.setRoutingCheckpoints(u), m(u);
+        }
+        return { edge: t, connection: h };
+      });
+      a.processTransaction();
+      for (const { edge: t, connection: r } of G) {
+        const c = r.displayRoute(), h = Array.from({ length: c.size() }, (o, u) => {
+          const w = c.at(u), l = { x: w.x, y: w.y };
+          return m(w), l;
+        });
+        if (m(c), !r.hasValidRoute() || h.length < 2 || h.some((o) => !Number.isFinite(o.x) || !Number.isFinite(o.y)) || h.some((o, u) => u > 0 && o.x !== h[u - 1].x && o.y !== h[u - 1].y))
+          throw new Error(`Graph edge cannot be routed: ${t.id}`);
+        k.set(t.id, h);
+      }
+    } finally {
+      a.delete();
+    }
+  }
+  const D = s.edges.map((g) => ({ ...g, sections: [k.get(g.id)] }));
+  return W({ nodes: s.nodes, edges: D, bounds: s.bounds });
+}
+function W(s) {
+  const n = [
+    ...s.nodes.flatMap((i) => [
+      { x: i.x, y: i.y },
+      { x: i.x + i.width, y: i.y + i.height }
+    ]),
+    ...s.edges.flatMap((i) => i.sections.flat())
+  ], x = Math.min(...n.map((i) => i.x)), S = Math.min(...n.map((i) => i.y));
+  return {
+    nodes: s.nodes,
+    edges: s.edges,
+    bounds: {
+      x,
+      y: S,
+      width: Math.max(...n.map((i) => i.x)) - x,
+      height: Math.max(...n.map((i) => i.y)) - S
+    }
+  };
+}
+function E(s, n) {
+  return {
+    x: n === "WEST" ? s.x : n === "EAST" ? s.x + s.width : s.x + s.width / 2,
+    y: n === "NORTH" ? s.y : n === "SOUTH" ? s.y + s.height : s.y + s.height / 2
+  };
+}
+function B(s, n) {
+  return Math.max(n.x - s.x, 0, s.x - n.x - n.width) + Math.max(n.y - s.y, 0, s.y - n.y - n.height);
+}
+export {
+  L as routeGraphGeometry
+};

package/dist/licenses/graph-notice.txt

@@ -3,3 +3,14 @@ Copyright (c) 2017 Kiel University and others.
 Licensed under the Eclipse Public License 2.0. A copy is in elkjs.txt.
 Unmodified upstream source is available at https://github.com/kieler/elkjs/tree/0.12.0
 and https://registry.npmjs.org/elkjs/-/elkjs-0.12.0.tgz.
+
+Orthogonal routing uses libavoid-js 0.5.0-beta.5 and its separate unmodified
+libavoid.wasm library. libavoid is Copyright (C) Monash University and others;
+libavoid-js is maintained by Vladyslav Hnatiuk. Licensed under LGPL-2.1-or-later;
+a copy is in libavoid.txt. Corresponding source and build instructions are
+included in libavoid-sources.tar.gz. The unmodified source revisions are:
+https://github.com/Aksem/libavoid-js/tree/5062a42fbd82fff562afeebcbb7b1ed45eed8e75
+https://github.com/Aksem/adaptagrams/tree/0ab3467b4ed3523bb3e404a0dd7da7647d9eb13d
+The separate WASM library can be replaced with an API-compatible build.
+Extract the source archive, enter libavoid-js, and run python3 tools/generate.py
+(requires Docker), npm install, and npm run build to rebuild the library.