@mui/x-charts 7.0.0-alpha.2 → 7.0.0-alpha.3

package/legacy/ChartsTooltip/DefaultChartsAxisTooltipContent.js

@@ -0,0 +1,167 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import Typography from '@mui/material/Typography';
+import { ChartsTooltipCell, ChartsTooltipPaper, ChartsTooltipTable, ChartsTooltipMark, ChartsTooltipRow } from './ChartsTooltipTable';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+function DefaultChartsAxisTooltipContent(props) {
+  var _axis$valueFormatter;
+  var series = props.series,
+    axis = props.axis,
+    dataIndex = props.dataIndex,
+    axisValue = props.axisValue,
+    sx = props.sx,
+    classes = props.classes;
+  if (dataIndex == null) {
+    return null;
+  }
+  var axisFormatter = (_axis$valueFormatter = axis.valueFormatter) != null ? _axis$valueFormatter : function (v) {
+    return v.toLocaleString();
+  };
+  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
+    sx: sx,
+    className: classes.root,
+    children: /*#__PURE__*/_jsxs(ChartsTooltipTable, {
+      className: classes.table,
+      children: [axisValue != null && !axis.hideTooltip && /*#__PURE__*/_jsx("thead", {
+        children: /*#__PURE__*/_jsx(ChartsTooltipRow, {
+          children: /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            colSpan: 3,
+            children: /*#__PURE__*/_jsx(Typography, {
+              children: axisFormatter(axisValue)
+            })
+          })
+        })
+      }), /*#__PURE__*/_jsx("tbody", {
+        children: series.map(function (_ref) {
+          var color = _ref.color,
+            id = _ref.id,
+            label = _ref.label,
+            valueFormatter = _ref.valueFormatter,
+            data = _ref.data;
+          var formattedValue = valueFormatter(data[dataIndex]);
+          if (formattedValue == null) {
+            return null;
+          }
+          return /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+            className: classes.row,
+            children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+              className: clsx(classes.markCell, classes.cell),
+              children: /*#__PURE__*/_jsx(ChartsTooltipMark, {
+                ownerState: {
+                  color: color
+                },
+                boxShadow: 1,
+                className: classes.mark
+              })
+            }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+              className: clsx(classes.labelCell, classes.cell),
+              children: label ? /*#__PURE__*/_jsx(Typography, {
+                children: label
+              }) : null
+            }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+              className: clsx(classes.valueCell, classes.cell),
+              children: /*#__PURE__*/_jsx(Typography, {
+                children: formattedValue
+              })
+            })]
+          }, id);
+        })
+      })]
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? DefaultChartsAxisTooltipContent.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The properties of the triggered axis.
+   */
+  axis: PropTypes.shape({
+    axisId: PropTypes.string,
+    classes: PropTypes.object,
+    data: PropTypes.array,
+    dataKey: PropTypes.string,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    hideTooltip: PropTypes.bool,
+    id: PropTypes.string.isRequired,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    labelStyle: PropTypes.object,
+    max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+    min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
+    position: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
+    scale: PropTypes.func.isRequired,
+    scaleType: PropTypes.oneOf(['time']).isRequired,
+    slotProps: PropTypes.object,
+    slots: PropTypes.object,
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickInterval: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.array, PropTypes.func]),
+    tickLabelInterval: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.func]),
+    tickLabelStyle: PropTypes.object,
+    tickMaxStep: PropTypes.number,
+    tickMinStep: PropTypes.number,
+    tickNumber: PropTypes.number.isRequired,
+    tickSize: PropTypes.number,
+    valueFormatter: PropTypes.func
+  }).isRequired,
+  /**
+   * Data identifying the triggered axis.
+   */
+  axisData: PropTypes.shape({
+    x: PropTypes.shape({
+      index: PropTypes.number,
+      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+    }),
+    y: PropTypes.shape({
+      index: PropTypes.number,
+      value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired
+    })
+  }).isRequired,
+  /**
+   * The value associated to the current mouse position.
+   */
+  axisValue: PropTypes.any.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object.isRequired,
+  /**
+   * The index of the data item triggered.
+   */
+  dataIndex: PropTypes.number,
+  /**
+   * The series linked to the triggered axis.
+   */
+  series: PropTypes.arrayOf(PropTypes.shape({
+    area: PropTypes.bool,
+    color: PropTypes.string.isRequired,
+    connectNulls: PropTypes.bool,
+    curve: PropTypes.oneOf(['catmullRom', 'linear', 'monotoneX', 'monotoneY', 'natural', 'step', 'stepAfter', 'stepBefore']),
+    data: PropTypes.arrayOf(PropTypes.number).isRequired,
+    dataKey: PropTypes.string,
+    disableHighlight: PropTypes.bool,
+    highlightScope: PropTypes.shape({
+      faded: PropTypes.oneOf(['global', 'none', 'series']),
+      highlighted: PropTypes.oneOf(['item', 'none', 'series'])
+    }),
+    id: PropTypes.string.isRequired,
+    label: PropTypes.string,
+    showMark: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
+    stack: PropTypes.string,
+    stackOffset: PropTypes.oneOf(['diverging', 'expand', 'none', 'silhouette', 'wiggle']),
+    stackOrder: PropTypes.oneOf(['appearance', 'ascending', 'descending', 'insideOut', 'none', 'reverse']),
+    type: PropTypes.oneOf(['line']).isRequired,
+    valueFormatter: PropTypes.func.isRequired,
+    xAxisKey: PropTypes.string,
+    yAxisKey: PropTypes.string
+  })).isRequired,
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export { DefaultChartsAxisTooltipContent };

