@mui/x-charts-premium 9.0.3 → 9.1.0

package/ScatterChartPremium/webgl/ScatterWebGLPlot.js

@@ -0,0 +1,70 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScatterWebGLPlot = ScatterWebGLPlot;
+var React = _interopRequireWildcard(require("react"));
+var _hooks = require("@mui/x-charts/hooks");
+var _ChartsWebGLContext = require("../../ChartsWebGLLayer/ChartsWebGLContext");
+var _ScatterWebGLProgram = require("./ScatterWebGLProgram");
+var _useScatterWebGLPlotData = require("./useScatterWebGLPlotData");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * @ignore - Internal component used for rendering the scatter plot using WebGL. Not exported from the package.
+ */
+function ScatterWebGLPlot() {
+  const layer = (0, _ChartsWebGLContext.useWebGLLayer)();
+  const seriesData = (0, _hooks.useScatterSeriesContext)();
+  const hasVisibleSeries = React.useMemo(() => {
+    if (!seriesData) {
+      return false;
+    }
+    return seriesData.seriesOrder.some(id => !seriesData.series[id].hidden);
+  }, [seriesData]);
+  if (!layer || !hasVisibleSeries) {
+    return null;
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(ScatterWebGLPlotImpl, {
+    gl: layer.gl,
+    registerDraw: layer.registerDraw,
+    requestRender: layer.requestRender
+  });
+}
+function ScatterWebGLPlotImpl(props) {
+  const {
+    gl,
+    registerDraw,
+    requestRender
+  } = props;
+  const drawingArea = (0, _hooks.useDrawingArea)();
+  const [program, setProgram] = React.useState(null);
+  React.useEffect(() => {
+    const prog = new _ScatterWebGLProgram.ScatterWebGLProgram(gl);
+    setProgram(prog);
+    return () => {
+      prog.dispose();
+    };
+  }, [gl]);
+  const plotData = (0, _useScatterWebGLPlotData.useScatterWebGLPlotData)();
+  const drawRef = React.useRef(null);
+  React.useEffect(() => {
+    drawRef.current = () => {
+      program?.render(plotData);
+    };
+  }, [program, plotData]);
+  React.useEffect(() => {
+    return registerDraw(drawRef);
+  }, [registerDraw]);
+  React.useEffect(() => {
+    program?.setResolution(drawingArea.width, drawingArea.height);
+    requestRender();
+  }, [drawingArea.height, drawingArea.width, program, requestRender]);
+  React.useEffect(() => {
+    program?.plot(plotData);
+    requestRender();
+  }, [plotData, program, requestRender]);
+  return null;
+}

package/ScatterChartPremium/webgl/ScatterWebGLPlot.mjs

@@ -0,0 +1,65 @@
+'use client';
+
+import * as React from 'react';
+import { useDrawingArea, useScatterSeriesContext } from '@mui/x-charts/hooks';
+import { useWebGLLayer } from "../../ChartsWebGLLayer/ChartsWebGLContext.mjs";
+import { ScatterWebGLProgram } from "./ScatterWebGLProgram.mjs";
+import { useScatterWebGLPlotData } from "./useScatterWebGLPlotData.mjs";
+
+/**
+ * @ignore - Internal component used for rendering the scatter plot using WebGL. Not exported from the package.
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export function ScatterWebGLPlot() {
+  const layer = useWebGLLayer();
+  const seriesData = useScatterSeriesContext();
+  const hasVisibleSeries = React.useMemo(() => {
+    if (!seriesData) {
+      return false;
+    }
+    return seriesData.seriesOrder.some(id => !seriesData.series[id].hidden);
+  }, [seriesData]);
+  if (!layer || !hasVisibleSeries) {
+    return null;
+  }
+  return /*#__PURE__*/_jsx(ScatterWebGLPlotImpl, {
+    gl: layer.gl,
+    registerDraw: layer.registerDraw,
+    requestRender: layer.requestRender
+  });
+}
+function ScatterWebGLPlotImpl(props) {
+  const {
+    gl,
+    registerDraw,
+    requestRender
+  } = props;
+  const drawingArea = useDrawingArea();
+  const [program, setProgram] = React.useState(null);
+  React.useEffect(() => {
+    const prog = new ScatterWebGLProgram(gl);
+    setProgram(prog);
+    return () => {
+      prog.dispose();
+    };
+  }, [gl]);
+  const plotData = useScatterWebGLPlotData();
+  const drawRef = React.useRef(null);
+  React.useEffect(() => {
+    drawRef.current = () => {
+      program?.render(plotData);
+    };
+  }, [program, plotData]);
+  React.useEffect(() => {
+    return registerDraw(drawRef);
+  }, [registerDraw]);
+  React.useEffect(() => {
+    program?.setResolution(drawingArea.width, drawingArea.height);
+    requestRender();
+  }, [drawingArea.height, drawingArea.width, program, requestRender]);
+  React.useEffect(() => {
+    program?.plot(plotData);
+    requestRender();
+  }, [plotData, program, requestRender]);
+  return null;
+}

