@mui/x-charts 9.0.0-alpha.0 → 9.0.0-alpha.2

package/hooks/useSeries.mjs

@@ -0,0 +1,14 @@
+'use client';
+
+import { useStore } from "../internals/store/useStore.mjs";
+import { selectorChartSeriesProcessed } from "../internals/plugins/corePlugins/useChartSeries/useChartSeries.selectors.mjs";
+/**
+ * Get access to the internal state of series.
+ * Structured by type of series:
+ * { seriesType?: { series: { id1: precessedValue, ... }, seriesOrder: [id1, ...] } }
+ * @returns FormattedSeries series
+ */
+export function useSeries() {
+  const store = useStore();
+  return store.use(selectorChartSeriesProcessed);
+}

package/hooks/useSkipAnimation.mjs

@@ -0,0 +1,15 @@
+'use client';
+
+import { selectorChartSkipAnimation } from "../internals/plugins/corePlugins/useChartAnimation/index.mjs";
+import { useStore } from "../internals/store/useStore.mjs";
+
+/**
+ * A hook to get if chart animations should be skipped.
+ *
+ * @returns {boolean} whether to skip animations
+ */
+export function useSkipAnimation(skipAnimation) {
+  const store = useStore();
+  const storeSkipAnimation = store.use(selectorChartSkipAnimation);
+  return skipAnimation || storeSkipAnimation;
+}

package/hooks/useTicks.d.mts

@@ -0,0 +1,91 @@
+import type { AxisConfig, D3Scale } from "../models/axis.mjs";
+import type { OrdinalTimeTicks } from "../models/timeTicks.mjs";
+export interface TickParams {
+  /**
+   * Maximal step between two ticks.
+   * When using time data, the value is assumed to be in ms.
+   * Not supported by categorical axis (band, points).
+   */
+  tickMaxStep?: number;
+  /**
+   * Minimal step between two ticks.
+   * When using time data, the value is assumed to be in ms.
+   * Not supported by categorical axis (band, points).
+   */
+  tickMinStep?: number;
+  /**
+   * The number of ticks. This number is not guaranteed.
+   * Not supported by categorical axis (band, points).
+   */
+  tickNumber?: number;
+  /**
+   * Defines which ticks are displayed.
+   * Its value can be:
+   * - 'auto' In such case the ticks are computed based on axis scale and other parameters.
+   * - a filtering function of the form `(value, index) => boolean` which is available only if the axis has "point" scale.
+   * - an array containing the values where ticks should be displayed.
+   * @see See {@link https://mui.com/x/react-charts/axis/#fixed-tick-positions}
+   * @default 'auto'
+   */
+  tickInterval?: 'auto' | ((value: any, index: number) => boolean) | any[];
+  /**
+   * The placement of ticks in regard to the band interval.
+   * Only used if scale is 'band'.
+   * @default 'extremities'
+   */
+  tickPlacement?: 'start' | 'end' | 'middle' | 'extremities';
+  /**
+   * The placement of ticks label. Can be the middle of the band, or the tick position.
+   * Only used if scale is 'band'.
+   * @default 'middle'
+   */
+  tickLabelPlacement?: 'middle' | 'tick';
+  /**
+   * The minimum space between ticks when using an ordinal scale. It defines the minimum distance in pixels between two ticks.
+   * @default 0
+   */
+  tickSpacing?: number;
+}
+export type TickItem = {
+  /**
+   * The value of the tick.
+   * It is only `undefined` if it's the tick closing the last band.
+   */
+  value?: any;
+  /**
+   * The formatted value of the tick.
+   * It is only `undefined` if it's the tick closing the last band.
+   */
+  formattedValue?: string;
+  /**
+   * The offset in pixels relative to the SVG origin.
+   * For an x-axis, it is relative to the left side of the SVG.
+   * For a y-axis, it is relative to the top side of the SVG.
+   */
+  offset: number;
+  /**
+   * The offset in pixels relative to the tick position.
+   * For an x-axis, a positive value means the label is shifted to the right of the tick.
+   * For a y-axis, a positive value means the label is shifted downwards from the tick.
+   */
+  labelOffset: number;
+};
+/**
+ * Returns a new domain where each tick is at least {@link tickSpacing}px from the next one.
+ * Assumes tick spacing is greater than 0.
+ * @param domain Domain of the scale.
+ * @param range Range of the scale.
+ * @param tickSpacing Spacing in pixels.
+ */
+export declare function applyTickSpacing<T>(domain: T[], range: [number, number], tickSpacing: number): T[];
+interface GetTicksOptions extends Pick<TickParams, 'tickInterval' | 'tickPlacement' | 'tickLabelPlacement' | 'tickSpacing'>, Required<Pick<TickParams, 'tickNumber'>> {
+  scale: D3Scale;
+  valueFormatter?: AxisConfig['valueFormatter'];
+  isInside: (offset: number) => boolean;
+  ordinalTimeTicks?: OrdinalTimeTicks;
+}
+export declare function getTicks(options: GetTicksOptions): TickItem[];
+export declare function useTicks(options: Omit<GetTicksOptions, 'isInside'> & {
+  direction: 'x' | 'y';
+}): TickItem[];
+export {};

