@mui/x-charts 8.13.1 → 8.14.1

package/esm/models/axis.d.ts

@@ -1,4 +1,4 @@
-import type { ScaleBand, ScaleLinear, ScaleLogarithmic, ScaleOrdinal, ScalePoint, ScalePower, ScaleSequential, ScaleThreshold, ScaleTime, ScaleSymLog } from '@mui/x-charts-vendor/d3-scale';
+import type { ScaleBand, ScaleLinear, ScaleLogarithmic, ScaleOrdinal, ScalePoint, ScalePower, ScaleSequential, ScaleThreshold, ScaleTime, ScaleSymLog, NumberValue } from '@mui/x-charts-vendor/d3-scale';
 import { SxProps } from '@mui/system/styleFunctionSx';
 import { type MakeOptional, MakeRequired } from '@mui/x-internals/types';
 import type { DefaultizedZoomOptions } from "../internals/plugins/featurePlugins/useChartCartesianAxis/index.js";
@@ -9,11 +9,15 @@ import { ContinuousColorConfig, OrdinalColorConfig, PiecewiseColorConfig } from
 export type AxisId = string | number;
 export type D3Scale<Domain extends {
   toString(): string;
-} = number | Date | string, Range = number, Output = number> = ScaleBand<Domain> | ScaleSymLog<Range, Output> | ScaleLogarithmic<Range, Output> | ScalePoint<Domain> | ScalePower<Range, Output> | ScaleTime<Range, Output> | ScaleLinear<Range, Output>;
+} = {
+  toString(): string;
+}, Range = number, Output = number> = ScaleBand<Domain> | ScaleSymLog<Range, Output> | ScaleLogarithmic<Range, Output> | ScalePoint<Domain> | ScalePower<Range, Output> | ScaleTime<Range, Output> | ScaleLinear<Range, Output>;
 export type D3ContinuousScale<Range = number, Output = number> = ScaleSymLog<Range, Output> | ScaleLogarithmic<Range, Output> | ScalePower<Range, Output> | ScaleTime<Range, Output> | ScaleLinear<Range, Output>;
 export type D3OrdinalScale<Domain extends {
   toString(): string;
-} = number | Date | string> = ScaleBand<Domain> | ScalePoint<Domain>;
+} = {
+  toString(): string;
+}> = ScaleBand<Domain> | ScalePoint<Domain>;
 export interface ChartsAxisSlots {
   /**
    * Custom component for the axis main line.
@@ -220,7 +224,9 @@ export type AxisGroups = {
 export interface AxisScaleConfig {
   band: {
     scaleType: 'band';
-    scale: ScaleBand<number | Date | string>;
+    scale: ScaleBand<{
+      toString(): string;
+    }>;
     /**
      * The ratio between the space allocated for padding between two categories and the category width.
      * 0 means no gap, and 1 no data.
@@ -237,7 +243,9 @@ export interface AxisScaleConfig {
   } & AxisGroups & Pick<TickParams, 'tickPlacement' | 'tickLabelPlacement'>;
   point: {
     scaleType: 'point';
-    scale: ScalePoint<number | Date | string>;
+    scale: ScalePoint<{
+      toString(): string;
+    }>;
     colorMap?: OrdinalColorConfig | ContinuousColorConfig | PiecewiseColorConfig;
   } & AxisGroups;
   log: {
@@ -363,26 +371,39 @@ export type AxisValueFormatterContext<S extends ScaleName = ScaleName> = {
    */
   tickNumber?: number;
 };
