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

package/legacy/context/CartesianContextProvider.js

@@ -7,12 +7,15 @@ import PropTypes from 'prop-types';
 import { getExtremumX as getBarExtremumX, getExtremumY as getBarExtremumY } from '../BarChart/extremums';
 import { getExtremumX as getScatterExtremumX, getExtremumY as getScatterExtremumY } from '../ScatterChart/extremums';
 import { getExtremumX as getLineExtremumX, getExtremumY as getLineExtremumY } from '../LineChart/extremums';
-import { getScale } from '../hooks/useScale';
+import { isBandScaleConfig, isPointScaleConfig } from '../models/axis';
+import { getScale } from '../internals/getScale';
 import { DrawingContext } from './DrawingProvider';
 import { SeriesContext } from './SeriesContextProvider';
 import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from '../constants';
 import { getTicksNumber } from '../hooks/useTicks';
 import { jsx as _jsx } from "react/jsx-runtime";
+var DEFAULT_CATEGORY_GAP_RATIO = 0.1;
+
 // TODO: those might be better placed in a distinct file
 var xExtremumGetters = {
   bar: getBarExtremumX,
@@ -86,24 +89,29 @@ function CartesianContextProvider(_ref) {
         _getAxisExtremum2 = _slicedToArray(_getAxisExtremum, 2),
         minData = _getAxisExtremum2[0],
         maxData = _getAxisExtremum2[1];
-      var scaleType = (_axis$scaleType = axis.scaleType) != null ? _axis$scaleType : 'linear';
       var range = [drawingArea.left, drawingArea.left + drawingArea.width];
-      if (scaleType === 'band') {
-        completedXAxis[axis.id] = _extends({}, axis, {
-          scaleType: scaleType,
-          scale: scaleBand(axis.data, range),
+      if (isBandScaleConfig(axis)) {
+        var _axis$categoryGapRati;
+        var categoryGapRatio = (_axis$categoryGapRati = axis.categoryGapRatio) != null ? _axis$categoryGapRati : DEFAULT_CATEGORY_GAP_RATIO;
+        completedXAxis[axis.id] = _extends({
+          categoryGapRatio: categoryGapRatio,
+          barGapRatio: 0
+        }, axis, {
+          scale: scaleBand(axis.data, range).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
           ticksNumber: axis.data.length
         });
-        return;
       }
-      if (scaleType === 'point') {
+      if (isPointScaleConfig(axis)) {
         completedXAxis[axis.id] = _extends({}, axis, {
-          scaleType: scaleType,
           scale: scalePoint(axis.data, range),
           ticksNumber: axis.data.length
         });
+      }
+      if (axis.scaleType === 'band' || axis.scaleType === 'point') {
+        // Could be merged with the two previous "if conditions" but then TS does not get that `axis.scaleType` can't be `band` or `point`.
         return;
       }
+      var scaleType = (_axis$scaleType = axis.scaleType) != null ? _axis$scaleType : 'linear';
       var extremums = [(_axis$min = axis.min) != null ? _axis$min : minData, (_axis$max = axis.max) != null ? _axis$max : maxData];
       var ticksNumber = getTicksNumber(_extends({}, axis, {
         range: range
@@ -137,23 +145,28 @@ function CartesianContextProvider(_ref) {
         minData = _getAxisExtremum4[0],
         maxData = _getAxisExtremum4[1];
       var range = [drawingArea.top + drawingArea.height, drawingArea.top];
-      var scaleType = (_axis$scaleType2 = axis.scaleType) != null ? _axis$scaleType2 : 'linear';
-      if (scaleType === 'band') {
-        completedYAxis[axis.id] = _extends({}, axis, {
-          scaleType: scaleType,
-          scale: scaleBand(axis.data, range),
+      if (isBandScaleConfig(axis)) {
+        var _axis$categoryGapRati2;
+        var categoryGapRatio = (_axis$categoryGapRati2 = axis.categoryGapRatio) != null ? _axis$categoryGapRati2 : DEFAULT_CATEGORY_GAP_RATIO;
+        completedXAxis[axis.id] = _extends({
+          categoryGapRatio: categoryGapRatio,
+          barGapRatio: 0
+        }, axis, {
+          scale: scaleBand(axis.data, range).paddingInner(categoryGapRatio).paddingOuter(categoryGapRatio / 2),
           ticksNumber: axis.data.length
         });
-        return;
       }
-      if (scaleType === 'point') {
-        completedYAxis[axis.id] = _extends({}, axis, {
-          scaleType: scaleType,
+      if (isPointScaleConfig(axis)) {
+        completedXAxis[axis.id] = _extends({}, axis, {
           scale: scalePoint(axis.data, range),
           ticksNumber: axis.data.length
         });
+      }
+      if (axis.scaleType === 'band' || axis.scaleType === 'point') {
+        // Could be merged with the two previous "if conditions" but then TS does not get that `axis.scaleType` can't be `band` or `point`.
         return;
       }
+      var scaleType = (_axis$scaleType2 = axis.scaleType) != null ? _axis$scaleType2 : 'linear';
       var extremums = [(_axis$min3 = axis.min) != null ? _axis$min3 : minData, (_axis$max3 = axis.max) != null ? _axis$max3 : maxData];
       var ticksNumber = getTicksNumber(_extends({}, axis, {
         range: range

package/legacy/context/SeriesContextProvider.js

@@ -4,6 +4,7 @@ import { useTheme } from '@mui/material/styles';
 import barSeriesFormatter from '../BarChart/formatter';
 import scatterSeriesFormatter from '../ScatterChart/formatter';
 import lineSeriesFormatter from '../LineChart/formatter';
+import pieSeriesFormatter from '../PieChart/formatter';
 import { defaultizeColor } from '../internals/defaultizeColor';
 import { blueberryTwilightPalette } from '../colorPalettes';
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -11,8 +12,17 @@ export var SeriesContext = /*#__PURE__*/React.createContext({});
 var seriesTypeFormatter = {
   bar: barSeriesFormatter,
   scatter: scatterSeriesFormatter,
-  line: lineSeriesFormatter
+  line: lineSeriesFormatter,
+  pie: pieSeriesFormatter
 };
+/**
+ * This methods is the interface between what the developer is providing and what components receives
+ * To simplify the components behaviors, it groups series by type, such that LinePlots props are not updated if some line data are modified
+ * It also add defaultized values such as the ids, colors
+ * @param series The array of series provided by devs
+ * @param colors The color palette used to defaultize series colors
+ * @returns An object structuring all the series by type.
+ */
 var formatSeries = function formatSeries(series, colors) {
   // Group series by type
   var seriesGroups = {};

package/legacy/hooks/index.js

@@ -0,0 +1,2 @@
+export * from './useDrawingArea';
+export * from './useScale';

package/legacy/hooks/useAxisEvents.js

@@ -2,7 +2,7 @@ import * as React from 'react';
 import { InteractionContext } from '../context/InteractionProvider';
 import { CartesianContext } from '../context/CartesianContextProvider';
 import { SVGContext, DrawingContext } from '../context/DrawingProvider';
-import { isBandScale } from './useScale';
+import { isBandScale } from '../internals/isBandScale';
 export var useAxisEvents = function useAxisEvents(disableAxisListener) {
   var svgRef = React.useContext(SVGContext);
   var _React$useContext = React.useContext(DrawingContext),
@@ -104,12 +104,17 @@ export var useAxisEvents = function useAxisEvents(disableAxisListener) {
       });
     };
     var handleMouseMove = function handleMouseMove(event) {
+      // Get mouse coordinate in global SVG space
+      var pt = svgRef.current.createSVGPoint();
+      pt.x = event.clientX;
+      pt.y = event.clientY;
+      var svgPt = pt.matrixTransform(svgRef.current.getScreenCTM().inverse());
       mousePosition.current = {
-        x: event.offsetX,
-        y: event.offsetY
+        x: svgPt.x,
+        y: svgPt.y
       };
-      var outsideX = event.offsetX < left || event.offsetX > left + width;
-      var outsideY = event.offsetY < top || event.offsetY > top + height;
+      var outsideX = svgPt.x < left || svgPt.x > left + width;
+      var outsideY = svgPt.y < top || svgPt.y > top + height;
       if (outsideX || outsideY) {
         dispatch({
           type: 'updateAxis',
@@ -120,8 +125,8 @@ export var useAxisEvents = function useAxisEvents(disableAxisListener) {
         });
         return;
       }
-      var newStateX = getUpdateX(event.offsetX);
-      var newStateY = getUpdateY(event.offsetY);
+      var newStateX = getUpdateX(svgPt.x);
+      var newStateY = getUpdateY(svgPt.y);
       dispatch({
         type: 'updateAxis',
         data: {

package/legacy/hooks/useDrawingArea.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { DrawingContext } from '../context/DrawingProvider';
+export function useDrawingArea() {
+  var _React$useContext = React.useContext(DrawingContext),
+    left = _React$useContext.left,
+    top = _React$useContext.top,
+    width = _React$useContext.width,
+    height = _React$useContext.height;
+  return React.useMemo(function () {
+    return {
+      left: left,
+      top: top,
+      width: width,
+      height: height
+    };
+  }, [height, left, top, width]);
+}

package/legacy/hooks/useScale.js

@@ -1,24 +1,6 @@
-import { scaleLog, scalePow, scaleSqrt, scaleTime, scaleUtc, scaleLinear } from 'd3-scale';
-export function getScale(scaleType, domain, range) {
-  switch (scaleType) {
-    case 'log':
-      return scaleLog(domain, range);
-    case 'pow':
-      return scalePow(domain, range);
-    case 'sqrt':
-      return scaleSqrt(domain, range);
-    case 'time':
-      return scaleTime(domain, range);
-    case 'utc':
-      return scaleUtc(domain, range);
-    default:
-      return scaleLinear(domain, range);
-  }
-}
-export function isBandScale(scale) {
-  return scale.bandwidth !== undefined;
-}
-
+import * as React from 'react';
+import { CartesianContext } from '../context/CartesianContextProvider';
+import { isBandScale } from '../internals/isBandScale';
 /**
  * For a given scale return a function that map value to their position.
  * Usefull when dealing with specific scale such as band.
@@ -34,4 +16,18 @@ export function getValueToPositionMapper(scale) {
   return function (value) {
     return scale(value);
   };
+}
+export function useXScale(identifier) {
+  var _React$useContext = React.useContext(CartesianContext),
+    xAxis = _React$useContext.xAxis,
+    xAxisIds = _React$useContext.xAxisIds;
+  var id = typeof identifier === 'string' ? identifier : xAxisIds[identifier != null ? identifier : 0];
+  return xAxis[id].scale;
+}
+export function useYScale(identifier) {
+  var _React$useContext2 = React.useContext(CartesianContext),
+    yAxis = _React$useContext2.yAxis,
+    yAxisIds = _React$useContext2.yAxisIds;
+  var id = typeof identifier === 'string' ? identifier : yAxisIds[identifier != null ? identifier : 0];
+  return yAxis[id].scale;
 }

package/legacy/hooks/useTicks.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import * as React from 'react';
-import { isBandScale } from './useScale';
+import { isBandScale } from '../internals/isBandScale';
 export function getTicksNumber(params) {
   var _params$maxTicks = params.maxTicks,
     maxTicks = _params$maxTicks === void 0 ? 999 : _params$maxTicks,
@@ -20,23 +20,36 @@ function useTicks(options) {
     // band scale
     if (isBandScale(scale)) {
       var domain = scale.domain();
-      return [].concat(_toConsumableArray(domain.map(function (value) {
-        var _valueFormatter, _scale;
+      if (scale.bandwidth() > 0) {
+        // scale type = 'band'
+        return [].concat(_toConsumableArray(domain.map(function (value, index) {
+          var _valueFormatter;
+          return {
+            formattedValue: (_valueFormatter = valueFormatter == null ? void 0 : valueFormatter(value)) != null ? _valueFormatter : value,
+            offset: index === 0 ? scale.range()[0] : scale(value) - (scale.step() - scale.bandwidth()) / 2,
+            labelOffset: scale.step() / 2
+          };
+        })), [{
+          formattedValue: undefined,
+          offset: scale.range()[1],
+          labelOffset: 0
+        }]);
+      }
+
+      // scale type = 'point'
+      return domain.map(function (value) {
+        var _valueFormatter2;
         return {
-          formattedValue: (_valueFormatter = valueFormatter == null ? void 0 : valueFormatter(value)) != null ? _valueFormatter : value,
-          offset: (_scale = scale(value)) != null ? _scale : 0,
-          labelOffset: scale.bandwidth() / 2
+          formattedValue: (_valueFormatter2 = valueFormatter == null ? void 0 : valueFormatter(value)) != null ? _valueFormatter2 : value,
+          offset: scale(value),
+          labelOffset: 0
         };
-      })), _toConsumableArray(scale.bandwidth() > 0 ? [{
-        formattedValue: undefined,
-        offset: scale.range()[1],
-        labelOffset: 0
-      }] : []));
+      });
     }
     return scale.ticks(ticksNumber).map(function (value) {
-      var _valueFormatter2;
+      var _valueFormatter3;
       return {
-        formattedValue: (_valueFormatter2 = valueFormatter == null ? void 0 : valueFormatter(value)) != null ? _valueFormatter2 : scale.tickFormat(ticksNumber)(value),
+        formattedValue: (_valueFormatter3 = valueFormatter == null ? void 0 : valueFormatter(value)) != null ? _valueFormatter3 : scale.tickFormat(ticksNumber)(value),
         offset: scale(value),
         labelOffset: 0
       };

package/legacy/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts v6.0.0-alpha.1
+ * @mui/x-charts v6.0.0-alpha.3
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -7,6 +7,7 @@
  */
 export * from './constants';
 export * from './context';
+export * from './hooks';
 export * from './colorPalettes';
 export * from './models';
 export * from './ChartsClipPath';
@@ -17,6 +18,7 @@ export * from './ChartsTooltip';
 export * from './ChartsAxisHighlight';
 export * from './BarChart';
 export * from './LineChart';
+export * from './PieChart';
 export * from './ScatterChart';
 export * from './ChartContainer';
 export * from './ResponsiveChartContainer';

package/legacy/internals/defaultizeColor.js

@@ -2,6 +2,15 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 var DEFAULT_COLORS = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'];
 export function defaultizeColor(series, seriesIndex) {
   var colors = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_COLORS;
+  if (series.type === 'pie') {
+    return _extends({}, series, {
+      data: series.data.map(function (d, index) {
+        return _extends({
+          color: colors[index % colors.length]
+        }, d);
+      })
+    });
+  }
   return _extends({
     color: colors[seriesIndex % colors.length]
   }, series);

package/legacy/internals/getScale.js

@@ -0,0 +1,17 @@
+import { scaleLog, scalePow, scaleSqrt, scaleTime, scaleUtc, scaleLinear } from 'd3-scale';
+export function getScale(scaleType, domain, range) {
+  switch (scaleType) {
+    case 'log':
+      return scaleLog(domain, range);
+    case 'pow':
+      return scalePow(domain, range);
+    case 'sqrt':
+      return scaleSqrt(domain, range);
+    case 'time':
+      return scaleTime(domain, range);
+    case 'utc':
+      return scaleUtc(domain, range);
+    default:
+      return scaleLinear(domain, range);
+  }
+}

package/legacy/internals/isBandScale.js

@@ -0,0 +1,3 @@
+export function isBandScale(scale) {
+  return scale.bandwidth !== undefined;
+}

package/legacy/models/axis.js

@@ -1 +1,6 @@
-export {};
+export function isBandScaleConfig(scaleConfig) {
+  return scaleConfig.scaleType === 'band';
+}
+export function isPointScaleConfig(scaleConfig) {
+  return scaleConfig.scaleType === 'point';
+}

package/legacy/models/seriesType/index.js

@@ -1,12 +1,5 @@
-// import { PieSeriesType } from './pie';
-
-// | PieSeriesType;
-
-// | PieSeriesType;
-
-// | PieSeriesType
-
 export * from './line';
 export * from './bar';
 export * from './scatter';
+export * from './pie';
 export {};

package/models/axis.d.ts

@@ -1,6 +1,8 @@
 import type { ScaleBand, ScaleLogarithmic, ScalePower, ScaleTime, ScaleLinear, ScalePoint } from 'd3-scale';
 import { ChartsAxisClasses } from '../ChartsAxis/axisClasses';
 import type { TickParams } from '../hooks/useTicks';
+export type D3Scale = ScaleBand<any> | ScaleLogarithmic<any, any> | ScalePoint<any> | ScalePower<any, any> | ScaleTime<any, any> | ScaleLinear<any, any>;
+export type D3ContinuouseScale = ScaleLogarithmic<any, any> | ScalePower<any, any> | ScaleTime<any, any> | ScaleLinear<any, any>;
 export interface ChartsAxisProps {
     /**
      * Id of the axis to render.
@@ -68,51 +70,62 @@ interface AxisScaleConfig {
     band: {
         scaleType: 'band';
         scale: ScaleBand<any>;
-        ticksNumber: number;
+        /**
+         * The ratio between the space allocated for padding between two categories and the category width.
+         * 0 means no gap, and 1 no data.
+         * @default 0.1
+         */
+        categoryGapRatio: number;
+        /**
+         * The ratio between the width of a bar, and the gap between two bars.
+         * 0 means no gap, and 1 no bar.
+         * @default 0
+         */
+        barGapRatio: number;
     };
     point: {
         scaleType: 'point';
         scale: ScalePoint<any>;
-        ticksNumber: number;
     };
     log: {
         scaleType: 'log';
         scale: ScaleLogarithmic<any, any>;
-        ticksNumber: number;
     };
     pow: {
         scaleType: 'pow';
         scale: ScalePower<any, any>;
-        ticksNumber: number;
     };
     sqrt: {
         scaleType: 'sqrt';
         scale: ScalePower<any, any>;
-        ticksNumber: number;
     };
     time: {
         scaleType: 'time';
         scale: ScaleTime<any, any>;
-        ticksNumber: number;
     };
     utc: {
         scaleType: 'utc';
         scale: ScaleTime<any, any>;
-        ticksNumber: number;
     };
     linear: {
         scaleType: 'linear';
         scale: ScaleLinear<any, any>;
-        ticksNumber: number;
     };
 }
-export type AxisConfig<S = ScaleName, V = any> = {
+export type AxisConfig<S extends ScaleName = ScaleName, V = any> = {
     id: string;
-    scaleType?: S;
     min?: number;
     max?: number;
     data?: V[];
     valueFormatter?: (value: V) => string;
-} & Partial<ChartsXAxisProps | ChartsYAxisProps> & TickParams;
-export type AxisDefaultized<S extends ScaleName = ScaleName, V = any> = Omit<AxisConfig<S, V>, 'scaleType'> & AxisScaleConfig[S];
+} & Partial<ChartsXAxisProps | ChartsYAxisProps> & Partial<Omit<AxisScaleConfig[S], 'scale'>> & TickParams;
+export type AxisDefaultized<S extends ScaleName = ScaleName, V = any> = Omit<AxisConfig<S, V>, 'scaleType'> & AxisScaleConfig[S] & {
+    ticksNumber: number;
+};
+export declare function isBandScaleConfig(scaleConfig: AxisConfig<ScaleName>): scaleConfig is AxisConfig<'band'> & {
+    scaleType: 'band';
+};
+export declare function isPointScaleConfig(scaleConfig: AxisConfig<ScaleName>): scaleConfig is AxisConfig<'point'> & {
+    scaleType: 'point';
+};
 export {};

package/models/axis.js

@@ -2,4 +2,12 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+exports.isBandScaleConfig = isBandScaleConfig;
+exports.isPointScaleConfig = isPointScaleConfig;
+function isBandScaleConfig(scaleConfig) {
+  return scaleConfig.scaleType === 'band';
+}
+function isPointScaleConfig(scaleConfig) {
+  return scaleConfig.scaleType === 'point';
+}

package/models/seriesType/bar.d.ts

@@ -14,5 +14,5 @@ export type BarItemIdentifier = {
     seriesId: DefaultizedBarSeriesType['id'];
     dataIndex: number;
 };
-export interface DefaultizedBarSeriesType extends DefaultizedProps<BarSeriesType, CommonDefaultizedProps> {
+export interface DefaultizedBarSeriesType extends DefaultizedProps<BarSeriesType, CommonDefaultizedProps | 'color'> {
 }

package/models/seriesType/common.d.ts

@@ -11,7 +11,7 @@ export type CommonSeriesType<TValue> = {
     valueFormatter?: (value: TValue) => string;
     highlightScope?: Partial<HighlightScope>;
 };
-export type CommonDefaultizedProps = 'id' | 'color' | 'valueFormatter';
+export type CommonDefaultizedProps = 'id' | 'valueFormatter';
 export type CartesianSeriesType = {
     xAxisKey?: string;
     yAxisKey?: string;

package/models/seriesType/config.d.ts

@@ -1,8 +1,9 @@
 import { ScatterSeriesType, DefaultizedScatterSeriesType, ScatterItemIdentifier } from './scatter';
 import { LineSeriesType, DefaultizedLineSeriesType, LineItemIdentifier } from './line';
 import { BarItemIdentifier, BarSeriesType, DefaultizedBarSeriesType } from './bar';
+import { PieSeriesType, DefaultizedPieSeriesType, PieItemIdentifier, PieValueType } from './pie';
 import { AxisConfig } from '../axis';
-import { DefaultizedProps } from '../helpers';
+import { DefaultizedProps, MakeOptional } from '../helpers';
 import { StackingGroupsType } from '../../internals/stackSeries';
 interface ChartsSeriesConfig {
     bar: {
@@ -28,8 +29,18 @@ interface ChartsSeriesConfig {
         series: DefaultizedScatterSeriesType;
         itemIdentifier: ScatterItemIdentifier;
     };
+    pie: {
+        seriesInput: Omit<DefaultizedProps<PieSeriesType, 'id'>, 'data'> & {
+            data: (MakeOptional<PieValueType, 'id'> & {
+                color: string;
+            })[];
+        };
+        series: DefaultizedPieSeriesType;
+        itemIdentifier: PieItemIdentifier;
+    };
 }
-export type ChartSeriesType = 'bar' | 'line' | 'scatter';
+export type CartesianChartSeriesType = 'bar' | 'line' | 'scatter';
+export type ChartSeriesType = 'bar' | 'line' | 'scatter' | 'pie';
 export type ChartSeries<T extends ChartSeriesType> = ChartsSeriesConfig[T] extends {
     canBeStacked: true;
 } ? ChartsSeriesConfig[T]['seriesInput'] & {
@@ -63,4 +74,20 @@ export type FormatterResult<T extends ChartSeriesType> = {
     stackingGroups: StackingGroupsType;
 } : {});
 export type Formatter<T extends ChartSeriesType> = (params: FormatterParams<T>) => FormatterResult<T>;
+export type LegendParams = {
+    /**
+     * The color used in the legend
+     */
+    color: string;
+    /**
+     * The label displayed in the legend
+     */
+    label: string;
+    /**
+     * The identifier of the legend element.
+     * Used for internal purpose such as `key` props
+     */
+    id: string;
+};
+export type LegendGetter<T extends ChartSeriesType> = (series: FormatterResult<T>) => LegendParams[];
 export {};

package/models/seriesType/index.d.ts

@@ -1,13 +1,17 @@
 import { BarItemIdentifier, BarSeriesType, DefaultizedBarSeriesType } from './bar';
 import { DefaultizedLineSeriesType, LineItemIdentifier, LineSeriesType } from './line';
 import { DefaultizedScatterSeriesType, ScatterItemIdentifier, ScatterSeriesType } from './scatter';
-type AllSeriesType = BarSeriesType | LineSeriesType | ScatterSeriesType;
+import { DefaultizedPieSeriesType, PieSeriesType, PieItemIdentifier, PieValueType } from './pie';
+import { MakeOptional } from '../helpers';
+type AllSeriesType = BarSeriesType | LineSeriesType | ScatterSeriesType | PieSeriesType<MakeOptional<PieValueType, 'id'>>;
 type CartesianSeriesType = BarSeriesType | LineSeriesType | ScatterSeriesType;
 type DefaultizedCartesianSeriesType = DefaultizedBarSeriesType | DefaultizedLineSeriesType | DefaultizedScatterSeriesType;
+type DefaultizedSeriesType = DefaultizedCartesianSeriesType | DefaultizedPieSeriesType;
 type StackableSeriesType = DefaultizedBarSeriesType | DefaultizedLineSeriesType;
-export type SeriesItemIdentifier = BarItemIdentifier | LineItemIdentifier | ScatterItemIdentifier;
+export type SeriesItemIdentifier = BarItemIdentifier | LineItemIdentifier | ScatterItemIdentifier | PieItemIdentifier;
 export * from './line';
 export * from './bar';
 export * from './scatter';
+export * from './pie';
 export type { StackOrderType, StackOffsetType } from './common';
-export type { AllSeriesType, CartesianSeriesType, DefaultizedCartesianSeriesType, StackableSeriesType, };
+export type { AllSeriesType, CartesianSeriesType, DefaultizedSeriesType, DefaultizedCartesianSeriesType, StackableSeriesType, };

package/models/seriesType/index.js

@@ -35,4 +35,15 @@ Object.keys(_scatter).forEach(function (key) {
       return _scatter[key];
     }
   });
+});
+var _pie = require("./pie");
+Object.keys(_pie).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pie[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pie[key];
+    }
+  });
 });

package/models/seriesType/line.d.ts

@@ -21,5 +21,5 @@ export type LineItemIdentifier = {
      */
     dataIndex?: number;
 };
-export interface DefaultizedLineSeriesType extends DefaultizedProps<LineSeriesType, CommonDefaultizedProps> {
+export interface DefaultizedLineSeriesType extends DefaultizedProps<LineSeriesType, CommonDefaultizedProps | 'color'> {
 }