package/hooks/useTicks.mjs

@@ -0,0 +1,260 @@
+'use client';
+
+import * as React from 'react';
+import { isOrdinalScale } from "../internals/scaleGuards.mjs";
+import { isInfinity } from "../internals/isInfinity.mjs";
+import { tickFrequencies } from "../utils/timeTicks.mjs";
+import { isDateData } from "../internals/dateHelpers.mjs";
+import { useChartContext } from "../context/ChartProvider/useChartContext.mjs";
+const offsetRatio = {
+  start: 0,
+  extremities: 0,
+  end: 1,
+  middle: 0.5
+};
+function getTickPosition(scale, value, placement) {
+  return scale(value) - (scale.step() - scale.bandwidth()) / 2 + offsetRatio[placement] * scale.step();
+}
+
+/**
+ * Returns a new domain where each tick is at least {@link tickSpacing}px from the next one.
+ * Assumes tick spacing is greater than 0.
+ * @param domain Domain of the scale.
+ * @param range Range of the scale.
+ * @param tickSpacing Spacing in pixels.
+ */
+export function applyTickSpacing(domain, range, tickSpacing) {
+  const rangeSpan = Math.abs(range[1] - range[0]);
+  const every = Math.ceil(domain.length / (rangeSpan / tickSpacing));
+  if (Number.isNaN(every) || every <= 1) {
+    return domain;
+  }
+  return domain.filter((_, index) => index % every === 0);
+}
+function getTimeTicks(domain, tickNumber, ticksFrequencies, scale, isInside) {
+  if (ticksFrequencies.length === 0) {
+    return [];
+  }
+  const isReversed = scale.range()[0] > scale.range()[1];
+  // Indexes are inclusive regarding the entire band.
+  const startIndex = domain.findIndex(value => {
+    return isInside(getTickPosition(scale, value, isReversed ? 'start' : 'end'));
+  });
+  const endIndex = domain.findLastIndex(value => isInside(getTickPosition(scale, value, isReversed ? 'end' : 'start')));
+  const start = domain[0];
+  const end = domain[domain.length - 1];
+  if (!(start instanceof Date) || !(end instanceof Date)) {
+    return [];
+  }
+  let startFrequencyIndex = 0;
+  for (let i = 0; i < ticksFrequencies.length; i += 1) {
+    if (ticksFrequencies[i].getTickNumber(start, end) !== 0) {
+      startFrequencyIndex = i;
+      break;
+    }
+  }
+  let endFrequencyIndex = startFrequencyIndex;
+  for (let i = startFrequencyIndex; i < ticksFrequencies.length; i += 1) {
+    if (i === ticksFrequencies.length - 1) {
+      // If we reached the end, use the last tick frequency
+      endFrequencyIndex = i;
+      break;
+    }
+    const prevTickCount = ticksFrequencies[i].getTickNumber(start, end);
+    const nextTickCount = ticksFrequencies[i + 1].getTickNumber(start, end);
+
+    // Smooth ratio between ticks steps: ticksNumber[i]*ticksNumber[i+1] <= targetTickNumber^2
+    if (nextTickCount > tickNumber || tickNumber / prevTickCount < nextTickCount / tickNumber) {
+      endFrequencyIndex = i;
+      break;
+    }
+  }
+  const ticks = [];
+  for (let tickIndex = Math.max(1, startIndex); tickIndex <= endIndex; tickIndex += 1) {
+    for (let i = startFrequencyIndex; i <= endFrequencyIndex; i += 1) {
+      const prevDate = domain[tickIndex - 1];
+      const currentDate = domain[tickIndex];
+      if (prevDate instanceof Date && currentDate instanceof Date && ticksFrequencies[i].isTick(prevDate, currentDate)) {
+        ticks.push({
+          index: tickIndex,
+          formatter: ticksFrequencies[i].format
+        });
+
+        // once we found a matching tick space, we can break the inner loop
+        break;
+      }
+    }
+  }
+  return ticks;
+}
+export function getTicks(options) {
+  const {
+    scale,
+    tickNumber,
+    valueFormatter,
+    tickInterval,
+    tickPlacement: tickPlacementProp,
+    tickLabelPlacement: tickLabelPlacementProp,
+    tickSpacing,
+    isInside,
+    ordinalTimeTicks
+  } = options;
+  if (ordinalTimeTicks !== undefined && isDateData(scale.domain()) && isOrdinalScale(scale)) {
+    // ordinal scale with spaced ticks.
+    const domain = scale.domain();
+    if (domain.length === 0 || domain.length === 1) {
+      return [];
+    }
+    const tickPlacement = 'middle';
+    const ticksIndexes = getTimeTicks(domain, tickNumber, ordinalTimeTicks.map(tickDef => typeof tickDef === 'string' ? tickFrequencies[tickDef] : tickDef), scale, isInside);
+    return ticksIndexes.map(({
+      index,
+      formatter
+    }) => {
+      const value = domain[index];
+      const formattedValue = formatter(value);
+      return {
+        value,
+        formattedValue,
+        offset: getTickPosition(scale, value, tickPlacement),
+        labelOffset: 0
+      };
+    });
+  }
+  const tickPlacement = tickPlacementProp ?? 'extremities';
+
+  // Standard ordinal scale: 1 item =1 tick
+  if (isOrdinalScale(scale)) {
+    const domain = scale.domain();
+    const tickLabelPlacement = tickLabelPlacementProp ?? 'middle';
+    let filteredDomain = domain;
+    if (typeof tickInterval === 'object' && tickInterval != null) {
+      filteredDomain = tickInterval;
+    } else {
+      if (typeof tickInterval === 'function') {
+        filteredDomain = filteredDomain.filter(tickInterval);
+      }
+      if (tickSpacing !== undefined && tickSpacing > 0) {
+        filteredDomain = applyTickSpacing(filteredDomain, scale.range(), tickSpacing);
+      }
+    }
+    if (filteredDomain.length === 0) {
+      return [];
+    }
+    if (scale.bandwidth() > 0) {
+      // scale type = 'band'
+
+      const isReversed = scale.range()[0] > scale.range()[1];
+      // Indexes are inclusive regarding the entire band.
+      const startIndex = filteredDomain.findIndex(value => {
+        return isInside(getTickPosition(scale, value, isReversed ? 'start' : 'end'));
+      });
+      const endIndex = filteredDomain.findLastIndex(value => isInside(getTickPosition(scale, value, isReversed ? 'end' : 'start')));
+      return [...filteredDomain.slice(startIndex, endIndex + 1).map(value => {
+        const defaultTickLabel = `${value}`;
+        return {
+          value,
+          formattedValue: valueFormatter?.(value, {
+            location: 'tick',
+            scale,
+            tickNumber,
+            defaultTickLabel
+          }) ?? defaultTickLabel,
+          offset: getTickPosition(scale, value, tickPlacement),
+          labelOffset: tickLabelPlacement === 'tick' ? 0 : scale.step() * (offsetRatio[tickLabelPlacement] - offsetRatio[tickPlacement])
+        };
+      }), ...(tickPlacement === 'extremities' && endIndex === domain.length - 1 && isInside(scale.range()[1]) ? [{
+        formattedValue: undefined,
+        offset: scale.range()[1],
+        labelOffset: 0
+      }] : [])];
+    }
+
+    // scale type = 'point'
+    return filteredDomain.map(value => {
+      const defaultTickLabel = `${value}`;
+      return {
+        value,
+        formattedValue: valueFormatter?.(value, {
+          location: 'tick',
+          scale,
+          tickNumber,
+          defaultTickLabel
+        }) ?? defaultTickLabel,
+        offset: scale(value),
+        labelOffset: 0
+      };
+    });
+  }
+  const domain = scale.domain();
+  // Skip axis rendering if no data is available
+  // - The domains contains Infinity for continuous scales.
+  if (domain.some(isInfinity)) {
+    return [];
+  }
+  const tickLabelPlacement = tickLabelPlacementProp;
+  const ticks = typeof tickInterval === 'object' ? tickInterval : getDefaultTicks(scale, tickNumber);
+
+  // Ticks inside the drawing area
+  const visibleTicks = [];
+  for (let i = 0; i < ticks.length; i += 1) {
+    const value = ticks[i];
+    const offset = scale(value);
+    if (isInside(offset)) {
+      /* If d3 returns an empty string, it means that a tick should be shown, but its label shouldn't.
+       * This is especially useful in a log scale where we want to show ticks to demonstrate it's a log
+       * scale, but don't want to show labels because they would overlap.
+       * https://github.com/mui/mui-x/issues/18239 */
+      const defaultTickLabel = scale.tickFormat(tickNumber)(value);
+      visibleTicks.push({
+        value,
+        formattedValue: valueFormatter?.(value, {
+          location: 'tick',
+          scale,
+          tickNumber,
+          defaultTickLabel
+        }) ?? defaultTickLabel,
+        offset,
+        // Allowing the label to be placed in the middle of a continuous scale is weird.
+        // But it is useful in some cases, like funnel categories with a linear scale.
+        labelOffset: tickLabelPlacement === 'middle' ? scale(ticks[i - 1] ?? 0) - (offset + scale(ticks[i - 1] ?? 0)) / 2 : 0
+      });
+    }
+  }
+  return visibleTicks;
+}
+function getDefaultTicks(scale, tickNumber) {
+  const domain = scale.domain();
+  if (domain[0] === domain[1]) {
+    return [domain[0]];
+  }
+  return scale.ticks(tickNumber);
+}
+export function useTicks(options) {
+  const {
+    scale,
+    tickNumber,
+    valueFormatter,
+    tickInterval,
+    tickPlacement = 'extremities',
+    tickLabelPlacement,
+    tickSpacing,
+    direction,
+    ordinalTimeTicks
+  } = options;
+  const {
+    instance
+  } = useChartContext();
+  const isInside = direction === 'x' ? instance.isXInside : instance.isYInside;
+  return React.useMemo(() => getTicks({
+    scale,
+    tickNumber,
+    tickPlacement,
+    tickInterval,
+    tickLabelPlacement,
+    tickSpacing,
+    valueFormatter,
+    isInside,
+    ordinalTimeTicks
+  }), [scale, tickNumber, tickPlacement, tickInterval, tickLabelPlacement, tickSpacing, valueFormatter, isInside, ordinalTimeTicks]);
+}

