@mui/x-charts 7.6.1 → 7.7.0

package/internals/index.js

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useReducedMotion: true,
+  useSeries: true
+};
+Object.defineProperty(exports, "useReducedMotion", {
+  enumerable: true,
+  get: function () {
+    return _useReducedMotion.useReducedMotion;
+  }
+});
+Object.defineProperty(exports, "useSeries", {
+  enumerable: true,
+  get: function () {
+    return _useSeries.useSeries;
+  }
+});
+var _ChartsAxesGradients = require("./components/ChartsAxesGradients");
+Object.keys(_ChartsAxesGradients).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ChartsAxesGradients[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ChartsAxesGradients[key];
+    }
+  });
+});
+var _useChartContainerDimensions = require("../ResponsiveChartContainer/useChartContainerDimensions");
+Object.keys(_useChartContainerDimensions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useChartContainerDimensions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useChartContainerDimensions[key];
+    }
+  });
+});
+var _ResizableContainer = require("../ResponsiveChartContainer/ResizableContainer");
+Object.keys(_ResizableContainer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ResizableContainer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ResizableContainer[key];
+    }
+  });
+});
+var _useReducedMotion = require("../hooks/useReducedMotion");
+var _useSeries = require("../hooks/useSeries");
+var _defaultizeValueFormatter = require("./defaultizeValueFormatter");
+Object.keys(_defaultizeValueFormatter).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _defaultizeValueFormatter[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _defaultizeValueFormatter[key];
+    }
+  });
+});
+var _configInit = require("./configInit");
+Object.keys(_configInit).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _configInit[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _configInit[key];
+    }
+  });
+});
+var _CartesianContextProvider = require("../context/CartesianContextProvider");
+Object.keys(_CartesianContextProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _CartesianContextProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _CartesianContextProvider[key];
+    }
+  });
+});
+var _DrawingProvider = require("../context/DrawingProvider");
+Object.keys(_DrawingProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DrawingProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DrawingProvider[key];
+    }
+  });
+});
+var _InteractionProvider = require("../context/InteractionProvider");
+Object.keys(_InteractionProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _InteractionProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _InteractionProvider[key];
+    }
+  });
+});
+var _SeriesContextProvider = require("../context/SeriesContextProvider");
+Object.keys(_SeriesContextProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SeriesContextProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _SeriesContextProvider[key];
+    }
+  });
+});
+var _ZAxisContextProvider = require("../context/ZAxisContextProvider");
+Object.keys(_ZAxisContextProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ZAxisContextProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ZAxisContextProvider[key];
+    }
+  });
+});
+var _config = require("../models/seriesType/config");
+Object.keys(_config).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _config[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _config[key];
+    }
+  });
+});
+var _common = require("../models/seriesType/common");
+Object.keys(_common).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _common[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _common[key];
+    }
+  });
+});
+var _helpers = require("../models/helpers");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});
+var _zAxis = require("../models/z-axis");
+Object.keys(_zAxis).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _zAxis[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _zAxis[key];
+    }
+  });
+});
+var _axis = require("../models/axis");
+Object.keys(_axis).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _axis[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _axis[key];
+    }
+  });
+});

package/internals/isCartesian.d.ts

@@ -0,0 +1,7 @@
+import { ChartSeriesType, CartesianChartSeriesType, ChartSeriesDefaultized } from '../models/seriesType/config';
+export declare function isCartesianSeriesType(seriesType: string): seriesType is CartesianChartSeriesType;
+export declare function isCartesianSeries(series: ChartSeriesDefaultized<ChartSeriesType> & {
+    getColor: (dataIndex: number) => string;
+}): series is ChartSeriesDefaultized<CartesianChartSeriesType> & {
+    getColor: (dataIndex: number) => string;
+};

package/internals/isCartesian.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCartesianSeries = isCartesianSeries;
+exports.isCartesianSeriesType = isCartesianSeriesType;
+var _configInit = require("./configInit");
+function isCartesianSeriesType(seriesType) {
+  return _configInit.cartesianSeriesTypes.getTypes().has(seriesType);
+}
+function isCartesianSeries(series) {
+  return isCartesianSeriesType(series.type);
+}

package/internals/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "../esm/internals/index.js",
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/internals/warning.d.ts

