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

package/esm/SankeyChart/SankeyNodeElement.d.ts

@@ -1,23 +0,0 @@
-import * as React from 'react';
-import type { SeriesId } from '@mui/x-charts/internals';
-import type { SankeyLayoutNode, SankeyNodeIdentifierWithData } from "./sankey.types.js";
-export interface SankeyNodeElementProps {
-  /**
-   * The series ID to which the node belongs
-   */
-  seriesId: SeriesId;
-  /**
-   * The node data
-   */
-  node: SankeyLayoutNode;
-  /**
-   * Callback fired when a sankey item is clicked.
-   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
-   * @param {SankeyNodeIdentifierWithData} node The sankey node identifier.
-   */
-  onClick?: (event: React.MouseEvent<SVGElement, MouseEvent>, node: SankeyNodeIdentifierWithData) => void;
-}
-/**
- * @ignore - internal component.
- */
-export declare const SankeyNodeElement: React.ForwardRefExoticComponent<SankeyNodeElementProps & React.RefAttributes<SVGGElement>>;

package/esm/SankeyChart/SankeyNodeElement.js

@@ -1,65 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useEventCallback from '@mui/utils/useEventCallback';
-import { useInteractionItemProps, useStore } from '@mui/x-charts/internals';
-import { selectorIsNodeHighlighted } from "./plugins/index.js";
-import { selectorIsSankeyItemFaded } from "./plugins/useSankeyHighlight.selectors.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * @ignore - internal component.
- */
-export const SankeyNodeElement = /*#__PURE__*/React.forwardRef(function SankeyNodeElement(props, ref) {
-  const {
-    node,
-    onClick,
-    seriesId
-  } = props;
-  const store = useStore();
-  const x0 = node.x0 ?? 0;
-  const y0 = node.y0 ?? 0;
-  const x1 = node.x1 ?? 0;
-  const y1 = node.y1 ?? 0;
-  const nodeWidth = x1 - x0;
-  const nodeHeight = y1 - y0;
-  const identifier = {
-    type: 'sankey',
-    seriesId,
-    subType: 'node',
-    nodeId: node.id,
-    node
-  };
-  const isHighlighted = store.use(selectorIsNodeHighlighted, node.id);
-  const isFaded = store.use(selectorIsSankeyItemFaded, isHighlighted);
-
-  // Add interaction props for tooltips
-  const interactionProps = useInteractionItemProps(identifier);
-  const handleClick = useEventCallback(event => {
-    onClick?.(event, identifier);
-  });
-  let opacity = 1;
-  if (isFaded) {
-    opacity = 0.3;
-  } else if (isHighlighted) {
-    opacity = 1;
-  }
-  return /*#__PURE__*/_jsx("g", {
-    ref: ref,
-    "data-node": node.id,
-    children: /*#__PURE__*/_jsx("rect", _extends({
-      x: node.x0,
-      y: node.y0,
-      width: nodeWidth,
-      height: nodeHeight,
-      fill: node.color,
-      opacity: opacity,
-      onClick: onClick ? handleClick : undefined,
-      cursor: onClick ? 'pointer' : 'default',
-      stroke: "none",
-      "data-highlighted": isHighlighted || undefined,
-      "data-faded": isFaded || undefined
-    }, interactionProps))
-  });
-});
-if (process.env.NODE_ENV !== "production") SankeyNodeElement.displayName = "SankeyNodeElement";

package/esm/SankeyChart/SankeyNodeLabel.d.ts

@@ -1,12 +0,0 @@
-import * as React from 'react';
-import type { SankeyLayoutNode } from "./sankey.types.js";
-export interface SankeyNodeLabelProps {
-  /**
-   * The node data
-   */
-  node: SankeyLayoutNode;
-}
-/**
- * @ignore - internal component.
- */
-export declare const SankeyNodeLabel: React.ForwardRefExoticComponent<SankeyNodeLabelProps & React.RefAttributes<SVGTextElement>>;

package/esm/SankeyChart/SankeyNodeLabel.js

