@mui/x-charts 9.3.0 → 9.5.0

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 };

package/ScatterChart/async/scatterRenderData.selectors.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Pre-computed render data for a single scatter series.
+ *
+ * Coordinates are stored in a packed `Float64Array` (stride 3: `[x0, y0, i0,
+ * x1, y1, i1, ...]`, where `iN` is the original `dataIndex`). Only points that
+ * project inside the drawing area are kept, so the progressive renderer can
+ * size its batches by the number of *visible* points — when zoomed in tightly
+ * the wave finishes in a single tick. Batches are contiguous slices of this
+ * array, so a batch's data is obtained with a zero-copy `subarray` view (see
+ * {@link getScatterBatchView}).
+ */
+export interface ScatterSeriesRenderData {
+  /** Packed projected pixel coordinates + dataIndex, stride 3. */
+  coords: Float64Array;
+  /** Number of visible points (i.e. `coords.length / 3`). */
+  count: number;
+}
+/**
+ * Packed projected coordinates for every scatter series, filtered to the
+ * drawing area. Recomputes when the processed series, axis scales, or drawing
+ * area change.
+ */
+export declare const selectorScatterRenderData: (args_0: import("../../internals/plugins/corePlugins/useChartId/useChartId.types.mjs").UseChartIdState & import("../../internals/plugins/corePlugins/useChartSeriesConfig/useChartSeriesConfig.types.mjs").UseChartSeriesConfigState<keyof import("../../internals/index.mjs").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.mjs").UseChartExperimentalFeaturesState & import("../../internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types.mjs").UseChartDimensionsState & import("../../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.mjs").UseChartSeriesState<keyof import("../../internals/index.mjs").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartAnimation/useChartAnimation.types.mjs").UseChartAnimationState & import("../../internals/index.mjs").UseChartInteractionListenerState & Partial<{}> & {
+  cacheKey: import("../../internals/index.mjs").ChartStateCacheKey;
+}) => Map<string, ScatterSeriesRenderData>;
+/**
+ * Render data for a single scatter series, or `undefined` while it is not
+ * available yet (processors/axes still pending).
+ */
+export declare const selectorScatterSeriesRenderData: (args_0: import("../../internals/plugins/corePlugins/useChartId/useChartId.types.mjs").UseChartIdState & import("../../internals/plugins/corePlugins/useChartSeriesConfig/useChartSeriesConfig.types.mjs").UseChartSeriesConfigState<keyof import("../../internals/index.mjs").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.mjs").UseChartExperimentalFeaturesState & import("../../internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types.mjs").UseChartDimensionsState & import("../../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.mjs").UseChartSeriesState<keyof import("../../internals/index.mjs").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartAnimation/useChartAnimation.types.mjs").UseChartAnimationState & import("../../internals/index.mjs").UseChartInteractionListenerState & Partial<{}> & {
+  cacheKey: import("../../internals/index.mjs").ChartStateCacheKey;
+}, seriesId: string) => ScatterSeriesRenderData | undefined;
+/**
+ * Zero-copy view of one batch's coordinates. `start`/`end` are visible-point
+ * indices (not original `dataIndex` values). The returned `Float64Array` shares
+ * the buffer with `renderData.coords`.
+ */
+export declare function getScatterBatchView(renderData: ScatterSeriesRenderData, start: number, end: number): Float64Array;

