Class Charturbo

Largest texture edge in texels the GPU allows (capped at 4096); 0 when the engine has no texture support.

Undo / redo depth of the zoom history (at most 50 steps; cleared by a new chart).

Appends one annotation; returns its index.

Atomically appends one chunk per area series, in render order. Stacked / percent chunks must have equal lengths and identical x; overlap chunks may differ. Validation failure leaves every series unchanged. maxPoints trims each series to its newest samples. Styles, visibility and the zoom window are preserved. Returns the retained lengths. Stacks recompute cumulative tops in O(retained samples); overlap uses the line FIFO path.

Append XYZ samples to a cloud, optionally retaining only the newest maxPoints. Preserves orbit and visibility; returns the retained series length. IDs are rebased. Currently copies retained metadata and rebuilds native geometry (not an O(chunk) GPU upload).

Streams samples onto one line / overlap area series. Stacked / percent areas use appendAreaData instead. x (required iff the chart has x) must not go back before the series' last x. With maxPoints the oldest samples beyond it are dropped and ids are re-based. Amortized O(appended) in the engine plus a rebuild of the visible window on the next frame; the SDK keeps no copy of streamed data (tooltips / a11y read it back from the engine). Returns the new sample count.

Applies an instant 3D spatial layout preset (cluster-sphere, radial-shells, helix, grid-3d).

Removes the brush and its selection; emits an empty 'select' when something was selected.

Clears every parallel coordinates brush interval (no-op without a brush or chart).

Removes every scene object and the active chart.

Clears the graph selection and, with a chart shown, its brush selection (see clearChartSelection).

Copies the chart image (PNG, toImage) to the clipboard. Resolves false when the browser has no ClipboardItem / clipboard.write or refuses (call it from a user gesture).

Creates a texture from raw RGBA8 texels (straight alpha, row-major, first row at the top of the image); returns its id. Handy for procedural textures such as checkerboards. Throws when rgba.length is not width * height * 4.

Creates an HDR environment map from linear RGB floats: width * height texels, 3 floats each, row-major with the top row straight up (equirect, 2:1, at most 4096x2048). Same prefiltering and use as loadEnvironmentHdr. Negative and non-finite values are treated as 0, values above 65504 are clamped. Returns the texture id. GPU errors while prefiltering (validation or out of memory) throw on WebGL2; WebGPU reports them asynchronously, so there the map is returned, then freed again with a console warning: await environmentReady(id) to catch them.

Detaches every interaction, removes overlay DOM, and releases the WASM engine.

Removes the objects and textures a loadGltf call created.

Frees a texture. Objects that used it render untextured (white) from then on. Returns false for an unknown id.

Downloads toPDF().

Downloads exportChartSVG().

Downloads toImage (format from the extension unless options.format is given).

Treemap / sunburst: shows the subtree of target (node index, flat input id, or node name). Returns false when unchanged or not drillable (leaves). Emits 'drill'; call render() afterwards (pointer, keyboard and breadcrumb drills render themselves).

Treemap / sunburst: back up one level. Returns false at the top.

Returns the active high-dimensional embedding dimension D (0 if dataset was loaded as raw 3D coordinates).

Fades every series but seriesIndex (null clears).

Binds pointer hover & click interactions to canvas so users can immediately inspect node data via a floating tooltip and click callbacks without writing manual raycast/NDC boilerplate. Returns a cleanup function () => void to detach listeners and remove the tooltip.

Resolves once the GPU prefiltering of an HDR environment map (loadEnvironmentHdr / createEnvironmentFromFloat) is known to have succeeded. Rejects with the creating method's error (createEnvironmentFromFloat: GPU error while creating the environment map: ...) when it failed; the map has then been freed with disposeTexture. Only needed for createEnvironmentFromFloat on WebGPU: everywhere else such errors already throw or reject. Rejects for ids that are not live HDR environment maps.

getChartDataTable() as RFC 4180 CSV (CRLF rows).

The current 2D chart view as a vector SVG document (chart-svg.ts): engine marks as paths / rects / circles (decimated lines stay decimated; maxMarks caps points), clipped like the canvas, plus the DOM overlay as <text>. Heatmaps embed their plot as a PNG; 3D views and kinds without a vector writer embed the canvas (with a console warning).

