minerva-design 1.2.0 → 1.4.0

package/dist/charts/engine/three-d/types.d.ts

@@ -0,0 +1,588 @@
+import { ChartRendererKind, ChartRendererPreference } from '../types.js';
+/** How a 3D series is drawn */
+export type Chart3DSeriesType = "scatter" | "surface" | "bar" | "line";
+/**
+ * Built-in color ramps, from the lowest to the highest value: perceptually
+ * uniform (`viridis`, `plasma`, `inferno`, `magma`, `cividis`), rainbow
+ * (`turbo`, `spectral`), diverging (`coolwarm`), elevation (`terrain`) and
+ * sequential (`blues`)
+ */
+export type Chart3DColorMap = "viridis" | "plasma" | "inferno" | "magma" | "cividis" | "turbo" | "spectral" | "coolwarm" | "terrain" | "blues";
+/** A built-in ramp, or two or more CSS colors from the lowest to the highest value */
+export type Chart3DColorScale = Chart3DColorMap | readonly string[];
+/**
+ * What sets the color of the points, cells or bars: the series color, the
+ * height (`z`) or the `value` of the data, both through the chart's
+ * `colorScale`
+ */
+export type Chart3DColorBy = "series" | "z" | "value";
+/** One 3D datum written as an object */
+export interface Chart3DPoint {
+    x: number;
+    y: number;
+    /** Height (vertical axis) */
+    z: number;
+    /** Diameter of the dot in CSS pixels (scatter) */
+    size?: number;
+    /** Color of the dot (any CSS color); wins over the series color and the color scale */
+    color?: string;
+    /** Value mapped to the color scale (`colorBy: "value"`) */
+    value?: number;
+    /** Text shown in the tooltip */
+    label?: string;
+}
+/**
+ * Column-oriented 3D data: the fastest form for large data sets (typed
+ * arrays are used as is, `NaN` skips a point)
+ */
+export interface Chart3DColumnData {
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** Heights (vertical axis) */
+    z: ArrayLike<number>;
+    /** Per-point diameters in CSS pixels (scatter) */
+    size?: ArrayLike<number>;
+    /** Per-point values mapped to the color scale (`colorBy: "value"`) */
+    value?: ArrayLike<number>;
+    /** Per-point texts shown in the tooltip */
+    label?: readonly string[];
+}
+/** Points of a scatter or line series: objects, `[x, y, z]` tuples or columns */
+export type Chart3DPointData = readonly Chart3DPoint[] | readonly (readonly [number, number, number])[] | Chart3DColumnData;
+/** Options shared by every 3D series */
+export interface Chart3DSeriesBase {
+    /** Stable identifier (defaults to the index) */
+    id?: string;
+    /** Name shown in the legend and the tooltip */
+    name?: string;
+    /** Series color (any CSS color, `var(--x)` included); the palette when omitted */
+    color?: string;
+    /** Hides the series (it stays in the legend) */
+    hidden?: boolean;
+    /**
+     * Formats the `value` of the hovered item in the tooltip (its height when
+     * the data has no values); the axis formats by default
+     */
+    format?: (value: number) => string;
+}
+/** A cloud of 3D points */
+export interface Scatter3DSeries extends Chart3DSeriesBase {
+    /**
+     * Set by the chart components; `createChart3D` treats series without a
+     * type as scatter series
+     * @default "scatter"
+     */
+    type?: "scatter";
+    /** The points */
+    data: Chart3DPointData;
+    /**
+     * Dot diameter in CSS pixels (per-point `size` wins)
+     * @default 6
+     */
+    pointSize?: number;
+    /**
+     * Opacity of the dots, 0-1
+     * @default 1
+     */
+    opacity?: number;
+    /**
+     * Source of the dot colors
+     * @default "value" when the data has values, "series" otherwise
+     */
+    colorBy?: Chart3DColorBy;
+    /**
+     * Scales the dots with their distance (perspective projection only)
+     * @default true
+     */
+    perspectiveSize?: boolean;
+}
+/** A 3D polyline (trajectory); `NaN` coordinates break the line */
+export interface Line3DSeries extends Chart3DSeriesBase {
+    type?: "line";
+    /** The vertices, in drawing order */
+    data: Chart3DPointData;
+    /**
+     * Line width in CSS pixels
+     * @default 2
+     */
+    lineWidth?: number;
+    /**
+     * Opacity of the line, 0-1
+     * @default 1
+     */
+    opacity?: number;
+    /**
+     * Source of the line color (a gradient along the line for `z` / `value`)
+     * @default "value" when the data has values, "series" otherwise
+     */
+    colorBy?: Chart3DColorBy;
+    /**
+     * Diameter of a dot drawn at every vertex, in CSS pixels (0: no dots)
+     * @default 0
+     */
+    pointSize?: number;
+}
+/**
+ * Heights of a regular grid, `z = f(x, y)`: `rows × cols` values stored row
+ * by row (row `r` is `y[r]`, column `c` is `x[c]`); `NaN` leaves a hole
+ */
+export interface Surface3DData {
+    /** Number of rows (y samples), 2 or more */
+    rows: number;
+    /** Number of columns (x samples), 2 or more */
+    cols: number;
+    /** `rows × cols` heights, row-major (`Float32Array` recommended) */
+    z: ArrayLike<number>;
+    /** X coordinates of the columns (`cols` values); `0 … cols - 1` when omitted */
+    x?: ArrayLike<number>;
+    /** Y coordinates of the rows (`rows` values); `0 … rows - 1` when omitted */
+    y?: ArrayLike<number>;
+    /** `rows × cols` values mapped to the color scale instead of the heights (`colorBy: "value"`) */
+    value?: ArrayLike<number>;
+}
+/** Contour lines of a surface */
+export interface Surface3DContourOptions {
+    /**
+     * Number of levels, spread over the height range (ignored with `levels`)
+     * @default 10
+     */
+    count?: number;
+    /** Heights of the lines */
+    levels?: readonly number[];
+    /**
+     * Projects the lines on the floor of the axis box
+     * @default true
+     */
+    floor?: boolean;
+    /**
+     * Draws the lines on the surface itself
+     * @default false
+     */
+    surface?: boolean;
+    /** Line color (any CSS color); each level takes its color-scale color when omitted */
+    color?: string;
+    /**
+     * Line width in CSS pixels
+     * @default 1
+     */
+    width?: number;
+}
+/** Wireframe drawn over a surface */
+export interface Surface3DWireframeOptions {
+    /** Line color (any CSS color); a contrasting tint of the text color when omitted */
+    color?: string;
+    /**
+     * Draws every n-th grid line
+     * @default 1 (a line every 64 rows / columns at most)
+     */
+    step?: number;
+    /**
+     * Line width in CSS pixels
+     * @default 1
+     */
+    width?: number;
+}
+/** A surface over a regular grid */
+export interface Surface3DSeries extends Chart3DSeriesBase {
+    type?: "surface";
+    /** Grid of heights */
+    data: Surface3DData;
+    /**
+     * Source of the colors: the height (`z`), the `value` grid or the series color
+     * @default "value" when the data has values, "z" otherwise
+     */
+    colorBy?: Chart3DColorBy;
+    /**
+     * Opacity of the surface, 0-1 (below 1 the surface does not hide what is behind it)
+     * @default 1
+     */
+    opacity?: number;
+    /**
+     * Grid lines over the surface
+     * @default false
+     */
+    wireframe?: boolean | Surface3DWireframeOptions;
+    /**
+     * Contour lines (on the floor by default)
+     * @default false
+     */
+    contours?: boolean | Surface3DContourOptions;
+    /**
+     * Draws the faces; `false` keeps only the wireframe / contours
+     * @default true
+     */
+    fill?: boolean;
+}
+/** One bar: a cell of the x × y category grid and its height */
+export interface Bar3DDatum {
+    /** X category (a name, or its index) */
+    x: string | number;
+    /** Y category (a name, or its index) */
+    y: string | number;
+    /** Height; `null` leaves the cell empty */
+    z: number | null;
+    /** Bar color (any CSS color); wins over the series color and the color scale */
+    color?: string;
+    /** Value mapped to the color scale (`colorBy: "value"`); the height by default */
+    value?: number;
+    /** Text shown in the tooltip */
+    label?: string;
+}
+/** Bars over an x × y category grid; bars of several series in the same cell are stacked */
+export interface Bar3DSeries extends Chart3DSeriesBase {
+    type?: "bar";
+    /** The bars: objects or `[x, y, z]` tuples */
+    data: readonly Bar3DDatum[] | readonly (readonly [string | number, string | number, number | null])[];
+    /**
+     * Source of the bar colors
+     * @default "series"
+     */
+    colorBy?: Chart3DColorBy;
+    /**
+     * Opacity of the bars, 0-1
+     * @default 1
+     */
+    opacity?: number;
+    /**
+     * Width of the bars as a fraction of a cell, 0-1
+     * @default 0.7
+     */
+    barWidth?: number;
+}
+/** A 3D data series */
+export type Chart3DSeries = Scatter3DSeries | Surface3DSeries | Bar3DSeries | Line3DSeries;
+/** Options of a 3D axis */
+export interface Chart3DAxisOptions {
+    /** Axis title */
+    title?: string;
+    /** Lower bound; computed from the data when omitted */
+    min?: number;
+    /** Upper bound; computed from the data when omitted */
+    max?: number;
+    /**
+     * Category names (x / y axes of bar charts); collected from the data when
+     * omitted. Setting them makes the axis a category axis.
+     */
+    categories?: readonly string[];
+    /** Formats a tick / tooltip value (category axes: the category index) */
+    format?: (value: number) => string;
+    /**
+     * Approximate number of ticks
+     * @default 5
+     */
+    tickCount?: number;
+    /**
+     * Draws grid lines at the ticks on the walls of the box
+     * @default true
+     */
+    grid?: boolean;
+    /**
+     * Shows the tick labels and the title
+     * @default true
+     */
+    visible?: boolean;
+    /**
+     * Rounds the automatic range to tick values
+     * @default true
+     */
+    nice?: boolean;
+}
+/** Projection of the camera */
+export type Chart3DProjection = "perspective" | "orthographic";
+/** Camera position around the center of the box */
+export interface Chart3DCameraOptions {
+    /**
+     * Horizontal angle in degrees, counterclockwise seen from above (0 looks
+     * along the y axis)
+     * @default 35
+     */
+    azimuth?: number;
+    /**
+     * Height angle in degrees (-89 … 89; positive looks from above)
+     * @default 24
+     */
+    elevation?: number;
+    /**
+     * Zoom: 1 fits the box, 2 shows it twice as large
+     * @default 1
+     */
+    zoom?: number;
+    /**
+     * Perspective (vanishing lines) or orthographic (parallel lines)
+     * @default "perspective"
+     */
+    projection?: Chart3DProjection;
+    /**
+     * Vertical field of view in degrees (perspective)
+     * @default 32
+     */
+    fov?: number;
+}
+/** Current camera, reported by `camera` events and `getCamera()` */
+export interface Chart3DCameraState {
+    /** Horizontal angle in degrees */
+    azimuth: number;
+    /** Height angle in degrees */
+    elevation: number;
+    /** Zoom factor (1 fits the box) */
+    zoom: number;
+    /** Shift of the box center in screen space, as fractions of the plot height */
+    pan: [number, number];
+    projection: Chart3DProjection;
+}
+/** Rotation / zoom / pan options */
+export interface Chart3DInteractionOptions {
+    /**
+     * Drag (one finger) rotates the camera
+     * @default true
+     */
+    rotate?: boolean;
+    /**
+     * Wheel and pinch zoom
+     * @default true
+     */
+    zoom?: boolean;
+    /**
+     * Wheel zoom: only with Ctrl / ⌘ (and trackpad pinch) or always
+     * @default "modifier"
+     */
+    wheel?: "modifier" | "always";
+    /**
+     * Right-drag, Shift + drag and two-finger drag pan the view
+     * @default true
+     */
+    pan?: boolean;
+    /**
+     * Arrow keys rotate, +/- zoom, 0 resets, Esc clears the highlight
+     * @default true
+     */
+    keyboard?: boolean;
+}
+/** Lighting of the surfaces and bars */
+export interface Chart3DLightingOptions {
+    /**
+     * Light reaching every face, 0-1
+     * @default 0.5
+     */
+    ambient?: number;
+    /**
+     * Strength of the directional light (Lambert), 0-1
+     * @default 0.6
+     */
+    diffuse?: number;
+    /**
+     * Strength of the highlights (Blinn-Phong), 0-1
+     * @default 0.25
+     */
+    specular?: number;
+    /**
+     * Sharpness of the highlights
+     * @default 32
+     */
+    shininess?: number;
+}
+/** Color bar of the color scale */
+export interface Chart3DColorBarOptions {
+    /** Title above the bar */
+    title?: string;
+    /** Formats the values of the bar (the z axis format by default) */
+    format?: (value: number) => string;
+}
+/** Legend options */
+export interface Chart3DLegendOptions {
+    /**
+     * Legend position
+     * @default "top"
+     */
+    position?: "top" | "bottom";
+    /**
+     * Clicking an item toggles its series
+     * @default true
+     */
+    toggle?: boolean;
+}
+/** Tooltip options */
+export interface Chart3DTooltipOptions {
+    /** Renders the tooltip content (a string is set as text) */
+    render?: (event: Chart3DHoverEvent) => string | Node | null;
+}
+/** Options of `createChart3D` */
+export interface Chart3DOptions {
+    /** Data series (scatter, surface, bar and line series can be mixed) */
+    series: readonly Chart3DSeries[];
+    /** X axis (width) */
+    xAxis?: Chart3DAxisOptions;
+    /** Y axis (depth) */
+    yAxis?: Chart3DAxisOptions;
+    /** Z axis (height) */
+    zAxis?: Chart3DAxisOptions;
+    /** Initial camera (also the position restored by a double click) */
+    camera?: Chart3DCameraOptions;
+    /**
+     * Turns the camera around the box: `true` at 12°/s, or a speed in
+     * degrees per second (negative turns clockwise). Pauses while the pointer
+     * is over the chart, when it is off-screen and with `prefers-reduced-motion`.
+     * @default false
+     */
+    autoRotate?: boolean | number;
+    /**
+     * Proportions of the box (x, y, z)
+     * @default [1, 1, 0.7]
+     */
+    aspect?: readonly [number, number, number];
+    /**
+     * Draws the axis box: back walls, grid lines, tick labels and axis titles
+     * @default true
+     */
+    box?: boolean;
+    /**
+     * Colors of `colorBy: "z"` / `"value"`: a built-in ramp or CSS colors
+     * @default "viridis"
+     */
+    colorScale?: Chart3DColorScale;
+    /** Values mapped to the ends of the color scale; the data range by default */
+    valueRange?: readonly [number, number];
+    /** Color bar of the color scale; shown by default when a visible series uses it */
+    colorBar?: boolean | Chart3DColorBarOptions;
+    /** Legend; shown by default when there are several named series */
+    legend?: boolean | Chart3DLegendOptions;
+    /** Tooltip; `false` disables it */
+    tooltip?: boolean | Chart3DTooltipOptions;
+    /** Rotation / zoom / pan / keyboard; `false` makes the chart static */
+    interaction?: boolean | Chart3DInteractionOptions;
+    /** Lighting of the surfaces and bars */
+    lighting?: Chart3DLightingOptions;
+    /**
+     * Backend of the data layer: `auto` tries WebGPU, then WebGL2, then WebGL,
+     * then Canvas2D (CPU projection, decimated) and skips GPUs running in software
+     * @default "auto"
+     */
+    renderer?: ChartRendererPreference;
+    /** Colors of the series without `color` (defaults to the `--chart-series-1..8` CSS variables, then the theme colors) */
+    palette?: readonly string[];
+    /** Accessible name of the chart */
+    ariaLabel?: string;
+    /**
+     * Language of the built-in texts (accessible summary, legend announcements,
+     * tooltip row names) and of the number formatting (`Intl.NumberFormat`,
+     * compact units such as k / M or 万 / 亿). Built-in texts exist in English,
+     * Chinese, Japanese and French; other languages fall back to English.
+     * @default the page language (`<html lang>`), then the browser language
+     */
+    locale?: string;
+    /** Overrides of the built-in texts of the `locale` */
+    labels?: Partial<Chart3DLabels>;
+}
+/**
+ * Built-in texts of the 3D charts. Templates replace `{name}`-style
+ * placeholders.
+ */
+export interface Chart3DLabels {
+    /** Role description and accessible name of an unnamed chart @default "3D chart" */
+    chart: string;
+    /** Accessible name when series are named; `{names}` @default "3D chart: {names}" */
+    chartNamed: string;
+    /** Name of an unnamed series; `{n}` is its 1-based position @default "Series {n}" */
+    series: string;
+    /** Summary: number of series; `{count}` @default "{count} series." */
+    seriesCount: string;
+    /** Summary of a series; `{name}`, `{type}`, `{size}` @default "{name} ({type}): {size}." */
+    seriesSummary: string;
+    /** Summary of a hidden series; `{name}`, `{type}`, `{size}` @default "{name} ({type}): {size}, hidden." */
+    seriesSummaryHidden: string;
+    /** Type name of scatter series @default "scatter" */
+    scatter: string;
+    /** Type name of line series @default "line" */
+    line: string;
+    /** Type name of surface series @default "surface" */
+    surface: string;
+    /** Type name of bar series @default "bar" */
+    bar: string;
+    /** Size of a scatter series; `{count}` @default "{count} points" */
+    points: string;
+    /** Size of a line series; `{count}` @default "{count} vertices" */
+    vertices: string;
+    /** Size of a surface series; `{rows}`, `{cols}` @default "{rows} × {cols} grid" */
+    grid: string;
+    /** Size of a bar series; `{count}` @default "{count} bars" */
+    bars: string;
+    /** Summary of an axis without title; `{axis}`, `{range}` @default "{axis} axis: {range}." */
+    axis: string;
+    /** Summary of an axis with a title; `{axis}`, `{title}`, `{range}` @default "{axis} axis ({title}): {range}." */
+    axisTitled: string;
+    /** Range of a numeric axis; `{min}`, `{max}` @default "{min} to {max}" */
+    range: string;
+    /** Separator of the lists (series names, categories) @default ", " */
+    listSeparator: string;
+    /** Announcement when the legend shows a series; `{name}` @default "{name}: shown" */
+    shown: string;
+    /** Announcement when the legend hides a series; `{name}` @default "{name}: hidden" */
+    hidden: string;
+    /** Tooltip row of the `value` (when the color bar has no title) @default "value" */
+    value: string;
+    /** Tooltip row of x when the axis has no title @default "x" */
+    x: string;
+    /** Tooltip row of y when the axis has no title @default "y" */
+    y: string;
+    /** Tooltip row of z when the axis has no title @default "z" */
+    z: string;
+}
+/** The point, surface cell or bar under the pointer */
+export interface Chart3DHoverEvent {
+    seriesIndex: number;
+    seriesId: string;
+    seriesName: string;
+    /** Type of the series */
+    type: Chart3DSeriesType;
+    /** Index of the point / bar in the series data; surfaces: `row * cols + col` */
+    index: number;
+    /** Surfaces: row of the grid vertex */
+    row?: number;
+    /** Surfaces: column of the grid vertex */
+    col?: number;
+    x: number;
+    y: number;
+    z: number;
+    /** Color-scale value (`value` of the data) */
+    value?: number;
+    /** Bars: category names */
+    xCategory?: string;
+    yCategory?: string;
+    /** Resolved color of the point / cell / bar */
+    color: string;
+    label?: string;
+    /** Position of the item in CSS pixels, relative to the chart's container */
+    clientX: number;
+    clientY: number;
+}
+/** Events of a 3D chart instance */
+export interface Chart3DEventMap {
+    hover: Chart3DHoverEvent | null;
+    click: Chart3DHoverEvent;
+    /** The camera moved (rotation, zoom, pan, reset; not the automatic rotation) */
+    camera: Chart3DCameraState;
+    renderer: ChartRendererKind;
+}
+/** Chart created by `createChart3D` */
+export interface Chart3DInstance {
+    /** Replaces the options (unchanged data arrays are not processed again) */
+    setOptions(options: Chart3DOptions): void;
+    /** Measures the container again (a ResizeObserver does it automatically) */
+    resize(): void;
+    /** Restores the camera of the options */
+    resetCamera(): void;
+    /** Current camera */
+    getCamera(): Chart3DCameraState;
+    /** Moves the camera */
+    setCamera(camera: Partial<Chart3DCameraState>): void;
+    /** Backend in use, `null` until ready */
+    getRenderer(): ChartRendererKind | null;
+    /** Resolves with the backend once the first frame can be drawn (`null` when the browser has no canvas support) */
+    ready: Promise<ChartRendererKind | null>;
+    /** Reads the CSS variables again (theme changes on `<html>` / `<body>` are detected automatically) */
+    refreshTheme(): void;
+    /** Subscribes to an event; returns the unsubscribe function */
+    on<K extends keyof Chart3DEventMap>(type: K, listener: (event: Chart3DEventMap[K]) => void): () => void;
+    /** Removes the DOM and frees the GPU resources */
+    destroy(): void;
+}