-/**
- * Config that is shared between cartesian and polar axes.
- */
-type CommonAxisConfig<S extends ScaleName = ScaleName, V = any> = {
+type MinMaxConfig<S extends ScaleName = ScaleName> = S extends ContinuousScaleName ? S extends 'utc' | 'time' ? {
   /**
-   * ID used to identify the axis.
-   *
-   * The ID must be unique across all axes in this chart.
+   * The minimal value of the domain.
+   * If not provided, it gets computed to display the entire chart data.
    */
-  id: AxisId;
+  min?: NumberValue;
+  /**
+   * The maximal value of the domain.
+   * If not provided, it gets computed to display the entire chart data.
+   */
+  max?: NumberValue;
+} : {
   /**
    * The minimal value of the domain.
    * If not provided, it gets computed to display the entire chart data.
    */
-  min?: number | Date;
+  min?: number;
   /**
    * The maximal value of the domain.
    * If not provided, it gets computed to display the entire chart data.
    */
-  max?: number | Date;
+  max?: number;
+} : {};
+/**
+ * Config that is shared between cartesian and polar axes.
+ */
+type CommonAxisConfig<S extends ScaleName = ScaleName, V = any> = {
+  /**
+   * ID used to identify the axis.
+   *
+   * The ID must be unique across all axes in this chart.
+   */
+  id: AxisId;
   /**
    * The data used by `'band'` and `'point'` scales.
    */
@@ -429,7 +450,7 @@ export type PolarAxisConfig<S extends ScaleName = ScaleName, V = any, AxisProps
    * @default 0
    */
   offset?: number;
-} & CommonAxisConfig<S, V> & Omit<Partial<AxisProps>, 'axisId'> & Partial<Omit<AxisScaleConfig[S], 'scale'>> & AxisConfigExtension;
+} & CommonAxisConfig<S, V> & MinMaxConfig<S> & Omit<Partial<AxisProps>, 'axisId'> & Partial<Omit<AxisScaleConfig[S], 'scale'>> & AxisConfigExtension;
 /**
  * Use this type for advanced typing. For basic usage, use `XAxis`, `YAxis`, `RotationAxis` or `RadiusAxis`.
  */
@@ -441,7 +462,7 @@ export type AxisConfig<S extends ScaleName = ScaleName, V = any, AxisProps exten
    * @default 0
    */
   offset?: number;
