@mui/x-charts-pro 9.0.0-alpha.0 → 9.0.0-alpha.2

package/esm/SankeyChart/SankeyTooltip/index.js

@@ -1,3 +0,0 @@
-export * from "./SankeyTooltip.js";
-export * from "./SankeyTooltipContent.js";
-export {};

package/esm/SankeyChart/calculateSankeyLayout.d.ts

@@ -1,12 +0,0 @@
-import type { ChartDrawingArea } from '@mui/x-charts/hooks';
-import type { SankeyLayout, SankeyLayoutLink, DefaultizedSankeySeriesType } from "./sankey.types.js";
-/**
- * Calculates the layout for a Sankey diagram using d3-sankey
- *
- * @param data The Sankey data (nodes and links)
- * @param drawingArea The drawing area dimensions
- * @param options Layout configuration options
- * @returns The calculated layout
- */
-export declare function calculateSankeyLayout(series: DefaultizedSankeySeriesType, drawingArea: ChartDrawingArea): SankeyLayout<true>;
-export declare function improvedNaiveSankeyLinkPathHorizontal(link: SankeyLayoutLink<true>, curveCorrection?: number): string;

package/esm/SankeyChart/calculateSankeyLayout.js

@@ -1,130 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { path } from '@mui/x-charts-vendor/d3-path';
-import { sankey } from "./d3Sankey/index.js";
-import { getNodeAlignFunction } from "./utils.js";
-
-/**
- * Calculates the layout for a Sankey diagram using d3-sankey
- *
- * @param data The Sankey data (nodes and links)
- * @param drawingArea The drawing area dimensions
- * @param options Layout configuration options
- * @returns The calculated layout
- */
-
-export function calculateSankeyLayout(series, drawingArea) {
-  const {
-    data,
-    iterations = 6,
-    nodeOptions,
-    linkOptions
-  } = series;
-  const {
-    width: nodeWidth = 15,
-    padding: nodePadding = 10,
-    align: nodeAlign,
-    sort: nodeSort
-  } = nodeOptions ?? {};
-  const {
-    sort: linkSort,
-    curveCorrection = 10
-  } = linkOptions ?? {};
-  if (!data || !data.links) {
-    return {
-      nodes: [],
-      links: []
-    };
-  }
-  const {
-    width,
-    height,
-    left,
-    top,
-    bottom,
-    right
-  } = drawingArea;
-
-  // Create the sankey layout generator
-  const sankeyGenerator = sankey(true).nodeWidth(nodeWidth).nodePadding(nodePadding).nodeAlign(getNodeAlignFunction(nodeAlign)).nodeId(d => d.id).extent([[left, top], [width + right, height + bottom]]).iterations(iterations);
-
-  // For 'auto' or undefined, don't set anything (use d3-sankey default behavior)
-  if (typeof nodeSort === 'function') {
-    sankeyGenerator.nodeSort(nodeSort);
-  } else if (nodeSort === 'fixed') {
-    // Null is not accepted by the types.
-    // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/73953
-    sankeyGenerator.nodeSort(null);
-  }
-  if (typeof linkSort === 'function') {
-    sankeyGenerator.linkSort(linkSort);
-  } else if (linkSort === 'fixed') {
-    // Null is not accepted by the types.
-    sankeyGenerator.linkSort(null);
-  }
-
-  // Generate the layout
-  let result;
-  try {
-    result = sankeyGenerator(data);
-  } catch (error) {
-    // There are two errors that can occur:
-    // 1. If the data contains circular references, d3-sankey will throw an error.
-    // 2. If there are missing source/target nodes, d3-sankey will throw an error.
-    // We handle the second case by building a map of nodes ourselves, so they are always present.
-    if (error instanceof Error && error.message === 'circular link') {
-      throw new Error('MUI X Charts: Sankey diagram contains circular references.');
-    }
-    throw error;
-  }
-  const {
-    nodes,
-    links
-  } = result;
-
-  // Convert d3-sankey links to our format
-  const layoutLinks = links.map(link => {
-    const rep = _extends({}, link, {
-      path: improvedNaiveSankeyLinkPathHorizontal(link, curveCorrection)
-    });
-    return rep;
-  });
-  return {
-    nodes,
-    links: layoutLinks
-  };
-}
-export function improvedNaiveSankeyLinkPathHorizontal(link, curveCorrection) {
-  const sx = link.source.x1;
-  const tx = link.target.x0;
-  // Weirdly this seems to work for any chart or node width change
-  // But needs to be changed when the sankey height changes.
-  const correction = curveCorrection ?? 5;
-  const y0 = link.y0;
-  const y1 = link.y1;
-  const w = link.width;
-  const halfW = w / 2;
-  const sy0 = y0 - halfW;
-  const sy1 = y0 + halfW;
-  const ty0 = y1 - halfW;
-  const ty1 = y1 + halfW;
-  const halfX = (tx - sx) / 2;
-  const p = path();
-  p.moveTo(sx, sy0);
-  const isDecreasing = y0 > y1;
-  const direction = isDecreasing ? -1 : 1;
-  let cpx1 = sx + halfX + correction * direction;
-  let cpy1 = sy0;
-  let cpx2 = sx + halfX + correction * direction;
-  let cpy2 = ty0;
-  p.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, tx, ty0);
-  p.lineTo(tx, ty1);
-  cpx1 = sx + halfX - correction * direction;
-  cpy1 = ty1;
-  cpx2 = sx + halfX - correction * direction;
-  cpy2 = sy1;
-  p.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, sx, sy1);
-  p.lineTo(sx, sy0);
-  return p.toString();
-}

