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

package/context/ZAxisContextProvider.js

@@ -1,96 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { getColorScale, getOrdinalColorScale } from "../internals/colorScale.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-export const ZAxisContext = /*#__PURE__*/React.createContext({
-  zAxis: {},
-  zAxisIds: []
-});
-if (process.env.NODE_ENV !== 'production') {
-  ZAxisContext.displayName = 'ZAxisContext';
-}
-function ZAxisContextProvider(props) {
-  const {
-    zAxis: inZAxis,
-    dataset,
-    children
-  } = props;
-  const zAxis = React.useMemo(() => inZAxis?.map(axisConfig => {
-    const dataKey = axisConfig.dataKey;
-    if (dataKey === undefined || axisConfig.data !== undefined) {
-      return axisConfig;
-    }
-    if (dataset === undefined) {
-      throw new Error('MUI X: z-axis uses `dataKey` but no `dataset` is provided.');
-    }
-    return _extends({}, axisConfig, {
-      data: dataset.map(d => d[dataKey])
-    });
-  }), [inZAxis, dataset]);
-  const value = React.useMemo(() => {
-    const allZAxis = zAxis?.map((axis, index) => _extends({
-      id: `defaultized-z-axis-${index}`
-    }, axis)) ?? [];
-    const completedZAxis = {};
-    allZAxis.forEach(axis => {
-      completedZAxis[axis.id] = _extends({}, axis, {
-        colorScale: axis.colorMap && (axis.colorMap.type === 'ordinal' && axis.data ? getOrdinalColorScale(_extends({
-          values: axis.data
-        }, axis.colorMap)) : getColorScale(axis.colorMap.type === 'continuous' ? _extends({
-          min: axis.min,
-          max: axis.max
-        }, axis.colorMap) : axis.colorMap))
-      });
-    });
-    return {
-      zAxis: completedZAxis,
-      zAxisIds: allZAxis.map(({
-        id
-      }) => id)
-    };
-  }, [zAxis]);
-  return /*#__PURE__*/_jsx(ZAxisContext.Provider, {
-    value: value,
-    children: children
-  });
-}
-process.env.NODE_ENV !== "production" ? ZAxisContextProvider.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  children: PropTypes.node,
-  /**
-   * An array of objects that can be used to populate series and axes data using their `dataKey` property.
-   */
-  dataset: PropTypes.arrayOf(PropTypes.object),
-  /**
-   * The configuration of the z-axes.
-   */
-  zAxis: PropTypes.arrayOf(PropTypes.shape({
-    colorMap: PropTypes.oneOfType([PropTypes.shape({
-      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
-      type: PropTypes.oneOf(['ordinal']).isRequired,
-      unknownColor: PropTypes.string,
-      values: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.string]).isRequired)
-    }), PropTypes.shape({
-      color: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string.isRequired), PropTypes.func]).isRequired,
-      max: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-      min: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-      type: PropTypes.oneOf(['continuous']).isRequired
-    }), PropTypes.shape({
-      colors: PropTypes.arrayOf(PropTypes.string).isRequired,
-      thresholds: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]).isRequired).isRequired,
-      type: PropTypes.oneOf(['piecewise']).isRequired
-    })]),
-    data: PropTypes.array,
-    dataKey: PropTypes.string,
-    id: PropTypes.string,
-    max: PropTypes.number,
-    min: PropTypes.number
-  }))
-} : void 0;
-export { ZAxisContextProvider };

package/internals/computeAxisValue.d.ts

