@mui/x-charts 8.28.2 → 8.29.2

package/internals/components/ChartsAxesGradients/ChartsAxesGradients.mjs

@@ -0,0 +1,133 @@
+import * as React from 'react';
+import { useDrawingArea, useXAxes, useYAxes } from "../../../hooks/index.mjs";
+import ChartsPiecewiseGradient from "./ChartsPiecewiseGradient.mjs";
+import ChartsContinuousGradient from "./ChartsContinuousGradient.mjs";
+import ChartsContinuousGradientObjectBound from "./ChartsContinuousGradientObjectBound.mjs";
+import { useZAxes } from "../../../hooks/useZAxis.mjs";
+import { useChartGradientIdBuilder, useChartGradientIdObjectBoundBuilder } from "../../../hooks/useChartGradientId.mjs";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function ChartsAxesGradients() {
+  const {
+    top,
+    height,
+    bottom,
+    left,
+    width,
+    right
+  } = useDrawingArea();
+  const svgHeight = top + height + bottom;
+  const svgWidth = left + width + right;
+  const getGradientId = useChartGradientIdBuilder();
+  const getObjectBoundGradientId = useChartGradientIdObjectBoundBuilder();
+  const {
+    xAxis,
+    xAxisIds
+  } = useXAxes();
+  const {
+    yAxis,
+    yAxisIds
+  } = useYAxes();
+  const {
+    zAxis,
+    zAxisIds
+  } = useZAxes();
+  const filteredYAxisIds = yAxisIds.filter(axisId => yAxis[axisId].colorMap !== undefined);
+  const filteredXAxisIds = xAxisIds.filter(axisId => xAxis[axisId].colorMap !== undefined);
+  const filteredZAxisIds = zAxisIds.filter(axisId => zAxis[axisId].colorMap !== undefined);
+  if (filteredYAxisIds.length === 0 && filteredXAxisIds.length === 0 && filteredZAxisIds.length === 0) {
+    return null;
+  }
+  return /*#__PURE__*/_jsxs("defs", {
+    children: [filteredYAxisIds.map(axisId => {
+      const gradientId = getGradientId(axisId);
+      const objectBoundGradientId = getObjectBoundGradientId(axisId);
+      const {
+        colorMap,
+        scale,
+        colorScale,
+        reverse
+      } = yAxis[axisId];
+      if (colorMap?.type === 'piecewise') {
+        return /*#__PURE__*/_jsx(ChartsPiecewiseGradient, {
+          isReversed: !reverse,
+          scale: scale,
+          colorMap: colorMap,
+          size: svgHeight,
+          gradientId: gradientId,
+          direction: "y"
+        }, gradientId);
+      }
+      if (colorMap?.type === 'continuous') {
+        return /*#__PURE__*/_jsxs(React.Fragment, {
+          children: [/*#__PURE__*/_jsx(ChartsContinuousGradient, {
+            isReversed: !reverse,
+            scale: scale,
+            colorScale: colorScale,
+            colorMap: colorMap,
+            size: svgHeight,
+            gradientId: gradientId,
+            direction: "y"
+          }), /*#__PURE__*/_jsx(ChartsContinuousGradientObjectBound, {
+            isReversed: reverse,
+            colorScale: colorScale,
+            colorMap: colorMap,
+            gradientId: objectBoundGradientId
+          })]
+        }, gradientId);
+      }
+      return null;
+    }), filteredXAxisIds.map(axisId => {
+      const gradientId = getGradientId(axisId);
+      const objectBoundGradientId = getObjectBoundGradientId(axisId);
+      const {
+        colorMap,
+        scale,
+        reverse,
+        colorScale
+      } = xAxis[axisId];
+      if (colorMap?.type === 'piecewise') {
+        return /*#__PURE__*/_jsx(ChartsPiecewiseGradient, {
+          isReversed: reverse,
+          scale: scale,
+          colorMap: colorMap,
+          size: svgWidth,
+          gradientId: gradientId,
+          direction: "x"
+        }, gradientId);
+      }
+      if (colorMap?.type === 'continuous') {
+        return /*#__PURE__*/_jsxs(React.Fragment, {
+          children: [/*#__PURE__*/_jsx(ChartsContinuousGradient, {
+            isReversed: reverse,
+            scale: scale,
+            colorScale: colorScale,
+            colorMap: colorMap,
+            size: svgWidth,
+            gradientId: gradientId,
+            direction: "x"
+          }), /*#__PURE__*/_jsx(ChartsContinuousGradientObjectBound, {
+            isReversed: reverse,
+            colorScale: colorScale,
+            colorMap: colorMap,
+            gradientId: objectBoundGradientId
+          })]
+        }, gradientId);
+      }
+      return null;
+    }), filteredZAxisIds.map(axisId => {
+      const objectBoundGradientId = getObjectBoundGradientId(axisId);
+      const {
+        colorMap,
+        colorScale
+      } = zAxis[axisId];
+      if (colorMap?.type === 'continuous') {
+        return /*#__PURE__*/_jsx(ChartsContinuousGradientObjectBound, {
+          colorScale: colorScale,
+          colorMap: colorMap,
+          gradientId: objectBoundGradientId
+        }, objectBoundGradientId);
+      }
+      return null;
+    })]
+  });
+}

