@mui/x-charts 9.4.0 → 9.6.0

package/ScatterChart/ScatterPlot.d.ts

@@ -8,8 +8,15 @@ export interface ScatterPlotSlotProps extends ScatterSlotProps {
   scatter?: Partial<ScatterProps> & ScatterPropsOverrides;
 }
 export type RendererType = 'svg-single' | 'svg-batch';
-export interface ScatterPlotProps extends Pick<ScatterProps, 'onItemClick' | 'classes'> {
+export interface ScatterPlotProps extends Pick<ScatterProps, 'classes'> {
   className?: string;
+  /**
+   * Callback fired when a marker is clicked directly.
+   * For closest-point clicks (the `ScatterChart` default), pass `onItemClick` to the chart container instead.
+   * @param {MouseEvent} event Mouse event recorded on the `<svg/>` element.
+   * @param {ScatterItemIdentifier} scatterItemIdentifier The scatter item identifier.
+   */
+  onItemClick?: ScatterProps['onItemClick'];
   /**
    * Overridable component slots.
    * @default {}
@@ -22,13 +29,15 @@ export interface ScatterPlotProps extends Pick<ScatterProps, 'onItemClick' | 'cl
   slotProps?: ScatterPlotSlotProps;
   /**
    * The type of renderer to use for the scatter plot.
-   * - `svg-single`: Renders every scatter item in a `<circle />` element.
+   * - `svg-single`: Renders every scatter item in a `<circle />` element, synchronously.
+   * - `svg-progressive`: Renders every scatter item in a `<circle />` element, in progressive batches that paint over several animation frames to keep the main thread responsive.
    * - `svg-batch`: Batch renders scatter items in `<path />` elements for better performance with large datasets, at the cost of some limitations.
    *                Read more: https://mui.com/x/react-charts/scatter/#performance
    *
+   * When not set, defaults to `svg-single`. Enable the `progressiveRendering` experimental feature to auto-select `svg-progressive` above an internal point-count threshold; this will become the default in the next major version.
    * @default 'svg-single'
    */
-  renderer?: RendererType;
+  renderer?: RendererType | 'svg-progressive';
 }
 /**
  * Demos:

package/ScatterChart/ScatterPlot.js

@@ -19,8 +19,13 @@ var _useZAxis = require("../hooks/useZAxis");
 var _seriesConfig = require("./seriesConfig");
 var _getMarkerSize = _interopRequireDefault(require("./seriesConfig/getMarkerSize"));
 var _BatchScatter = require("./BatchScatter");
+var _ScatterAsync = require("./async/ScatterAsync");
 var _scatterClasses = require("./scatterClasses");
+var _ChartsProvider = require("../context/ChartsProvider");
+var _useStore = require("../internals/store/useStore");
+var _useProgressiveRendering = require("../internals/plugins/featurePlugins/useProgressiveRendering");
 var _jsxRuntime = require("react/jsx-runtime");
+const EMPTY_SERIES_IDS = [];
 const ScatterPlotRoot = (0, _styles.styled)('g', {
   name: 'MuiScatterPlot',
   slot: 'Root'
@@ -61,6 +66,14 @@ function ScatterPlot(props) {
   const classes = (0, _scatterClasses.useUtilityClasses)({
     classes: inClasses
   });
+  const {
+    instance
+  } = (0, _ChartsProvider.useChartsContext)();
+  const store = (0, _useStore.useStore)();
+  const plotId = React.useId();
+  const seriesIds = seriesData?.seriesOrder ?? EMPTY_SERIES_IDS;
+  const isProgressive = store.use(_useProgressiveRendering.selectorShouldUseProgressiveRenderer, seriesIds, renderer);
+  React.useEffect(() => instance.registerProgressivePlan(plotId, seriesIds, renderer), [instance, plotId, seriesIds, renderer]);
   if (seriesData === undefined) {
     return null;
   }
@@ -71,7 +84,14 @@ function ScatterPlot(props) {
   const defaultXAxisId = xAxisIds[0];
   const defaultYAxisId = yAxisIds[0];
   const defaultZAxisId = zAxisIds[0];
-  const DefaultScatterItems = renderer === 'svg-batch' ? _BatchScatter.BatchScatter : _Scatter.Scatter;
+  let DefaultScatterItems;
+  if (renderer === 'svg-batch') {
+    DefaultScatterItems = _BatchScatter.BatchScatter;
+  } else if (isProgressive) {
+    DefaultScatterItems = _ScatterAsync.ScatterAsync;
+  } else {
+    DefaultScatterItems = _Scatter.Scatter;
+  }
   const ScatterItems = slots?.scatter ?? DefaultScatterItems;
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(ScatterPlotRoot, {
     className: (0, _clsx.default)(classes.root, className),
@@ -107,26 +127,31 @@ function ScatterPlot(props) {
     })
   });
 }
-process.env.NODE_ENV !== "production" ? ScatterPlot.propTypes = {
+process.env.NODE_ENV !== "production" ? ScatterPlot.propTypes /* remove-proptypes */ = {
   // ----------------------------- Warning --------------------------------
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
+  classes: _propTypes.default.object,
+  className: _propTypes.default.string,
   /**
-   * Callback fired when clicking on a scatter item.
+   * Callback fired when a marker is clicked directly.
+   * For closest-point clicks (the `ScatterChart` default), pass `onItemClick` to the chart container instead.
    * @param {MouseEvent} event Mouse event recorded on the `<svg/>` element.
    * @param {ScatterItemIdentifier} scatterItemIdentifier The scatter item identifier.
    */
   onItemClick: _propTypes.default.func,
   /**
    * The type of renderer to use for the scatter plot.
-   * - `svg-single`: Renders every scatter item in a `<circle />` element.
+   * - `svg-single`: Renders every scatter item in a `<circle />` element, synchronously.
+   * - `svg-progressive`: Renders every scatter item in a `<circle />` element, in progressive batches that paint over several animation frames to keep the main thread responsive.
    * - `svg-batch`: Batch renders scatter items in `<path />` elements for better performance with large datasets, at the cost of some limitations.
    *                Read more: https://mui.com/x/react-charts/scatter/#performance
    *
+   * When not set, defaults to `svg-single`. Enable the `progressiveRendering` experimental feature to auto-select `svg-progressive` above an internal point-count threshold; this will become the default in the next major version.
    * @default 'svg-single'
    */
-  renderer: _propTypes.default.oneOf(['svg-batch', 'svg-single']),
+  renderer: _propTypes.default.oneOf(['svg-batch', 'svg-progressive', 'svg-single']),
   /**
    * The props used for each component slot.
    * @default {}

package/ScatterChart/ScatterPlot.mjs

@@ -12,8 +12,13 @@ import { useZAxes } from "../hooks/useZAxis.mjs";
 import { scatterSeriesConfig } from "./seriesConfig/index.mjs";
 import getMarkerSize from "./seriesConfig/getMarkerSize.mjs";
 import { BatchScatter } from "./BatchScatter.mjs";
+import { ScatterAsync } from "./async/ScatterAsync.mjs";
 import { useUtilityClasses } from "./scatterClasses.mjs";
+import { useChartsContext } from "../context/ChartsProvider/index.mjs";
+import { useStore } from "../internals/store/useStore.mjs";
+import { selectorShouldUseProgressiveRenderer } from "../internals/plugins/featurePlugins/useProgressiveRendering/index.mjs";
 import { jsx as _jsx } from "react/jsx-runtime";
+const EMPTY_SERIES_IDS = [];
 const ScatterPlotRoot = styled('g', {
   name: 'MuiScatterPlot',
   slot: 'Root'
@@ -54,6 +59,14 @@ function ScatterPlot(props) {
   const classes = useUtilityClasses({
     classes: inClasses
   });
+  const {
+    instance
+  } = useChartsContext();
+  const store = useStore();
+  const plotId = React.useId();
+  const seriesIds = seriesData?.seriesOrder ?? EMPTY_SERIES_IDS;
+  const isProgressive = store.use(selectorShouldUseProgressiveRenderer, seriesIds, renderer);
+  React.useEffect(() => instance.registerProgressivePlan(plotId, seriesIds, renderer), [instance, plotId, seriesIds, renderer]);
   if (seriesData === undefined) {
     return null;
   }
@@ -64,7 +77,14 @@ function ScatterPlot(props) {
   const defaultXAxisId = xAxisIds[0];
   const defaultYAxisId = yAxisIds[0];
   const defaultZAxisId = zAxisIds[0];
-  const DefaultScatterItems = renderer === 'svg-batch' ? BatchScatter : Scatter;
+  let DefaultScatterItems;
+  if (renderer === 'svg-batch') {
+    DefaultScatterItems = BatchScatter;
+  } else if (isProgressive) {
+    DefaultScatterItems = ScatterAsync;
+  } else {
+    DefaultScatterItems = Scatter;
+  }
   const ScatterItems = slots?.scatter ?? DefaultScatterItems;
   return /*#__PURE__*/_jsx(ScatterPlotRoot, {
     className: clsx(classes.root, className),
@@ -100,26 +120,31 @@ function ScatterPlot(props) {
     })
   });
 }
