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

package/context/{DrawingProvider.js → DrawingAreaProvider/DrawingAreaProvider.js}

@@ -3,42 +3,19 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import useId from '@mui/utils/useId';
-import useChartDimensions from "../hooks/useChartDimensions.js";
-
-/**
- * Defines the area in which it is possible to draw the charts.
- */
+import useChartDimensions from "../../hooks/useChartDimensions.js";
+import { DrawingAreaContext } from "./DrawingAreaContext.js";
+import { useSize } from "../SizeProvider/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-export const DrawingContext = /*#__PURE__*/React.createContext({
-  top: 0,
-  left: 0,
-  bottom: 0,
-  right: 0,
-  height: 300,
-  width: 400,
-  chartId: '',
-  isPointInside: () => false
-});
-if (process.env.NODE_ENV !== 'production') {
-  DrawingContext.displayName = 'DrawingContext';
-}
-export const SvgContext = /*#__PURE__*/React.createContext({
-  isInitialized: false,
-  data: {
-    current: null
-  }
-});
-if (process.env.NODE_ENV !== 'production') {
-  SvgContext.displayName = 'SvgContext';
-}
-export function DrawingProvider(props) {
+export function DrawingAreaProvider(props) {
   const {
-    width,
-    height,
     margin,
-    svgRef,
     children
   } = props;
+  const {
+    width,
+    height
+  } = useSize();
   const drawingArea = useChartDimensions(width, height, margin);
   const chartId = useId();
   const isPointInside = React.useCallback(({
@@ -64,15 +41,8 @@ export function DrawingProvider(props) {
   }, drawingArea, {
     isPointInside
   }), [chartId, drawingArea, isPointInside]);
-  const refValue = React.useMemo(() => ({
-    isInitialized: true,
-    data: svgRef
-  }), [svgRef]);
-  return /*#__PURE__*/_jsx(SvgContext.Provider, {
-    value: refValue,
-    children: /*#__PURE__*/_jsx(DrawingContext.Provider, {
-      value: value,
-      children: children
-    })
+  return /*#__PURE__*/_jsx(DrawingAreaContext.Provider, {
+    value: value,
+    children: children
   });
 }

package/context/DrawingAreaProvider/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DrawingArea.types';
+export * from './DrawingAreaProvider';
+export * from './DrawingAreaContext';

package/context/DrawingAreaProvider/index.js

@@ -0,0 +1,3 @@
+export * from "./DrawingArea.types.js";
+export * from "./DrawingAreaProvider.js";
+export * from "./DrawingAreaContext.js";

package/context/InteractionProvider.d.ts

@@ -1,50 +1,7 @@
 import * as React from 'react';
-import { ChartItemIdentifier, ChartSeriesType } from '../models/seriesType/config';
-export interface InteractionProviderProps {
-    children: React.ReactNode;
-}
-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 InteractionActions<T extends ChartSeriesType = ChartSeriesType> = {
-    type: 'enterItem';
-    data: ItemInteractionData<T>;
-} | {
-    type: 'leaveItem';
-    data: Partial<ItemInteractionData<T>>;
-} | {
-    type: 'exitChart';
-} | {
-    type: 'updateVoronoiUsage';
-    useVoronoiInteraction: boolean;
-} | {
-    type: 'updateAxis';
-    data: AxisInteractionData;
-};
-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.
-     */
-    useVoronoiInteraction: boolean;
-    dispatch: React.Dispatch<InteractionActions>;
-};
-export declare const InteractionContext: React.Context<InteractionState>;
-declare function InteractionProvider(props: InteractionProviderProps): React.JSX.Element;
+import { ChartStore } from '../internals/plugins/utils/ChartStore';
+export declare const ChartsContext: React.Context<{
+    store: ChartStore;
+} | null>;
+declare function InteractionProvider(props: React.PropsWithChildren): React.JSX.Element;
 export { InteractionProvider };

package/context/InteractionProvider.js

@@ -1,77 +1,21 @@
 'use client';
 
-import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
+import { useCharts } from "../internals/useCharts.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-export const InteractionContext = /*#__PURE__*/React.createContext({
-  item: null,
-  axis: {
-    x: null,
-    y: null
-  },
-  useVoronoiInteraction: false,
-  dispatch: () => null
-});
+export const ChartsContext = /*#__PURE__*/React.createContext(null);
 if (process.env.NODE_ENV !== 'production') {
-  InteractionContext.displayName = 'InteractionContext';
+  ChartsContext.displayName = 'ChartsContext';
 }
-const dataReducer = (prevState, action) => {
-  switch (action.type) {
-    case 'enterItem':
-      return _extends({}, prevState, {
-        item: action.data
-      });
-    case 'exitChart':
-      if (prevState.item === null && prevState.axis.x === null && prevState.axis.y === null) {
-        return prevState;
-      }
-      return _extends({}, prevState, {
-        axis: {
-          x: null,
-          y: null
-        },
-        item: null
-      });
-    case 'updateVoronoiUsage':
-      return _extends({}, prevState, {
-        useVoronoiInteraction: action.useVoronoiInteraction
-      });
-    case 'leaveItem':
-      if (prevState.item === null || Object.keys(action.data).some(key => action.data[key] !== prevState.item[key])) {
-        // The item is already something else
-        return prevState;
-      }
-      return _extends({}, prevState, {
-        item: null
-      });
-    case 'updateAxis':
-      if (action.data.x === prevState.axis.x && action.data.y === prevState.axis.y) {
-        return prevState;
-      }
-      return _extends({}, prevState, {
-        axis: action.data
-      });
-    default:
-      return prevState;
-  }
-};
 function InteractionProvider(props) {
   const {
     children
   } = props;
-  const [data, dispatch] = React.useReducer(dataReducer, {
-    item: null,
-    axis: {
-      x: null,
-      y: null
-    },
-    useVoronoiInteraction: false
-  });
-  const value = React.useMemo(() => _extends({}, data, {
-    dispatch
-  }), [data]);
-  return /*#__PURE__*/_jsx(InteractionContext.Provider, {
-    value: value,
+  const {
+    contextValue
+  } = useCharts();
+  return /*#__PURE__*/_jsx(ChartsContext.Provider, {
+    value: contextValue,
     children: children
   });
 }

package/context/InteractionSelectors.d.ts

@@ -0,0 +1,359 @@
+import { ChartState } from '../internals/plugins/models';
+declare function selectInteraction(state: ChartState): {
+    item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+    axis: import("../internals/plugins/models").AxisInteractionData;
+    isVoronoiEnabled?: boolean;
+};
+export declare const selectorChartsInteractionItem: ((state: ChartState) => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null;
+    dependencies: [typeof selectInteraction];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionAxis: ((state: ChartState) => import("../internals/plugins/models").AxisInteractionData) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("../internals/plugins/models").AxisInteractionData;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => import("../internals/plugins/models").AxisInteractionData) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../internals/plugins/models").AxisInteractionData;
+    dependencies: [typeof selectInteraction];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionXAxis: ((state: ChartState) => {
+    value: number | Date | string;
+    index: number;
+} | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    dependencies: [typeof selectInteraction];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionYAxis: ((state: ChartState) => {
+    value: number | Date | string;
+    index: number;
+} | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        value: number | Date | string;
+        index: number;
+    } | null;
+    dependencies: [typeof selectInteraction];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionItemIsDefined: ((state: ChartState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: ChartState) => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+            axis: import("../internals/plugins/models").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+            axis: import("../internals/plugins/models").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("..").BarItemIdentifier | import("..").ScatterItemIdentifier | import("..").LineItemIdentifier | import("..").PieItemIdentifier | null;
+        dependencies: [typeof selectInteraction];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionXAxisIsDefined: ((state: ChartState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: ChartState) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+            axis: import("../internals/plugins/models").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+            axis: import("../internals/plugins/models").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        dependencies: [typeof selectInteraction];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionYAxisIsDefined: ((state: ChartState) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        value: number | Date | string;
+        index: number;
+    } | null) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: ChartState) => {
+        value: number | Date | string;
+        index: number;
+    } | null) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+            axis: import("../internals/plugins/models").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+            axis: import("../internals/plugins/models").AxisInteractionData;
+            isVoronoiEnabled?: boolean;
+        }) => {
+            value: number | Date | string;
+            index: number;
+        } | null) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => {
+            value: number | Date | string;
+            index: number;
+        } | null;
+        dependencies: [typeof selectInteraction];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectorChartsInteractionIsVoronoiEnabled: ((state: ChartState) => boolean | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => boolean | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        item: null | import("../internals/plugins/models").ItemInteractionData<import("../internals").ChartSeriesType>;
+        axis: import("../internals/plugins/models").AxisInteractionData;
+        isVoronoiEnabled?: boolean;
+    }) => boolean | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean | undefined;
+    dependencies: [typeof selectInteraction];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export {};

