@graphysdk/geom-sankey 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,611 @@
+import { Dataset as H, Geom as B, GeomPath as U, GeomRect as X, Stat as R, UserInputError as j, createValueFormatter as z, defineGeomRenderer as q, defineGeomStyleTarget as J, readVariableName as m, toPaintColor as O, toPercent as b, token as N, useGraphLocale as Z, usePaintDefs as I, useSceneSelector as Q } from "@graphysdk/react";
+import { sankey as ee, sankeyCenter as te, sankeyJustify as re, sankeyLeft as ne, sankeyRight as ae } from "d3-sankey";
+import { useMemo as T } from "react";
+import { Fragment as Y, jsx as g, jsxs as C } from "react/jsx-runtime";
+var i = {
+  kind: "sankeyKind",
+  nodeName: "sankeyNodeName",
+  observationKey: "sankeyObservationKey",
+  nodeKey: "sankeyNodeKey",
+  targetKey: "sankeyTargetKey",
+  x0: "sankeyX0",
+  x1: "sankeyX1",
+  y0: "sankeyY0",
+  y1: "sankeyY1",
+  targetY0: "sankeyTargetY0",
+  targetY1: "sankeyTargetY1"
+}, k = (e, t) => {
+  const n = e[t];
+  return typeof n == "number" && Number.isFinite(n) ? n : null;
+}, L = (e) => {
+  const t = e[i.observationKey], n = e[i.nodeKey], a = k(e, i.x0), o = k(e, i.x1), r = k(e, i.y0), s = k(e, i.y1);
+  if (typeof t != "string" || typeof n != "string" || a === null || o === null || r === null || s === null) return null;
+  switch (e[i.kind]) {
+    case "node":
+      return {
+        kind: "node",
+        observation: e,
+        key: t,
+        nodeKey: n,
+        x0: a,
+        x1: o,
+        y0: r,
+        y1: s
+      };
+    case "flow": {
+      const l = k(e, i.targetY0), u = k(e, i.targetY1), c = e[i.targetKey];
+      return l === null || u === null || typeof c != "string" ? null : {
+        kind: "flow",
+        observation: e,
+        key: t,
+        nodeKey: n,
+        targetKey: c,
+        x0: a,
+        x1: o,
+        y0: r,
+        y1: s,
+        targetY0: l,
+        targetY1: u
+      };
+    }
+    default:
+      return null;
+  }
+}, P = /* @__PURE__ */ new WeakMap(), A = (e) => {
+  const t = P.get(e);
+  if (t !== void 0) return t;
+  const n = [], a = [];
+  for (const r of e) {
+    const s = L(r);
+    s?.kind === "node" && n.push(s), s?.kind === "flow" && a.push(s);
+  }
+  const o = {
+    nodes: n,
+    flows: a
+  };
+  return P.set(e, o), o;
+}, _ = (e, t) => e.nodeKey === t.nodeKey || e.targetKey === t.nodeKey, oe = (e) => e * e * (3 - 2 * e), M = (e, t) => {
+  const n = oe(t);
+  return {
+    top: e.y0 + (e.targetY0 - e.y0) * n,
+    bottom: e.y1 + (e.targetY1 - e.y1) * n
+  };
+}, se = (e, t) => {
+  const n = e.x1 - e.x0;
+  if (n <= 0 || t.x < e.x0 || t.x > e.x1) return !1;
+  const { top: a, bottom: o } = M(e, (t.x - e.x0) / n);
+  return t.y >= a && t.y <= o;
+}, W = (e, t) => {
+  const n = (u) => u * t.width, a = (u) => u * t.height, o = n(e.x0), r = n(e.x1), s = n(e.x0 + (e.x1 - e.x0) / 3), l = n(e.x0 + (e.x1 - e.x0) * 2 / 3);
+  return [
+    `M${o},${a(e.y0)}`,
+    `C${s},${a(e.y0)} ${l},${a(e.targetY0)} ${r},${a(e.targetY0)}`,
+    `L${r},${a(e.targetY1)}`,
+    `C${l},${a(e.targetY1)} ${s},${a(e.y1)} ${o},${a(e.y1)}`,
+    "Z"
+  ].join("");
+}, ie = 0.018, le = 0.03, ue = {
+  justify: re,
+  left: ne,
+  right: ae,
+  center: te
+}, ce = (e, t) => {
+  const n = ye(e);
+  if (n.length === 0) return {
+    nodes: [],
+    flows: []
+  };
+  const a = [...new Set(n.flatMap((r) => [r.source, r.target]))], o = ee().nodeId((r) => r.key).nodeAlign(ue[t]).nodeWidth(ie).nodePadding(le).extent([[0, 0], [1, 1]])({
+    nodes: a.map((r) => ({ key: r })),
+    links: n.map((r) => ({
+      source: r.source,
+      target: r.target,
+      value: r.value,
+      link: r
+    }))
+  });
+  return {
+    nodes: o.nodes.map((r) => ({
+      key: r.key,
+      value: r.value ?? 0,
+      x0: p(r.x0),
+      x1: p(r.x1),
+      y0: p(r.y0),
+      y1: p(r.y1)
+    })),
+    flows: o.links.map((r) => {
+      const s = r.source, l = r.target, u = (r.width ?? 0) / 2;
+      return {
+        link: r.link,
+        x0: p(s.x1),
+        x1: p(l.x0),
+        y0: p((r.y0 ?? 0) - u),
+        y1: p((r.y0 ?? 0) + u),
+        targetY0: p((r.y1 ?? 0) - u),
+        targetY1: p((r.y1 ?? 0) + u)
+      };
+    })
+  };
+}, p = (e) => Math.min(1, Math.max(0, e ?? 0)), ye = (e) => {
+  const t = /* @__PURE__ */ new Map(), n = (a, o) => {
+    const r = /* @__PURE__ */ new Set(), s = [a];
+    for (; s.length > 0; ) {
+      const l = s.pop();
+      if (l === o) return !0;
+      r.has(l) || (r.add(l), s.push(...t.get(l) ?? []));
+    }
+    return !1;
+  };
+  return e.filter((a) => t.get(a.source)?.has(a.target) === !0 ? !0 : n(a.target, a.source) ? !1 : (t.set(a.source, (t.get(a.source) ?? /* @__PURE__ */ new Set()).add(a.target)), !0));
+}, D = /* @__PURE__ */ new Set(["node"]), G = ["color", "alpha"], de = [
+  "justify",
+  "left",
+  "right",
+  "center"
+], ge = class extends R {
+  constructor(...e) {
+    super(...e), this.type = "sankey", this.computedVariables = D;
+  }
+  computeStat({ data: e, mapping: t, params: n }) {
+    const a = xe(e, t);
+    return a === null ? {
+      data: e,
+      mapping: {}
+    } : (fe(e, a), {
+      data: Ne(e, a, me(n)),
+      mapping: {
+        node: i.nodeName,
+        ...ve(t, a)
+      }
+    });
+  }
+}, ve = (e, t) => {
+  const n = {};
+  for (const a of G) {
+    const o = he(a, e[a], t);
+    o !== null && (n[a] = o);
+  }
+  return n;
+}, he = (e, t, { sourceVariable: n, targetVariable: a }) => {
+  if (t === void 0) return e === "color" ? i.nodeKey : null;
+  const o = m(t);
+  return o === n ? i.nodeKey : o === a ? i.targetKey : null;
+}, pe = (e) => de.includes(e), me = (e) => {
+  const t = e?.align;
+  return pe(t) ? t : "justify";
+}, $ = (e, t) => e === null ? null : e instanceof Date ? t.type === "year" ? String(e.getUTCFullYear()) : e.toISOString() : String(e), fe = (e, { valueVariable: t }) => {
+  const n = e.getType(t);
+  if (!(e.size() === 0 || n === "numeric"))
+    throw new j({
+      code: "INCOMPATIBLE_TYPE",
+      message: `'sankey' stat requires a numeric 'value' (got '${n}' for variable '${t}')`,
+      context: {
+        aesthetic: "value",
+        variableName: t,
+        variableType: n
+      },
+      suggestion: "Map each flow's amount to 'value', declaring the column numeric if it holds whole years."
+    });
+}, xe = (e, t) => {
+  const n = m(t.source), a = m(t.target), o = m(t.value);
+  return n === null || a === null || o === null || ![
+    n,
+    a,
+    o
+  ].every((r) => e.hasVariable(r)) ? null : {
+    sourceVariable: n,
+    targetVariable: a,
+    valueVariable: o
+  };
+}, ke = (e, { sourceVariable: t, targetVariable: n, valueVariable: a }) => {
+  const o = e.getValues(t), r = e.getValues(n), s = e.getValues(a, { type: "numeric" }), l = e.getValueFormat(t), u = e.getValueFormat(n), c = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), y = [];
+  return o.forEach((v, h) => {
+    const S = r[h] ?? null, f = $(v, l), x = $(S, u);
+    if (f === null || x === null) return;
+    d.set(f, v), d.set(x, S);
+    const F = JSON.stringify([f, x]), V = c.get(F) ?? 0;
+    c.set(F, V + 1);
+    const K = s[h];
+    typeof K != "number" || !Number.isFinite(K) || K <= 0 || y.push({
+      source: f,
+      target: x,
+      value: K,
+      row: h,
+      occurrence: V
+    });
+  }), {
+    links: y,
+    names: d
+  };
+}, w = (e, { sourceVariable: t, targetVariable: n }) => e.getType(t) === e.getType(n), be = (e, t, n, a) => {
+  const o = e.getType(t.sourceVariable);
+  return w(e, t) ? {
+    type: o,
+    values: n.map((r) => a.get(r) ?? null),
+    valueFormat: e.getValueFormat(t.sourceVariable)
+  } : {
+    type: "categorical",
+    values: [...n]
+  };
+}, Se = (e, t, n, a, o) => e === n.valueVariable ? a.nodes.map((r) => r.value) : e === n.sourceVariable && w(t, n) ? a.nodes.map((r) => o.get(r.key) ?? null) : null, Ne = (e, t, n) => {
+  const { links: a, names: o } = ke(e, t), r = ce(a, n), s = r.nodes.length, l = (y) => [...y, ...Array.from({ length: s }, () => null)], u = e.getVariableNames(), c = Object.fromEntries(u.map((y) => {
+    const v = e.getValues(y), h = r.flows.map(({ link: x }) => v[x.row] ?? null), S = Se(y, e, t, r, o), f = S === null ? l(h) : [...h, ...S];
+    return [y, {
+      type: e.getType(y),
+      values: f,
+      valueFormat: e.getValueFormat(y)
+    }];
+  })), d = [...r.flows.map(({ link: y }) => y.source), ...r.nodes.map(({ key: y }) => y)];
+  return new H({
+    ...c,
+    ...Ae(r),
+    [i.nodeName]: be(e, t, d, o)
+  });
+}, Ae = (e) => {
+  const t = e.flows.map(({ link: l, ...u }) => ({
+    [i.kind]: "flow",
+    [i.observationKey]: JSON.stringify([
+      "flow",
+      l.source,
+      l.target,
+      l.occurrence
+    ]),
+    [i.nodeKey]: l.source,
+    [i.targetKey]: l.target,
+    [i.x0]: u.x0,
+    [i.x1]: u.x1,
+    [i.y0]: u.y0,
+    [i.y1]: u.y1,
+    [i.targetY0]: u.targetY0,
+    [i.targetY1]: u.targetY1
+  })), n = e.nodes.map((l) => ({
+    [i.kind]: "node",
+    [i.observationKey]: JSON.stringify(["node", l.key]),
+    [i.nodeKey]: l.key,
+    [i.targetKey]: l.key,
+    [i.x0]: l.x0,
+    [i.x1]: l.x1,
+    [i.y0]: l.y0,
+    [i.y1]: l.y1,
+    [i.targetY0]: null,
+    [i.targetY1]: null
+  })), a = [...t, ...n], o = (l) => a.map((u) => u[l]), r = (l) => ({
+    type: "categorical",
+    values: o(l)
+  }), s = (l) => ({
+    type: "numeric",
+    values: o(l)
+  });
+  return {
+    [i.kind]: r(i.kind),
+    [i.observationKey]: r(i.observationKey),
+    [i.nodeKey]: r(i.nodeKey),
+    [i.targetKey]: r(i.targetKey),
+    [i.x0]: s(i.x0),
+    [i.x1]: s(i.x1),
+    [i.y0]: s(i.y0),
+    [i.y1]: s(i.y1),
+    [i.targetY0]: s(i.targetY0),
+    [i.targetY1]: s(i.targetY1)
+  };
+}, Ke = 0.4, Oe = 0.65, Te = 12, Ye = 3, Ce = {}, Le = {
+  fill: "paint",
+  fillAlpha: "unitInterval",
+  alpha: "unitInterval",
+  stroke: "color",
+  strokeWidth: "pixels"
+}, Ee = {
+  fontFamily: "fontFamily",
+  fontSize: "pixels",
+  fontWeight: "fontWeight",
+  textColor: "color",
+  textOutlineColor: "color",
+  textOutlineWidth: "pixels"
+}, Fe = class extends B {
+  constructor(...e) {
+    super(...e), this.type = "sankey", this.defaultParams = { align: "justify" }, this.defaultStat = new ge(), this.aesthetics = [
+      {
+        kind: "data",
+        name: "source",
+        required: !0
+      },
+      {
+        kind: "data",
+        name: "target",
+        required: !0
+      },
+      {
+        kind: "data",
+        name: "value",
+        required: !0
+      },
+      {
+        kind: "data",
+        name: "node"
+      },
+      {
+        kind: "visual",
+        name: "color"
+      },
+      {
+        kind: "visual",
+        name: "alpha"
+      }
+    ], this.identityKey = { variable: i.observationKey }, this.supportedPositions = ["identity"], this.supportedCoordTypes = ["cartesian"], this.legend = { defaultPosition: "none" }, this.spatialKind = "render-hit-test", this.highlightStrategy = "observation-rerender", this.tooltip = [
+      {
+        aes: "node",
+        heading: !0
+      },
+      { aes: "target" },
+      { aes: "value" }
+    ], this.styleTarget = J({
+      observation: {
+        vocabulary: Ce,
+        aesthetics: {
+          fill: "color",
+          alpha: "alpha"
+        },
+        rest: {
+          fill: N("geom"),
+          fillAlpha: Ke
+        },
+        hovered: { fillAlpha: Oe }
+      },
+      parts: {
+        node: {
+          vocabulary: Le,
+          aesthetics: {
+            fill: "color",
+            alpha: "alpha"
+          },
+          rest: {
+            fill: N("geom"),
+            fillAlpha: 1,
+            alpha: 1,
+            stroke: N("graphBackground"),
+            strokeWidth: 0
+          }
+        },
+        label: {
+          vocabulary: Ee,
+          rest: {
+            fontSize: Te,
+            fontWeight: 500,
+            textColor: N("textPrimary"),
+            textOutlineColor: N("graphBackground"),
+            textOutlineWidth: Ye
+          }
+        }
+      }
+    }), this.resolveValueSource = (t) => t.value ?? null, this.validateMapping = ({ mapping: t, computedVariables: n }) => {
+      if (!n.has("node")) return [{
+        code: "MISSING_STAT_OUTPUT",
+        message: "sankey geom lays its flows out in the 'sankey' stat; remove the layer's stat"
+      }];
+      const a = [...D].filter((s) => t[s] !== void 0).map((s) => ({
+        code: "CONFLICTING_STAT_MAPPING",
+        message: `sankey stat computes '${s}' from 'source' and 'target'; remove its mapping`
+      })), o = [m(t.source), m(t.target)], r = G.flatMap((s) => {
+        const l = m(t[s]);
+        return l === null || o.includes(l) ? [] : [{
+          code: "UNSUPPORTED_MAPPING",
+          message: `sankey geom scales '${s}' by node; map it to the source or target column rather than '${l}'`
+        }];
+      });
+      return [...a, ...r];
+    }, this.resolveAnchorPosition = (t) => {
+      const n = L(t);
+      if (n === null) return null;
+      if (n.kind === "node") return {
+        x: (n.x0 + n.x1) / 2,
+        y: 1 - (n.y0 + n.y1) / 2
+      };
+      const { top: a, bottom: o } = M(n, 0.5);
+      return {
+        x: (n.x0 + n.x1) / 2,
+        y: 1 - (a + o) / 2
+      };
+    };
+  }
+  compile({ data: e }) {
+    return {
+      data: e,
+      mapping: {}
+    };
+  }
+}, Ve = ({ layer: e, panelRect: t }) => {
+  const { nodes: n, flows: a } = A(e.data), o = (s) => s * t.width, r = (s) => s * t.height;
+  return [...a.map((s) => ({
+    kind: "region",
+    pathData: W(s, t)
+  })), ...n.map((s) => ({
+    kind: "region",
+    pathData: `M${o(s.x0)},${r(s.y0)}H${o(s.x1)}V${r(s.y1)}H${o(s.x0)}Z`
+  }))];
+}, Pe = ({ flows: e, size: t, source: n, styleReaders: a, isHovered: o = !1, shouldAnimateTransitions: r = !1 }) => {
+  const s = o ? "hovered" : void 0, l = T(() => e.map((d) => a.get("fill", d.observation, s) ?? "transparent"), [
+    e,
+    a,
+    s
+  ]), { fillFor: u, defs: c } = I({ paints: l });
+  return /* @__PURE__ */ C(Y, { children: [c, e.map((d, y) => {
+    const v = l[y], h = a.get("stroke", d.observation, s);
+    return /* @__PURE__ */ g(U, {
+      "data-testid": "sankey-flow",
+      d: W(d, t),
+      source: n,
+      fill: v === void 0 ? void 0 : u(v),
+      opacity: a.get("alpha", d.observation, s),
+      fillOpacity: a.get("fillAlpha", d.observation, s),
+      stroke: h === void 0 ? void 0 : O(h),
+      strokeOpacity: a.get("strokeAlpha", d.observation, s),
+      shouldAnimateTransitions: r
+    }, d.key);
+  })] });
+}, _e = 6, $e = (e) => {
+  const t = (e.y0 + e.y1) / 2;
+  return (e.x0 + e.x1) / 2 < 0.5 ? {
+    x: e.x1,
+    y: t,
+    offsetX: _e,
+    textAnchor: "start"
+  } : {
+    x: e.x0,
+    y: t,
+    offsetX: -6,
+    textAnchor: "end"
+  };
+}, Ie = ({ nodes: e, valueFormat: t, styleReaders: n, isHovered: a = !1 }) => {
+  const o = a ? "hovered" : void 0, r = n.part("label"), s = Z(), l = Q((c) => c.config.numberFormat), u = T(() => z({
+    valueFormat: t,
+    locale: s,
+    numberFormat: l
+  }), [
+    t,
+    s,
+    l
+  ]);
+  return /* @__PURE__ */ g("g", {
+    pointerEvents: "none",
+    children: e.map((c) => {
+      const d = c.observation[i.nodeName];
+      if (d == null) return null;
+      const y = $e(c), v = r?.get("textColor", c.observation, o), h = r?.get("textOutlineColor", c.observation, o);
+      return /* @__PURE__ */ g("text", {
+        "data-testid": "sankey-label",
+        x: b(y.x),
+        y: b(y.y),
+        dx: y.offsetX,
+        textAnchor: y.textAnchor,
+        dominantBaseline: "central",
+        fontFamily: r?.get("fontFamily", c.observation, o),
+        fontSize: r?.get("fontSize", c.observation, o),
+        fontWeight: r?.get("fontWeight", c.observation, o),
+        fill: v === void 0 ? void 0 : O(v),
+        stroke: h === void 0 ? void 0 : O(h),
+        strokeWidth: r?.get("textOutlineWidth", c.observation, o),
+        strokeLinejoin: "round",
+        paintOrder: "stroke",
+        children: u(d, c.observation)
+      }, c.key);
+    })
+  });
+}, Me = ({ nodes: e, styleReaders: t, isHovered: n = !1, shouldAnimateTransitions: a = !1 }) => {
+  const o = n ? "hovered" : void 0, r = t.part("node"), s = T(() => e.map((c) => r?.get("fill", c.observation, o) ?? "transparent"), [
+    e,
+    r,
+    o
+  ]), { fillFor: l, defs: u } = I({ paints: s });
+  return /* @__PURE__ */ C(Y, { children: [u, e.map((c, d) => {
+    const y = s[d], v = r?.get("stroke", c.observation, o);
+    return /* @__PURE__ */ g(X, {
+      "data-testid": "sankey-node",
+      x: b(c.x0),
+      y: b(c.y0),
+      width: b(c.x1 - c.x0),
+      height: b(c.y1 - c.y0),
+      fill: y === void 0 ? void 0 : l(y),
+      opacity: r?.get("alpha", c.observation, o),
+      fillOpacity: r?.get("fillAlpha", c.observation, o),
+      stroke: v === void 0 ? void 0 : O(v),
+      strokeWidth: r?.get("strokeWidth", c.observation, o),
+      shouldAnimateTransitions: a
+    }, c.key);
+  })] });
+}, We = { type: "text" }, E = ({ observations: e, layer: t, size: n, styleReaders: a, isHovered: o = !1, shouldAnimateTransitions: r = !1 }) => /* @__PURE__ */ C(Y, { children: [
+  /* @__PURE__ */ g(Pe, {
+    flows: e.flows,
+    size: n,
+    source: t,
+    styleReaders: a,
+    isHovered: o,
+    shouldAnimateTransitions: r
+  }),
+  /* @__PURE__ */ g(Me, {
+    nodes: e.nodes,
+    styleReaders: a,
+    isHovered: o,
+    shouldAnimateTransitions: r
+  }),
+  /* @__PURE__ */ g(Ie, {
+    nodes: e.nodes,
+    valueFormat: t.data.hasVariable(i.nodeName) ? t.data.getValueFormat(i.nodeName) : We,
+    styleReaders: a,
+    isHovered: o
+  })
+] }), De = ({ layer: e, size: t, styleReaders: n }) => /* @__PURE__ */ g(E, {
+  observations: A(e.data),
+  layer: e,
+  size: t,
+  styleReaders: n
+}), Ge = ({ layer: e }) => {
+  const { nodes: t, flows: n } = A(e.data), a = [...t].reverse(), o = [...n].reverse();
+  return (r) => {
+    const s = a.find((u) => r.x >= u.x0 && r.x <= u.x1 && r.y >= u.y0 && r.y <= u.y1);
+    if (s !== void 0) return { key: s.key };
+    const l = o.find((u) => se(u, r));
+    return l === void 0 ? null : { key: l.key };
+  };
+}, we = ({ layer: e, primary: t, size: n, styleReaders: a }) => {
+  const o = A(e.data), r = t.observation;
+  return /* @__PURE__ */ g("g", {
+    "data-testid": "hovered-observations",
+    children: /* @__PURE__ */ g(E, {
+      observations: T(() => He(o, r), [o, r]),
+      layer: e,
+      size: n,
+      styleReaders: a,
+      isHovered: !0
+    })
+  });
+}, He = (e, t) => {
+  const n = L(t);
+  if (n === null) return {
+    nodes: [],
+    flows: []
+  };
+  if (n.kind === "node") {
+    const a = e.flows.filter((r) => _(r, n)), o = new Set(a.flatMap((r) => [r.nodeKey, r.targetKey]));
+    return {
+      nodes: e.nodes.filter((r) => o.has(r.nodeKey)),
+      flows: a
+    };
+  }
+  return {
+    nodes: e.nodes.filter((a) => _(n, a)),
+    flows: [n]
+  };
+}, Be = ({ layer: e, size: t, styleReaders: n, shouldAnimateTransitions: a }) => /* @__PURE__ */ g(E, {
+  observations: A(e.data),
+  layer: e,
+  size: t,
+  styleReaders: n,
+  shouldAnimateTransitions: a
+}), ze = q(new Fe(), {
+  coord: "cartesian",
+  swatchShape: "square",
+  render: ({ layer: e, panelRect: t, styleReaders: n, shouldAnimateTransitions: a }) => /* @__PURE__ */ g(Be, {
+    layer: e,
+    size: t,
+    styleReaders: n,
+    shouldAnimateTransitions: a
+  }),
+  renderHighlight: ({ layer: e, panelRect: t, styleReaders: n }) => /* @__PURE__ */ g(De, {
+    layer: e,
+    size: t,
+    styleReaders: n
+  }),
+  renderHover: ({ layer: e, primary: t, panelRect: n, styleReaders: a }) => /* @__PURE__ */ g(we, {
+    layer: e,
+    primary: t,
+    size: n,
+    styleReaders: a
+  }),
+  renderHoverCompanions: () => null,
+  hitTest: Ge,
+  getEditOutlineShapes: Ve
+});
+export {
+  Fe as SankeyGeom,
+  ze as sankey
+};