-process.env.NODE_ENV !== "production" ? ScatterPlot.propTypes = {
+process.env.NODE_ENV !== "production" ? ScatterPlot.propTypes /* remove-proptypes */ = {
   // ----------------------------- Warning --------------------------------
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "pnpm proptypes"  |
   // ----------------------------------------------------------------------
+  classes: PropTypes.object,
+  className: PropTypes.string,
   /**
-   * Callback fired when clicking on a scatter item.
+   * Callback fired when a marker is clicked directly.
+   * For closest-point clicks (the `ScatterChart` default), pass `onItemClick` to the chart container instead.
    * @param {MouseEvent} event Mouse event recorded on the `<svg/>` element.
    * @param {ScatterItemIdentifier} scatterItemIdentifier The scatter item identifier.
    */
   onItemClick: PropTypes.func,
   /**
    * The type of renderer to use for the scatter plot.
-   * - `svg-single`: Renders every scatter item in a `<circle />` element.
+   * - `svg-single`: Renders every scatter item in a `<circle />` element, synchronously.
+   * - `svg-progressive`: Renders every scatter item in a `<circle />` element, in progressive batches that paint over several animation frames to keep the main thread responsive.
    * - `svg-batch`: Batch renders scatter items in `<path />` elements for better performance with large datasets, at the cost of some limitations.
    *                Read more: https://mui.com/x/react-charts/scatter/#performance
    *
+   * When not set, defaults to `svg-single`. Enable the `progressiveRendering` experimental feature to auto-select `svg-progressive` above an internal point-count threshold; this will become the default in the next major version.
    * @default 'svg-single'
    */
-  renderer: PropTypes.oneOf(['svg-batch', 'svg-single']),
+  renderer: PropTypes.oneOf(['svg-batch', 'svg-progressive', 'svg-single']),
   /**
    * The props used for each component slot.
    * @default {}

package/ScatterChart/async/ScatterAsync.d.mts

@@ -0,0 +1,9 @@
+import { type ScatterProps } from "../Scatter.mjs";
+/**
+ * @ignore - internal component.
+ */
+declare function ScatterAsync(props: ScatterProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ScatterAsync {
+  var propTypes: any;
+}
+export { ScatterAsync };

package/ScatterChart/async/ScatterAsync.d.ts

@@ -0,0 +1,9 @@
+import { type ScatterProps } from "../Scatter.js";
+/**
+ * @ignore - internal component.
+ */
+declare function ScatterAsync(props: ScatterProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ScatterAsync {
+  var propTypes: any;
+}
+export { ScatterAsync };

package/ScatterChart/async/ScatterAsync.js

@@ -0,0 +1,71 @@
+"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.ScatterAsync = ScatterAsync;
+var React = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _ScatterAsyncBatch = require("./ScatterAsyncBatch");
+var _useStore = require("../../internals/store/useStore");
+var _useProgressiveRendering = require("../../internals/plugins/featurePlugins/useProgressiveRendering");
+var _scatterRenderData = require("./scatterRenderData.selectors");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * @ignore - internal component.
+ */function ScatterAsync(props) {
+  const {
+    series,
+    colorGetter,
+    onItemClick,
+    slots,
+    slotProps,
+    classes
+  } = props;
+  const store = (0, _useStore.useStore)();
+  const batchSize = store.use(_useProgressiveRendering.selectorProgressiveBatchSize);
+  const revealedBatches = store.use(_useProgressiveRendering.selectorProgressiveSeriesRevealedBatches, series.id);
+  // Size batches by the number of *visible* points so that zooming in (which
+  // shrinks the filtered set in the selector) collapses the progressive wave
+  // into a single tick once everything fits in one batch.
+  const renderData = store.use(_scatterRenderData.selectorScatterSeriesRenderData, series.id);
+  const count = renderData?.count ?? 0;
+  const nBatches = count === 0 ? 0 : Math.ceil(count / Math.max(1, batchSize));
+  const batches = [];
+  for (let b = 0; b < nBatches; b += 1) {
+    const start = b * batchSize;
+    const end = Math.min(count, start + batchSize);
+    batches.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_ScatterAsyncBatch.ScatterAsyncBatch, {
+      series: series,
+      colorGetter: colorGetter,
+      onItemClick: onItemClick,
+      slots: slots,
+      slotProps: slotProps,
+      start: start,
+      end: end,
+      classes: classes,
+      revealed: b < revealedBatches
+    }, b));
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(React.Fragment, {
+    children: batches
+  });
+}
+process.env.NODE_ENV !== "production" ? ScatterAsync.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: _propTypes.default.object,
+  color: _propTypes.default.string.isRequired,
+  colorGetter: _propTypes.default.func.isRequired,
+  onItemClick: _propTypes.default.func,
+  series: _propTypes.default.object.isRequired,
+  slotProps: _propTypes.default.object,
+  slots: _propTypes.default.object,
+  xScale: _propTypes.default.func.isRequired,
+  yScale: _propTypes.default.func.isRequired
+} : void 0;

package/ScatterChart/async/ScatterAsync.mjs

@@ -0,0 +1,67 @@
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { ScatterAsyncBatch } from "./ScatterAsyncBatch.mjs";
+import { useStore } from "../../internals/store/useStore.mjs";
+import { selectorProgressiveBatchSize, selectorProgressiveSeriesRevealedBatches } from "../../internals/plugins/featurePlugins/useProgressiveRendering/index.mjs";
+import { selectorScatterSeriesRenderData } from "./scatterRenderData.selectors.mjs";
+
+/**
+ * @ignore - internal component.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+function ScatterAsync(props) {
+  const {
+    series,
+    colorGetter,
+    onItemClick,
+    slots,
+    slotProps,
+    classes
+  } = props;
+  const store = useStore();
+  const batchSize = store.use(selectorProgressiveBatchSize);
+  const revealedBatches = store.use(selectorProgressiveSeriesRevealedBatches, series.id);
+  // Size batches by the number of *visible* points so that zooming in (which
+  // shrinks the filtered set in the selector) collapses the progressive wave
+  // into a single tick once everything fits in one batch.
+  const renderData = store.use(selectorScatterSeriesRenderData, series.id);
+  const count = renderData?.count ?? 0;
+  const nBatches = count === 0 ? 0 : Math.ceil(count / Math.max(1, batchSize));
+  const batches = [];
+  for (let b = 0; b < nBatches; b += 1) {
+    const start = b * batchSize;
+    const end = Math.min(count, start + batchSize);
+    batches.push(/*#__PURE__*/_jsx(ScatterAsyncBatch, {
+      series: series,
+      colorGetter: colorGetter,
+      onItemClick: onItemClick,
+      slots: slots,
+      slotProps: slotProps,
+      start: start,
+      end: end,
+      classes: classes,
+      revealed: b < revealedBatches
+    }, b));
+  }
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: batches
+  });
+}
+process.env.NODE_ENV !== "production" ? ScatterAsync.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: PropTypes.object,
+  color: PropTypes.string.isRequired,
+  colorGetter: PropTypes.func.isRequired,
+  onItemClick: PropTypes.func,
+  series: PropTypes.object.isRequired,
+  slotProps: PropTypes.object,
+  slots: PropTypes.object,
+  xScale: PropTypes.func.isRequired,
+  yScale: PropTypes.func.isRequired
+} : void 0;
+export { ScatterAsync };

