@mui/x-charts-pro 8.10.1 → 8.11.0

package/SankeyChart/calculateSankeyLayout.d.ts

@@ -0,0 +1,13 @@
+import type { ChartDrawingArea } from '@mui/x-charts/hooks';
+import type { Theme } from '@mui/material/styles';
+import type { SankeySeriesType, 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(data: DefaultizedSankeySeriesType['data'], drawingArea: ChartDrawingArea, theme: Theme, series?: Pick<SankeySeriesType, 'nodeOptions' | 'linkOptions' | 'iterations'>): SankeyLayout;
+export declare function improvedNaiveSankeyLinkPathHorizontal(link: SankeyLayoutLink, curveCorrection?: number): string;

package/SankeyChart/calculateSankeyLayout.js

@@ -0,0 +1,141 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateSankeyLayout = calculateSankeyLayout;
+exports.improvedNaiveSankeyLinkPathHorizontal = improvedNaiveSankeyLinkPathHorizontal;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _d3Sankey = require("@mui/x-charts-vendor/d3-sankey");
+var _d3Path = require("@mui/x-charts-vendor/d3-path");
+var _utils = require("./utils");
+/**
+ * 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
+ */
+
+function calculateSankeyLayout(data, drawingArea, theme, series = {}) {
+  const {
+    iterations = 6,
+    nodeOptions,
+    linkOptions
+  } = series;
+  const {
+    width: nodeWidth = 15,
+    padding: nodePadding = 10,
+    align: nodeAlign = 'justify',
+    sort: nodeSort = null
+  } = nodeOptions ?? {};
+  const {
+    color: linkColor = (theme.vars || theme).palette.text.primary,
+    sort: linkSort = null,
+    curveCorrection = 10
+  } = linkOptions ?? {};
+  const {
+    width,
+    height,
+    left,
+    top,
+    bottom,
+    right
+  } = drawingArea;
+  if (!data || !data.links) {
+    return {
+      nodes: [],
+      links: []
+    };
+  }
+
+  // Prepare the data structure expected by d3-sankey
+  const graph = {
+    nodes: data.nodes.values().toArray().map(v => (0, _extends2.default)({}, v)),
+    links: data.links.map(v => (0, _extends2.default)({}, v))
+  };
+
+  // Create the sankey layout generator
+  let sankeyGenerator = (0, _d3Sankey.sankey)().nodeWidth(nodeWidth).nodePadding(nodePadding).nodeAlign((0, _utils.getNodeAlignFunction)(nodeAlign)).extent([[left, top], [width + right, height + bottom]]).nodeId(d => d.id).iterations(iterations);
+  if (nodeSort) {
+    sankeyGenerator = sankeyGenerator.nodeSort(nodeSort);
+  }
+  if (linkSort) {
+    sankeyGenerator = sankeyGenerator.linkSort(linkSort);
+  }
+
+  // Generate the layout
+  let result;
+  try {
+    result = sankeyGenerator(graph);
+  } 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 => {
+    // Get the original link data
+    const originalLink = data.links.find(l => {
+      return l.source === link.source.id && l.target === link.target.id;
+    });
+    return (0, _extends2.default)({}, originalLink, link, {
+      color: originalLink?.color ?? linkColor,
+      path: improvedNaiveSankeyLinkPathHorizontal(link, curveCorrection)
+    });
+  });
+  const layoutNodes = nodes.map(node => {
+    const originalNode = data.nodes.get(node.id) || {};
+    return (0, _extends2.default)({}, originalNode, node);
+  });
+  return {
+    nodes: layoutNodes,
+    links: layoutLinks
+  };
+}
+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 = (0, _d3Path.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/SankeyChart/index.d.ts

@@ -0,0 +1,9 @@
+export { SankeyChart as Unstable_SankeyChart } from "./SankeyChart.js";
+export type { SankeyChartProps, SankeySeries } from "./SankeyChart.js";
+export { SankeyPlot } from "./SankeyPlot.js";
+export type { SankeyPlotProps } from "./SankeyPlot.js";
+export * from "./sankey.types.js";
+export * from "./sankeySlots.types.js";
+export { type SankeyPlotClasses, sankeyPlotClasses } from "./sankeyClasses.js";
+export { SankeyTooltip, SankeyTooltipContent } from "./SankeyTooltip/index.js";
+export type { SankeyTooltipProps } from "./SankeyTooltip/index.js";

package/SankeyChart/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Unstable_SankeyChart: true,
+  SankeyPlot: true,
+  sankeyPlotClasses: true,
+  SankeyTooltip: true,
+  SankeyTooltipContent: true
+};
+Object.defineProperty(exports, "SankeyPlot", {
+  enumerable: true,
+  get: function () {
+    return _SankeyPlot.SankeyPlot;
+  }
+});
+Object.defineProperty(exports, "SankeyTooltip", {
+  enumerable: true,
+  get: function () {
+    return _SankeyTooltip.SankeyTooltip;
+  }
+});
+Object.defineProperty(exports, "SankeyTooltipContent", {
+  enumerable: true,
+  get: function () {
+    return _SankeyTooltip.SankeyTooltipContent;
+  }
+});
+Object.defineProperty(exports, "Unstable_SankeyChart", {
+  enumerable: true,
+  get: function () {
+    return _SankeyChart.SankeyChart;
+  }
+});
+Object.defineProperty(exports, "sankeyPlotClasses", {
+  enumerable: true,
+  get: function () {
+    return _sankeyClasses.sankeyPlotClasses;
+  }
+});
+var _SankeyChart = require("./SankeyChart");
+var _SankeyPlot = require("./SankeyPlot");
+var _sankey = require("./sankey.types");
+Object.keys(_sankey).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _sankey[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sankey[key];
+    }
+  });
+});
+var _sankeySlots = require("./sankeySlots.types");
+Object.keys(_sankeySlots).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _sankeySlots[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sankeySlots[key];
+    }
+  });
+});
+var _sankeyClasses = require("./sankeyClasses");
+var _SankeyTooltip = require("./SankeyTooltip");