package/context/InteractionSelectors.js

@@ -0,0 +1,12 @@
+import { createSelector } from "../internals/plugins/utils/selectors.js";
+function selectInteraction(state) {
+  return state.interaction;
+}
+export const selectorChartsInteractionItem = createSelector(selectInteraction, interaction => interaction.item);
+export const selectorChartsInteractionAxis = createSelector(selectInteraction, interaction => interaction.axis);
+export const selectorChartsInteractionXAxis = createSelector(selectInteraction, interaction => interaction.axis.x);
+export const selectorChartsInteractionYAxis = createSelector(selectInteraction, interaction => interaction.axis.y);
+export const selectorChartsInteractionItemIsDefined = createSelector(selectorChartsInteractionItem, item => item !== null);
+export const selectorChartsInteractionXAxisIsDefined = createSelector(selectorChartsInteractionXAxis, x => x !== null);
+export const selectorChartsInteractionYAxisIsDefined = createSelector(selectorChartsInteractionYAxis, y => y !== null);
+export const selectorChartsInteractionIsVoronoiEnabled = createSelector(selectInteraction, interaction => interaction.isVoronoiEnabled);

package/context/SizeProvider/Size.types.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+export interface SizeProviderProps {
+    /**
+     * The width of the chart in px. If not defined, it takes the width of the parent element.
+     */
+    width?: number;
+    /**
+     * The height of the chart in px. If not defined, it takes the height of the parent element.
+     */
+    height?: number;
+    children: React.ReactNode;
+}
+export interface SizeContextState extends Required<Pick<SizeProviderProps, 'height' | 'width'>> {
+    /**
+     * The ref of the container element that the chart is rendered in.
+     */
+    containerRef: React.RefObject<HTMLDivElement>;
+    /**
+     * If the chart has a defined size.
+     */
+    hasIntrinsicSize: boolean;
+    /**
+     * The input height of the chart in px.
+     */
+    inHeight?: number;
+    /**
+     * The input width of the chart in px.
+     */
+    inWidth?: number;
+}

package/context/SizeProvider/Size.types.js

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

package/context/SizeProvider/SizeContext.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { Initializable } from '../context.types';
+import { SizeContextState } from './Size.types';
+export declare const SizeContext: React.Context<Initializable<SizeContextState>>;

package/context/SizeProvider/SizeContext.js

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export const SizeContext = /*#__PURE__*/React.createContext({
+  isInitialized: false,
+  data: {
+    hasIntrinsicSize: false,
+    containerRef: null,
+    height: 0,
+    width: 0
+  }
+});
+if (process.env.NODE_ENV !== 'production') {
+  SizeContext.displayName = 'SizeContext';
+}

package/context/SizeProvider/SizeProvider.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { SizeProviderProps } from './Size.types';
+/**
+ * The size provider.
+ *
+ * This differs from the DrawingProvider in that it provides the full size of the container.
+ *
+ * This provider is also responsible for resolving the size of the container before rendering and if the parent size changes.
+ */
+declare function SizeProvider(props: SizeProviderProps): React.JSX.Element;
+export { SizeProvider };