@@ -1,38 +0,0 @@
-import { AxisConfig, ScaleName } from '../models';
-import { ChartsXAxisProps, ChartsAxisProps, ChartsYAxisProps, ChartsRadiusAxisProps, ChartsRotationAxisProps } from '../models/axis';
-import { CartesianChartSeriesType } from '../models/seriesType/config';
-import { DrawingAreaState } from '../context/DrawingAreaProvider';
-import { FormattedSeries } from '../context/SeriesProvider';
-import { ExtremumGetter } from '../context/PluginProvider';
-import { DefaultizedAxisConfig, ZoomData, ZoomOptions, GetZoomAxisFilters } from '../context/CartesianProvider/Cartesian.types';
-type ComputeResult<T extends ChartsAxisProps> = {
-    axis: DefaultizedAxisConfig<T>;
-    axisIds: string[];
-};
-type ComputeCommonParams = {
-    drawingArea: DrawingAreaState;
-    formattedSeries: FormattedSeries;
-    extremumGetters: {
-        [K in CartesianChartSeriesType]?: ExtremumGetter<K>;
-    };
-    zoomData?: ZoomData[];
-    zoomOptions?: ZoomOptions;
-    getFilters?: GetZoomAxisFilters;
-};
-export declare function computeAxisValue(options: ComputeCommonParams & {
-    axis: AxisConfig<ScaleName, any, ChartsYAxisProps>[];
-    axisDirection: 'y';
-}): ComputeResult<ChartsYAxisProps>;
-export declare function computeAxisValue(options: ComputeCommonParams & {
-    axis: AxisConfig<ScaleName, any, ChartsXAxisProps>[];
-    axisDirection: 'x';
-}): ComputeResult<ChartsAxisProps>;
-export declare function computeAxisValue(options: ComputeCommonParams & {
-    axis: AxisConfig<ScaleName, any, ChartsRadiusAxisProps>[];
-    axisDirection: 'radius';
-}): ComputeResult<ChartsRadiusAxisProps>;
-export declare function computeAxisValue(options: ComputeCommonParams & {
-    axis: AxisConfig<ScaleName, any, ChartsRotationAxisProps>[];
-    axisDirection: 'rotation';
-}): ComputeResult<ChartsRotationAxisProps>;
-export {};

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

@@ -1,12 +0,0 @@
-import type { ChartState } from '../models';
-type Listener<T> = (value: T) => void;
-export type StoreUpdater = (prevState: ChartState) => ChartState;
-export declare class ChartsStore {
-    value: ChartState;
-    private listeners;
-    constructor(value: ChartState);
-    subscribe: (fn: Listener<ChartState>) => () => void;
-    getSnapshot: () => ChartState;
-    update: (updater: StoreUpdater) => void;
-}
-export {};

package/internals/plugins/utils/ChartsStore.js