package/SankeyChart/sankey.types.d.ts

@@ -0,0 +1,225 @@
+import type { HighlightScope, SeriesId } from '@mui/x-charts/internals';
+import type { DefaultizedProps, MakeRequired } from '@mui/x-internals/types';
+import type { SankeyLink as D3SankeyLink, SankeyNode as D3SankeyNode } from '@mui/x-charts-vendor/d3-sankey';
+export type SankeyNodeId = string | number;
+export interface SankeyNode {
+  /**
+   * Unique identifier for the node
+   */
+  id: SankeyNodeId;
+  /**
+   * The node label to display
+   */
+  label?: string;
+  /**
+   * Optional custom data for the node
+   */
+  data?: any;
+  /**
+   * Optional color override for the node
+   */
+  color?: string;
+}
+export interface SankeyLink {
+  /**
+   * Source node ID
+   */
+  source: SankeyNodeId;
+  /**
+   * Target node ID
+   */
+  target: SankeyNodeId;
+  /**
+   * The value/weight of the link (affects width)
+   */
+  value: number;
+  /**
+   * Optional custom data for the link
+   */
+  data?: any;
+  /**
+   * Optional color override for the link
+   */
+  color?: string;
+}
+export type SankeyNodeOptions = {
+  /**
+   * Default color for nodes without specified colors
+   */
+  color?: string;
+  /**
+   * Width of the nodes in pixels
+   */
+  width?: number;
+  /**
+   * Padding between nodes in pixels
+   */
+  padding?: number;
+  /**
+   * Node alignment strategy
+   * - 'justify': Nodes are evenly distributed across the width.
+   * - 'left': Nodes are  aligned to the left.
+   * - 'right': Nodes are aligned to the right.
+   * - 'center': Nodes are centered.
+   * @default 'justify'
+   */
+  align?: 'justify' | 'left' | 'right' | 'center';
+  /**
+   * Whether to show node labels
+   */
+  showLabels?: boolean;
+  /**
+   * Custom sort function for nodes
+   * @param {SankeyLayoutNode} a - First node to compare
+   * @param {SankeyLayoutNode} b - Second node to compare
+   * @returns {number} Comparison result
+   */
+  sort?: (a: SankeyLayoutNode, b: SankeyLayoutNode) => number | null;
+};
+export type SankeyLinkOptions = {
+  /**
+   * Default color for links without specified colors
+   */
+  color?: string;
+  /**
+   * Opacity of the links (0-1)
+   */
+  opacity?: number;
+  /**
+   * Whether to show link values
+   */
+  showValues?: boolean;
+  /**
+   * Custom sort function for links
+   * @param {SankeyLayoutLink} a - First link to compare
+   * @param {SankeyLayoutLink} b - Second link to compare
+   * @returns {number} Comparison result
+   */
+  sort?: (a: SankeyLayoutLink, b: SankeyLayoutLink) => number | null;
+  /**
+   * Applies the given number to the X dimension of the control points of the link's curve function.
+   * This can create better looking links between nodes, but is dependent on the graph layout.
+   * It is specially impacted by the chart height.
+   * @default 10
+   */
+  curveCorrection?: number;
+};
+export interface SankeyData {
+  /**
+   * An array of node configs for the Sankey diagram
+   *
+   * This is optional, but can be used to provide custom labels or styles for nodes.
+   */
+  nodes?: readonly SankeyNode[];
+  /**
+   * Array of links between nodes.
+   *
+   * The node ids will be used as the labels. If you want to provide custom labels, use the `nodes` property.
+   *
+   * Each link should have a `source`, `target`, and `value` property.
+   */
+  links: readonly SankeyLink[];
+}
+export interface SankeySeriesType {
+  /**
+   * Unique identifier for the series
+   */
+  id?: SeriesId;
+  /**
+   * Type identifier for Sankey series
+   */
+  type: 'sankey';
+  /**
+   * The data for the Sankey diagram
+   */
+  data: SankeyData;
+  /**
+   * Optional configuration for the nodes style, layout, and behavior
+   */
+  nodeOptions?: SankeyNodeOptions;
+  /**
+   * Optional configuration for the links style, layout, and behavior
+   */
+  linkOptions?: SankeyLinkOptions;
+  /**
+   * Number of iterations for the layout algorithm
+   * @default 6
+   */
+  iterations?: number;
+}
+/**
+ * Represents the calculated positions and dimensions for a node in the Sankey diagram
+ */
+export interface SankeyLayoutNode extends D3SankeyNode<MakeRequired<SankeyNode, 'label' | 'color'>, SankeyLayoutLink> {
+  targetLinks: SankeyLayoutLink[];
+  sourceLinks: SankeyLayoutLink[];
+  value: number;
+}
+/**
+ * Represents the calculated positions and paths for a link in the Sankey diagram
+ */
+export interface SankeyLayoutLink extends D3SankeyLink<SankeyLayoutNode, Omit<MakeRequired<SankeyLink, 'color'>, 'source' | 'target'>> {
+  path?: string | null;
+  source: SankeyLayoutNode;
+  target: SankeyLayoutNode;
+}
+/**
+ * Calculated layout for the Sankey diagram
+ */
+export interface SankeyLayout {
+  nodes: readonly SankeyLayoutNode[];
+  links: readonly SankeyLayoutLink[];
+}
+export interface DefaultizedSankeySeriesType extends DefaultizedProps<Omit<SankeySeriesType, 'data'>, 'id'> {
+  data: {
+    nodes: Map<SankeyNodeId, SankeyNode>;
+    links: readonly SankeyLink[];
+  };
+  highlightScope?: HighlightScope;
+}
+type SankeyNodeIdentifierBase = {
+  type: 'sankey';
+  /**
+   * Unique identifier for the series
+   */
+  seriesId: SeriesId;
+};
+export type SankeyNodeIdentifier = SankeyNodeIdentifierBase & {
+  /**
+   * Subtype to differentiate between node and link
+   */
+  subType: 'node';
+  /**
+   * The id of the node
+   */
+  nodeId: SankeyNodeId;
+};
+export type SankeyNodeIdentifierWithData = SankeyNodeIdentifier & {
+  /**
+   * The node object with all the calculated properties
+   */
+  node: SankeyLayoutNode;
+};
+export type SankeyLinkIdentifier = SankeyNodeIdentifierBase & {
+  /**
+   * Subtype to differentiate between node and link
+   */
+  subType: 'link';
+  /**
+   * The id of the source node
+   */
+  sourceId: SankeyNodeId;
+  /**
+   * The id of the target node
+   */
+  targetId: SankeyNodeId;
+};
+export type SankeyLinkIdentifierWithData = SankeyLinkIdentifier & {
+  /**
+   * The link object with all the calculated properties
+   */
+  link: SankeyLayoutLink;
+};
+export type SankeyItemIdentifier = SankeyNodeIdentifier | SankeyLinkIdentifier;
+export type SankeyItemIdentifierWithData = SankeyNodeIdentifierWithData | SankeyLinkIdentifierWithData;
+export {};