package/legacy/ChartsTooltip/DefaultChartsItemTooltipContent.js

@@ -0,0 +1,89 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import { ChartsTooltipTable, ChartsTooltipCell, ChartsTooltipMark, ChartsTooltipPaper, ChartsTooltipRow } from './ChartsTooltipTable';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+function DefaultChartsItemTooltipContent(props) {
+  var series = props.series,
+    itemData = props.itemData,
+    sx = props.sx,
+    classes = props.classes;
+  if (itemData.dataIndex === undefined) {
+    return null;
+  }
+  var _ref = series.type === 'pie' ? {
+      color: series.data[itemData.dataIndex].color,
+      displayedLabel: series.data[itemData.dataIndex].label
+    } : {
+      color: series.color,
+      displayedLabel: series.label
+    },
+    displayedLabel = _ref.displayedLabel,
+    color = _ref.color;
+
+  // TODO: Manage to let TS understand series.data and series.valueFormatter are coherent
+  // @ts-ignore
+  var formattedValue = series.valueFormatter(series.data[itemData.dataIndex]);
+  return /*#__PURE__*/_jsx(ChartsTooltipPaper, {
+    sx: sx,
+    className: classes.root,
+    children: /*#__PURE__*/_jsx(ChartsTooltipTable, {
+      className: classes.table,
+      children: /*#__PURE__*/_jsx("tbody", {
+        children: /*#__PURE__*/_jsxs(ChartsTooltipRow, {
+          className: classes.row,
+          children: [/*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes.markCell, classes.cell),
+            children: /*#__PURE__*/_jsx(ChartsTooltipMark, {
+              ownerState: {
+                color: color
+              },
+              className: classes.mark
+            })
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes.labelCell, classes.cell),
+            children: displayedLabel
+          }), /*#__PURE__*/_jsx(ChartsTooltipCell, {
+            className: clsx(classes.valueCell, classes.cell),
+            children: formattedValue
+          })]
+        })
+      })
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? DefaultChartsItemTooltipContent.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: PropTypes.object.isRequired,
+  /**
+   * The data used to identify the triggered item.
+   */
+  itemData: PropTypes.shape({
+    dataIndex: PropTypes.number,
+    seriesId: PropTypes.string.isRequired,
+    type: PropTypes.oneOf(['bar', 'line', 'pie', 'scatter']).isRequired
+  }).isRequired,
+  /**
+   * The series linked to the triggered axis.
+   */
+  series: PropTypes.shape({
+    color: PropTypes.string,
+    data: PropTypes.arrayOf(PropTypes.number).isRequired,
+    highlightScope: PropTypes.shape({
+      faded: PropTypes.oneOf(['global', 'none', 'series']),
+      highlighted: PropTypes.oneOf(['item', 'none', 'series'])
+    }),
+    id: PropTypes.string.isRequired,
+    type: PropTypes.oneOf(['bar', 'line', 'pie', 'scatter']).isRequired,
+    valueFormatter: PropTypes.func.isRequired
+  }).isRequired,
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export { DefaultChartsItemTooltipContent };

package/legacy/ChartsTooltip/index.js

@@ -1,2 +1,6 @@
 export * from './ChartsTooltip';
-export * from './chartsTooltipClasses';
+export * from './chartsTooltipClasses';
+export * from './ChartsAxisTooltipContent';
+export * from './ChartsItemTooltipContent';
+export * from './DefaultChartsAxisTooltipContent';
+export * from './DefaultChartsItemTooltipContent';

package/legacy/ChartsYAxis/ChartsYAxis.js

@@ -65,6 +65,8 @@ function ChartsYAxis(inProps) {
     tickFontSize = defaultizedProps.tickFontSize,
     label = defaultizedProps.label,
     labelFontSize = defaultizedProps.labelFontSize,
+    labelStyle = defaultizedProps.labelStyle,
+    tickLabelStyle = defaultizedProps.tickLabelStyle,
     tickSizeProp = defaultizedProps.tickSize,
     valueFormatter = defaultizedProps.valueFormatter,
     slots = defaultizedProps.slots,
@@ -97,11 +99,11 @@ function ChartsYAxis(inProps) {
     elementType: TickLabel,
     externalSlotProps: slotProps == null ? void 0 : slotProps.axisTickLabel,
     additionalProps: {
-      style: {
+      style: _extends({
         fontSize: tickFontSize,
         textAnchor: position === 'right' ? 'start' : 'end',
         dominantBaseline: 'central'
-      },
+      }, tickLabelStyle),
       className: classes.tickLabel
     },
     ownerState: {}
@@ -110,12 +112,12 @@ function ChartsYAxis(inProps) {
     elementType: Label,
     externalSlotProps: slotProps == null ? void 0 : slotProps.axisLabel,
     additionalProps: {
-      style: {
+      style: _extends({
         fontSize: labelFontSize,
         angle: positionSign * 90,
         textAnchor: 'middle',
         dominantBaseline: 'auto'
-      }
+      }, labelStyle)
     },
     ownerState: {}
   });

package/legacy/LineChart/extremums.js

@@ -7,6 +7,21 @@ export var getExtremumX = function getExtremumX(params) {
   var maxX = Math.max.apply(Math, _toConsumableArray((_axis$data2 = axis.data) != null ? _axis$data2 : []));
   return [minX, maxX];
 };
+function getSeriesExtremums(getValues, stackedData) {
+  if (stackedData.length === 0) {
+    return [null, null];
+  }
+  return stackedData.reduce(function (seriesAcc, stackedValue) {
+    var _getValues = getValues(stackedValue),
+      _getValues2 = _slicedToArray(_getValues, 2),
+      base = _getValues2[0],
+      value = _getValues2[1];
+    if (seriesAcc[0] === null) {
+      return [Math.min(base, value), Math.max(base, value)];
+    }
+    return [Math.min(base, value, seriesAcc[0]), Math.max(base, value, seriesAcc[1])];
+  }, getValues(stackedData[0]));
+}
 export var getExtremumY = function getExtremumY(params) {
   var series = params.series,
     axis = params.axis,
@@ -14,26 +29,26 @@ export var getExtremumY = function getExtremumY(params) {
   return Object.keys(series).filter(function (seriesId) {
     return series[seriesId].yAxisKey === axis.id || isDefaultAxis && series[seriesId].yAxisKey === undefined;
   }).reduce(function (acc, seriesId) {
-    var isArea = series[seriesId].area !== undefined;
+    var _series$seriesId = series[seriesId],
+      area = _series$seriesId.area,
+      stackedData = _series$seriesId.stackedData;
+    var isArea = area !== undefined;
     var getValues = isArea ? function (d) {
       return d;
     } : function (d) {
       return [d[1], d[1]];
-    }; // Id area should go from bottom to top, without area should only consider the top
+    }; // Since this series is not used to display an area, we do not consider the base (the d[0]).
 
-    var _series$seriesId$stac = series[seriesId].stackedData.reduce(function (seriesAcc, stackedValue) {
-        var _getValues = getValues(stackedValue),
-          _getValues2 = _slicedToArray(_getValues, 2),
-          base = _getValues2[0],
-          value = _getValues2[1];
-        return [Math.min(base, value, seriesAcc[0]), Math.max(base, value, seriesAcc[1])];
-      }, getValues(series[seriesId].stackedData[0])),
-      _series$seriesId$stac2 = _slicedToArray(_series$seriesId$stac, 2),
-      seriesMin = _series$seriesId$stac2[0],
-      seriesMax = _series$seriesId$stac2[1];
-    if (acc[0] === null || acc[1] === null) {
-      return [seriesMin, seriesMax];
+    var seriesExtremums = getSeriesExtremums(getValues, stackedData);
+    if (acc[0] === null) {
+      return seriesExtremums;
+    }
+    if (seriesExtremums[0] === null) {
+      return acc;
     }
+    var _seriesExtremums = _slicedToArray(seriesExtremums, 2),
+      seriesMin = _seriesExtremums[0],
+      seriesMax = _seriesExtremums[1];
     return [Math.min(seriesMin, acc[0]), Math.max(seriesMax, acc[1])];
   }, [null, null]);
 };

package/legacy/LineChart/index.js

@@ -1,8 +1,8 @@
+export * from './LineChart';
 export * from './LinePlot';
 export * from './AreaPlot';
 export * from './MarkPlot';
 export * from './LineHighlightPlot';
-export * from './LineChart';
 export * from './AreaElement';
 export * from './LineElement';
 export * from './MarkElement';

package/legacy/PieChart/PieArc.js

@@ -2,6 +2,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 var _excluded = ["id", "dataIndex", "classes", "color", "highlightScope", "onClick", "isFaded", "isHighlighted", "startAngle", "endAngle", "paddingAngle", "innerRadius", "outerRadius", "cornerRadius"];
 import * as React from 'react';
+import PropTypes from 'prop-types';
 import { arc as d3Arc } from 'd3-shape';
 import { animated, to } from '@react-spring/web';
 import composeClasses from '@mui/utils/composeClasses';
@@ -38,7 +39,7 @@ var PieArcRoot = styled(animated.path, {
     strokeLinejoin: 'round'
   };
 });
-export default function PieArc(props) {
+function PieArc(props) {
   var id = props.id,
     dataIndex = props.dataIndex,
     innerClasses = props.classes,
@@ -83,4 +84,19 @@ export default function PieArc(props) {
     seriesId: id,
     dataIndex: dataIndex
   })));
-}
+}
+process.env.NODE_ENV !== "production" ? PieArc.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: PropTypes.object,
+  dataIndex: PropTypes.number.isRequired,
+  highlightScope: PropTypes.shape({
+    faded: PropTypes.oneOf(['global', 'none', 'series']),
+    highlighted: PropTypes.oneOf(['item', 'none', 'series'])
+  }),
+  isFaded: PropTypes.bool.isRequired,
+  isHighlighted: PropTypes.bool.isRequired
+} : void 0;
+export { PieArc };