package/ScatterChart/async/scatterRenderData.selectors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pre-computed render data for a single scatter series.
+ *
+ * Coordinates are stored in a packed `Float64Array` (stride 3: `[x0, y0, i0,
+ * x1, y1, i1, ...]`, where `iN` is the original `dataIndex`). Only points that
+ * project inside the drawing area are kept, so the progressive renderer can
+ * size its batches by the number of *visible* points — when zoomed in tightly
+ * the wave finishes in a single tick. Batches are contiguous slices of this
+ * array, so a batch's data is obtained with a zero-copy `subarray` view (see
+ * {@link getScatterBatchView}).
+ */
+export interface ScatterSeriesRenderData {
+  /** Packed projected pixel coordinates + dataIndex, stride 3. */
+  coords: Float64Array;
+  /** Number of visible points (i.e. `coords.length / 3`). */
+  count: number;
+}
+/**
+ * Packed projected coordinates for every scatter series, filtered to the
+ * drawing area. Recomputes when the processed series, axis scales, or drawing
+ * area change.
+ */
+export declare const selectorScatterRenderData: (args_0: import("../../internals/plugins/corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../internals/plugins/corePlugins/useChartSeriesConfig/useChartSeriesConfig.types.js").UseChartSeriesConfigState<keyof import("../../internals/index.js").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../internals/index.js").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../internals/index.js").UseChartInteractionListenerState & Partial<{}> & {
+  cacheKey: import("../../internals/index.js").ChartStateCacheKey;
+}) => Map<string, ScatterSeriesRenderData>;
+/**
+ * Render data for a single scatter series, or `undefined` while it is not
+ * available yet (processors/axes still pending).
+ */
+export declare const selectorScatterSeriesRenderData: (args_0: import("../../internals/plugins/corePlugins/useChartId/useChartId.types.js").UseChartIdState & import("../../internals/plugins/corePlugins/useChartSeriesConfig/useChartSeriesConfig.types.js").UseChartSeriesConfigState<keyof import("../../internals/index.js").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartExperimentalFeature/useChartExperimentalFeature.types.js").UseChartExperimentalFeaturesState & import("../../internals/plugins/corePlugins/useChartDimensions/useChartDimensions.types.js").UseChartDimensionsState & import("../../internals/plugins/corePlugins/useChartSeries/useChartSeries.types.js").UseChartSeriesState<keyof import("../../internals/index.js").ChartsSeriesConfig> & import("../../internals/plugins/corePlugins/useChartAnimation/useChartAnimation.types.js").UseChartAnimationState & import("../../internals/index.js").UseChartInteractionListenerState & Partial<{}> & {
+  cacheKey: import("../../internals/index.js").ChartStateCacheKey;
+}, seriesId: string) => ScatterSeriesRenderData | undefined;
+/**
+ * Zero-copy view of one batch's coordinates. `start`/`end` are visible-point
+ * indices (not original `dataIndex` values). The returned `Float64Array` shares
+ * the buffer with `renderData.coords`.
+ */
+export declare function getScatterBatchView(renderData: ScatterSeriesRenderData, start: number, end: number): Float64Array;