package/hooks/useTicksGrouped.d.mts

@@ -0,0 +1,28 @@
+import type { ScaleBand, ScalePoint } from '@mui/x-charts-vendor/d3-scale';
+import { type AxisConfig, type AxisGroup } from "../models/axis.mjs";
+import type { TickParams } from "./useTicks.mjs";
+export type GroupedTickItemType = {
+  /**
+   * This property is undefined only if it's the tick closing the last band
+   */
+  value?: any;
+  formattedValue?: string;
+  offset: number;
+  labelOffset: number;
+  /**
+   * In band scales, we remove some redundant ticks.
+   */
+  ignoreTick?: boolean;
+  dataIndex?: number;
+  /**
+   * The index of the group this tick belongs to. If `getGrouping` returns `[[0, 1], [2, 3]]`
+   * both ticks with value `0` and `2` will have `groupIndex: 0`, and both ticks with value `1` and `3` will have `groupIndex: 1`.
+   */
+  groupIndex?: number;
+};
+export declare function useTicksGrouped(options: {
+  scale: ScaleBand<any> | ScalePoint<any>;
+  valueFormatter?: AxisConfig['valueFormatter'];
+  direction: 'x' | 'y';
+  groups: AxisGroup[];
+} & Pick<TickParams, 'tickNumber' | 'tickInterval' | 'tickPlacement' | 'tickLabelPlacement'>): GroupedTickItemType[];