package/ScatterChartPremium/webgl/ScatterWebGLProgram.d.mts

@@ -0,0 +1,18 @@
+import { type ScatterWebGLPlotData } from "./useScatterWebGLPlotData.mjs";
+export declare class ScatterWebGLProgram {
+  private gl;
+  private readonly shaders;
+  private readonly quadBuffer;
+  private readonly program;
+  private readonly vao;
+  private readonly centers;
+  private readonly sizes;
+  private readonly colors;
+  constructor(gl: WebGL2RenderingContext);
+  setResolution(width: number, height: number): void;
+  plot(plotData: ScatterWebGLPlotData): void;
+  render(plotData: ScatterWebGLPlotData): void;
+  dispose(): void;
+  private setupInstancedAttribute;
+  private uploadBuffer;
+}

package/ScatterChartPremium/webgl/ScatterWebGLProgram.d.ts

@@ -0,0 +1,18 @@
+import { type ScatterWebGLPlotData } from "./useScatterWebGLPlotData.js";
+export declare class ScatterWebGLProgram {
+  private gl;
+  private readonly shaders;
+  private readonly quadBuffer;
+  private readonly program;
+  private readonly vao;
+  private readonly centers;
+  private readonly sizes;
+  private readonly colors;
+  constructor(gl: WebGL2RenderingContext);
+  setResolution(width: number, height: number): void;
+  plot(plotData: ScatterWebGLPlotData): void;
+  render(plotData: ScatterWebGLPlotData): void;
+  dispose(): void;
+  private setupInstancedAttribute;
+  private uploadBuffer;
+}

package/ScatterChartPremium/webgl/ScatterWebGLProgram.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScatterWebGLProgram = void 0;
+var _utils = require("../../utils/webgl/utils");
+var _shaders = require("./shaders");
+const QUAD_VERTICES = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
+class ScatterWebGLProgram {
+  shaders = [];
+  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);
+    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);
+    gl.bindVertexArray(null);
+  }
+  setResolution(width, height) {
+    const {
+      gl
+    } = this;
+    gl.useProgram(this.program);
+    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);
+  }
+  render(plotData) {
+    if (plotData.pointCount === 0) {
+      return;
+    }
+    const {
+      gl
+    } = this;
+    gl.useProgram(this.program);
+    (0, _utils.logWebGLErrors)(gl);
+    gl.bindVertexArray(this.vao);
+    gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, plotData.pointCount);
+    gl.bindVertexArray(null);
+  }
+  dispose() {
+    const {
+      gl
+    } = 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.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
+  };
+}

package/ScatterChartPremium/webgl/ScatterWebGLProgram.mjs