package/ScatterChart/async/scatterRenderData.selectors.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getScatterBatchView = getScatterBatchView;
+exports.selectorScatterSeriesRenderData = exports.selectorScatterRenderData = void 0;
+var _store = require("@mui/x-internals/store");
+var _getValueToPositionMapper = require("../../hooks/getValueToPositionMapper");
+var _useChartSeries = require("../../internals/plugins/corePlugins/useChartSeries");
+var _useChartDimensions = require("../../internals/plugins/corePlugins/useChartDimensions");
+var _useChartCartesianAxis = require("../../internals/plugins/featurePlugins/useChartCartesianAxis");
+/**
+ * Pre-computed render data for a single scatter series.
+ *
+ * Coordinates are stored in a packed `Float64Array` (stride 3: `[x0, y0, i0,
+ * x1, y1, i1, ...]`, where `iN` is the original `dataIndex`). Only points that
+ * project inside the drawing area are kept, so the progressive renderer can
+ * size its batches by the number of *visible* points — when zoomed in tightly
+ * the wave finishes in a single tick. Batches are contiguous slices of this
+ * array, so a batch's data is obtained with a zero-copy `subarray` view (see
+ * {@link getScatterBatchView}).
+ */
+
+const EMPTY_RENDER_DATA = new Map();
+
+/**
+ * Packed projected coordinates for every scatter series, filtered to the
+ * drawing area. Recomputes when the processed series, axis scales, or drawing
+ * area change.
+ */
+const selectorScatterRenderData = exports.selectorScatterRenderData = (0, _store.createSelectorMemoized)(_useChartSeries.selectorChartSeriesProcessed, _useChartCartesianAxis.selectorChartXAxis, _useChartCartesianAxis.selectorChartYAxis, _useChartDimensions.selectorChartDrawingArea, function selectorScatterRenderData(processedSeries, xAxes, yAxes, drawingArea) {
+  const scatter = processedSeries.scatter;
+  if (scatter === undefined) {
+    return EMPTY_RENDER_DATA;
+  }
+  const defaultXAxisId = xAxes.axisIds[0];
+  const defaultYAxisId = yAxes.axisIds[0];
+  const result = new Map();
+  const xMin = drawingArea.left - 1;
+  const xMax = drawingArea.left + drawingArea.width;
+  const yMin = drawingArea.top - 1;
+  const yMax = drawingArea.top + drawingArea.height;
+  for (const seriesId of scatter.seriesOrder) {
+    const series = scatter.series[seriesId];
+    const xAxis = xAxes.axis[series.xAxisId ?? defaultXAxisId];
+    const yAxis = yAxes.axis[series.yAxisId ?? defaultYAxisId];
+    if (xAxis === undefined || yAxis === undefined) {
+      continue;
+    }
+    const getXPosition = (0, _getValueToPositionMapper.getValueToPositionMapper)(xAxis.scale);
+    const getYPosition = (0, _getValueToPositionMapper.getValueToPositionMapper)(yAxis.scale);
+    const data = series.data;
+    const n = data.length;
+    const packed = new Float64Array(n * 3);
+    let j = 0;
+    for (let i = 0; i < n; i += 1) {
+      const x = getXPosition(data[i].x);
+      if (!(x >= xMin && x <= xMax)) {
+        continue;
+      }
+      const y = getYPosition(data[i].y);
+      if (!(y >= yMin && y <= yMax)) {
+        continue;
+      }
+      packed[j] = x;
+      packed[j + 1] = y;
+      packed[j + 2] = i;
+      j += 3;
+    }
+    const coords = packed.slice(0, j);
+    result.set(seriesId, {
+      coords,
+      count: j / 3
+    });
+  }
+  return result;
+});
+
+/**
+ * Render data for a single scatter series, or `undefined` while it is not
+ * available yet (processors/axes still pending).
+ */
+const selectorScatterSeriesRenderData = exports.selectorScatterSeriesRenderData = (0, _store.createSelector)(selectorScatterRenderData, (renderData, seriesId) => renderData.get(seriesId));
+
+/**
+ * Zero-copy view of one batch's coordinates. `start`/`end` are visible-point
+ * indices (not original `dataIndex` values). The returned `Float64Array` shares
+ * the buffer with `renderData.coords`.
+ */
+function getScatterBatchView(renderData, start, end) {
+  return renderData.coords.subarray(start * 3, end * 3);
+}

package/ScatterChart/async/scatterRenderData.selectors.mjs

