@mui/x-charts-premium 8.23.0 → 8.24.0

package/BarChartPremium/BarChartPremium.d.ts

@@ -1,6 +1,21 @@
 import * as React from 'react';
 import { type BarChartProProps } from '@mui/x-charts-pro/BarChartPro';
-export interface BarChartPremiumProps extends BarChartProProps {}
+import { type BarSeries } from '@mui/x-charts/BarChart';
+import { type BarItemIdentifier, type RangeBarItemIdentifier, type RangeBarSeriesType } from "../models/index.js";
+export type RangeBarSeries = RangeBarSeriesType;
+export interface BarChartPremiumProps extends Omit<BarChartProProps, 'series' | 'onItemClick'> {
+  /**
+   * Callback fired when a bar or range bar item is clicked.
+   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
+   * @param {BarItemIdentifier | RangeBarItemIdentifier} itemIdentifier The item identifier.
+   */
+  onItemClick?(event: React.MouseEvent<SVGElement, MouseEvent>, itemIdentifier: BarItemIdentifier | RangeBarItemIdentifier): void;
+  /**
+   * The series to display in the bar chart.
+   * An array of [[BarSeries]] or [[RangeBarSeries]] objects.
+   */
+  series: ReadonlyArray<BarSeries | RangeBarSeries>;
+}
 /**
  * Demos:
  *

package/BarChartPremium/BarChartPremium.js

@@ -29,8 +29,11 @@ var _internals = require("@mui/x-charts-pro/internals");
 var _useBarChartPremiumProps = require("./useBarChartPremiumProps");
 var _BarChartPremium2 = require("./BarChartPremium.plugins");
 var _ChartDataProviderPremium = require("../ChartDataProviderPremium");
+var _RangeBarPlot = require("./RangeBar/RangeBarPlot");
+var _RangeBarPreviewPlot = require("../ChartZoomSlider/internals/previews/RangeBarPreviewPlot");
 var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["initialZoom", "zoomData", "onZoomChange", "apiRef", "showToolbar"];
+_internals.seriesPreviewPlotMap.set('rangeBar', _RangeBarPreviewPlot.RangeBarPreviewPlot);
 /**
  * Demos:
  *
@@ -59,6 +62,7 @@ const BarChartPremium = exports.BarChartPremium = /*#__PURE__*/React.forwardRef(
     chartsWrapperProps,
     chartContainerProps,
     barPlotProps,
+    rangeBarPlotProps,
     gridProps,
     clipPathProps,
     clipPathGroupProps,
@@ -84,7 +88,7 @@ const BarChartPremium = exports.BarChartPremium = /*#__PURE__*/React.forwardRef(
     children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ChartsWrapper.ChartsWrapper, (0, _extends2.default)({}, chartsWrapperProps, {
       children: [showToolbar ? /*#__PURE__*/(0, _jsxRuntime.jsx)(Toolbar, (0, _extends2.default)({}, props.slotProps?.toolbar)) : null, !props.hideLegend && /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsLegend.ChartsLegend, (0, _extends2.default)({}, legendProps)), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ChartsSurface.ChartsSurface, (0, _extends2.default)({}, chartsSurfaceProps, {
         children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsGrid.ChartsGrid, (0, _extends2.default)({}, gridProps)), /*#__PURE__*/(0, _jsxRuntime.jsxs)("g", (0, _extends2.default)({}, clipPathGroupProps, {
-          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_BarChart.BarPlot, (0, _extends2.default)({}, barPlotProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsOverlay.ChartsOverlay, (0, _extends2.default)({}, overlayProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsAxisHighlight.ChartsAxisHighlight, (0, _extends2.default)({}, axisHighlightProps))]
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_BarChart.BarPlot, (0, _extends2.default)({}, barPlotProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_RangeBarPlot.RangeBarPlot, (0, _extends2.default)({}, rangeBarPlotProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsOverlay.ChartsOverlay, (0, _extends2.default)({}, overlayProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsAxisHighlight.ChartsAxisHighlight, (0, _extends2.default)({}, axisHighlightProps))]
         })), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsAxis.ChartsAxis, (0, _extends2.default)({}, chartsAxisProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartZoomSlider.ChartZoomSlider, {}), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsBrushOverlay.ChartsBrushOverlay, {}), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ChartsClipPath.ChartsClipPath, (0, _extends2.default)({}, clipPathProps)), children]
       })), !props.loading && /*#__PURE__*/(0, _jsxRuntime.jsx)(Tooltip, (0, _extends2.default)({}, props.slotProps?.tooltip))]
     }))