@@ -1,26 +0,0 @@
-// For now this is fixed. Will need to support generic if we add plugins
-
-export class ChartsStore {
-  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/internals/useCharts.d.ts

@@ -1,6 +0,0 @@
-import { ChartStore } from './plugins/utils/ChartStore';
-export declare function useCharts(): {
-    contextValue: {
-        store: ChartStore;
-    };
-};

package/internals/useCharts.js

@@ -1,29 +0,0 @@
-import * as React from 'react';
-import { ChartStore } from "./plugins/utils/ChartStore.js";
-let globalId = 0;
-export function useCharts() {
-  const storeRef = React.useRef(null);
-  if (storeRef.current == null) {
-    // eslint-disable-next-line react-compiler/react-compiler
-    globalId += 1;
-    const initialState = {
-      interaction: {
-        item: null,
-        axis: {
-          x: null,
-          y: null
-        }
-      },
-      cacheKey: {
-        id: globalId
-      }
-    };
-    storeRef.current = new ChartStore(initialState);
-  }
-  const contextValue = React.useMemo(() => ({
-    store: storeRef.current
-  }), []);
-  return {
-    contextValue
-  };
-}

package/internals/useSelector.d.ts

@@ -1,4 +0,0 @@
-import { ChartState } from './plugins/models';
-import { ChartsSelector } from './plugins/utils/selectors';
-import { ChartStore } from './plugins/utils/ChartStore';
-export declare const useSelector: <TArgs, TValue>(store: ChartStore, selector: ChartsSelector<ChartState, TArgs, TValue>, args?: TArgs, equals?: (a: TValue, b: TValue) => boolean) => TValue;

package/internals/useStore.d.ts

@@ -1,2 +0,0 @@
-import { ChartStore } from './plugins/utils/ChartStore';
-export declare function useStore(skipError?: boolean): ChartStore;

package/internals/useStore.js

@@ -1,17 +0,0 @@
-import * as React from 'react';
-import { ChartsContext } from "../context/InteractionProvider.js";
-export function useStore(skipError) {
-  const charts = React.useContext(ChartsContext);
-  if (skipError) {
-    // TODO: Remove once store is used by all charts.
-    // This line is only for `useAxisEvents` which is in the surface of the Gauge.
-    // But the Gauge don't have store yet because it does not need the interaction provider.
-    // Will be fixed when every thing move to the store since every component will have access to it.
-    // @ts-ignore
-    return charts?.store;
-  }
-  if (!charts) {
-    throw new Error(['MUI X: Could not find the charts context.', 'It looks like you rendered your component outside of a ChartsContainer parent component.'].join('\n'));
-  }
-  return charts.store;
-}

package/modern/ChartContainer/ResizableContainer.js

@@ -1,60 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { styled } from '@mui/material/styles';
-import { useSize } from "../context/SizeProvider/index.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * Wrapping div that take the shape of its parent.
- *
- * @ignore - do not document.
- */
-export const ResizableContainerRoot = styled('div', {
-  name: 'MuiResponsiveChart',
-  slot: 'Container'
-})(({
-  ownerState
-}) => ({
-  width: ownerState.width ?? '100%',
-  height: ownerState.height ?? '100%',
-  display: 'flex',
-  position: 'relative',
-  flexGrow: 1,
-  flexDirection: 'column',
-  alignItems: 'center',
-  justifyContent: 'center',
-  overflow: 'hidden',
-  '&>svg': {
-    width: '100%',
-    height: '100%'
-  }
-}));
-
-/**
- * Wrapping div that take the shape of its parent.
- *
- * @ignore - do not document.
- */
-function ResizableContainer(props) {
-  const {
-    inHeight,
-    inWidth,
-    containerRef
-  } = useSize();
-  return /*#__PURE__*/_jsx(ResizableContainerRoot, _extends({}, props, {
-    ownerState: {
-      width: inWidth,
-      height: inHeight
-    },
-    ref: containerRef,
-    children: props.children
-  }));
-}
-process.env.NODE_ENV !== "production" ? ResizableContainer.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  children: PropTypes.node
-} : void 0;
-export { ResizableContainer };

package/modern/ChartsLegend/ChartsLegendItem.js

@@ -1,65 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import clsx from 'clsx';
-import { useRtl } from '@mui/system/RtlProvider';
-import { ChartsText } from "../ChartsText/index.js";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * @ignore - internal component.
- */
-function ChartsLegendItem(props) {
-  const isRTL = useRtl();
-  const {
-    id,
-    positionY,
-    label,
-    positionX,
-    innerHeight,
-    innerWidth,
-    legendWidth,
-    color,
-    gapX,
-    gapY,
-    itemMarkHeight,
-    itemMarkWidth,
-    markGap,
-    labelStyle,
-    classes,
-    onClick
-  } = props;
-  return /*#__PURE__*/_jsxs("g", {
-    className: clsx(classes?.series, `${classes?.series}-${id}`),
-    transform: `translate(${gapX + (isRTL ? legendWidth - positionX : positionX)} ${gapY + positionY})`,
-    children: [/*#__PURE__*/_jsx("rect", {
-      x: isRTL ? -(innerWidth + 2) : -2,
-      y: -itemMarkHeight / 2 - 2,
-      width: innerWidth + 4,
-      height: innerHeight + 4,
-      fill: "transparent",
-      className: classes?.itemBackground,
-      onClick: onClick,
-      style: {
-        pointerEvents: onClick ? 'all' : 'none',
-        cursor: onClick ? 'pointer' : 'unset'
-      }
-    }), /*#__PURE__*/_jsx("rect", {
-      className: classes?.mark,
-      x: isRTL ? -itemMarkWidth : 0,
-      y: -itemMarkHeight / 2,
-      width: itemMarkWidth,
-      height: itemMarkHeight,
-      fill: color,
-      style: {
-        pointerEvents: 'none'
-      }
-    }), /*#__PURE__*/_jsx(ChartsText, {
-      style: _extends({
-        pointerEvents: 'none'
-      }, labelStyle),
-      text: label,
-      x: (isRTL ? -1 : 1) * (itemMarkWidth + markGap),
-      y: 0
-    })]
-  });
-}
-export { ChartsLegendItem };

