@jcsoftdev/ui 0.0.0-stage → 0.1.1

package/dist/charts/core/polar.js

@@ -0,0 +1,173 @@
+const TAU = Math.PI * 2;
+const round = (value) => Math.round(value * 100) / 100;
+function degToRad(degrees) {
+  return degrees * Math.PI / 180;
+}
+function radToDeg(radians) {
+  return radians * 180 / Math.PI;
+}
+function polarPoint(cx, cy, radius, angle) {
+  return { x: cx + radius * Math.sin(angle), y: cy - radius * Math.cos(angle) };
+}
+function angleOf(cx, cy, x, y) {
+  const angle = Math.atan2(x - cx, cy - y);
+  return angle < 0 ? angle + TAU : angle;
+}
+function normalizeAngle(angle) {
+  const wrapped = angle % TAU;
+  return wrapped < 0 ? wrapped + TAU : wrapped;
+}
+function slotAt(angle, count, offset = 0) {
+  if (count <= 0) return -1;
+  const slot = TAU / count;
+  return Math.floor(normalizeAngle(angle - offset + slot / 2) / slot) % count;
+}
+function sliceAngles(values, options = {}) {
+  const { startAngle = 0, endAngle = TAU, padAngle = 0 } = options;
+  const clean = values.map((value) => Number.isFinite(value) && value > 0 ? value : 0);
+  const total = clean.reduce((sum, value) => sum + value, 0);
+  const span = endAngle - startAngle;
+  const visible = clean.filter((value) => value > 0).length;
+  const pad = visible > 1 || Math.abs(span) < TAU - 1e-6 ? padAngle : 0;
+  let cursor = startAngle;
+  return clean.map((value, index) => {
+    const fraction = total > 0 ? value / total : 0;
+    const from = cursor;
+    const to = cursor + span * fraction;
+    cursor = to;
+    const inset = Math.min(pad / 2, Math.abs(to - from) / 2);
+    return {
+      index,
+      value,
+      fraction,
+      start: from + inset,
+      end: to - inset,
+      mid: (from + to) / 2
+    };
+  });
+}
+const at = (cx, cy, radius, angle) => {
+  const point = polarPoint(cx, cy, radius, angle);
+  return `${round(point.x)} ${round(point.y)}`;
+};
+function arcSegments(parts, cx, cy, radius, from, to, sweep) {
+  const pieces = Math.max(1, Math.ceil(Math.abs(to - from) / (Math.PI * 0.99)));
+  for (let step = 1; step <= pieces; step++) {
+    const target = at(cx, cy, radius, from + (to - from) * step / pieces);
+    parts.push(`A${round(radius)} ${round(radius)} 0 0 ${sweep} ${target}`);
+  }
+}
+function arcPath(spec) {
+  const { cx, cy, startAngle: a0, endAngle: a1 } = spec;
+  const r0 = Math.max(0, spec.innerRadius);
+  const r1 = spec.outerRadius;
+  const span = a1 - a0;
+  if (!(span > 1e-6) || !(r1 > r0)) return "";
+  if (span >= TAU - 1e-3) {
+    const ring = [`M${at(cx, cy, r1, a0)}`];
+    arcSegments(ring, cx, cy, r1, a0, a0 + TAU, 1);
+    ring.push("Z");
+    if (r0 > 0) {
+      ring.push(`M${at(cx, cy, r0, a0)}`);
+      arcSegments(ring, cx, cy, r0, a0, a0 - TAU, 0);
+      ring.push("Z");
+    }
+    return ring.join("");
+  }
+  let rc = Math.max(0, Math.min(spec.cornerRadius ?? 0, (r1 - r0) / 2, r1 / 2));
+  const fits = (radius) => 2 * Math.asin(radius / (r1 - radius)) <= span && (r0 <= 0 || 2 * Math.asin(radius / (r0 + radius)) <= span);
+  while (rc > 0.05 && !fits(rc)) rc *= 0.85;
+  if (rc <= 0.05) rc = 0;
+  const outerOffset = rc > 0 ? Math.asin(rc / (r1 - rc)) : 0;
+  const innerOffset = rc > 0 && r0 > 0 ? Math.asin(rc / (r0 + rc)) : 0;
+  const outerEdge = rc > 0 ? Math.sqrt((r1 - rc) ** 2 - rc ** 2) : r1;
+  const innerEdge = rc > 0 && r0 > 0 ? Math.sqrt((r0 + rc) ** 2 - rc ** 2) : r0;
+  const corner = (target) => `A${round(rc)} ${round(rc)} 0 0 1 ${target}`;
+  const parts = [`M${at(cx, cy, r1, a0 + outerOffset)}`];
+  arcSegments(parts, cx, cy, r1, a0 + outerOffset, a1 - outerOffset, 1);
+  if (rc > 0) parts.push(corner(at(cx, cy, outerEdge, a1)));
+  if (r0 > 0) {
+    parts.push(`L${at(cx, cy, innerEdge, a1)}`);
+    if (rc > 0) parts.push(corner(at(cx, cy, r0, a1 - innerOffset)));
+    arcSegments(parts, cx, cy, r0, a1 - innerOffset, a0 + innerOffset, 0);
+    if (rc > 0) parts.push(corner(at(cx, cy, innerEdge, a0)));
+  } else {
+    parts.push(`L${round(cx)} ${round(cy)}`);
+  }
+  parts.push(`L${at(cx, cy, outerEdge, a0)}`);
+  if (rc > 0) parts.push(corner(at(cx, cy, r1, a0 + outerOffset)));
+  parts.push("Z");
+  return parts.join("");
+}
+function arcLine(cx, cy, radius, startAngle, endAngle) {
+  if (!(radius > 0) || !(Math.abs(endAngle - startAngle) > 1e-6)) return "";
+  const sweep = endAngle > startAngle ? 1 : 0;
+  const delta = Math.max(-TAU + 1e-3, Math.min(TAU - 1e-3, endAngle - startAngle));
+  const parts = [`M${at(cx, cy, radius, startAngle)}`];
+  arcSegments(parts, cx, cy, radius, startAngle, startAngle + delta, sweep);
+  return parts.join("");
+}
+function spreadLabels(boxes, min, max, gap = 2) {
+  const order = boxes.map((_, index) => index).sort((a, b) => (boxes[a]?.y ?? 0) - (boxes[b]?.y ?? 0));
+  const ys = order.map((index) => boxes[index]?.y ?? 0);
+  const half = order.map((index) => (boxes[index]?.height ?? 0) / 2);
+  const h = (i) => half[i] ?? 0;
+  for (let i = 0; i < ys.length; i++) {
+    const floor = i === 0 ? min + h(0) : (ys[i - 1] ?? 0) + h(i - 1) + gap + h(i);
+    ys[i] = Math.max(ys[i] ?? 0, floor);
+  }
+  for (let i = ys.length - 1; i >= 0; i--) {
+    const ceil = i === ys.length - 1 ? max - h(i) : (ys[i + 1] ?? 0) - h(i + 1) - gap - h(i);
+    ys[i] = Math.min(ys[i] ?? 0, ceil);
+  }
+  if (ys.length > 0 && (ys[0] ?? 0) - h(0) < min - 1e-9) {
+    let cursor = min;
+    for (let i = 0; i < ys.length; i++) {
+      ys[i] = cursor + h(i);
+      cursor += h(i) * 2 + gap;
+    }
+  }
+  const out = new Array(boxes.length).fill(0);
+  order.forEach((original, i) => {
+    out[original] = ys[i] ?? 0;
+  });
+  return out;
+}
+function funnelStages(values, options) {
+  const { length, thickness, gap = 0, variant = "funnel", neck = 0.72, tapered = true } = options;
+  const clean = values.map((value) => Number.isFinite(value) && value > 0 ? value : 0);
+  const max = Math.max(0, ...clean);
+  const count = clean.length;
+  const first = clean[0] ?? 0;
+  const size = count > 0 ? Math.max(0, (length - gap * (count - 1)) / count) : 0;
+  return clean.map((value, index) => {
+    const next = clean[index + 1];
+    const widthFrom = max > 0 ? value / max * thickness : 0;
+    const widthTo = !tapered && variant !== "pyramid" ? widthFrom : next != null && max > 0 ? next / max * thickness : variant === "pyramid" ? 0 : widthFrom * neck;
+    const previous = clean[index - 1];
+    return {
+      index,
+      value,
+      from: index * (size + gap),
+      to: index * (size + gap) + size,
+      widthFrom,
+      widthTo,
+      ofFirst: first > 0 ? value / first : 0,
+      conversion: previous == null ? null : previous > 0 ? value / previous : 0
+    };
+  });
+}
+export {
+  TAU,
+  angleOf,
+  arcLine,
+  arcPath,
+  degToRad,
+  funnelStages,
+  normalizeAngle,
+  polarPoint,
+  radToDeg,
+  sliceAngles,
+  slotAt,
+  spreadLabels
+};