CSV of the parallel coordinates rows (activeOnly: only the rows inside the brush).

Exports the current 3D Scene (objects, transforms, materials, physics, lighting, helpers) as a serializable SceneDescriptor. Textures the objects use are listed in textures (ids, size and src for fetched images); pixel data is not exported.

Jumps a running chart animation to its final frame (call render() to show it).

Re-frames the camera on the current chart.

Frames every node: centers the camera on them and sets the distance at which they fill the view from the current direction (the engine fits horizontally and vertically, so wide and tall canvases both fill). Also the overview distance focusNode zooms relative to.

Centers the camera on a node (a chart data point in chart mode) and, in graph / 3D views, moves it closer: by default to 40 % of the overview distance (fitToView / setCameraPose), never farther than it is (options.distance overrides; false keeps it). The move is immediate. Returns false for an unknown id.

Populates realistic domain metadata for all current nodes in the graph (useful for demos or quick inspection).

The SDK-wide animation setting (null = off).

Applied main-pass sample count (1 = off, 4 = MSAA x4).

Current scale options of one axis, or null (no line / area / scatter chart).

Orbit camera pose: target, eye, distance, yaw / pitch, field of view and aspect. null on engine builds without the camera_state binding.

Chart data as { columns, rows } (line: x rows x series columns; bar: categories; heatmap: grid rows x columns). Full by default; maxRows / maxColumns downsample evenly (first / last kept, sampledRows / sampledColumns set). A full 4096 x 4096 heatmap is 16M cells: cap it, or use exportChartCSV(), which streams rows.

Current point editing options (null = off).

Short text summary of the active chart (the canvas aria-label).

Data x of the current chart hover's primary point (line: series x or sample index; bar: category index; scatter: x), null without one. What synced charts hover at.

Navigator strip [left, top, width, height] in CSS px (null without one).

Returns complete live 3D state, topology connectivity, and custom metadata for nodeId.

Retrieves stored metadata for a node ID (or a default generated label if none was registered).

Row indices inside the brush (visible series; every visible row without a brush).

Current parallel coordinates brush in axis values (category axes also list their names).

GPU buffer / texture bytes, chart upload bytes, staged mark counts and the WebAssembly memory size of this engine (chart-stats.ts); null on backends without counters.

Fits of the scatter chart's trendlines (ScatterChartOptions.trendline); empty for other charts.

Committed brush selection of the active chart (re-queried after data / legend changes), or null.

Current data of one series (after edits): line series index as x (x values, or sample indices) and y; scatter series id index as the x / y of its points with their point index in the input arrays. null without a line / scatter chart or for an unknown series.

Sync group key and effective flags of this instance (null when not synced).

Textures created through this SDK, by id (src is set for string / URL sources only).

The current watermark with defaults filled in (null = none).

Visible x range in data units: line charts the series x (epoch ms on time axes) or the sample index, scatter charts x values. null for bar charts / without a chart.

Current [min, max] of the right y domain, or null (no right-axis series).

Current [min, max] of the line chart's y domain, or null.

Visible y range in data units: the line / area y domain (autoscaled or zoomed), scatter y (null otherwise).

True while built-in camera controls (enableNodeInteractions cameraControls) drive the camera of the current graph / 3D view: hosts should skip their own camera drag / wheel handling.

True while chart mouse drags draw a brush (setChartBrush on and a chart shown): hosts should skip their own drag handling unless Alt is held (Alt + drag navigates).

True when the active chart handles wheel / drag itself (2D line chart navigation).

True while an enableNodeInteractions binding owns touch / pen gestures (hosts should skip their own).

Removes the loading indicator (and a pending delayed one).

Computes and highlights the undirected shortest path between startNodeId and endNodeId via BFS. Returns the ordered sequence of node IDs along the path.

Hovers the chart at data x like a pointer resting there in index mode (crosshair + markers of every series at that x; bars: the category at round(x)), without 'hover' events. null / out of range clears. tooltip also shows the built-in tooltip (needs enableNodeInteractions). Returns true when something is hovered; call render() to draw.

True while a chart animation runs.

True between showLoading and hideLoading (also while a delay is pending).

Bulk loads a custom 3D graph or embedding point cloud from flat TypedArrays.