package/ScatterChart/async/ScatterAsyncBatch.d.mts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { type DefaultizedScatterSeriesType } from "../../models/seriesType/scatter.mjs";
+import type { ColorGetter } from "../../internals/plugins/corePlugins/useChartSeriesConfig/index.mjs";
+import { type ScatterProps } from "../Scatter.mjs";
+export interface ScatterAsyncBatchProps extends Pick<ScatterProps, 'series' | 'colorGetter' | 'onItemClick' | 'slots' | 'slotProps' | 'classes'> {
+  series: DefaultizedScatterSeriesType;
+  colorGetter: ColorGetter<'scatter'>;
+  /** First point index of this batch (inclusive). */
+  start: number;
+  /** Last point index of this batch (exclusive). */
+  end: number;
+  /**
+   * Whether this batch is allowed to render its markers yet. `ScatterAsync`
+   * ramps this up batch by batch across animation frames for a progressive
+   * paint. When `false` the `<g>` still mounts but stays empty.
+   */
+  revealed: boolean;
+}
+/**
+ * @ignore - internal component.
+ */
+declare function ScatterAsyncBatchComponent(props: ScatterAsyncBatchProps): import("react/jsx-runtime").JSX.Element;
+declare const ScatterAsyncBatch: React.MemoExoticComponent<typeof ScatterAsyncBatchComponent>;
+export { ScatterAsyncBatch };

