JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 56
  • Score
    100M100P100Q63631F
  • License MIT

Real-time LOD time series rendering engine for the browser.

Package Exports

  • blazeplot
  • blazeplot/core
  • blazeplot/data
  • blazeplot/export
  • blazeplot/interaction
  • blazeplot/linked
  • blazeplot/linked-core
  • blazeplot/package.json
  • blazeplot/plugins/annotations
  • blazeplot/plugins/crosshair
  • blazeplot/plugins/interactions
  • blazeplot/plugins/legend
  • blazeplot/plugins/navigator
  • blazeplot/plugins/selection
  • blazeplot/plugins/tooltip
  • blazeplot/react
  • blazeplot/render

Readme

BlazePlot

npm version npm downloads license previews

Fast WebGL2 plotting engine for the browser.

Built for people who have hit the performance ceiling of Chart.js, Plotly, and similar browser charting libraries. BlazePlot keeps the hot path GPU-native and the DOM minimal, so large streaming datasets stay interactive instead of turning into a slideshow.

Built on native WebGL2 with no rendering runtime dependency.

Performance

The core chart runtime is intentionally compact: the production build for blazeplot (without optional plugins) is about 139 KiB raw / 34 KiB gzip. Optional plugins and helpers ship as separate subpath entries.

A minimal 1,000-point line chart renders its first frame in about 0.3 ms median / 0.5 ms p95 of render work (640×360 canvas, HeadlessChrome 148, SwiftShader). Chart construction and WebGL setup takes about 19 ms median.

Size and first-draw comparison (vendor-published figures, best value bolded):

Library Version Size First draw
BlazePlot 0.3.4 139 KiB raw / 34 KiB gzip 0.3 ms render (19 ms setup)
Chart.js 4.5.1 1,562 KB tarball (5.9 MB unpacked) —
Plotly.js 3.5.0 4.6 MB min (1.4 MB gzip) —
LightningChart JS 5.2.1 1.2–1.5 MB JS (25.5 MB unpacked) —
SciChart.js 5.x 1.9 MB JS + ~1 MB WASM ~250 ms init

References: BlazePlot — this release build and local benchmark. Chart.js — v4.5.1. Plotly.js — v3.5.0. LightningChart JS — v5.2.1. SciChart.js — v5.

Installation

bun install blazeplot

Quick start

A chart only needs a host element. For regular arrays, wrap your data in a StaticDataset; capacity is only needed when you want a streaming ring buffer.

<div id="chart" style="width:100%;height:400px"></div>

<script type="module">
  import { Chart, StaticDataset } from "blazeplot";

  const el = document.getElementById("chart");
  if (!el) throw new Error("Missing #chart element");

  const x = Array.from({ length: 1000 }, (_, i) => i);
  const y = x.map((value) => Math.sin(value * 0.02));

  const chart = new Chart(el);
  chart.addLine({ dataset: new StaticDataset(x, y), name: "sine" });
  chart.setViewport({ xMin: x[0], xMax: x[x.length - 1], yMin: -1.5, yMax: 1.5 });
  chart.start();
</script>

Features
WebGL2 rendering GPU-accelerated plot rendering from the ground up. No Canvas2D fallback. Axis labels use lightweight DOM layers.
Flexible data model Streaming ring buffer or static arrays. Bring your own data shape.
LOD downsampling Min/max pyramid for efficient line rendering at any zoom level — sparse views show raw points, dense views show vertical segments. Server-pre-sampled min/max buckets can also be rendered directly with ServerSampledDataset.
Pan & zoom Pointer/touch pan and wheel zoom via Camera2D. Customizable viewport policies.
Grid lines Data-anchored grid rendered as WebGL line lists.
Axis labels Smart tick generation with DOM labels. Per-axis inside/outside positioning; outside axes reserve real layout gutters.
Multi-series Independent buffers, styles, and visibility per series. Line, area, scatter, bar, OHLC, and candlestick modes are supported.
Plugin-ready UI Optional built-in legend, tooltip, interactions, annotations, selection, crosshair, and navigator plugins use the same public APIs available to custom plugins.
React and linked charts First-party blazeplot/react and blazeplot/linked subpaths support React usage and synchronized multi-panel layouts.
Export helpers chart.screenshot() composites WebGL output with built-in DOM/SVG overlays. blazeplot/data provides lightweight CSV/JSON data export and pure transform helpers; blazeplot/export provides download/clipboard helpers.
Benchmark overlay Built-in fps, frame time, vertex count, draw calls.
ResizeObserver Automatic DPR-aware canvas sizing.

