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

package/internals/components/NotRendered.mjs

@@ -0,0 +1,11 @@
+import _formatErrorMessage from "@mui/x-internals/formatErrorMessage";
+/**
+ * This component is used to assert that a certain component should not be rendered.
+ * It is used in cases where we want to apply styles to a component that is not rendered because we use the `as` prop (introduced by `styled`) to replace the rendered component.
+ * We need it because we don't know the component that will be rendered at the time of writing the styles.
+ *
+ * @param _props Not used
+ */
+export function NotRendered(_props) {
+  throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X Charts: Failed assertion - this component should not be rendered. ' + 'This is an internal component used for styling purposes only. ' + 'If you see this error, there may be a configuration issue with styled components.' : _formatErrorMessage(31));
+}

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/configInit.js

@@ -1,16 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.polarSeriesTypes = exports.cartesianSeriesTypes = void 0;
+var _formatErrorMessage2 = _interopRequireDefault(require("@mui/x-internals/formatErrorMessage"));
 let cartesianInstance;
 let polarInstance;
 class CartesianSeriesTypes {
   types = new Set();
   constructor() {
     if (cartesianInstance) {
-      throw new Error('You can only create one instance!');
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X Charts: Only one CartesianSeriesTypes instance can be created. ' + 'This is a singleton class used internally for series type registration. ' + 'Use the existing instance instead of creating a new one.' : (0, _formatErrorMessage2.default)(24));
     }
     cartesianInstance = this.types;
   }
@@ -25,7 +27,7 @@ class PolarSeriesTypes {
   types = new Set();
   constructor() {
     if (polarInstance) {
-      throw new Error('You can only create one instance!');
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X Charts: Only one PolarSeriesTypes instance can be created. ' + 'This is a singleton class used internally for series type registration. ' + 'Use the existing instance instead of creating a new one.' : (0, _formatErrorMessage2.default)(25));
     }
     polarInstance = this.types;
   }

package/internals/configInit.mjs

@@ -0,0 +1,39 @@
+import _formatErrorMessage from "@mui/x-internals/formatErrorMessage";
+let cartesianInstance;
+let polarInstance;
+class CartesianSeriesTypes {
+  types = (() => new Set())();
+  constructor() {
+    if (cartesianInstance) {
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X Charts: Only one CartesianSeriesTypes instance can be created. ' + 'This is a singleton class used internally for series type registration. ' + 'Use the existing instance instead of creating a new one.' : _formatErrorMessage(24));
+    }
+    cartesianInstance = this.types;
+  }
+  addType(value) {
+    this.types.add(value);
+  }
+  getTypes() {
+    return this.types;
+  }
+}
+class PolarSeriesTypes {
+  types = (() => new Set())();
+  constructor() {
+    if (polarInstance) {
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X Charts: Only one PolarSeriesTypes instance can be created. ' + 'This is a singleton class used internally for series type registration. ' + 'Use the existing instance instead of creating a new one.' : _formatErrorMessage(25));
+    }
+    polarInstance = this.types;
+  }
+  addType(value) {
+    this.types.add(value);
+  }
+  getTypes() {
+    return this.types;
+  }
+}
+export const cartesianSeriesTypes = new CartesianSeriesTypes();
+cartesianSeriesTypes.addType('bar');
+cartesianSeriesTypes.addType('line');
+cartesianSeriesTypes.addType('scatter');
+export const polarSeriesTypes = new PolarSeriesTypes();
+polarSeriesTypes.addType('radar');

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/createCommonKeyboardFocusHandler.d.mts

@@ -0,0 +1,15 @@
+import type { ChartSeriesType } from "../models/seriesType/config.mjs";
+/**
+ * Create a keyboard focus handler for common use cases where focused item are defined by the series is and data index.
+ */
+export declare function createCommonKeyboardFocusHandler<TSeriesType extends Exclude<ChartSeriesType, 'sankey'>, TInputSeriesType extends Exclude<ChartSeriesType, 'sankey'> = TSeriesType>(outSeriesTypes: Set<TSeriesType>, allowCycles?: boolean): (event: KeyboardEvent) => ((currentItem: import("../index.mjs").FocusedItemIdentifier<TInputSeriesType> | null, state: {
+  series: {
+    defaultizedSeries: import("./plugins/corePlugins/useChartSeries/useChartSeries.types.mjs").DefaultizedSeriesGroups<TInputSeriesType>;
+    idToType: import("./index.mjs").SeriesIdToType;
+    dataset?: Readonly<import("./index.mjs").DatasetType>;
+  };
+}) => {
+  type: TSeriesType;
+  seriesId: import("../index.mjs").SeriesId;
+  dataIndex: number;
+} | null) | null;

package/internals/createCommonKeyboardFocusHandler.d.ts

@@ -0,0 +1,15 @@
+import type { ChartSeriesType } from "../models/seriesType/config.js";
+/**
+ * Create a keyboard focus handler for common use cases where focused item are defined by the series is and data index.
+ */
+export declare function createCommonKeyboardFocusHandler<TSeriesType extends Exclude<ChartSeriesType, 'sankey'>, TInputSeriesType extends Exclude<ChartSeriesType, 'sankey'> = TSeriesType>(outSeriesTypes: Set<TSeriesType>, allowCycles?: boolean): (event: KeyboardEvent) => ((currentItem: import("../index.js").FocusedItemIdentifier<TInputSeriesType> | null, state: {
+  series: {
+    defaultizedSeries: import("./plugins/corePlugins/useChartSeries/useChartSeries.types.js").DefaultizedSeriesGroups<TInputSeriesType>;
+    idToType: import("./index.js").SeriesIdToType;
+    dataset?: Readonly<import("./index.js").DatasetType>;
+  };
+}) => {
+  type: TSeriesType;
+  seriesId: import("../index.js").SeriesId;
+  dataIndex: number;
+} | null) | null;

package/internals/createCommonKeyboardFocusHandler.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCommonKeyboardFocusHandler = createCommonKeyboardFocusHandler;
+var _commonNextFocusItem = require("./commonNextFocusItem");
+/**
+ * Create a keyboard focus handler for common use cases where focused item are defined by the series is and data index.
+ */
+function createCommonKeyboardFocusHandler(outSeriesTypes, allowCycles) {
+  const keyboardFocusHandler = event => {
+    switch (event.key) {
+      case 'ArrowRight':
+        return (0, _commonNextFocusItem.createGetNextIndexFocusedItem)(outSeriesTypes, allowCycles);
+      case 'ArrowLeft':
+        return (0, _commonNextFocusItem.createGetPreviousIndexFocusedItem)(outSeriesTypes, allowCycles);
+      case 'ArrowDown':
+        return (0, _commonNextFocusItem.createGetPreviousSeriesFocusedItem)(outSeriesTypes);
+      case 'ArrowUp':
+        return (0, _commonNextFocusItem.createGetNextSeriesFocusedItem)(outSeriesTypes);
+      default:
+        return null;
+    }
+  };
+  return keyboardFocusHandler;
+}

package/internals/createCommonKeyboardFocusHandler.mjs

@@ -0,0 +1,22 @@
+import { createGetNextIndexFocusedItem, createGetPreviousIndexFocusedItem, createGetNextSeriesFocusedItem, createGetPreviousSeriesFocusedItem } from "./commonNextFocusItem.mjs";
+
+/**
+ * Create a keyboard focus handler for common use cases where focused item are defined by the series is and data index.
+ */
+export function createCommonKeyboardFocusHandler(outSeriesTypes, allowCycles) {
+  const keyboardFocusHandler = event => {
+    switch (event.key) {
+      case 'ArrowRight':
+        return createGetNextIndexFocusedItem(outSeriesTypes, allowCycles);
+      case 'ArrowLeft':
+        return createGetPreviousIndexFocusedItem(outSeriesTypes, allowCycles);
+      case 'ArrowDown':
+        return createGetPreviousSeriesFocusedItem(outSeriesTypes);
+      case 'ArrowUp':
+        return createGetNextSeriesFocusedItem(outSeriesTypes);
+      default:
+        return null;
+    }
+  };
+  return keyboardFocusHandler;
+}

package/internals/createGetBarDimensions.d.mts

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

package/internals/createGetBarDimensions.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 createGetBarDimensions(params) {
+  const {
+    verticalLayout,
+    xAxisConfig,
+    yAxisConfig,
+    series,
+    numberOfGroups
+  } = 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 xScale = xAxisConfig.scale;
+  const yScale = yAxisConfig.scale;
+  return function getBarDimensions(dataIndex, groupIndex) {
+    const barOffset = groupIndex * (barWidth + offset);
+    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/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/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/getGraphemeCount.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getGraphemeCount = void 0;
-const segmenter = typeof window !== 'undefined' && 'Intl' in window && 'Segmenter' in Intl ? new Intl.Segmenter(undefined, {
+const segmenter = typeof window !== 'undefined' && 'Intl' in window && 'Segmenter' in Intl ?
+// eslint-disable-next-line compat/compat
+new Intl.Segmenter(undefined, {
   granularity: 'grapheme'
 }) : null;
 function getGraphemeCountFallback(text) {

package/internals/getGraphemeCount.mjs

@@ -0,0 +1,21 @@
+const segmenter = typeof window !== 'undefined' && 'Intl' in window && 'Segmenter' in Intl ?
+// eslint-disable-next-line compat/compat
+new Intl.Segmenter(undefined, {
+  granularity: 'grapheme'
+}) : null;
+function getGraphemeCountFallback(text) {
+  return text.length;
+}
+function getGraphemeCountModern(text) {
+  const segments = segmenter.segment(text);
+  let count = 0;
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/naming-convention,no-underscore-dangle
+  for (const _unused of segments) {
+    count += 1;
+  }
+  return count;
+}
+
+/** Returns the number of graphemes (basically characters) present in {@link text}. */
+export const getGraphemeCount = segmenter ? getGraphemeCountModern : getGraphemeCountFallback;

package/internals/getPercentageValue.js

@@ -1,9 +1,11 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getPercentageValue = getPercentageValue;
+var _formatErrorMessage2 = _interopRequireDefault(require("@mui/x-internals/formatErrorMessage"));
 /**
  * Helper that converts values and percentages into values.
  * @param value The value provided by the developer. Can either be a number or a string with '%' or 'px'.
@@ -30,5 +32,5 @@ function getPercentageValue(value, refValue) {
       return val;
     }
   }
-  throw new Error(`MUI X Charts: Received an unknown value "${value}". It should be a number, or a string with a percentage value.`);
+  throw new Error(process.env.NODE_ENV !== "production" ? `MUI X Charts: Received an unknown value "${value}". ` + 'Values must be a number, a string with a percentage (e.g., "50%"), or a string with pixels (e.g., "100px"). ' + 'Provide a valid number or string format.' : (0, _formatErrorMessage2.default)(26, value));
 }

package/internals/getPercentageValue.mjs

@@ -0,0 +1,29 @@
+import _formatErrorMessage from "@mui/x-internals/formatErrorMessage";
+/**
+ * Helper that converts values and percentages into values.
+ * @param value The value provided by the developer. Can either be a number or a string with '%' or 'px'.
+ * @param refValue The numerical value associated to 100%.
+ * @returns The numerical value associated to the provided value.
+ */
+export function getPercentageValue(value, refValue) {
+  if (typeof value === 'number') {
+    return value;
+  }
+  if (value === '100%') {
+    // Avoid potential rounding issues
+    return refValue;
+  }
+  if (value.endsWith('%')) {
+    const percentage = Number.parseFloat(value.slice(0, value.length - 1));
+    if (!Number.isNaN(percentage)) {
+      return percentage * refValue / 100;
+    }
+  }
+  if (value.endsWith('px')) {
+    const val = Number.parseFloat(value.slice(0, value.length - 2));
+    if (!Number.isNaN(val)) {
+      return val;
+    }
+  }
+  throw new Error(process.env.NODE_ENV !== "production" ? `MUI X Charts: Received an unknown value "${value}". ` + 'Values must be a number, a string with a percentage (e.g., "50%"), or a string with pixels (e.g., "100px"). ' + 'Provide a valid number or string format.' : _formatErrorMessage(26, value));
+}

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,6 @@
+import { type CommonSeriesType, type ColorCallbackValue } from "../models/seriesType/common.mjs";
+import { type ChartSeriesType } from "../models/seriesType/config.mjs";
+export declare function getSeriesColorFn<TValue>(series: {
+  color: NonNullable<CommonSeriesType<TValue, ChartSeriesType>['color']>;
+  colorGetter?: CommonSeriesType<TValue, ChartSeriesType>['colorGetter'];
+}): (data: ColorCallbackValue<TValue>) => string;

package/internals/getSurfacePoint.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Transform mouse event position to coordinates inside the SVG surface or the layer container.
+ * @param element The SVG surface or the layer container
+ * @param event The mouseEvent to transform
+ */
+export declare function getSurfacePoint(element: Element, event: Pick<MouseEvent, 'clientX' | 'clientY'>): DOMPoint;

package/internals/getSurfacePoint.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transform mouse event position to coordinates inside the SVG surface or the layer container.
+ * @param element The SVG surface or the layer container
+ * @param event The mouseEvent to transform
+ */
+export declare function getSurfacePoint(element: Element, event: Pick<MouseEvent, 'clientX' | 'clientY'>): DOMPoint;

package/internals/getSurfacePoint.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSurfacePoint = getSurfacePoint;
+/**
+ * Transform mouse event position to coordinates inside the SVG surface or the layer container.
+ * @param element The SVG surface or the layer container
+ * @param event The mouseEvent to transform
+ */
+function getSurfacePoint(element, event) {
+  const rect = element.getBoundingClientRect();
+  const style = getComputedStyle(element);
+  const transform = new DOMMatrix(style.transform);
+  const point = new DOMPoint(event.clientX - rect.left, event.clientY - rect.top);
+  return point.matrixTransform(transform.inverse());
+}

package/internals/getSurfacePoint.mjs

@@ -0,0 +1,12 @@
+/**
+ * Transform mouse event position to coordinates inside the SVG surface or the layer container.
+ * @param element The SVG surface or the layer container
+ * @param event The mouseEvent to transform
+ */
+export function getSurfacePoint(element, event) {
+  const rect = element.getBoundingClientRect();
+  const style = getComputedStyle(element);
+  const transform = new DOMMatrix(style.transform);
+  const point = new DOMPoint(event.clientX - rect.left, event.clientY - rect.top);
+  return point.matrixTransform(transform.inverse());
+}

package/internals/getWordsByLines.mjs

@@ -0,0 +1,14 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { getStringSize } from "./domUtils.mjs";
+export function getWordsByLines({
+  style,
+  needsComputation,
+  text
+}) {
+  return text.split('\n').map(subText => _extends({
+    text: subText
+  }, needsComputation ? getStringSize(subText, style) : {
+    width: 0,
+    height: 0
+  }));
+}

package/internals/identifierCleaner.d.mts

@@ -0,0 +1,11 @@
+import type { SeriesId, SeriesItemIdentifierWithType } from "../models/index.mjs";
+import type { ChartSeriesType } from "../models/seriesType/config.mjs";
+/**
+ * Cleans an identifier by extracting only type, seriesId, and dataIndex properties.
+ * This is the common cleaner for most series types (bar, line, pie, scatter, radar, etc.).
+ */
+export declare const identifierCleanerSeriesIdDataIndex: <T extends ChartSeriesType>(identifier: {
+  type: T;
+  seriesId: SeriesId;
+  dataIndex?: number;
+}) => SeriesItemIdentifierWithType<T>;

package/internals/identifierCleaner.d.ts

@@ -1,4 +1,4 @@
-import type { SeriesId, SeriesItemIdentifier } from "../models/index.js";
+import type { SeriesId, SeriesItemIdentifierWithType } from "../models/index.js";
 import type { ChartSeriesType } from "../models/seriesType/config.js";
 /**
  * Cleans an identifier by extracting only type, seriesId, and dataIndex properties.
@@ -8,4 +8,4 @@ export declare const identifierCleanerSeriesIdDataIndex: <T extends ChartSeriesT
   type: T;
   seriesId: SeriesId;
   dataIndex?: number;
-}) => SeriesItemIdentifier<T>;
+}) => SeriesItemIdentifierWithType<T>;

package/internals/identifierSerializer.d.mts

@@ -0,0 +1,9 @@
+import type { SeriesId } from "../models/index.mjs";
+export declare const typeSerializer: (type: string) => string;
+export declare const seriesIdSerializer: (id: SeriesId) => string;
+export declare const dataIndexSerializer: (dataIndex?: number) => string;
+export declare const identifierSerializerSeriesIdDataIndex: (identifier: {
+  type: string;
+  seriesId: SeriesId;
+  dataIndex?: number;
+}) => string;