Projects an arbitrary D-dimensional embedding matrix (vectors.length === N * options.dimensions, supporting 64D, 128D, 384D, 768D, 1024D, 1536D, 3072D, 4096D+) into 3D space (x, y, z) and constructs a cosine-similarity k-NN graph inside Rust WASM.

Loads a Radiance .hdr (RGBE, flat or run-length encoded, at most 4096x2048) as an HDR environment map; resolves to its texture id for setShading({ environment: { map } }). The equirect image is downsampled to at most 1024 texels wide and prefiltered once on the GPU: a GGX mip chain read by roughness plus spherical-harmonics diffuse irradiance. Radiance above 1 is kept for exposure and tone mapping. Strings and URLs are fetched (CORS applies). Rejects with an AbortError when signal fires and with loadEnvironmentHdr: ... for malformed or oversized files and for GPU errors while prefiltering (validation or out of memory; the map is freed again). Free it with disposeTexture.

Loads a glTF 2.0 model (.gltf with external or data: buffers / images, or .glb) as custom meshes, one object per triangle primitive with the node hierarchy baked into the vertices. position / rotation become the objects' transform, scale is baked in. Base color factor and texture, metallic / roughness factors, emissive and alpha modes map onto the scene material; unsupported features are skipped with one console.warn per kind. Rejects with an AbortError when signal fires and with loadGltf: ... errors otherwise; objects and textures created before a failure are removed. Free the model with disposeGltf(result).

Declaratively loads an entire 3D Scene from a SceneDescriptor (clearing existing objects).

loadScene for a scene exported in another session: textures in descriptor.textures that have a src are loaded first (a live texture with the same src is reused) and the objects' map ids are remapped to the new ids. Textures that fail to load, and textures without a src that no live data texture of the same id and size replaces, are dropped from the objects with a console warning.

Decodes an image and uploads it as a texture; resolves to its id for the map field of addBox / addPrimitive / addCustomMesh / setObjectMaterial. Strings and URLs are fetched (CORS applies); other sources are decoded with straight alpha and the browser's default color handling. Images whose longest edge exceeds maxTextureSize are downscaled keeping the aspect ratio. ImageData is uploaded as is. Rejects with an AbortError when signal fires and with loadTexture: cross-origin image for tainted sources.

Subscribes to an SDK event ('hover', 'click', 'rangechange', 'legendtoggle', 'themechange', 'resize'); returns the unsubscribe function. Pointer events need enableNodeInteractions. Existing option callbacks keep working alongside.

Pans the x axis of a 2D line chart by a canvas-relative NDC delta.

Pans both axes of a scatter chart by a canvas-relative NDC delta (+y = up).

Batch version of projectNodeToScreen (one WASM call for many labels). Returns [x0, y0, x1, y1, ...] in canvas pixels; NaN for points behind the camera.

Projects a 3D node's world position into 2D canvas pixel coordinates { x, y, ndcZ }. Returns null if the node is behind the camera or out of bounds.

Records the current zoom as an undo step (wheel / drag / box gestures do it themselves).

Queries the top topK most similar nodes to nodeId using exact D-dimensional Cosine Similarity computed directly in the original high-dimensional embedding space (R^D).

Re-applies the last undone zoom; true when the view moved.

Renders a 2D area chart natively: overlapping areas filled to zero, stacked areas, or percent-stacked areas (options.mode). Strokes, M4 decimation, axes (index / numeric / time x), legend (toggle re-stacks), zoom / pan, and hover work like renderLineChart; tooltips show the raw series values plus the total (stacked) or each share (percent).

Two independent curves filled between their edges (no center line required). Shares numeric / time axes, dual-edge LOD, legend, zoom, brush and vector export. Replace both channels together by calling this method again.

Renders a bar chart natively: flat 2D bars with rounded data ends and nice-tick axes, or a lit 3D matrix. Negative values hang below the zero baseline. Hover highlights on the GPU.

Renders a box plot (or violins with violin) natively: one distribution per category and series, series side by side like grouped bars. Quartiles (numpy linear interpolation), whiskers ('tukey' 1.5 IQR, 'minmax', or a percentile pair), outlier counts, a capped outlier sample and the violin KDE are computed in the engine in O(n) per group; the samples are uploaded once and not kept. Hover reports a group's statistics, or the value of the outlier under the pointer. Data point ids: box = series * categories + category, outliers follow (chart_box_outliers).