package/SankeyChart/sankey.types.js

@@ -0,0 +1,6 @@
+"use strict";
+'use client';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/SankeyChart/sankeyClasses.d.ts

@@ -0,0 +1,15 @@
+export interface SankeyPlotClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the nodes container. */
+  nodes: string;
+  /** Styles applied to the links container. */
+  links: string;
+  /** Styles applied to the link label container. */
+  linkLabels: string;
+}
+export declare function getSankeyPlotUtilityClass(slot: string): string;
+export declare const sankeyPlotClasses: SankeyPlotClasses;
+export declare const useUtilityClasses: (ownerState: {
+  classes?: Partial<SankeyPlotClasses>;
+}) => Record<"root" | "nodes" | "links" | "linkLabels", string>;

package/SankeyChart/sankeyClasses.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSankeyPlotUtilityClass = getSankeyPlotUtilityClass;
+exports.useUtilityClasses = exports.sankeyPlotClasses = void 0;
+var _composeClasses = _interopRequireDefault(require("@mui/utils/composeClasses"));
+var _generateUtilityClass = _interopRequireDefault(require("@mui/utils/generateUtilityClass"));
+var _generateUtilityClasses = _interopRequireDefault(require("@mui/utils/generateUtilityClasses"));
+function getSankeyPlotUtilityClass(slot) {
+  return (0, _generateUtilityClass.default)('MuiSankeyChart', slot);
+}
+const sankeyPlotClasses = exports.sankeyPlotClasses = (0, _generateUtilityClasses.default)('MuiSankeyChart', ['root', 'nodes', 'links', 'linkLabels']);
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['root'],
+    nodes: ['nodes'],
+    links: ['links'],
+    linkLabels: ['linkLabels']
+  };
+  return (0, _composeClasses.default)(slots, getSankeyPlotUtilityClass, classes);
+};
+exports.useUtilityClasses = useUtilityClasses;