package/modern/ChartsLegend/DefaultChartsLegend.js

@@ -1,112 +0,0 @@
-'use client';
-
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["seriesToDisplay", "hidden", "onItemClick"];
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import { LegendPerItem } from "./LegendPerItem.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const seriesContextBuilder = context => ({
-  type: 'series',
-  color: context.color,
-  label: context.label,
-  seriesId: context.seriesId,
-  itemId: context.itemId
-});
-function DefaultChartsLegend(props) {
-  const {
-      seriesToDisplay,
-      hidden,
-      onItemClick
-    } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
-  if (hidden) {
-    return null;
-  }
-  return /*#__PURE__*/_jsx(LegendPerItem, _extends({}, other, {
-    itemsToDisplay: seriesToDisplay,
-    onItemClick: onItemClick ? (event, i) => onItemClick(event, seriesContextBuilder(seriesToDisplay[i]), i) : undefined
-  }));
-}
-process.env.NODE_ENV !== "production" ? DefaultChartsLegend.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
-  // ----------------------------------------------------------------------
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes: PropTypes.object,
-  /**
-   * The direction of the legend layout.
-   * The default depends on the chart.
-   */
-  direction: PropTypes.oneOf(['column', 'row']).isRequired,
-  /**
-   * Set to true to hide the legend.
-   * @default false
-   */
-  hidden: PropTypes.bool,
-  /**
-   * Space between two legend items (in px).
-   * @default 10
-   */
-  itemGap: PropTypes.number,
-  /**
-   * Height of the item mark (in px).
-   * @default 20
-   */
-  itemMarkHeight: PropTypes.number,
-  /**
-   * Width of the item mark (in px).
-   * @default 20
-   */
-  itemMarkWidth: PropTypes.number,
-  /**
-   * Style applied to legend labels.
-   * @default theme.typography.subtitle1
-   */
-  labelStyle: PropTypes.object,
-  /**
-   * Space between the mark and the label (in px).
-   * @default 5
-   */
-  markGap: PropTypes.number,
-  /**
-   * Callback fired when a legend item is clicked.
-   * @param {React.MouseEvent<SVGRectElement, MouseEvent>} event The click event.
-   * @param {SeriesLegendItemContext} legendItem The legend item data.
-   * @param {number} index The index of the clicked legend item.
-   */
-  onItemClick: PropTypes.func,
-  /**
-   * Legend padding (in px).
-   * Can either be a single number, or an object with top, left, bottom, right properties.
-   * @default 10
-   */
-  padding: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
-    bottom: PropTypes.number,
-    left: PropTypes.number,
-    right: PropTypes.number,
-    top: PropTypes.number
-  })]),
-  /**
-   * The position of the legend.
-   */
-  position: PropTypes.shape({
-    horizontal: PropTypes.oneOf(['left', 'middle', 'right']).isRequired,
-    vertical: PropTypes.oneOf(['bottom', 'middle', 'top']).isRequired
-  }).isRequired,
-  series: PropTypes.object.isRequired,
-  seriesToDisplay: PropTypes.arrayOf(PropTypes.shape({
-    color: PropTypes.string.isRequired,
-    id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
-    itemId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
-    label: PropTypes.string.isRequired,
-    maxValue: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-    minValue: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number]),
-    seriesId: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
-  })).isRequired
-} : void 0;
-export { DefaultChartsLegend };

package/modern/ChartsLegend/LegendPerItem.js