Data export and transforms

Use the tree-shakable blazeplot/data subpath when you only need data helpers. It collects raw rows from the current visible x range, a committed selection plugin state, or the full chart, then serializes them as CSV or JSON.

import { chartDataToCSV, chartDataToJSON, exportSelectedChartData, exportVisibleChartData, rollingMean } from "blazeplot/data";
import { downloadBlob } from "blazeplot/export";

const visible = exportVisibleChartData(chart);
const csv = chartDataToCSV(visible);

const selection = selectionPluginHandle.getSelection();
const selectedJson = chartDataToJSON(exportSelectedChartData(chart, selection));

const smoothed = rollingMean(visible.series[0]?.samples ?? [], 5);
downloadBlob(new Blob([csv], { type: "text/csv" }), "visible-data.csv");

exportVisibleChartData exports samples in each series' current x viewport by default; pass { includeYRange: true } to require y-viewport overlap. Selection exports follow the selection plugin mode (x-range, y-range, or xy) and include OHLC/candlestick open, high, low, and close columns when available.

API reference

This section is generated by bun run docs:readme from TypeScript declaration files, JSDoc comments, and built dist/ bundle sizes. Do not edit it by hand.

Package entry points

Import Contents
blazeplot Core chart, data, interaction, rendering types, and low-level primitives.
blazeplot/core Data structures, datasets, LOD helpers, and series storage without chart UI.
blazeplot/interaction Camera, axis, pan/zoom intent, and viewport policy helpers without chart UI.
blazeplot/render Renderer and WebGL backend primitives without chart UI.
blazeplot/react React wrapper component and hooks.
blazeplot/linked Linked chart layout helpers with tooltip/crosshair sync factories.
blazeplot/linked-core Lean linked chart layout helpers without tooltip/crosshair sync imports.
blazeplot/data Pure chart data export and transform helpers.
blazeplot/export Screenshot download and clipboard helpers.
blazeplot/plugins/legend Built-in legend plugin.
blazeplot/plugins/tooltip Built-in tooltip plugin.
blazeplot/plugins/interactions Built-in pan, zoom, axis interaction, and reset plugin.
blazeplot/plugins/annotations Built-in annotation overlay plugin.
blazeplot/plugins/selection Built-in brush/range selection plugin.
blazeplot/plugins/crosshair Built-in crosshair and ruler plugin.
blazeplot/plugins/navigator Built-in overview/navigator plugin.

Bundle size summary

Generated from dist/ after the package build. Budgets are enforced by bun run test:bundle-size.