package/esm/SankeyChart/d3Sankey/align.d.ts

@@ -1,33 +0,0 @@
-import type { SankeyNode } from "./sankey.types.js";
-/**
- * Compute the horizontal node position of a node in a Sankey layout with left alignment.
- * Returns (node.depth) to indicate the desired horizontal position of the node in the generated Sankey diagram.
- *
- * @param node Sankey node for which to calculate the horizontal node position.
- */
-export declare function sankeyLeft<WithPosition extends boolean>(node: SankeyNode<WithPosition, {}, {}>): number;
-/**
- * Compute the horizontal node position of a node in a Sankey layout with right alignment.
- * Returns (n - 1 - node.height) to indicate the desired horizontal position of the node in the generated Sankey diagram.
- *
- * @param node Sankey node for which to calculate the horizontal node position.
- * @param n Total depth n of the graph  (one plus the maximum node.depth)
- */
-export declare function sankeyRight<WithPosition extends boolean>(node: SankeyNode<WithPosition, {}, {}>, n: number): number;
-/**
- * Compute the horizontal node position of a node in a Sankey layout with justified alignment.
- * Like d3.sankeyLeft, except that nodes without any outgoing links are moved to the far right.
- * Returns an integer between 0 and n - 1 that indicates the desired horizontal position of the node in the generated Sankey diagram.
- *
- * @param node Sankey node for which to calculate the horizontal node position.
- * @param n Total depth n of the graph  (one plus the maximum node.depth)
- */
-export declare function sankeyJustify<WithPosition extends boolean>(node: SankeyNode<WithPosition, {}, {}>, n: number): number;
-/**
- * Compute the horizontal node position of a node in a Sankey layout with center alignment.
- * Like d3.sankeyLeft, except that nodes without any incoming links are moved as right as possible.
- * Returns an integer between 0 and n - 1 that indicates the desired horizontal position of the node in the generated Sankey diagram.
- *
- * @param node Sankey node for which to calculate the horizontal node position.
- */
-export declare function sankeyCenter<WithPosition extends boolean>(node: SankeyNode<WithPosition, {}, {}>): number;

package/esm/SankeyChart/d3Sankey/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./sankey.js";
-export * from "./align.js";
-export * from "./sankeyLinkHorizontal.js";
-export * from "./sankey.types.js";

package/esm/SankeyChart/d3Sankey/index.js

@@ -1,4 +0,0 @@
-export * from "./sankey.js";
-export * from "./align.js";
-export * from "./sankeyLinkHorizontal.js";
-export * from "./sankey.types.js";