package/legacy/PieChart/PieArcLabel.js

@@ -3,9 +3,9 @@ import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutPr
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 var _excluded = ["id", "classes", "color", "startAngle", "endAngle", "paddingAngle", "innerRadius", "outerRadius", "cornerRadius", "formattedArcLabel", "isHighlighted", "isFaded", "style"];
 import * as React from 'react';
+import PropTypes from 'prop-types';
 import { animated, to } from '@react-spring/web';
 import { arc as d3Arc } from 'd3-shape';
-import PropTypes from 'prop-types';
 import composeClasses from '@mui/utils/composeClasses';
 import generateUtilityClass from '@mui/utils/generateUtilityClass';
 import { styled } from '@mui/material/styles';
@@ -64,7 +64,7 @@ var getLabelPosition = function getLabelPosition(formattedArcLabel, variable) {
     return y;
   };
 };
-export default function PieArcLabel(props) {
+function PieArcLabel(props) {
   var id = props.id,
     innerClasses = props.classes,
     color = props.color,
@@ -103,12 +103,8 @@ process.env.NODE_ENV !== "production" ? PieArcLabel.propTypes = {
   // | To update them edit the TypeScript types and run "yarn proptypes"  |
   // ----------------------------------------------------------------------
   classes: PropTypes.object,
-  cornerRadius: PropTypes.number,
-  dataIndex: PropTypes.number.isRequired,
-  highlightScope: PropTypes.shape({
-    faded: PropTypes.oneOf(['global', 'none', 'series']),
-    highlighted: PropTypes.oneOf(['item', 'none', 'series'])
-  }),
-  innerRadius: PropTypes.number,
-  outerRadius: PropTypes.number.isRequired
-} : void 0;
+  formattedArcLabel: PropTypes.string,
+  isFaded: PropTypes.bool.isRequired,
+  isHighlighted: PropTypes.bool.isRequired
+} : void 0;
+export { PieArcLabel };

package/legacy/PieChart/PieArcLabelPlot.js

@@ -3,10 +3,11 @@ import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutPr
 var _excluded = ["slots", "slotProps", "innerRadius", "outerRadius", "cornerRadius", "paddingAngle", "id", "highlightScope", "highlighted", "faded", "data", "arcLabel", "arcLabelMinAngle", "skipAnimation"],
   _excluded2 = ["startAngle", "endAngle", "paddingAngle", "innerRadius", "outerRadius", "cornerRadius"];
 import * as React from 'react';
+import PropTypes from 'prop-types';
 import { useTransition } from '@react-spring/web';
 import { defaultLabelTransitionConfig } from './dataTransform/transition';
 import { useTransformData } from './dataTransform/useTransformData';
-import PieArcLabel from './PieArcLabel';
+import { PieArcLabel } from './PieArcLabel';
 import { jsx as _jsx } from "react/jsx-runtime";
 var RATIO = 180 / Math.PI;
 function getItemLabel(arcLabel, arcLabelMinAngle, item) {
@@ -23,7 +24,7 @@ function getItemLabel(arcLabel, arcLabelMinAngle, item) {
   }
   return arcLabel(item);
 }
-export function PieArcLabelPlot(props) {
+function PieArcLabelPlot(props) {
   var _slots$pieArcLabel;
   var slots = props.slots,
     slotProps = props.slotProps,
@@ -90,4 +91,92 @@ export function PieArcLabelPlot(props) {
       }, slotProps == null ? void 0 : slotProps.pieArcLabel));
     })
   }));
