@mui/x-charts-premium 9.7.0 → 9.8.0

package/Map/seriesConfig/seriesProcessor.mjs

@@ -1,4 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
+import _formatErrorMessage from "@mui/x-internals/formatErrorMessage";
 import { incompleteDatasetKeysError } from '@mui/x-charts/internals';
 const defaultValueFormatter = v => v == null ? '' : String(v.value);
 const seriesProcessor = ({
@@ -34,16 +35,24 @@ const seriesProcessor = ({
     } else {
       data = input.data ?? [];
     }
+    const lookupByName = new Map();
+    data.forEach((item, index) => {
+      if (lookupByName.has(item.name)) {
+        throw new Error(process.env.NODE_ENV !== "production" ? `MUI X Charts: Series "${seriesId}" has a duplicated name "${item.name}".\n` + `Map shapes are identified by their name, so duplicates cannot be told apart for coloring, tooltips, and highlighting.\n` + `Ensure each data entry has a unique name.` : _formatErrorMessage(294, seriesId, item.name));
+      }
+      lookupByName.set(item.name, index);
+    });
     defaultizedSeries[seriesId] = _extends({
       labelMarkType: 'square'
     }, input, {
-      data: data.map((item, dataIndex) => _extends({}, item, {
+      data: data.map(item => _extends({}, item, {
         hidden: !isItemVisible?.({
           type: 'mapShape',
           seriesId,
-          dataIndex
+          name: item.name
         })
       })),
+      lookupByName,
       hidden: !isItemVisible?.({
         type: 'mapShape',
         seriesId

package/Map/seriesConfig/tooltip.js

@@ -10,20 +10,24 @@ const tooltipGetter = ({
   getColor,
   identifier
 }) => {
-  if (!identifier || identifier.dataIndex === undefined) {
+  if (!identifier || identifier.name === undefined) {
     return null;
   }
-  const point = series.data[identifier.dataIndex];
+  const index = series.lookupByName.get(identifier.name);
+  if (index === undefined) {
+    return null;
+  }
+  const point = series.data[index];
   if (point == null) {
     return null;
   }
-  const color = getColor(identifier.dataIndex);
+  const color = getColor(identifier.name);
   if (color === null) {
     return null;
   }
   const label = (0, _internals.getLabel)(point.label ?? point.name, 'tooltip');
   const formattedValue = series.valueFormatter(point, {
-    dataIndex: identifier.dataIndex
+    dataIndex: index
   });
   return {
     identifier,

package/Map/seriesConfig/tooltip.mjs

@@ -4,20 +4,24 @@ const tooltipGetter = ({
   getColor,
   identifier
 }) => {
-  if (!identifier || identifier.dataIndex === undefined) {
+  if (!identifier || identifier.name === undefined) {
     return null;
   }
-  const point = series.data[identifier.dataIndex];
+  const index = series.lookupByName.get(identifier.name);
+  if (index === undefined) {
+    return null;
+  }
+  const point = series.data[index];
   if (point == null) {
     return null;
   }
-  const color = getColor(identifier.dataIndex);
+  const color = getColor(identifier.name);
   if (color === null) {
     return null;
   }
   const label = getLabel(point.label ?? point.name, 'tooltip');
   const formattedValue = series.valueFormatter(point, {
-    dataIndex: identifier.dataIndex
+    dataIndex: index
   });
   return {
     identifier,

package/Map/seriesConfig/tooltipPosition.d.mts

@@ -1,3 +1,8 @@
-import type { TooltipItemPositionGetter } from '@mui/x-charts/internals';
-declare const tooltipItemPositionGetter: TooltipItemPositionGetter<'mapShape'>;
-export default tooltipItemPositionGetter;
+import type { TooltipItemPositionSelector } from '@mui/x-charts/internals';
+/**
+ * Positions a map shape tooltip from the geo projection. It lives in the map
+ * series config (rather than the core tooltip plugin) so the geo projection is a
+ * tracked dependency and d3-geo is only bundled with map charts.
+ */
+declare const selectorTooltipItemPosition: TooltipItemPositionSelector;
+export default selectorTooltipItemPosition;

package/Map/seriesConfig/tooltipPosition.d.ts

@@ -1,3 +1,8 @@
-import type { TooltipItemPositionGetter } from '@mui/x-charts/internals';
-declare const tooltipItemPositionGetter: TooltipItemPositionGetter<'mapShape'>;
-export default tooltipItemPositionGetter;
+import type { TooltipItemPositionSelector } from '@mui/x-charts/internals';
+/**
+ * Positions a map shape tooltip from the geo projection. It lives in the map
+ * series config (rather than the core tooltip plugin) so the geo projection is a
+ * tracked dependency and d3-geo is only bundled with map charts.
+ */
+declare const selectorTooltipItemPosition: TooltipItemPositionSelector;
+export default selectorTooltipItemPosition;

package/Map/seriesConfig/tooltipPosition.js

@@ -5,39 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _d3Geo = require("@mui/x-charts-vendor/d3-geo");
-const tooltipItemPositionGetter = params => {
-  const {
-    series,
-    identifier,
-    axesConfig,
-    placement
-  } = params;
-  if (!identifier || identifier.dataIndex === undefined) {
+var _store = require("@mui/x-internals/store");
+var _internals = require("@mui/x-charts/internals");
+/**
+ * Positions a map shape tooltip from the geo projection. It lives in the map
+ * series config (rather than the core tooltip plugin) so the geo projection is a
+ * tracked dependency and d3-geo is only bundled with map charts.
+ */
+const selectorTooltipItemPosition = (0, _store.createSelectorMemoized)(_internals.selectorChartsTooltipItem, _internals.useGeoProjectionSelectors.selectorGeoTooltipPosition,
+// `selectorChartsTooltipItem` is typed with the community series types, which
+// don't include `mapShape`, so the identifier is matched structurally here.
+(identifier, {
+  projection,
+  geoData,
+  featureIndexesByName
+}, position) => {
+  if (identifier?.type !== 'mapShape' || identifier.name === undefined) {
     return null;
   }
-  const itemSeries = series.mapShape?.series[identifier.seriesId];
-  if (itemSeries == null) {
-    return null;
-  }
-  if (axesConfig.geo === undefined) {
-    return null;
-  }
-  const {
-    projection,
-    geoData,
-    featureIndexesByName
-  } = axesConfig.geo;
   if (projection == null || geoData == null) {
     return null;
   }
-  const featureIndex = featureIndexesByName.get(itemSeries.data[identifier.dataIndex].name)?.[0];
+  const featureIndex = featureIndexesByName.get(identifier.name)?.[0];
   if (featureIndex === undefined) {
     return null;
   }
-  const feature = geoData.features[featureIndex];
-  const path = (0, _d3Geo.geoPath)(projection);
-  const [[x0, y0], [x1, y1]] = path.bounds(feature);
-  switch (placement) {
+  const [[x0, y0], [x1, y1]] = (0, _d3Geo.geoPath)(projection).bounds(geoData.features[featureIndex]);
+  switch (position) {
     case 'right':
       return {
         x: x1,
@@ -60,5 +54,5 @@ const tooltipItemPositionGetter = params => {
         y: y0
       };
   }
-};
-var _default = exports.default = tooltipItemPositionGetter;
+});
+var _default = exports.default = selectorTooltipItemPosition;

package/Map/seriesConfig/tooltipPosition.mjs

@@ -1,37 +1,32 @@
 import { geoPath } from '@mui/x-charts-vendor/d3-geo';
-const tooltipItemPositionGetter = params => {
-  const {
-    series,
-    identifier,
-    axesConfig,
-    placement
-  } = params;
-  if (!identifier || identifier.dataIndex === undefined) {
+import { createSelectorMemoized } from '@mui/x-internals/store';
+import { selectorChartsTooltipItem, useGeoProjectionSelectors } from '@mui/x-charts/internals';
+
+/**
+ * Positions a map shape tooltip from the geo projection. It lives in the map
+ * series config (rather than the core tooltip plugin) so the geo projection is a
+ * tracked dependency and d3-geo is only bundled with map charts.
+ */
+const selectorTooltipItemPosition = createSelectorMemoized(selectorChartsTooltipItem, useGeoProjectionSelectors.selectorGeoTooltipPosition,
+// `selectorChartsTooltipItem` is typed with the community series types, which
+// don't include `mapShape`, so the identifier is matched structurally here.
+(identifier, {
+  projection,
+  geoData,
+  featureIndexesByName
+}, position) => {
+  if (identifier?.type !== 'mapShape' || identifier.name === undefined) {
     return null;
   }
-  const itemSeries = series.mapShape?.series[identifier.seriesId];
-  if (itemSeries == null) {
-    return null;
-  }
-  if (axesConfig.geo === undefined) {
-    return null;
-  }
-  const {
-    projection,
-    geoData,
-    featureIndexesByName
-  } = axesConfig.geo;
   if (projection == null || geoData == null) {
     return null;
   }
-  const featureIndex = featureIndexesByName.get(itemSeries.data[identifier.dataIndex].name)?.[0];
+  const featureIndex = featureIndexesByName.get(identifier.name)?.[0];
   if (featureIndex === undefined) {
     return null;
   }
-  const feature = geoData.features[featureIndex];
-  const path = geoPath(projection);
-  const [[x0, y0], [x1, y1]] = path.bounds(feature);
-  switch (placement) {
+  const [[x0, y0], [x1, y1]] = geoPath(projection).bounds(geoData.features[featureIndex]);
+  switch (position) {
     case 'right':
       return {
         x: x1,
@@ -54,5 +49,5 @@ const tooltipItemPositionGetter = params => {
         y: y0
       };
   }
-};
-export default tooltipItemPositionGetter;
+});
+export default selectorTooltipItemPosition;

package/ScatterChartPremium/webgl/ScatterWebGLProgram.d.mts

@@ -13,6 +13,4 @@ export declare class ScatterWebGLProgram {
   plot(plotData: ScatterWebGLPlotData): void;
   render(plotData: ScatterWebGLPlotData): void;
   dispose(): void;
-  private setupInstancedAttribute;
-  private uploadBuffer;
 }

package/ScatterChartPremium/webgl/ScatterWebGLProgram.d.ts

@@ -13,6 +13,4 @@ export declare class ScatterWebGLProgram {
   plot(plotData: ScatterWebGLPlotData): void;
   render(plotData: ScatterWebGLPlotData): void;
   dispose(): void;
-  private setupInstancedAttribute;
-  private uploadBuffer;
 }

package/ScatterChartPremium/webgl/ScatterWebGLProgram.js

@@ -5,32 +5,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ScatterWebGLProgram = void 0;
 var _utils = require("../../utils/webgl/utils");
+var _instancedAttribute = require("../../utils/webgl/instancedAttribute");
 var _shaders = require("./shaders");
-const QUAD_VERTICES = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
 class ScatterWebGLProgram {
   shaders = [];
+
+  /* Colors come in as Uint8 [0, 255]; normalized=true makes the GPU read them back as vec4 in [0, 1]. */
+
   constructor(gl) {
     this.gl = gl;
-    gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-    this.quadBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, QUAD_VERTICES, gl.STATIC_DRAW);
-    const prog = initializeProgram(gl, _shaders.scatterVertexShader, _shaders.scatterFragmentShader);
-    this.program = prog.program;
-    this.shaders.push(prog.vertexShader, prog.fragmentShader);
+    (0, _utils.setupStandardBlending)(gl);
+    const linked = (0, _utils.linkProgram)(gl, _shaders.scatterVertexShader, _shaders.scatterFragmentShader);
+    this.program = linked.program;
+    this.shaders.push(...linked.shaders);
+    this.quadBuffer = (0, _utils.uploadQuadBuffer)(gl);
     this.vao = gl.createVertexArray();
     gl.bindVertexArray(this.vao);
-
-    // a_position references the shared quad; bind it once while the VAO is active.
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
-    const aPosition = gl.getAttribLocation(this.program, 'a_position');
-    gl.enableVertexAttribArray(aPosition);
-    gl.vertexAttribPointer(aPosition, 2, gl.FLOAT, false, 0, 0);
-    this.centers = this.setupInstancedAttribute('a_center', 2, gl.FLOAT, false);
-    this.sizes = this.setupInstancedAttribute('a_size', 1, gl.FLOAT, false);
-    // Colors come in as Uint8 [0, 255]; normalized=true makes the GPU read them back as vec4 in [0, 1].
-    this.colors = this.setupInstancedAttribute('a_color', 4, gl.UNSIGNED_BYTE, true);
+    (0, _utils.bindQuadBuffer)(gl, this.program, this.quadBuffer);
+    this.centers = (0, _instancedAttribute.createInstancedAttribute)(gl, this.program, 'a_center', 2);
+    this.sizes = (0, _instancedAttribute.createInstancedAttribute)(gl, this.program, 'a_size', 1);
+    this.colors = (0, _instancedAttribute.createInstancedAttribute)(gl, this.program, 'a_color', 4, gl.UNSIGNED_BYTE, true);
     gl.bindVertexArray(null);
   }
   setResolution(width, height) {
@@ -41,9 +35,12 @@ class ScatterWebGLProgram {
     gl.uniform2f(gl.getUniformLocation(this.program, 'u_resolution'), width, height);
   }
   plot(plotData) {
-    this.uploadBuffer(this.centers, plotData.centers);
-    this.uploadBuffer(this.sizes, plotData.sizes);
-    this.uploadBuffer(this.colors, plotData.colors);
+    const {
+      gl
+    } = this;
+    (0, _utils.uploadGrowableBuffer)(gl, this.centers.buffer, plotData.centers);
+    (0, _utils.uploadGrowableBuffer)(gl, this.sizes.buffer, plotData.sizes);
+    (0, _utils.uploadGrowableBuffer)(gl, this.colors.buffer, plotData.colors);
   }
   render(plotData) {
     if (plotData.pointCount === 0) {
@@ -64,66 +61,11 @@ class ScatterWebGLProgram {
     } = this;
     gl.deleteProgram(this.program);
     gl.deleteVertexArray(this.vao);
-    gl.deleteBuffer(this.centers.buffer);
-    gl.deleteBuffer(this.sizes.buffer);
-    gl.deleteBuffer(this.colors.buffer);
+    gl.deleteBuffer(this.centers.buffer.buffer);
+    gl.deleteBuffer(this.sizes.buffer.buffer);
+    gl.deleteBuffer(this.colors.buffer.buffer);
     gl.deleteBuffer(this.quadBuffer);
     this.shaders.forEach(shader => gl.deleteShader(shader));
   }
-
-  // Assumes the owning VAO (Vertex Array Object) is already bound.
-  setupInstancedAttribute(name, size, glType, normalized) {
-    const {
-      gl,
-      program
-    } = this;
-    const buffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    const location = gl.getAttribLocation(program, name);
-    gl.enableVertexAttribArray(location);
-    gl.vertexAttribPointer(location, size, glType, normalized, 0, 0);
-    gl.vertexAttribDivisor(location, 1);
-    return {
-      buffer,
-      size,
-      glType,
-      capacityBytes: 0,
-      lastUploaded: null
-    };
-  }
-  uploadBuffer(target, data) {
-    if (target.lastUploaded === data) {
-      return;
-    }
-    const {
-      gl
-    } = this;
-    gl.bindBuffer(gl.ARRAY_BUFFER, target.buffer);
-    if (data.byteLength <= target.capacityBytes) {
-      gl.bufferSubData(gl.ARRAY_BUFFER, 0, data);
-    } else {
-      gl.bufferData(gl.ARRAY_BUFFER, data, gl.DYNAMIC_DRAW);
-      target.capacityBytes = data.byteLength;
-    }
-    target.lastUploaded = data;
-  }
 }
-exports.ScatterWebGLProgram = ScatterWebGLProgram;
-function initializeProgram(gl, vertexShaderSource, fragmentShaderSource) {
-  const program = gl.createProgram();
-  const vertexShader = (0, _utils.compileShader)(gl, vertexShaderSource, gl.VERTEX_SHADER);
-  const fragmentShader = (0, _utils.compileShader)(gl, fragmentShaderSource, gl.FRAGMENT_SHADER);
-  gl.attachShader(program, vertexShader);
-  gl.attachShader(program, fragmentShader);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    console.error(`Program linking failed: ${gl.getProgramInfoLog(program)}`);
-    console.error(`Vertex shader info-log: ${gl.getShaderInfoLog(vertexShader)}`);
-    console.error(`Fragment shader info-log: ${gl.getShaderInfoLog(fragmentShader)}`);
-  }
-  return {
-    program,
-    vertexShader,
-    fragmentShader
-  };
-}
+exports.ScatterWebGLProgram = ScatterWebGLProgram;

package/ScatterChartPremium/webgl/ScatterWebGLProgram.mjs

@@ -1,30 +1,24 @@
-import { compileShader, logWebGLErrors } from "../../utils/webgl/utils.mjs";
+import { bindQuadBuffer, linkProgram, logWebGLErrors, setupStandardBlending, uploadGrowableBuffer, uploadQuadBuffer } from "../../utils/webgl/utils.mjs";
+import { createInstancedAttribute } from "../../utils/webgl/instancedAttribute.mjs";
 import { scatterVertexShader, scatterFragmentShader } from "./shaders.mjs";
-const QUAD_VERTICES = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
 export class ScatterWebGLProgram {
   shaders = [];
+
+  /* Colors come in as Uint8 [0, 255]; normalized=true makes the GPU read them back as vec4 in [0, 1]. */
+
   constructor(gl) {
     this.gl = gl;
-    gl.enable(gl.BLEND);
-    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-    this.quadBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, QUAD_VERTICES, gl.STATIC_DRAW);
-    const prog = initializeProgram(gl, scatterVertexShader, scatterFragmentShader);
-    this.program = prog.program;
-    this.shaders.push(prog.vertexShader, prog.fragmentShader);
+    setupStandardBlending(gl);
+    const linked = linkProgram(gl, scatterVertexShader, scatterFragmentShader);
+    this.program = linked.program;
+    this.shaders.push(...linked.shaders);
+    this.quadBuffer = uploadQuadBuffer(gl);
     this.vao = gl.createVertexArray();
     gl.bindVertexArray(this.vao);
-
-    // a_position references the shared quad; bind it once while the VAO is active.
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
-    const aPosition = gl.getAttribLocation(this.program, 'a_position');
-    gl.enableVertexAttribArray(aPosition);
-    gl.vertexAttribPointer(aPosition, 2, gl.FLOAT, false, 0, 0);
-    this.centers = this.setupInstancedAttribute('a_center', 2, gl.FLOAT, false);
-    this.sizes = this.setupInstancedAttribute('a_size', 1, gl.FLOAT, false);
-    // Colors come in as Uint8 [0, 255]; normalized=true makes the GPU read them back as vec4 in [0, 1].
-    this.colors = this.setupInstancedAttribute('a_color', 4, gl.UNSIGNED_BYTE, true);
+    bindQuadBuffer(gl, this.program, this.quadBuffer);
+    this.centers = createInstancedAttribute(gl, this.program, 'a_center', 2);
+    this.sizes = createInstancedAttribute(gl, this.program, 'a_size', 1);
+    this.colors = createInstancedAttribute(gl, this.program, 'a_color', 4, gl.UNSIGNED_BYTE, true);
     gl.bindVertexArray(null);
   }
   setResolution(width, height) {
@@ -35,9 +29,12 @@ export class ScatterWebGLProgram {
     gl.uniform2f(gl.getUniformLocation(this.program, 'u_resolution'), width, height);
   }
   plot(plotData) {
-    this.uploadBuffer(this.centers, plotData.centers);
-    this.uploadBuffer(this.sizes, plotData.sizes);
-    this.uploadBuffer(this.colors, plotData.colors);
+    const {
+      gl
+    } = this;
+    uploadGrowableBuffer(gl, this.centers.buffer, plotData.centers);
+    uploadGrowableBuffer(gl, this.sizes.buffer, plotData.sizes);
+    uploadGrowableBuffer(gl, this.colors.buffer, plotData.colors);
   }
   render(plotData) {
     if (plotData.pointCount === 0) {
@@ -58,65 +55,10 @@ export class ScatterWebGLProgram {
     } = this;
     gl.deleteProgram(this.program);
     gl.deleteVertexArray(this.vao);
-    gl.deleteBuffer(this.centers.buffer);
-    gl.deleteBuffer(this.sizes.buffer);
-    gl.deleteBuffer(this.colors.buffer);
+    gl.deleteBuffer(this.centers.buffer.buffer);
+    gl.deleteBuffer(this.sizes.buffer.buffer);
+    gl.deleteBuffer(this.colors.buffer.buffer);
     gl.deleteBuffer(this.quadBuffer);
     this.shaders.forEach(shader => gl.deleteShader(shader));
   }
-
-  // Assumes the owning VAO (Vertex Array Object) is already bound.
-  setupInstancedAttribute(name, size, glType, normalized) {
-    const {
-      gl,
-      program
-    } = this;
-    const buffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    const location = gl.getAttribLocation(program, name);
-    gl.enableVertexAttribArray(location);
-    gl.vertexAttribPointer(location, size, glType, normalized, 0, 0);
-    gl.vertexAttribDivisor(location, 1);
-    return {
-      buffer,
-      size,
-      glType,
-      capacityBytes: 0,
-      lastUploaded: null
-    };
-  }
-  uploadBuffer(target, data) {
-    if (target.lastUploaded === data) {
-      return;
-    }
-    const {
-      gl
-    } = this;
-    gl.bindBuffer(gl.ARRAY_BUFFER, target.buffer);
-    if (data.byteLength <= target.capacityBytes) {
-      gl.bufferSubData(gl.ARRAY_BUFFER, 0, data);
-    } else {
-      gl.bufferData(gl.ARRAY_BUFFER, data, gl.DYNAMIC_DRAW);
-      target.capacityBytes = data.byteLength;
-    }
-    target.lastUploaded = data;
-  }
-}
-function initializeProgram(gl, vertexShaderSource, fragmentShaderSource) {
-  const program = gl.createProgram();
-  const vertexShader = compileShader(gl, vertexShaderSource, gl.VERTEX_SHADER);
-  const fragmentShader = compileShader(gl, fragmentShaderSource, gl.FRAGMENT_SHADER);
-  gl.attachShader(program, vertexShader);
-  gl.attachShader(program, fragmentShader);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    console.error(`Program linking failed: ${gl.getProgramInfoLog(program)}`);
-    console.error(`Vertex shader info-log: ${gl.getShaderInfoLog(vertexShader)}`);
-    console.error(`Fragment shader info-log: ${gl.getShaderInfoLog(fragmentShader)}`);
-  }
-  return {
-    program,
-    vertexShader,
-    fragmentShader
-  };
 }

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts-premium v9.7.0
+ * @mui/x-charts-premium v9.8.0
  *
  * @license SEE LICENSE IN LICENSE
  * This source code is licensed under the SEE LICENSE IN LICENSE license found in the

package/index.mjs

@@ -1,5 +1,5 @@
 /**
- * @mui/x-charts-premium v9.7.0
+ * @mui/x-charts-premium v9.8.0
  *
  * @license SEE LICENSE IN LICENSE
  * This source code is licensed under the SEE LICENSE IN LICENSE license found in the

package/internals/createGetVisibleCoordinate.d.mts

@@ -0,0 +1,14 @@
+import type { GeoProjection } from '@mui/x-charts-vendor/d3-geo';
+/**
+ * Builds a test that maps a device pixel to its `[lon, lat]`, or `null` when the
+ * pixel is not part of the visible map. It combines two clips that `projection.invert`
+ * alone misses:
+ *
+ * - the **post-clip** (cartesian) stream rejects device pixels outside the clip
+ *   rectangle — relevant once the map is panned/zoomed with a `clipExtent`;
+ * - streaming the inverted coordinate **back** through the projection applies the
+ *   pre-clip (spherical) boundary and checks the round trip: azimuthal projections
+ *   clamp `invert` outside the visible disk to the limb, and those clamped points do
+ *   not project back to the pixel they came from.
+ */
+export declare function createGetVisibleCoordinate(projection: GeoProjection): ([deviceX, deviceY]: [number, number]) => [number, number] | null;

package/internals/createGetVisibleCoordinate.d.ts

@@ -0,0 +1,14 @@
+import type { GeoProjection } from '@mui/x-charts-vendor/d3-geo';
+/**
+ * Builds a test that maps a device pixel to its `[lon, lat]`, or `null` when the
+ * pixel is not part of the visible map. It combines two clips that `projection.invert`
+ * alone misses:
+ *
+ * - the **post-clip** (cartesian) stream rejects device pixels outside the clip
+ *   rectangle — relevant once the map is panned/zoomed with a `clipExtent`;
+ * - streaming the inverted coordinate **back** through the projection applies the
+ *   pre-clip (spherical) boundary and checks the round trip: azimuthal projections
+ *   clamp `invert` outside the visible disk to the limb, and those clamped points do
+ *   not project back to the pixel they came from.
+ */
+export declare function createGetVisibleCoordinate(projection: GeoProjection): ([deviceX, deviceY]: [number, number]) => [number, number] | null;

package/internals/createGetVisibleCoordinate.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGetVisibleCoordinate = createGetVisibleCoordinate;
+// A `GeoStream` sink that only records whether a point passed through (and where),
+// so a projection/clip pipeline can be probed one point at a time.
+
+function createPointSink() {
+  const sink = {
+    hit: false,
+    x: 0,
+    y: 0,
+    point(x, y) {
+      sink.hit = true;
+      sink.x = x;
+      sink.y = y;
+    },
+    lineStart() {},
+    lineEnd() {},
+    polygonStart() {},
+    polygonEnd() {}
+  };
+  return sink;
+}
+
+/**
+ * Builds a test that maps a device pixel to its `[lon, lat]`, or `null` when the
+ * pixel is not part of the visible map. It combines two clips that `projection.invert`
+ * alone misses:
+ *
+ * - the **post-clip** (cartesian) stream rejects device pixels outside the clip
+ *   rectangle — relevant once the map is panned/zoomed with a `clipExtent`;
+ * - streaming the inverted coordinate **back** through the projection applies the
+ *   pre-clip (spherical) boundary and checks the round trip: azimuthal projections
+ *   clamp `invert` outside the visible disk to the limb, and those clamped points do
+ *   not project back to the pixel they came from.
+ */
+function createGetVisibleCoordinate(projection) {
+  const invert = projection.invert;
+  const forwardSink = createPointSink();
+  const forwardStream = projection.stream(forwardSink);
+  const postClip = projection.postclip?.();
+  const clipSink = createPointSink();
+  const clipStream = postClip?.(clipSink);
+  return ([deviceX, deviceY]) => {
+    if (clipStream) {
+      clipSink.hit = false;
+      clipStream.point(deviceX, deviceY);
+      if (!clipSink.hit) {
+        return null;
+      }
+    }
+    const coordinates = invert([deviceX, deviceY]);
+    if (!coordinates) {
+      return null;
+    }
+    forwardSink.hit = false;
+    forwardStream.point(coordinates[0], coordinates[1]);
+    if (!forwardSink.hit || Math.abs(forwardSink.x - deviceX) > 0.5 || Math.abs(forwardSink.y - deviceY) > 0.5) {
+      return null;
+    }
+    return coordinates;
+  };
+}