package/esm/SankeyChart/d3Sankey/sankey.d.ts

@@ -1,42 +0,0 @@
-import type { SankeyExtraProperties, SankeyGraph, SankeyLayout } from "./sankey.types.js";
-/**
- * Get a Sankey layout generator.
- *
- * Invoking sankey() without generics, means the node type and link type assume no user-defined attributes, i.e.
- * only the attributes internally used by the Sankey layout generator.
- *
- * Default nodes/links accessors are assumed.
- */
-export declare function sankey<WithPosition extends boolean>(withoutPositions?: WithPosition): SankeyLayout<WithPosition, SankeyGraph<WithPosition, {}, {}>, {}, {}>;
-/**
- * Get a Sankey layout generator.
- *
- * Default nodes/links accessors are assumed.
- *
- * The first generic N refers to user-defined properties contained in the node data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyNodeMinimal interface.
- *
- * The second generic L refers to user-defined properties contained in the link data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyLinkMinimal interface.
- */
-export declare function sankey<N extends SankeyExtraProperties, L extends SankeyExtraProperties, WithPosition extends boolean>(withoutPositions?: WithPosition): SankeyLayout<WithPosition, SankeyGraph<WithPosition, N, L>, N, L>;
-/**
- * Get a Sankey layout generator.
- *
- * The nodes/links accessors need to be configured to work with the data type of the first argument passed
- * in when invoking the Sankey layout generator.
- *
- * The first generic corresponds to the data type of the first argument passed in when invoking the Sankey layout generator,
- * and its nodes/links accessors.
- *
- * The second generic N refers to user-defined properties contained in the node data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyNodeMinimal interface.
- *
- * The third generic L refers to user-defined properties contained in the link data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyLinkMinimal interface.
- */
-export declare function sankey<Data, N extends SankeyExtraProperties, L extends SankeyExtraProperties, WithPosition extends boolean>(withPositions?: WithPosition): SankeyLayout<WithPosition, Data, N, L>;

package/esm/SankeyChart/d3Sankey/sankey.js

