@floegence/floe-webapp-core 0.86.7 → 0.86.8

package/dist/components/graph/routing.js

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

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

@@ -52,8 +52,10 @@ export interface GraphLayoutOptions {
     positions?: readonly (GraphPoint & {
         nodeId: string;
     })[];
-    /** Fixed (default) rejects impossible geometry. Preferred retains clear positions and separates colliding siblings, resizing groups around their content before routing. */
-    positionMode?: 'fixed' | 'preferred';
+    /** Root-level ranks. Unassigned roots are placed deterministically near their closest ranked neighbors. */
+    layers?: readonly (readonly string[])[];
+    /** Fixed (default) rejects impossible geometry. Preferred retains positions; compact uses them only as stable ordering hints. */
+    positionMode?: 'fixed' | 'preferred' | 'compact';
     direction?: 'RIGHT' | 'DOWN' | 'LEFT' | 'UP';
     spacing?: number;
     groupPadding?: {