Chunk File Size Budget Headroom
root entry dist/index.js 0.7 KiB 31.3 KiB 30.6 KiB free
core subpath entry dist/core.js 0.7 KiB 3.9 KiB 3.2 KiB free
interaction subpath entry dist/interaction.js 0.1 KiB 2.0 KiB 1.9 KiB free
render subpath entry dist/render.js 0.3 KiB 2.0 KiB 1.7 KiB free
react entry dist/react.js 0.7 KiB 7.8 KiB 7.1 KiB free
linked entry dist/linked.js 0.4 KiB 15.6 KiB 15.3 KiB free
linked core entry dist/linked-core.js 0.1 KiB 7.8 KiB 7.7 KiB free
data entry dist/data.js 4.9 KiB 11.7 KiB 6.8 KiB free
export entry dist/export.js 1.3 KiB 7.8 KiB 6.5 KiB free
interactions plugin dist/plugins/interactions.js 15.3 KiB 23.4 KiB 8.1 KiB free
annotations plugin dist/plugins/annotations.js 9.3 KiB 15.6 KiB 6.3 KiB free
navigator plugin dist/plugins/navigator.js 8.6 KiB 15.6 KiB 7.0 KiB free
selection plugin dist/plugins/selection.js 5.3 KiB 11.7 KiB 6.4 KiB free
legend plugin dist/plugins/legend.js 2.8 KiB 7.8 KiB 5.0 KiB free
tooltip plugin entry dist/plugins/tooltip.js 0.1 KiB 3.9 KiB 3.8 KiB free
crosshair plugin entry dist/plugins/crosshair.js 0.1 KiB 3.9 KiB 3.8 KiB free
shared Chart chunk dist/Chart-D1ISQl_J.js 57.0 KiB 136.7 KiB 79.7 KiB free
shared RingBuffer chunk dist/RingBuffer-Bd5JaRf4.js 29.6 KiB 39.1 KiB 9.4 KiB free
shared OhlcDataset chunk dist/OhlcDataset-1cMrc6BC.js 17.3 KiB 23.4 KiB 6.1 KiB free
shared AxisController chunk dist/AxisController-CUL9i0MS.js 13.6 KiB 19.5 KiB 6.0 KiB free
shared WebGL2Backend chunk dist/WebGL2Backend-wxbXnm0h.js 20.9 KiB 23.4 KiB 2.5 KiB free
shared LinkedChartsCore chunk dist/LinkedChartsCore-DDrAyfEg.js 2.1 KiB 7.8 KiB 5.7 KiB free
lazy screenshot chunk dist/screenshot-BVw2v67J.js 3.0 KiB 7.8 KiB 4.8 KiB free
shared OverlayUtils chunk dist/OverlayUtils-Gk-tb2Ak.js 3.1 KiB 7.8 KiB 4.7 KiB free
shared Tooltip chunk dist/Tooltip-DDEQ32oy.js 4.8 KiB 11.7 KiB 6.9 KiB free
shared Crosshair chunk dist/Crosshair-DyBHoqIB.js 8.6 KiB 15.6 KiB 7.0 KiB free

Selected generated declarations

These member tables are generated from TypeScript declarations.