package/hooks/useTicksGrouped.mjs

@@ -0,0 +1,98 @@
+'use client';
+
+import * as React from 'react';
+import { isOrdinalScale } from "../internals/scaleGuards.mjs";
+const offsetRatio = {
+  start: 0,
+  extremities: 0,
+  end: 1,
+  middle: 0.5,
+  tick: 0
+};
+export function useTicksGrouped(options) {
+  const {
+    scale,
+    tickInterval,
+    tickLabelPlacement = 'middle',
+    tickPlacement = 'extremities',
+    groups
+  } = options;
+  return React.useMemo(() => {
+    const domain = scale.domain();
+    const filteredDomain = typeof tickInterval === 'function' && domain.filter(tickInterval) || typeof tickInterval === 'object' && tickInterval || domain;
+    if (scale.bandwidth() > 0) {
+      // scale type = 'band'
+      const entries = mapToGrouping(filteredDomain, groups, tickPlacement, tickLabelPlacement, scale);
+      if (entries[0]) {
+        entries[0].ignoreTick = true;
+      }
+      return [{
+        formattedValue: undefined,
+        offset: scale.range()[0],
+        labelOffset: 0,
+        groupIndex: groups.length - 1
+      }, ...entries,
+      // Last tick
+      {
+        formattedValue: undefined,
+        offset: scale.range()[1],
+        labelOffset: 0,
+        groupIndex: groups.length - 1
+      }];
+    }
+
+    // scale type = 'point'
+    return mapToGrouping(filteredDomain, groups, tickPlacement, tickLabelPlacement, scale);
+  }, [scale, tickInterval, groups, tickPlacement, tickLabelPlacement]);
+}
+function mapToGrouping(tickValues, groups, tickPlacement, tickLabelPlacement, scale) {
+  const allTickItems = [];
+  // Map to keep track of offsets and their corresponding tick indexes
+  // Used to remove redundant ticks when they are in the same position
+  const dataIndexToTickIndex = new Map();
+  let currentValueCount = 0;
+  for (let groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
+    for (let dataIndex = 0; dataIndex < tickValues.length; dataIndex += 1) {
+      const tickValue = tickValues[dataIndex];
+      const groupValue = groups[groupIndex].getValue(tickValue, dataIndex);
+      const lastItem = allTickItems[allTickItems.length - 1];
+
+      // Check if this is a new unique value for this group
+      const isNew = lastItem?.value !== groupValue || lastItem?.groupIndex !== groupIndex;
+      if (isNew) {
+        currentValueCount = 1;
+        // Calculate tick offset
+        const tickOffset = isOrdinalScale(scale) ? scale(tickValue) - (scale.step() - scale.bandwidth()) / 2 + offsetRatio[tickPlacement] * scale.step() : scale(tickValue);
+
+        // Calculate the label offset
+        const labelOffset = scale.step() * currentValueCount * (offsetRatio[tickLabelPlacement] - offsetRatio[tickPlacement]);
+
+        // Add a new item
+        allTickItems.push({
+          value: groupValue,
+          formattedValue: `${groupValue}`,
+          offset: tickOffset,
+          groupIndex,
+          dataIndex,
+          ignoreTick: false,
+          labelOffset
+        });
+        if (!dataIndexToTickIndex.has(dataIndex)) {
+          dataIndexToTickIndex.set(dataIndex, new Set());
+        }
+        const tickIndexes = dataIndexToTickIndex.get(dataIndex);
+        for (const previousIndex of tickIndexes.values()) {
+          allTickItems[previousIndex].ignoreTick = true;
+        }
+        tickIndexes.add(allTickItems.length - 1);
+      } else {
+        currentValueCount += 1;
+
+        // Calculate the label offset
+        const labelOffset = scale.step() * currentValueCount * (offsetRatio[tickLabelPlacement] - offsetRatio[tickPlacement]);
+        lastItem.labelOffset = labelOffset;
+      }
+    }
+  }
+  return allTickItems;
+}