package/ScatterChart/async/ScatterAsyncBatch.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { type DefaultizedScatterSeriesType } from "../../models/seriesType/scatter.js";
+import type { ColorGetter } from "../../internals/plugins/corePlugins/useChartSeriesConfig/index.js";
+import { type ScatterProps } from "../Scatter.js";
+export interface ScatterAsyncBatchProps extends Pick<ScatterProps, 'series' | 'colorGetter' | 'onItemClick' | 'slots' | 'slotProps' | 'classes'> {
+  series: DefaultizedScatterSeriesType;
+  colorGetter: ColorGetter<'scatter'>;
+  /** First point index of this batch (inclusive). */
+  start: number;
+  /** Last point index of this batch (exclusive). */
+  end: number;
+  /**
+   * Whether this batch is allowed to render its markers yet. `ScatterAsync`
+   * ramps this up batch by batch across animation frames for a progressive
+   * paint. When `false` the `<g>` still mounts but stays empty.
+   */
+  revealed: boolean;
+}
+/**
+ * @ignore - internal component.
+ */
+declare function ScatterAsyncBatchComponent(props: ScatterAsyncBatchProps): import("react/jsx-runtime").JSX.Element;
+declare const ScatterAsyncBatch: React.MemoExoticComponent<typeof ScatterAsyncBatchComponent>;
+export { ScatterAsyncBatch };

