@mui/x-charts 8.0.0-alpha.11 → 8.0.0-alpha.12

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

@@ -0,0 +1,171 @@
+import * as React from 'react';
+import type { MergeSignaturesProperty, OptionalIfEmpty } from './helpers';
+import type { ChartCorePluginSignatures } from '../corePlugins';
+import { ChartStore } from "../utils/ChartStore.js";
+import { ChartSeriesConfig } from "./seriesConfig/index.js";
+export interface ChartPluginOptions<TSignature extends ChartAnyPluginSignature> {
+  /**
+   * An imperative api available for internal use.
+   */
+  instance: ChartUsedInstance<TSignature>;
+  /**
+   * The parameters after being processed with the default values.
+   */
+  params: ChartUsedDefaultizedParams<TSignature>;
+  /**
+   * The store of controlled properties.
+   * If they are not controlled by the user, they will be initialized by the plugin.
+   */
+  models: ChartUsedControlModels<TSignature>;
+  /**
+   * The store that can be used to access the state of other plugins.
+   */
+  store: ChartUsedStore<TSignature>;
+  /**
+   * Reference to the main svg element.
+   */
+  svgRef: React.RefObject<SVGSVGElement | null>;
+  /**
+   * All the plugins that are used in the chart.
+   */
+  plugins: ChartPlugin<ChartAnyPluginSignature>[];
+  /**
+   * All the series configurations that are currently loaded.
+   */
+  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[];
+}> = {
+  /**
+   * The raw properties that can be passed to the plugin.
+   */
+  params: T extends {
+    params: {};
+  } ? T['params'] : {};
+  /**
+   * The params after being processed with the default values.
+   */
+  defaultizedParams: T extends {
+    defaultizedParams: {};
+  } ? T['defaultizedParams'] : {};
+  /**
+   * An imperative api available for internal use.
+   */
+  instance: T extends {
+    instance: {};
+  } ? T['instance'] : {};
+  /**
+   * The state is the mutable data that will actually be stored in the plugin state and can be accessed by other plugins.
+   */
+  state: T extends {
+    state: {};
+  } ? T['state'] : {};
+  /**
+   * The public imperative API that will be exposed to the user.
+   * Accessed through the `apiRef` property of the plugin.
+   */
+  publicAPI: T extends {
+    publicAPI: {};
+  } ? T['publicAPI'] : {};
+  /**
+   * A helper for controlled properties.
+   * Properties defined here can be controlled by the user. If they are not controlled, they will be initialized by the plugin.
+   */
+  models: T extends {
+    defaultizedParams: {};
+    modelNames: keyof T['defaultizedParams'];
+  } ? { [TControlled in T['modelNames']]-?: ChartControlModel<Exclude<T['defaultizedParams'][TControlled], undefined>> } : {};
+  /**
+   * Any plugins that this plugin depends on.
+   */
+  dependencies: T extends {
+    dependencies: Array<any>;
+  } ? T['dependencies'] : [];
+  /**
+   * Same as dependencies but the plugin might not have been initialized.
+   */
+  optionalDependencies: T extends {
+    optionalDependencies: Array<any>;
+  } ? T['optionalDependencies'] : [];
+};
+export type ChartAnyPluginSignature = ChartPluginSignature<{
+  params: any;
+  defaultizedParams: any;
+  instance: any;
+  publicAPI: any;
+  state: any;
+  modelNames: any;
+  dependencies: any;
+  optionalDependencies: 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> = {
+  /**
+   * The main function of the plugin that will be executed by the chart.
+   *
+   * This should be a valid React `use` function, as it will be executed in the render phase and can contain hooks.
+   */
+  (options: ChartPluginOptions<TSignature>): ChartResponse<TSignature>;
+  /**
+   * The initial state is computed after the default values are applied.
+   * It set up the state for the first render.
+   * Other state modifications have to be done in effects and so could not be applied on the initial render.
+   *
+   * @param {ChartUsedDefaultizedParams<TSignature>} params The parameters after being processed with the default values.
+   * @param {MergeSignaturesProperty<ChartRequiredPlugins<TSignature>, 'state'>} currentState The current state of the chart.
+   * @param {ChartSeriesConfig<any>} seriesConfig The series configuration.
+   *
+   * @returns {TSignature['state']} The initial state of the plugin.
+   */
+  getInitialState?: (params: ChartUsedDefaultizedParams<TSignature>, currentState: MergeSignaturesProperty<ChartRequiredPlugins<TSignature>, 'state'>, seriesConfig: ChartSeriesConfig<any>) => TSignature['state'];
+  /**
+   * The configuration of properties that can be controlled by the user.
+   * If they are not controlled, they will be initialized by the plugin.
+   */
+  models?: ChartControlModelsInitializer<TSignature>;
+  /**
+   * An object where each property used by the plugin is set to `true`.
+   */
+  params: Record<keyof TSignature['params'], true>;
+  /**
+   * A function that receives the parameters and returns the parameters after being processed with the default values.
+   *
+   * @param {ChartUsedParams<TSignature>} options The options object.
+   * @param {ChartUsedParams<TSignature>['params']} options.params The parameters before being processed with the default values.
+   * @returns {TSignature['defaultizedParams']} The parameters after being processed with the default values.
+   */
+  getDefaultizedParams?: (options: {
+    params: ChartUsedParams<TSignature>;
+  }) => TSignature['defaultizedParams'];
+};
+export {};

package/esm/internals/plugins/models/plugin.js

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

package/esm/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/esm/internals/plugins/models/seriesConfig/colorProcessor.types.js

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

package/esm/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/esm/internals/plugins/models/seriesConfig/extremumGetter.types.js

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

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

@@ -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/esm/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/esm/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/esm/internals/plugins/models/seriesConfig/legendGetter.types.js

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

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

@@ -0,0 +1,16 @@
+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/esm/internals/plugins/models/seriesConfig/seriesConfig.types.js

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

package/esm/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/esm/internals/plugins/models/seriesConfig/seriesProcessor.types.js

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

package/esm/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/esm/internals/plugins/models/seriesConfig/tooltipGetter.types.js

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

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

@@ -0,0 +1,13 @@
+import type { ChartState } from '../models/chart';
+import type { ChartAnyPluginSignature } from '../models/plugin';
+type Listener<T> = (value: T) => void;
+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<TSignatures>);
+  subscribe: (fn: Listener<ChartState<TSignatures>>) => () => void;
+  getSnapshot: () => ChartState<TSignatures>;
+  update: (updater: StoreUpdater<TSignatures>) => void;
+}
+export {};