Renders a calendar heatmap natively: one cell per day of each range (a year, a month or [start, end]; default one calendar per year of the data) in week columns (or rows when vertical) starting at firstDay, colored by the heatmap colormap (empty days in a neutral tone), with weekday / month / year labels, month split lines and a colorbar. Dates are 'YYYY-MM-DD' (as written) or epoch ms / Date (their day in the chart time zone). Hover and the keyboard visit every day. Throws for an invalid date, range or option. Point ids = day offset over the calendars.

Renders a candlestick (OHLC) chart natively: bodies + wicks on the GPU, per-pixel-column OHLC aggregation in the engine once candles get narrower than ~2 px (open = first, high = max, low = min, close = last; 1,000,000+ candles stay interactive), optional volume pane, x zoom / pan (wheel / drag / pinch) with the price axis fitting the visible candles, a crosshair, and an O/H/L/C/V tooltip. Rising candles default to the theme's first palette color and hollow bodies, falling ones to the second color (blue / orange: not red / green alone). Data point ids = candle index.

Renders a chord diagram natively (d3-chord chord() / chordDirected() layout in the engine): one outer arc per group sized by its total flow, padAngle apart from startAngle, and one ribbon per pair of groups (per direction when directed, with arrow tips) colored by source, target or a gradient. Input: a square flow matrix with names, or ECharts-style nodes / links. Hovering a group lights its ribbons and dims the rest; ribbon tooltips show both directions. The legend emphasizes / hides groups (re-laid out, tweened when animation is on). Throws for an invalid matrix or option before the current chart is replaced. Point ids: group index, then n + source * n + target per ribbon.

Renders a combo chart natively: bar, line and area series (type per series) on one plot sharing a category axis (categories) or numeric / time x, with an optional right y axis (yAxis: 'right'). Bars (barMode grouped / stacked / percent) sit on category slots and line points on the slot centers; layout, restacking on legend toggles, both y domains, area fills, hover (every series at the hovered category: bars tinted, line markers) and x zoom / pan run in the engine. Line / area series take the line styles (marker, dash, curve, nulls). Data point ids = seriesIndex * categoryCount + categoryIndex.

Independent high/low whiskers around each center; all channels are replaced atomically.

Renders a funnel chart natively: stages from the largest to the smallest share of the widest stage (trapezoids narrowing to the next stage, or centered bars), 2 px surface gaps, labels with value and conversion rate (of the first / previous stage, computed in the engine), and a hover tooltip with both rates. Values must be finite and >= 0. Point ids = stage index.

Renders a gauge natively: an arc from min to max (default 0-100, -120 to 120 degrees) with threshold bands (status bands use the reserved good / warning / serious / critical colors with an icon + label), a needle (default with bands) or a progress arc, min / max labels and the formatted value in the center. Throws for an invalid range or band. Use setGaugeValue for live values (only the indicator is rebuilt). Point ids: 0 = value, 1 + k = band k in drawing order (sorted by from).

Renders a 2D graph natively (ECharts graph): layout 'force' (force-directed in the plane on the engine's CPU simulator, settled before display; fixed nodes stay at x / y), 'circular' (slices by value, clockwise from 3 o'clock; rotateLabel runs labels outward), 'none' (given x / y, aspect kept) or 'cartesian' (x / y on value axes with gridlines; xAxis.categories for a category x). Category colors with a legend that toggles and emphasizes, size by value (symbolSize: [min, max]), straight or curved edges with optional arrows, hover highlights the node and its links. Input is validated before the current chart is replaced (a throw keeps it). Data point ids: node index.

Renders a multi-series bar chart natively: 'grouped' (side by side), 'stacked' (positive values stack up, negative values down) or 'percent' (each category normalized to 100%). Layout, stacking, hit-testing, and legend toggles (re-stacking) run in the engine. Stacked hover reports every series of the category (tooltip adds the total / shares). Data point ids = seriesIndex * categories.length + categoryIndex. The 3D matrix view (viewMode: '3d') shows the first series only.