package/dist/renderer/paint/sankey-flows.d.ts

@@ -0,0 +1,17 @@
+import { GeomStyleReaders, SceneLayer } from '@graphysdk/react';
+import { SankeyFlowObservation } from '../../utils/read-sankey';
+export interface SankeyFlowsProps {
+    flows: readonly SankeyFlowObservation[];
+    /** The panel's size in pixels: a ribbon is a path, which has no percentage units. */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** The layer the ribbons are drawn from, so a resize redraws them in place and only new data morphs them. */
+    source: SceneLayer;
+    styleReaders: GeomStyleReaders;
+    isHovered?: boolean;
+    shouldAnimateTransitions?: boolean;
+}
+/** Each flow as a filled ribbon, painted through the observations' readers. */
+export declare const SankeyFlows: ({ flows, size, source, styleReaders, isHovered, shouldAnimateTransitions, }: SankeyFlowsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/renderer/paint/sankey-labels.d.ts

@@ -0,0 +1,14 @@
+import { GeomStyleReaders, ValueFormat } from '@graphysdk/react';
+import { SankeyNodeObservation } from '../../utils/read-sankey';
+export interface SankeyLabelsProps {
+    nodes: readonly SankeyNodeObservation[];
+    /** The node names' format. */
+    valueFormat: ValueFormat;
+    styleReaders: GeomStyleReaders;
+    isHovered?: boolean;
+}
+/**
+ * Each node's name beside it, painted through the `label` part's readers. The outline, in the background's color
+ * by default, keeps a name legible where it crosses a flow.
+ */
+export declare const SankeyLabels: ({ nodes, valueFormat, styleReaders, isHovered }: SankeyLabelsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/renderer/paint/sankey-nodes.d.ts

@@ -0,0 +1,10 @@
+import { GeomStyleReaders } from '@graphysdk/react';
+import { SankeyNodeObservation } from '../../utils/read-sankey';
+export interface SankeyNodesProps {
+    nodes: readonly SankeyNodeObservation[];
+    styleReaders: GeomStyleReaders;
+    isHovered?: boolean;
+    shouldAnimateTransitions?: boolean;
+}
+/** Each node as its box, painted through the `node` part's readers. */
+export declare const SankeyNodes: ({ nodes, styleReaders, isHovered, shouldAnimateTransitions, }: SankeyNodesProps) => import("react/jsx-runtime").JSX.Element;

package/dist/renderer/paint/sankey-paint.d.ts

@@ -0,0 +1,16 @@
+import { GeomStyleReaders, SceneLayer } from '@graphysdk/react';
+import { SankeyObservations } from '../../utils/read-sankey';
+export interface SankeyPaintProps {
+    observations: SankeyObservations;
+    /** The layer the observations were read from: the node names' format, and what a ribbon morph is keyed to. */
+    layer: SceneLayer;
+    size: {
+        width: number;
+        height: number;
+    };
+    styleReaders: GeomStyleReaders;
+    isHovered?: boolean;
+    shouldAnimateTransitions?: boolean;
+}
+/** The flows, the nodes over their ends, and the names over both. */
+export declare const SankeyPaint: ({ observations, layer, size, styleReaders, isHovered, shouldAnimateTransitions, }: SankeyPaintProps) => import("react/jsx-runtime").JSX.Element;

package/dist/renderer/sankey-edit-outline.d.ts

@@ -0,0 +1,3 @@
+import { EditOutlineShape, GeomEditOutlineShapesRendererInput } from '@graphysdk/react';
+/** A node outlines as its box, a flow as its ribbon. */
+export declare const getSankeyEditOutlineShapes: ({ layer, panelRect, }: GeomEditOutlineShapesRendererInput) => EditOutlineShape[];

package/dist/renderer/sankey-highlight.d.ts

@@ -0,0 +1,12 @@
+import { GeomStyleReaders, SceneLayer } from '@graphysdk/react';
+interface HighlightedObservationsProps {
+    layer: SceneLayer;
+    size: {
+        width: number;
+        height: number;
+    };
+    styleReaders: GeomStyleReaders;
+}
+/** Repaints the matched nodes and flows above the dimmed layer. */
+export declare const HighlightedObservations: ({ layer, size, styleReaders }: HighlightedObservationsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/renderer/sankey-hit-test.d.ts

@@ -0,0 +1,3 @@
+import { GeomRendererInput, RenderHitTester } from '@graphysdk/react';
+/** Tests in unit space, in reverse paint order (nodes over flows, later flows over earlier), so the topmost answers. */
+export declare const buildSankeyHitTester: ({ layer }: GeomRendererInput) => RenderHitTester;