@mui/x-charts 8.0.0-alpha.1 → 8.0.0-alpha.10

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

@@ -0,0 +1,2 @@
+export { useChartZAxis } from "./useChartZAxis.js";
+export * from "./useChartZAxis.selectors.js";

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

@@ -0,0 +1,3 @@
+import { ChartPlugin } from '../../models';
+import { UseChartZAxisSignature } from './useChartZAxis.types';
+export declare const useChartZAxis: ChartPlugin<UseChartZAxisSignature>;

package/internals/plugins/featurePlugins/useChartZAxis/useChartZAxis.js

@@ -0,0 +1,86 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { getColorScale, getOrdinalColorScale } from "../../../colorScale.js";
+function addDefaultId(axisConfig, defaultId) {
+  if (axisConfig.id !== undefined) {
+    return axisConfig;
+  }
+  return _extends({
+    id: defaultId
+  }, axisConfig);
+}
+function processColorMap(axisConfig) {
+  if (!axisConfig.colorMap) {
+    return axisConfig;
+  }
+  return _extends({}, axisConfig, {
+    colorScale: axisConfig.colorMap.type === 'ordinal' && axisConfig.data ? getOrdinalColorScale(_extends({
+      values: axisConfig.data
+    }, axisConfig.colorMap)) : getColorScale(axisConfig.colorMap.type === 'continuous' ? _extends({
+      min: axisConfig.min,
+      max: axisConfig.max
+    }, axisConfig.colorMap) : axisConfig.colorMap)
+  });
+}
+function getZAxisState(zAxis, dataset) {
+  if (!zAxis || zAxis.length === 0) {
+    return {
+      axis: {},
+      axisIds: []
+    };
+  }
+  const zAxisLookup = {};
+  const axisIds = [];
+  zAxis.forEach((axisConfig, index) => {
+    const dataKey = axisConfig.dataKey;
+    const defaultizedId = axisConfig.id ?? `defaultized-z-axis-${index}`;
+    if (dataKey === undefined || axisConfig.data !== undefined) {
+      zAxisLookup[defaultizedId] = processColorMap(addDefaultId(axisConfig, defaultizedId));
+      axisIds.push(defaultizedId);
+      return;
+    }
+    if (dataset === undefined) {
+      throw new Error('MUI X: z-axis uses `dataKey` but no `dataset` is provided.');
+    }
+    zAxisLookup[defaultizedId] = processColorMap(addDefaultId(_extends({}, axisConfig, {
+      data: dataset.map(d => d[dataKey])
+    }), defaultizedId));
+    axisIds.push(defaultizedId);
+  });
+  return {
+    axis: zAxisLookup,
+    axisIds
+  };
+}
+export const useChartZAxis = ({
+  params,
+  store
+}) => {
+  const {
+    zAxis,
+    dataset
+  } = params;
+
+  // The effect do not track any value defined synchronously during the 1st render by hooks called after `useChartZAxis`
+  // 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, {
+      zAxis: getZAxisState(zAxis, dataset)
+    }));
+  }, [zAxis, dataset, store]);
+  return {};
+};
+useChartZAxis.params = {
+  zAxis: true,
+  dataset: true
+};
+useChartZAxis.getInitialState = params => ({
+  zAxis: getZAxisState(params.zAxis, params.dataset)
+});

package/internals/plugins/featurePlugins/useChartZAxis/useChartZAxis.selectors.d.ts