@@ -1,52 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { useTheme } from '@mui/material/styles';
-import { useSankeyNodeHighlightState } from "./sankeyHighlightHooks.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * @ignore - internal component.
- */
-export const SankeyNodeLabel = /*#__PURE__*/React.forwardRef(function SankeyNodeLabel(props, ref) {
-  const {
-    node
-  } = props;
-  const theme = useTheme();
-  const x0 = node.x0 ?? 0;
-  const y0 = node.y0 ?? 0;
-  const x1 = node.x1 ?? 0;
-  const y1 = node.y1 ?? 0;
-  const isRightSide = node.depth === 0;
-
-  // Determine label position
-  const labelX = isRightSide ? x1 + 6 // Right side for first column
-  : x0 - 6; // Left side for other columns
-
-  const labelAnchor = isRightSide ? 'start' : 'end';
-  const highlightState = useSankeyNodeHighlightState(node.id);
-  let opacity = 1;
-  if (highlightState === 'faded') {
-    opacity = 0.3;
-  } else if (highlightState === 'highlighted') {
-    opacity = 1;
-  }
-  if (!node.label) {
-    return null;
-  }
-  return /*#__PURE__*/_jsx("text", {
-    ref: ref,
-    x: labelX,
-    y: (y0 + y1) / 2,
-    textAnchor: labelAnchor,
-    fill: (theme.vars || theme).palette.text.primary,
-    fontSize: theme.typography.caption.fontSize,
-    fontFamily: theme.typography.fontFamily,
-    pointerEvents: "none",
-    opacity: opacity,
-    "data-node": node.id,
-    "data-highlighted": highlightState === 'highlighted' || undefined,
-    "data-faded": highlightState === 'faded' || undefined,
-    children: node.label
-  });
-});
-if (process.env.NODE_ENV !== "production") SankeyNodeLabel.displayName = "SankeyNodeLabel";

package/esm/SankeyChart/SankeyNodeLabelPlot.d.ts

@@ -1,9 +0,0 @@
-import { type SankeyPlotClasses } from "./sankeyClasses.js";
-export interface SankeyNodeLabelPlotProps {
-  /**
-   * Classes applied to the various elements.
-   */
-  classes?: Partial<SankeyPlotClasses>;
-}
-declare function SankeyNodeLabelPlot(props: SankeyNodeLabelPlotProps): import("react/jsx-runtime").JSX.Element | null;
-export { SankeyNodeLabelPlot };

package/esm/SankeyChart/SankeyNodeLabelPlot.js

@@ -1,35 +0,0 @@
-'use client';
-
-import { useSankeyLayout, useSankeySeries } from "../hooks/useSankeySeries.js";
-import { useUtilityClasses } from "./sankeyClasses.js";
-import { SankeyNodeLabel } from "./SankeyNodeLabel.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-function SankeyNodeLabelPlot(props) {
-  const {
-    classes: inputClasses
-  } = props;
-  const classes = useUtilityClasses({
-    classes: inputClasses
-  });
-  const sankeySeries = useSankeySeries()[0];
-  const layout = useSankeyLayout();
-  if (!sankeySeries) {
-    throw new Error(`MUI X Charts: Sankey series context is missing. Ensure the SankeyPlot is used inside a properly configured ChartDataProviderPro.`);
-  }
-
-  // Early return if no data or dimensions
-  if (!layout || !layout.nodes) {
-    return null;
-  }
-  const showNodeLabels = sankeySeries.nodeOptions?.showLabels ?? true;
-  if (!showNodeLabels) {
-    return null;
-  }
-  return /*#__PURE__*/_jsx("g", {
-    className: classes.nodeLabels,
-    children: layout.nodes.map(node => /*#__PURE__*/_jsx(SankeyNodeLabel, {
-      node: node
-    }, `label-node-${node.id}`))
-  });
-}
-export { SankeyNodeLabelPlot };

package/esm/SankeyChart/SankeyNodePlot.d.ts

