@mui/x-charts 8.0.0-alpha.6 → 8.0.0-alpha.8

package/internals/plugins/corePlugins/useChartSeries/useChartSeries.types.d.ts

@@ -0,0 +1,51 @@
+import { AllSeriesType } from '../../../../models/seriesType';
+import { ChartsColorPalette } from '../../../../colorPalettes';
+import { ChartPluginSignature, ChartSeriesConfig } from '../../models';
+import { ChartSeriesType, DatasetType } from '../../../../models/seriesType/config';
+import { SeriesProcessorResult } from '../../models/seriesConfig/seriesProcessor.types';
+export interface UseChartSeriesParameters<T extends ChartSeriesType = ChartSeriesType> {
+    dataset?: DatasetType;
+    /**
+     * The array of series to display.
+     * Each type of series has its own specificity.
+     * Please refer to the appropriate docs page to learn more about it.
+     */
+    series?: AllSeriesType<T>[];
+    /**
+     * Color palette used to colorize multiple series.
+     * @default blueberryTwilightPalette
+     */
+    colors?: ChartsColorPalette;
+    theme?: 'light' | 'dark';
+}
+export type UseChartSeriesDefaultizedParameters<T extends ChartSeriesType = ChartSeriesType> = UseChartSeriesParameters<T> & {
+    /**
+     * The array of series to display.
+     * Each type of series has its own specificity.
+     * Please refer to the appropriate docs page to learn more about it.
+     */
+    series: AllSeriesType<T>[];
+    /**
+     * Color palette used to colorize multiple series.
+     * @default blueberryTwilightPalette
+     */
+    colors: ChartsColorPalette;
+    theme: 'light' | 'dark';
+};
+export type ProcessedSeries<TSeriesTypes extends ChartSeriesType = ChartSeriesType> = {
+    [type in TSeriesTypes]?: SeriesProcessorResult<type>;
+};
+export interface UseChartSeriesState<T extends ChartSeriesType = ChartSeriesType> {
+    series: {
+        processedSeries: ProcessedSeries<T>;
+        seriesConfig: ChartSeriesConfig<T>;
+    };
+}
+export interface UseChartSeriesInstance {
+}
+export type UseChartSeriesSignature<SeriesType extends ChartSeriesType = ChartSeriesType> = ChartPluginSignature<{
+    params: UseChartSeriesParameters;
+    defaultizedParams: UseChartSeriesDefaultizedParameters<SeriesType>;
+    state: UseChartSeriesState<SeriesType>;
+    instance: UseChartSeriesInstance;
+}>;

package/internals/plugins/corePlugins/useChartSeries/useColorProcessor.d.ts

@@ -0,0 +1,10 @@
+import { ChartSeriesType } from '../../../../models/seriesType/config';
+import { DefaultizedSeriesType } from '../../../../models/seriesType';
+import { AxisDefaultized } from '../../../../models/axis';
+import { ZAxisDefaultized } from '../../../../models/z-axis';
+export 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 declare function useColorProcessor<T extends ChartSeriesType>(seriesType: T): ColorProcessorsConfig<T>[T];
+export declare function useColorProcessor(): ColorProcessorsConfig<ChartSeriesType>;

package/internals/plugins/corePlugins/useChartSeries/useColorProcessor.js

@@ -0,0 +1,21 @@
+'use client';
+
+import * as React from 'react';
+import { useSelector } from "../../../store/useSelector.js";
+import { useStore } from "../../../store/useStore.js";
+import { selectorChartSeriesConfig } from "./useChartSeries.selectors.js";
+export function useColorProcessor(seriesType) {
+  const store = useStore();
+  const seriesConfig = useSelector(store, selectorChartSeriesConfig);
+  const colorProcessors = React.useMemo(() => {
+    const rep = {};
+    Object.keys(seriesConfig).forEach(seriesT => {
+      rep[seriesT] = seriesConfig[seriesT].colorProcessor;
+    });
+    return rep;
+  }, [seriesConfig]);
+  if (!seriesType) {
+    return colorProcessors;
+  }
+  return colorProcessors[seriesType];
+}