@@ -165,6 +169,31 @@ process.env.NODE_ENV !== "production" ? BarChartPremium.propTypes = {
    * The height of the chart in px. If not defined, it takes the height of the parent element.
    */
   height: _propTypes.default.number,
+  /**
+   * List of hidden series and/or items.
+   *
+   * Different chart types use different keys.
+   *
+   * @example
+   * ```ts
+   * [
+   *   {
+   *     type: 'pie',
+   *     seriesId: 'series-1',
+   *     dataIndex: 3,
+   *   },
+   *   {
+   *     type: 'line',
+   *     seriesId: 'series-2',
+   *   }
+   * ]
+   * ```
+   */
+  hiddenItems: _propTypes.default.arrayOf(_propTypes.default.shape({
+    dataIndex: _propTypes.default.number,
+    seriesId: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.string]),
+    type: _propTypes.default.oneOf(['bar']).isRequired
+  })),
   /**
    * If `true`, the legend is not rendered.
    */
@@ -232,6 +261,11 @@ process.env.NODE_ENV !== "production" ? BarChartPremium.propTypes = {
    * @param {null | ChartsAxisData} data The data about the clicked axis and items associated with it.
    */
   onAxisClick: _propTypes.default.func,
+  /**
+   * Callback fired when any hidden identifiers change.
+   * @param {VisibilityIdentifier[]} hiddenItems The new list of hidden identifiers.
+   */
+  onHiddenItemsChange: _propTypes.default.func,
   /**
    * The callback fired when the highlighted item changes.
    *
@@ -258,6 +292,15 @@ process.env.NODE_ENV !== "production" ? BarChartPremium.propTypes = {
    * @param {ZoomData[]} zoomData Updated zoom data.
    */
   onZoomChange: _propTypes.default.func,
+  /**
+   * The type of renderer to use for the bar plot.
+   * - `svg-single`: Renders every bar in a `<rect />` element.
+   * - `svg-batch`: Batch renders bars in `<path />` elements for better performance with large datasets, at the cost of some limitations.
+   *                Read more: https://mui.com/x/react-charts/bars/#performance
+   *
+   * @default 'svg-single'
+   */
+  renderer: _propTypes.default.oneOf(['svg-batch', 'svg-single']),
   /**
    * The series to display in the bar chart.
    * An array of [[BarSeries]] or [[RangeBarSeries]] objects.

package/BarChartPremium/RangeBar/AnimatedRangeBarElement.d.ts

@@ -0,0 +1,3 @@
+import { type BarProps } from '@mui/x-charts/BarChart';
+export interface AnimatedRangeBarElementProps extends BarProps {}
+export declare function AnimatedRangeBarElement(props: AnimatedRangeBarElementProps): import("react/jsx-runtime").JSX.Element;

package/BarChartPremium/RangeBar/AnimatedRangeBarElement.js

@@ -0,0 +1,28 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AnimatedRangeBarElement = AnimatedRangeBarElement;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _useAnimateRangeBar = require("../../hooks/animation/useAnimateRangeBar");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["ownerState", "skipAnimation", "id", "dataIndex", "xOrigin", "yOrigin"];
+function AnimatedRangeBarElement(props) {
+  const {
+      ownerState
+    } = props,
+    other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const animatedProps = (0, _useAnimateRangeBar.useAnimateRangeBar)(props);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("rect", (0, _extends2.default)({}, other, {
+    filter: ownerState.isHighlighted ? 'brightness(120%)' : undefined,
+    opacity: ownerState.isFaded ? 0.3 : 1,
+    "data-highlighted": ownerState.isHighlighted || undefined,
+    "data-faded": ownerState.isFaded || undefined
+  }, animatedProps));
+}

package/BarChartPremium/RangeBar/RangeBarPlot.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { type BarElementSlotProps, type BarElementSlots, type BarLabelSlots, type BarLabelSlotProps } from '@mui/x-charts/BarChart';
+import { type RangeBarItemIdentifier } from "../../models/index.js";
+export interface RangeBarPlotSlots extends BarElementSlots, BarLabelSlots {}
+export interface RangeBarPlotSlotProps extends BarElementSlotProps, BarLabelSlotProps {}
+export interface RangeBarPlotProps {
+  /**
+   * If `true`, animations are skipped.
+   * @default undefined
+   */
+  skipAnimation?: boolean;
+  /**
+   * Callback fired when a bar item is clicked.
+   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
+   * @param {RangeBarItemIdentifier} barItemIdentifier The range bar item identifier.
+   */
+  onItemClick?: (event: React.MouseEvent<SVGElement, MouseEvent>, barItemIdentifier: RangeBarItemIdentifier) => void;
+  /**
+   * Defines the border radius of the bar element.
+   */
+  borderRadius?: number;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: RangeBarPlotSlotProps;
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: RangeBarPlotSlots;
+}
+/**
+ * Demos:
+ *
+ * - [Range Bar](https://mui.com/x/react-charts/range-bar/)
+ *
+ * API:
+ *
+ * - [RangeBarPlot API](https://mui.com/x/api/charts/range-bar-plot/)
+ */
+declare function RangeBarPlot(props: RangeBarPlotProps): React.JSX.Element;
+declare namespace RangeBarPlot {
+  var propTypes: any;
+}
+export { RangeBarPlot };