package/dist/charts/engine/three-d/webgl.cjs

@@ -0,0 +1,2 @@
+const e=require("./render-types.cjs"),t=require("./shaders.cjs");var n=/swiftshader|llvmpipe|softpipe|software|basic render driver|microsoft basic/i,r=e=>{let t=e.getExtension(`WEBGL_debug_renderer_info`),r=t?e.getParameter(t.UNMASKED_RENDERER_WEBGL):e.getParameter(e.RENDERER);return n.test(String(r??``))},i=[`u_viewProj`,`u_viewport`,`u_eye`,`u_light`,`u_material`,`u_params`,`u_fog`],a=(e,t,n)=>{let r=(t,n)=>{let r=e.createShader(t);return r?(e.shaderSource(r,n),e.compileShader(r),e.getShaderParameter(r,e.COMPILE_STATUS)?r:(e.deleteShader(r),null)):null},a=r(e.VERTEX_SHADER,t.vertex),o=r(e.FRAGMENT_SHADER,t.fragment),s=e.createProgram();if(!a||!o||!s)return null;if(e.attachShader(s,a),e.attachShader(s,o),n.forEach((t,n)=>e.bindAttribLocation(s,n,t)),e.linkProgram(s),e.deleteShader(a),e.deleteShader(o),!e.getProgramParameter(s,e.LINK_STATUS))return e.deleteProgram(s),null;let c={};for(let t of i)c[t]=e.getUniformLocation(s,t);return{program:s,uniforms:c}},o=new Float32Array([0,0,1,0,0,1,1,1]),s=4,c=(n,i,c,l=!1)=>{let u={alpha:!0,premultipliedAlpha:!0,antialias:!0,depth:!0,stencil:!1,preserveDrawingBuffer:!1,failIfMajorPerformanceCaveat:l},d=n.getContext(i===2?`webgl2`:`webgl`,u);if(!d)return null;let f=()=>d.getExtension(`WEBGL_lose_context`)?.loseContext(),p=i===2?d:null,m=p?null:d.getExtension(`ANGLE_instanced_arrays`),h=p?!0:!!d.getExtension(`OES_element_index_uint`);if(!p&&(!m||!h)||l&&r(d))return f(),null;let g=(e,t)=>{p?p.vertexAttribDivisor(e,t):m?.vertexAttribDivisorANGLE(e,t)},_=e=>{p?p.drawArraysInstanced(d.TRIANGLE_STRIP,0,4,e):m?.drawArraysInstancedANGLE(d.TRIANGLE_STRIP,0,4,e)},v=t.glslPrograms(i),y=a(d,v.points,t.GLSL_ATTRIBUTES.points),b=a(d,v.mesh,t.GLSL_ATTRIBUTES.mesh),x=a(d,v.lines,t.GLSL_ATTRIBUTES.lines),S=d.createBuffer();if(!y||!b||!x||!S)return f(),null;let C={points:y,mesh:b,lines:x};d.bindBuffer(d.ARRAY_BUFFER,S),d.bufferData(d.ARRAY_BUFFER,o,d.STATIC_DRAW);let w=!1,T=e=>{e.preventDefault(),w=!0,c()};n.addEventListener(`webglcontextlost`,T);let E=new Map,D=new Float32Array(40),O=(e,t,n,r,i,a)=>{d.enableVertexAttribArray(e),d.vertexAttribPointer(e,t,n,n===d.UNSIGNED_BYTE,r,i),g(e,+!!a)},k=(e,t)=>{let n=d.FLOAT,r=d.UNSIGNED_BYTE,i;e.kind===`mesh`?(d.bindBuffer(d.ARRAY_BUFFER,t.vertex),O(0,3,n,28,0,!1),O(1,3,n,28,12,!1),O(2,4,r,28,24,!1),i=3):(d.bindBuffer(d.ARRAY_BUFFER,S),O(0,2,n,0,0,!1),d.bindBuffer(d.ARRAY_BUFFER,t.vertex),e.kind===`points`?(O(1,3,n,20,0,!0),O(2,1,n,20,12,!0),O(3,4,r,20,16,!0)):(O(1,3,n,28,0,!0),O(2,3,n,28,12,!0),O(3,4,r,28,24,!0)),i=4);for(let e=i;e<s;e++)d.disableVertexAttribArray(e),g(e,0)},A=e=>{let t=E.get(e.key);if(t&&t.version===e.version&&t.kind===e.kind)return e.kind===`mesh`&&t.index&&(e.order??0)!==t.order&&(d.bindBuffer(d.ELEMENT_ARRAY_BUFFER,t.index),d.bufferSubData(d.ELEMENT_ARRAY_BUFFER,0,e.indices),t.order=e.order??0),t;t&&(d.deleteBuffer(t.vertex),t.index&&d.deleteBuffer(t.index),E.delete(e.key));let n=d.createBuffer();if(!n)return null;d.bindBuffer(d.ARRAY_BUFFER,n),d.bufferData(d.ARRAY_BUFFER,e.kind===`mesh`?e.vertices:e.data,d.STATIC_DRAW);let r=null;if(e.kind===`mesh`){if(r=d.createBuffer(),!r)return d.deleteBuffer(n),null;d.bindBuffer(d.ELEMENT_ARRAY_BUFFER,r),d.bufferData(d.ELEMENT_ARRAY_BUFFER,e.indices,e.order===void 0?d.STATIC_DRAW:d.DYNAMIC_DRAW)}let i={version:e.version,kind:e.kind,vertex:n,index:r,order:e.kind===`mesh`?e.order??0:0};return E.set(e.key,i),i};return{kind:i===2?`webgl2`:`webgl`,canvas:n,resize(e,t){n.width=Math.max(1,e),n.height=Math.max(1,t)},render(r,i){if(w||d.isContextLost())return;d.viewport(0,0,n.width,n.height),d.clearColor(0,0,0,0),d.clearDepth(1),d.depthMask(!0),d.clear(d.COLOR_BUFFER_BIT|d.DEPTH_BUFFER_BIT),d.enable(d.BLEND),d.blendFunc(d.ONE,d.ONE_MINUS_SRC_ALPHA),d.enable(d.DEPTH_TEST),d.depthFunc(d.LEQUAL),d.disable(d.CULL_FACE);let a=new Set;for(let n of e.drawOrder(r)){a.add(n.key);let e=n.kind===`mesh`?n.indices.length:n.count;if(e<=0)continue;let r=A(n);if(!r)continue;let o=C[n.kind];d.useProgram(o.program);let s=t.itemUniforms(n,i,D),c=o.uniforms;d.uniformMatrix4fv(c.u_viewProj,!1,s.subarray(0,16)),d.uniform4fv(c.u_viewport,s.subarray(16,20)),d.uniform4fv(c.u_eye,s.subarray(20,24)),d.uniform4fv(c.u_light,s.subarray(24,28)),d.uniform4fv(c.u_material,s.subarray(28,32)),d.uniform4fv(c.u_params,s.subarray(32,36)),d.uniform4fv(c.u_fog,s.subarray(36,40)),d.depthMask(t.writesDepth(n)),k(n,r),n.kind===`mesh`?(d.bindBuffer(d.ELEMENT_ARRAY_BUFFER,r.index),d.drawElements(d.TRIANGLES,e,d.UNSIGNED_INT,0)):_(e)}d.depthMask(!0);for(let[e,t]of E)a.has(e)||(d.deleteBuffer(t.vertex),t.index&&d.deleteBuffer(t.index),E.delete(e))},destroy(){if(n.removeEventListener(`webglcontextlost`,T),!d.isContextLost()){for(let e of E.values())d.deleteBuffer(e.vertex),e.index&&d.deleteBuffer(e.index);for(let e of Object.values(C))d.deleteProgram(e.program);d.deleteBuffer(S)}E.clear(),f()}}};exports.SOFTWARE_RENDERER=n,exports.createWebGl3D=c,exports.isSoftwareRenderer=r;
+//# sourceMappingURL=webgl.cjs.map