package/internals/plugins/featurePlugins/useChartCartesianAxis/computeAxisValue.d.ts

@@ -0,0 +1,29 @@
+import { AxisConfig, ScaleName } from '../../../../models';
+import { ChartsXAxisProps, ChartsAxisProps, ChartsYAxisProps, AxisId } from '../../../../models/axis';
+import { ChartSeriesType } from '../../../../models/seriesType/config';
+import type { ChartDrawingArea } from '../../../../hooks';
+import { ChartSeriesConfig } from '../../models/seriesConfig';
+import { DefaultizedAxisConfig, DefaultizedZoomOptions } from './useChartCartesianAxis.types';
+import { ProcessedSeries } from '../../corePlugins/useChartSeries/useChartSeries.types';
+import { GetZoomAxisFilters, ZoomData } from './zoom.types';
+type ComputeResult<T extends ChartsAxisProps> = {
+    axis: DefaultizedAxisConfig<T>;
+    axisIds: string[];
+};
+type ComputeCommonParams<T extends ChartSeriesType = ChartSeriesType> = {
+    drawingArea: ChartDrawingArea;
+    formattedSeries: ProcessedSeries<T>;
+    seriesConfig: ChartSeriesConfig<T>;
+    zoomMap?: Map<AxisId, ZoomData>;
+    zoomOptions?: Record<AxisId, DefaultizedZoomOptions>;
+    getFilters?: GetZoomAxisFilters;
+};
+export declare function computeAxisValue<T extends ChartSeriesType>(options: ComputeCommonParams<T> & {
+    axis?: AxisConfig<ScaleName, any, ChartsYAxisProps>[];
+    axisDirection: 'y';
+}): ComputeResult<ChartsYAxisProps>;
+export declare function computeAxisValue<T extends ChartSeriesType>(options: ComputeCommonParams<T> & {
+    axis?: AxisConfig<ScaleName, any, ChartsXAxisProps>[];
+    axisDirection: 'x';
+}): ComputeResult<ChartsAxisProps>;
+export {};

package/internals/{computeAxisValue.js → plugins/featurePlugins/useChartCartesianAxis/computeAxisValue.js}