package/dist/charts/core/sankey.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Sankey layout: nodes in columns, links as bands whose width is the flow.
+ * Pure functions: no React, no DOM, unit tested in `test/charts-graph.test.mjs`.
+ *
+ * 1. Links are validated; links that would close a cycle are removed (a sankey
+ *    reads left to right, so a feedback loop has nowhere to go) and reported.
+ * 2. Each node goes to the column of its longest path from a source; with
+ *    `align: "justify"` the sinks move to the last column.
+ * 3. Nodes are stacked per column with a shared scale (`ky`, pixels per unit)
+ *    and then relaxed: a few sweeps right-to-left and left-to-right pull each
+ *    node towards the weighted centre of its neighbours, resolving overlaps
+ *    after every sweep. That shortens links and removes most crossings.
+ * 4. Links are ordered on both ends by the position of the node at the other
+ *    end, so bands leave and arrive without crossing each other at the node.
+ */
+export interface SankeyNodeInput {
+    id: string;
+    name: string;
+    /** CSS color, e.g. `var(--chart-cat-2)`; defaults to a palette slot. */
+    color?: string;
+    /**
+     * Fixed column (0-based) instead of the longest path from a source. Used by the
+     * alluvial layout, where a column is a moment in time. Links should point to a later column.
+     */
+    column?: number;
+}
+export interface SankeyLinkInput {
+    source: string;
+    target: string;
+    value: number;
+}
+export interface SankeyOptions {
+    width: number;
+    height: number;
+    /** Thickness of the node bars. */
+    nodeWidth?: number;
+    /** Vertical gap between nodes of a column (shrinks when the column is crowded). */
+    nodePadding?: number;
+    /** Relaxation sweeps. */
+    iterations?: number;
+    /** `justify` pushes the sinks to the last column; `left` keeps each node at its depth. */
+    align?: "justify" | "left";
+    /**
+     * `false` skips the relaxation sweeps: nodes stay in input order inside their column
+     * (alluvial diagrams, where the order of the categories must not change between stages).
+     */
+    relax?: boolean;
+}
+export interface SankeyNode {
+    id: string;
+    name: string;
+    color?: string;
+    /** Position in the input list. */
+    index: number;
+    column: number;
+    /** Larger of the incoming and outgoing totals. */
+    value: number;
+    inValue: number;
+    outValue: number;
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+    incoming: SankeyLink[];
+    outgoing: SankeyLink[];
+}
+export interface SankeyLink {
+    /** `source->target`, with a `~n` suffix for repeated pairs. */
+    id: string;
+    source: SankeyNode;
+    target: SankeyNode;
+    value: number;
+    /** Band thickness in pixels. */
+    width: number;
+    /** Centre of the band where it leaves the source and where it reaches the target. */
+    y0: number;
+    y1: number;
+}
+export type SankeyRemovalReason = "cycle" | "self" | "unknown-node" | "invalid-value";
+export interface SankeyGraph {
+    /** Nodes with flow, in input order. */
+    nodes: SankeyNode[];
+    links: SankeyLink[];
+    columns: number;
+    /** Pixels per unit of value. */
+    ky: number;
+    /** Input links left out of the layout, and why. */
+    removed: Array<{
+        link: SankeyLinkInput;
+        reason: SankeyRemovalReason;
+    }>;
+}
+/**
+ * Splits the links into an acyclic set and the links that close a cycle.
+ * Orders the nodes with the greedy feedback-arc-set heuristic of Eades, Lin
+ * and Smyth, weighted by value: sinks go to the end, sources to the front,
+ * otherwise the node with the largest outflow minus inflow goes next. Links
+ * that point backwards in that order are the ones removed, so a small return
+ * flow (e.g. "comes back to book again") is cut rather than a main flow.
+ */
+export declare function breakCycles(nodeIds: readonly string[], links: readonly SankeyLinkInput[]): {
+    kept: SankeyLinkInput[];
+    cyclic: SankeyLinkInput[];
+};
+/** Lays out a sankey diagram in a `width` x `height` box. */
+export declare function sankeyLayout(nodesInput: readonly SankeyNodeInput[], linksInput: readonly SankeyLinkInput[], options: SankeyOptions): SankeyGraph;
+/** Centre line of a link band, drawn with `stroke-width = link.width`. */
+export declare function sankeyLinkPath(link: Pick<SankeyLink, "source" | "target" | "y0" | "y1">): string;
+/** Ids of the links and nodes upstream and downstream of a node (the node included). */
+export declare function sankeyFlowOf(node: SankeyNode): {
+    nodes: Set<string>;
+    links: Set<string>;
+};
+/**
+ * The path through a link: the link itself, everything that feeds its source
+ * (upstream) and everything its target feeds (downstream).
+ */
+export declare function sankeyTraceOf(link: SankeyLink): {
+    nodes: Set<string>;
+    links: Set<string>;
+};
+/** One flow in two periods. */
+export interface SankeyDiffLink extends SankeyLinkInput {
+    /** The layout value: the larger of the two periods, so both fit. */
+    value: number;
+    before: number;
+    after: number;
+    /** `after - before`. */
+    delta: number;
+}
+/**
+ * Merges the flows of two periods by `source -> target` (repeated pairs are
+ * summed). A flow missing in a period counts as 0 there. The merged `value` is
+ * the larger one, which is what the layout reserves; `before`/`after` are
+ * what is drawn on top of it.
+ */
+export declare function sankeyDiff(before: readonly SankeyLinkInput[], after: readonly SankeyLinkInput[]): SankeyDiffLink[];
+export interface AlluvialInput {
+    /** Moments in time, left to right: "Jun", "Jul", ... */
+    stages: readonly string[];
+    /** The categories that flow; their order is the order top to bottom in every stage. */
+    categories: ReadonlyArray<{
+        id: string;
+        name: string;
+        color?: string;
+    }>;
+    /**
+     * `flows[s]` moves people from stage `s` to stage `s + 1`:
+     * `{ from: categoryId, to: categoryId, value }`.
+     */
+    flows: ReadonlyArray<ReadonlyArray<{
+        from: string;
+        to: string;
+        value: number;
+    }>>;
+}
+/** Node id of a category at a stage: `"2:vip"`. */
+export declare function alluvialNodeId(stage: number, category: string): string;
+/**
+ * Turns stage-by-stage category flows into sankey nodes and links: one node per
+ * category per stage (pinned to its column), the same color across stages, in
+ * category order. Categories with no flow at a stage are left out. Draw with
+ * `relax: false` and `align: "left"` to keep the order.
+ */
+export declare function alluvialGraph(input: AlluvialInput): {
+    nodes: SankeyNodeInput[];
+    links: SankeyLinkInput[];
+};