package/SankeyChart/sankeySlots.types.d.ts

@@ -0,0 +1,24 @@
+import { ChartsOverlaySlotProps, ChartsOverlaySlots } from '@mui/x-charts/ChartsOverlay';
+import { ChartsTooltipProps, ChartsTooltipSlotProps, ChartsTooltipSlots } from '@mui/x-charts/ChartsTooltip';
+import { ChartsSlotProps, ChartsSlots } from '@mui/x-charts/internals';
+import { ChartsToolbarSlotProps, ChartsToolbarSlots } from '@mui/x-charts/Toolbar';
+export interface SankeyChartSlots extends ChartsTooltipSlots, ChartsOverlaySlots, ChartsToolbarSlots, Partial<ChartsSlots> {}
+export interface SankeyChartSlotProps extends Omit<ChartsTooltipSlotProps, 'tooltip'>, ChartsOverlaySlotProps, ChartsToolbarSlotProps, Partial<ChartsSlotProps> {
+  /**
+   * Slot props for the tooltip component.
+   * @default {}
+   */
+  tooltip?: Partial<ChartsTooltipProps<'item' | 'none'>>;
+}
+export interface SankeyChartSlotExtension {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: SankeyChartSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: SankeyChartSlotProps;
+}

package/SankeyChart/sankeySlots.types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/SankeyChart/seriesConfig/getSeriesWithDefaultValues.d.ts