class Chart
Member
isWebGL2Available(): boolean
constructor(target: HTMLElement, options?: ChartOptions)
get canvas(): HTMLCanvasElement
get rootElement(): HTMLElement
get plotElement(): HTMLElement
get xAxisElement(): HTMLElement
get yAxisElement(): HTMLElement
get y2AxisElement(): HTMLElement
get theme(): ResolvedChartTheme
`getWebGLContext(): WebGL2RenderingContext \
getCamera(yAxis?: SeriesYAxis): Camera2D
dataToPlot(x: number, y: number, yAxis?: SeriesYAxis): [ number, number ]
`clientToData(clientX: number, clientY: number, yAxis?: SeriesYAxis): [ number, number ] \
getViewport(yAxis?: SeriesYAxis): Viewport
pan(intent: PanIntent): void
zoom(intent: ZoomIntent): void
addSeries(config: SeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
addLine(config: TypedSeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
addArea(config: TypedSeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
addScatter(config: TypedSeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
addBar(config: TypedSeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
addOhlc(config: TypedSeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
addCandlestick(config: TypedSeriesConfig, style?: Partial<SeriesStyle>): SeriesStore
removeSeries(series: SeriesStore): boolean
setSeriesVisible(series: SeriesStore, visible: boolean): boolean
getSeriesState(): ChartSeriesState[]
setViewport(v: { xMin?: number; xMax?: number; yMin?: number; yMax?: number; }): void
setYViewport(yAxis: SeriesYAxis, v: { yMin?: number; yMax?: number; }): void
setXFollowPaused(paused: boolean): void
resumeXFollow(): void
fitToData(options?: ChartFitToDataOptions): boolean
resize(dpr?: number): boolean
getFrameStats(target?: ChartFrameStats): ChartFrameStats
`getHoverState(): ChartHoverState \
`setLayoutReservation(id: string, reservation: ChartLayoutReservation \
`subscribe(event: "hover", callback: (state: ChartHoverState \
subscribe(event: "serieschange", callback: () => void): () => void
subscribe(event: "themechange", callback: () => void): () => void
subscribe(event: "render", callback: (chart: Chart) => void): () => void
subscribe(event: "viewportchange", callback: (event: ChartViewportChangeEvent) => void): () => void
subscribe(event: "select", callback: (event: ChartSelectEvent) => void): () => void
subscribe(event: "seriesclick", callback: (event: ChartSeriesClickEvent) => void): () => void
subscribe(event: ChartPointerEventType, callback: (event: ChartPointerEventState) => void): () => void
emitSelect(selection: unknown): void
setTheme(theme?: ChartTheme): void
setGridVisible(visible: boolean): void
getGridVisible(): boolean
setAxes(axes: ChartOptions["axes"]): void
`pick(clientX: number, clientY: number, options?: ChartPickOptions): ChartHoverState \
screenshot(options?: ChartScreenshotOptions): Promise<Blob>
start(): void
stop(): void
dispose(): void
interface ChartOptions
Member
viewportPolicy?: ViewportPolicy
grid?: boolean
gridStyle?: Partial<SeriesStyle>
`axes?: boolean \
`title?: string \
`subtitle?: string \
hover?: ChartPickOptions
`accessibility?: boolean \
`autoFitY?: boolean \
`followX?: boolean \
plugins?: readonly ChartPlugin[]
theme?: ChartTheme
backendFactory?: ChartBackendFactory
interface ChartTheme
Member
backgroundColor?: ThemeColor
gridColor?: ThemeColor
axisColor?: string
axisFont?: string
seriesColors?: readonly ThemeColor[]
tooltipBackgroundColor?: string
tooltipTextColor?: string
tooltipFont?: string
legendBackgroundColor?: string
legendBorderColor?: string
legendTextColor?: string
legendMutedTextColor?: string
legendFont?: string
titleColor?: string
titleFont?: string
subtitleColor?: string
subtitleFont?: string
axisTitleColor?: string
axisTitleFont?: string
interface AxisConfig
Member
visible?: boolean
position?: AxisPosition
scale?: AxisScale
tickFormat?: AxisTickFormat
timezone?: AxisTimeZone
`title?: string \
class SeriesStore
Member
config: SeriesConfig
style: SeriesStyle
constructor(dataset: Dataset, config: SeriesConfig, style: SeriesStyle)
get hasLOD(): boolean
get hasServerMinMax(): boolean
get dirty(): boolean
get length(): number
get visible(): boolean
setVisible(visible: boolean): void
append(x: ArrayLike<number>, y: ArrayLike<number>): void
appendY(y: ArrayLike<number>): void
markDirty(): void
clear(): void
rebuildPyramid(): void
query(viewport: Viewport, pixelWidth: number): LODView
visibleSampleCount(viewport: Viewport): number
`sampleAt(index: number): SeriesSample \
`ohlcAt(index: number): SeriesOhlcSample \
`dataBounds(options?: SeriesDataBoundsOptions): SeriesDataBounds \
`nearestSampleByX(x: number, viewport?: Viewport): SeriesSample \
`nearestSampleByPoint(x: number, y: number, viewport: Viewport, plotWidth: number, plotHeight: number, maxDistancePx?: number): SeriesSample \
copyRawVisible(viewport: Viewport, target: Float32Array, maxPoints: number, xOrigin?: number): number
copyScatterVisible(viewport: Viewport, target: Float32Array, maxPoints: number, pixelWidth: number, pixelHeight: number, pointSize: number, xOrigin?: number): number
copyScatterRange(start: number, end: number, viewport: Viewport, target: Float32Array, maxPoints: number, xOrigin?: number, pixelHeight?: number, pointSize?: number): number
copyRawVisibleClipped(viewport: Viewport, target: Float32Array, maxPoints: number, xOrigin?: number): number
copyRawVisibleClipSpace(viewport: Viewport, target: Float32Array, maxPoints: number): number
copyRawRange(start: number, end: number, target: Float32Array, maxPoints: number, xOrigin?: number): number
copyAreaVisible(viewport: Viewport, target: Float32Array, maxPoints: number, baseline?: number, xOrigin?: number): number
copyAreaRange(start: number, end: number, target: Float32Array, maxPoints: number, baseline?: number, xOrigin?: number): number
copyMinMaxVisible(viewport: Viewport, target: Float32Array, maxSegments: number, xOrigin?: number): number
copyMinMaxInstanced(viewport: Viewport, target: Float32Array, maxSegments: number, xOrigin?: number): number
copyOhlcRange(start: number, end: number, target: Float32Array, maxCandles: number, tickWidth: number, xOrigin?: number): number
copyOhlcTuplesRange(start: number, end: number, target: Float32Array, maxCandles: number, xOrigin?: number): number
`visibleIndexRange(viewport: Viewport \
interface SeriesConfig
Member
mode: SeriesMode
capacity?: number
downsample?: LODStrategy
overflow?: BufferOverflowStrategy
dataset?: Dataset
yAxis?: SeriesYAxis
id?: string
name?: string
interface SeriesStyle
Member
color: readonly [ number, number, number, number ]
lineWidth: number
pointSize?: number
barWidth?: number
baseline?: number
fillColor?: readonly [ number, number, number, number ]
tickWidth?: number
upColor?: readonly [ number, number, number, number ]
downColor?: readonly [ number, number, number, number ]
wickColor?: readonly [ number, number, number, number ]
class UniformRingBuffer
Member
capacity: number
xStep: number
constructor(capacity: number, options?: UniformRingBufferOptions)
get length(): number
`get range(): TimeRange \
push(x: number, y: number): void
append(x: ArrayLike<number>, y: ArrayLike<number>): void
appendY(y: ArrayLike<number>): void
clear(): void
getX(index: number): number
getY(index: number): number
isGap(index: number): boolean
lowerBoundX(x: number): number
upperBoundX(x: number): number
`rangeMinMaxY(start: number, end: number): { minY: number; maxY: number; } \
copyVisibleSamples(viewport: Viewport, target: Float32Array, maxPoints: number, layout: SampleLayout, baseline: number, xOrigin: number): number
copySamplesRange(start: number, end: number, target: Float32Array, maxPoints: number, layout: SampleLayout, baseline: number, xOrigin: number): number
copyMinMaxSegments(viewport: Viewport, target: Float32Array, maxSegments: number, layout: MinMaxLayout, xOrigin: number): number
class RingBuffer
Member
capacity: number
constructor(capacity: number, options?: RingBufferOptions)
get length(): number
`get range(): TimeRange \
push(x: number, y: number): void
append(x: ArrayLike<number>, y: ArrayLike<number>): void
`get(index: number): { x: number; y: number; } \
getX(index: number): number
getY(index: number): number
isGap(index: number): boolean
lowerBoundX(x: number): number
upperBoundX(x: number): number
`rangeMinMaxY(start: number, end: number): { minY: number; maxY: number; } \
clear(): void
class StaticDataset
Member
constructor(xData: ArrayLike<number>, yData: ArrayLike<number>)
get length(): number
`get range(): TimeRange \
getX(index: number): number
getY(index: number): number
isGap(index: number): boolean
lowerBoundX(x: number): number
upperBoundX(x: number): number
class OhlcRingBuffer
Member
capacity: number
constructor(capacity: number, options?: OhlcRingBufferOptions)
get length(): number
`get range(): TimeRange \
push(x: number, open: number, high: number, low: number, close: number): void
updateLast(open: number, high: number, low: number, close: number): boolean
append(x: ArrayLike<number>, open: ArrayLike<number>, high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>): void
clear(): void
getX(index: number): number
getY(index: number): number
getOpen(index: number): number
getHigh(index: number): number
getLow(index: number): number
getClose(index: number): number
lowerBoundX(x: number): number
upperBoundX(x: number): number
interface Dataset
Member
length: number
`range: TimeRange \
getX(index: number): number
getY(index: number): number
isGap(index: number): boolean
lowerBoundX(x: number): number
upperBoundX(x: number): number
interface ViewportPolicy
Member
`beforePan(camera: Camera2D, intent: PanIntent): PanIntent \
`beforeZoom(camera: Camera2D, intent: ZoomIntent): ZoomIntent \
beforeRender(camera: Camera2D): void

All public exports

Generated from dist/index.d.ts after the package build
Export Kind Source JSDoc summary
AcceleratedDataset interface ./core/types Convenience contract for maximum-performance custom datasets. Implement this when a dataset can provide fast exact sample copies, stable viewport sampling, range min/max queries, and renderer-ready min/max buckets.
AppendableDataset interface ./core/types —
AttributeSpec interface ./render/types —
AxisConfig interface ./ui/Chart —
AxisController class ./interaction/AxisController —
AxisControllerAxisOptions interface ./interaction/AxisController —
AxisControllerOptions interface ./interaction/AxisController —
AxisPosition type ./ui/ChartLayout —
AxisRenderTarget type ./interaction/AxisController —
AxisScale type ./interaction/AxisController —
AxisTickFormat type ./interaction/AxisController —
AxisTickFormatter type ./interaction/AxisController —
AxisTimeZone type ./interaction/AxisController —
AxisTitleConfig interface ./ui/Chart —
BufferOverflowStrategy type ./core/types —
BufferSpec interface ./render/types —
BuiltInAxisScale type ./interaction/AxisController —
Camera2D class ./interaction/Camera2D —
Chart class ./ui/Chart —
ChartAccessibilityOptions interface ./ui/Chart —
ChartAutoFitYOptions interface ./ui/Chart —
ChartBackendFactory type ./ui/Chart —
ChartBackendFactoryContext interface ./ui/Chart —
ChartFitToDataOptions interface ./ui/Chart —
ChartFitToDataPadding interface ./ui/Chart —
ChartFollowXOptions interface ./ui/Chart —
ChartFrameStats interface ./ui/Chart —
ChartHoverState interface ./ui/Chart —
ChartKeyboardOptions interface ./ui/Chart —
ChartLayoutReservation interface ./ui/Chart —
ChartOptions interface ./ui/Chart —
ChartPickGroup type ./ui/Chart —
ChartPickItem interface ./ui/Chart —
ChartPickMode type ./ui/Chart —
ChartPickOptions interface ./ui/Chart —
ChartPlugin interface ./ui/Chart —
ChartPluginContext interface ./ui/Chart —
ChartPluginHandle interface ./ui/Chart —
ChartPointerEventState interface ./ui/Chart —
ChartPointerEventType type ./ui/Chart —
ChartScreenshotOptions interface ./ui/Chart —
ChartScreenshotPreset type ./ui/Chart —
ChartSelectEvent interface ./ui/Chart —
ChartSeriesClickEvent interface ./ui/Chart —
ChartSeriesState interface ./ui/Chart —
ChartTheme interface ./ui/theme —
ChartTitleConfig interface ./ui/Chart —
ChartViewportChangeEvent interface ./ui/Chart —
CssColor type ./ui/theme —
CustomAxisScale interface ./interaction/AxisController —
Dataset interface ./core/types —
DEFAULT_CHART_THEME const ./ui/theme —
DrawSpec interface ./render/types —
GpuBackend interface ./render/types —
GpuBuffer interface ./render/types —
GpuCapabilities interface ./render/types —
GpuProgram interface ./render/types —
GpuResource type ./render/types —
isWebGL2Available function ./render/WebGL2Backend —
LODBucket interface ./core/types —
LODStrategy type ./core/types —
LODView interface ./core/types —
MinMaxPyramid class ./core/MinMaxPyramid —
MinMaxSegmentCopyDataset interface ./core/types Optional high-performance min/max extraction capability for dense rendering. Implementations can use pyramids, segment trees, database aggregates, or analytic/procedural envelopes to emit renderer-ready min/max buckets.
MinMaxSegmentLayout type ./core/types —
OhlcDataset interface ./core/types —
OhlcRingBuffer class ./core/OhlcDataset —
OhlcRingBufferOptions interface ./core/OhlcDataset —
PanIntent interface ./interaction/types —
RangeMinMaxDataset interface ./core/types —
RangeSampleCopyDataset interface ./core/types Optional high-performance extraction capability for datasets that can copy raw samples without going through repeated getX/getY calls. Implement this for very large datasets, implicit-X datasets, or remote/memory-mapped sources.
ReglBackend const ./render/WebGL2Backend Deprecated alias for WebGL2Backend. This preserves the pre-native-backend public API.
ResolvedChartTheme interface ./ui/theme —
RgbaColor type ./ui/theme —
RingBuffer class ./core/RingBuffer —
RingBufferOptions interface ./core/RingBuffer —
RingBufferOverflow type ./core/RingBuffer —
SampleCopyLayout type ./core/types —
SeriesConfig interface ./core/types —
SeriesDataBounds interface ./core/SeriesStore —
SeriesDataBoundsOptions interface ./core/SeriesStore —
SeriesMode type ./core/types —
SeriesOhlcSample interface ./core/SeriesStore —
SeriesSample interface ./core/types —
SeriesStore class ./core/SeriesStore —
SeriesStyle interface ./core/types —
SeriesYAxis type ./core/types —
ServerSampledBuckets interface ./core/ServerSampledDataset —
ServerSampledData type ./core/ServerSampledDataset —
ServerSampledDataset class ./core/ServerSampledDataset Mutable dataset for viewport samples that were already reduced by a server. Use point data with downsample: "none", or min/max buckets with downsample: "server" so BlazePlot renders the supplied buckets directly instead of applying another client-side sampler.
ServerSampledDatasetKind type ./core/ServerSampledDataset —
ServerSampledPoints interface ./core/ServerSampledDataset —
StaticDataset class ./core/StaticDataset —
StaticOhlcDataset class ./core/OhlcDataset —
TextOverlayConfig interface ./ui/Chart —
ThemeColor type ./ui/theme —
TimeRange interface ./core/types —
TypedSeriesConfig type ./ui/Chart —
UniformRingBuffer class ./core/UniformRingBuffer High-throughput ring buffer for uniformly spaced X values. Store only Y samples and derive X as xStart + index * xStep. This is the fastest built-in dataset for live telemetry, signals, and other fixed-rate streams because appends copy a single typed array and min/max extraction uses a block segment tree over the physical ring.
UniformRingBufferOptions interface ./core/UniformRingBuffer —
Viewport interface ./core/types —
ViewportPolicy interface ./interaction/types —
VisiblePointCopyDataset interface ./core/types Optional high-performance extraction capability for point/scatter datasets. Implementations should cull against the full 2D viewport and may sample in screen space so dense point clouds respond to both X and Y zoom.
VisibleSampleCopyDataset interface ./core/types Optional high-performance stable visible sampling capability. Unlike copySamplesRange, this method may stride/downsample, but should choose samples anchored to data coordinates so streamed appends do not make existing sampled points jitter.
WebGL2Backend class ./render/WebGL2Backend —
WebGL2UnavailableError class ./render/WebGL2Backend —
YAppendableDataset interface ./core/types —
ZoomAxis type ./interaction/types —
ZoomIntent interface ./interaction/types —

Development

bun install
bun run dev             # Vite dev server → preview/
bun run ci              # Typecheck + tests + package build + benchmark smoke test
bun run build           # Package build (JS + declarations)
bun test                # Tests
bun run typecheck       # TypeScript strict check
bun run bench:ci        # Headless browser benchmark smoke test
bun run version:patch   # Prepare package.json + changelog for a patch release PR
bun run release:benchmarks  # Append benchmark results to the current release changelog

Branch flow: development is the integration branch for regular work; open feature/fix PRs into development. Open release PRs from development into main with version and changelog already updated. Release PRs publish npm and create the GitHub Release on merge.

See docs/release-and-benchmarks.md for full workflow details.