package/ScatterChart/async/ScatterAsyncBatch.js

@@ -0,0 +1,112 @@
+"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.ScatterAsyncBatch = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _useSlotProps2 = _interopRequireDefault(require("@mui/utils/useSlotProps"));
+var _useInteractionItemProps = require("../../hooks/useInteractionItemProps");
+var _useStore = require("../../internals/store/useStore");
+var _useItemHighlightStateGetter = require("../../hooks/useItemHighlightStateGetter");
+var _useChartClosestPoint = require("../../internals/plugins/featurePlugins/useChartClosestPoint");
+var _ScatterMarker = require("../ScatterMarker");
+var _scatterClasses = require("../scatterClasses");
+var _ChartsProvider = require("../../context/ChartsProvider");
+var _scatterRenderData = require("./scatterRenderData.selectors");
+var _jsxRuntime = require("react/jsx-runtime");
+const _excluded = ["ownerState"];
+/**
+ * @ignore - internal component.
+ */
+function ScatterAsyncBatchComponent(props) {
+  const {
+    series,
+    colorGetter,
+    onItemClick,
+    slots,
+    slotProps,
+    start,
+    end,
+    revealed,
+    classes: inClasses
+  } = props;
+  const classes = (0, _scatterClasses.useUtilityClasses)({
+    classes: inClasses
+  });
+  const {
+    instance
+  } = (0, _ChartsProvider.useChartsContext)();
+  const store = (0, _useStore.useStore)();
+  const isVoronoiEnabled = store.use(_useChartClosestPoint.selectorChartsIsVoronoiEnabled);
+  const skipInteractionHandlers = isVoronoiEnabled;
+  const getHighlightState = (0, _useItemHighlightStateGetter.useItemHighlightStateGetter)();
+  const renderData = store.use(_scatterRenderData.selectorScatterSeriesRenderData, series.id);
+  const Marker = slots?.marker ?? _ScatterMarker.ScatterMarker;
+  const _useSlotProps = (0, _useSlotProps2.default)({
+      elementType: Marker,
+      externalSlotProps: slotProps?.marker,
+      additionalProps: {
+        seriesId: series.id,
+        size: series.markerSize
+      },
+      ownerState: {}
+    }),
+    markerProps = (0, _objectWithoutPropertiesLoose2.default)(_useSlotProps, _excluded);
+  if (renderData === undefined || !revealed) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)("g", {
+      "data-series": series.id,
+      className: classes.series
+    });
+  }
+  const view = (0, _scatterRenderData.getScatterBatchView)(renderData, start, end);
+  const markers = [];
+  const nLocal = view.length / 3;
+  for (let local = 0; local < nLocal; local += 1) {
+    const x = view[local * 3];
+    const y = view[local * 3 + 1];
+    const dataIndex = view[local * 3 + 2];
+    const dataPoint = {
+      x,
+      y,
+      dataIndex,
+      seriesId: series.id,
+      type: 'scatter'
+    };
+    const highlightState = getHighlightState(dataPoint);
+    const isItemHighlighted = highlightState === 'highlighted';
+    const isItemFaded = highlightState === 'faded';
+    markers.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(Marker, (0, _extends2.default)({
+      className: (0, _clsx.default)(classes.marker, markerProps.className),
+      dataIndex: dataIndex,
+      color: colorGetter(dataIndex),
+      isHighlighted: isItemHighlighted,
+      isFaded: isItemFaded,
+      x: x,
+      y: y,
+      onClick: onItemClick && (event => onItemClick(event, {
+        type: 'scatter',
+        seriesId: series.id,
+        dataIndex
+      })),
+      "data-highlighted": isItemHighlighted || undefined,
+      "data-faded": isItemFaded || undefined
+    }, skipInteractionHandlers ? undefined : (0, _useInteractionItemProps.getInteractionItemProps)(instance, dataPoint), markerProps), dataIndex));
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)("g", {
+    "data-series": series.id,
+    className: classes.series,
+    children: markers
+  });
+}
+
+// Memoized so a reveal tick (which re-renders every `ScatterAsync`) only
+// re-renders the one batch whose `revealed` prop changed.
+const ScatterAsyncBatch = exports.ScatterAsyncBatch = /*#__PURE__*/React.memo(ScatterAsyncBatchComponent);
+if (process.env.NODE_ENV !== "production") ScatterAsyncBatch.displayName = "ScatterAsyncBatch";

