@mui/x-charts-pro 8.10.1 → 8.11.0

package/esm/SankeyChart/SankeyTooltip/SankeyTooltip.js

@@ -0,0 +1,202 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { ChartsTooltipContainer } from '@mui/x-charts/ChartsTooltip';
+import { SankeyTooltipContent } from "./SankeyTooltipContent.js";
+import { useUtilityClasses } from "./SankeyTooltip.classes.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+function SankeyTooltip(props) {
+  const classes = useUtilityClasses(props);
+  return /*#__PURE__*/_jsx(ChartsTooltipContainer, _extends({
+    trigger: "item"
+  }, props, {
+    classes: classes,
+    children: /*#__PURE__*/_jsx(SankeyTooltipContent, {
+      classes: classes
+    })
+  }));
+}
+process.env.NODE_ENV !== "production" ? SankeyTooltip.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * An HTML element, [virtualElement](https://popper.js.org/docs/v2/virtual-elements/),
+   * or a function that returns either.
+   * It's used to set the position of the popper.
+   * The return value will passed as the reference object of the Popper instance.
+   */
+  anchorEl: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func, PropTypes.shape({
+    contextElement: (props, propName) => {
+      if (props[propName] == null) {
+        return null;
+      }
+      if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+        return new Error(`Expected prop '${propName}' to be of type Element`);
+      }
+      return null;
+    },
+    getBoundingClientRect: PropTypes.func.isRequired
+  })]),
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: PropTypes.elementType,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   *
+   * @deprecated use the `slots` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   * @default {}
+   */
+  components: PropTypes.shape({
+    Root: PropTypes.elementType
+  }),
+  /**
+   * The props used for each slot inside the Popper.
+   *
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   * @default {}
+   */
+  componentsProps: PropTypes.shape({
+    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: PropTypes.oneOfType([(props, propName) => {
+    if (props[propName] == null) {
+      return new Error(`Prop '${propName}' is required but wasn't specified`);
+    }
+    if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+      return new Error(`Expected prop '${propName}' to be of type Element`);
+    }
+    return null;
+  }, PropTypes.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: PropTypes.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Popper.
+   * @default false
+   */
+  keepMounted: PropTypes.bool,
+  /**
+   * Popper.js is based on a "plugin-like" architecture,
+   * most of its features are fully encapsulated "modifiers".
+   *
+   * A modifier is a function that is called each time Popper.js needs to
+   * compute the position of the popper.
+   * For this reason, modifiers should be very performant to avoid bottlenecks.
+   * To learn how to create a modifier, [read the modifiers documentation](https://popper.js.org/docs/v2/modifiers/).
+   */
+  modifiers: PropTypes.arrayOf(PropTypes.shape({
+    data: PropTypes.object,
+    effect: PropTypes.func,
+    enabled: PropTypes.bool,
+    fn: PropTypes.func,
+    name: PropTypes.any,
+    options: PropTypes.object,
+    phase: PropTypes.oneOf(['afterMain', 'afterRead', 'afterWrite', 'beforeMain', 'beforeRead', 'beforeWrite', 'main', 'read', 'write']),
+    requires: PropTypes.arrayOf(PropTypes.string),
+    requiresIfExists: PropTypes.arrayOf(PropTypes.string)
+  })),
+  /**
+   * If `true`, the component is shown.
+   */
+  open: PropTypes.bool,
+  /**
+   * Popper placement.
+   * @default 'bottom'
+   */
+  placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+  /**
+   * Options provided to the [`Popper.js`](https://popper.js.org/docs/v2/constructors/#options) instance.
+   * @default {}
+   */
+  popperOptions: PropTypes.shape({
+    modifiers: PropTypes.array,
+    onFirstUpdate: PropTypes.func,
+    placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']),
+    strategy: PropTypes.oneOf(['absolute', 'fixed'])
+  }),
+  /**
+   * A ref that points to the used popper instance.
+   */
+  popperRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      destroy: PropTypes.func.isRequired,
+      forceUpdate: PropTypes.func.isRequired,
+      setOptions: PropTypes.func.isRequired,
+      state: PropTypes.shape({
+        attributes: PropTypes.object.isRequired,
+        elements: PropTypes.object.isRequired,
+        modifiersData: PropTypes.object.isRequired,
+        options: PropTypes.object.isRequired,
+        orderedModifiers: PropTypes.arrayOf(PropTypes.object).isRequired,
+        placement: PropTypes.oneOf(['auto-end', 'auto-start', 'auto', 'bottom-end', 'bottom-start', 'bottom', 'left-end', 'left-start', 'left', 'right-end', 'right-start', 'right', 'top-end', 'top-start', 'top']).isRequired,
+        rects: PropTypes.object.isRequired,
+        reset: PropTypes.bool.isRequired,
+        scrollParents: PropTypes.object.isRequired,
+        strategy: PropTypes.oneOf(['absolute', 'fixed']).isRequired,
+        styles: PropTypes.object.isRequired
+      }).isRequired,
+      update: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * The props used for each slot inside the Popper.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * The components used for each slot inside the Popper.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * Help supporting a react-transition-group/Transition component.
+   * @default false
+   */
+  transition: PropTypes.bool,
+  /**
+   * Select the kind of tooltip to display
+   * - 'item': Shows data about the item below the mouse.
+   * - 'none': Does not display tooltip
+   * @default 'item'
+   */
+  trigger: PropTypes.oneOf(['item', 'none'])
+} : void 0;
+export { SankeyTooltip };

package/esm/SankeyChart/SankeyTooltip/SankeyTooltip.types.d.ts

@@ -0,0 +1,10 @@
+import { ChartsTooltipContainerProps } from '@mui/x-charts/ChartsTooltip';
+export interface SankeyTooltipProps extends Omit<ChartsTooltipContainerProps, 'trigger' | 'children'> {
+  /**
+   * Select the kind of tooltip to display
+   * - 'item': Shows data about the item below the mouse.
+   * - 'none': Does not display tooltip
+   * @default 'item'
+   */
+  trigger?: 'item' | 'none';
+}

package/esm/SankeyChart/SankeyTooltip/SankeyTooltip.types.js

@@ -0,0 +1 @@
+export {};

package/esm/SankeyChart/SankeyTooltip/SankeyTooltipContent.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { SankeyTooltipProps } from "./SankeyTooltip.types.js";
+export interface SankeyTooltipContentProps extends Pick<SankeyTooltipProps, 'classes'> {}
+export declare function SankeyTooltipContent(props: SankeyTooltipContentProps): React.JSX.Element | null;
+export declare namespace SankeyTooltipContent {
+  var propTypes: any;
+}

package/esm/SankeyChart/SankeyTooltip/SankeyTooltipContent.js

@@ -0,0 +1,59 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import { ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipRow, ChartsTooltipCell, useItemTooltip } from '@mui/x-charts/ChartsTooltip';
+import { ChartsLabelMark } from '@mui/x-charts/internals';
+import { useUtilityClasses } from "./SankeyTooltip.classes.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function SankeyTooltipContent(props) {
+  const classes = useUtilityClasses(props);
+  const tooltipData = useItemTooltip();
+  if (!tooltipData) {
+    return null;
+  }
+  const {
+    color,
+    formattedValue,
+    markType,
+    label
+  } = tooltipData;
+  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
+    className: classes.paper,
+    children: /*#__PURE__*/_jsx(ChartsTooltipTable, {
+      className: classes.table,
+      children: /*#__PURE__*/_jsx("tbody", {
+        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+          className: classes.row,
+          children: [/*#__PURE__*/_jsxs(ChartsTooltipCell, {
+            className: clsx(classes.cell),
+            component: "th",
+            children: [/*#__PURE__*/_jsx("div", {
+              className: classes.markContainer,
+              children: /*#__PURE__*/_jsx(ChartsLabelMark, {
+                type: markType,
+                color: color,
+                className: classes.mark
+              })
+            }), label]
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes.valueCell, classes.cell),
+            component: "td",
+            children: formattedValue
+          })]
+        })
+      })
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? SankeyTooltipContent.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object
+} : void 0;

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

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

