@omg-dev/app 0.5.1 → 0.6.1

package/dist-lib/{cynefinDiagram-TSTJHNR4-Be7CamD2.js → cynefinDiagram-TSTJHNR4-CrgvPEr1.js}

@@ -1,6 +1,6 @@
-import { p as xt } from "./chunk-JWPE2WC7-DFPBClX_.js";
-import { s as gt, g as $t, p as bt, o as wt, a as Ct, b as vt, _ as s, l as O, F as Dt, e as kt, q as Tt, B as U, z as Q, D as At, W as ot } from "./index-JkCQXUYs.js";
-import { p as Bt } from "./cynefin-VYW2F7L2-DQXPWaog.js";
+import { p as xt } from "./chunk-JWPE2WC7-DnwG7Xzp.js";
+import { s as gt, g as $t, p as bt, o as wt, a as Ct, b as vt, _ as s, l as O, F as Dt, e as kt, q as Tt, B as U, z as Q, D as At, W as ot } from "./index-B0neMIbR.js";
+import { p as Bt } from "./cynefin-VYW2F7L2-XAY3mHv8.js";
 var rt = /* @__PURE__ */ s(() => ({
   domains: /* @__PURE__ */ new Map(),
   transitions: []

package/dist-lib/{cytoscape.esm-B0ledd6M.js → cytoscape.esm-BB6Ga9He.js}

@@ -788,7 +788,7 @@ var _o = !0, Kc = console.warn != null, Xc = console.trace != null, Js = Number.
   var t = Object.keys(e);
   return function(a) {
     for (var n = {}, i = 0; i < t.length; i++) {
-      var s = t[i], o = a == null ? void 0 : a[s];
+      var s = t[i], o = a?.[s];
       n[s] = o === void 0 ? e[s] : o;
     }
     return n;
@@ -3460,7 +3460,7 @@ function Vh() {
   if (pu) return ki;
   pu = 1;
   function r(e, t) {
-    return e == null ? void 0 : e[t];
+    return e?.[t];
   }
   return ki = r, ki;
 }
@@ -14391,7 +14391,7 @@ ia.load = function() {
       };
       fe.emit(pe("box")).stdFilter(ke).select().emit(pe("boxselect")), fe.nonempty() && r.redrawHint("eles", !0), r.redraw();
     }
-    if (z != null && z.unactivate(), T.touches[2])
+    if (z?.unactivate(), T.touches[2])
       r.data.bgActivePosistion = void 0, r.redrawHint("select", !0);
     else if (!T.touches[1]) {
       if (!T.touches[0]) {

package/dist-lib/dagre-VKFMJZFB-CE5k06mJ.js

@@ -0,0 +1,343 @@
+import { c as O, w as I, a as J, f as P, b as E, s as A } from "./chunk-RYQCIY6F-I-J4fVFd.js";
+import { _ as w, am as v, an as D, ao as H, ap as Y, l, c as _, aq as W, ar as $, ag as j, as as q, ah as R, af as F, at as z, au as K, av as G } from "./index-B0neMIbR.js";
+import { G as Q } from "./graph-DAHC4kPm.js";
+import { l as U } from "./layout-DBbo_M5I.js";
+var C = /* @__PURE__ */ w((s, t, g) => Math.max(t, Math.min(g, s)), "clamp"), B = /* @__PURE__ */ w((s = "TB") => {
+  switch (s) {
+    case "BT":
+      return "bottom";
+    case "LR":
+      return "right";
+    case "RL":
+      return "left";
+    case "TB":
+    default:
+      return "top";
+  }
+}, "getDefaultSelfLoopSide"), V = /* @__PURE__ */ w((s) => s === "flowchart" || s === "flowchart-v2" || s === "stateDiagram", "shouldMergeSelfLoopSegments"), Z = /* @__PURE__ */ w((s, t, g, y, c) => {
+  const o = [], r = /* @__PURE__ */ new Set();
+  if (g.forEach(({ start: i, end: n }) => {
+    i !== y && r.add(i), n !== y && r.add(n);
+  }), r.forEach((i) => {
+    const n = s.node(i);
+    typeof n?.x == "number" && typeof n?.y == "number" && o.push(n);
+  }), o.length === 0 && g.forEach(({ edge: i }) => {
+    (i.points ?? []).forEach((n) => {
+      typeof n?.x == "number" && typeof n?.y == "number" && o.push(n);
+    });
+  }), o.length === 0)
+    return B(c);
+  const f = o.reduce(
+    (i, n) => ({
+      x: i.x + n.x / o.length,
+      y: i.y + n.y / o.length
+    }),
+    { x: 0, y: 0 }
+  ), h = f.x - t.x, a = f.y - t.y;
+  return Math.abs(h) > Math.abs(a) ? h > 0 ? "right" : "left" : Math.abs(a) > 0 ? a > 0 ? "bottom" : "top" : B(c);
+}, "getSelfLoopSide"), ee = /* @__PURE__ */ w((s, t = "top", g = 0, y = 0) => {
+  const c = s.x, o = s.y - g, r = s.width / 2, f = s.height / 2, h = Math.max(36, Math.min(100, s.width * 0.8)), a = C(Math.max(y, s.width * 0.35), 36, h), i = C(Math.min(s.width, s.height) * 0.45, 24, 48);
+  switch (t) {
+    case "bottom": {
+      const n = o + f;
+      return [
+        { x: c - a / 2, y: n },
+        { x: c - a / 2, y: n + i },
+        { x: c + a / 2, y: n + i },
+        { x: c + a / 2, y: n }
+      ];
+    }
+    case "right": {
+      const n = c + r;
+      return [
+        { x: n, y: o - a / 2 },
+        { x: n + i, y: o - a / 2 },
+        { x: n + i, y: o + a / 2 },
+        { x: n, y: o + a / 2 }
+      ];
+    }
+    case "left": {
+      const n = c - r;
+      return [
+        { x: n, y: o - a / 2 },
+        { x: n - i, y: o - a / 2 },
+        { x: n - i, y: o + a / 2 },
+        { x: n, y: o + a / 2 }
+      ];
+    }
+    case "top":
+    default: {
+      const n = o - f;
+      return [
+        { x: c - a / 2, y: n },
+        { x: c - a / 2, y: n - i },
+        { x: c + a / 2, y: n - i },
+        { x: c + a / 2, y: n }
+      ];
+    }
+  }
+}, "getSelfLoopPoints"), te = /* @__PURE__ */ w((s, t, g = "top", y = 0, c = {}) => {
+  const r = s.x, f = s.y - y, h = c.width ?? 0, a = c.height ?? 0;
+  switch (g) {
+    case "bottom":
+      return { x: r, y: Math.max(...t.map((i) => i.y)) + a / 2 + 4 };
+    case "right":
+      return { x: Math.max(...t.map((i) => i.x)) + h / 2 + 4, y: f };
+    case "left":
+      return { x: Math.min(...t.map((i) => i.x)) - h / 2 - 4, y: f };
+    case "top":
+    default:
+      return { x: r, y: Math.min(...t.map((i) => i.y)) - a / 2 - 4 };
+  }
+}, "getSelfLoopLabelPosition"), ne = /* @__PURE__ */ w((s, t = 0, { mergeSelfLoops: g = !0 } = {}) => {
+  const y = /* @__PURE__ */ new Map(), c = [], o = s.graph()?.rankdir;
+  return s.edges().forEach((r) => {
+    const f = s.edge(r);
+    if (g && f.selfLoop) {
+      const h = f.selfLoop.id;
+      y.has(h) || y.set(h, []), y.get(h).push({ edge: f, start: r.v, end: r.w });
+    } else
+      c.push({ edge: f, start: r.v, end: r.w });
+  }), y.forEach((r) => {
+    if (r.length !== 3) {
+      r.forEach((L) => c.push(L));
+      return;
+    }
+    r.sort((L, d) => L.edge.selfLoop.order - d.edge.selfLoop.order);
+    const [f, h, a] = r, i = f.edge.originalEdge ?? h.edge.originalEdge ?? a.edge.originalEdge ?? h.edge, n = s.node(i.start);
+    if (!n) {
+      r.forEach((L) => c.push(L));
+      return;
+    }
+    const p = {
+      width: h.edge.width,
+      height: h.edge.height
+    }, m = Z(s, n, r, i.start, o), X = ee(n, m, t, p.width ?? 0), S = te(n, X, m, t, p), b = {
+      ...h.edge,
+      ...i,
+      id: i.id,
+      points: X,
+      start: i.start,
+      end: i.end,
+      x: S.x,
+      y: S.y,
+      width: p.width,
+      height: p.height,
+      labelStyle: h.edge.labelStyle,
+      fromCluster: f.edge.fromCluster ?? h.edge.fromCluster ?? a.edge.fromCluster,
+      toCluster: f.edge.toCluster ?? h.edge.toCluster ?? a.edge.toCluster
+    };
+    delete b.selfLoop, delete b.originalEdge, c.push({ edge: b, start: b.start, end: b.end });
+  }), c;
+}, "getEdgesToRender"), T = /* @__PURE__ */ w(async (s, t, g, y, c, o) => {
+  l.warn("Graph in recursive render:XAX", I(t), c);
+  const r = t.graph().rankdir;
+  l.trace("Dir in recursive render - dir:", r);
+  const f = s.insert("g").attr("class", "root");
+  t.nodes() ? l.info("Recursive render XXX", t.nodes()) : l.info("No nodes found for", t), t.edges().length > 0 && l.info("Recursive edges", t.edge(t.edges()[0]));
+  const h = f.insert("g").attr("class", "clusters"), a = f.insert("g").attr("class", "edgePaths"), i = f.insert("g").attr("class", "edgeLabels"), n = f.insert("g").attr("class", "nodes"), p = V(g);
+  await Promise.all(
+    t.nodes().map(async function(d) {
+      const e = t.node(d);
+      if (c !== void 0) {
+        const u = JSON.parse(JSON.stringify(c.clusterData));
+        l.trace(
+          `Setting data for parent cluster XXX
+ Node.id = `,
+          d,
+          `
+ data=`,
+          u.height,
+          `
+Parent cluster`,
+          c.height
+        ), t.setNode(c.id, u), t.parent(d) || (l.trace("Setting parent", d, c.id), t.setParent(d, c.id, u));
+      }
+      if (l.info("(Insert) Node XXX" + d + ": " + JSON.stringify(t.node(d))), e?.clusterNode) {
+        l.info("Cluster identified XBX", d, e.width, t.node(d));
+        const { ranksep: u, nodesep: x } = t.graph();
+        e.graph.setGraph({
+          ...e.graph.graph(),
+          ranksep: u + 25,
+          nodesep: x
+        });
+        const N = await T(
+          n,
+          e.graph,
+          g,
+          y,
+          t.node(d),
+          o
+        ), M = N.elem;
+        W(e, M), e.diff = N.diff || 0, l.info(
+          "New compound node after recursive render XAX",
+          d,
+          "width",
+          // node,
+          e.width,
+          "height",
+          e.height
+          // node.x,
+          // node.y
+        ), $(M, e);
+      } else
+        t.children(d).length > 0 ? (l.trace(
+          "Cluster - the non recursive path XBX",
+          d,
+          e.id,
+          e,
+          e.width,
+          "Graph:",
+          t
+        ), l.trace(P(e.id, t)), E.set(e.id, { id: P(e.id, t), node: e })) : (l.trace("Node - the non recursive path XAX", d, n, t.node(d), r), await j(n, t.node(d), { config: o, dir: r }));
+    })
+  ), await (/* @__PURE__ */ w(async () => {
+    const d = t.edges().map(async function(e) {
+      const u = t.edge(e.v, e.w, e.name);
+      if (l.info("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(e)), l.info("Edge " + e.v + " -> " + e.w + ": ", e, " ", JSON.stringify(t.edge(e))), l.info(
+        "Fix",
+        E,
+        "ids:",
+        e.v,
+        e.w,
+        "Translating: ",
+        E.get(e.v),
+        E.get(e.w)
+      ), p && u.selfLoop) {
+        if (u.selfLoop.order !== 1)
+          return;
+        const x = u.id;
+        u.id = u.selfLoop.id, await G(i, u), u.id = x;
+        return;
+      }
+      await G(i, u);
+    });
+    await Promise.all(d);
+  }, "processEdges"))(), l.info("Graph before layout:", JSON.stringify(I(t))), l.info("############################################# XXX"), l.info("###                Layout                 ### XXX"), l.info("############################################# XXX"), U(t), l.info("Graph after layout:", JSON.stringify(I(t)));
+  let X = 0, { subGraphTitleTotalMargin: S } = q(o);
+  await Promise.all(
+    A(t).map(async function(d) {
+      const e = t.node(d);
+      if (l.info(
+        "Position XBX => " + d + ": (" + e.x,
+        "," + e.y,
+        ") width: ",
+        e.width,
+        " height: ",
+        e.height
+      ), e?.clusterNode)
+        e.y += S, l.info(
+          "A tainted cluster node XBX1",
+          d,
+          e.id,
+          e.width,
+          e.height,
+          e.x,
+          e.y,
+          t.parent(d)
+        ), E.get(e.id).node = e, R(e);
+      else if (t.children(d).length > 0) {
+        l.info(
+          "A pure cluster node XBX1",
+          d,
+          e.id,
+          e.x,
+          e.y,
+          e.width,
+          e.height,
+          t.parent(d)
+        ), e.height += S, t.node(e.parentId);
+        const u = e?.padding / 2 || 0, x = e?.labelBBox?.height || 0, N = x - u || 0;
+        l.debug("OffsetY", N, "labelHeight", x, "halfPadding", u), await F(h, e), E.get(e.id).node = e;
+      } else {
+        const u = t.node(e.parentId);
+        e.y += S / 2, l.info(
+          "A regular node XBX1 - using the padding",
+          e.id,
+          "parent",
+          e.parentId,
+          e.width,
+          e.height,
+          e.x,
+          e.y,
+          "offsetY",
+          e.offsetY,
+          "parent",
+          u,
+          u?.offsetY,
+          e
+        ), R(e);
+      }
+    })
+  );
+  const b = S / 2;
+  return ne(t, b, { mergeSelfLoops: p }).forEach(function({ edge: d, start: e, end: u }) {
+    l.info("Edge " + e + " -> " + u + ": " + JSON.stringify(d), d), d.points.forEach((k) => k.y += b);
+    const x = t.node(e), N = t.node(u), M = z(a, d, E, g, x, N, y);
+    K(d, M);
+  }), t.nodes().forEach(function(d) {
+    const e = t.node(d);
+    l.info(d, e.type, e.diff), e.isGroup && (X = e.diff);
+  }), l.warn("Returning from recursive render XAX", f, X), { elem: f, diff: X };
+}, "recursiveRender"), de = /* @__PURE__ */ w(async (s, t) => {
+  const g = new Q({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: s.direction,
+    nodesep: s.config?.nodeSpacing || s.config?.flowchart?.nodeSpacing || s.nodeSpacing,
+    ranksep: s.config?.rankSpacing || s.config?.flowchart?.rankSpacing || s.rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  }), y = t.select("g");
+  v(y, s.markers, s.type, s.diagramId), D(), H(), Y(), O(), s.nodes.forEach((o) => {
+    g.setNode(o.id, { ...o }), o.parentId && g.setParent(o.id, o.parentId);
+  }), l.debug("Edges:", s.edges), s.edges.forEach((o) => {
+    if (o.start === o.end) {
+      const r = o.start, f = r + "---" + r + "---1", h = r + "---" + r + "---2", a = g.node(r);
+      g.setNode(f, {
+        domId: f,
+        id: f,
+        parentId: a.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      }), g.setParent(f, a.parentId), g.setNode(h, {
+        domId: h,
+        id: h,
+        parentId: a.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      }), g.setParent(h, a.parentId);
+      const i = structuredClone(o), n = structuredClone(o), p = structuredClone(o), m = structuredClone(o);
+      n.originalEdge = i, n.selfLoop = { id: i.id, order: 0 }, p.originalEdge = i, p.selfLoop = { id: i.id, order: 1 }, m.originalEdge = i, m.selfLoop = { id: i.id, order: 2 }, n.label = "", n.arrowTypeEnd = "none", n.endLabelLeft = "", n.endLabelRight = "", n.startLabelLeft = "", n.id = r + "-cyclic-special-1", p.startLabelRight = "", p.startLabelLeft = "", p.endLabelLeft = "", p.endLabelRight = "", p.arrowTypeStart = "none", p.arrowTypeEnd = "none", p.id = r + "-cyclic-special-mid", m.label = "", m.startLabelRight = "", m.startLabelLeft = "", m.arrowTypeStart = "none", a.isGroup && (n.fromCluster = r, m.toCluster = r), m.id = r + "-cyclic-special-2", m.arrowTypeStart = "none", g.setEdge(r, f, n, r + "-cyclic-special-0"), g.setEdge(f, h, p, r + "-cyclic-special-1"), g.setEdge(h, r, m, r + "-cyclic-special-2");
+    } else
+      g.setEdge(o.start, o.end, { ...o }, o.id);
+  }), l.warn("Graph at first:", JSON.stringify(I(g))), J(g), l.warn("Graph after XAX:", JSON.stringify(I(g)));
+  const c = _();
+  await T(
+    y,
+    g,
+    s.type,
+    s.diagramId,
+    void 0,
+    c
+  );
+}, "render");
+export {
+  ne as getEdgesToRender,
+  de as render
+};