@@ -0,0 +1,45 @@
+import { ChartState } from '../../models/chart';
+import { UseChartZAxisSignature } from './useChartZAxis.types';
+export declare const selectorChartZAxis: ((state: import("../../corePlugins/useChartId/useChartId.types").UseChartIdState & import("../../corePlugins/useChartDimensions/useChartDimensions.types").UseChartDimensionsState & import("../../corePlugins/useChartSeries/useChartSeries.types").UseChartSeriesState<keyof import("../../..").ChartsSeriesConfig> & import("./useChartZAxis.types").UseChartZAxisState & Partial<{}> & {
+    cacheKey: import("../../models").ChartStateCacheKey;
+}) => {
+    axis: {
+        [axisId: string]: import("../../..").ZAxisDefaultized;
+    };
+    axisIds: import("../../..").AxisId[];
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: ChartState<[UseChartZAxisSignature]>) => {
+        axis: {
+            [axisId: string]: import("../../..").ZAxisDefaultized;
+        };
+        axisIds: import("../../..").AxisId[];
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: ChartState<[UseChartZAxisSignature]>) => {
+        axis: {
+            [axisId: string]: import("../../..").ZAxisDefaultized;
+        };
+        axisIds: import("../../..").AxisId[];
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        axis: {
+            [axisId: string]: import("../../..").ZAxisDefaultized;
+        };
+        axisIds: import("../../..").AxisId[];
+    };
+    dependencies: [(state: ChartState<[UseChartZAxisSignature]>) => ChartState<[UseChartZAxisSignature]>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

package/internals/plugins/featurePlugins/useChartZAxis/useChartZAxis.selectors.js

@@ -0,0 +1,3 @@
+import { createSelector } from "../../utils/selectors.js";
+const selectRootState = state => state;
+export const selectorChartZAxis = createSelector([selectRootState], state => state.zAxis);

package/internals/plugins/featurePlugins/useChartZAxis/useChartZAxis.types.d.ts

@@ -0,0 +1,39 @@
+import { MakeOptional } from '@mui/x-internals/types';
+import { ChartPluginSignature } from '../../models';
+import { DatasetType } from '../../../../models/seriesType/config';
+import { AxisId } from '../../../../models/axis';
+import { ZAxisConfig, ZAxisDefaultized } from '../../../../models/z-axis';
+type DefaultizedZAxisConfig = {
+    [axisId: string]: ZAxisDefaultized;
+};
+export interface UseChartZAxisParameters {
+    /**
+     * The configuration of the z-axes.
+     */
+    zAxis?: MakeOptional<ZAxisConfig, 'id'>[];
+    /**
+     * An array of objects that can be used to populate series and axes data using their `dataKey` property.
+     */
+    dataset?: DatasetType;
+}
+export type UseChartZAxisDefaultizedParameters = UseChartZAxisParameters;
+export interface UseChartZAxisState {
+    zAxis: {
+        /**
+         * Mapping from z-axis key to scaling configuration.
+         */
+        axis: DefaultizedZAxisConfig;
+        /**
+         * The z-axes IDs sorted by order they got provided.
+         */
+        axisIds: AxisId[];
+    };
+}
+export interface UseChartZAxisInstance {
+}
+export type UseChartZAxisSignature = ChartPluginSignature<{
+    params: UseChartZAxisParameters;
+    defaultizedParams: UseChartZAxisDefaultizedParameters;
+    state: UseChartZAxisState;
+}>;
+export {};

package/internals/plugins/models/chart.d.ts

@@ -0,0 +1,14 @@
+import type { ChartAnyPluginSignature } from './plugin';
+import type { MergeSignaturesProperty } from './helpers';
+import type { ChartCorePluginSignatures } from '../corePlugins';
+export type ChartInstance<TSignatures extends readonly ChartAnyPluginSignature[], TOptionalSignatures extends readonly ChartAnyPluginSignature[] = []> = MergeSignaturesProperty<[...ChartCorePluginSignatures, ...TSignatures], 'instance'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
+export type ChartPublicAPI<TSignatures extends readonly ChartAnyPluginSignature[], TOptionalSignatures extends readonly ChartAnyPluginSignature[] = []> = MergeSignaturesProperty<[...ChartCorePluginSignatures, ...TSignatures], 'publicAPI'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'instance'>>;
+export type ChartStateCacheKey = {
+    id: number;
+};
+export type ChartState<TSignatures extends readonly ChartAnyPluginSignature[], TOptionalSignatures extends readonly ChartAnyPluginSignature[] = []> = MergeSignaturesProperty<[...ChartCorePluginSignatures, ...TSignatures], 'state'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'state'>> & {
+    /**
+     * The key used to identify the chart in the global cache object.
+     */
+    cacheKey: ChartStateCacheKey;
+};

package/internals/plugins/models/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { ChartAnyPluginSignature, ChartPlugin } from './plugin';
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type OptionalIfEmpty<A extends string, B> = keyof B extends never ? Partial<Record<A, B>> : IsAny<B> extends true ? Partial<Record<A, B>> : Record<A, B>;
+export type MergeSignaturesProperty<TSignatures extends readonly any[], TProperty extends keyof ChartAnyPluginSignature> = TSignatures extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends ChartAnyPluginSignature ? P[TProperty] & MergeSignaturesProperty<R, TProperty> : {} : {};
+export type ConvertPluginsIntoSignatures<TPlugins extends readonly ChartPlugin<ChartAnyPluginSignature>[]> = TPlugins extends readonly [plugin: infer TPlugin, ...otherPlugin: infer R] ? R extends readonly ChartPlugin<any>[] ? TPlugin extends ChartPlugin<infer TSignature> ? readonly [TSignature, ...ConvertPluginsIntoSignatures<R>] : never : never : [];
+export type ConvertSignaturesIntoPlugins<TSignatures extends readonly ChartAnyPluginSignature[]> = TSignatures extends readonly [signature: infer TSignature, ...otherSignatures: infer R] ? R extends readonly ChartAnyPluginSignature[] ? TSignature extends ChartAnyPluginSignature ? readonly [ChartPlugin<TSignature>, ...ConvertSignaturesIntoPlugins<R>] : never : never : [];
+export {};

package/internals/plugins/models/index.d.ts

@@ -1,35 +1,4 @@
-import { ChartItemIdentifier, ChartSeriesType } from '../../../models/seriesType/config';
-export type ItemInteractionData<T extends ChartSeriesType> = ChartItemIdentifier<T>;
-export type AxisInteractionData = {
-    x: null | {
-        value: number | Date | string;
-        index: number;
-    };
-    y: null | {
-        value: number | Date | string;
-        index: number;
-    };
-};
-type InteractionState = {
-    /**
-     * The item currently interacting.
-     */
-    item: null | ItemInteractionData<ChartSeriesType>;
-    /**
-     * The x- and y-axes currently interacting.
-     */
-    axis: AxisInteractionData;
-    /**
-     * Set to `true` when `VoronoiHandler` is active.
-     * Used to prevent collision with mouseEnter events.
-     */
-    isVoronoiEnabled?: boolean;
-};
-export type ChartStateCacheKey = {
-    id: number;
-};
-export type ChartState = {
-    interaction: InteractionState;
-    cacheKey: ChartStateCacheKey;
-};
-export {};
+export * from './helpers';
+export * from './plugin';
+export * from './chart';
+export * from './seriesConfig';

package/internals/plugins/models/index.js

@@ -1 +1,4 @@
-export {};
+export * from "./helpers.js";
+export * from "./plugin.js";
+export * from "./chart.js";
+export * from "./seriesConfig/index.js";

package/internals/plugins/models/plugin.d.ts

@@ -0,0 +1,105 @@
+import * as React from 'react';
+import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
+import type { ChartCorePluginSignatures } from '../corePlugins';
+import { ChartStore } from '../utils/ChartStore';
+import { ChartSeriesConfig } from './seriesConfig';
+export interface ChartPluginOptions<TSignature extends ChartAnyPluginSignature> {
+    instance: ChartUsedInstance<TSignature>;
+    params: ChartUsedDefaultizedParams<TSignature>;
+    models: ChartUsedControlModels<TSignature>;
+    store: ChartUsedStore<TSignature>;
+    svgRef: React.RefObject<SVGSVGElement | null>;
+    plugins: ChartPlugin<ChartAnyPluginSignature>[];
+    seriesConfig: ChartSeriesConfig<any>;
+}
+type ChartControlModelsInitializer<TSignature extends ChartAnyPluginSignature> = {
+    [TControlled in keyof TSignature['models']]: {
+        getDefaultValue: (params: TSignature['defaultizedParams']) => Exclude<TSignature['defaultizedParams'][TControlled], undefined>;
+    };
+};
+type ChartResponse<TSignature extends ChartAnyPluginSignature> = OptionalIfEmpty<'publicAPI', TSignature['publicAPI']> & OptionalIfEmpty<'instance', TSignature['instance']>;
+export type ChartPluginSignature<T extends {
+    params?: {};
+    defaultizedParams?: {};
+    instance?: {};
+    publicAPI?: {};
+    state?: {};
+    modelNames?: keyof T['defaultizedParams'];
+    dependencies?: readonly ChartAnyPluginSignature[];
+    optionalDependencies?: readonly ChartAnyPluginSignature[];
+}> = {
+    params: T extends {
+        params: {};
+    } ? T['params'] : {};
+    defaultizedParams: T extends {
+        defaultizedParams: {};
+    } ? T['defaultizedParams'] : {};
+    instance: T extends {
+        instance: {};
+    } ? T['instance'] : {};
+    state: T extends {
+        state: {};
+    } ? T['state'] : {};
+    publicAPI: T extends {
+        publicAPI: {};
+    } ? T['publicAPI'] : {};
+    models: T extends {
+        defaultizedParams: {};
+        modelNames: keyof T['defaultizedParams'];
+    } ? {
+        [TControlled in T['modelNames']]-?: ChartControlModel<Exclude<T['defaultizedParams'][TControlled], undefined>>;
+    } : {};
+    dependencies: T extends {
+        dependencies: Array<any>;
+    } ? T['dependencies'] : [];
+    optionalDependencies: T extends {
+        optionalDependencies: Array<any>;
+    } ? T['optionalDependencies'] : [];
+};
+export type ChartAnyPluginSignature = {
+    state: any;
+    instance: any;
+    params: any;
+    models: any;
+    defaultizedParams: any;
+    dependencies: any;
+    optionalDependencies: any;
+    publicAPI: any;
+};
+type ChartRequiredPlugins<TSignature extends ChartAnyPluginSignature> = [
+    ...ChartCorePluginSignatures,
+    ...TSignature['dependencies']
+];
+type PluginPropertyWithDependencies<TSignature extends ChartAnyPluginSignature, TProperty extends keyof ChartAnyPluginSignature> = TSignature[TProperty] & MergeSignaturesProperty<ChartRequiredPlugins<TSignature>, TProperty> & Partial<MergeSignaturesProperty<TSignature['optionalDependencies'], TProperty>>;
+export type ChartUsedParams<TSignature extends ChartAnyPluginSignature> = MergeSignaturesProperty<TSignature['dependencies'], 'defaultizedParams'> & PluginPropertyWithDependencies<TSignature, 'params'>;
+type ChartUsedDefaultizedParams<TSignature extends ChartAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'defaultizedParams'>;
+export type ChartUsedInstance<TSignature extends ChartAnyPluginSignature> = PluginPropertyWithDependencies<TSignature, 'instance'> & {
+    /**
+     * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
+     */
+    $$signature: TSignature;
+};
+export interface ChartControlModel<TValue> {
+    name: string;
+    value: TValue;
+    setControlledValue: (value: TValue | ((prevValue: TValue) => TValue)) => void;
+    isControlled: boolean;
+}
+type RemoveSetValue<Models extends Record<string, ChartControlModel<any>>> = {
+    [K in keyof Models]: Omit<Models[K], 'setValue'>;
+};
+export type ChartUsedControlModels<TSignature extends ChartAnyPluginSignature> = TSignature['models'] & RemoveSetValue<MergeSignaturesProperty<ChartRequiredPlugins<TSignature>, 'models'>>;
+export type ChartUsedStore<TSignature extends ChartAnyPluginSignature> = ChartStore<[
+    TSignature,
+    ...TSignature['dependencies']
+]>;
+export type ChartPlugin<TSignature extends ChartAnyPluginSignature> = {
+    (options: ChartPluginOptions<TSignature>): ChartResponse<TSignature>;
+    getInitialState?: (params: ChartUsedDefaultizedParams<TSignature>, currentState: MergeSignaturesProperty<ChartRequiredPlugins<TSignature>, 'state'>, seriesConfig: ChartSeriesConfig<any>) => TSignature['state'];
+    models?: ChartControlModelsInitializer<TSignature>;
+    params: Record<keyof TSignature['params'], true>;
+    getDefaultizedParams?: (options: {
+        params: ChartUsedParams<TSignature>;
+    }) => TSignature['defaultizedParams'];
+};
+export {};

package/internals/plugins/models/seriesConfig/colorProcessor.types.d.ts

@@ -0,0 +1,5 @@
+import type { AxisDefaultized } from '../../../../models/axis';
+import type { DefaultizedSeriesType } from '../../../../models/seriesType';
+import type { ZAxisDefaultized } from '../../../../models/z-axis';
+import type { ChartSeriesType } from '../../../../models/seriesType/config';
+export type ColorProcessor<TSeriesType extends ChartSeriesType> = (series: DefaultizedSeriesType<TSeriesType>, xAxis?: AxisDefaultized, yAxis?: AxisDefaultized, zAxis?: ZAxisDefaultized) => (dataIndex: number) => string;

package/internals/plugins/models/seriesConfig/extremumGetter.types.d.ts

@@ -0,0 +1,22 @@
+import type { CartesianChartSeriesType, ChartSeriesDefaultized } from '../../../../models/seriesType/config';
+import type { AxisConfig, AxisId } from '../../../../models/axis';
+import type { SeriesId } from '../../../../models/seriesType/common';
+type CartesianExtremumGetterParams<TSeriesType extends CartesianChartSeriesType> = {
+    series: Record<SeriesId, ChartSeriesDefaultized<TSeriesType>>;
+    axis: AxisConfig;
+    axisIndex: number;
+    isDefaultAxis: boolean;
+    getFilters?: (params: {
+        currentAxisId: AxisId | undefined;
+        seriesXAxisId?: AxisId;
+        seriesYAxisId?: AxisId;
+        isDefaultAxis: boolean;
+    }) => CartesianExtremumFilter;
+};
+export type CartesianExtremumGetterResult = [number, number];
+export type CartesianExtremumGetter<TSeriesType extends CartesianChartSeriesType> = (params: CartesianExtremumGetterParams<TSeriesType>) => CartesianExtremumGetterResult;
+export type CartesianExtremumFilter = (value: {
+    x: number | Date | string | null;
+    y: number | Date | string | null;
+}, dataIndex: number) => boolean;
+export {};

package/internals/plugins/models/seriesConfig/extremumGetter.types.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/seriesConfig/index.d.ts

@@ -0,0 +1,6 @@
+export * from './colorProcessor.types';
+export * from './extremumGetter.types';
+export * from './seriesConfig.types';
+export * from './seriesProcessor.types';
+export * from './tooltipGetter.types';
+export * from './legendGetter.types';

package/internals/plugins/models/seriesConfig/index.js

@@ -0,0 +1,6 @@
+export * from "./colorProcessor.types.js";
+export * from "./extremumGetter.types.js";
+export * from "./seriesConfig.types.js";
+export * from "./seriesProcessor.types.js";
+export * from "./tooltipGetter.types.js";
+export * from "./legendGetter.types.js";

package/internals/plugins/models/seriesConfig/legendGetter.types.d.ts

@@ -0,0 +1,4 @@
+import type { LegendItemParams } from '../../../../ChartsLegend';
+import type { ChartSeriesType } from '../../../../models/seriesType/config';
+import type { SeriesProcessorResult } from './seriesProcessor.types';
+export type LegendGetter<T extends ChartSeriesType> = (series: SeriesProcessorResult<T>) => LegendItemParams[];

package/internals/plugins/models/seriesConfig/legendGetter.types.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/seriesConfig/seriesConfig.types.d.ts

@@ -0,0 +1,18 @@
+import type { SeriesProcessor } from './seriesProcessor.types';
+import type { CartesianChartSeriesType, ChartSeriesType } from '../../../../models/seriesType/config';
+import type { ColorProcessor } from './colorProcessor.types';
+import type { CartesianExtremumGetter } from './extremumGetter.types';
+import type { LegendGetter } from './legendGetter.types';
+import type { TooltipGetter } from './tooltipGetter.types';
+export type ChartSeriesTypeConfig<TSeriesType extends ChartSeriesType> = {
+    seriesProcessor: SeriesProcessor<TSeriesType>;
+    colorProcessor: ColorProcessor<TSeriesType>;
+    legendGetter: LegendGetter<TSeriesType>;
+    tooltipGetter: TooltipGetter<TSeriesType>;
+} & (TSeriesType extends CartesianChartSeriesType ? {
+    xExtremumGetter: CartesianExtremumGetter<TSeriesType>;
+    yExtremumGetter: CartesianExtremumGetter<TSeriesType>;
+} : {});
+export type ChartSeriesConfig<TSeriesType extends ChartSeriesType> = {
+    [Key in TSeriesType]: ChartSeriesTypeConfig<Key>;
+};

package/internals/plugins/models/seriesConfig/seriesConfig.types.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/seriesConfig/seriesProcessor.types.d.ts

@@ -0,0 +1,16 @@
+import type { ChartSeriesDefaultized, ChartSeriesType, ChartsSeriesConfig, DatasetType } from '../../../../models/seriesType/config';
+import type { SeriesId } from '../../../../models/seriesType/common';
+import type { StackingGroupsType } from '../../../stackSeries';
+export type SeriesProcessorParams<TSeriesType extends ChartSeriesType> = {
+    series: Record<SeriesId, ChartsSeriesConfig[TSeriesType]['seriesInput']>;
+    seriesOrder: SeriesId[];
+};
+export type SeriesProcessorResult<TSeriesType extends ChartSeriesType> = {
+    series: Record<SeriesId, ChartSeriesDefaultized<TSeriesType>>;
+    seriesOrder: SeriesId[];
+} & (ChartsSeriesConfig[TSeriesType] extends {
+    canBeStacked: true;
+} ? {
+    stackingGroups: StackingGroupsType;
+} : {});
+export type SeriesProcessor<TSeriesType extends ChartSeriesType> = (params: SeriesProcessorParams<TSeriesType>, dataset?: DatasetType) => SeriesProcessorResult<TSeriesType>;

package/internals/plugins/models/seriesConfig/seriesProcessor.types.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/models/seriesConfig/tooltipGetter.types.d.ts

@@ -0,0 +1,7 @@
+import type { ItemTooltip } from '../../../../ChartsTooltip';
+import type { ChartItemIdentifier, ChartSeriesDefaultized, ChartSeriesType } from '../../../../models/seriesType/config';
+export type TooltipGetter<T extends ChartSeriesType> = (params: {
+    series: ChartSeriesDefaultized<T>;
+    getColor: (dataIndex: number) => string;
+    identifier: ChartItemIdentifier<T> | null;
+}) => ItemTooltip<T> | null;

package/internals/plugins/models/seriesConfig/tooltipGetter.types.js

@@ -0,0 +1 @@
+export {};

package/internals/plugins/utils/ChartStore.d.ts

@@ -1,12 +1,13 @@
-import type { ChartState } from '../models';
+import type { ChartState } from '../models/chart';
+import type { ChartAnyPluginSignature } from '../models/plugin';
 type Listener<T> = (value: T) => void;
-export type StoreUpdater = (prevState: ChartState) => ChartState;
-export declare class ChartStore {
-    value: ChartState;
+export type StoreUpdater<TSignatures extends readonly ChartAnyPluginSignature[]> = (prevState: ChartState<TSignatures>) => ChartState<TSignatures>;
+export declare class ChartStore<TSignatures extends readonly ChartAnyPluginSignature[]> {
+    value: ChartState<TSignatures>;
     private listeners;
-    constructor(value: ChartState);
-    subscribe: (fn: Listener<ChartState>) => () => void;
-    getSnapshot: () => ChartState;
-    update: (updater: StoreUpdater) => void;
+    constructor(value: ChartState<TSignatures>);
+    subscribe: (fn: Listener<ChartState<TSignatures>>) => () => void;
+    getSnapshot: () => ChartState<TSignatures>;
+    update: (updater: StoreUpdater<TSignatures>) => void;
 }
 export {};

package/internals/plugins/utils/ChartStore.js

@@ -1,5 +1,3 @@
-// For now this is fixed. Will need to support generic if we add plugins
-
 export class ChartStore {
   constructor(value) {
     this.value = void 0;

package/internals/plugins/utils/selectors.d.ts

@@ -1,6 +1,6 @@
 import { CreateSelectorFunction } from 'reselect';
-import { ChartState } from '../models';
-export type ChartsRootSelector = (state: ChartState) => ChartState[keyof ChartState];
+import { ChartAnyPluginSignature, ChartState } from '../models';
+export type ChartRootSelector<TSignature extends ChartAnyPluginSignature> = <TSignatures extends [TSignature]>(state: ChartState<TSignatures>) => TSignature['state'][keyof TSignature['state']];
 export type ChartsSelector<TState, TArgs, TResult> = (state: TState, args: TArgs) => TResult;
 /**
  * Method wrapping reselect's createSelector to provide caching for chart instances.

package/internals/store/extractPluginParamsFromProps.d.ts

@@ -0,0 +1,7 @@
+import { ChartCorePluginSignatures } from '../plugins/corePlugins';
+import { ChartPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from '../plugins/models';
+import { UseChartBaseProps } from './useCharts.types';
+export declare const extractPluginParamsFromProps: <TSignatures extends readonly ChartPluginSignature<any>[], TProps extends Partial<UseChartBaseProps<TSignatures>>>({ props: { apiRef, ...props }, plugins, }: {
+    props: TProps;
+    plugins: ConvertSignaturesIntoPlugins<readonly [...ChartCorePluginSignatures, ...TSignatures]>;
+}) => MergeSignaturesProperty<TSignatures, "defaultizedParams">;

package/internals/store/extractPluginParamsFromProps.js

@@ -0,0 +1,28 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["apiRef"];
+export const extractPluginParamsFromProps = _ref => {
+  let {
+      plugins
+    } = _ref,
+    props = _objectWithoutPropertiesLoose(_ref.props, _excluded);
+  const paramsLookup = {};
+  plugins.forEach(plugin => {
+    Object.assign(paramsLookup, plugin.params);
+  });
+  const pluginParams = {};
+  Object.keys(props).forEach(propName => {
+    const prop = props[propName];
+    if (paramsLookup[propName]) {
+      pluginParams[propName] = prop;
+    }
+  });
+  const defaultizedPluginParams = plugins.reduce((acc, plugin) => {
+    if (plugin.getDefaultizedParams) {
+      return plugin.getDefaultizedParams({
+        params: acc
+      });
+    }
+    return acc;
+  }, pluginParams);
+  return defaultizedPluginParams;
+};

package/internals/store/useChartModels.d.ts

@@ -0,0 +1,7 @@
+import { ChartAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from '../plugins/models';
+import { ChartCorePluginSignatures } from '../plugins/corePlugins';
+/**
+ * Implements the same behavior as `useControlled` but for several models.
+ * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
+ */
+export declare const useChartModels: <TSignatures extends readonly ChartAnyPluginSignature[]>(plugins: ConvertSignaturesIntoPlugins<readonly [...ChartCorePluginSignatures, ...TSignatures]>, props: MergeSignaturesProperty<TSignatures, "defaultizedParams">) => MergeSignaturesProperty<TSignatures, "models">;

package/internals/store/useChartModels.js

@@ -0,0 +1,64 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+/**
+ * Implements the same behavior as `useControlled` but for several models.
+ * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
+ */
+export const useChartModels = (plugins, props) => {
+  const modelsRef = React.useRef({});
+  const [modelsState, setModelsState] = React.useState(() => {
+    const initialState = {};
+    plugins.forEach(plugin => {
+      if (plugin.models) {
+        Object.entries(plugin.models).forEach(([modelName, modelInitializer]) => {
+          modelsRef.current[modelName] = {
+            isControlled: props[modelName] !== undefined,
+            getDefaultValue: modelInitializer.getDefaultValue
+          };
+          initialState[modelName] = modelInitializer.getDefaultValue(props);
+        });
+      }
+    });
+    return initialState;
+  });
+  const models = Object.fromEntries(Object.entries(modelsRef.current).map(([modelName, model]) => {
+    const value = props[modelName] ?? modelsState[modelName];
+    return [modelName, {
+      value,
+      setControlledValue: newValue => {
+        if (!model.isControlled) {
+          setModelsState(prevState => _extends({}, prevState, {
+            [modelName]: typeof newValue === 'function' ? newValue(value) : newValue
+          }));
+        }
+      },
+      isControlled: modelsRef.current[modelName].isControlled
+    }];
+  }));
+
+  // We know that `modelsRef` do not vary across renders.
+  if (process.env.NODE_ENV !== 'production') {
+    Object.entries(modelsRef.current).forEach(([modelName, model]) => {
+      const controlled = props[modelName];
+      const newDefaultValue = model.getDefaultValue(props);
+
+      /* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps, react-compiler/react-compiler */
+      React.useEffect(() => {
+        if (model.isControlled !== (controlled !== undefined)) {
+          console.error([`MUI X: A component is changing the ${model.isControlled ? '' : 'un'}controlled ${modelName} state of Chart to be ${model.isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled ${modelName} ` + 'element for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
+        }
+      }, [controlled]);
+      const {
+        current: defaultValue
+      } = React.useRef(newDefaultValue);
+      React.useEffect(() => {
+        if (!model.isControlled && defaultValue !== newDefaultValue) {
+          console.error([`MUI X: A component is changing the default ${modelName} state of an uncontrolled Chart after being initialized. ` + `To suppress this warning opt to use a controlled Chart.`].join('\n'));
+        }
+      }, [JSON.stringify(newDefaultValue)]);
+    });
+  }
+  /* eslint-enable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
+
+  return models;
+};