@@ -1,17 +0,0 @@
-import * as React from 'react';
-import type { SankeyNodeIdentifierWithData } from "./sankey.types.js";
-import { type SankeyPlotClasses } from "./sankeyClasses.js";
-export interface SankeyNodePlotProps {
-  /**
-   * Classes applied to the various elements.
-   */
-  classes?: Partial<SankeyPlotClasses>;
-  /**
-   * Callback fired when a sankey item is clicked.
-   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
-   * @param {SankeyNodeIdentifierWithData} node The sankey node identifier.
-   */
-  onClick?: (event: React.MouseEvent<SVGElement, MouseEvent>, node: SankeyNodeIdentifierWithData) => void;
-}
-declare function SankeyNodePlot(props: SankeyNodePlotProps): import("react/jsx-runtime").JSX.Element | null;
-export { SankeyNodePlot };

package/esm/SankeyChart/SankeyNodePlot.js

@@ -1,48 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import { styled } from '@mui/material/styles';
-import { SankeyNodeElement } from "./SankeyNodeElement.js";
-import { useSankeyLayout, useSankeySeries } from "../hooks/useSankeySeries.js";
-import { useUtilityClasses } from "./sankeyClasses.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const SankeyNodePlotRoot = styled('g', {
-  slot: 'internal',
-  shouldForwardProp: undefined
-})({
-  transition: 'opacity 0.1s ease-out, filter 0.1s ease-out',
-  '& [data-faded=true]': {
-    filter: 'saturate(80%)'
-  },
-  '& [data-highlighted=true]': {
-    filter: 'saturate(120%)'
-  }
-});
-function SankeyNodePlot(props) {
-  const {
-    classes: inputClasses,
-    onClick
-  } = props;
-  const classes = useUtilityClasses({
-    classes: inputClasses
-  });
-  const sankeySeries = useSankeySeries()[0];
-  const layout = useSankeyLayout();
-  if (!sankeySeries) {
-    throw new Error(`MUI X Charts: Sankey series context is missing. Ensure the SankeyPlot is used inside a properly configured ChartDataProviderPro.`);
-  }
-
-  // Early return if no data or dimensions
-  if (!layout || !layout.nodes) {
-    return null;
-  }
-  return /*#__PURE__*/_jsx(SankeyNodePlotRoot, {
-    className: classes.nodes,
-    children: layout.nodes.map(node => /*#__PURE__*/_jsx(SankeyNodeElement, {
-      seriesId: sankeySeries.id,
-      node: node,
-      onClick: onClick
-    }, node.id))
-  });
-}
-export { SankeyNodePlot };

package/esm/SankeyChart/SankeyPlot.d.ts

@@ -1,29 +0,0 @@
-import * as React from 'react';
-import { type SankeyLinkIdentifierWithData, type SankeyNodeIdentifierWithData } from "./sankey.types.js";
-import { type SankeyPlotClasses } from "./sankeyClasses.js";
-export interface SankeyPlotProps {
-  /**
-   * Classes applied to the various elements.
-   */
-  classes?: Partial<SankeyPlotClasses>;
-  /**
-   * Callback fired when a sankey item is clicked.
-   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
-   * @param {SankeyNodeIdentifierWithData} node The sankey node identifier.
-   */
-  onNodeClick?: (event: React.MouseEvent<SVGElement, MouseEvent>, node: SankeyNodeIdentifierWithData) => void;
-  /**
-   * Callback fired when a sankey item is clicked.
-   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
-   * @param {SankeyLinkIdentifierWithData} link The sankey link identifier.
-   */
-  onLinkClick?: (event: React.MouseEvent<SVGElement, MouseEvent>, link: SankeyLinkIdentifierWithData) => void;
-}
-/**
- * Renders a Sankey diagram plot.
- */
-declare function SankeyPlot(props: SankeyPlotProps): import("react/jsx-runtime").JSX.Element | null;
-declare namespace SankeyPlot {
-  var propTypes: any;
-}
-export { SankeyPlot };

package/esm/SankeyChart/SankeyPlot.js

