@orangelogic/design-system 2.162.0 → 2.164.0

package/library/chunks/sankey.BR94A-8L.js

@@ -0,0 +1,294 @@
+function D(r, u) {
+  let c;
+  if (u === void 0)
+    for (const s of r)
+      s != null && (c < s || c === void 0 && s >= s) && (c = s);
+  else {
+    let s = -1;
+    for (let l of r)
+      (l = u(l, ++s, r)) != null && (c < l || c === void 0 && l >= l) && (c = l);
+  }
+  return c;
+}
+function $(r, u) {
+  let c;
+  if (u === void 0)
+    for (const s of r)
+      s != null && (c > s || c === void 0 && s >= s) && (c = s);
+  else {
+    let s = -1;
+    for (let l of r)
+      (l = u(l, ++s, r)) != null && (c > l || c === void 0 && l >= l) && (c = l);
+  }
+  return c;
+}
+function z(r, u) {
+  let c = 0;
+  if (u === void 0)
+    for (let s of r)
+      (s = +s) && (c += s);
+  else {
+    let s = -1;
+    for (let l of r)
+      (l = +u(l, ++s, r)) && (c += l);
+  }
+  return c;
+}
+function nn(r) {
+  return r.target.depth;
+}
+function fn(r) {
+  return r.depth;
+}
+function un(r, u) {
+  return u - 1 - r.height;
+}
+function tn(r, u) {
+  return r.sourceLinks.length ? r.depth : u - 1;
+}
+function sn(r) {
+  return r.targetLinks.length ? r.depth : r.sourceLinks.length ? $(r.sourceLinks, nn) - 1 : 0;
+}
+function S(r) {
+  return function() {
+    return r;
+  };
+}
+function R(r, u) {
+  return v(r.source, u.source) || r.index - u.index;
+}
+function H(r, u) {
+  return v(r.target, u.target) || r.index - u.index;
+}
+function v(r, u) {
+  return r.y0 - u.y0;
+}
+function C(r) {
+  return r.value;
+}
+function en(r) {
+  return r.index;
+}
+function on(r) {
+  return r.nodes;
+}
+function rn(r) {
+  return r.links;
+}
+function P(r, u) {
+  const c = r.get(u);
+  if (!c) throw new Error("missing: " + u);
+  return c;
+}
+function W({ nodes: r }) {
+  for (const u of r) {
+    let c = u.y0, s = c;
+    for (const l of u.sourceLinks)
+      l.y0 = c + l.width / 2, c += l.width;
+    for (const l of u.targetLinks)
+      l.y1 = s + l.width / 2, s += l.width;
+  }
+}
+function cn() {
+  let r = 0, u = 0, c = 1, s = 1, l = 24, B = 8, g, N = en, T = tn, k, h, M = on, b = rn, w = 6;
+  function d() {
+    const n = { nodes: M.apply(null, arguments), links: b.apply(null, arguments) };
+    return q(n), F(n), G(n), J(n), Q(n), W(n), n;
+  }
+  d.update = function(n) {
+    return W(n), n;
+  }, d.nodeId = function(n) {
+    return arguments.length ? (N = typeof n == "function" ? n : S(n), d) : N;
+  }, d.nodeAlign = function(n) {
+    return arguments.length ? (T = typeof n == "function" ? n : S(n), d) : T;
+  }, d.nodeSort = function(n) {
+    return arguments.length ? (k = n, d) : k;
+  }, d.nodeWidth = function(n) {
+    return arguments.length ? (l = +n, d) : l;
+  }, d.nodePadding = function(n) {
+    return arguments.length ? (B = g = +n, d) : B;
+  }, d.nodes = function(n) {
+    return arguments.length ? (M = typeof n == "function" ? n : S(n), d) : M;
+  }, d.links = function(n) {
+    return arguments.length ? (b = typeof n == "function" ? n : S(n), d) : b;
+  }, d.linkSort = function(n) {
+    return arguments.length ? (h = n, d) : h;
+  }, d.size = function(n) {
+    return arguments.length ? (r = u = 0, c = +n[0], s = +n[1], d) : [c - r, s - u];
+  }, d.extent = function(n) {
+    return arguments.length ? (r = +n[0][0], c = +n[1][0], u = +n[0][1], s = +n[1][1], d) : [[r, u], [c, s]];
+  }, d.iterations = function(n) {
+    return arguments.length ? (w = +n, d) : w;
+  };
+  function q({ nodes: n, links: i }) {
+    for (const [o, t] of n.entries())
+      t.index = o, t.sourceLinks = [], t.targetLinks = [];
+    const e = new Map(n.map((o, t) => [N(o, t, n), o]));
+    for (const [o, t] of i.entries()) {
+      t.index = o;
+      let { source: f, target: a } = t;
+      typeof f != "object" && (f = t.source = P(e, f)), typeof a != "object" && (a = t.target = P(e, a)), f.sourceLinks.push(t), a.targetLinks.push(t);
+    }
+    if (h != null)
+      for (const { sourceLinks: o, targetLinks: t } of n)
+        o.sort(h), t.sort(h);
+  }
+  function F({ nodes: n }) {
+    for (const i of n)
+      i.value = i.fixedValue === void 0 ? Math.max(z(i.sourceLinks, C), z(i.targetLinks, C)) : i.fixedValue;
+  }
+  function G({ nodes: n }) {
+    const i = n.length;
+    let e = new Set(n), o = /* @__PURE__ */ new Set(), t = 0;
+    for (; e.size; ) {
+      for (const f of e) {
+        f.depth = t;
+        for (const { target: a } of f.sourceLinks)
+          o.add(a);
+      }
+      if (++t > i) throw new Error("circular link");
+      e = o, o = /* @__PURE__ */ new Set();
+    }
+  }
+  function J({ nodes: n }) {
+    const i = n.length;
+    let e = new Set(n), o = /* @__PURE__ */ new Set(), t = 0;
+    for (; e.size; ) {
+      for (const f of e) {
+        f.height = t;
+        for (const { source: a } of f.targetLinks)
+          o.add(a);
+      }
+      if (++t > i) throw new Error("circular link");
+      e = o, o = /* @__PURE__ */ new Set();
+    }
+  }
+  function K({ nodes: n }) {
+    const i = D(n, (t) => t.depth) + 1, e = (c - r - l) / (i - 1), o = new Array(i);
+    for (const t of n) {
+      const f = Math.max(0, Math.min(i - 1, Math.floor(T.call(null, t, i))));
+      t.layer = f, t.x0 = r + f * e, t.x1 = t.x0 + l, o[f] ? o[f].push(t) : o[f] = [t];
+    }
+    if (k) for (const t of o)
+      t.sort(k);
+    return o;
+  }
+  function O(n) {
+    const i = $(n, (e) => (s - u - (e.length - 1) * g) / z(e, C));
+    for (const e of n) {
+      let o = u;
+      for (const t of e) {
+        t.y0 = o, t.y1 = o + t.value * i, o = t.y1 + g;
+        for (const f of t.sourceLinks)
+          f.width = f.value * i;
+      }
+      o = (s - o + g) / (e.length + 1);
+      for (let t = 0; t < e.length; ++t) {
+        const f = e[t];
+        f.y0 += o * (t + 1), f.y1 += o * (t + 1);
+      }
+      Y(e);
+    }
+  }
+  function Q(n) {
+    const i = K(n);
+    g = Math.min(B, (s - u) / (D(i, (e) => e.length) - 1)), O(i);
+    for (let e = 0; e < w; ++e) {
+      const o = Math.pow(0.99, e), t = Math.max(1 - o, (e + 1) / w);
+      X(i, o, t), U(i, o, t);
+    }
+  }
+  function U(n, i, e) {
+    for (let o = 1, t = n.length; o < t; ++o) {
+      const f = n[o];
+      for (const a of f) {
+        let m = 0, y = 0;
+        for (const { source: p, value: j } of a.targetLinks) {
+          let x = j * (a.layer - p.layer);
+          m += Z(p, a) * x, y += x;
+        }
+        if (!(y > 0)) continue;
+        let L = (m / y - a.y0) * i;
+        a.y0 += L, a.y1 += L, A(a);
+      }
+      k === void 0 && f.sort(v), E(f, e);
+    }
+  }
+  function X(n, i, e) {
+    for (let o = n.length, t = o - 2; t >= 0; --t) {
+      const f = n[t];
+      for (const a of f) {
+        let m = 0, y = 0;
+        for (const { target: p, value: j } of a.sourceLinks) {
+          let x = j * (p.layer - a.layer);
+          m += _(a, p) * x, y += x;
+        }
+        if (!(y > 0)) continue;
+        let L = (m / y - a.y0) * i;
+        a.y0 += L, a.y1 += L, A(a);
+      }
+      k === void 0 && f.sort(v), E(f, e);
+    }
+  }
+  function E(n, i) {
+    const e = n.length >> 1, o = n[e];
+    V(n, o.y0 - g, e - 1, i), I(n, o.y1 + g, e + 1, i), V(n, s, n.length - 1, i), I(n, u, 0, i);
+  }
+  function I(n, i, e, o) {
+    for (; e < n.length; ++e) {
+      const t = n[e], f = (i - t.y0) * o;
+      f > 1e-6 && (t.y0 += f, t.y1 += f), i = t.y1 + g;
+    }
+  }
+  function V(n, i, e, o) {
+    for (; e >= 0; --e) {
+      const t = n[e], f = (t.y1 - i) * o;
+      f > 1e-6 && (t.y0 -= f, t.y1 -= f), i = t.y0 - g;
+    }
+  }
+  function A({ sourceLinks: n, targetLinks: i }) {
+    if (h === void 0) {
+      for (const { source: { sourceLinks: e } } of i)
+        e.sort(H);
+      for (const { target: { targetLinks: e } } of n)
+        e.sort(R);
+    }
+  }
+  function Y(n) {
+    if (h === void 0)
+      for (const { sourceLinks: i, targetLinks: e } of n)
+        i.sort(H), e.sort(R);
+  }
+  function Z(n, i) {
+    let e = n.y0 - (n.sourceLinks.length - 1) * g / 2;
+    for (const { target: o, width: t } of n.sourceLinks) {
+      if (o === i) break;
+      e += t + g;
+    }
+    for (const { source: o, width: t } of i.targetLinks) {
+      if (o === n) break;
+      e -= t;
+    }
+    return e;
+  }
+  function _(n, i) {
+    let e = i.y0 - (i.targetLinks.length - 1) * g / 2;
+    for (const { source: o, width: t } of i.targetLinks) {
+      if (o === n) break;
+      e += t + g;
+    }
+    for (const { target: o, width: t } of n.sourceLinks) {
+      if (o === i) break;
+      e -= t;
+    }
+    return e;
+  }
+  return d;
+}
+export {
+  cn as S,
+  sn as c,
+  tn as j,
+  fn as l,
+  un as r
+};