package/dist/charts/engine/three-d/webgl.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl.cjs","names":["glslPrograms","GLSL_ATTRIBUTES","drawOrder","itemUniforms","writesDepth","require_render_types","require_shaders","SOFTWARE_RENDERER","isSoftwareRenderer","info","gl","name","UNIFORMS","compile","shader","s","type","code","vs","source","fs","program","attributes","i","uniforms","CORNERS","MAX_LOCATIONS","createWebGl3D","requireHardware","canvas","version","loseContext","gl2","angle","uint","divisor","location","value","drawInstanced","count","sources","points","mesh","lines","corners","programs","lost","handleLost","event","onLost","resources","uniformData","attribute","size","stride","offset","bind","F","U8","used","item","res","upload","existing","vertex","index","width","height","seen","items","u","frame","loc","key","p"],"sources":["../../../../../charts/src/engine/three-d/webgl.ts"],"sourcesContent":["// WebGL2 / WebGL (1) backend of the 3D charts: the same GLSL for both\n// (a macro prefix makes it GLSL ES 3.0), instancing through WebGL2 or\n// ANGLE_instanced_arrays, 32-bit indices through WebGL2 or\n// OES_element_index_uint. Attributes are bound for every draw (no vertex\n// array objects in WebGL 1): a few calls per item.\n\nimport type { RendererLostHandler } from \"../renderers/types\";\nimport {\n  POINT_STRIDE,\n  SEGMENT_STRIDE,\n  VERTEX_STRIDE,\n  drawOrder,\n  type Item3D,\n  type Renderer3D,\n} from \"./render-types\";\nimport {\n  GLSL_ATTRIBUTES,\n  glslPrograms,\n  itemUniforms,\n  writesDepth,\n  type GlslSource,\n} from \"./shaders\";\n\ntype Gl = WebGLRenderingContext | WebGL2RenderingContext;\n\n/** Software rasterizers behind a WebGL context */\nexport const SOFTWARE_RENDERER =\n  /swiftshader|llvmpipe|softpipe|software|basic render driver|microsoft basic/i;\n\nexport const isSoftwareRenderer = (gl: Gl): boolean => {\n  const info = gl.getExtension(\"WEBGL_debug_renderer_info\");\n  const name = info\n    ? gl.getParameter(info.UNMASKED_RENDERER_WEBGL)\n    : gl.getParameter(gl.RENDERER);\n  return SOFTWARE_RENDERER.test(String(name ?? \"\"));\n};\n\nconst UNIFORMS = [\n  \"u_viewProj\",\n  \"u_viewport\",\n  \"u_eye\",\n  \"u_light\",\n  \"u_material\",\n  \"u_params\",\n  \"u_fog\",\n] as const;\n\ninterface Program {\n  program: WebGLProgram;\n  uniforms: Record<(typeof UNIFORMS)[number], WebGLUniformLocation | null>;\n}\n\nconst compile = (\n  gl: Gl,\n  source: GlslSource,\n  attributes: readonly string[],\n): Program | null => {\n  const shader = (type: number, code: string) => {\n    const s = gl.createShader(type);\n    if (!s) return null;\n    gl.shaderSource(s, code);\n    gl.compileShader(s);\n    if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {\n      gl.deleteShader(s);\n      return null;\n    }\n    return s;\n  };\n  const vs = shader(gl.VERTEX_SHADER, source.vertex);\n  const fs = shader(gl.FRAGMENT_SHADER, source.fragment);\n  const program = gl.createProgram();\n  if (!vs || !fs || !program) return null;\n  gl.attachShader(program, vs);\n  gl.attachShader(program, fs);\n  attributes.forEach((name, i) => gl.bindAttribLocation(program, i, name));\n  gl.linkProgram(program);\n  gl.deleteShader(vs);\n  gl.deleteShader(fs);\n  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {\n    gl.deleteProgram(program);\n    return null;\n  }\n  const uniforms = {} as Program[\"uniforms\"];\n  for (const name of UNIFORMS)\n    uniforms[name] = gl.getUniformLocation(program, name);\n  return { program, uniforms };\n};\n\ninterface ItemResources {\n  version: number;\n  kind: Item3D[\"kind\"];\n  vertex: WebGLBuffer;\n  index: WebGLBuffer | null;\n  /** `order` of the uploaded indices (meshes) */\n  order: number;\n}\n\n/** Corners of the triangle strip of a billboard / segment */\nconst CORNERS = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);\nconst MAX_LOCATIONS = 4;\n\nexport const createWebGl3D = (\n  canvas: HTMLCanvasElement,\n  version: 1 | 2,\n  onLost: RendererLostHandler,\n  /** Refuses software rendering: the decimating Canvas2D backend is faster there */\n  requireHardware = false,\n): Renderer3D | null => {\n  const attributes: WebGLContextAttributes = {\n    alpha: true,\n    premultipliedAlpha: true,\n    antialias: true,\n    depth: true,\n    stencil: false,\n    preserveDrawingBuffer: false,\n    failIfMajorPerformanceCaveat: requireHardware,\n  };\n  const gl = canvas.getContext(\n    version === 2 ? \"webgl2\" : \"webgl\",\n    attributes,\n  ) as Gl | null;\n  if (!gl) return null;\n  const loseContext = () =>\n    gl.getExtension(\"WEBGL_lose_context\")?.loseContext();\n  const gl2 = version === 2 ? (gl as WebGL2RenderingContext) : null;\n  const angle = gl2 ? null : gl.getExtension(\"ANGLE_instanced_arrays\");\n  const uint = gl2 ? true : !!gl.getExtension(\"OES_element_index_uint\");\n  if (\n    (!gl2 && (!angle || !uint)) ||\n    (requireHardware && isSoftwareRenderer(gl))\n  ) {\n    loseContext();\n    return null;\n  }\n  const divisor = (location: number, value: number) => {\n    if (gl2) gl2.vertexAttribDivisor(location, value);\n    else angle?.vertexAttribDivisorANGLE(location, value);\n  };\n  const drawInstanced = (count: number) => {\n    if (gl2) gl2.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, count);\n    else angle?.drawArraysInstancedANGLE(gl.TRIANGLE_STRIP, 0, 4, count);\n  };\n\n  const sources = glslPrograms(version);\n  const points = compile(gl, sources.points, GLSL_ATTRIBUTES.points);\n  const mesh = compile(gl, sources.mesh, GLSL_ATTRIBUTES.mesh);\n  const lines = compile(gl, sources.lines, GLSL_ATTRIBUTES.lines);\n  const corners = gl.createBuffer();\n  if (!points || !mesh || !lines || !corners) {\n    loseContext();\n    return null;\n  }\n  const programs = { points, mesh, lines };\n  gl.bindBuffer(gl.ARRAY_BUFFER, corners);\n  gl.bufferData(gl.ARRAY_BUFFER, CORNERS, gl.STATIC_DRAW);\n\n  let lost = false;\n  const handleLost = (event: Event) => {\n    event.preventDefault();\n    lost = true;\n    onLost();\n  };\n  canvas.addEventListener(\"webglcontextlost\", handleLost);\n\n  const resources = new Map<string, ItemResources>();\n  const uniformData = new Float32Array(40);\n\n  const attribute = (\n    location: number,\n    size: number,\n    type: number,\n    stride: number,\n    offset: number,\n    perInstance: boolean,\n  ) => {\n    gl.enableVertexAttribArray(location);\n    gl.vertexAttribPointer(\n      location,\n      size,\n      type,\n      type === gl.UNSIGNED_BYTE,\n      stride,\n      offset,\n    );\n    divisor(location, perInstance ? 1 : 0);\n  };\n\n  const bind = (item: Item3D, res: ItemResources) => {\n    const F = gl.FLOAT;\n    const U8 = gl.UNSIGNED_BYTE;\n    let used: number;\n    if (item.kind === \"mesh\") {\n      gl.bindBuffer(gl.ARRAY_BUFFER, res.vertex);\n      attribute(0, 3, F, VERTEX_STRIDE, 0, false);\n      attribute(1, 3, F, VERTEX_STRIDE, 12, false);\n      attribute(2, 4, U8, VERTEX_STRIDE, 24, false);\n      used = 3;\n    } else {\n      gl.bindBuffer(gl.ARRAY_BUFFER, corners);\n      attribute(0, 2, F, 0, 0, false);\n      gl.bindBuffer(gl.ARRAY_BUFFER, res.vertex);\n      if (item.kind === \"points\") {\n        attribute(1, 3, F, POINT_STRIDE, 0, true);\n        attribute(2, 1, F, POINT_STRIDE, 12, true);\n        attribute(3, 4, U8, POINT_STRIDE, 16, true);\n      } else {\n        attribute(1, 3, F, SEGMENT_STRIDE, 0, true);\n        attribute(2, 3, F, SEGMENT_STRIDE, 12, true);\n        attribute(3, 4, U8, SEGMENT_STRIDE, 24, true);\n      }\n      used = 4;\n    }\n    for (let i = used; i < MAX_LOCATIONS; i++) {\n      gl.disableVertexAttribArray(i);\n      divisor(i, 0);\n    }\n  };\n\n  const upload = (item: Item3D): ItemResources | null => {\n    const existing = resources.get(item.key);\n    if (\n      existing &&\n      existing.version === item.version &&\n      existing.kind === item.kind\n    ) {\n      // same mesh, triangles in a new order (transparent, sorted by depth)\n      if (\n        item.kind === \"mesh\" &&\n        existing.index &&\n        (item.order ?? 0) !== existing.order\n      ) {\n        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, existing.index);\n        gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, item.indices);\n        existing.order = item.order ?? 0;\n      }\n      return existing;\n    }\n    if (existing) {\n      gl.deleteBuffer(existing.vertex);\n      if (existing.index) gl.deleteBuffer(existing.index);\n      resources.delete(item.key);\n    }\n    const vertex = gl.createBuffer();\n    if (!vertex) return null;\n    gl.bindBuffer(gl.ARRAY_BUFFER, vertex);\n    gl.bufferData(\n      gl.ARRAY_BUFFER,\n      item.kind === \"mesh\" ? item.vertices : item.data,\n      gl.STATIC_DRAW,\n    );\n    let index: WebGLBuffer | null = null;\n    if (item.kind === \"mesh\") {\n      index = gl.createBuffer();\n      if (!index) {\n        gl.deleteBuffer(vertex);\n        return null;\n      }\n      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, index);\n      gl.bufferData(\n        gl.ELEMENT_ARRAY_BUFFER,\n        item.indices,\n        item.order === undefined ? gl.STATIC_DRAW : gl.DYNAMIC_DRAW,\n      );\n    }\n    const res = {\n      version: item.version,\n      kind: item.kind,\n      vertex,\n      index,\n      order: item.kind === \"mesh\" ? (item.order ?? 0) : 0,\n    };\n    resources.set(item.key, res);\n    return res;\n  };\n\n  return {\n    kind: version === 2 ? \"webgl2\" : \"webgl\",\n    canvas,\n    resize(width, height) {\n      canvas.width = Math.max(1, width);\n      canvas.height = Math.max(1, height);\n    },\n    render(items, frame) {\n      if (lost || gl.isContextLost()) return;\n      gl.viewport(0, 0, canvas.width, canvas.height);\n      gl.clearColor(0, 0, 0, 0);\n      gl.clearDepth(1);\n      gl.depthMask(true);\n      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);\n      gl.enable(gl.BLEND);\n      gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n      gl.enable(gl.DEPTH_TEST);\n      gl.depthFunc(gl.LEQUAL);\n      gl.disable(gl.CULL_FACE);\n      const seen = new Set<string>();\n      for (const item of drawOrder(items)) {\n        seen.add(item.key);\n        const count = item.kind === \"mesh\" ? item.indices.length : item.count;\n        if (count <= 0) continue;\n        const res = upload(item);\n        if (!res) continue;\n        const program = programs[item.kind];\n        gl.useProgram(program.program);\n        const u = itemUniforms(item, frame, uniformData);\n        const loc = program.uniforms;\n        gl.uniformMatrix4fv(loc.u_viewProj, false, u.subarray(0, 16));\n        gl.uniform4fv(loc.u_viewport, u.subarray(16, 20));\n        gl.uniform4fv(loc.u_eye, u.subarray(20, 24));\n        gl.uniform4fv(loc.u_light, u.subarray(24, 28));\n        gl.uniform4fv(loc.u_material, u.subarray(28, 32));\n        gl.uniform4fv(loc.u_params, u.subarray(32, 36));\n        gl.uniform4fv(loc.u_fog, u.subarray(36, 40));\n        gl.depthMask(writesDepth(item));\n        bind(item, res);\n        if (item.kind === \"mesh\") {\n          gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, res.index);\n          gl.drawElements(gl.TRIANGLES, count, gl.UNSIGNED_INT, 0);\n        } else {\n          drawInstanced(count);\n        }\n      }\n      gl.depthMask(true);\n      for (const [key, res] of resources) {\n        if (!seen.has(key)) {\n          gl.deleteBuffer(res.vertex);\n          if (res.index) gl.deleteBuffer(res.index);\n          resources.delete(key);\n        }\n      }\n    },\n    destroy() {\n      canvas.removeEventListener(\"webglcontextlost\", handleLost);\n      if (!gl.isContextLost()) {\n        for (const res of resources.values()) {\n          gl.deleteBuffer(res.vertex);\n          if (res.index) gl.deleteBuffer(res.index);\n        }\n        for (const p of Object.values(programs)) gl.deleteProgram(p.program);\n        gl.deleteBuffer(corners);\n      }\n      resources.clear();\n      loseContext();\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/charts/engine/three-d/webgl.d.cts

