@mui/x-charts 6.0.0-alpha.1 → 6.0.0-alpha.2

package/esm/BarChart/BarChart.js

@@ -123,6 +123,7 @@ process.env.NODE_ENV !== "production" ? BarChart.propTypes = {
   legend: PropTypes.shape({
     classes: PropTypes.object,
     direction: PropTypes.oneOf(['column', 'row']),
+    hidden: PropTypes.bool,
     itemWidth: PropTypes.number,
     markSize: PropTypes.number,
     offset: PropTypes.shape({

package/esm/BarChart/legend.js

@@ -0,0 +1,13 @@
+const legendGetter = params => {
+  const {
+    seriesOrder,
+    series
+  } = params;
+  const data = seriesOrder.map(seriesId => ({
+    color: series[seriesId].color,
+    label: series[seriesId].label,
+    id: seriesId
+  }));
+  return data.filter(item => item.label !== undefined);
+};
+export default legendGetter;

package/esm/ChartsLegend/ChartsLegend.js

@@ -146,7 +146,8 @@ export function ChartsLegend(inProps) {
   const {
     position,
     direction,
-    offset
+    offset,
+    hidden
   } = props;
   const theme = useTheme();
   const classes = useUtilityClasses(_extends({}, props, {
@@ -154,6 +155,9 @@ export function ChartsLegend(inProps) {
   }));
   const drawingArea = React.useContext(DrawingContext);
   const series = React.useContext(SeriesContext);
+  if (hidden) {
+    return null;
+  }
   const seriesToDisplay = getSeriesToDisplay(series);
   return /*#__PURE__*/_jsx(ChartsLegendRoot, {
     ownerState: {

package/esm/ChartsLegend/utils.js

@@ -1,3 +1,13 @@
+import getBarLegend from '../BarChart/legend';
+import getScatterLegend from '../ScatterChart/legend';
+import getLineLegend from '../LineChart/legend';
+import getPieLegend from '../PieChart/legend';
+const legendGetter = {
+  bar: getBarLegend,
+  scatter: getScatterLegend,
+  line: getLineLegend,
+  pie: getPieLegend
+};
 export function getSeriesToDisplay(series) {
-  return Object.values(series).flatMap(s => s.seriesOrder.map(seriesId => s.series[seriesId])).filter(s => s.label !== undefined);
+  return Object.keys(series).flatMap(seriesType => legendGetter[seriesType](series[seriesType]));
 }

package/esm/ChartsTooltip/ChartsAxisTooltipContent.js

@@ -82,7 +82,7 @@ export function ChartsAxisTooltipContent(props) {
   const USED_X_AXIS_ID = xAxisIds[0];
   const relevantSeries = React.useMemo(() => {
     const rep = [];
-    Object.keys(series).forEach(seriesType => {
+    Object.keys(series).filter(seriesType => ['bar', 'line', 'scatter'].includes(seriesType)).forEach(seriesType => {
       series[seriesType].seriesOrder.forEach(seriesId => {
         const axisKey = series[seriesType].series[seriesId].xAxisKey;
         if (axisKey === undefined || axisKey === USED_X_AXIS_ID) {

package/esm/ChartsTooltip/ChartsItemTooltipContent.js

@@ -4,7 +4,6 @@ import { ChartsTooltipTable, ChartsTooltipCell, ChartsTooltipMark, ChartsTooltip
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 export function DefaultChartsItemContent(props) {
-  var _series$label;
   const {
     series,
     itemData,
@@ -14,8 +13,17 @@ export function DefaultChartsItemContent(props) {
   if (itemData.dataIndex === undefined) {
     return null;
   }
-  const displayedLabel = (_series$label = series.label) != null ? _series$label : null;
-  const color = series.color;
+  const {
+    displayedLabel,
+    color
+  } = series.type === 'pie' ? {
+    color: series.data[itemData.dataIndex].color,
+    displayedLabel: series.data[itemData.dataIndex].label
+  } : {
+    color: series.color,
+    displayedLabel: series.label
+  };
+
   // TODO: Manage to let TS understand series.data and series.valueFormatter are coherent
   // @ts-ignore
   const formattedValue = series.valueFormatter(series.data[itemData.dataIndex]);

package/esm/LineChart/LineChart.js

@@ -125,6 +125,7 @@ process.env.NODE_ENV !== "production" ? LineChart.propTypes = {
   legend: PropTypes.shape({
     classes: PropTypes.object,
     direction: PropTypes.oneOf(['column', 'row']),
+    hidden: PropTypes.bool,
     itemWidth: PropTypes.number,
     markSize: PropTypes.number,
     offset: PropTypes.shape({

package/esm/LineChart/legend.js

@@ -0,0 +1,13 @@
+const legendGetter = params => {
+  const {
+    seriesOrder,
+    series
+  } = params;
+  const data = seriesOrder.map(seriesId => ({
+    color: series[seriesId].color,
+    label: series[seriesId].label,
+    id: seriesId
+  }));
+  return data.filter(item => item.label !== undefined);
+};
+export default legendGetter;

package/esm/PieChart/PieArc.js

@@ -0,0 +1,117 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["id", "dataIndex", "classes", "color", "highlightScope", "innerRadius", "outerRadius", "cornerRadius", "highlighted", "faded"];
+import * as React from 'react';
+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';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import { InteractionContext } from '../context/InteractionProvider';
+import { getIsFaded, getIsHighlighted, useInteractionItemProps } from '../hooks/useInteractionItemProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+export function getPieArcUtilityClass(slot) {
+  return generateUtilityClass('MuiPieArc', slot);
+}
+export const pieArcClasses = generateUtilityClasses('MuiPieArc', ['root', 'highlighted', 'faded']);
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    id,
+    isFaded,
+    isHighlighted
+  } = ownerState;
+  const slots = {
+    root: ['root', `series-${id}`, isHighlighted && 'highlighted', isFaded && 'faded']
+  };
+  return composeClasses(slots, getPieArcUtilityClass, classes);
+};
+const PieArcRoot = styled('path', {
+  name: 'MuiPieArc',
+  slot: 'Root',
+  overridesResolver: (_, styles) => styles.arc
+})(({
+  ownerState,
+  theme
+}) => ({
+  stroke: theme.palette.background.paper,
+  strokeWidth: 1,
+  strokeLinejoin: 'round',
+  fill: ownerState.color,
+  opacity: ownerState.isFaded ? 0.3 : 1
+}));
+export default function PieArc(props) {
+  var _attibuesOverride$inn, _attibuesOverride$out, _attibuesOverride$cor;
+  const {
+      id,
+      dataIndex,
+      classes: innerClasses,
+      color,
+      highlightScope,
+      innerRadius: baseInnerRadius = 0,
+      outerRadius: baseOuterRadius,
+      cornerRadius: baseCornerRadius = 0,
+      highlighted,
+      faded = {
+        additionalRadius: -5
+      }
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const getInteractionItemProps = useInteractionItemProps(highlightScope);
+  const {
+    item
+  } = React.useContext(InteractionContext);
+  const isHighlighted = getIsHighlighted(item, {
+    type: 'pie',
+    seriesId: id,
+    dataIndex
+  }, highlightScope);
+  const isFaded = !isHighlighted && getIsFaded(item, {
+    type: 'pie',
+    seriesId: id,
+    dataIndex
+  }, highlightScope);
+  const ownerState = {
+    id,
+    dataIndex,
+    classes: innerClasses,
+    color,
+    isFaded,
+    isHighlighted
+  };
+  const classes = useUtilityClasses(ownerState);
+  const attibuesOverride = _extends({
+    additionalRadius: 0
+  }, isFaded && faded || isHighlighted && highlighted || {});
+  const innerRadius = Math.max(0, (_attibuesOverride$inn = attibuesOverride.innerRadius) != null ? _attibuesOverride$inn : baseInnerRadius);
+  const outerRadius = Math.max(0, (_attibuesOverride$out = attibuesOverride.outerRadius) != null ? _attibuesOverride$out : baseOuterRadius + attibuesOverride.additionalRadius);
+  const cornerRadius = (_attibuesOverride$cor = attibuesOverride.cornerRadius) != null ? _attibuesOverride$cor : baseCornerRadius;
+  return /*#__PURE__*/_jsx(PieArcRoot, _extends({
+    d: d3Arc().cornerRadius(cornerRadius)(_extends({}, other, {
+      innerRadius,
+      outerRadius
+    })),
+    ownerState: ownerState,
+    className: classes.root
+  }, getInteractionItemProps({
+    type: 'pie',
+    seriesId: id,
+    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,
+  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;

package/esm/PieChart/PieArcLabel.js

@@ -0,0 +1,101 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["id", "dataIndex", "classes", "color", "highlightScope", "innerRadius", "outerRadius", "cornerRadius", "formattedArcLabel"];
+import * as React from 'react';
+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';
+import generateUtilityClasses from '@mui/utils/generateUtilityClasses';
+import { InteractionContext } from '../context/InteractionProvider';
+import { getIsFaded, getIsHighlighted } from '../hooks/useInteractionItemProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+export function getPieArcLabelUtilityClass(slot) {
+  return generateUtilityClass('MuiPieArcLabel', slot);
+}
+export const pieArcLabelClasses = generateUtilityClasses('MuiPieArcLabel', ['root', 'highlighted', 'faded']);
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    id,
+    isFaded,
+    isHighlighted
+  } = ownerState;
+  const slots = {
+    root: ['root', `series-${id}`, isHighlighted && 'highlighted', isFaded && 'faded']
+  };
+  return composeClasses(slots, getPieArcLabelUtilityClass, classes);
+};
+const PieArcLabelRoot = styled('text', {
+  name: 'MuiPieArcLabel',
+  slot: 'Root',
+  overridesResolver: (_, styles) => styles.root
+})(({
+  theme
+}) => ({
+  fill: theme.palette.text.primary,
+  alignmentBaseline: 'baseline',
+  textAnchor: 'middle'
+}));
+export default function PieArcLabel(props) {
+  const {
+      id,
+      dataIndex,
+      classes: innerClasses,
+      color,
+      highlightScope,
+      innerRadius = 0,
+      outerRadius,
+      cornerRadius = 0,
+      formattedArcLabel
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const {
+    item
+  } = React.useContext(InteractionContext);
+  const isHighlighted = getIsHighlighted(item, {
+    type: 'pie',
+    seriesId: id,
+    dataIndex
+  }, highlightScope);
+  const isFaded = !isHighlighted && getIsFaded(item, {
+    type: 'pie',
+    seriesId: id,
+    dataIndex
+  }, highlightScope);
+  const ownerState = {
+    id,
+    dataIndex,
+    classes: innerClasses,
+    color,
+    isFaded,
+    isHighlighted
+  };
+  const classes = useUtilityClasses(ownerState);
+  const arcLabelPosition = formattedArcLabel ? d3Arc().cornerRadius(cornerRadius).centroid(_extends({}, other, {
+    innerRadius,
+    outerRadius
+  })) : [0, 0];
+  return /*#__PURE__*/_jsx(PieArcLabelRoot, {
+    className: classes.root,
+    x: arcLabelPosition[0],
+    y: arcLabelPosition[1],
+    children: formattedArcLabel
+  });
+}
+process.env.NODE_ENV !== "production" ? PieArcLabel.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,
+  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;

package/esm/PieChart/PieChart.js

@@ -0,0 +1,285 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { ResponsiveChartContainer } from '../ResponsiveChartContainer';
+import { ChartsAxis } from '../ChartsAxis/ChartsAxis';
+import { DEFAULT_X_AXIS_KEY } from '../constants';
+import { ChartsTooltip } from '../ChartsTooltip';
+import { ChartsLegend } from '../ChartsLegend';
+import { ChartsAxisHighlight } from '../ChartsAxisHighlight';
+import { PiePlot } from './PiePlot';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const defaultMargin = {
+  top: 5,
+  bottom: 5,
+  left: 5,
+  right: 100
+};
+function PieChart(props) {
+  const {
+    xAxis,
+    yAxis,
+    series,
+    width,
+    height,
+    margin: marginProps,
+    colors,
+    sx,
+    tooltip = {
+      trigger: 'item'
+    },
+    axisHighlight = {
+      x: 'none',
+      y: 'none'
+    },
+    legend = {
+      direction: 'column',
+      position: {
+        vertical: 'middle',
+        horizontal: 'right'
+      }
+    },
+    topAxis = null,
+    leftAxis = null,
+    rightAxis = null,
+    bottomAxis = null,
+    children
+  } = props;
+  const margin = _extends({}, defaultMargin, marginProps);
+  return /*#__PURE__*/_jsxs(ResponsiveChartContainer, {
+    series: series.map(s => _extends({
+      type: 'pie'
+    }, s)),
+    width: width,
+    height: height,
+    margin: margin,
+    xAxis: xAxis != null ? xAxis : [{
+      id: DEFAULT_X_AXIS_KEY,
+      scaleType: 'point',
+      data: [...new Array(Math.max(...series.map(s => s.data.length)))].map((_, index) => index)
+    }],
+    yAxis: yAxis,
+    colors: colors,
+    sx: sx,
+    disableAxisListener: (tooltip == null ? void 0 : tooltip.trigger) !== 'axis' && (axisHighlight == null ? void 0 : axisHighlight.x) === 'none' && (axisHighlight == null ? void 0 : axisHighlight.y) === 'none',
+    children: [/*#__PURE__*/_jsx(ChartsAxis, {
+      topAxis: topAxis,
+      leftAxis: leftAxis,
+      rightAxis: rightAxis,
+      bottomAxis: bottomAxis
+    }), /*#__PURE__*/_jsx(PiePlot, {}), /*#__PURE__*/_jsx(ChartsLegend, _extends({}, legend)), /*#__PURE__*/_jsx(ChartsAxisHighlight, _extends({}, axisHighlight)), /*#__PURE__*/_jsx(ChartsTooltip, _extends({}, tooltip)), children]
+  });
+}
+process.env.NODE_ENV !== "production" ? PieChart.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  axisHighlight: PropTypes.shape({
+    x: PropTypes.oneOf(['band', 'line', 'none']),
+    y: PropTypes.oneOf(['line', 'none'])
+  }),
+  /**
+   * Indicate which axis to display the bottom of the charts.
+   * Can be a string (the id of the axis) or an object `ChartsXAxisProps`
+   * @default xAxisIds[0] The id of the first provided axis
+   */
+  bottomAxis: PropTypes.oneOfType([PropTypes.shape({
+    axisId: PropTypes.string.isRequired,
+    classes: PropTypes.object,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    position: PropTypes.oneOf(['bottom', 'top']),
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickSize: PropTypes.number
+  }), PropTypes.string]),
+  children: PropTypes.node,
+  className: PropTypes.string,
+  /**
+   * Color palette used to colorize multiple series.
+   */
+  colors: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.func]),
+  desc: PropTypes.string,
+  disableAxisListener: PropTypes.bool,
+  height: PropTypes.number,
+  /**
+   * Indicate which axis to display the left of the charts.
+   * Can be a string (the id of the axis) or an object `ChartsYAxisProps`
+   * @default yAxisIds[0] The id of the first provided axis
+   */
+  leftAxis: PropTypes.oneOfType([PropTypes.shape({
+    axisId: PropTypes.string.isRequired,
+    classes: PropTypes.object,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    position: PropTypes.oneOf(['left', 'right']),
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickSize: PropTypes.number
+  }), PropTypes.string]),
+  legend: PropTypes.shape({
+    classes: PropTypes.object,
+    direction: PropTypes.oneOf(['column', 'row']),
+    hidden: PropTypes.bool,
+    itemWidth: PropTypes.number,
+    markSize: PropTypes.number,
+    offset: PropTypes.shape({
+      x: PropTypes.number,
+      y: PropTypes.number
+    }),
+    position: PropTypes.shape({
+      horizontal: PropTypes.oneOf(['left', 'middle', 'right']).isRequired,
+      vertical: PropTypes.oneOf(['bottom', 'middle', 'top']).isRequired
+    }),
+    spacing: PropTypes.number
+  }),
+  margin: PropTypes.shape({
+    bottom: PropTypes.number,
+    left: PropTypes.number,
+    right: PropTypes.number,
+    top: PropTypes.number
+  }),
+  /**
+   * Indicate which axis to display the right of the charts.
+   * Can be a string (the id of the axis) or an object `ChartsYAxisProps`
+   * @default null
+   */
+  rightAxis: PropTypes.oneOfType([PropTypes.shape({
+    axisId: PropTypes.string.isRequired,
+    classes: PropTypes.object,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    position: PropTypes.oneOf(['left', 'right']),
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickSize: PropTypes.number
+  }), PropTypes.string]),
+  series: PropTypes.arrayOf(PropTypes.shape({
+    arcLabel: PropTypes.oneOfType([PropTypes.oneOf(['formattedValue', 'label', 'value']), PropTypes.func]),
+    arcLabelMinAngle: PropTypes.number,
+    color: PropTypes.string,
+    cornerRadius: PropTypes.number,
+    cx: PropTypes.number,
+    cy: PropTypes.number,
+    data: PropTypes.arrayOf(PropTypes.shape({
+      color: PropTypes.string,
+      id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+      label: PropTypes.string,
+      value: PropTypes.number.isRequired
+    })).isRequired,
+    endAngle: PropTypes.number,
+    faded: PropTypes.shape({
+      additionalRadius: PropTypes.number,
+      cornerRadius: PropTypes.number,
+      innerRadius: PropTypes.number,
+      outerRadius: PropTypes.number
+    }),
+    highlighted: PropTypes.shape({
+      additionalRadius: PropTypes.number,
+      cornerRadius: PropTypes.number,
+      innerRadius: PropTypes.number,
+      outerRadius: PropTypes.number
+    }),
+    highlightScope: PropTypes.shape({
+      faded: PropTypes.oneOf(['global', 'none', 'series']),
+      highlighted: PropTypes.oneOf(['item', 'none', 'series'])
+    }),
+    id: PropTypes.string,
+    innerRadius: PropTypes.number,
+    outerRadius: PropTypes.number,
+    paddingAngle: PropTypes.number,
+    sortingValues: PropTypes.oneOfType([PropTypes.oneOf(['asc', 'desc', 'none']), PropTypes.func]),
+    startAngle: PropTypes.number,
+    type: PropTypes.oneOf(['pie']),
+    valueFormatter: PropTypes.func
+  })).isRequired,
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  title: PropTypes.string,
+  tooltip: PropTypes.shape({
+    axisContent: PropTypes.elementType,
+    classes: PropTypes.object,
+    itemContent: PropTypes.elementType,
+    trigger: PropTypes.oneOf(['axis', 'item', 'none'])
+  }),
+  /**
+   * Indicate which axis to display the top of the charts.
+   * Can be a string (the id of the axis) or an object `ChartsXAxisProps`
+   * @default null
+   */
+  topAxis: PropTypes.oneOfType([PropTypes.shape({
+    axisId: PropTypes.string.isRequired,
+    classes: PropTypes.object,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    position: PropTypes.oneOf(['bottom', 'top']),
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickSize: PropTypes.number
+  }), PropTypes.string]),
+  viewBox: PropTypes.shape({
+    height: PropTypes.number,
+    width: PropTypes.number,
+    x: PropTypes.number,
+    y: PropTypes.number
+  }),
+  width: PropTypes.number,
+  xAxis: PropTypes.arrayOf(PropTypes.shape({
+    axisId: PropTypes.string,
+    classes: PropTypes.object,
+    data: PropTypes.array,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    id: PropTypes.string,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    max: PropTypes.number,
+    maxTicks: PropTypes.number,
+    min: PropTypes.number,
+    minTicks: PropTypes.number,
+    position: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
+    scaleType: PropTypes.oneOf(['band', 'linear', 'log', 'point', 'pow', 'sqrt', 'time', 'utc']),
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickSize: PropTypes.number,
+    tickSpacing: PropTypes.number,
+    valueFormatter: PropTypes.func
+  })),
+  yAxis: PropTypes.arrayOf(PropTypes.shape({
+    axisId: PropTypes.string,
+    classes: PropTypes.object,
+    data: PropTypes.array,
+    disableLine: PropTypes.bool,
+    disableTicks: PropTypes.bool,
+    fill: PropTypes.string,
+    id: PropTypes.string,
+    label: PropTypes.string,
+    labelFontSize: PropTypes.number,
+    max: PropTypes.number,
+    maxTicks: PropTypes.number,
+    min: PropTypes.number,
+    minTicks: PropTypes.number,
+    position: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),
+    scaleType: PropTypes.oneOf(['band', 'linear', 'log', 'point', 'pow', 'sqrt', 'time', 'utc']),
+    stroke: PropTypes.string,
+    tickFontSize: PropTypes.number,
+    tickSize: PropTypes.number,
+    tickSpacing: PropTypes.number,
+    valueFormatter: PropTypes.func
+  }))
+} : void 0;
+export { PieChart };