package/BarChartPremium/RangeBar/RangeBarPlot.js

@@ -0,0 +1,141 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RangeBarPlot = RangeBarPlot;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _styles = require("@mui/material/styles");
+var _internals = require("@mui/x-charts/internals");
+var _BarChart = require("@mui/x-charts/BarChart");
+var _hooks = require("@mui/x-charts/hooks");
+var _hooks2 = require("@mui/x-charts-pro/hooks");
+var _useUtilityClasses = require("./useUtilityClasses");
+var _useRangeBarPlotData = require("./useRangeBarPlotData");
+var _AnimatedRangeBarElement = require("./AnimatedRangeBarElement");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["skipAnimation", "onItemClick", "borderRadius"];
+const RangeBarPlotRoot = (0, _styles.styled)('g', {
+  name: 'MuiRangeBarPlot',
+  slot: 'Root'
+})({
+  [`& .${_BarChart.barElementClasses.root}`]: {
+    transition: 'opacity 0.2s ease-in, fill 0.2s ease-in'
+  }
+});
+
+/**
+ * Demos:
+ *
+ * - [Range Bar](https://mui.com/x/react-charts/range-bar/)
+ *
+ * API:
+ *
+ * - [RangeBarPlot API](https://mui.com/x/api/charts/range-bar-plot/)
+ */
+function RangeBarPlot(props) {
+  const {
+      skipAnimation: inSkipAnimation,
+      onItemClick,
+      borderRadius
+    } = props,
+    other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const isZoomInteracting = (0, _hooks2.useIsZoomInteracting)();
+  const skipAnimation = (0, _internals.useSkipAnimation)(isZoomInteracting || inSkipAnimation);
+  const {
+    xAxis: xAxes
+  } = (0, _hooks.useXAxes)();
+  const {
+    yAxis: yAxes
+  } = (0, _hooks.useYAxes)();
+  const completedData = (0, _useRangeBarPlotData.useRangeBarPlotData)((0, _hooks.useDrawingArea)(), xAxes, yAxes);
+  const classes = (0, _useUtilityClasses.useUtilityClasses)();
+  const slots = (0, _extends2.default)({}, props.slots, {
+    bar: props.slots?.bar ?? _AnimatedRangeBarElement.AnimatedRangeBarElement
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(RangeBarPlotRoot, {
+    className: classes.root,
+    children: completedData.map(({
+      seriesId,
+      layout,
+      xOrigin,
+      yOrigin,
+      data
+    }) => {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)("g", {
+        "data-series": seriesId,
+        className: classes.series,
+        children: data.map(({
+          dataIndex,
+          color,
+          x,
+          y,
+          width,
+          height
+        }) => {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_BarChart.BarElement, (0, _extends2.default)({
+            id: seriesId,
+            dataIndex: dataIndex,
+            color: color,
+            skipAnimation: skipAnimation ?? false,
+            layout: layout ?? 'vertical',
+            x: x,
+            xOrigin: xOrigin,
+            y: y,
+            yOrigin: yOrigin,
+            width: width,
+            height: height,
+            rx: borderRadius,
+            ry: borderRadius
+          }, other, {
+            slots: slots,
+            onClick: onItemClick && (event => {
+              onItemClick(event, {
+                type: 'rangeBar',
+                seriesId,
+                dataIndex
+              });
+            })
+          }), dataIndex);
+        })
+      }, seriesId);
+    })
+  });
+}
+process.env.NODE_ENV !== "production" ? RangeBarPlot.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Defines the border radius of the bar element.
+   */
+  borderRadius: _propTypes.default.number,
+  /**
+   * Callback fired when a bar item is clicked.
+   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
+   * @param {RangeBarItemIdentifier} barItemIdentifier The range bar item identifier.
+   */
+  onItemClick: _propTypes.default.func,
+  /**
+   * If `true`, animations are skipped.
+   * @default undefined
+   */
+  skipAnimation: _propTypes.default.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: _propTypes.default.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: _propTypes.default.object
+} : void 0;

