@graphysdk/geom-waterfall 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,568 @@
+import { Geom as q, GeomLine as z, GeomRect as J, IntroFade as Z, POSITION_VARIABLES as x, Stat as Q, UserInputError as G, buildPanelAnchorBox as ee, composePoint as b, createStableBandKeyGenerator as te, defineGeomRenderer as re, defineGeomStyleTarget as ae, getScaledAesthetic as _, getX as ne, getXMax as B, getXMin as W, getY as se, getYMax as P, getYMin as O, readBackdropColor as oe, readMainAxis as m, resolveAnchoredLabelCenter as ie, toPaintColor as T, toPercent as g, toStrokeDasharray as le, toViewBoxX as k, toViewBoxY as M, token as f } from "@graphysdk/react";
+import { useMemo as S } from "react";
+import { Fragment as de, jsx as u, jsxs as ce } from "react/jsx-runtime";
+var c = {
+  start: "waterfallStart",
+  end: "waterfallEnd",
+  kind: "waterfallKind",
+  value: "waterfallValue"
+}, K = (e, t) => {
+  const r = t === "x" ? ne(e) : se(e), a = t === "x" ? W(e) : O(e), s = t === "x" ? B(e) : P(e), n = t === "x" ? O(e) : W(e), l = t === "x" ? P(e) : B(e), o = _(e, "start"), i = _(e, "end"), d = ue(e[c.kind]);
+  return r === null || a === null || s === null || n === null || l === null || o === null || i === null || d === null ? null : {
+    observation: e,
+    band: r,
+    bandStart: a,
+    bandEnd: s,
+    low: Math.min(n, l),
+    high: Math.max(n, l),
+    start: o,
+    end: i,
+    kind: d
+  };
+}, w = (e, t) => {
+  const r = [];
+  for (const a of e) {
+    const s = K(a, t);
+    s !== null && r.push(s);
+  }
+  return r;
+}, F = (e) => e === void 0 ? null : typeof e == "string" ? e : "variable" in e ? e.variable : null, ue = (e) => e === "increase" || e === "decrease" || e === "total" ? e : null, H = ["between", "spanning"], he = 0.8, $ = ({ width: e }) => e ?? he, ge = ({ connector: e }) => Y(e) ? e : "spanning", Y = (e) => H.some((t) => t === e), pe = /* @__PURE__ */ new Set([
+  "relative",
+  "total",
+  "absolute"
+]), ve = (e) => e == null || e === "", j = (e, t) => e.map((r) => {
+  if (ve(r)) return "relative";
+  if (pe.has(r)) return r;
+  throw new G({
+    code: "INVALID_DATA_SHAPE",
+    message: `waterfall measure must be 'relative', 'total' or 'absolute' (got '${String(r)}' in variable '${t}')`,
+    context: {
+      aesthetic: "measure",
+      variableName: t
+    },
+    suggestion: "Mark each total 'total' and each opening balance 'absolute'; leave a step empty or 'relative'."
+  });
+}), fe = (e, t) => {
+  let r = 0;
+  return e.map((a, s) => {
+    const n = t[s] ?? "relative";
+    if (n === "total") return {
+      start: 0,
+      end: r
+    };
+    if (a === null || !Number.isFinite(a)) return null;
+    if (n === "absolute")
+      return r = a, {
+        start: 0,
+        end: a
+      };
+    const l = r;
+    return r += a, {
+      start: l,
+      end: r
+    };
+  });
+}, C = (e, t) => t !== "relative" ? "total" : e.end < e.start ? "decrease" : "increase", U = {
+  start: c.start,
+  end: c.end
+}, I = new Set(Object.keys(U)), me = class extends Q {
+  constructor(...e) {
+    super(...e), this.type = "waterfall", this.computedVariables = I;
+  }
+  computeStat({ data: e, mapping: t }) {
+    const r = A(t.y);
+    if (r === null || !e.hasVariable(r)) return {
+      data: e,
+      mapping: {}
+    };
+    if (e.size() > 0 && e.getType(r) !== "numeric") {
+      const o = e.getType(r);
+      throw new G({
+        code: "INCOMPATIBLE_TYPE",
+        message: `'waterfall' stat requires a numeric 'y' (got '${o}' for variable '${r}')`,
+        context: {
+          aesthetic: "y",
+          variableName: r,
+          variableType: o
+        },
+        suggestion: "Map each bar's change to 'y', or running totals to 'start' and 'end' under stat 'identity'."
+      });
+    }
+    const a = A(t.measure), s = a !== null && e.hasVariable(a) ? j(e.getValues(a), a) : [], n = A(t.group), l = n !== null && e.hasVariable(n) ? [n] : [];
+    return {
+      data: be(e, r, s, Se(e, l)),
+      mapping: U
+    };
+  }
+}, be = (e, t, r, a) => {
+  const s = e.getValues(t, { type: "numeric" }), n = ye(s, r, a), l = e.getValueFormat(t);
+  return e.addVariable(c.start, "numeric", n.map((o) => o?.start ?? null), l).addVariable(c.end, "numeric", n.map((o) => o?.end ?? null), l).addVariable(c.kind, "categorical", n.map((o, i) => o === null ? null : C(o, r[i] ?? "relative")));
+}, ye = (e, t, r) => {
+  const a = /* @__PURE__ */ new Map();
+  r.forEach((n, l) => {
+    const o = a.get(n);
+    o === void 0 ? a.set(n, [l]) : o.push(l);
+  });
+  const s = e.map(() => null);
+  for (const n of a.values()) {
+    const l = fe(n.map((o) => e[o] ?? null), n.map((o) => t[o] ?? "relative"));
+    n.forEach((o, i) => {
+      s[o] = l[i] ?? null;
+    });
+  }
+  return s;
+}, Se = (e, t) => {
+  const r = t.map((a) => e.getValues(a));
+  return Array.from({ length: e.size() }, (a, s) => JSON.stringify(r.map((n) => n[s])));
+}, A = (e) => e === void 0 ? null : typeof e == "string" ? e : "variable" in e ? e.variable : null, we = (e) => {
+  const t = [];
+  if (!e.layer.dataLabels.showDataLabels) return {
+    labels: t,
+    droppedCount: 0
+  };
+  const { position: r, justify: a, align: s, offset: n } = e.layer.dataLabels, l = r === "auto" ? "outside" : r, o = m(e.coordSystem), i = ee(e.panelRect);
+  for (const d of w(e.layer.data, o)) {
+    const h = e.formatLabel(d.observation);
+    if (h === "") continue;
+    const { width: p, height: y } = e.measureDataLabel("observation", l, h), v = ie({
+      box: xe(d, o, e.panelRect),
+      panel: i,
+      orientation: ke(d, o),
+      placement: l,
+      justify: r === "auto" ? "end" : a,
+      align: s,
+      offset: n,
+      labelWidth: p,
+      labelHeight: y
+    });
+    t.push({
+      layerId: e.layer.id,
+      x: v.x,
+      y: v.y,
+      text: h,
+      width: p,
+      height: y,
+      isRotated: !1,
+      role: "observation",
+      position: v.position,
+      backdropColor: v.position === "inside" ? oe(e.styleReaders, d.observation, e.styleReaders.part(d.kind)?.get("fill", d.observation)) : void 0
+    });
+  }
+  return {
+    labels: t,
+    droppedCount: 0
+  };
+}, xe = (e, t, r) => {
+  const a = b(t, {
+    main: e.bandStart,
+    cross: e.low
+  }), s = b(t, {
+    main: e.bandEnd,
+    cross: e.high
+  }), n = Math.min(a.x, s.x) * r.width, l = Math.max(a.x, s.x) * r.width, o = (1 - Math.max(a.y, s.y)) * r.height, i = (1 - Math.min(a.y, s.y)) * r.height;
+  return {
+    x: n,
+    y: o,
+    width: l - n,
+    height: i - o
+  };
+}, ke = (e, t) => {
+  const r = e.end >= e.start;
+  return t === "x" ? {
+    valueAxis: "y",
+    valueDirectionSign: r ? -1 : 1
+  } : {
+    valueAxis: "x",
+    valueDirectionSign: r ? 1 : -1
+  };
+}, Me = 1, Ae = {
+  alpha: "unitInterval",
+  fillAlpha: "unitInterval",
+  strokeWidth: "pixels"
+}, E = {
+  fill: "color",
+  stroke: "color"
+}, Ee = {
+  stroke: "color",
+  alpha: "unitInterval",
+  strokeWidth: "pixels",
+  dashArray: "dashArray"
+}, Ve = class extends q {
+  constructor(...e) {
+    super(...e), this.type = "waterfall", this.defaultParams = {}, this.defaultStat = new me(), this.derivedVariables = Object.values(c), this.positionRoles = [
+      {
+        axis: "x",
+        role: "point",
+        valueKind: "value"
+      },
+      {
+        axis: "y",
+        role: "min",
+        valueKind: "value"
+      },
+      {
+        axis: "y",
+        role: "max",
+        valueKind: "value"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "start"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "end"
+      }
+    ], this.aesthetics = [
+      {
+        kind: "data",
+        name: "y"
+      },
+      {
+        kind: "data",
+        name: "measure"
+      },
+      {
+        kind: "visual",
+        name: "color"
+      }
+    ], this.supportedPositions = ["identity"], this.supportedCoordTypes = ["cartesian", "flip"], this.scaleConstraints = {
+      discreteMainAxis: !0,
+      zeroBaseline: !0
+    }, this.dataLabelCoordTypes = ["cartesian", "flip"], this.getDataLabelPlacements = we, this.spatialKind = "rects", this.highlightStrategy = "observation-rerender", this.tooltip = [{
+      key: "Value",
+      aes: "value"
+    }, {
+      key: "Running total",
+      aes: "end"
+    }], this.styleTarget = ae({
+      observation: {
+        vocabulary: Ae,
+        sharedPaint: !1,
+        aesthetics: {},
+        rest: {
+          alpha: 1,
+          fillAlpha: 1,
+          strokeWidth: 0
+        }
+      },
+      parts: {
+        increase: {
+          vocabulary: E,
+          aesthetics: {
+            fill: "color",
+            stroke: "color"
+          },
+          rest: {
+            fill: f("trendPositive"),
+            stroke: f("trendPositive")
+          }
+        },
+        decrease: {
+          vocabulary: E,
+          aesthetics: {
+            fill: "color",
+            stroke: "color"
+          },
+          rest: {
+            fill: f("trendNegative"),
+            stroke: f("trendNegative")
+          }
+        },
+        total: {
+          vocabulary: E,
+          aesthetics: {
+            fill: "color",
+            stroke: "color"
+          },
+          rest: {
+            fill: f("trendNeutral"),
+            stroke: f("trendNeutral")
+          }
+        },
+        connector: {
+          vocabulary: Ee,
+          rest: {
+            stroke: f("geomBorder"),
+            alpha: 1,
+            strokeWidth: Me,
+            dashArray: []
+          }
+        }
+      }
+    }), this.resolveBandFraction = (t) => $(t), this.resolveValueSource = () => ({ variable: c.value }), this.validateMapping = ({ mapping: t, computedVariables: r }) => r.has("end") ? [...[...I].filter((a) => t[a] !== void 0).map((a) => ({
+      code: "CONFLICTING_STAT_MAPPING",
+      message: `waterfall stat computes '${a}' from 'y'; remove its mapping, or set the layer's stat to 'identity'`
+    })), ...t.y === void 0 ? [{
+      code: "MISSING_AESTHETIC",
+      message: "waterfall stat runs the total through 'y'; map it to the changes",
+      context: { aesthetic: "y" }
+    }] : []] : [...I].filter((a) => t[a] === void 0).map((a) => ({
+      code: "MISSING_AESTHETIC",
+      message: `waterfall geom requires '${a}' when its running totals are already in the data`,
+      context: { aesthetic: a }
+    })), this.resolveAnchorPosition = (t, { coordSystem: r }) => {
+      const a = m(r), s = K(t, a);
+      return s === null ? null : a === "x" ? {
+        x: s.band,
+        y: s.end
+      } : {
+        x: s.end,
+        y: s.band
+      };
+    };
+  }
+  resolveParams(e) {
+    const { width: t, connector: r, ...a } = super.resolveParams(e);
+    return {
+      ...a,
+      ...Te(t, e.diagnostics),
+      ...Ce(r, e.diagnostics)
+    };
+  }
+  compile({ data: e, mapping: t, params: r }) {
+    const a = V(t.start), s = V(t.end);
+    if (a === null || s === null) return {
+      data: e,
+      mapping: {}
+    };
+    if (!e.hasVariable(a) || !e.hasVariable(s)) return {
+      data: e,
+      mapping: {}
+    };
+    const n = $(r) / 2;
+    return {
+      data: Ie(e, a, s, V(t.measure)).addConstantVariable(x.xMin, "numeric", -n).addConstantVariable(x.xMax, "numeric", n),
+      mapping: {
+        y: t.end,
+        value: c.value
+      }
+    };
+  }
+}, Te = (e, t) => {
+  if (e === void 0) return {};
+  const r = typeof e == "number" && Number.isFinite(e) ? e : null;
+  if (r !== null && r > 0 && r <= 1) return { width: r };
+  const a = r !== null && r > 1 ? 1 : void 0;
+  return t?.addWarning({
+    code: "INVALID_GEOM_PARAM",
+    message: `Waterfall width must be a fraction in (0, 1], got ${String(e)}; falling back to ${a ?? "the default band"}.`,
+    context: {
+      geom: "waterfall",
+      param: "width",
+      expected: "0 < width <= 1",
+      actual: r ?? String(e)
+    },
+    suggestion: "Set params.width to a fraction of the category band in (0, 1]."
+  }), a === void 0 ? {} : { width: a };
+}, Ce = (e, t) => {
+  if (e === void 0) return {};
+  if (Y(e)) return { connector: e };
+  const r = H.map((a) => `'${a}'`).join(", ");
+  return t?.addWarning({
+    code: "INVALID_GEOM_PARAM",
+    message: `Waterfall connector must be one of ${r}, got ${String(e)}; falling back to 'spanning'.`,
+    context: {
+      geom: "waterfall",
+      param: "connector",
+      expected: r,
+      actual: String(e)
+    },
+    suggestion: `Set params.connector to one of ${r}.`
+  }), {};
+}, V = (e) => e === void 0 ? null : typeof e == "string" ? e : "variable" in e ? e.variable : null, Ie = (e, t, r, a) => {
+  const s = e.getValues(t, { type: "numeric" }), n = e.getValues(r, { type: "numeric" }), l = Le(e, a), o = s.map((i, d) => {
+    const h = n[d] ?? null;
+    if (i === null || h === null || !Number.isFinite(i) || !Number.isFinite(h)) return null;
+    const p = {
+      start: i,
+      end: h
+    };
+    return {
+      ...p,
+      kind: l(p, d)
+    };
+  });
+  return e.addVariable(c.kind, "categorical", o.map((i) => i?.kind ?? null)).addVariable(c.value, "numeric", o.map((i) => i === null ? null : i.kind === "total" ? i.end : i.end - i.start), e.getValueFormat(r)).addVariable(x.yMin, "numeric", o.map((i) => i === null ? null : Math.min(i.start, i.end))).addVariable(x.yMax, "numeric", o.map((i) => i === null ? null : Math.max(i.start, i.end)));
+}, Le = (e, t) => {
+  if (e.hasVariable(c.kind)) {
+    const a = e.getValues(c.kind);
+    return (s, n) => _e(a[n]) ? a[n] : C(s, "relative");
+  }
+  const r = t !== null && e.hasVariable(t) ? j(e.getValues(t), t) : [];
+  return (a, s) => C(a, r[s] ?? "relative");
+}, Ne = /* @__PURE__ */ new Set([
+  "increase",
+  "decrease",
+  "total"
+]), _e = (e) => Ne.has(e), Be = 5e-4, X = (e, t) => {
+  const r = (e.low + e.high) / 2, a = Math.max(e.high - e.low, Be) / 2, s = b(t, {
+    main: e.bandStart,
+    cross: r - a
+  }), n = b(t, {
+    main: e.bandEnd,
+    cross: r + a
+  }), [l, o] = D(k(s.x), k(n.x)), [i, d] = D(M(s.y), M(n.y));
+  return {
+    x: l,
+    y: i,
+    width: o - l,
+    height: d - i
+  };
+}, We = (e, t, r = "spanning", a = null) => {
+  const s = /* @__PURE__ */ new Map();
+  return e.flatMap((n) => {
+    const l = a === null ? null : n.observation[a], o = s.get(l);
+    if (s.set(l, n), o === void 0 || !Pe(o, n)) return [];
+    const i = n.band >= o.band, d = r === "spanning", h = i === d ? o.bandStart : o.bandEnd, p = i === d ? n.bandEnd : n.bandStart, y = b(t, {
+      main: h,
+      cross: o.end
+    }), v = b(t, {
+      main: p,
+      cross: o.end
+    });
+    return [{
+      from: o,
+      to: n,
+      segment: {
+        x1: k(y.x),
+        y1: M(y.y),
+        x2: k(v.x),
+        y2: M(v.y)
+      }
+    }];
+  });
+}, R = 1e-9, Pe = (e, t) => Math.abs(t.start - e.end) < R || Math.abs(t.end - e.end) < R, D = (e, t) => e <= t ? [e, t] : [t, e], Oe = ({ layer: e, coordSystem: t, panelRect: r }) => {
+  const a = m(t);
+  return w(e.data, a).map((s) => {
+    const n = X(s, a), l = n.x * r.width;
+    return {
+      kind: "region",
+      pathData: `M${l},${n.y * r.height}H${(n.x + n.width) * r.width}V${(n.y + n.height) * r.height}H${l}Z`
+    };
+  });
+}, L = (e, t) => {
+  const r = te(e.data, e.mapping, e.id), a = F(e.mapping.group), s = /* @__PURE__ */ new Map();
+  return new Map(t.map((n) => {
+    const l = r(n.observation) ?? e.id, o = a === null ? l : `${l}-${String(n.observation[a])}`, i = s.get(o) ?? 0;
+    return s.set(o, i + 1), [n, i === 0 ? o : `${o}#${i}`];
+  }));
+}, N = ({ steps: e, connectors: t = [], mainAxis: r, styleReaders: a, keys: s, isHovered: n = !1, shouldAnimateTransitions: l = !1 }) => {
+  const o = n ? "hovered" : void 0, i = a.part("connector");
+  return /* @__PURE__ */ ce(de, { children: [e.map((d) => /* @__PURE__ */ u(Re, {
+    step: d,
+    mainAxis: r,
+    styleReaders: a,
+    state: o,
+    shouldAnimateTransitions: l
+  }, s.get(d))), i && t.map((d) => /* @__PURE__ */ u($e, {
+    connector: d,
+    readers: i,
+    shouldAnimateTransitions: l
+  }, `${s.get(d.from)}-connector`))] });
+}, $e = ({ connector: e, readers: t, shouldAnimateTransitions: r }) => {
+  const { observation: a } = e.from, s = t.get("strokeWidth", a) ?? 0, n = t.get("stroke", a);
+  return /* @__PURE__ */ u(z, {
+    "data-testid": "waterfall-connector",
+    x1: g(e.segment.x1),
+    y1: g(e.segment.y1),
+    x2: g(e.segment.x2),
+    y2: g(e.segment.y2),
+    stroke: n === void 0 ? void 0 : T(n),
+    strokeOpacity: t.get("alpha", a),
+    strokeWidth: s,
+    strokeDasharray: le(t.get("dashArray", a), s),
+    shouldAnimateTransitions: r
+  });
+}, Re = ({ step: e, mainAxis: t, styleReaders: r, state: a, shouldAnimateTransitions: s }) => {
+  const n = X(e, t), l = r.part(e.kind), o = l?.get("fill", e.observation, a), i = l?.get("stroke", e.observation, a);
+  return /* @__PURE__ */ u(J, {
+    "data-testid": "waterfall-bar",
+    x: g(n.x),
+    y: g(n.y),
+    width: g(n.width),
+    height: g(n.height),
+    fill: o === void 0 ? void 0 : T(o),
+    opacity: r.get("alpha", e.observation, a),
+    fillOpacity: r.get("fillAlpha", e.observation, a),
+    stroke: i === void 0 ? void 0 : T(i),
+    strokeWidth: r.get("strokeWidth", e.observation, a),
+    shouldAnimateTransitions: s
+  });
+}, De = ({ layer: e, sourceLayer: t, mainAxis: r, styleReaders: a }) => {
+  const s = S(() => w(e.data, r), [e.data, r]);
+  return /* @__PURE__ */ u(N, {
+    steps: s,
+    mainAxis: r,
+    styleReaders: a,
+    keys: S(() => L(t, s), [t, s])
+  });
+}, Ge = ({ layer: e, primary: t, siblings: r, mainAxis: a, styleReaders: s }) => {
+  const n = w([t, ...r].map((l) => l.observation), a);
+  return /* @__PURE__ */ u("g", {
+    "data-testid": "hovered-steps",
+    children: /* @__PURE__ */ u(N, {
+      steps: n,
+      mainAxis: a,
+      styleReaders: s,
+      keys: L(e, n),
+      isHovered: !0
+    })
+  });
+}, Ke = ({ layer: e, mainAxis: t, styleReaders: r, shouldAnimateTransitions: a, intro: s }) => {
+  const n = S(() => w(e.data, t), [e.data, t]), l = ge(e.params), o = F(e.mapping.group), i = /* @__PURE__ */ u(N, {
+    steps: n,
+    connectors: S(() => We(n, t, l, o), [
+      n,
+      t,
+      l,
+      o
+    ]),
+    mainAxis: t,
+    styleReaders: r,
+    keys: S(() => L(e, n), [e, n]),
+    shouldAnimateTransitions: a
+  }), d = Fe(s);
+  return d === null ? i : /* @__PURE__ */ u(Z, {
+    intro: d,
+    children: i
+  });
+}, Fe = (e) => e == null ? null : {
+  type: "fade",
+  layerId: e.layerId,
+  durationSeconds: e.durationSeconds
+}, Ue = re(new Ve(), {
+  coord: "cartesian",
+  swatchShape: "square",
+  guideMode: "band",
+  render: ({ layer: e, coordSystem: t, styleReaders: r, shouldAnimateTransitions: a, intro: s }) => /* @__PURE__ */ u(Ke, {
+    layer: e,
+    mainAxis: m(t),
+    styleReaders: r,
+    shouldAnimateTransitions: a,
+    intro: s
+  }),
+  renderHighlight: ({ layer: e, sourceLayer: t, coordSystem: r, styleReaders: a }) => /* @__PURE__ */ u(De, {
+    layer: e,
+    sourceLayer: t,
+    mainAxis: m(r),
+    styleReaders: a
+  }),
+  renderHover: ({ layer: e, primary: t, group: r, related: a, coordSystem: s, styleReaders: n }) => /* @__PURE__ */ u(Ge, {
+    layer: e,
+    primary: t,
+    siblings: [...r, ...a],
+    mainAxis: m(s),
+    styleReaders: n
+  }),
+  renderHoverCompanions: () => null,
+  getEditOutlineShapes: Oe
+});
+export {
+  Ve as WaterfallGeom,
+  Ue as waterfall
+};