-} & CommonAxisConfig<S, V> & Omit<Partial<AxisProps>, 'axisId'> & Partial<Omit<AxisScaleConfig[S], 'scale'>> & AxisSideConfig<AxisProps> & TickParams & AxisConfigExtension;
+} & CommonAxisConfig<S, V> & MinMaxConfig<S> & Omit<Partial<AxisProps>, 'axisId'> & Partial<Omit<AxisScaleConfig[S], 'scale'>> & AxisSideConfig<AxisProps> & TickParams & AxisConfigExtension;
 export interface AxisConfigExtension {}
 export type PolarAxisDefaultized<S extends ScaleName = ScaleName, V = any, AxisProps extends ChartsAxisProps = ChartsRotationAxisProps | ChartsRadiusAxisProps> = Omit<PolarAxisConfig<S, V, AxisProps>, 'scaleType'> & AxisScaleConfig[S] & AxisScaleComputedConfig[S] & {
   /**
@@ -467,6 +488,7 @@ export declare function isBandScaleConfig(scaleConfig: AxisConfig<ScaleName>): s
 export declare function isPointScaleConfig(scaleConfig: AxisConfig<ScaleName>): scaleConfig is AxisConfig<'point'> & {
   scaleType: 'point';
 };
+export declare function isContinuousScaleConfig(scaleConfig: AxisConfig<ScaleName>): scaleConfig is AxisConfig<ContinuousScaleName>;
 export declare function isSymlogScaleConfig(scaleConfig: AxisConfig<ScaleName>): scaleConfig is AxisConfig<'symlog'> & {
   scaleType: 'symlog';
 };

package/esm/models/axis.js

@@ -17,6 +17,9 @@ export function isBandScaleConfig(scaleConfig) {
 export function isPointScaleConfig(scaleConfig) {
   return scaleConfig.scaleType === 'point';
 }
+export function isContinuousScaleConfig(scaleConfig) {
+  return scaleConfig.scaleType !== 'point' && scaleConfig.scaleType !== 'band';
+}
 export function isSymlogScaleConfig(scaleConfig) {
   return scaleConfig.scaleType === 'symlog';
 }

package/esm/models/seriesType/scatter.d.ts

@@ -23,6 +23,8 @@ export interface ScatterSeriesType extends CommonSeriesType<ScatterValueType | n
   /**
    * If true, the interaction will not use element hover for this series.
    * @default false
+   * @deprecated This prop will be removed in a future version because it is ambiguous. You can select what to disable
+   *             on hover by disabling the highlight or the tooltip separately.
    */
   disableHover?: boolean;
   /**

package/esm/themeAugmentation/components.d.ts

@@ -62,6 +62,9 @@ export interface ChartsComponents<Theme = unknown> {
     defaultProps?: ComponentsProps['MuiScatterChart'];
   };
   MuiScatter?: {};
+  MuiGauge?: {
+    styleOverrides?: ComponentsOverrides<Theme>['MuiGauge'];
+  };
 }
 declare module '@mui/material/styles' {
   interface Components<Theme = unknown> extends ChartsComponents<Theme> {}

package/esm/themeAugmentation/overrides.d.ts

@@ -1,3 +1,4 @@
+import { GaugeClassKey } from "../Gauge/index.js";
 import { BarLabelClassKey } from "../BarChart/index.js";
 import { BarElementClassKey } from "../BarChart/barElementClasses.js";
 import { ChartsAxisHighlightClassKey } from "../ChartsAxisHighlight/index.js";
@@ -18,6 +19,7 @@ export interface ChartsComponentNameToClassKey {
   MuiAreaElement: AreaElementClassKey;
   MuiLineElement: LineElementClassKey;
   MuiMarkElement: MarkElementClassKey;
+  MuiGauge: GaugeClassKey;
 }
 declare module '@mui/material/styles' {
   interface ComponentNameToClassKey extends ChartsComponentNameToClassKey {}

package/hooks/animation/useAnimate.js

@@ -1,4 +1,5 @@
 "use strict";
+'use client';
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
@@ -41,14 +42,14 @@ function useAnimate(props, {
   ref
 }) {
   const transform = transformProps ?? (p => p);
-  const animateRef = (0, _useAnimateInternal.useAnimateInternal)(props, {
+  const [animateRef, lastInterpolatedProps] = (0, _useAnimateInternal.useAnimateInternal)(props, {
     initialProps,
     createInterpolator,
     applyProps: (element, animatedProps) => applyProps(element, transform(animatedProps)),
     skip
   });
-  const usedProps = skip ? props : initialProps;
-  return (0, _extends2.default)({}, transformProps(usedProps), {
+  const usedProps = skip ? transformProps(props) : transformProps(lastInterpolatedProps);
+  return (0, _extends2.default)({}, usedProps, {
     ref: (0, _useForkRef.default)(animateRef, ref)
   });
 }

package/hooks/useScale.d.ts

@@ -5,7 +5,11 @@ import { AxisId, AxisScaleConfig, D3Scale, ScaleName } from "../models/axis.js";
  * @param {D3Scale} scale The scale to use
  * @returns {(value: any) => number} A function that map value to their position
  */
-export declare function getValueToPositionMapper(scale: D3Scale): (value: any) => number;
+export declare function getValueToPositionMapper<Domain extends {
+  toString(): string;
+} = {
+  toString(): string;
+}, Range = number>(scale: D3Scale<Domain, Range>): (value: any) => number;
 /**
  * Get the X scale.
  *

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts v8.13.1
+ * @mui/x-charts v8.14.1
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/Flatbush.bench.d.ts

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

package/internals/Flatbush.bench.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _Flatbush = require("./Flatbush");
+const data = [],
+  n = 1_000_000;
+
+// Generate and position the datapoints in a tangent wave pattern
+for (let i = 0; i < n; i += 1) {
+  const theta = Math.random() * 2 * Math.PI;
+  const radius = Math.pow(Math.random(), 2) * 100;
+  const waveDeviation = (Math.random() - 0.5) * 70;
+  const waveValue = Math.tan(theta) * waveDeviation;
+  data.push({
+    x: 50 + (radius + waveValue) * Math.cos(theta),
+    y: 50 + (radius + waveValue) * Math.sin(theta)
+  });
+}
+const flatbush1M = new _Flatbush.Flatbush(data.length);
+for (let i = 0; i < data.length; i += 1) {
+  flatbush1M.add(data[i].x, data[i].y);
+}
+flatbush1M.finish();
+(0, _vitest.describe)('Flatbush benchmarks', () => {
+  (0, _vitest.describe)('add + finish', () => {
+    (0, _vitest.bench)('add 1M points + finish', () => {
+      const flatbush = new _Flatbush.Flatbush(data.length);
+      for (let i = 0; i < data.length; i += 1) {
+        flatbush.add(data[i].x, data[i].y);
+      }
+      flatbush.finish();
+    });
+  });
+  (0, _vitest.describe)('search 1M points', () => {
+    (0, _vitest.bench)('search 1M points', () => {
+      flatbush1M.search(0.4, 0.4, 0.6, 0.6);
+    });
+  });
+  (0, _vitest.describe)('neighbors 1M points', () => {
+    (0, _vitest.bench)('neighbors 1M points', () => {
+      flatbush1M.neighbors(0.5, 0.5, 1, 0.04, undefined);
+    });
+  });
+});

package/internals/Flatbush.d.ts

@@ -0,0 +1,63 @@
+import FlatQueue from 'flatqueue';
+type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+export declare class Flatbush {
+  _queue: FlatQueue<number>;
+  _boxes: TypedArrayConstructor;
+  _indices: Uint16Array | Uint32Array;
+  data: ArrayBufferLike;
+  numItems: number;
+  nodeSize: number;
+  _levelBounds: number[];
+  byteOffset: number;
+  /**
+   * Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
+   * @param {ArrayBufferLike} data
+   * @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
+   * @returns {Flatbush} index
+   */
+  static from(data: any, byteOffset?: number): Flatbush;
+  /**
+   * Create a Flatbush index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=16] Size of the tree node (16 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
+   * @param {ArrayBufferLike} [data] (Only used internally)
+   * @param {number} [byteOffset=0] (Only used internally)
+   */
+  constructor(numItems: number, nodeSize?: number, ArrayType?: TypedArrayConstructor, ArrayBufferType?: ArrayBufferConstructor | SharedArrayBufferConstructor, data?: ArrayBufferLike, byteOffset?: number);
+  /**
+   * Add a given rectangle to the index.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number} A zero-based, incremental number that represents the newly added rectangle.
+   */
+  add(minX: any, minY: any, maxX?: any, maxY?: any): number;
+  /** Perform indexing of the added rectangles. */
+  finish(): void;
+  /**
+   * Search the index by a bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array containing the index, the x coordinate and the y coordinate of the points intersecting or touching the given bounding box.
+   */
+  search(minX: number, minY: number, maxX: number, maxY: number, filterFn?: (index: number) => boolean): number[];
+  /**
+   * Search items in order of distance from the given point.
+   * @param x
+   * @param y
+   * @param [maxResults=Infinity]
+   * @param maxDistSq
+   * @param [filterFn] An optional function for filtering the results.
+   * @param [sqDistFn] An optional function to calculate squared distance from the point to the item.
+   * @returns {number[]} An array of indices of items found.
+   */
+  neighbors(x: any, y: any, maxResults?: number, maxDistSq?: number, filterFn?: (index: number) => boolean, sqDistFn?: typeof sqDist): number[];
+}
+declare function sqDist(dx: number, dy: number): number;
+export {};