@@ -1,26 +1,14 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { scaleBand, scalePoint, scaleTime } from '@mui/x-charts-vendor/d3-scale';
-import { isBandScaleConfig, isPointScaleConfig } from "../models/axis.js";
-import { getColorScale, getOrdinalColorScale } from "./colorScale.js";
-import { getTickNumber } from "../hooks/useTicks.js";
-import { getScale } from "./getScale.js";
-import { zoomScaleRange } from "../context/CartesianProvider/zoom.js";
-import { getAxisExtremum } from "../context/CartesianProvider/getAxisExtremum.js";
-function getRange(drawingArea, axisDirection, axis) {
-  if (axisDirection === 'rotation') {
-    const {
-      startAngle = 0,
-      endAngle = startAngle + 360
-    } = axis;
-    return axis.reverse ? [Math.PI * startAngle / 180, Math.PI * endAngle / 180] : [Math.PI * endAngle / 180, Math.PI * startAngle / 180];
-  }
-  if (axisDirection === 'radius') {
-    const {
-      minRadius = 0,
-      maxRadius = Math.min(drawingArea.width, drawingArea.height) / 2
-    } = axis;
-    return [minRadius, maxRadius];
-  }
+import { isBandScaleConfig, isPointScaleConfig } from "../../../../models/axis.js";
+import { getColorScale, getOrdinalColorScale } from "../../../colorScale.js";
+import { getTickNumber } from "../../../../hooks/useTicks.js";
+import { getScale } from "../../../getScale.js";
+import { zoomScaleRange } from "./zoom.js";
+import { getAxisExtremum } from "./getAxisExtremum.js";
+function getRange(drawingArea, axisDirection,
+// | 'rotation' | 'radius',
+axis) {
   const range = axisDirection === 'x' ? [drawingArea.left, drawingArea.left + drawingArea.width] : [drawingArea.top + drawingArea.height, drawingArea.top];
   return axis.reverse ? [range[1], range[0]] : range;
 }
@@ -37,22 +25,26 @@ export function computeAxisValue({
   drawingArea,
   formattedSeries,
   axis: allAxis,
-  extremumGetters,
+  seriesConfig,
   axisDirection,
-  zoomData,
+  zoomMap,
   zoomOptions,
   getFilters
 }) {
+  if (allAxis === undefined) {
+    return {
+      axis: {},
+      axisIds: []
+    };
+  }
   const completeAxis = {};
   allAxis.forEach((eachAxis, axisIndex) => {
     const axis = eachAxis;
     const zoomOption = zoomOptions?.[axis.id];
-    const zoom = zoomData?.find(({
-      axisId
-    }) => axisId === axis.id);
+    const zoom = zoomMap?.get(axis.id);
     const zoomRange = zoom ? [zoom.start, zoom.end] : [0, 100];
     const range = getRange(drawingArea, axisDirection, axis);
-    const [minData, maxData] = getAxisExtremum(axis, extremumGetters, axisIndex, formattedSeries, zoom === undefined && !zoomOption ? getFilters : undefined // Do not apply filtering if zoom is already defined.
+    const [minData, maxData] = getAxisExtremum(axis, axisDirection, seriesConfig, axisIndex, formattedSeries, zoom === undefined && !zoomOption ? getFilters : undefined // Do not apply filtering if zoom is already defined.
     );
     const data = axis.data ?? [];
     if (isBandScaleConfig(axis)) {

package/internals/plugins/featurePlugins/useChartCartesianAxis/createAxisFilterMapper.d.ts

@@ -0,0 +1,18 @@
+import type { ChartsAxisProps } from '../../../../ChartsAxis';
+import { AxisId } from '../../../../models/axis';
+import { CartesianChartSeriesType } from '../../../../models/seriesType/config';
+import { ProcessedSeries } from '../../corePlugins/useChartSeries';
+import { AxisConfig, ScaleName } from '../../../../models';
+import { ChartSeriesConfig } from '../../models/seriesConfig';
+import { DefaultizedZoomOptions, ExtremumFilter } from './useChartCartesianAxis.types';
+import { GetZoomAxisFilters, ZoomAxisFilters, ZoomData } from './zoom.types';
+type CreateAxisFilterMapperParams = {
+    zoomMap: Map<AxisId, ZoomData>;
+    zoomOptions: Record<AxisId, DefaultizedZoomOptions>;
+    seriesConfig: ChartSeriesConfig<CartesianChartSeriesType>;
+    formattedSeries: ProcessedSeries;
+    direction: 'x' | 'y';
+};
+export declare const createAxisFilterMapper: ({ zoomMap, zoomOptions, seriesConfig, formattedSeries, direction, }: CreateAxisFilterMapperParams) => (axis: AxisConfig<ScaleName, any, ChartsAxisProps>, axisIndex: number) => ExtremumFilter | null;
+export declare const createGetAxisFilters: (filters: ZoomAxisFilters) => GetZoomAxisFilters;
+export {};

package/internals/plugins/featurePlugins/useChartCartesianAxis/createAxisFilterMapper.js

@@ -0,0 +1,61 @@
+import { isDefined } from "../../../isDefined.js";
+import { getAxisExtremum } from "./getAxisExtremum.js";
+import { getScale } from "../../../getScale.js";
+export const createAxisFilterMapper = ({
+  zoomMap,
+  zoomOptions,
+  seriesConfig,
+  formattedSeries,
+  direction
+}) => (axis, axisIndex) => {
+  const zoomOption = zoomOptions[axis.id];
+  if (!zoomOption || zoomOption.filterMode !== 'discard') {
+    return null;
+  }
+  const zoom = zoomMap?.get(axis.id);
+  if (zoom === undefined || zoom.start <= 0 && zoom.end >= 100) {
+    // No zoom, or zoom with all data visible
+    return null;
+  }
+  let extremums = [];
+  const scaleType = axis.scaleType;
+  if (scaleType === 'point' || scaleType === 'band') {
+    extremums = [0, (axis.data?.length ?? 1) - 1];
+  } else {
+    extremums = getAxisExtremum(axis, direction, seriesConfig, axisIndex, formattedSeries);
+  }
+  let min;
+  let max;
+  const continuousScaleType = !scaleType || scaleType === 'band' || scaleType === 'point' ? 'linear' : scaleType;
+  [min, max] = getScale(continuousScaleType, extremums, [0, 100]).nice().domain();
+  min = min instanceof Date ? min.getTime() : min;
+  max = max instanceof Date ? max.getTime() : max;
+  const minVal = min + zoom.start * (max - min) / 100;
+  const maxVal = min + zoom.end * (max - min) / 100;
+  return (value, dataIndex) => {
+    const val = value[direction] ?? axis.data?.[dataIndex];
+    if (val == null) {
+      // If the value does not exist because of missing data point, or out of range index, we just ignore.
+      return true;
+    }
+    if (axis.scaleType === 'point' || axis.scaleType === 'band' || typeof val === 'string') {
+      return dataIndex >= minVal && dataIndex <= maxVal;
+    }
+    return val >= minVal && val <= maxVal;
+  };
+};
+export const createGetAxisFilters = filters => ({
+  currentAxisId,
+  seriesXAxisId,
+  seriesYAxisId,
+  isDefaultAxis
+}) => {
+  return (value, dataIndex) => {
+    const axisId = currentAxisId === seriesXAxisId ? seriesYAxisId : seriesXAxisId;
+    if (!axisId || isDefaultAxis) {
+      return Object.values(filters ?? {})[0]?.(value, dataIndex) ?? true;
+    }
+    const data = [seriesYAxisId, seriesXAxisId].filter(id => id !== currentAxisId).map(id => filters[id ?? '']).filter(isDefined);
+    return data.every(f => f(value, dataIndex));
+  };
+};

package/internals/plugins/featurePlugins/useChartCartesianAxis/defaultizeAxis.d.ts

@@ -0,0 +1,39 @@
+import { MakeOptional } from '@mui/x-internals/types';
+import { AxisConfig, ScaleName } from '../../../../models';
+import { ChartsAxisProps } from '../../../../models/axis';
+import { DatasetType } from '../../../../models/seriesType/config';
+export declare function defaultizeAxis(inAxis: MakeOptional<AxisConfig<ScaleName, any, ChartsAxisProps>, 'id'>[] | undefined, dataset: DatasetType | undefined, axisName: 'x' | 'y'): {
+    fill?: string | undefined;
+    data?: any[] | undefined;
+    label?: string | undefined;
+    slots?: Partial<import("../../..").ChartsAxisSlots> | undefined;
+    slotProps?: Partial<import("../../..").ChartsAxisSlotProps> | undefined;
+    reverse?: boolean | undefined;
+    classes?: Partial<import("../../../..").ChartsAxisClasses> | undefined;
+    stroke?: string | undefined;
+    sx?: import("@mui/system").SxProps | undefined;
+    valueFormatter?: ((value: any, context: import("../../..").AxisValueFormatterContext) => string) | undefined;
+    tickMaxStep?: number | undefined;
+    tickMinStep?: number | undefined;
+    tickNumber?: number | undefined;
+    disableLine?: boolean | undefined;
+    disableTicks?: boolean | undefined;
+    tickLabelStyle?: import("../../../getWordsByLines").ChartsTextStyle | undefined;
+    labelStyle?: import("../../../getWordsByLines").ChartsTextStyle | undefined;
+    tickLabelInterval?: "auto" | ((value: any, index: number) => boolean) | undefined;
+    tickSize?: number | undefined;
+    tickInterval?: "auto" | ((value: any, index: number) => boolean) | any[] | undefined;
+    tickPlacement?: "start" | "end" | "middle" | "extremities" | undefined;
+    tickLabelPlacement?: "middle" | "tick" | undefined;
+    scaleType?: "time" | "band" | "point" | "log" | "pow" | "sqrt" | "utc" | "linear" | undefined;
+    colorMap?: import("../../../../models/colorMapping").ContinuousColorConfig<number | Date> | import("../../../../models/colorMapping").PiecewiseColorConfig<number | Date> | import("../../../../models/colorMapping").OrdinalColorConfig<string | number | Date> | undefined;
+    max?: (number | Date) | undefined;
+    min?: (number | Date) | undefined;
+    dataKey?: string | undefined;
+    hideTooltip?: boolean | undefined;
+    domainLimit?: "nice" | "strict" | ((min: number, max: number) => {
+        min: number;
+        max: number;
+    }) | undefined;
+    id: import("../../..").AxisId;
+}[];

package/{context/ChartDataProvider/useDefaultizeAxis.js → internals/plugins/featurePlugins/useChartCartesianAxis/defaultizeAxis.js}

@@ -1,9 +1,6 @@
-'use client';
-
 import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from "../../constants/index.js";
-const defaultizeAxis = (inAxis, dataset, axisName) => {
+import { DEFAULT_X_AXIS_KEY, DEFAULT_Y_AXIS_KEY } from "../../../../constants/index.js";
+export function defaultizeAxis(inAxis, dataset, axisName) {
   const DEFAULT_AXIS_KEY = axisName === 'x' ? DEFAULT_X_AXIS_KEY : DEFAULT_Y_AXIS_KEY;
   return [...(inAxis?.map((axis, index) => _extends({
     id: `defaultized-${axisName}-axis-${index}`
@@ -24,9 +21,4 @@ const defaultizeAxis = (inAxis, dataset, axisName) => {
       data: dataset.map(d => d[dataKey])
     });
   });
-};
-export const useDefaultizeAxis = (inXAxis, inYAxis, dataset) => {
-  const xAxis = React.useMemo(() => defaultizeAxis(inXAxis, dataset, 'x'), [inXAxis, dataset]);
-  const yAxis = React.useMemo(() => defaultizeAxis(inYAxis, dataset, 'y'), [inYAxis, dataset]);
-  return [xAxis, yAxis];
-};
+}

package/internals/plugins/featurePlugins/useChartCartesianAxis/getAxisExtremum.d.ts

@@ -0,0 +1,6 @@
+import { AxisConfig } from '../../../../models';
+import { CartesianChartSeriesType } from '../../../../models/seriesType/config';
+import { ChartSeriesConfig } from '../../models/seriesConfig';
+import { ProcessedSeries } from '../../corePlugins/useChartSeries/useChartSeries.types';
+import { GetZoomAxisFilters } from './zoom.types';
+export declare const getAxisExtremum: <T extends CartesianChartSeriesType>(axis: AxisConfig, axisDirection: "x" | "y", seriesConfig: ChartSeriesConfig<T>, axisIndex: number, formattedSeries: ProcessedSeries<T>, getFilters?: GetZoomAxisFilters) => number[];

package/internals/plugins/featurePlugins/useChartCartesianAxis/getAxisExtremum.js

@@ -0,0 +1,22 @@
+import { isCartesianSeriesType } from "../../../isCartesian.js";
+const axisExtremumCallback = (acc, chartType, axis, axisDirection, seriesConfig, axisIndex, formattedSeries, getFilters) => {
+  const getter = axisDirection === 'x' ? seriesConfig[chartType].xExtremumGetter : seriesConfig[chartType].yExtremumGetter;
+  const series = formattedSeries[chartType]?.series ?? {};
+  const [minChartTypeData, maxChartTypeData] = getter?.({
+    series,
+    axis,
+    axisIndex,
+    isDefaultAxis: axisIndex === 0,
+    getFilters
+  }) ?? [Infinity, -Infinity];
+  const [minData, maxData] = acc;
+  return [Math.min(minChartTypeData, minData), Math.max(maxChartTypeData, maxData)];
+};
+export const getAxisExtremum = (axis, axisDirection, seriesConfig, axisIndex, formattedSeries, getFilters) => {
+  const charTypes = Object.keys(seriesConfig).filter(isCartesianSeriesType);
+  const extremums = charTypes.reduce((acc, charType) => axisExtremumCallback(acc, charType, axis, axisDirection, seriesConfig, axisIndex, formattedSeries, getFilters), [Infinity, -Infinity]);
+  if (Number.isNaN(extremums[0]) || Number.isNaN(extremums[1])) {
+    return [Infinity, -Infinity];
+  }
+  return extremums;
+};

package/internals/plugins/featurePlugins/useChartCartesianAxis/index.d.ts

@@ -0,0 +1,5 @@
+export { useChartCartesianAxis } from './useChartCartesianAxis';
+export type * from './useChartCartesianAxis.types';
+export { defaultizeAxis } from './defaultizeAxis';
+export * from './computeAxisValue';
+export * from './zoom.types';

package/internals/plugins/featurePlugins/useChartCartesianAxis/index.js

@@ -0,0 +1,4 @@
+export { useChartCartesianAxis } from "./useChartCartesianAxis.js";
+export { defaultizeAxis } from "./defaultizeAxis.js";
+export * from "./computeAxisValue.js";
+export * from "./zoom.types.js";

package/internals/plugins/featurePlugins/useChartCartesianAxis/useChartCartesianAxis.d.ts

@@ -0,0 +1,4 @@
+import { ChartPlugin } from '../../models';
+import { ChartSeriesType } from '../../../../models/seriesType/config';
+import { UseChartCartesianAxisSignature } from './useChartCartesianAxis.types';
+export declare const useChartCartesianAxis: ChartPlugin<UseChartCartesianAxisSignature<ChartSeriesType>>;

package/internals/plugins/featurePlugins/useChartCartesianAxis/useChartCartesianAxis.js

@@ -0,0 +1,68 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { warnOnce } from '@mui/x-internals/warning';
+import { blueberryTwilightPalette } from "../../../../colorPalettes/index.js";
+import { useSelector } from "../../../store/useSelector.js";
+import { selectorChartDrawingArea } from "../../corePlugins/useChartDimensions/useChartDimensions.selectors.js";
+import { selectorChartSeriesState } from "../../corePlugins/useChartSeries/useChartSeries.selectors.js";
+import { defaultizeAxis } from "./defaultizeAxis.js";
+export const useChartCartesianAxis = ({
+  params,
+  store,
+  seriesConfig
+}) => {
+  const {
+    xAxis,
+    yAxis,
+    dataset
+  } = params;
+  if (process.env.NODE_ENV !== 'production') {
+    const ids = [...(xAxis ?? []), ...(yAxis ?? [])].filter(axis => axis.id).map(axis => axis.id);
+    const duplicates = new Set(ids.filter((id, index) => ids.indexOf(id) !== index));
+    if (duplicates.size > 0) {
+      warnOnce([`MUI X: The following axis ids are duplicated: ${Array.from(duplicates).join(', ')}.`, `Please make sure that each axis has a unique id.`].join('\n'), 'error');
+    }
+  }
+  const drawingArea = useSelector(store, selectorChartDrawingArea);
+  const formattedSeries = useSelector(store, selectorChartSeriesState);
+
+  // The effect do not track any value defined synchronously during the 1st render by hooks called after `useChartCartesianAxis`
+  // As a consequence, the state generated by the 1st run of this useEffect will always be equal to the initialization one
+  const isFirstRender = React.useRef(true);
+  React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
+    store.update(prev => _extends({}, prev, {
+      cartesianAxis: _extends({}, prev.cartesianAxis, {
+        x: defaultizeAxis(xAxis, dataset, 'x'),
+        y: defaultizeAxis(yAxis, dataset, 'y')
+      })
+    }));
+  }, [seriesConfig, drawingArea, formattedSeries, xAxis, yAxis, dataset, store]);
+  return {};
+};
+useChartCartesianAxis.params = {
+  xAxis: true,
+  yAxis: true,
+  dataset: true
+};
+useChartCartesianAxis.getDefaultizedParams = ({
+  params
+}) => {
+  return _extends({}, params, {
+    colors: params.colors ?? blueberryTwilightPalette,
+    theme: params.theme ?? 'light',
+    defaultizedXAxis: defaultizeAxis(params.xAxis, params.dataset, 'x'),
+    defaultizedYAxis: defaultizeAxis(params.yAxis, params.dataset, 'y')
+  });
+};
+useChartCartesianAxis.getInitialState = params => ({
+  cartesianAxis: {
+    x: params.defaultizedXAxis,
+    y: params.defaultizedYAxis
+  }
+});