@@ -0,0 +1 @@
+export declare function buildWarning(message: (...args: any) => string, gravity?: 'warning' | 'error'): (...args: any) => void;

package/internals/warning.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildWarning = buildWarning;
+function buildWarning(message, gravity = 'warning') {
+  let alreadyWarned = false;
+  return (...args) => {
+    if (!alreadyWarned) {
+      alreadyWarned = true;
+      if (gravity === 'error') {
+        console.error(message(...args));
+      } else {
+        console.warn(message(...args));
+      }
+    }
+  };
+}

package/models/axis.d.ts

@@ -182,7 +182,7 @@ export interface AxisScaleConfig {
         colorMap?: ContinuousColorConfig | PiecewiseColorConfig;
     };
 }
-interface AxisScaleComputedConfig {
+export interface AxisScaleComputedConfig {
     band: {
         colorScale?: ScaleOrdinal<string | number | Date, string, string | null> | ScaleOrdinal<number, string, string | null> | ScaleSequential<string, string | null> | ScaleThreshold<number | Date, string | null>;
     };
@@ -216,7 +216,7 @@ export type AxisValueFormatterContext = {
      */
     location: 'tick' | 'tooltip';
 };
-export type AxisConfig<S extends ScaleName = ScaleName, V = any> = {
+export type AxisConfig<S extends ScaleName = ScaleName, V = any, AxisProps = ChartsXAxisProps | ChartsYAxisProps> = {
     /**
      * Id used to identify the axis.
      */
@@ -254,8 +254,8 @@ export type AxisConfig<S extends ScaleName = ScaleName, V = any> = {
      * If `true`, Reverse the axis scaleBand.
      */
     reverse?: boolean;
-} & 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] & AxisScaleComputedConfig[S] & {
+} & Partial<AxisProps> & Partial<Omit<AxisScaleConfig[S], 'scale'>> & TickParams;
+export type AxisDefaultized<S extends ScaleName = ScaleName, V = any, AxisProps = ChartsXAxisProps | ChartsYAxisProps> = Omit<AxisConfig<S, V, AxisProps>, 'scaleType'> & AxisScaleConfig[S] & AxisScaleComputedConfig[S] & {
     /**
      * An indication of the expected number of ticks.
      */
@@ -267,4 +267,3 @@ export declare function isBandScaleConfig(scaleConfig: AxisConfig<ScaleName>): s
 export declare function isPointScaleConfig(scaleConfig: AxisConfig<ScaleName>): scaleConfig is AxisConfig<'point'> & {
     scaleType: 'point';
 };
-export {};

package/models/index.d.ts

@@ -1,4 +1,5 @@
 export * from './seriesType';
 export * from './layout';
 export * from './stacking';
+export * from './plugin';
 export type { AxisConfig, ChartsYAxisProps, ChartsXAxisProps, ScaleName, ContinuousScaleName, } from './axis';

package/models/index.js

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

package/models/plugin.d.ts

@@ -0,0 +1,16 @@
+import { ChartSeriesType, ExtremumGetter, Formatter } from './seriesType/config';
+import { AxisDefaultized } from './axis';
+import { DefaultizedSeriesType } from './seriesType';
+import { ZAxisDefaultized } from './z-axis';
+type ColorProcessor<T extends ChartSeriesType> = (series: DefaultizedSeriesType<T>, xAxis?: AxisDefaultized, yAxis?: AxisDefaultized, zAxis?: ZAxisDefaultized) => (dataIndex: number) => string;
+export type ColorProcessorsConfig<T extends ChartSeriesType> = {
+    [Key in T]?: ColorProcessor<Key>;
+};
+export type ChartsPluginType<T> = T extends ChartSeriesType ? {
+    seriesType: T;
+    seriesFormatter: Formatter<T>;
+    colorProcessor: ColorProcessor<T>;
+    xExtremumGetter?: ExtremumGetter<T>;
+    yExtremumGetter?: ExtremumGetter<T>;
+} : never;
+export {};

package/models/plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/models/seriesType/config.d.ts

@@ -6,29 +6,44 @@ import { AxisConfig } from '../axis';
 import { DefaultizedProps, MakeOptional } from '../helpers';
 import { StackingGroupsType } from '../../internals/stackSeries';
 import { SeriesId } from './common';
-interface ChartsSeriesConfig {
+export interface ChartsSeriesConfig {
     bar: {
+        /**
+         * Series type when passed to the formatter (some ids are given default values to simplify the DX)
+         */
         seriesInput: DefaultizedProps<BarSeriesType, 'id'> & {
             color: string;
         };
+        /**
+         * Series type when stored in the context (with all the preprocessing added))
+         */
         series: DefaultizedBarSeriesType;
-        canBeStacked: true;
+        /**
+         * Series typing such that the one user need to provide
+         */
+        seriesProp: BarSeriesType;
         itemIdentifier: BarItemIdentifier;
+        canBeStacked: true;
+        cartesian: true;
     };
     line: {
         seriesInput: DefaultizedProps<LineSeriesType, 'id'> & {
             color: string;
         };
         series: DefaultizedLineSeriesType;
-        canBeStacked: true;
+        seriesProp: LineSeriesType;
         itemIdentifier: LineItemIdentifier;
+        canBeStacked: true;
+        cartesian: true;
     };
     scatter: {
         seriesInput: DefaultizedProps<ScatterSeriesType, 'id'> & {
             color: string;
         };
         series: DefaultizedScatterSeriesType;
+        seriesProp: ScatterSeriesType;
         itemIdentifier: ScatterItemIdentifier;
+        cartesian: true;
     };
     pie: {
         seriesInput: Omit<DefaultizedProps<PieSeriesType, 'id'>, 'data'> & {
@@ -37,11 +52,21 @@ interface ChartsSeriesConfig {
             })[];
         };
         series: DefaultizedPieSeriesType;
+        seriesProp: PieSeriesType<MakeOptional<PieValueType, 'id'>>;
         itemIdentifier: PieItemIdentifier;
     };
 }
-export type CartesianChartSeriesType = 'bar' | 'line' | 'scatter';
-export type ChartSeriesType = 'bar' | 'line' | 'scatter' | 'pie';
+export type ChartSeriesType = keyof ChartsSeriesConfig;
+export type CartesianChartSeriesType = keyof Pick<ChartsSeriesConfig, {
+    [Key in ChartSeriesType]: ChartsSeriesConfig[Key] extends {
+        cartesian: true;
+    } ? Key : never;
+}[ChartSeriesType]>;
+export type StackableChartSeriesType = keyof Pick<ChartsSeriesConfig, {
+    [Key in ChartSeriesType]: ChartsSeriesConfig[Key] extends {
+        canBeStacked: true;
+    } ? Key : never;
+}[ChartSeriesType]>;
 export type ChartSeries<T extends ChartSeriesType> = ChartsSeriesConfig[T] extends {
     canBeStacked: true;
 } ? ChartsSeriesConfig[T]['seriesInput'] & {

package/models/seriesType/index.d.ts

@@ -1,14 +1,11 @@
-import { BarItemIdentifier, BarSeriesType, DefaultizedBarSeriesType } from './bar';
-import { DefaultizedLineSeriesType, LineItemIdentifier, LineSeriesType } from './line';
-import { DefaultizedScatterSeriesType, ScatterItemIdentifier, ScatterSeriesType } from './scatter';
-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 | PieItemIdentifier;
+import { BarSeriesType, DefaultizedBarSeriesType } from './bar';
+import { CartesianChartSeriesType, ChartSeriesType, ChartsSeriesConfig, StackableChartSeriesType } from './config';
+type AllSeriesType<T extends ChartSeriesType = ChartSeriesType> = ChartsSeriesConfig[T]['seriesProp'];
+type CartesianSeriesType = AllSeriesType<CartesianChartSeriesType>;
+type DefaultizedSeriesType<T extends ChartSeriesType = ChartSeriesType> = ChartsSeriesConfig[T]['series'];
+type DefaultizedCartesianSeriesType = DefaultizedSeriesType<CartesianChartSeriesType>;
+type StackableSeriesType = DefaultizedSeriesType<StackableChartSeriesType>;
+export type SeriesItemIdentifier<T extends ChartSeriesType = ChartSeriesType> = ChartsSeriesConfig[T]['itemIdentifier'];
 export * from './line';
 export * from './bar';
 export * from './scatter';

package/models/seriesType/index.js

@@ -57,6 +57,12 @@ Object.keys(_pie).forEach(function (key) {
     }
   });
 });
+// Series definition
+
+// item identifier
+
+// Helpers
+
 function isDefaultizedBarSeries(series) {
   return series.type === 'bar';
 }

package/modern/BarChart/BarChart.js

@@ -351,7 +351,7 @@ process.env.NODE_ENV !== "production" ? BarChart.propTypes = {
     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']),
+    position: PropTypes.oneOf(['bottom', 'top']),
     reverse: PropTypes.bool,
     scaleType: PropTypes.oneOf(['band', 'linear', 'log', 'point', 'pow', 'sqrt', 'time', 'utc']),
     slotProps: PropTypes.object,
@@ -404,7 +404,7 @@ process.env.NODE_ENV !== "production" ? BarChart.propTypes = {
     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']),
+    position: PropTypes.oneOf(['left', 'right']),
     reverse: PropTypes.bool,
     scaleType: PropTypes.oneOf(['band', 'linear', 'log', 'point', 'pow', 'sqrt', 'time', 'utc']),
     slotProps: PropTypes.object,

package/modern/BarChart/BarPlot.js

@@ -4,7 +4,6 @@ const _excluded = ["skipAnimation", "onItemClick", "borderRadius", "barLabel"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import { useTransition } from '@react-spring/web';
-import { SeriesContext } from '../context/SeriesContextProvider';
 import { CartesianContext } from '../context/CartesianContextProvider';
 import { BarElement } from './BarElement';
 import getColor from './getColor';
@@ -12,6 +11,7 @@ import { useChartId } from '../hooks';
 import { BarClipPath } from './BarClipPath';
 import { BarLabelPlot } from './BarLabel/BarLabelPlot';
 import { checkScaleErrors } from './checkScaleErrors';
+import { useBarSeries } from '../hooks/useSeries';
 
 /**
  * Solution of the equations
@@ -42,7 +42,7 @@ function getBandSize({
   };
 }
 const useAggregatedData = () => {
-  const seriesData = React.useContext(SeriesContext).bar ?? {
+  const seriesData = useBarSeries() ?? {
     series: {},
     stackingGroups: [],
     seriesOrder: []

package/modern/BarChart/formatter.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { stack as d3Stack } from 'd3-shape';
 import { getStackingGroups } from '../internals/stackSeries';
-import defaultizeValueFormatter from '../internals/defaultizeValueFormatter';
+import { defaultizeValueFormatter } from '../internals/defaultizeValueFormatter';
 let warnOnce = false;
 const formatter = (params, dataset) => {
   const {

package/modern/BarChart/getColor.js

@@ -1,8 +1,8 @@
 export default function getColor(series, xAxis, yAxis) {
   const verticalLayout = series.layout === 'vertical';
-  const bandColorScale = verticalLayout ? xAxis.colorScale : yAxis.colorScale;
-  const valueColorScale = verticalLayout ? yAxis.colorScale : xAxis.colorScale;
-  const bandValues = verticalLayout ? xAxis.data : yAxis.data;
+  const bandColorScale = verticalLayout ? xAxis?.colorScale : yAxis?.colorScale;
+  const valueColorScale = verticalLayout ? yAxis?.colorScale : xAxis?.colorScale;
+  const bandValues = verticalLayout ? xAxis?.data : yAxis?.data;
   if (valueColorScale) {
     return dataIndex => {
       const value = series.data[dataIndex];
@@ -13,7 +13,7 @@ export default function getColor(series, xAxis, yAxis) {
       return color;
     };
   }
-  if (bandColorScale) {
+  if (bandColorScale && bandValues) {
     return dataIndex => {
       const value = bandValues[dataIndex];
       const color = value === null ? series.color : bandColorScale(value);

package/modern/BarChart/plugin.js

@@ -0,0 +1,10 @@
+import { getExtremumX, getExtremumY } from './extremums';
+import formatter from './formatter';
+import getColor from './getColor';
+export const plugin = {
+  seriesType: 'bar',
+  seriesFormatter: formatter,
+  colorProcessor: getColor,
+  xExtremumGetter: getExtremumX,
+  yExtremumGetter: getExtremumY
+};