package/internals/components/ChartsAxesGradients/ChartsContinuousGradient.d.mts

@@ -0,0 +1,18 @@
+import { type ContinuousColorConfig } from "../../../models/colorMapping.mjs";
+type ChartsContinuousGradientProps = {
+  isReversed?: boolean;
+  gradientId: string;
+  size: number;
+  direction: 'x' | 'y';
+  scale: (value: any) => number | undefined;
+  colorMap: ContinuousColorConfig;
+  colorScale: (value: any) => string | null;
+  /**
+   * Defines the coordinate base to use:
+   * - 'userSpaceOnUse': uses the coordinate of the SVG (values in px).
+   * - 'objectBoundingBox': uses the coordinate ot the object on which gradient is applied (values from 0 to 1).
+   */
+  gradientUnits?: 'objectBoundingBox' | 'userSpaceOnUse';
+};
+export default function ChartsContinuousGradient(props: ChartsContinuousGradientProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/internals/components/ChartsAxesGradients/ChartsContinuousGradientObjectBound.d.mts

@@ -0,0 +1,12 @@
+import { type ContinuousColorConfig } from "../../../models/colorMapping.mjs";
+type ChartsContinuousGradientObjectBoundProps = {
+  isReversed?: boolean;
+  gradientId: string;
+  colorMap: ContinuousColorConfig;
+  colorScale: (value: any) => string | null;
+};
+/**
+ * Generates gradients to be used in tooltips and legends.
+ */
+export default function ChartsContinuousGradientObjectBound(props: ChartsContinuousGradientObjectBoundProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/internals/components/ChartsAxesGradients/ChartsPiecewiseGradient.d.mts

@@ -0,0 +1,11 @@
+import { type PiecewiseColorConfig } from "../../../models/colorMapping.mjs";
+type ChartsPiecewiseGradientProps = {
+  isReversed?: boolean;
+  gradientId: string;
+  size: number;
+  direction: 'x' | 'y';
+  scale: (value: any) => number | undefined;
+  colorMap: PiecewiseColorConfig;
+};
+export default function ChartsPiecewiseGradient(props: ChartsPiecewiseGradientProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/internals/components/ChartsAxesGradients/index.d.mts

@@ -0,0 +1 @@
+export * from "./ChartsAxesGradients.mjs";

package/internals/components/ChartsAxesGradients/index.mjs

@@ -0,0 +1 @@
+export * from "./ChartsAxesGradients.mjs";

package/internals/configInit.d.mts

@@ -0,0 +1,16 @@
+import { type CartesianChartSeriesType, type PolarChartSeriesType } from "../models/seriesType/config.mjs";
+declare class CartesianSeriesTypes {
+  types: Set<CartesianChartSeriesType>;
+  constructor();
+  addType(value: CartesianChartSeriesType): void;
+  getTypes(): Set<"line" | "bar" | "scatter">;
+}
+declare class PolarSeriesTypes {
+  types: Set<PolarChartSeriesType>;
+  constructor();
+  addType(value: PolarChartSeriesType): void;
+  getTypes(): Set<"radar">;
+}
+export declare const cartesianSeriesTypes: CartesianSeriesTypes;
+export declare const polarSeriesTypes: PolarSeriesTypes;
+export {};

package/internals/constants.d.mts

@@ -0,0 +1,16 @@
+import type { ZoomSliderShowTooltip } from "./plugins/featurePlugins/useChartCartesianAxis/zoom.types.mjs";
+/** Margin in the opposite direction of the axis, i.e., horizontal if the axis is vertical and vice versa. */
+export declare const ZOOM_SLIDER_MARGIN = 4;
+/** Size of the zoom slider preview. */
+export declare const ZOOM_SLIDER_PREVIEW_SIZE = 40;
+/** Size reserved for the zoom slider. The actual size of the slider might be smaller. */
+export declare const DEFAULT_ZOOM_SLIDER_SIZE: number;
+export declare const DEFAULT_ZOOM_SLIDER_PREVIEW_SIZE: number;
+export declare const DEFAULT_ZOOM_SLIDER_SHOW_TOOLTIP: ZoomSliderShowTooltip;
+/** Default margin for pie charts. */
+export declare const DEFAULT_PIE_CHART_MARGIN: {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+};

package/internals/consumeSlots.js

@@ -61,7 +61,7 @@ const consumeSlots = (name, slotPropName, options, InComponent) => {
   function ConsumeSlotsInternal(props, ref) {
     const themedProps = (0, _styles.useThemeProps)({
       props,
-      // eslint-disable-next-line material-ui/mui-name-matches-component-name
+      // eslint-disable-next-line mui/material-ui-name-matches-component-name
       name
     });
     const defaultProps = typeof options.defaultProps === 'function' ? options.defaultProps(themedProps) : options.defaultProps ?? {};

package/internals/consumeSlots.mjs

@@ -0,0 +1,100 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["slots", "slotProps"],
+  _excluded2 = ["ownerState"];
+import { useTheme, useThemeProps } from '@mui/material/styles';
+import resolveProps from '@mui/utils/resolveProps';
+import useSlotProps from '@mui/utils/useSlotProps';
+import * as React from 'react';
+
+/**
+ * A higher order component that consumes a slot from the props and renders the component provided in the slot.
+ *
+ * This HOC will wrap a single component, and will render the component provided in the slot, if it exists.
+ *
+ * If you need to render multiple components, you can manually consume the slots from the props and render them in your component instead of using this HOC.
+ *
+ * In the example below, `MyComponent` will render the component provided in `mySlot` slot, if it exists. Otherwise, it will render the `DefaultComponent`.
+ *
+ * @example
+ *
+ * ```tsx
+ * type MyComponentProps = {
+ *   direction: 'row' | 'column';
+ *   slots?: {
+ *     mySlot?: React.JSXElementConstructor<{ direction: 'row' | 'column' }>;
+ *   }
+ * };
+ *
+ * const MyComponent = consumeSlots(
+ *   'MuiMyComponent',
+ *   'mySlot',
+ *   function DefaultComponent(props: MyComponentProps) {
+ *     return (
+ *       <div className={props.classes.root}>
+ *         {props.direction}
+ *       </div>
+ *     );
+ *   }
+ * );
+ * ```
+ *
+ * @param {string} name The mui component name.
+ * @param {string} slotPropName The name of the prop to retrieve the slot from.
+ * @param {object} options Options for the HOC.
+ * @param {boolean} options.propagateSlots Whether to propagate the slots to the component, this is always false if the slot is provided.
+ * @param {Record<string, any>} options.defaultProps A set of defaults for the component, will be deep merged with the props.
+ * @param {Array<keyof Props>} options.omitProps An array of props to omit from the component.
+ * @param {Function} options.classesResolver A function that returns the classes for the component. It receives the props, after theme props and defaults have been applied. And the theme object as the second argument.
+ * @param InComponent The component to render if the slot is not provided.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export const consumeSlots = (name, slotPropName, options, InComponent) => {
+  function ConsumeSlotsInternal(props, ref) {
+    const themedProps = useThemeProps({
+      props,
+      // eslint-disable-next-line mui/material-ui-name-matches-component-name
+      name
+    });
+    const defaultProps = typeof options.defaultProps === 'function' ? options.defaultProps(themedProps) : options.defaultProps ?? {};
+    const defaultizedProps = resolveProps(defaultProps, themedProps);
+    const _ref = defaultizedProps,
+      {
+        slots,
+        slotProps
+      } = _ref,
+      other = _objectWithoutPropertiesLoose(_ref, _excluded);
+    const theme = useTheme();
+    const classes = options.classesResolver?.(defaultizedProps, theme);
+
+    // Can be a function component or a forward ref component.
+    const Component = slots?.[slotPropName] ?? InComponent;
+    const propagateSlots = options.propagateSlots && !slots?.[slotPropName];
+    const _useSlotProps = useSlotProps({
+        elementType: Component,
+        externalSlotProps: slotProps?.[slotPropName],
+        additionalProps: _extends({}, other, {
+          classes
+        }, propagateSlots && {
+          slots,
+          slotProps
+        }),
+        ownerState: {}
+      }),
+      originalOutProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded2);
+    const outProps = _extends({}, originalOutProps);
+    for (const prop of options.omitProps ?? []) {
+      delete outProps[prop];
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      Component.displayName = `${name}.slots.${slotPropName}`;
+    }
+    return /*#__PURE__*/_jsx(Component, _extends({}, outProps, {
+      ref: ref
+    }));
+  }
+  return /*#__PURE__*/React.forwardRef(ConsumeSlotsInternal);
+};
+if (process.env.NODE_ENV !== "production") consumeSlots.displayName = "consumeSlots";

package/internals/consumeThemeProps.js

@@ -60,7 +60,7 @@ var _jsxRuntime = require("react/jsx-runtime");
 const consumeThemeProps = (name, options, InComponent) => /*#__PURE__*/React.forwardRef(function ConsumeThemeInternal(props, ref) {
   const themedProps = (0, _styles.useThemeProps)({
     props,
-    // eslint-disable-next-line material-ui/mui-name-matches-component-name
+    // eslint-disable-next-line mui/material-ui-name-matches-component-name
     name
   });
   const defaultProps = typeof options.defaultProps === 'function' ? options.defaultProps(themedProps) : options.defaultProps ?? {};

package/internals/consumeThemeProps.mjs

@@ -0,0 +1,74 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { useTheme, useThemeProps } from '@mui/material/styles';
+import resolveProps from '@mui/utils/resolveProps';
+import * as React from 'react';
+
+/**
+ * A higher order component that consumes and merges the theme `defaultProps` and handles the `classes` and renders the component.
+ *
+ * This HOC will wrap a single component.
+ * If you need to render multiple components, you can manually consume the theme and render them in your component instead of using this HOC.
+ *
+ * In the example below, `MyComponent` will render the `DefaultComponent` with the `direction` prop set to `'row'` and the className set to `'my-custom-root'`.
+ *
+ * @example
+ * ```tsx
+ * createTheme({
+ *   components: {
+ *     MuiMyComponent: {
+ *       defaultProps: {
+ *         direction: 'row',
+ *       },
+ *     },
+ *   },
+ * })
+ *
+ * type MyComponentProps = {
+ *   direction: 'row' | 'column';
+ *   classes?: Record<'root', string>;
+ * };
+ *
+ * const MyComponent = consumeThemeProps(
+ *   'MuiMyComponent',
+ *   function DefaultComponent(props: MyComponentProps) {
+ *     return (
+ *       <div className={props.classes.root}>
+ *         {props.direction}
+ *       </div>
+ *     );
+ *   }
+ * );
+ *
+ * render(<MyComponent classes={{ root: 'my-custom-root' }} />);
+ * ```
+ *
+ * @param {string} name The mui component name.
+ * @param {object} options Options for the HOC.
+ * @param {Record<string, any>} options.defaultProps A set of defaults for the component, will be deep merged with the props.
+ * @param {Function} options.classesResolver A function that returns the classes for the component. It receives the props, after theme props and defaults have been applied. And the theme object as the second argument.
+ * @param InComponent The component to render if the slot is not provided.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export const consumeThemeProps = (name, options, InComponent) => /*#__PURE__*/React.forwardRef(function ConsumeThemeInternal(props, ref) {
+  const themedProps = useThemeProps({
+    props,
+    // eslint-disable-next-line mui/material-ui-name-matches-component-name
+    name
+  });
+  const defaultProps = typeof options.defaultProps === 'function' ? options.defaultProps(themedProps) : options.defaultProps ?? {};
+  const outProps = resolveProps(defaultProps, themedProps);
+  const theme = useTheme();
+  const classes = options.classesResolver?.(outProps, theme);
+  const OutComponent = /*#__PURE__*/React.forwardRef(InComponent);
+  if (process.env.NODE_ENV !== "production") OutComponent.displayName = "OutComponent";
+  if (process.env.NODE_ENV !== 'production') {
+    OutComponent.displayName = `consumeThemeProps(${name})`;
+  }
+  return /*#__PURE__*/_jsx(OutComponent, _extends({}, outProps, {
+    classes: classes,
+    ref: ref
+  }));
+});
+if (process.env.NODE_ENV !== "production") consumeThemeProps.displayName = "consumeThemeProps";

package/internals/createSvgIcon.d.mts

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+import { type ChartBaseIconProps } from "../models/slots/chartsBaseSlotProps.mjs";
+export declare const createSvgIcon: (path: React.ReactNode, displayName?: string) => (props: ChartBaseIconProps) => React.ReactNode;

package/internals/dateHelpers.d.mts

@@ -0,0 +1,17 @@
+import { type NumberValue } from '@mui/x-charts-vendor/d3-scale';
+import { type AxisConfig } from "../models/index.mjs";
+import { type ChartsAxisProps } from "../models/axis.mjs";
+/**
+ * Checks if the provided data array contains Date objects.
+ * @param data The data array to check.
+ * @returns A type predicate indicating if the data is an array of Date objects.
+ */
+export declare const isDateData: (data?: readonly any[]) => data is Date[];
+/**
+ * Creates a formatter function for date values.
+ * @param data The data array containing Date or NumberValue objects.
+ * @param range The range for the time scale.
+ * @param tickNumber (Optional) The number of ticks for formatting.
+ * @returns A formatter function for date values.
+ */
+export declare function createDateFormatter(data: Iterable<Date | NumberValue>, range: number[], tickNumber?: number): AxisConfig<'band' | 'point', any, ChartsAxisProps>['valueFormatter'];

package/internals/defaultValueFormatters.d.mts

@@ -0,0 +1,6 @@
+import { type AxisValueFormatterContext, type ContinuousScaleName, type D3ContinuousScale } from "../models/axis.mjs";
+/**
+ * Creates a default formatter function for continuous scales (e.g., linear, sqrt, log).
+ * @returns A formatter function for continuous values.
+ */
+export declare function createScalarFormatter(tickNumber: number, zoomScale: D3ContinuousScale): <S extends ContinuousScaleName = ContinuousScaleName>(value: any, context: AxisValueFormatterContext<S>) => string;

package/internals/defaultizeMargin.d.mts

@@ -0,0 +1,3 @@
+import type { ChartMargin, UseChartDimensionsParameters } from "./plugins/corePlugins/useChartDimensions/useChartDimensions.types.mjs";
+export declare function defaultizeMargin(input: UseChartDimensionsParameters['margin'], defaultMargin: ChartMargin): ChartMargin;
+export declare function defaultizeMargin(input: UseChartDimensionsParameters['margin'], defaultMargin?: ChartMargin): Partial<ChartMargin> | undefined;

package/internals/ellipsize.mjs

@@ -0,0 +1,53 @@
+import { getGraphemeCount } from "./getGraphemeCount.mjs";
+import { degToRad } from "./degToRad.mjs";
+import { sliceUntil } from "./sliceUntil.mjs";
+const ELLIPSIS = '…';
+export function doesTextFitInRect(text, config) {
+  const {
+    width,
+    height,
+    measureText
+  } = config;
+  const angle = degToRad(config.angle);
+  const textSize = measureText(text);
+  const angledWidth = Math.abs(textSize.width * Math.cos(angle)) + Math.abs(textSize.height * Math.sin(angle));
+  const angledHeight = Math.abs(textSize.width * Math.sin(angle)) + Math.abs(textSize.height * Math.cos(angle));
+  return angledWidth <= width && angledHeight <= height;
+}
+
+/** This function finds the best place to clip the text to add an ellipsis.
+ *  This function assumes that the {@link doesTextFit} never returns true for longer text after returning false for
+ *  shorter text.
+ *
+ *  @param text Text to ellipsize if needed
+ *  @param doesTextFit a function that returns whether a string fits inside a container.
+ */
+export function ellipsize(text, doesTextFit) {
+  if (doesTextFit(text)) {
+    return text;
+  }
+  let shortenedText = text;
+  let step = 1;
+  let by = 1 / 2;
+  const graphemeCount = getGraphemeCount(text);
+  let newLength = graphemeCount;
+  let lastLength = graphemeCount;
+  let longestFittingText = null;
+  do {
+    lastLength = newLength;
+    newLength = Math.floor(graphemeCount * by);
+    if (newLength === 0) {
+      break;
+    }
+    shortenedText = sliceUntil(text, newLength).trim();
+    const fits = doesTextFit(shortenedText + ELLIPSIS);
+    step += 1;
+    if (fits) {
+      longestFittingText = shortenedText;
+      by += 1 / 2 ** step;
+    } else {
+      by -= 1 / 2 ** step;
+    }
+  } while (Math.abs(newLength - lastLength) !== 1);
+  return longestFittingText ? longestFittingText + ELLIPSIS : '';
+}

package/internals/geometry.mjs

@@ -0,0 +1,35 @@
+import { warnOnce } from '@mui/x-internals/warning';
+import { deg2rad } from "./angleConversion.mjs";
+const ANGLE_APPROX = 5; // Angle (in deg) for which we approximate the rectangle as perfectly horizontal/vertical
+
+/**
+ * Return the minimal translation along the x-axis to avoid overflow of a rectangle of a given width, height, and rotation.
+ * This assumes that all rectangles have the same height and angle between -90 and 90.
+ * Otherwise it would be problematic because you need the height/width of the next rectangle to do the correct computation.
+ * @param width the side along the x-axis.
+ * @param height the side along the y-axis.
+ * @param angle the rotation in degrees.
+ */
+export function getMinXTranslation(width, height, angle = 0) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (angle > 90 && angle < -90) {
+      warnOnce([`MUI X Charts: It seems you applied an angle larger than 90° or smaller than -90° to an axis text.`, `This could cause some text overlapping.`, `If you encounter a use case where it's needed, please open an issue.`]);
+    }
+  }
+  const standardAngle = Math.min(Math.abs(angle) % 180, Math.abs(Math.abs(angle) % 180 - 180) % 180); // Map from R to [0, 90]
+
+  if (standardAngle < ANGLE_APPROX) {
+    // It's nearly horizontal
+    return width;
+  }
+  if (standardAngle > 90 - ANGLE_APPROX) {
+    // It's nearly vertical
+    return height;
+  }
+  const radAngle = deg2rad(standardAngle);
+  const angleSwich = Math.atan2(height, width);
+  if (radAngle < angleSwich) {
+    return width / Math.cos(radAngle);
+  }
+  return height / Math.sin(radAngle);
+}

package/internals/getBarDimensions.d.mts

@@ -0,0 +1,16 @@
+import type { ChartsXAxisProps, ChartsYAxisProps, ComputedAxis, ScaleName } from "../models/axis.mjs";
+import type { ChartSeriesDefaultized } from "../models/seriesType/config.mjs";
+export declare function getBarDimensions(params: {
+  verticalLayout: boolean;
+  xAxisConfig: ComputedAxis<ScaleName, any, ChartsXAxisProps>;
+  yAxisConfig: ComputedAxis<ScaleName, any, ChartsYAxisProps>;
+  series: ChartSeriesDefaultized<'bar'>;
+  dataIndex: number;
+  numberOfGroups: number;
+  groupIndex: number;
+}): {
+  x: number;
+  y: number;
+  height: number;
+  width: number;
+} | null;

package/internals/getBarDimensions.mjs

@@ -0,0 +1,55 @@
+import { findMinMax } from "./findMinMax.mjs";
+import { getBandSize } from "./getBandSize.mjs";
+function shouldInvertStartCoordinate(verticalLayout, baseValue, reverse) {
+  const isVerticalAndPositive = verticalLayout && baseValue > 0;
+  const isHorizontalAndNegative = !verticalLayout && baseValue < 0;
+  const invertStartCoordinate = isVerticalAndPositive || isHorizontalAndNegative;
+  return reverse ? !invertStartCoordinate : invertStartCoordinate;
+}
+export function getBarDimensions(params) {
+  const {
+    verticalLayout,
+    xAxisConfig,
+    yAxisConfig,
+    series,
+    dataIndex,
+    numberOfGroups,
+    groupIndex
+  } = params;
+  const baseScaleConfig = verticalLayout ? xAxisConfig : yAxisConfig;
+  const reverse = (verticalLayout ? yAxisConfig.reverse : xAxisConfig.reverse) ?? false;
+  const {
+    barWidth,
+    offset
+  } = getBandSize(baseScaleConfig.scale.bandwidth(), numberOfGroups, baseScaleConfig.barGapRatio);
+  const barOffset = groupIndex * (barWidth + offset);
+  const xScale = xAxisConfig.scale;
+  const yScale = yAxisConfig.scale;
+  const baseValue = baseScaleConfig.data[dataIndex];
+  const seriesValue = series.data[dataIndex];
+  if (seriesValue == null) {
+    return null;
+  }
+  const values = series.visibleStackedData[dataIndex];
+  const valueCoordinates = values.map(v => verticalLayout ? yScale(v) : xScale(v));
+  const [minValueCoord, maxValueCoord] = findMinMax(valueCoordinates).map(v => Math.round(v));
+  let barSize = 0;
+  if (seriesValue !== 0) {
+    if (!series.hidden) {
+      barSize = Math.max(series.minBarSize, maxValueCoord - minValueCoord);
+    }
+  }
+  const shouldInvert = shouldInvertStartCoordinate(verticalLayout, seriesValue, reverse);
+  let startCoordinate = 0;
+  if (shouldInvert) {
+    startCoordinate = maxValueCoord - barSize;
+  } else {
+    startCoordinate = minValueCoord;
+  }
+  return {
+    x: verticalLayout ? xScale(baseValue) + barOffset : startCoordinate,
+    y: verticalLayout ? startCoordinate : yScale(baseValue) + barOffset,
+    height: verticalLayout ? barSize : barWidth,
+    width: verticalLayout ? barWidth : barSize
+  };
+}

package/internals/getCurve.d.mts

@@ -0,0 +1,2 @@
+import { type CurveType } from "../models/curve.mjs";
+export declare function getCurveFactory(curveType?: CurveType): import("@mui/x-charts-vendor/d3-shape").CurveFactory;

package/internals/getScale.d.mts

@@ -0,0 +1,3 @@
+import { type NumberValue } from '@mui/x-charts-vendor/d3-scale';
+import { type ContinuousScaleName, type D3ContinuousScale } from "../models/axis.mjs";
+export declare function getScale<Domain extends NumberValue = any, Range = any>(scaleType: ContinuousScaleName, domain: Iterable<Domain>, range: readonly Range[]): D3ContinuousScale<Range, Range>;

package/internals/getScale.mjs

@@ -0,0 +1,20 @@
+import { scaleLog, scalePow, scaleSqrt, scaleTime, scaleUtc, scaleLinear } from '@mui/x-charts-vendor/d3-scale';
+import { scaleSymlog } from "./scales/index.mjs";
+export function getScale(scaleType, domain, range) {
+  switch (scaleType) {
+    case 'log':
+      return scaleLog(domain, range);
+    case 'pow':
+      return scalePow(domain, range);
+    case 'sqrt':
+      return scaleSqrt(domain, range);
+    case 'time':
+      return scaleTime(domain, range);
+    case 'utc':
+      return scaleUtc(domain, range);
+    case 'symlog':
+      return scaleSymlog(domain, range);
+    default:
+      return scaleLinear(domain, range);
+  }
+}

package/internals/getSeriesColorFn.d.mts

@@ -0,0 +1,5 @@
+import { type CommonSeriesType, type ColorCallbackValue } from "../models/seriesType/common.mjs";
+export declare function getSeriesColorFn<TValue>(series: {
+  color: NonNullable<CommonSeriesType<TValue>['color']>;
+  colorGetter?: CommonSeriesType<TValue>['colorGetter'];
+}): (data: ColorCallbackValue<TValue>) => string;