@@ -0,0 +1,2 @@
+import type { GetSeriesWithDefaultValues } from '@mui/x-charts/internals';
+export declare const getSeriesWithDefaultValues: GetSeriesWithDefaultValues<'sankey'>;

package/SankeyChart/seriesConfig/getSeriesWithDefaultValues.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSeriesWithDefaultValues = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+const getSeriesWithDefaultValues = (seriesData, seriesIndex, colors) => {
+  const nodeMap = new Map();
+  const nodeColor = seriesData.nodeOptions?.color;
+  const data = seriesData.data;
+  let colorIndex = -1;
+  if (data.nodes) {
+    data.nodes.forEach(node => {
+      const id = node.id || node.label || '';
+      const label = node.label || `${id}`;
+      colorIndex += 1;
+      nodeMap.set(id, (0, _extends2.default)({}, node, {
+        id,
+        label,
+        color: node.color ?? nodeColor ?? colors?.[colorIndex % colors.length]
+      }));
+    });
+  }
+  data.links.forEach(v => {
+    if (!nodeMap.has(v.source)) {
+      colorIndex += 1;
+      const source = {
+        id: v.source,
+        label: `${v.source}`,
+        color: nodeColor ?? colors?.[colorIndex % colors.length]
+      };
+      nodeMap.set(source.id, source);
+    }
+    if (!nodeMap.has(v.target)) {
+      colorIndex += 1;
+      const target = {
+        id: v.target,
+        label: `${v.target}`,
+        color: nodeColor ?? colors?.[colorIndex % colors.length]
+      };
+      nodeMap.set(target.id, target);
+    }
+  });
+  return (0, _extends2.default)({
+    id: seriesData.id ?? `auto-generated-id-${seriesIndex}`
+  }, seriesData, {
+    data: {
+      links: data.links,
+      nodes: nodeMap
+    }
+  });
+};
+exports.getSeriesWithDefaultValues = getSeriesWithDefaultValues;

package/SankeyChart/seriesConfig/index.d.ts

@@ -0,0 +1,2 @@
+import type { ChartSeriesTypeConfig } from '@mui/x-charts/internals';
+export declare const seriesConfig: ChartSeriesTypeConfig<'sankey'>;

package/SankeyChart/seriesConfig/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.seriesConfig = void 0;
+var _getSeriesWithDefaultValues = require("./getSeriesWithDefaultValues");
+var _tooltipGetter = require("./tooltipGetter");
+// Simple passthrough functions for sankey chart
+const seriesProcessor = series => series;
+const colorProcessor = series => series;
+const legendGetter = () => [];
+const seriesConfig = exports.seriesConfig = {
+  seriesProcessor,
+  colorProcessor,
+  legendGetter,
+  tooltipGetter: _tooltipGetter.tooltipGetter,
+  getSeriesWithDefaultValues: _getSeriesWithDefaultValues.getSeriesWithDefaultValues
+};

package/SankeyChart/seriesConfig/tooltipGetter.d.ts

@@ -0,0 +1,2 @@
+import type { TooltipGetter } from '@mui/x-charts/internals';
+export declare const tooltipGetter: TooltipGetter<'sankey'>;

package/SankeyChart/seriesConfig/tooltipGetter.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tooltipGetter = void 0;
+const tooltipGetter = params => {
+  const {
+    identifier
+  } = params;
+  if (!identifier) {
+    return null;
+  }
+  const {
+    subType
+  } = identifier;
+  if (subType === 'node') {
+    const node = identifier.node;
+    return {
+      identifier,
+      color: node.color,
+      label: `${node.label}:`,
+      value: node.value,
+      formattedValue: `${node.value}`,
+      markType: 'square'
+    };
+  }
+  if (subType === 'link') {
+    const link = identifier.link;
+    if (!link) {
+      return null;
+    }
+    const sourceLabel = link.source.label;
+    const targetLabel = link.target.label;
+    return {
+      identifier,
+      color: link.color,
+      label: `${sourceLabel} → ${targetLabel}:`,
+      value: link.value,
+      formattedValue: `${link.value}`,
+      markType: 'line'
+    };
+  }
+  return null;
+};
+exports.tooltipGetter = tooltipGetter;