package/BarChartPremium/RangeBar/seriesConfig/extrema.d.ts

@@ -0,0 +1,3 @@
+import { type CartesianExtremumGetter } from '@mui/x-charts/internals';
+export declare const getExtremumX: CartesianExtremumGetter<'rangeBar'>;
+export declare const getExtremumY: CartesianExtremumGetter<'rangeBar'>;

package/BarChartPremium/RangeBar/seriesConfig/extrema.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtremumY = exports.getExtremumX = void 0;
+var _internals = require("@mui/x-charts/internals");
+const createResult = (data, direction) => {
+  if (direction === 'x') {
+    return {
+      x: data,
+      y: null
+    };
+  }
+  return {
+    x: null,
+    y: data
+  };
+};
+const getBaseExtremum = params => {
+  const {
+    axis,
+    getFilters,
+    isDefaultAxis
+  } = params;
+  const filter = getFilters?.({
+    currentAxisId: axis.id,
+    isDefaultAxis
+  });
+  const data = filter ? axis.data?.filter((_, i) => filter({
+    x: null,
+    y: null
+  }, i)) : axis.data;
+  return (0, _internals.findMinMax)(data ?? []);
+};
+const getValueExtremum = direction => params => {
+  const {
+    series,
+    axis,
+    getFilters,
+    isDefaultAxis
+  } = params;
+  return Object.keys(series).filter(seriesId => {
+    const axisId = direction === 'x' ? series[seriesId].xAxisId : series[seriesId].yAxisId;
+    return axisId === axis.id || isDefaultAxis && axisId === undefined;
+  }).reduce((acc, seriesId) => {
+    const {
+      data
+    } = series[seriesId];
+    const filter = getFilters?.({
+      currentAxisId: axis.id,
+      isDefaultAxis,
+      seriesXAxisId: series[seriesId].xAxisId,
+      seriesYAxisId: series[seriesId].yAxisId
+    });
+    const [seriesMin, seriesMax] = data?.reduce((seriesAcc, values, index) => {
+      if (values == null) {
+        return seriesAcc;
+      }
+      if (filter && (!filter(createResult(values[0], direction), index) || !filter(createResult(values[1], direction), index))) {
+        return seriesAcc;
+      }
+      return [Math.min(values[0], values[1], seriesAcc[0]), Math.max(values[0], values[1], seriesAcc[1])];
+    }, [Infinity, -Infinity]) ?? [Infinity, -Infinity];
+    return [Math.min(seriesMin, acc[0]), Math.max(seriesMax, acc[1])];
+  }, [Infinity, -Infinity]);
+};
+const getExtremumX = params => {
+  // Notice that bar should be all horizontal or all vertical.
+  // Don't think it's a problem for now
+  const isHorizontal = Object.keys(params.series).some(seriesId => params.series[seriesId].layout === 'horizontal');
+  if (isHorizontal) {
+    return getValueExtremum('x')(params);
+  }
+  return getBaseExtremum(params);
+};
+exports.getExtremumX = getExtremumX;
+const getExtremumY = params => {
+  const isHorizontal = Object.keys(params.series).some(seriesId => params.series[seriesId].layout === 'horizontal');
+  if (isHorizontal) {
+    return getBaseExtremum(params);
+  }
+  return getValueExtremum('y')(params);
+};
+exports.getExtremumY = getExtremumY;

package/BarChartPremium/RangeBar/seriesConfig/getColor.d.ts

@@ -0,0 +1,3 @@
+import { type ColorProcessor } from '@mui/x-charts/internals';
+declare const getColor: ColorProcessor<'rangeBar'>;
+export default getColor;