package/ScatterChart/async/ScatterAsyncBatch.mjs

@@ -0,0 +1,106 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["ownerState"];
+import * as React from 'react';
+import clsx from 'clsx';
+import useSlotProps from '@mui/utils/useSlotProps';
+import { getInteractionItemProps } from "../../hooks/useInteractionItemProps.mjs";
+import { useStore } from "../../internals/store/useStore.mjs";
+import { useItemHighlightStateGetter } from "../../hooks/useItemHighlightStateGetter.mjs";
+import { selectorChartsIsVoronoiEnabled } from "../../internals/plugins/featurePlugins/useChartClosestPoint/index.mjs";
+import { ScatterMarker } from "../ScatterMarker.mjs";
+import { useUtilityClasses } from "../scatterClasses.mjs";
+import { useChartsContext } from "../../context/ChartsProvider/index.mjs";
+import { getScatterBatchView, selectorScatterSeriesRenderData } from "./scatterRenderData.selectors.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @ignore - internal component.
+ */
+function ScatterAsyncBatchComponent(props) {
+  const {
+    series,
+    colorGetter,
+    onItemClick,
+    slots,
+    slotProps,
+    start,
+    end,
+    revealed,
+    classes: inClasses
+  } = props;
+  const classes = useUtilityClasses({
+    classes: inClasses
+  });
+  const {
+    instance
+  } = useChartsContext();
+  const store = useStore();
+  const isVoronoiEnabled = store.use(selectorChartsIsVoronoiEnabled);
+  const skipInteractionHandlers = isVoronoiEnabled;
+  const getHighlightState = useItemHighlightStateGetter();
+  const renderData = store.use(selectorScatterSeriesRenderData, series.id);
+  const Marker = slots?.marker ?? ScatterMarker;
+  const _useSlotProps = useSlotProps({
+      elementType: Marker,
+      externalSlotProps: slotProps?.marker,
+      additionalProps: {
+        seriesId: series.id,
+        size: series.markerSize
+      },
+      ownerState: {}
+    }),
+    markerProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded);
+  if (renderData === undefined || !revealed) {
+    return /*#__PURE__*/_jsx("g", {
+      "data-series": series.id,
+      className: classes.series
+    });
+  }
+  const view = getScatterBatchView(renderData, start, end);
+  const markers = [];
+  const nLocal = view.length / 3;
+  for (let local = 0; local < nLocal; local += 1) {
+    const x = view[local * 3];
+    const y = view[local * 3 + 1];
+    const dataIndex = view[local * 3 + 2];
+    const dataPoint = {
+      x,
+      y,
+      dataIndex,
+      seriesId: series.id,
+      type: 'scatter'
+    };
+    const highlightState = getHighlightState(dataPoint);
+    const isItemHighlighted = highlightState === 'highlighted';
+    const isItemFaded = highlightState === 'faded';
+    markers.push(/*#__PURE__*/_jsx(Marker, _extends({
+      className: clsx(classes.marker, markerProps.className),
+      dataIndex: dataIndex,
+      color: colorGetter(dataIndex),
+      isHighlighted: isItemHighlighted,
+      isFaded: isItemFaded,
+      x: x,
+      y: y,
+      onClick: onItemClick && (event => onItemClick(event, {
+        type: 'scatter',
+        seriesId: series.id,
+        dataIndex
+      })),
+      "data-highlighted": isItemHighlighted || undefined,
+      "data-faded": isItemFaded || undefined
+    }, skipInteractionHandlers ? undefined : getInteractionItemProps(instance, dataPoint), markerProps), dataIndex));
+  }
+  return /*#__PURE__*/_jsx("g", {
+    "data-series": series.id,
+    className: classes.series,
+    children: markers
+  });
+}
+
+// Memoized so a reveal tick (which re-renders every `ScatterAsync`) only
+// re-renders the one batch whose `revealed` prop changed.
+const ScatterAsyncBatch = /*#__PURE__*/React.memo(ScatterAsyncBatchComponent);
+if (process.env.NODE_ENV !== "production") ScatterAsyncBatch.displayName = "ScatterAsyncBatch";
+export { ScatterAsyncBatch };