@@ -1,452 +0,0 @@
-/* eslint-disable */
-import { max, min, sum } from '@mui/x-charts-vendor/d3-array';
-import { sankeyJustify } from "./align.js";
-
-// Helper types for internal use within the Sankey layout generator.
-
-function constant(x) {
-  return function () {
-    return x;
-  };
-}
-function ascendingSourceBreadth(a, b) {
-  return ascendingBreadth(a.source, b.source) || a.index - b.index;
-}
-function ascendingTargetBreadth(a, b) {
-  return ascendingBreadth(a.target, b.target) || a.index - b.index;
-}
-function ascendingBreadth(a, b) {
-  return a.y0 - b.y0;
-}
-function value(d) {
-  return d.value;
-}
-function defaultId(d, e, f) {
-  return d.index;
-}
-function defaultNodes(graph) {
-  return graph.nodes;
-}
-function defaultLinks(graph) {
-  return graph.links;
-}
-function find(nodeById, id) {
-  const node = nodeById.get(id);
-  if (!node) {
-    throw new Error('missing: ' + id);
-  }
-  return node;
-}
-function computeLinkBreadths({
-  nodes
-}) {
-  for (const node of nodes) {
-    let y0 = node.y0;
-    let y1 = y0;
-    for (const link of node.sourceLinks) {
-      link.y0 = y0 + link.width / 2;
-      y0 += link.width;
-    }
-    for (const link of node.targetLinks) {
-      link.y1 = y1 + link.width / 2;
-      y1 += link.width;
-    }
-  }
-}
-
-/**
- * Get a Sankey layout generator.
- *
- * Invoking sankey() without generics, means the node type and link type assume no user-defined attributes, i.e.
- * only the attributes internally used by the Sankey layout generator.
- *
- * Default nodes/links accessors are assumed.
- */
-
-/**
- * Get a Sankey layout generator.
- *
- * Default nodes/links accessors are assumed.
- *
- * The first generic N refers to user-defined properties contained in the node data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyNodeMinimal interface.
- *
- * The second generic L refers to user-defined properties contained in the link data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyLinkMinimal interface.
- */
-
-/**
- * Get a Sankey layout generator.
- *
- * The nodes/links accessors need to be configured to work with the data type of the first argument passed
- * in when invoking the Sankey layout generator.
- *
- * The first generic corresponds to the data type of the first argument passed in when invoking the Sankey layout generator,
- * and its nodes/links accessors.
- *
- * The second generic N refers to user-defined properties contained in the node data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyNodeMinimal interface.
- *
- * The third generic L refers to user-defined properties contained in the link data passed into
- * Sankey layout generator. These properties are IN EXCESS to the properties explicitly identified in the
- * SankeyLinkMinimal interface.
- */
-
-export function sankey(withPositions) {
-  let x0 = 0,
-    y0 = 0,
-    x1 = 1,
-    y1 = 1; // extent
-  let dx = 24; // nodeWidth
-  let dy = 8,
-    py; // nodePadding
-  let id = defaultId;
-  let align = sankeyJustify;
-  let sort;
-  let linkSort;
-  let nodes = defaultNodes;
-  let links = defaultLinks;
-  let iterations = 6;
-  function sankey() {
-    const graph = {
-      nodes: nodes.apply(null, arguments),
-      links: links.apply(null, arguments)
-      // It is not really complete at this point, but will mostly be once
-      // computeNodeLinks(graph) is called.
-    };
-    computeNodeLinks(graph);
-    computeNodeValues(graph);
-    computeNodeDepths(graph);
-    computeNodeHeights(graph);
-    computeNodeLayers(graph);
-    if (!withPositions) {
-      return graph;
-    }
-    computeNodeBreadths(graph);
-    computeLinkBreadths(graph);
-    return graph;
-  }
-  sankey.update = function (graph) {
-    computeLinkBreadths(graph);
-    return graph;
-  };
-  sankey.nodeId = function (_) {
-    return arguments.length ? (id = typeof _ === 'function' ? _ : constant(_), sankey) : id;
-  };
-  sankey.nodeAlign = function (_) {
-    return arguments.length ? (align = typeof _ === 'function' ? _ : constant(_), sankey) : align;
-  };
-  sankey.nodeSort = function (_) {
-    return arguments.length ? (sort = _, sankey) : sort;
-  };
-  sankey.nodeWidth = function (_) {
-    return arguments.length ? (dx = +_, sankey) : dx;
-  };
-  sankey.nodePadding = function (_) {
-    return arguments.length ? (dy = py = +_, sankey) : dy;
-  };
-  sankey.nodes = function (_) {
-    return arguments.length ? (nodes = typeof _ === 'function' ? _ : constant(_), sankey) : nodes;
-  };
-  sankey.links = function (_) {
-    return arguments.length ? (links = typeof _ === 'function' ? _ : constant(_), sankey) : links;
-  };
-  sankey.linkSort = function (_) {
-    return arguments.length ? (linkSort = _, sankey) : linkSort;
-  };
-  sankey.size = function (_) {
-    return arguments.length ? (x0 = y0 = 0, x1 = +_[0], y1 = +_[1], sankey) : [x1 - x0, y1 - y0];
-  };
-  sankey.extent = function (_) {
-    return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], sankey) : [[x0, y0], [x1, y1]];
-  };
-  sankey.iterations = function (_) {
-    return arguments.length ? (iterations = +_, sankey) : iterations;
-  };
-  function computeNodeLinks({
-    nodes,
-    links
-  }) {
-    for (const [i, node] of nodes.entries()) {
-      node.index = i;
-      node.sourceLinks = [];
-      node.targetLinks = [];
-    }
-    const nodeById = new Map(nodes.map((d, i) => [id(d, i, nodes), d]));
-    for (const [i, link] of links.entries()) {
-      link.index = i;
-      let {
-        source,
-        target
-      } = link;
-      if (typeof source !== 'object') source = link.source = find(nodeById, source);
-      if (typeof target !== 'object') target = link.target = find(nodeById, target);
-      source.sourceLinks.push(link);
-      target.targetLinks.push(link);
-    }
-    if (linkSort != null) {
-      for (const {
-        sourceLinks,
-        targetLinks
-      } of nodes) {
-        sourceLinks.sort(linkSort);
-        targetLinks.sort(linkSort);
-      }
-    }
-  }
-  function computeNodeValues({
-    nodes
-  }) {
-    for (const node of nodes) {
-      node.value = node.fixedValue === undefined ? Math.max(sum(node.sourceLinks, value), sum(node.targetLinks, value)) : node.fixedValue;
-    }
-  }
-  function computeNodeDepths({
-    nodes
-  }) {
-    const n = nodes.length;
-    let current = new Set(nodes);
-    let next = new Set();
-    let x = 0;
-    while (current.size) {
-      for (const node of current) {
-        node.depth = x;
-        for (const {
-          target
-        } of node.sourceLinks) {
-          next.add(target);
-        }
-      }
-      if (++x > n) throw new Error('circular link');
-      current = next;
-      next = new Set();
-    }
-  }
-  function computeNodeHeights({
-    nodes
-  }) {
-    const n = nodes.length;
-    let current = new Set(nodes);
-    let next = new Set();
-    let x = 0;
-    while (current.size) {
-      for (const node of current) {
-        node.height = x;
-        for (const {
-          source
-        } of node.targetLinks) {
-          next.add(source);
-        }
-      }
-      if (++x > n) throw new Error('circular link');
-      current = next;
-      next = new Set();
-    }
-  }
-  function computeNodeLayers({
-    nodes
-  }) {
-    const x = (max(nodes, d => d.depth) ?? 0) + 1;
-    const kx = (x1 - x0 - dx) / (x - 1);
-    const columns = new Array(x);
-    for (const node of nodes) {
-      const i = Math.max(0, Math.min(x - 1, Math.floor(align.call(null, node, x))));
-      node.layer = i;
-      node.x0 = x0 + i * kx;
-      node.x1 = node.x0 + dx;
-      if (columns[i]) columns[i].push(node);else columns[i] = [node];
-    }
-    if (sort) for (const column of columns) {
-      column.sort(sort);
-    }
-    return columns;
-  }
-  function initializeNodeBreadths(columns) {
-    const ky = min(columns, c => (y1 - y0 - (c.length - 1) * py) / sum(c, value));
-    for (const nodes of columns) {
-      let y = y0;
-      for (const node of nodes) {
-        node.y0 = y;
-        node.y1 = y + node.value * ky;
-        y = node.y1 + py;
-        for (const link of node.sourceLinks) {
-          link.width = link.value * ky;
-        }
-      }
-      y = (y1 - y + py) / (nodes.length + 1);
-      for (let i = 0; i < nodes.length; ++i) {
-        const node = nodes[i];
-        node.y0 += y * (i + 1);
-        node.y1 += y * (i + 1);
-      }
-      reorderLinks(nodes);
-    }
-  }
-  function computeNodeBreadths(graph) {
-    const columns = computeNodeLayers(graph);
-    py = Math.min(dy, (y1 - y0) / (max(columns, c => c.length) - 1));
-    initializeNodeBreadths(columns);
-    for (let i = 0; i < iterations; ++i) {
-      const alpha = Math.pow(0.99, i);
-      const beta = Math.max(1 - alpha, (i + 1) / iterations);
-      relaxRightToLeft(columns, alpha, beta);
-      relaxLeftToRight(columns, alpha, beta);
-    }
-  }
-
-  // Reposition each node based on its incoming (target) links.
-  function relaxLeftToRight(columns, alpha, beta) {
-    for (let i = 1, n = columns.length; i < n; ++i) {
-      const column = columns[i];
-      for (const target of column) {
-        let y = 0;
-        let w = 0;
-        for (const {
-          source,
-          value
-        } of target.targetLinks) {
-          let v = value * (target.layer - source.layer);
-          y += targetTop(source, target) * v;
-          w += v;
-        }
-        if (!(w > 0)) continue;
-        let dy = (y / w - target.y0) * alpha;
-        target.y0 += dy;
-        target.y1 += dy;
-        reorderNodeLinks(target);
-      }
-      if (sort === undefined) column.sort(ascendingBreadth);
-      resolveCollisions(column, beta);
-    }
-  }
-
-  // Reposition each node based on its outgoing (source) links.
-  function relaxRightToLeft(columns, alpha, beta) {
-    for (let n = columns.length, i = n - 2; i >= 0; --i) {
-      const column = columns[i];
-      for (const source of column) {
-        let y = 0;
-        let w = 0;
-        for (const {
-          target,
-          value
-        } of source.sourceLinks) {
-          let v = value * (target.layer - source.layer);
-          y += sourceTop(source, target) * v;
-          w += v;
-        }
-        if (!(w > 0)) continue;
-        let dy = (y / w - source.y0) * alpha;
-        source.y0 += dy;
-        source.y1 += dy;
-        reorderNodeLinks(source);
-      }
-      if (sort === undefined) column.sort(ascendingBreadth);
-      resolveCollisions(column, beta);
-    }
-  }
-  function resolveCollisions(nodes, alpha) {
-    const i = nodes.length >> 1;
-    const subject = nodes[i];
-    resolveCollisionsBottomToTop(nodes, subject.y0 - py, i - 1, alpha);
-    resolveCollisionsTopToBottom(nodes, subject.y1 + py, i + 1, alpha);
-    resolveCollisionsBottomToTop(nodes, y1, nodes.length - 1, alpha);
-    resolveCollisionsTopToBottom(nodes, y0, 0, alpha);
-  }
-
-  // Push any overlapping nodes down.
-  function resolveCollisionsTopToBottom(nodes, y, i, alpha) {
-    for (; i < nodes.length; ++i) {
-      const node = nodes[i];
-      const dy = (y - node.y0) * alpha;
-      if (dy > 1e-6) node.y0 += dy, node.y1 += dy;
-      y = node.y1 + py;
-    }
-  }
-
-  // Push any overlapping nodes up.
-  function resolveCollisionsBottomToTop(nodes, y, i, alpha) {
-    for (; i >= 0; --i) {
-      const node = nodes[i];
-      const dy = (node.y1 - y) * alpha;
-      if (dy > 1e-6) node.y0 -= dy, node.y1 -= dy;
-      y = node.y0 - py;
-    }
-  }
-  function reorderNodeLinks({
-    sourceLinks,
-    targetLinks
-  }) {
-    if (linkSort === undefined) {
-      for (const {
-        source: {
-          sourceLinks
-        }
-      } of targetLinks) {
-        sourceLinks.sort(ascendingTargetBreadth);
-      }
-      for (const {
-        target: {
-          targetLinks
-        }
-      } of sourceLinks) {
-        targetLinks.sort(ascendingSourceBreadth);
-      }
-    }
-  }
-  function reorderLinks(nodes) {
-    if (linkSort === undefined) {
-      for (const {
-        sourceLinks,
-        targetLinks
-      } of nodes) {
-        sourceLinks?.sort(ascendingTargetBreadth);
-        targetLinks?.sort(ascendingSourceBreadth);
-      }
-    }
-  }
-
-  // Returns the target.y0 that would produce an ideal link from source to target.
-  function targetTop(source, target) {
-    let y = source.y0 - (source.sourceLinks.length - 1) * py / 2;
-    for (const {
-      target: node,
-      width
-    } of source.sourceLinks) {
-      if (node === target) break;
-      y += width + py;
-    }
-    for (const {
-      source: node,
-      width
-    } of target.targetLinks) {
-      if (node === source) break;
-      y -= width;
-    }
-    return y;
-  }
-
-  // Returns the source.y0 that would produce an ideal link from source to target.
-  function sourceTop(source, target) {
-    let y = target.y0 - (target.targetLinks.length - 1) * py / 2;
-    for (const {
-      source: node,
-      width
-    } of target.targetLinks) {
-      if (node === source) break;
-      y += width + py;
-    }
-    for (const {
-      target: node,
-      width
-    } of source.sourceLinks) {
-      if (node === target) break;
-      y -= width;
-    }
-    return y;
-  }
-  return sankey;
-}