package/esm/internals/plugins/utils/ChartStore.js

@@ -0,0 +1,24 @@
+export class ChartStore {
+  constructor(value) {
+    this.value = void 0;
+    this.listeners = void 0;
+    this.subscribe = fn => {
+      this.listeners.add(fn);
+      return () => {
+        this.listeners.delete(fn);
+      };
+    };
+    this.getSnapshot = () => {
+      return this.value;
+    };
+    this.update = updater => {
+      const newState = updater(this.value);
+      if (newState !== this.value) {
+        this.value = newState;
+        this.listeners.forEach(l => l(newState));
+      }
+    };
+    this.value = value;
+    this.listeners = new Set();
+  }
+}

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

@@ -0,0 +1,9 @@
+import { CreateSelectorFunction } from 'reselect';
+import { ChartAnyPluginSignature, ChartState } from "../models/index.js";
+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.
+ *
+ */
+export declare const createSelector: CreateSelectorFunction;

package/esm/internals/plugins/utils/selectors.js

@@ -0,0 +1,37 @@
+import { lruMemoize, createSelectorCreator } from 'reselect';
+const reselectCreateSelector = createSelectorCreator({
+  memoize: lruMemoize,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+const cache = new WeakMap();
+/**
+ * Method wrapping reselect's createSelector to provide caching for chart instances.
+ *
+ */
+export const createSelector = (...createSelectorArgs) => {
+  const selector = (state, selectorArgs) => {
+    const cacheKey = state.cacheKey;
+
+    // If there is no cache for the current chart instance, create one.
+    let cacheForCurrentChartInstance = cache.get(cacheKey);
+    if (!cacheForCurrentChartInstance) {
+      cacheForCurrentChartInstance = new Map();
+      cache.set(cacheKey, cacheForCurrentChartInstance);
+    }
+
+    // If there is a cached selector, execute it.
+    const cachedSelector = cacheForCurrentChartInstance.get(createSelectorArgs);
+    if (cachedSelector) {
+      return cachedSelector(state, selectorArgs);
+    }
+
+    // Otherwise, create a new selector and cache it and execute it.
+    const fn = reselectCreateSelector(...createSelectorArgs);
+    cacheForCurrentChartInstance.set(createSelectorArgs, fn);
+    return fn(state, selectorArgs);
+  };
+  return selector;
+};

package/esm/internals/stackSeries.d.ts

@@ -0,0 +1,27 @@
+import { Series } from '@mui/x-charts-vendor/d3-shape';
+import type { BarSeriesType, LineSeriesType } from '../models/seriesType';
+import type { StackOffsetType, StackOrderType } from '../models/stacking';
+import { SeriesId } from "../models/seriesType/common.js";
+type StackableSeries = Record<SeriesId, BarSeriesType> | Record<SeriesId, LineSeriesType>;
+type FormatterParams = {
+  series: StackableSeries;
+  seriesOrder: SeriesId[];
+  defaultStrategy?: {
+    stackOrder?: StackOrderType;
+    stackOffset?: StackOffsetType;
+  };
+};
+export type StackingGroupsType = {
+  ids: SeriesId[];
+  stackingOrder: (series: Series<any, any>) => number[];
+  stackingOffset: (series: Series<any, any>, order: Iterable<number>) => void;
+}[];
+export declare const StackOrder: { [key in StackOrderType]: (series: Series<any, any>) => number[] };
+export declare const StackOffset: { [key in StackOffsetType]: (series: Series<any, any>, order: Iterable<number>) => void };
+/**
+ * Takes a set of series and groups their ids
+ * @param series the object of all bars series
+ * @returns an array of groups, including the ids, the stacking order, and the stacking offset.
+ */
+export declare const getStackingGroups: (params: FormatterParams) => StackingGroupsType;
+export {};

package/esm/internals/stackSeries.js

@@ -0,0 +1,94 @@
+import { stackOrderAppearance as d3StackOrderAppearance, stackOrderAscending as d3StackOrderAscending, stackOrderDescending as d3StackOrderDescending, stackOrderInsideOut as d3StackOrderInsideOut, stackOrderNone as d3StackOrderNone, stackOrderReverse as d3StackOrderReverse, stackOffsetExpand as d3StackOffsetExpand, stackOffsetDiverging as d3StackOffsetDiverging, stackOffsetNone as d3StackOffsetNone, stackOffsetSilhouette as d3StackOffsetSilhouette, stackOffsetWiggle as d3StackOffsetWiggle } from '@mui/x-charts-vendor/d3-shape';
+export const StackOrder = {
+  /**
+   * Series order such that the earliest series (according to the maximum value) is at the bottom.
+   * */
+  appearance: d3StackOrderAppearance,
+  /**
+   *  Series order such that the smallest series (according to the sum of values) is at the bottom.
+   * */
+  ascending: d3StackOrderAscending,
+  /**
+   * Series order such that the largest series (according to the sum of values) is at the bottom.
+   */
+  descending: d3StackOrderDescending,
+  /**
+   * Series order such that the earliest series (according to the maximum value) are on the inside and the later series are on the outside. This order is recommended for streamgraphs in conjunction with the wiggle offset. See Stacked Graphs—Geometry & Aesthetics by Byron & Wattenberg for more information.
+   */
+  insideOut: d3StackOrderInsideOut,
+  /**
+   * Given series order [0, 1, … n - 1] where n is the number of elements in series. Thus, the stack order is given by the key accessor.
+   */
+  none: d3StackOrderNone,
+  /**
+   * Reverse of the given series order [n - 1, n - 2, … 0] where n is the number of elements in series. Thus, the stack order is given by the reverse of the key accessor.
+   */
+  reverse: d3StackOrderReverse
+};
+export const StackOffset = {
+  /**
+   * Applies a zero baseline and normalizes the values for each point such that the topline is always one.
+   * */
+  expand: d3StackOffsetExpand,
+  /**
+   * Positive values are stacked above zero, negative values are stacked below zero, and zero values are stacked at zero.
+   * */
+  diverging: d3StackOffsetDiverging,
+  /**
+   * Applies a zero baseline.
+   * */
+  none: d3StackOffsetNone,
+  /**
+   * Shifts the baseline down such that the center of the streamgraph is always at zero.
+   * */
+  silhouette: d3StackOffsetSilhouette,
+  /**
+   * Shifts the baseline so as to minimize the weighted wiggle of layers. This offset is recommended for streamgraphs in conjunction with the inside-out order. See Stacked Graphs—Geometry & Aesthetics by Bryon & Wattenberg for more information.
+   * */
+  wiggle: d3StackOffsetWiggle
+};
+
+/**
+ * Takes a set of series and groups their ids
+ * @param series the object of all bars series
+ * @returns an array of groups, including the ids, the stacking order, and the stacking offset.
+ */
+export const getStackingGroups = params => {
+  const {
+    series,
+    seriesOrder,
+    defaultStrategy
+  } = params;
+  const stackingGroups = [];
+  const stackIndex = {};
+  seriesOrder.forEach(id => {
+    const {
+      stack,
+      stackOrder,
+      stackOffset
+    } = series[id];
+    if (stack === undefined) {
+      stackingGroups.push({
+        ids: [id],
+        stackingOrder: StackOrder.none,
+        stackingOffset: StackOffset.none
+      });
+    } else if (stackIndex[stack] === undefined) {
+      stackIndex[stack] = stackingGroups.length;
+      stackingGroups.push({
+        ids: [id],
+        stackingOrder: StackOrder[stackOrder ?? defaultStrategy?.stackOrder ?? 'none'],
+        stackingOffset: StackOffset[stackOffset ?? defaultStrategy?.stackOffset ?? 'diverging']
+      });
+    } else {
+      stackingGroups[stackIndex[stack]].ids.push(id);
+      if (stackOrder !== undefined) {
+        stackingGroups[stackIndex[stack]].stackingOrder = StackOrder[stackOrder];
+      }
+      if (stackOffset !== undefined) {
+        stackingGroups[stackIndex[stack]].stackingOffset = StackOffset[stackOffset];
+      }
+    }
+  });
+  return stackingGroups;
+};

package/esm/internals/store/extractPluginParamsFromProps.d.ts

@@ -0,0 +1,13 @@
+import { ChartCorePluginSignatures } from "../plugins/corePlugins/index.js";
+import { ChartPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from "../plugins/models/index.js";
+import { UseChartBaseProps } from "./useCharts.types.js";
+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/esm/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/esm/internals/store/useChartModels.d.ts

@@ -0,0 +1,7 @@
+import { ChartAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from "../plugins/models/index.js";
+import { ChartCorePluginSignatures } from "../plugins/corePlugins/index.js";
+/**
+ * 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/esm/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;
+};

package/esm/internals/store/useCharts.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { ChartStore } from "../plugins/utils/ChartStore.js";
+import { ChartAnyPluginSignature, ChartInstance, ChartPublicAPI, ConvertSignaturesIntoPlugins } from "../plugins/models/index.js";
+import { UseChartBaseProps } from "./useCharts.types.js";
+import { UseChartInteractionState } from "../plugins/featurePlugins/useChartInteraction/useChartInteraction.types.js";
+import { ChartSeriesType } from "../../models/seriesType/config.js";
+import { ChartSeriesConfig } from "../plugins/models/seriesConfig/index.js";
+/**
+ * This is the main hook that setups the plugin system for the chart.
+ *
+ * It manages the data used to create the charts.
+ *
+ * @param inPlugins All the plugins that will be used in the chart.
+ * @param props The props passed to the chart.
+ * @param seriesConfig The set of helpers used for series-specific computation.
+ */
+export declare function useCharts<TSeriesType extends ChartSeriesType, TSignatures extends readonly ChartAnyPluginSignature[]>(inPlugins: ConvertSignaturesIntoPlugins<TSignatures>, props: Partial<UseChartBaseProps<TSignatures>>, seriesConfig: ChartSeriesConfig<TSeriesType>): {
+  contextValue: {
+    store: ChartStore<readonly [import("..").UseChartIdSignature, import("..").UseChartDimensionsSignature, import("..").UseChartSeriesSignature, ...TSignatures]> & UseChartInteractionState;
+    publicAPI: ChartPublicAPI<TSignatures>;
+    instance: ChartInstance<TSignatures>;
+    svgRef: React.RefObject<SVGSVGElement | null>;
+  };
+};
+export declare function useChartApiInitialization<T>(inputApiRef: React.RefObject<T | undefined> | undefined): T;