package/esm/SankeyChart/SankeyTooltip/index.js

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

package/esm/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/esm/SankeyChart/calculateSankeyLayout.js

@@ -0,0 +1,135 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { sankey } from '@mui/x-charts-vendor/d3-sankey';
+import { path } from '@mui/x-charts-vendor/d3-path';
+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(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 => _extends({}, v)),
+    links: data.links.map(v => _extends({}, v))
+  };
+
+  // Create the sankey layout generator
+  let sankeyGenerator = sankey().nodeWidth(nodeWidth).nodePadding(nodePadding).nodeAlign(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 _extends({}, originalLink, link, {
+      color: originalLink?.color ?? linkColor,
+      path: improvedNaiveSankeyLinkPathHorizontal(link, curveCorrection)
+    });
+  });
+  const layoutNodes = nodes.map(node => {
+    const originalNode = data.nodes.get(node.id) || {};
+    return _extends({}, originalNode, node);
+  });
+  return {
+    nodes: layoutNodes,
+    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/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/esm/SankeyChart/index.js

@@ -0,0 +1,6 @@
+export { SankeyChart as Unstable_SankeyChart } from "./SankeyChart.js";
+export { SankeyPlot } from "./SankeyPlot.js";
+export * from "./sankey.types.js";
+export * from "./sankeySlots.types.js";
+export { sankeyPlotClasses } from "./sankeyClasses.js";
+export { SankeyTooltip, SankeyTooltipContent } from "./SankeyTooltip/index.js";

package/esm/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/esm/SankeyChart/sankey.types.js

@@ -0,0 +1,3 @@
+'use client';
+
+export {};