@@ -1,129 +0,0 @@
-'use client';
-
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["rotate", "dominantBaseline"];
-import * as React from 'react';
-import NoSsr from '@mui/material/NoSsr';
-import { useTheme, styled } from '@mui/material/styles';
-import { getWordsByLines } from "../internals/getWordsByLines.js";
-import { legendItemPlacements } from "./legendItemsPlacement.js";
-import { useDrawingArea } from "../hooks/useDrawingArea.js";
-import { ChartsLegendItem } from "./ChartsLegendItem.js";
-import { createElement as _createElement } from "react";
-import { jsx as _jsx } from "react/jsx-runtime";
-export const ChartsLegendRoot = styled('g', {
-  name: 'MuiChartsLegend',
-  slot: 'Root',
-  overridesResolver: (props, styles) => styles.root
-})({});
-/**
- * Transforms number or partial padding object to a defaultized padding object.
- */
-const getStandardizedPadding = padding => {
-  if (typeof padding === 'number') {
-    return {
-      left: padding,
-      right: padding,
-      top: padding,
-      bottom: padding
-    };
-  }
-  return _extends({
-    left: 0,
-    right: 0,
-    top: 0,
-    bottom: 0
-  }, padding);
-};
-
-/**
- * Internal component to display an array of items as a legend.
- * Used for series legend, and threshold color legend.
- * @ignore - Do not document
- */
-export function LegendPerItem(props) {
-  const {
-    position,
-    direction,
-    itemsToDisplay,
-    classes,
-    itemMarkWidth = 20,
-    itemMarkHeight = 20,
-    markGap = 5,
-    itemGap = 10,
-    padding: paddingProps = 10,
-    labelStyle: inLabelStyle,
-    onItemClick
-  } = props;
-  const theme = useTheme();
-  const drawingArea = useDrawingArea();
-  const labelStyle = React.useMemo(() => _extends({}, theme.typography.subtitle1, {
-    color: 'inherit',
-    dominantBaseline: 'central',
-    textAnchor: 'start',
-    fill: (theme.vars || theme).palette.text.primary,
-    lineHeight: 1
-  }, inLabelStyle),
-  // To say to TS that the dominantBaseline and textAnchor are correct
-  [inLabelStyle, theme]);
-  const padding = React.useMemo(() => getStandardizedPadding(paddingProps), [paddingProps]);
-  const getItemSpace = React.useCallback((label, inStyle = {}) => {
-    const style = _objectWithoutPropertiesLoose(inStyle, _excluded);
-    const linesSize = getWordsByLines({
-      style,
-      needsComputation: true,
-      text: label
-    });
-    const innerSize = {
-      innerWidth: itemMarkWidth + markGap + Math.max(...linesSize.map(size => size.width)),
-      innerHeight: Math.max(itemMarkHeight, linesSize.length * linesSize[0].height)
-    };
-    return _extends({}, innerSize, {
-      outerWidth: innerSize.innerWidth + itemGap,
-      outerHeight: innerSize.innerHeight + itemGap
-    });
-  }, [itemGap, itemMarkHeight, itemMarkWidth, markGap]);
-  const totalWidth = drawingArea.left + drawingArea.width + drawingArea.right;
-  const totalHeight = drawingArea.top + drawingArea.height + drawingArea.bottom;
-  const availableWidth = totalWidth - padding.left - padding.right;
-  const availableHeight = totalHeight - padding.top - padding.bottom;
-  const [itemsWithPosition, legendWidth, legendHeight] = React.useMemo(() => legendItemPlacements(itemsToDisplay, getItemSpace, labelStyle, direction, availableWidth, availableHeight, itemGap), [itemsToDisplay, getItemSpace, labelStyle, direction, availableWidth, availableHeight, itemGap]);
-  const gapX = React.useMemo(() => {
-    switch (position.horizontal) {
-      case 'left':
-        return padding.left;
-      case 'right':
-        return totalWidth - padding.right - legendWidth;
-      default:
-        return (totalWidth - legendWidth) / 2;
-    }
-  }, [position.horizontal, padding.left, padding.right, totalWidth, legendWidth]);
-  const gapY = React.useMemo(() => {
-    switch (position.vertical) {
-      case 'top':
-        return padding.top;
-      case 'bottom':
-        return totalHeight - padding.bottom - legendHeight;
-      default:
-        return (totalHeight - legendHeight) / 2;
-    }
-  }, [position.vertical, padding.top, padding.bottom, totalHeight, legendHeight]);
-  return /*#__PURE__*/_jsx(NoSsr, {
-    children: /*#__PURE__*/_jsx(ChartsLegendRoot, {
-      className: classes?.root,
-      children: itemsWithPosition.map((item, i) => /*#__PURE__*/_createElement(ChartsLegendItem, _extends({}, item, {
-        key: item.id,
-        gapX: gapX,
-        gapY: gapY,
-        legendWidth: legendWidth,
-        itemMarkHeight: itemMarkHeight,
-        itemMarkWidth: itemMarkWidth,
-        markGap: markGap,
-        labelStyle: labelStyle,
-        classes: classes,
-        onClick: onItemClick ? event => onItemClick(event, i) : undefined
-      })))
-    })
-  });
-}