package/BarChartPremium/RangeBar/seriesConfig/getColor.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _internals = require("@mui/x-charts/internals");
+const getColor = (series, xAxis, yAxis) => {
+  const verticalLayout = series.layout === 'vertical';
+  const bandColorScale = verticalLayout ? xAxis?.colorScale : yAxis?.colorScale;
+  const bandValues = verticalLayout ? xAxis?.data : yAxis?.data;
+  const getSeriesColor = (0, _internals.getSeriesColorFn)(series);
+  if (bandColorScale && bandValues) {
+    return dataIndex => {
+      if (dataIndex === undefined) {
+        return series.color;
+      }
+      const value = bandValues[dataIndex];
+      const color = value === null ? getSeriesColor({
+        value,
+        dataIndex
+      }) : bandColorScale(value);
+      if (color === null) {
+        return getSeriesColor({
+          value,
+          dataIndex
+        });
+      }
+      return color;
+    };
+  }
+  return dataIndex => {
+    if (dataIndex === undefined) {
+      return series.color;
+    }
+    const value = series.data[dataIndex];
+    return getSeriesColor({
+      value,
+      dataIndex
+    });
+  };
+};
+var _default = exports.default = getColor;

package/BarChartPremium/RangeBar/seriesConfig/getSeriesWithDefaultValues.d.ts

@@ -0,0 +1,19 @@
+import { type AllSeriesType } from '@mui/x-charts/models';
+export declare function getSeriesWithDefaultValues(seriesData: AllSeriesType<'rangeBar'>, seriesIndex: number, colors: readonly string[]): {
+  id: import("@mui/x-charts").SeriesId;
+  color: string;
+  type: "rangeBar";
+  data?: ReadonlyArray<import("../../../index.js").RangeBarValueType | null>;
+  datasetKeys?: {
+    start: string;
+    end: string;
+  };
+  label?: string | ((location: "tooltip" | "legend") => string);
+  layout?: "horizontal" | "vertical";
+  valueFormatter?: import("@mui/x-charts/internals").SeriesValueFormatter<import("../../../index.js").RangeBarValueType | null> | undefined;
+  highlightScope?: import("@mui/x-charts").HighlightScope;
+  labelMarkType?: import("@mui/x-charts/internals").ChartsLabelMarkType;
+  colorGetter?: ((data: import("@mui/x-charts/internals").ColorCallbackValue<import("../../../index.js").RangeBarValueType | null>) => string) | undefined;
+  xAxisId?: import("@mui/x-charts/internals").AxisId;
+  yAxisId?: import("@mui/x-charts/internals").AxisId;
+};

package/BarChartPremium/RangeBar/seriesConfig/getSeriesWithDefaultValues.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSeriesWithDefaultValues = getSeriesWithDefaultValues;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+function getSeriesWithDefaultValues(seriesData, seriesIndex, colors) {
+  return (0, _extends2.default)({}, seriesData, {
+    id: seriesData.id ?? `auto-generated-id-${seriesIndex}`,
+    color: seriesData.color ?? colors[seriesIndex % colors.length]
+  });
+}

package/BarChartPremium/RangeBar/seriesConfig/index.d.ts

@@ -0,0 +1,2 @@
+import { type ChartSeriesTypeConfig } from '@mui/x-charts/internals';
+export declare const rangeBarSeriesConfig: ChartSeriesTypeConfig<'rangeBar'>;

package/BarChartPremium/RangeBar/seriesConfig/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rangeBarSeriesConfig = void 0;
+var _internals = require("@mui/x-charts/internals");
+var _extrema = require("./extrema");
+var _tooltip = _interopRequireWildcard(require("./tooltip"));
+var _seriesProcessor = _interopRequireDefault(require("./seriesProcessor"));
+var _getColor = _interopRequireDefault(require("./getColor"));
+var _legend = _interopRequireDefault(require("./legend"));
+var _tooltipPosition = _interopRequireDefault(require("./tooltipPosition"));
+var _getSeriesWithDefaultValues = require("./getSeriesWithDefaultValues");
+const rangeBarSeriesConfig = exports.rangeBarSeriesConfig = {
+  seriesProcessor: _seriesProcessor.default,
+  colorProcessor: _getColor.default,
+  legendGetter: _legend.default,
+  tooltipGetter: _tooltip.default,
+  tooltipItemPositionGetter: _tooltipPosition.default,
+  axisTooltipGetter: _tooltip.axisTooltipGetter,
+  xExtremumGetter: _extrema.getExtremumX,
+  yExtremumGetter: _extrema.getExtremumY,
+  getSeriesWithDefaultValues: _getSeriesWithDefaultValues.getSeriesWithDefaultValues,
+  identifierSerializer: _internals.identifierSerializerSeriesIdDataIndex
+};
+_internals.cartesianSeriesTypes.addType('rangeBar');