Renders a heatmap / matrix natively: the cols x rows grid is uploaded once as a float texture and drawn as ONE quad (4096 x 4096 cells stay interactive), colored through a 256-entry LUT built by the engine (sequential single hue, viridis, magma, or diverging around center). Wheel / drag zoom and pan both axes; hover outlines the cell under the pointer. A colorbar is drawn right of the plot. Data point ids = row * cols + col.

Renders a histogram of raw values: the engine bins them in O(n) (Freedman–Diaconis with a Sturges fallback, or bins equal-width bins; 1,000,000+ values) and draws zero-gap bars on a numeric x axis ticked at bin edges. Hover shows the bin range and its count / density. Data point ids = bin index.

Independent stems from each series baseline to its samples, with optional tip markers.

Renders a multi-series line chart natively (Rust + WebGPU): screen-resolution M4 decimation, constant-pixel strokes, nice-tick axes, legend, x zoom / pan, and GPU hover overlays. Handles 1,000,000+ points at 60 FPS. Data point ids = series offset + sample index.

High–low stem, left open tick and right close tick; shares candle LOD, volume and navigation.

Renders parallel coordinates natively: one polyline per row across dimensions (value / category / time axes, each with nice ticks, min / max and inverse), side by side or stacked (orient), straight or smooth, colored by series (legend toggles) or by a value dimension through the heatmap colormap (colorBy, with a colorbar). Dragging along an axis brushes an interval (Shift adds one, a click clears the axis; several on one axis = union, several axes = intersection); rows outside fade to inactiveOpacity. A brush change only re-uploads the row flags. Hover lists every dimension of a row; the keyboard moves along an axis in value order and Shift brushes. Throws for an invalid cell, dimension or option (before the active chart is torn down). Point ids = row index (series in order).

Renders a pictorial bar chart (ECharts pictorialBar): a 2D bar chart (items, or grouped / stacked / percent series) whose bars are drawn as symbols, built-in shapes or path:// SVG paths, stretched over each bar or repeated along it and optionally clipped at the value (chart-pictorial.ts). Symbol options are chart defaults, overridden per series / item. background tracks act as the shadow bars. Hover, tooltips, legend, labels, a11y and exports are the bar chart's. Throws for invalid symbol options or viewMode: '3d' before the current chart is replaced.

Renders a pie / donut chart natively. The engine validates the values (finite and >= 0, else this throws), folds the smallest slices beyond maxSlices (default 8) into "Other", sorts, lays out the angles and tessellates the slices with 2 px surface gaps and anti-aliased edges; hover explodes the slice under the pointer (O(log n) angle search). Outside labels get leader lines and per-side collision nudging from the engine; the SDK only places the DOM text. Legend click hides a slice (the rest re-lay out). Data point ids = displayed slice index. { rings } data draws nested rings (each with its own percents, folding and labels); same names share a color and one legend entry across rings.

Independent XYZ billboards with depth-tested orbit navigation.

Renders a polar chart natively (ECharts polar with angleAxis / radiusAxis): each axis is a category or value axis (nice ticks, min / max, labels, split circles / spokes); startAngle (degrees clockwise from 12 o'clock) and clockwise orient the angle axis, innerRadius opens a hole. Series: radial / ring bars (whichever axis is the category one; stacked by stack, roundCap), lines (open / closed, smooth, area, markers), scatter points and heatmap cells (category angle x category radius, colormap and colorbar). Hover outlines the item; the legend emphasizes / hides series (axes re-fit, tweened when animation is on). Throws for an invalid item or option before the current chart is replaced. Point ids = series offset + item index.

Renders a radar (spider) chart natively: one closed polygon per series (1 to 8) over axes (at least 3) on a shared nice radial scale (max fixes it, or gives one max per axis), with translucent fills, strokes, vertex markers and a concentric grid. Hover picks the axis nearest to the pointer and lists every visible series there; the legend toggles / emphasizes series. Throws for invalid values (negative / infinite) or shapes. Point ids = series * axes + axis.

Renders a sankey diagram natively (d3-sankey layout in the engine): nodes in columns (longest path, align, or explicit column), breadth by value, iterations rounds of relaxation with collision resolution (nodes in a column never overlap), cubic bezier ribbons as wide as their value. Hover highlights the connected flows; the tooltip reads A → B: value (x% of A). Links forming a cycle throw (the message names the nodes). Data point ids: node index, then node count + link index.