@@ -0,0 +1,10 @@
+import { RendererLostHandler } from '../renderers/types.cjs';
+import { Renderer3D } from './render-types.cjs';
+type Gl = WebGLRenderingContext | WebGL2RenderingContext;
+/** Software rasterizers behind a WebGL context */
+export declare const SOFTWARE_RENDERER: RegExp;
+export declare const isSoftwareRenderer: (gl: Gl) => boolean;
+export declare const createWebGl3D: (canvas: HTMLCanvasElement, version: 1 | 2, onLost: RendererLostHandler, 
+/** Refuses software rendering: the decimating Canvas2D backend is faster there */
+requireHardware?: boolean) => Renderer3D | null;
+export {};

package/dist/charts/engine/three-d/webgl.d.ts

@@ -0,0 +1,10 @@
+import { RendererLostHandler } from '../renderers/types.js';
+import { Renderer3D } from './render-types.js';
+type Gl = WebGLRenderingContext | WebGL2RenderingContext;
+/** Software rasterizers behind a WebGL context */
+export declare const SOFTWARE_RENDERER: RegExp;
+export declare const isSoftwareRenderer: (gl: Gl) => boolean;
+export declare const createWebGl3D: (canvas: HTMLCanvasElement, version: 1 | 2, onLost: RendererLostHandler, 
+/** Refuses software rendering: the decimating Canvas2D backend is faster there */
+requireHardware?: boolean) => Renderer3D | null;
+export {};