@@ -0,0 +1,122 @@
+import { compileShader, logWebGLErrors } from "../../utils/webgl/utils.mjs";
+import { scatterVertexShader, scatterFragmentShader } from "./shaders.mjs";
+const QUAD_VERTICES = new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]);
+export class ScatterWebGLProgram {
+  shaders = [];
+  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);
+    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);
+    gl.bindVertexArray(null);
+  }
+  setResolution(width, height) {
+    const {
+      gl
+    } = this;
+    gl.useProgram(this.program);
+    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);
+  }
+  render(plotData) {
+    if (plotData.pointCount === 0) {
+      return;
+    }
+    const {
+      gl
+    } = this;
+    gl.useProgram(this.program);
+    logWebGLErrors(gl);
+    gl.bindVertexArray(this.vao);
+    gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, plotData.pointCount);
+    gl.bindVertexArray(null);
+  }
+  dispose() {
+    const {
+      gl
+    } = 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.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/ScatterChartPremium/webgl/shaders.d.mts

@@ -0,0 +1,2 @@
+export declare const scatterVertexShader = "\n  precision highp float;\n  precision mediump int;\n\n  attribute vec2 a_position;\n  attribute highp vec2 a_center;\n  attribute float a_size;\n  attribute mediump vec4 a_color;\n\n  varying mediump vec4 v_color;\n  varying mediump vec2 v_offset;\n  varying mediump float v_radius;\n\n  uniform highp vec2 u_resolution;\n\n  void main() {\n    float radius = a_size * 0.5;\n    vec2 point = a_center + a_position * radius;\n\n    vec2 clipSpace = (point / u_resolution) * 2.0 - 1.0;\n    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);\n\n    v_color = a_color;\n    v_offset = a_position;\n    v_radius = radius;\n  }\n";
+export declare const scatterFragmentShader = "\n  precision mediump float;\n\n  varying mediump vec4 v_color;\n  varying mediump vec2 v_offset;\n  varying mediump float v_radius;\n\n  void main() {\n    float dist = length(v_offset);\n    if (dist > 1.0) {\n      discard;\n    }\n    // Simple antialiased edge: fade the last pixel of the radius.\n    float edge = max(0.0, 1.0 - 1.0 / max(v_radius, 1.0));\n    float alpha = 1.0 - smoothstep(edge, 1.0, dist);\n    gl_FragColor = vec4(v_color.rgb, v_color.a * alpha);\n  }\n";

package/ScatterChartPremium/webgl/shaders.d.ts

@@ -0,0 +1,2 @@
+export declare const scatterVertexShader = "\n  precision highp float;\n  precision mediump int;\n\n  attribute vec2 a_position;\n  attribute highp vec2 a_center;\n  attribute float a_size;\n  attribute mediump vec4 a_color;\n\n  varying mediump vec4 v_color;\n  varying mediump vec2 v_offset;\n  varying mediump float v_radius;\n\n  uniform highp vec2 u_resolution;\n\n  void main() {\n    float radius = a_size * 0.5;\n    vec2 point = a_center + a_position * radius;\n\n    vec2 clipSpace = (point / u_resolution) * 2.0 - 1.0;\n    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);\n\n    v_color = a_color;\n    v_offset = a_position;\n    v_radius = radius;\n  }\n";
+export declare const scatterFragmentShader = "\n  precision mediump float;\n\n  varying mediump vec4 v_color;\n  varying mediump vec2 v_offset;\n  varying mediump float v_radius;\n\n  void main() {\n    float dist = length(v_offset);\n    if (dist > 1.0) {\n      discard;\n    }\n    // Simple antialiased edge: fade the last pixel of the radius.\n    float edge = max(0.0, 1.0 - 1.0 / max(v_radius, 1.0));\n    float alpha = 1.0 - smoothstep(edge, 1.0, dist);\n    gl_FragColor = vec4(v_color.rgb, v_color.a * alpha);\n  }\n";

package/ScatterChartPremium/webgl/shaders.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scatterVertexShader = exports.scatterFragmentShader = void 0;
+// language=Glsl
+// Positions and resolution carry drawing-area pixel coordinates that can
+// exceed the ~1024 range where mediump loses sub-pixel precision on mobile
+// GPUs. They must be highp. v_color stays lowp/mediump to save interpolants.
+const scatterVertexShader = exports.scatterVertexShader = /* glsl */`
+  precision highp float;
+  precision mediump int;
+
+  attribute vec2 a_position;
+  attribute highp vec2 a_center;
+  attribute float a_size;
+  attribute mediump vec4 a_color;
+
+  varying mediump vec4 v_color;
+  varying mediump vec2 v_offset;
+  varying mediump float v_radius;
+
+  uniform highp vec2 u_resolution;
+
+  void main() {
+    float radius = a_size * 0.5;
+    vec2 point = a_center + a_position * radius;
+
+    vec2 clipSpace = (point / u_resolution) * 2.0 - 1.0;
+    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
+
+    v_color = a_color;
+    v_offset = a_position;
+    v_radius = radius;
+  }
+`;
+
+// language=Glsl
+const scatterFragmentShader = exports.scatterFragmentShader = /* glsl */`
+  precision mediump float;
+
+  varying mediump vec4 v_color;
+  varying mediump vec2 v_offset;
+  varying mediump float v_radius;
+
+  void main() {
+    float dist = length(v_offset);
+    if (dist > 1.0) {
+      discard;
+    }
+    // Simple antialiased edge: fade the last pixel of the radius.
+    float edge = max(0.0, 1.0 - 1.0 / max(v_radius, 1.0));
+    float alpha = 1.0 - smoothstep(edge, 1.0, dist);
+    gl_FragColor = vec4(v_color.rgb, v_color.a * alpha);
+  }
+`;

package/ScatterChartPremium/webgl/shaders.mjs

@@ -0,0 +1,51 @@
+// language=Glsl
+// Positions and resolution carry drawing-area pixel coordinates that can
+// exceed the ~1024 range where mediump loses sub-pixel precision on mobile
+// GPUs. They must be highp. v_color stays lowp/mediump to save interpolants.
+export const scatterVertexShader = /* glsl */`
+  precision highp float;
+  precision mediump int;
+
+  attribute vec2 a_position;
+  attribute highp vec2 a_center;
+  attribute float a_size;
+  attribute mediump vec4 a_color;
+
+  varying mediump vec4 v_color;
+  varying mediump vec2 v_offset;
+  varying mediump float v_radius;
+
+  uniform highp vec2 u_resolution;
+
+  void main() {
+    float radius = a_size * 0.5;
+    vec2 point = a_center + a_position * radius;
+
+    vec2 clipSpace = (point / u_resolution) * 2.0 - 1.0;
+    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
+
+    v_color = a_color;
+    v_offset = a_position;
+    v_radius = radius;
+  }
+`;
+
+// language=Glsl
+export const scatterFragmentShader = /* glsl */`
+  precision mediump float;
+
+  varying mediump vec4 v_color;
+  varying mediump vec2 v_offset;
+  varying mediump float v_radius;
+
+  void main() {
+    float dist = length(v_offset);
+    if (dist > 1.0) {
+      discard;
+    }
+    // Simple antialiased edge: fade the last pixel of the radius.
+    float edge = max(0.0, 1.0 - 1.0 / max(v_radius, 1.0));
+    float alpha = 1.0 - smoothstep(edge, 1.0, dist);
+    gl_FragColor = vec4(v_color.rgb, v_color.a * alpha);
+  }
+`;

package/ScatterChartPremium/webgl/useScatterWebGLPlotData.d.mts

@@ -0,0 +1,7 @@
+export interface ScatterWebGLPlotData {
+  centers: Float32Array;
+  sizes: Float32Array;
+  colors: Uint8Array;
+  pointCount: number;
+}
+export declare function useScatterWebGLPlotData(): ScatterWebGLPlotData;

package/ScatterChartPremium/webgl/useScatterWebGLPlotData.d.ts

@@ -0,0 +1,7 @@
+export interface ScatterWebGLPlotData {
+  centers: Float32Array;
+  sizes: Float32Array;
+  colors: Uint8Array;
+  pointCount: number;
+}
+export declare function useScatterWebGLPlotData(): ScatterWebGLPlotData;