package/hooks/useZAxis.d.mts

@@ -0,0 +1,7 @@
+export declare function useZAxes(): {
+  zAxis: {
+    [axisId: string]: import("../internals/index.mjs").ZAxisDefaultized;
+  };
+  zAxisIds: import("../internals/index.mjs").AxisId[];
+};
+export declare function useZAxis(identifier?: number | string): import("../internals/index.mjs").ZAxisDefaultized;

package/hooks/useZAxis.mjs

@@ -0,0 +1,26 @@
+'use client';
+
+import { useStore } from "../internals/store/useStore.mjs";
+import { selectorChartZAxis } from "../internals/plugins/featurePlugins/useChartZAxis/index.mjs";
+export function useZAxes() {
+  const store = useStore();
+  const {
+    axis: zAxis,
+    axisIds: zAxisIds
+  } = store.use(selectorChartZAxis) ?? {
+    axis: {},
+    axisIds: []
+  };
+  return {
+    zAxis,
+    zAxisIds
+  };
+}
+export function useZAxis(identifier) {
+  const {
+    zAxis,
+    zAxisIds
+  } = useZAxes();
+  const id = typeof identifier === 'string' ? identifier : zAxisIds[identifier ?? 0];
+  return zAxis[id];
+}

package/index.d.mts