@@ -0,0 +1,87 @@
+import { createSelector, createSelectorMemoized } from '@mui/x-internals/store';
+import { getValueToPositionMapper } from "../../hooks/getValueToPositionMapper.mjs";
+import { selectorChartSeriesProcessed } from "../../internals/plugins/corePlugins/useChartSeries/index.mjs";
+import { selectorChartDrawingArea } from "../../internals/plugins/corePlugins/useChartDimensions/index.mjs";
+import { selectorChartXAxis, selectorChartYAxis } from "../../internals/plugins/featurePlugins/useChartCartesianAxis/index.mjs";
+
+/**
+ * Pre-computed render data for a single scatter series.
+ *
+ * Coordinates are stored in a packed `Float64Array` (stride 3: `[x0, y0, i0,
+ * x1, y1, i1, ...]`, where `iN` is the original `dataIndex`). Only points that
+ * project inside the drawing area are kept, so the progressive renderer can
+ * size its batches by the number of *visible* points — when zoomed in tightly
+ * the wave finishes in a single tick. Batches are contiguous slices of this
+ * array, so a batch's data is obtained with a zero-copy `subarray` view (see
+ * {@link getScatterBatchView}).
+ */
+
+const EMPTY_RENDER_DATA = new Map();
+
+/**
+ * Packed projected coordinates for every scatter series, filtered to the
+ * drawing area. Recomputes when the processed series, axis scales, or drawing
+ * area change.
+ */
+export const selectorScatterRenderData = createSelectorMemoized(selectorChartSeriesProcessed, selectorChartXAxis, selectorChartYAxis, selectorChartDrawingArea, function selectorScatterRenderData(processedSeries, xAxes, yAxes, drawingArea) {
+  const scatter = processedSeries.scatter;
+  if (scatter === undefined) {
+    return EMPTY_RENDER_DATA;
+  }
+  const defaultXAxisId = xAxes.axisIds[0];
+  const defaultYAxisId = yAxes.axisIds[0];
+  const result = new Map();
+  const xMin = drawingArea.left - 1;
+  const xMax = drawingArea.left + drawingArea.width;
+  const yMin = drawingArea.top - 1;
+  const yMax = drawingArea.top + drawingArea.height;
+  for (const seriesId of scatter.seriesOrder) {
+    const series = scatter.series[seriesId];
+    const xAxis = xAxes.axis[series.xAxisId ?? defaultXAxisId];
+    const yAxis = yAxes.axis[series.yAxisId ?? defaultYAxisId];
+    if (xAxis === undefined || yAxis === undefined) {
+      continue;
+    }
+    const getXPosition = getValueToPositionMapper(xAxis.scale);
+    const getYPosition = getValueToPositionMapper(yAxis.scale);
+    const data = series.data;
+    const n = data.length;
+    const packed = new Float64Array(n * 3);
+    let j = 0;
+    for (let i = 0; i < n; i += 1) {
+      const x = getXPosition(data[i].x);
+      if (!(x >= xMin && x <= xMax)) {
+        continue;
+      }
+      const y = getYPosition(data[i].y);
+      if (!(y >= yMin && y <= yMax)) {
+        continue;
+      }
+      packed[j] = x;
+      packed[j + 1] = y;
+      packed[j + 2] = i;
+      j += 3;
+    }
+    const coords = packed.slice(0, j);
+    result.set(seriesId, {
+      coords,
+      count: j / 3
+    });
+  }
+  return result;
+});
+
+/**
+ * Render data for a single scatter series, or `undefined` while it is not
+ * available yet (processors/axes still pending).
+ */
+export const selectorScatterSeriesRenderData = createSelector(selectorScatterRenderData, (renderData, seriesId) => renderData.get(seriesId));
+
+/**
+ * Zero-copy view of one batch's coordinates. `start`/`end` are visible-point
+ * indices (not original `dataIndex` values). The returned `Float64Array` shares
+ * the buffer with `renderData.coords`.
+ */
+export function getScatterBatchView(renderData, start, end) {
+  return renderData.coords.subarray(start * 3, end * 3);
+}

package/ScatterChart/seriesConfig/extremums.js