package/dist/renderer/utils/step-geometry.d.ts

@@ -0,0 +1,34 @@
+import { MainAxis } from '@graphysdk/react';
+import { Step } from '../../utils/read-waterfall';
+import { WaterfallConnectorMode } from '../../utils/waterfall-params';
+/** A box in the `[0, 1]` view box, from its top left, y growing downward. */
+export interface ViewBoxRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A line in the `[0, 1]` view box. */
+export interface ViewBoxSegment {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+/** The connector from one bar to the next, and the two bars it joins. */
+export interface Connector {
+    from: Step;
+    to: Step;
+    segment: ViewBoxSegment;
+}
+/** The bar from its start to its end, across its share of the band. */
+export declare const readBarBox: (step: Step, mainAxis: MainAxis) => ViewBoxRect;
+/**
+ * One connector from each bar to the next in its group, at the running total the first ends on. The total
+ * runs per `group`, so a connector never joins two groups' bars even when their rows interleave. A bar that
+ * does not pick up that total, such as an absolute bar resetting it, gets no connector in.
+ * `'between'` runs from the first bar's edge facing the second to the second's edge facing the first;
+ * `'spanning'` runs from the first bar's far edge to the second's far edge, across both bands. Either way it
+ * reads whichever way the category axis runs.
+ */
+export declare const readConnectors: (steps: readonly Step[], mainAxis: MainAxis, mode?: WaterfallConnectorMode, groupVariable?: string | null) => Connector[];

package/dist/renderer/utils/waterfall-keys.d.ts

@@ -0,0 +1,12 @@
+import { SceneLayer } from '@graphysdk/react';
+import { Step } from '../../utils/read-waterfall';
+/**
+ * A bar keys on its category, read from the raw value rather than the band: the band moves with the domain,
+ * the very change a mark should spring through, not remount on. Only an explicit `group` joins the key, as it
+ * is the only mapping that splits the total: a mapped `color` only paints, and a bar whose colour changes
+ * (an up-or-down column flipping with its sign) is the same bar.
+ *
+ * A category can repeat within a group (a two-year monthly bridge has two Januaries), so repeats carry their
+ * occurrence in the order painted: every bar keeps its own key, and the keys survive a recompile.
+ */
+export declare const readWaterfallKeys: (layer: SceneLayer, steps: readonly Step[]) => Map<Step, string>;

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

@@ -0,0 +1,3 @@
+import { EditOutlineShape, GeomEditOutlineShapesRendererInput } from '@graphysdk/react';
+/** What point and edit outlines round the bars they take, each as its box. A connector belongs to no one bar. */
+export declare const getWaterfallEditOutlineShapes: ({ layer, coordSystem, panelRect, }: GeomEditOutlineShapesRendererInput) => EditOutlineShape[];

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

@@ -0,0 +1,11 @@
+import { GeomStyleReaders, MainAxis, SceneLayer } from '@graphysdk/react';
+interface HighlightedStepsProps {
+    layer: SceneLayer;
+    /** The whole layer the matched observations were taken from. */
+    sourceLayer: SceneLayer;
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+}
+/** Repaints the matched bars above the dimmed layer. */
+export declare const HighlightedSteps: ({ layer, sourceLayer, mainAxis, styleReaders }: HighlightedStepsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/renderer/waterfall-hover.d.ts

@@ -0,0 +1,12 @@
+import { GeomStyleReaders, HoverHit, MainAxis, SceneLayer } from '@graphysdk/react';
+interface HoveredStepsProps {
+    layer: SceneLayer;
+    primary: HoverHit;
+    /** Any other bar of the hovered category, from duplicate rows. */
+    siblings: readonly HoverHit[];
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+}
+/** The hovered category's bar, repainted above the dimmed layer. */
+export declare const HoveredSteps: ({ layer, primary, siblings, mainAxis, styleReaders }: HoveredStepsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/renderer/waterfall-layer.d.ts

@@ -0,0 +1,16 @@
+import { GeomStyleReaders, LayerIntroPlan, MainAxis, SceneLayer } from '@graphysdk/react';
+interface WaterfallLayerProps {
+    layer: SceneLayer;
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+    shouldAnimateTransitions: boolean;
+    intro: LayerIntroPlan | null | undefined;
+}
+/**
+ * The layer's own paint, connectors included. The whole layer fades up on one clock, whatever entrance the engine
+ * plans: a bar is a rect to the engine, which plans a bar's grow, but a waterfall's bars float on the running
+ * total, with no baseline to grow from. The fade is independent of `shouldAnimateTransitions`: it rides the group
+ * rather than moving the marks, so it plays even when data changes snap.
+ */
+export declare const WaterfallLayer: ({ layer, mainAxis, styleReaders, shouldAnimateTransitions, intro, }: WaterfallLayerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,27 @@
+import { GeomStyleReaders, MainAxis } from '@graphysdk/react';
+import { Step } from '../utils/read-waterfall';
+import { Connector } from './utils/step-geometry';
+/**
+ * What one pass paints: its bars, then its connectors above them, so a spanning connector runs visibly along
+ * the edges of the bars it joins.
+ */
+export interface WaterfallPaintProps {
+    steps: readonly Step[];
+    /**
+     * The lines between bars. Only the layer's own paint draws them: a hover or highlight repaint raises bars,
+     * and a connector belongs to no one bar.
+     */
+    connectors?: readonly Connector[];
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+    /** What identifies each bar across a data change, so a spring moves a mark rather than swapping it. */
+    keys: ReadonlyMap<Step, string>;
+    /** Paints in the `hovered` state. */
+    isHovered?: boolean;
+    /**
+     * Whether bars and connectors spring to their new positions when the data changes. The hover and highlight
+     * repaints mount and unmount with the interaction, so only the layer's own paint animates.
+     */
+    shouldAnimateTransitions?: boolean;
+}
+export declare const WaterfallPaint: ({ steps, connectors, mainAxis, styleReaders, keys, isHovered, shouldAnimateTransitions, }: WaterfallPaintProps) => import("react/jsx-runtime").JSX.Element;