@@ -0,0 +1,38 @@
+export * from "./constants/index.mjs";
+export * from "./context/index.mjs";
+export * from "./hooks/index.mjs";
+export * from "./plugins/index.mjs";
+export * from "./colorPalettes/index.mjs";
+export * from "./models/index.mjs";
+export * from "./ChartsClipPath/index.mjs";
+export * from "./ChartsReferenceLine/index.mjs";
+export * from "./ChartsAxis/index.mjs";
+export * from "./ChartsXAxis/index.mjs";
+export * from "./ChartsYAxis/index.mjs";
+export * from "./ChartsGrid/index.mjs";
+export * from "./ChartsText/index.mjs";
+export * from "./ChartsTooltip/index.mjs";
+export * from "./ChartsLabel/index.mjs";
+export * from "./ChartsLegend/index.mjs";
+export * from "./ChartsLocalizationProvider/index.mjs";
+export * from "./ChartsAxisHighlight/index.mjs";
+export * from "./BarChart/index.mjs";
+export * from "./LineChart/index.mjs";
+export * from "./PieChart/index.mjs";
+export * from "./ScatterChart/index.mjs";
+export * from "./SparkLineChart/index.mjs";
+export * from "./Gauge/index.mjs";
+export * from "./RadarChart/index.mjs";
+export * from "./ChartsSurface/index.mjs";
+export { ChartsContainer } from "./ChartsContainer/index.mjs";
+export type { ChartsContainerProps, ChartsContainerSlots, ChartsContainerSlotProps } from "./ChartsContainer/index.mjs";
+export { ChartContainer } from "./ChartContainer/index.mjs";
+export type { ChartContainerProps, ChartContainerSlots, ChartContainerSlotProps } from "./ChartContainer/index.mjs";
+export * from "./ChartsDataProvider/index.mjs";
+export * from "./ChartDataProvider/index.mjs";
+export * from "./Toolbar/index.mjs";
+export * from "./ChartsWrapper/index.mjs";
+export * from "./ChartsBrushOverlay/index.mjs";
+export * from "./utils/index.mjs";
+export * from "./ChartsLayerContainer/index.mjs";
+export * from "./ChartsSvgLayer/index.mjs";

package/index.d.ts

@@ -28,8 +28,11 @@ export { ChartsContainer } from "./ChartsContainer/index.js";
 export type { ChartsContainerProps, ChartsContainerSlots, ChartsContainerSlotProps } from "./ChartsContainer/index.js";
 export { ChartContainer } from "./ChartContainer/index.js";
 export type { ChartContainerProps, ChartContainerSlots, ChartContainerSlotProps } from "./ChartContainer/index.js";
+export * from "./ChartsDataProvider/index.js";
 export * from "./ChartDataProvider/index.js";
 export * from "./Toolbar/index.js";
 export * from "./ChartsWrapper/index.js";
 export * from "./ChartsBrushOverlay/index.js";
-export * from "./utils/index.js";
+export * from "./utils/index.js";
+export * from "./ChartsLayerContainer/index.js";
+export * from "./ChartsSvgLayer/index.js";

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts v9.0.0-alpha.0
+ * @mui/x-charts v9.0.0-alpha.2
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
@@ -340,6 +340,18 @@ Object.keys(_ChartsSurface).forEach(function (key) {
 });
 var _ChartsContainer = require("./ChartsContainer");
 var _ChartContainer = require("./ChartContainer");
+var _ChartsDataProvider = require("./ChartsDataProvider");
+Object.keys(_ChartsDataProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ChartsDataProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ChartsDataProvider[key];
+    }
+  });
+});
 var _ChartDataProvider = require("./ChartDataProvider");
 Object.keys(_ChartDataProvider).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -399,4 +411,28 @@ Object.keys(_utils).forEach(function (key) {
       return _utils[key];
     }
   });
+});
+var _ChartsLayerContainer = require("./ChartsLayerContainer");
+Object.keys(_ChartsLayerContainer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ChartsLayerContainer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ChartsLayerContainer[key];
+    }
+  });
+});
+var _ChartsSvgLayer = require("./ChartsSvgLayer");
+Object.keys(_ChartsSvgLayer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ChartsSvgLayer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ChartsSvgLayer[key];
+    }
+  });
 });