@@ -1,82 +0,0 @@
-'use client';
-
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { styled } from '@mui/material/styles';
-import { useSankeyLayout, useSankeySeries } from "../hooks/useSankeySeries.js";
-import { useUtilityClasses } from "./sankeyClasses.js";
-import { SankeyNodePlot } from "./SankeyNodePlot.js";
-import { SankeyLinkPlot } from "./SankeyLinkPlot.js";
-import { SankeyNodeLabelPlot } from "./SankeyNodeLabelPlot.js";
-import { SankeyLinkLabelPlot } from "./SankeyLinkLabelPlot.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const SankeyPlotRoot = styled('g', {
-  slot: 'internal',
-  shouldForwardProp: undefined
-})({});
-
-/**
- * Renders a Sankey diagram plot.
- */
-function SankeyPlot(props) {
-  const {
-    classes: inputClasses,
-    onLinkClick,
-    onNodeClick
-  } = props;
-  const classes = useUtilityClasses({
-    classes: inputClasses
-  });
-  const sankeySeries = useSankeySeries()[0];
-  const layout = useSankeyLayout();
-  if (!sankeySeries) {
-    throw new Error(`MUI X Charts: Sankey series context is missing. Ensure the SankeyPlot is used inside a properly configured ChartDataProviderPro.`);
-  }
-
-  // Early return if no data or dimensions
-  if (!layout || !layout.links) {
-    return null;
-  }
-  const {
-    linkOptions,
-    nodeOptions
-  } = sankeySeries;
-  const showNodeLabels = nodeOptions?.showLabels ?? true;
-  return /*#__PURE__*/_jsxs(SankeyPlotRoot, {
-    className: classes.root,
-    children: [/*#__PURE__*/_jsx(SankeyLinkPlot, {
-      classes: classes,
-      onClick: onLinkClick
-    }), /*#__PURE__*/_jsx(SankeyNodePlot, {
-      classes: classes,
-      onClick: onNodeClick
-    }), linkOptions?.showValues && /*#__PURE__*/_jsx(SankeyLinkLabelPlot, {
-      classes: classes
-    }), showNodeLabels && /*#__PURE__*/_jsx(SankeyNodeLabelPlot, {
-      classes: classes
-    })]
-  });
-}
-process.env.NODE_ENV !== "production" ? SankeyPlot.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  /**
-   * Classes applied to the various elements.
-   */
-  classes: PropTypes.object,
-  /**
-   * Callback fired when a sankey item is clicked.
-   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
-   * @param {SankeyLinkIdentifierWithData} link The sankey link identifier.
-   */
-  onLinkClick: PropTypes.func,
-  /**
-   * Callback fired when a sankey item is clicked.
-   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
-   * @param {SankeyNodeIdentifierWithData} node The sankey node identifier.
-   */
-  onNodeClick: PropTypes.func
-} : void 0;
-export { SankeyPlot };

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

@@ -1,2 +0,0 @@
-import type { SankeyTooltipProps } from "./SankeyTooltip.types.js";
-export declare const useUtilityClasses: (props: Pick<SankeyTooltipProps, "classes">) => Record<"mark" | "table" | "cell" | "row" | "root" | "paper" | "markContainer" | "labelCell" | "valueCell", string>;

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

@@ -1,6 +0,0 @@
-import { type SankeyTooltipProps } from "./SankeyTooltip.types.js";
-declare function SankeyTooltip(props: SankeyTooltipProps): import("react/jsx-runtime").JSX.Element;
-declare namespace SankeyTooltip {
-  var propTypes: any;
-}
-export { SankeyTooltip };

package/esm/SankeyChart/SankeyTooltip/SankeyTooltip.js

@@ -1,210 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-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"  |
-  // ----------------------------------------------------------------------
-  /**
-   * Determine if the tooltip should be placed on the pointer location or on the node.
-   * @default 'pointer'
-   */
-  anchor: PropTypes.oneOf(['node', 'pointer']),
-  /**
-   * 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
-    })
-  })]),
-  /**
-   * Determines the tooltip position relatively to the anchor.
-   */
-  position: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
-  /**
-   * 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/SankeyTooltipContent.d.ts

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

package/esm/SankeyChart/SankeyTooltip/SankeyTooltipContent.js

@@ -1,58 +0,0 @@
-'use client';
-
-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

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