package/modern/ChartsLegend/legendItemsPlacement.js

@@ -1,72 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["label"];
-export function legendItemPlacements(itemsToDisplay, getItemSpace, labelStyle, direction, availableWidth, availableHeight, itemGap) {
-  // Start at 0, 0. Will be modified later by padding and position.
-  let x = 0;
-  let y = 0;
-
-  // total values used to align legend later.
-  let totalWidthUsed = 0;
-  let totalHeightUsed = 0;
-  let rowIndex = 0;
-  const rowMaxHeight = [0];
-  const seriesWithRawPosition = itemsToDisplay.map(_ref => {
-    let {
-        label
-      } = _ref,
-      other = _objectWithoutPropertiesLoose(_ref, _excluded);
-    const itemSpace = getItemSpace(label, labelStyle);
-    const rep = _extends({}, other, {
-      label,
-      positionX: x,
-      positionY: y,
-      innerHeight: itemSpace.innerHeight,
-      innerWidth: itemSpace.innerWidth,
-      outerHeight: itemSpace.outerHeight,
-      outerWidth: itemSpace.outerWidth,
-      rowIndex
-    });
-    if (direction === 'row') {
-      if (x + itemSpace.innerWidth > availableWidth) {
-        // This legend item would create overflow along the x-axis, so we start a new row.
-        x = 0;
-        y += rowMaxHeight[rowIndex];
-        rowIndex += 1;
-        if (rowMaxHeight.length <= rowIndex) {
-          rowMaxHeight.push(0);
-        }
-        rep.positionX = x;
-        rep.positionY = y;
-        rep.rowIndex = rowIndex;
-      }
-      totalWidthUsed = Math.max(totalWidthUsed, x + itemSpace.outerWidth);
-      totalHeightUsed = Math.max(totalHeightUsed, y + itemSpace.outerHeight);
-      rowMaxHeight[rowIndex] = Math.max(rowMaxHeight[rowIndex], itemSpace.outerHeight);
-      x += itemSpace.outerWidth;
-    }
-    if (direction === 'column') {
-      if (y + itemSpace.innerHeight > availableHeight) {
-        // This legend item would create overflow along the y-axis, so we start a new column.
-        x = totalWidthUsed + itemGap;
-        y = 0;
-        rowIndex = 0;
-        rep.positionX = x;
-        rep.positionY = y;
-        rep.rowIndex = rowIndex;
-      }
-      if (rowMaxHeight.length <= rowIndex) {
-        rowMaxHeight.push(0);
-      }
-      totalWidthUsed = Math.max(totalWidthUsed, x + itemSpace.outerWidth);
-      totalHeightUsed = Math.max(totalHeightUsed, y + itemSpace.outerHeight);
-      rowIndex += 1;
-      y += itemSpace.outerHeight;
-    }
-    return rep;
-  });
-  return [seriesWithRawPosition.map(item => _extends({}, item, {
-    positionY: item.positionY + (direction === 'row' ? rowMaxHeight[item.rowIndex] / 2 // Get the center of the entire row
-    : item.outerHeight / 2) // Get the center of the item
-  })), totalWidthUsed, totalHeightUsed];
-}