-}
+}
+process.env.NODE_ENV !== "production" ? PieArcLabelPlot.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The label displayed into the arc.
+   */
+  arcLabel: PropTypes.oneOfType([PropTypes.oneOf(['formattedValue', 'label', 'value']), PropTypes.func]),
+  /**
+   * The minimal angle required to display the arc label.
+   */
+  arcLabelMinAngle: PropTypes.number,
+  /**
+   * The radius applied to arc corners (similar to border radius).
+   * @default 0
+   */
+  cornerRadius: PropTypes.number,
+  data: PropTypes.arrayOf(PropTypes.shape({
+    color: PropTypes.string.isRequired,
+    endAngle: PropTypes.number.isRequired,
+    formattedValue: PropTypes.string.isRequired,
+    id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+    index: PropTypes.number.isRequired,
+    label: PropTypes.string,
+    padAngle: PropTypes.number.isRequired,
+    startAngle: PropTypes.number.isRequired,
+    value: PropTypes.number.isRequired
+  })).isRequired,
+  /**
+   * Override the arc attibutes when it is faded.
+   */
+  faded: PropTypes.shape({
+    additionalRadius: PropTypes.number,
+    color: PropTypes.string,
+    cornerRadius: PropTypes.number,
+    innerRadius: PropTypes.number,
+    outerRadius: PropTypes.number,
+    paddingAngle: PropTypes.number
+  }),
+  /**
+   * Override the arc attibutes when it is highlighted.
+   */
+  highlighted: PropTypes.shape({
+    additionalRadius: PropTypes.number,
+    color: PropTypes.string,
+    cornerRadius: PropTypes.number,
+    innerRadius: PropTypes.number,
+    outerRadius: PropTypes.number,
+    paddingAngle: PropTypes.number
+  }),
+  highlightScope: PropTypes.shape({
+    faded: PropTypes.oneOf(['global', 'none', 'series']),
+    highlighted: PropTypes.oneOf(['item', 'none', 'series'])
+  }),
+  id: PropTypes.string.isRequired,
+  /**
+   * The radius between circle center and the begining of the arc.
+   * @default 0
+   */
+  innerRadius: PropTypes.number,
+  /**
+   * The radius between circle center and the end of the arc.
+   * @default R_max The maximal radius that fit into the drawing area.
+   */
+  outerRadius: PropTypes.number.isRequired,
+  /**
+   * The padding angle (deg) between two arcs.
+   * @default 0
+   */
+  paddingAngle: PropTypes.number,
+  /**
+   * If `true`, animations are skiped.
+   * @default false
+   */
+  skipAnimation: PropTypes.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: PropTypes.object
+} : void 0;
+export { PieArcLabelPlot };