@@ -17,6 +17,9 @@ const getExtremumX = params => {
     if (!Object.hasOwn(series, seriesId)) {
       continue;
     }
+    if (axis.domainSeries === 'visible' && series[seriesId].hidden) {
+      continue;
+    }
     const axisId = series[seriesId].xAxisId;
     if (!(axisId === axis.id || axisId === undefined && isDefaultAxis)) {
       continue;
@@ -59,6 +62,9 @@ const getExtremumY = params => {
     if (!Object.hasOwn(series, seriesId)) {
       continue;
     }
+    if (axis.domainSeries === 'visible' && series[seriesId].hidden) {
+      continue;
+    }
     const axisId = series[seriesId].yAxisId;
     if (!(axisId === axis.id || axisId === undefined && isDefaultAxis)) {
       continue;

package/ScatterChart/seriesConfig/extremums.mjs

@@ -11,6 +11,9 @@ export const getExtremumX = params => {
     if (!Object.hasOwn(series, seriesId)) {
       continue;
     }
+    if (axis.domainSeries === 'visible' && series[seriesId].hidden) {
+      continue;
+    }
     const axisId = series[seriesId].xAxisId;
     if (!(axisId === axis.id || axisId === undefined && isDefaultAxis)) {
       continue;
@@ -52,6 +55,9 @@ export const getExtremumY = params => {
     if (!Object.hasOwn(series, seriesId)) {
       continue;
     }
+    if (axis.domainSeries === 'visible' && series[seriesId].hidden) {
+      continue;
+    }
     const axisId = series[seriesId].yAxisId;
     if (!(axisId === axis.id || axisId === undefined && isDefaultAxis)) {
       continue;

package/ScatterChart/seriesConfig/getColor.js

@@ -25,7 +25,7 @@ const getColor = (series, xAxis, yAxis, zAxis) => {
       const color = value === null ? getSeriesColor({
         value,
         dataIndex
-      }) : zColorScale(value.z);
+      }) : zColorScale(value.colorValue ?? value.z);
       if (color === null) {
         return getSeriesColor({
           value,

package/ScatterChart/seriesConfig/getColor.mjs

@@ -19,7 +19,7 @@ const getColor = (series, xAxis, yAxis, zAxis) => {
       const color = value === null ? getSeriesColor({
         value,
         dataIndex
-      }) : zColorScale(value.z);
+      }) : zColorScale(value.colorValue ?? value.z);
       if (color === null) {
         return getSeriesColor({
           value,

package/ScatterChart/seriesConfig/getMarkerSize.d.mts

@@ -0,0 +1,18 @@
+import { type DefaultizedScatterSeriesType } from "../../models/seriesType/scatter.mjs";
+import { type ZAxisDefaultized } from "../../models/z-axis.mjs";
+/**
+ * Returns the marker size of a scatter item given its data index.
+ * @param {number} dataIndex The index of the scatter item.
+ * @returns {number} The marker size in pixels.
+ */
+export type ScatterSizeGetter = (dataIndex: number) => number;
+/**
+ * Builds a getter returning the marker size of each scatter item.
+ *
+ * When the size axis defines a `sizeMap`, the size is computed by mapping a value
+ * through the resulting `sizeScale`. The mapped value is taken from the size axis
+ * `data` when available, otherwise from the `sizeValue` of the scatter point.
+ * It falls back to the series `markerSize` when no size can be computed.
+ */
+declare const getMarkerSize: (series: DefaultizedScatterSeriesType, sizeZAxis?: ZAxisDefaultized) => ScatterSizeGetter;
+export default getMarkerSize;

package/ScatterChart/seriesConfig/getMarkerSize.d.ts

@@ -0,0 +1,18 @@
+import { type DefaultizedScatterSeriesType } from "../../models/seriesType/scatter.js";
+import { type ZAxisDefaultized } from "../../models/z-axis.js";
+/**
+ * Returns the marker size of a scatter item given its data index.
+ * @param {number} dataIndex The index of the scatter item.
+ * @returns {number} The marker size in pixels.
+ */
+export type ScatterSizeGetter = (dataIndex: number) => number;
+/**
+ * Builds a getter returning the marker size of each scatter item.
+ *
+ * When the size axis defines a `sizeMap`, the size is computed by mapping a value
+ * through the resulting `sizeScale`. The mapped value is taken from the size axis
+ * `data` when available, otherwise from the `sizeValue` of the scatter point.
+ * It falls back to the series `markerSize` when no size can be computed.
+ */
+declare const getMarkerSize: (series: DefaultizedScatterSeriesType, sizeZAxis?: ZAxisDefaultized) => ScatterSizeGetter;
+export default getMarkerSize;

package/ScatterChart/seriesConfig/getMarkerSize.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Returns the marker size of a scatter item given its data index.
+ * @param {number} dataIndex The index of the scatter item.
+ * @returns {number} The marker size in pixels.
+ */
+
+/**
+ * Builds a getter returning the marker size of each scatter item.
+ *
+ * When the size axis defines a `sizeMap`, the size is computed by mapping a value
+ * through the resulting `sizeScale`. The mapped value is taken from the size axis
+ * `data` when available, otherwise from the `sizeValue` of the scatter point.
+ * It falls back to the series `markerSize` when no size can be computed.
+ */
+const getMarkerSize = (series, sizeZAxis) => {
+  const sizeScale = sizeZAxis?.sizeScale;
+  if (!sizeScale) {
+    return () => series.markerSize;
+  }
+  return dataIndex => {
+    if (sizeZAxis?.data?.[dataIndex] !== undefined) {
+      const size = sizeScale(sizeZAxis.data[dataIndex]);
+      if (size != null && !Number.isNaN(size)) {
+        return size;
+      }
+    }
+    const value = series.data[dataIndex];
+    if (value != null) {
+      const size = sizeScale(value.sizeValue);
+      if (size != null && !Number.isNaN(size)) {
+        return size;
+      }
+    }
+    return series.markerSize;
+  };
+};
+var _default = exports.default = getMarkerSize;