package/BarChartPremium/RangeBar/seriesConfig/legend.d.ts

@@ -0,0 +1,3 @@
+import { type LegendGetter } from '@mui/x-charts/internals';
+declare const legendGetter: LegendGetter<'rangeBar'>;
+export default legendGetter;

package/BarChartPremium/RangeBar/seriesConfig/legend.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _internals = require("@mui/x-charts/internals");
+const legendGetter = params => {
+  const {
+    seriesOrder,
+    series
+  } = params;
+  return seriesOrder.reduce((acc, seriesId) => {
+    const formattedLabel = (0, _internals.getLabel)(series[seriesId].label, 'legend');
+    if (formattedLabel === undefined) {
+      return acc;
+    }
+    acc.push({
+      type: 'rangeBar',
+      markType: series[seriesId].labelMarkType,
+      id: seriesId,
+      seriesId,
+      color: series[seriesId].color,
+      label: formattedLabel
+    });
+    return acc;
+  }, []);
+};
+var _default = exports.default = legendGetter;

package/BarChartPremium/RangeBar/seriesConfig/seriesProcessor.d.ts

@@ -0,0 +1,3 @@
+import { type SeriesProcessor } from '@mui/x-charts/internals';
+declare const seriesProcessor: SeriesProcessor<'rangeBar'>;
+export default seriesProcessor;

package/BarChartPremium/RangeBar/seriesConfig/seriesProcessor.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _warning = require("@mui/x-internals/warning");
+const rangeBarValueFormatter = v => v == null ? '' : `[${v[0]}, ${v[1]}]`;
+const seriesProcessor = (params, dataset) => {
+  const {
+    seriesOrder,
+    series
+  } = params;
+  const completedSeries = {};
+  for (const id of seriesOrder) {
+    const seriesData = series[id];
+    const datasetKeys = seriesData?.datasetKeys;
+    if (seriesData.data === undefined && dataset === undefined && process.env.NODE_ENV !== 'production') {
+      throw new Error([`MUI X Charts: range bar series with id='${id}' has no data.`, 'Either provide a data property to the series or use the dataset prop.'].join('\n'));
+    }
+    const missingKeys = ['start', 'end'].filter(key => typeof datasetKeys?.[key] !== 'string');
+    if (datasetKeys && missingKeys.length > 0) {
+      throw new Error([`MUI X Charts: range bar series with id='${id}' has incomplete datasetKeys.`, `Properties ${missingKeys.map(key => `"${key}"`).join(', ')} are missing.`].join('\n'));
+    }
+    completedSeries[id] = (0, _extends2.default)({
+      layout: 'vertical'
+    }, series[id], {
+      valueFormatter: series[id].valueFormatter ?? rangeBarValueFormatter,
+      data: datasetKeys ? dataset.map(data => {
+        const start = data[datasetKeys.start];
+        const end = data[datasetKeys.end];
+        if (typeof start !== 'number' || typeof end !== 'number') {
+          if (process.env.NODE_ENV !== 'production') {
+            if (start !== null) {
+              (0, _warning.warnOnce)([`MUI X Charts: Your dataset key "start" is used for plotting an range bar, but contains nonnumerical elements.`, 'Range bars only support numbers.']);
+            }
+            if (end !== null) {
+              (0, _warning.warnOnce)([`MUI X Charts: Your dataset key "end" is used for plotting an range bar, but contains nonnumerical elements.`, 'Range bars only support numbers.']);
+            }
+          }
+          return null;
+        }
+        return [start, end];
+      }) : series[id].data
+    });
+  }
+  return {
+    seriesOrder,
+    series: completedSeries
+  };
+};
+var _default = exports.default = seriesProcessor;

package/BarChartPremium/RangeBar/seriesConfig/tooltip.d.ts

@@ -0,0 +1,4 @@
+import { type AxisTooltipGetter, type TooltipGetter } from '@mui/x-charts/internals';
+declare const tooltipGetter: TooltipGetter<'rangeBar'>;
+export declare const axisTooltipGetter: AxisTooltipGetter<'rangeBar', 'x' | 'y'>;
+export default tooltipGetter;