package/legacy/PieChart/PieArcPlot.js

@@ -3,12 +3,13 @@ import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutPr
 var _excluded = ["slots", "slotProps", "innerRadius", "outerRadius", "cornerRadius", "paddingAngle", "id", "highlightScope", "highlighted", "faded", "data", "onClick", "skipAnimation"],
   _excluded2 = ["startAngle", "endAngle", "paddingAngle", "innerRadius", "outerRadius", "cornerRadius"];
 import * as React from 'react';
+import PropTypes from 'prop-types';
 import { useTransition } from '@react-spring/web';
-import PieArc from './PieArc';
+import { PieArc } from './PieArc';
 import { defaultTransitionConfig } from './dataTransform/transition';
 import { useTransformData } from './dataTransform/useTransformData';
 import { jsx as _jsx } from "react/jsx-runtime";
-export function PieArcPlot(props) {
+function PieArcPlot(props) {
   var _slots$pieArc;
   var slots = props.slots,
     slotProps = props.slotProps,
@@ -81,4 +82,91 @@ export function PieArcPlot(props) {
       }, slotProps == null ? void 0 : slotProps.pieArc));
     })
   }));
-}
+}
+process.env.NODE_ENV !== "production" ? PieArcPlot.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The radius applied to arc corners (similar to border radius).
+   * @default 0
+   */
+  cornerRadius: PropTypes.number,
+  data: PropTypes.arrayOf(PropTypes.shape({
+    color: PropTypes.string.isRequired,
+    endAngle: PropTypes.number.isRequired,
+    formattedValue: PropTypes.string.isRequired,
+    id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+    index: PropTypes.number.isRequired,
+    label: PropTypes.string,
+    padAngle: PropTypes.number.isRequired,
+    startAngle: PropTypes.number.isRequired,
+    value: PropTypes.number.isRequired
+  })).isRequired,
+  /**
+   * Override the arc attibutes when it is faded.
+   */
+  faded: PropTypes.shape({
+    additionalRadius: PropTypes.number,
+    color: PropTypes.string,
+    cornerRadius: PropTypes.number,
+    innerRadius: PropTypes.number,
+    outerRadius: PropTypes.number,
+    paddingAngle: PropTypes.number
+  }),
+  /**
+   * Override the arc attibutes when it is highlighted.
+   */
+  highlighted: PropTypes.shape({
+    additionalRadius: PropTypes.number,
+    color: PropTypes.string,
+    cornerRadius: PropTypes.number,
+    innerRadius: PropTypes.number,
+    outerRadius: PropTypes.number,
+    paddingAngle: PropTypes.number
+  }),
+  highlightScope: PropTypes.shape({
+    faded: PropTypes.oneOf(['global', 'none', 'series']),
+    highlighted: PropTypes.oneOf(['item', 'none', 'series'])
+  }),
+  id: PropTypes.string.isRequired,
+  /**
+   * The radius between circle center and the begining of the arc.
+   * @default 0
+   */
+  innerRadius: PropTypes.number,
+  /**
+   * Callback fired when a pie item is clicked.
+   * @param {React.MouseEvent<SVGPathElement, MouseEvent>} event The event source of the callback.
+   * @param {PieItemIdentifier} pieItemIdentifier The pie item identifier.
+   * @param {DefaultizedPieValueType} item The pie item.
+   */
+  onClick: PropTypes.func,
+  /**
+   * The radius between circle center and the end of the arc.
+   * @default R_max The maximal radius that fit into the drawing area.
+   */
+  outerRadius: PropTypes.number.isRequired,
+  /**
+   * The padding angle (deg) between two arcs.
+   * @default 0
+   */
+  paddingAngle: PropTypes.number,
+  /**
+   * If `true`, animations are skiped.
+   * @default false
+   */
+  skipAnimation: PropTypes.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: PropTypes.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: PropTypes.object
+} : void 0;
+export { PieArcPlot };