package/dist/charts/core/sankey.js

@@ -0,0 +1,354 @@
+function breakCycles(nodeIds, links) {
+  const remaining = new Set(nodeIds);
+  const outgoing = new Map(nodeIds.map((id) => [id, []]));
+  const incoming = new Map(nodeIds.map((id) => [id, []]));
+  for (const link of links) {
+    outgoing.get(link.source)?.push(link);
+    incoming.get(link.target)?.push(link);
+  }
+  const live = (list, end) => list.filter((link) => remaining.has(link[end]));
+  const weight = (list) => list.reduce((sum, link) => sum + link.value, 0);
+  const front = [];
+  const back = [];
+  while (remaining.size > 0) {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const id of [...remaining]) {
+        if (live(outgoing.get(id) ?? [], "target").length === 0) {
+          back.unshift(id);
+          remaining.delete(id);
+          changed = true;
+        }
+      }
+      for (const id of [...remaining]) {
+        if (live(incoming.get(id) ?? [], "source").length === 0) {
+          front.push(id);
+          remaining.delete(id);
+          changed = true;
+        }
+      }
+    }
+    if (remaining.size === 0) break;
+    let best = "";
+    let bestScore = Number.NEGATIVE_INFINITY;
+    for (const id of remaining) {
+      const score = weight(live(outgoing.get(id) ?? [], "target")) - weight(live(incoming.get(id) ?? [], "source"));
+      if (score > bestScore) {
+        best = id;
+        bestScore = score;
+      }
+    }
+    front.push(best);
+    remaining.delete(best);
+  }
+  const position = new Map([...front, ...back].map((id, index) => [id, index]));
+  const forward = (link) => (position.get(link.source) ?? 0) < (position.get(link.target) ?? 0);
+  return {
+    kept: links.filter(forward),
+    cyclic: links.filter((link) => !forward(link))
+  };
+}
+function centre(node) {
+  return (node.y0 + node.y1) / 2;
+}
+function resolveCollisions(column, height, padding) {
+  column.sort((a, b) => a.y0 - b.y0 || a.index - b.index);
+  let y = 0;
+  for (const node of column) {
+    const shift = y - node.y0;
+    if (shift > 0) {
+      node.y0 += shift;
+      node.y1 += shift;
+    }
+    y = node.y1 + padding;
+  }
+  y = height;
+  for (let i = column.length - 1; i >= 0; i--) {
+    const node = column[i];
+    const shift = node.y1 - y;
+    if (shift > 0) {
+      node.y0 -= shift;
+      node.y1 -= shift;
+    }
+    y = node.y0 - padding;
+  }
+}
+function sankeyLayout(nodesInput, linksInput, options) {
+  const { width, height, nodeWidth = 12, nodePadding = 12, iterations = 6 } = options;
+  const align = options.align ?? "justify";
+  const removed = [];
+  const known = new Set(nodesInput.map((node) => node.id));
+  const valid = linksInput.filter((link) => {
+    const reason = !known.has(link.source) || !known.has(link.target) ? "unknown-node" : link.source === link.target ? "self" : !(Number.isFinite(link.value) && link.value > 0) ? "invalid-value" : null;
+    if (reason) removed.push({ link, reason });
+    return reason == null;
+  });
+  const { kept, cyclic } = breakCycles(
+    nodesInput.map((node) => node.id),
+    valid
+  );
+  for (const link of cyclic) removed.push({ link, reason: "cycle" });
+  const all = /* @__PURE__ */ new Map();
+  nodesInput.forEach((input, index) => {
+    if (all.has(input.id)) return;
+    all.set(input.id, {
+      id: input.id,
+      name: input.name,
+      color: input.color,
+      index,
+      column: 0,
+      value: 0,
+      inValue: 0,
+      outValue: 0,
+      x0: 0,
+      x1: 0,
+      y0: 0,
+      y1: 0,
+      incoming: [],
+      outgoing: []
+    });
+  });
+  const pairCount = /* @__PURE__ */ new Map();
+  const links = kept.map((input) => {
+    const source = all.get(input.source);
+    const target = all.get(input.target);
+    const key = `${source.id}->${target.id}`;
+    const count = pairCount.get(key) ?? 0;
+    pairCount.set(key, count + 1);
+    const link = {
+      id: count ? `${key}~${count}` : key,
+      source,
+      target,
+      value: input.value,
+      width: 0,
+      y0: 0,
+      y1: 0
+    };
+    source.outgoing.push(link);
+    target.incoming.push(link);
+    source.outValue += input.value;
+    target.inValue += input.value;
+    return link;
+  });
+  const nodes = [...all.values()].filter((node) => node.inValue > 0 || node.outValue > 0);
+  for (const node of nodes) node.value = Math.max(node.inValue, node.outValue);
+  if (nodes.length === 0) return { nodes, links, columns: 0, ky: 0, removed };
+  const pending = new Map(nodes.map((node) => [node.id, node.incoming.length]));
+  const queue = nodes.filter((node) => node.incoming.length === 0);
+  while (queue.length > 0) {
+    const node = queue.shift();
+    for (const link of node.outgoing) {
+      link.target.column = Math.max(link.target.column, node.column + 1);
+      const left = pending.get(link.target.id) - 1;
+      pending.set(link.target.id, left);
+      if (left === 0) queue.push(link.target);
+    }
+  }
+  const fixed = new Map(nodesInput.map((input) => [input.id, input.column]));
+  for (const node of nodes) {
+    const column = fixed.get(node.id);
+    if (column != null && column >= 0) node.column = Math.floor(column);
+  }
+  let last = 0;
+  for (const node of nodes) last = Math.max(last, node.column);
+  if (align === "justify") {
+    for (const node of nodes) {
+      if (node.outgoing.length === 0 && fixed.get(node.id) == null) node.column = last;
+    }
+  }
+  const columns = Array.from({ length: last + 1 }, () => []);
+  for (const node of nodes) columns[node.column]?.push(node);
+  const step = last > 0 ? (width - nodeWidth) / last : 0;
+  for (const node of nodes) {
+    node.x0 = node.column * step;
+    node.x1 = node.x0 + nodeWidth;
+  }
+  const crowded = Math.max(...columns.map((column) => column.length));
+  const padding = Math.min(nodePadding, crowded > 1 ? height * 0.4 / (crowded - 1) : nodePadding);
+  const ky = Math.min(
+    ...columns.filter((column) => column.length > 0).map(
+      (column) => (height - (column.length - 1) * padding) / column.reduce((sum, node) => sum + node.value, 0)
+    )
+  );
+  for (const column of columns) {
+    let y = 0;
+    for (const node of column) {
+      node.y0 = y;
+      node.y1 = y + node.value * ky;
+      y = node.y1 + padding;
+    }
+    const free = height - (y - padding);
+    for (const node of column) {
+      node.y0 += free / 2;
+      node.y1 += free / 2;
+    }
+  }
+  for (let i = 0; i < (options.relax === false ? 0 : iterations); i++) {
+    const alpha = 0.99 ** i;
+    const strength = Math.max(1 - alpha, 0.5);
+    for (let c = columns.length - 2; c >= 0; c--) {
+      const column = columns[c];
+      for (const node of column) {
+        if (node.outgoing.length === 0) continue;
+        let weight = 0;
+        let sum = 0;
+        for (const link of node.outgoing) {
+          sum += centre(link.target) * link.value;
+          weight += link.value;
+        }
+        const shift = (sum / weight - centre(node)) * strength;
+        node.y0 += shift;
+        node.y1 += shift;
+      }
+      resolveCollisions(column, height, padding);
+    }
+    for (let c = 1; c < columns.length; c++) {
+      const column = columns[c];
+      for (const node of column) {
+        if (node.incoming.length === 0) continue;
+        let weight = 0;
+        let sum = 0;
+        for (const link of node.incoming) {
+          sum += centre(link.source) * link.value;
+          weight += link.value;
+        }
+        const shift = (sum / weight - centre(node)) * strength;
+        node.y0 += shift;
+        node.y1 += shift;
+      }
+      resolveCollisions(column, height, padding);
+    }
+  }
+  for (const link of links) link.width = link.value * ky;
+  for (const node of nodes) {
+    node.outgoing.sort((a, b) => a.target.y0 - b.target.y0 || a.target.index - b.target.index);
+    node.incoming.sort((a, b) => a.source.y0 - b.source.y0 || a.source.index - b.source.index);
+    let y = node.y0;
+    for (const link of node.outgoing) {
+      link.y0 = y + link.width / 2;
+      y += link.width;
+    }
+    y = node.y0;
+    for (const link of node.incoming) {
+      link.y1 = y + link.width / 2;
+      y += link.width;
+    }
+  }
+  return { nodes, links, columns: columns.length, ky, removed };
+}
+function sankeyLinkPath(link) {
+  const x0 = link.source.x1;
+  const x1 = link.target.x0;
+  const mid = (x0 + x1) / 2;
+  const r = (n) => Math.round(n * 100) / 100;
+  return `M${r(x0)},${r(link.y0)}C${r(mid)},${r(link.y0)} ${r(mid)},${r(link.y1)} ${r(x1)},${r(link.y1)}`;
+}
+function sankeyFlowOf(node) {
+  const nodes = /* @__PURE__ */ new Set([node.id]);
+  const linkIds = /* @__PURE__ */ new Set();
+  const walk = (start, forward) => {
+    const stack = [start];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      for (const link of forward ? current.outgoing : current.incoming) {
+        if (linkIds.has(link.id)) continue;
+        linkIds.add(link.id);
+        const next = forward ? link.target : link.source;
+        nodes.add(next.id);
+        stack.push(next);
+      }
+    }
+  };
+  walk(node, true);
+  walk(node, false);
+  return { nodes, links: linkIds };
+}
+function sankeyTraceOf(link) {
+  const nodes = /* @__PURE__ */ new Set([link.source.id, link.target.id]);
+  const linkIds = /* @__PURE__ */ new Set([link.id]);
+  const walk = (start, forward) => {
+    const stack = [start];
+    const seen = /* @__PURE__ */ new Set([start.id]);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      for (const next of forward ? current.outgoing : current.incoming) {
+        linkIds.add(next.id);
+        const node = forward ? next.target : next.source;
+        nodes.add(node.id);
+        if (!seen.has(node.id)) {
+          seen.add(node.id);
+          stack.push(node);
+        }
+      }
+    }
+  };
+  walk(link.source, false);
+  walk(link.target, true);
+  return { nodes, links: linkIds };
+}
+function sankeyDiff(before, after) {
+  const merged = /* @__PURE__ */ new Map();
+  const add = (links, period) => {
+    for (const link of links) {
+      if (!(Number.isFinite(link.value) && link.value > 0)) continue;
+      const key = `${link.source}->${link.target}`;
+      const entry = merged.get(key) ?? {
+        source: link.source,
+        target: link.target,
+        value: 0,
+        before: 0,
+        after: 0,
+        delta: 0
+      };
+      entry[period] += link.value;
+      merged.set(key, entry);
+    }
+  };
+  add(before, "before");
+  add(after, "after");
+  for (const entry of merged.values()) {
+    entry.value = Math.max(entry.before, entry.after);
+    entry.delta = entry.after - entry.before;
+  }
+  return [...merged.values()];
+}
+function alluvialNodeId(stage, category) {
+  return `${stage}:${category}`;
+}
+function alluvialGraph(input) {
+  const used = /* @__PURE__ */ new Set();
+  const links = [];
+  input.flows.forEach((stage, s) => {
+    for (const flow of stage) {
+      if (!(flow.value > 0)) continue;
+      used.add(alluvialNodeId(s, flow.from));
+      used.add(alluvialNodeId(s + 1, flow.to));
+      links.push({
+        source: alluvialNodeId(s, flow.from),
+        target: alluvialNodeId(s + 1, flow.to),
+        value: flow.value
+      });
+    }
+  });
+  const nodes = [];
+  input.stages.forEach((_, s) => {
+    for (const category of input.categories) {
+      const id = alluvialNodeId(s, category.id);
+      if (used.has(id)) {
+        nodes.push({ id, name: category.name, color: category.color, column: s });
+      }
+    }
+  });
+  return { nodes, links };
+}
+export {
+  alluvialGraph,
+  alluvialNodeId,
+  breakCycles,
+  sankeyDiff,
+  sankeyFlowOf,
+  sankeyLayout,
+  sankeyLinkPath,
+  sankeyTraceOf
+};