@kymoscope/sdk 0.0.0-stage → 0.1.1

package/dist/types/charts/chartWindow.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A chart in its own browser window (e.g. dragged to a second screen). The
+ * window is a same-origin popup: the page's styles and theme are copied in and
+ * the chart renders into it through the engine's normal mount, so it keeps
+ * streaming, zoom links and settings. Closing the window destroys the view;
+ * the host decides where the chart goes next (usually back into its grid).
+ */
+import type { KymoscopeEngine } from '../engine/createEngine';
+import type { ChartView, MountOptions } from './runtime';
+export interface ChartWindowOptions {
+    /** Window title; defaults to the chart's title. */
+    title?: string;
+    /** Initial size in CSS px (the browser may adjust it). */
+    width?: number;
+    height?: number;
+    mount?: MountOptions;
+}
+export interface ChartWindow {
+    readonly chartId: string;
+    readonly window: Window;
+    /** Put your own controls here (e.g. a "return" button); it sits above the chart. */
+    readonly controls: HTMLElement;
+    readonly view: ChartView;
+    /** Close the window (also fires `close`). */
+    close(): void;
+    /** Fires once when the window closes, whoever closed it. */
+    on(event: 'close', cb: () => void): () => void;
+}
+export declare function openChartWindow(engine: KymoscopeEngine, chartId: string, mount: (element: HTMLElement, options?: MountOptions) => ChartView, o?: ChartWindowOptions): ChartWindow;
+/** Close every chart window of an engine (on dispose). */
+export declare function closeChartWindows(engine: KymoscopeEngine): void;

package/dist/types/charts/liveOverlay.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A live stream drawn over imported datasets on a multiband chart: the stream
+ * is pulled every frame (decimated once per data change, trimmed to the
+ * playout edge) and drawn as one more layer over the datasets' layers, which
+ * don't change.
+ */
+import type { LiveChartSource } from '../components/MultiBandCanvasChart';
+import { type PointColumns } from '../lib/data/pointColumns';
+import type { LiveConnection } from '../lib/live/types';
+export declare function liveOverlaySource(conn: LiveConnection, xKey: string, cols: string[], 
+/** Series key suffix of the stream (`__N`, its overlay index). */
+keySuffix: string, 
+/** X offset of the stream. */
+offset: number, staticLayers: PointColumns[], 
+/** The datasets' X range (the axis), widened by the stream's own range. */
+staticRange: [number, number] | null): LiveChartSource;

package/dist/types/charts/runtime.d.ts

@@ -0,0 +1,63 @@
+import { type KymoscopeEngine } from '../engine/createEngine';
+import { type ChartStatus, type ContextMenuEvent } from './ChartBody';
+import type { AnnotationTool } from '../lib/annotations';
+export interface ChartStyle {
+    /** Plot background (overrides the chart's own background setting). */
+    background?: string;
+    /** Axis labels and ticks. */
+    muted?: string;
+    grid?: string;
+    /** Highlight colour (cursor, selection). */
+    accent?: string;
+}
+export interface MountOptions {
+    /** Colour scheme of this chart; default: inherited `data-color-scheme` (dark when none). */
+    theme?: 'dark' | 'light';
+    style?: ChartStyle;
+    className?: string;
+    /** Show live performance numbers (FPS, render time, points…) in the chart's top-right corner. */
+    debug?: boolean;
+}
+export interface ChartViewEvents extends Record<string, unknown> {
+    status: ChartStatus;
+    contextmenu: ContextMenuEvent;
+    viewchange: [number, number] | null;
+    /** The annotation tool changed from inside the chart (Escape drops it: null). */
+    annotationtool: AnnotationTool | null;
+    /** An annotation was selected in the chart (its id), or the selection ended (null). */
+    annotationselect: string | null;
+}
+export interface ChartView {
+    readonly chartId: string;
+    /** Current status: 'no-data' (nothing plotted), 'empty' (chart has nothing to draw), 'ready'. */
+    status(): ChartStatus | null;
+    on<K extends keyof ChartViewEvents>(event: K, cb: (payload: ChartViewEvents[K]) => void): () => void;
+    /**
+     * The prepared data the chart is drawing (e.g. X-Y points, histogram values,
+     * multiband series + points); null while it has nothing to draw.
+     */
+    data(): unknown;
+    /** PNG of the plot (all its canvas layers), at device resolution. */
+    exportPng(): Promise<Blob>;
+    /** Re-fit the 3-D mesh view (X-Y-Z mesh charts). */
+    autoscale(): void;
+    /** While set, dragging on a multiband chart shifts this dataset along X. */
+    setShiftMode(datasetId: string | null): void;
+    /**
+     * While set, pointer gestures on the chart draw annotations of this kind
+     * (Escape in the chart drops it; null gives the pointer back to the chart).
+     * Annotations stay selectable, draggable and deletable either way.
+     */
+    setAnnotationTool(tool: AnnotationTool | null): void;
+    annotationTool(): AnnotationTool | null;
+    /** Id of the annotation selected in this chart, or null. */
+    selectedAnnotation(): string | null;
+    setOptions(options: MountOptions): void;
+    destroy(): void;
+}
+/** Render chart `chartId` into `element`. The chart fills the element. */
+export declare function mountChart(engine: KymoscopeEngine, chartId: string, element: HTMLElement, options?: MountOptions): ChartView;
+/** Redraw every mounted chart (e.g. after a font change). */
+export declare function refreshCharts(engine: KymoscopeEngine): void;
+/** Tear down every chart of an engine (called by engine.dispose()). */
+export declare function disposeCharts(engine: KymoscopeEngine): void;

package/dist/types/charts/useWorksheetData.d.ts

@@ -0,0 +1,159 @@
+import type { MultibandEnvelope } from '../components/MultiBandCanvasChart';
+import type { GaugeReading } from '../components/GaugeChart';
+import type { Worksheet } from '../lib/savedLayout';
+import type { LoadedDataset } from '../types/loadedDataset';
+import type { LiveConnection } from '../lib/live/types';
+import type { MathChannel } from '../lib/mathChannels/types';
+import type { PlotSeries } from '../types/plotSeries';
+import { type PointColumns } from '../lib/data/pointColumns';
+import type { XYZColumns, XYZSurface } from '../components/XYZMeshChart';
+import type { BoxPlotGroup } from '../components/BoxPlotChart';
+import type { HeatmapCell, HeatGrid } from '../components/HeatmapChart';
+import type { ViolinGroup } from '../components/ViolinChart';
+import type { LossSeries } from '../components/LossCurveChart';
+import type { ControlColumns } from '../components/ControlChart';
+import type { ParallelColumns } from '../components/ParallelCoordsChart';
+import type { EmbeddingColumns } from '../components/EmbeddingChart';
+import type { FlameNode } from '../components/FlameGraphChart';
+import type { BarGroup, BarColumns } from '../components/BarChart';
+import type { RadarSeries } from '../components/RadarChart';
+import type { AreaSeries } from '../components/AreaChart';
+import type { CdfSeries } from '../components/CdfChart';
+import type { BubbleColumns } from '../components/BubbleChart';
+import type { TreemapNode } from '../components/TreemapChart';
+import type { SankeyLink } from '../components/SankeyChart';
+import type { CalibrationBin } from '../components/CalibrationChart';
+import type { QQColumns } from '../components/QQPlotChart';
+import type { GanttTask } from '../components/GanttChart';
+import { type XYColumns } from '../lib/data/xyColumns';
+import { type Dataset, type DatasetRow } from '../lib/parseDataset';
+import type { DuckDbLayerSpec } from '../components/DuckDbMultiBandPanel';
+export interface WorksheetDataInput {
+    worksheet: Worksheet;
+    viewXRange: [number, number] | null;
+    selectedIds: string[];
+    selectedDatasets: LoadedDataset[];
+    liveConnections: LiveConnection[];
+    mathChannels: MathChannel[];
+    datasetOffsets: Record<string, number>;
+    datasetColors: Record<string, string>;
+    /** Colors by plotted position when not overridden (EngineOptions.palette). */
+    datasetPalette?: string[];
+}
+/**
+ * X range covered by imported datasets (each shifted by its offset): the fixed X
+ * axis while a live stream is shown alongside them, so the stream draws inside
+ * the datasets' range instead of stretching the axis. Null if none has the key.
+ */
+/** Parallel layout: distribute series into equal bands top-to-bottom. */
+export declare function withLayoutBands(srs: PlotSeries[], layout: 'overlay' | 'parallel'): PlotSeries[];
+export declare function staticXExtent(parts: {
+    rows: Record<string, unknown>[];
+    offset: number;
+}[], xKey: string): [number, number] | null;
+/**
+ * Rows of the current lap on a wrapping X: from the last sample where X drops by
+ * more than half its range (lap distance at the finish line). A channel that
+ * never wraps returns the rows unchanged.
+ */
+export declare function currentLapRows(rows: DatasetRow[], xKey: string): DatasetRow[];
+export declare function useWorksheetData(input: WorksheetDataInput): {
+    dataset: Dataset | null;
+    datasetWithChannels: Dataset | null;
+    multiDatasetMode: boolean;
+    numericCols: string[];
+    anyDuckDb: boolean;
+    duckDbLayers: DuckDbLayerSpec[];
+    liveConn: LiveConnection | null;
+    liveOverlay: {
+        conn: LiveConnection;
+        keySuffix: string;
+        offset: number;
+    } | null;
+    hasLiveSelected: boolean;
+    staticXRange: [number, number] | null;
+    xUnit: string;
+    columnUnits: Record<string, string>;
+    multibandDataByPanel: Record<string, {
+        effectiveSeries: PlotSeries[];
+        points: PointColumns[];
+        /** Min–max envelopes of the series across the plotted datasets (envelope on). */
+        envelopes?: MultibandEnvelope[];
+    }>;
+    xyPointsByPanel: {
+        pts: Record<string, XYColumns>;
+        colorMeta: Record<string, {
+            label: string;
+            min: number;
+            max: number;
+        }>;
+        datasetColors: Record<string, string[]>;
+    };
+    xyzPointsByPanel: Record<string, {
+        points: XYZColumns;
+        surface?: XYZSurface;
+    }>;
+    histogramDataByPanel: Record<string, Float64Array<ArrayBufferLike>>;
+    polarDataByPanel: Record<string, {
+        angles: ArrayLike<number>;
+        radii: ArrayLike<number>;
+    }>;
+    spectrumDataByPanel: Record<string, {
+        signal: Float64Array;
+        rate: number;
+    }>;
+    boxplotDataByPanel: Record<string, BoxPlotGroup[]>;
+    spectrogramDataByPanel: Record<string, {
+        signal: Float64Array;
+        rate: number;
+    }>;
+    heatmapDataByPanel: Record<string, {
+        cells: HeatmapCell[];
+        xLabels: string[];
+        yLabels: string[];
+        grid?: HeatGrid;
+        xCentres?: Float64Array;
+        yCentres?: Float64Array;
+    }>;
+    violinDataByPanel: Record<string, ViolinGroup[]>;
+    confusionDataByPanel: Record<string, {
+        actual: ArrayLike<string | number>;
+        predicted: ArrayLike<string | number>;
+    }>;
+    rocDataByPanel: Record<string, {
+        scores: ArrayLike<number>;
+        labels: ArrayLike<number>;
+    }>;
+    lossCurveDataByPanel: Record<string, {
+        xValues: ArrayLike<number>;
+        series: LossSeries[];
+    }>;
+    controlChartDataByPanel: Record<string, ControlColumns>;
+    parallelCoordsDataByPanel: Record<string, ParallelColumns>;
+    embeddingDataByPanel: Record<string, EmbeddingColumns>;
+    flameGraphDataByPanel: Record<string, FlameNode[]>;
+    barChartDataByPanel: Record<string, {
+        groups: BarGroup[];
+        columns?: BarColumns;
+        seriesNames: string[];
+    }>;
+    radarDataByPanel: Record<string, {
+        axes: string[];
+        series: RadarSeries[];
+    }>;
+    areaChartDataByPanel: Record<string, AreaSeries[]>;
+    cdfChartDataByPanel: Record<string, CdfSeries[]>;
+    bubbleChartDataByPanel: Record<string, BubbleColumns>;
+    treemapDataByPanel: Record<string, TreemapNode[]>;
+    sankeyDataByPanel: Record<string, {
+        nodeNames: string[];
+        links: SankeyLink[];
+    }>;
+    calibrationDataByPanel: Record<string, CalibrationBin[]>;
+    qqPlotDataByPanel: Record<string, QQColumns>;
+    ganttDataByPanel: Record<string, GanttTask[]>;
+    gaugeDataByPanel: Record<string, GaugeReading[]>;
+};
+export type WorksheetData = ReturnType<typeof useWorksheetData>;
+/** A gauge's scale: the given ends, else the data's range widened to round steps. */
+export declare function gaugeScale(lo: number, hi: number, min?: number, max?: number): [number, number];

package/dist/types/components/AreaChart.d.ts

@@ -0,0 +1,21 @@
+/** One area: its X and Y as arrays (typed arrays straight from the dataset, or plain). */
+export interface AreaSeries {
+    name: string;
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+}
+export interface AreaChartProps {
+    series: AreaSeries[];
+    stacked?: boolean;
+    /** Fixed Y range (either end absent: from the data). */
+    yRange?: {
+        min?: number;
+        max?: number;
+    };
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function AreaChart({ series, stacked, yRange, backgroundToken, onPlotContextMenu, }: AreaChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/BarChart.d.ts

@@ -0,0 +1,30 @@
+export interface BarGroup {
+    label: string;
+    values: number[];
+}
+/** One bar group per row: each series' values as an array (typed arrays straight from the dataset). */
+export interface BarColumns {
+    length: number;
+    values: ArrayLike<number>[];
+}
+export interface BarChartProps {
+    /** Labelled groups (categories)… */
+    groups?: BarGroup[];
+    /** …or one group per row, labelled by its number. */
+    columns?: BarColumns;
+    seriesNames: string[];
+    colors?: string[];
+    mode?: 'grouped' | 'stacked';
+    horizontal?: boolean;
+    /** Fixed value range (either end absent: from the data). */
+    valueRange?: {
+        min?: number;
+        max?: number;
+    };
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function BarChart({ groups, columns, seriesNames, colors, mode, horizontal, valueRange, backgroundToken, onPlotContextMenu, }: BarChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/BoxPlotChart.d.ts

@@ -0,0 +1,16 @@
+export interface BoxPlotGroup {
+    label: string;
+    values: ArrayLike<number>;
+}
+export interface BoxPlotChartProps {
+    groups: BoxPlotGroup[];
+    color?: string;
+    whiskers?: '1.5iqr' | 'minmax';
+    height?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function BoxPlotChart({ groups, color, whiskers, height, backgroundToken, onPlotContextMenu, }: BoxPlotChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/BubbleChart.d.ts

@@ -0,0 +1,24 @@
+/** Bubbles as columns: position, size, an optional colour (a value or a category) and a label. */
+export interface BubbleColumns {
+    length: number;
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    size: ArrayLike<number>;
+    colorValue?: ArrayLike<number>;
+    /** A category per bubble: an index into `colorLabels`. */
+    colorIndex?: ArrayLike<number>;
+    colorLabels?: string[];
+    label?: (i: number) => string;
+}
+export interface BubbleChartProps {
+    points: BubbleColumns;
+    color?: string;
+    colorByNumeric?: boolean;
+    maxRadius?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function BubbleChart({ points, color, colorByNumeric, maxRadius, backgroundToken, onPlotContextMenu, }: BubbleChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/CalibrationChart.d.ts

@@ -0,0 +1,15 @@
+export interface CalibrationBin {
+    center: number;
+    actual: number;
+    count: number;
+}
+export interface CalibrationChartProps {
+    bins: CalibrationBin[];
+    color?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function CalibrationChart({ bins, color, backgroundToken, onPlotContextMenu, }: CalibrationChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/CdfChart.d.ts

@@ -0,0 +1,15 @@
+export interface CdfSeries {
+    name: string;
+    values: ArrayLike<number>;
+}
+export interface CdfChartProps {
+    series: CdfSeries[];
+    complement?: boolean;
+    logX?: boolean;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function CdfChart({ series, complement, logX, backgroundToken, onPlotContextMenu, }: CdfChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ConfusionChart.d.ts

@@ -0,0 +1,11 @@
+export interface ConfusionChartProps {
+    actual: ArrayLike<string | number>;
+    predicted: ArrayLike<string | number>;
+    normalize?: boolean;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function ConfusionChart({ actual, predicted, normalize, backgroundToken, onPlotContextMenu, }: ConfusionChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ControlChart.d.ts

@@ -0,0 +1,17 @@
+/** The measured values in order (the X axis is their index), with an optional subgroup name each. */
+export interface ControlColumns {
+    length: number;
+    value: ArrayLike<number>;
+    subgroup?: (i: number) => string;
+}
+export interface ControlChartProps {
+    points: ControlColumns;
+    sigmaLevel?: number;
+    color?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function ControlChart({ points, sigmaLevel, color, backgroundToken, onPlotContextMenu, }: ControlChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/DuckDbMultiBandPanel.d.ts

@@ -0,0 +1,35 @@
+import { type MultiBandCanvasChartProps } from './MultiBandCanvasChart';
+import type { DataSource } from '../lib/data/dataSource';
+/** One dataset to overlay (any source kind): its `DataSource`, the set of columns
+ *  it actually has (so absent columns/xKey are skipped), and the column-key
+ *  suffix + X shift to apply (so several datasets coexist with `col__di` keys). */
+export interface DuckDbLayerSpec {
+    source: DataSource;
+    columnSet: Set<string>;
+    keySuffix: string;
+    xOffset: number;
+    /** A live stream: its points and extent refresh while it streams. */
+    live?: boolean;
+    /**
+     * Who this layer is (its dataset, and whether it carries that dataset's math
+     * channels). New data for the same dataset keeps the layer and its points on
+     * screen until the new ones are in; without it a layer is its source.
+     */
+    key?: string;
+}
+type Props = Omit<MultiBandCanvasChartProps, 'points' | 'fullXRange'> & {
+    layers: DuckDbLayerSpec[];
+    xKey: string;
+    /** Base column names to plot (without per-dataset suffix). */
+    columns: string[];
+    /** Target bucket count (≈ chart pixel width). */
+    maxPoints: number;
+};
+/**
+ * MultiBand chart over datasets read through their sources (out-of-core, and
+ * in-memory ones too large to plot row by row). Each layer is decimated per
+ * viewport (two-tier overview+detail) and the results are composited, so N
+ * datasets (laps, math-channel layers) overlay at flat cost (~2k buckets each).
+ */
+export declare function DuckDbMultiBandPanel({ layers, xKey, columns, maxPoints, ...chartProps }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/EmbeddingChart.d.ts

@@ -0,0 +1,25 @@
+/** Embedding points as columns, with an optional colour per point (a value, or a category) and a label. */
+export interface EmbeddingColumns {
+    length: number;
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** A numeric colour value per point. */
+    colorValue?: ArrayLike<number>;
+    /** A category per point: an index into `colorLabels` (-1: none). */
+    colorIndex?: ArrayLike<number>;
+    colorLabels?: string[];
+    /** A point's label for the tooltip. */
+    label?: (i: number) => string;
+}
+export interface EmbeddingChartProps {
+    points: EmbeddingColumns;
+    color?: string;
+    colorByNumeric?: boolean;
+    pointSize?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function EmbeddingChart({ points, color, colorByNumeric, pointSize, backgroundToken, onPlotContextMenu, }: EmbeddingChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/FlameGraphChart.d.ts

@@ -0,0 +1,15 @@
+export interface FlameNode {
+    name: string;
+    parent: string;
+    value: number;
+}
+export interface FlameGraphChartProps {
+    nodes: FlameNode[];
+    direction?: 'topdown' | 'bottomup';
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function FlameGraphChart({ nodes, direction, backgroundToken, onPlotContextMenu, }: FlameGraphChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/GanttChart.d.ts

@@ -0,0 +1,15 @@
+export interface GanttTask {
+    label: string;
+    start: number;
+    end: number;
+    group?: string;
+}
+export interface GanttChartProps {
+    tasks: GanttTask[];
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function GanttChart({ tasks, backgroundToken, onPlotContextMenu, }: GanttChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/GaugeChart.d.ts

@@ -0,0 +1,27 @@
+import type { AlarmLine } from '../types/plotSeries';
+import { type GaugeColorMode, type GaugeColorStop } from '../lib/gaugeColors';
+export interface GaugeReading {
+    name: string;
+    unit: string;
+    /** NaN: no value yet. */
+    value: number;
+    /** The scale. */
+    min: number;
+    max: number;
+    /** Marked on the scale; past it the gauge takes its colour. */
+    alarm?: AlarmLine | null;
+    color: string;
+    style: 'arc' | 'linear';
+    /** Colours by value (see GaugeItem.colorMode). */
+    colorMode?: GaugeColorMode;
+    stops?: GaugeColorStop[];
+}
+export interface GaugeChartProps {
+    gauges: GaugeReading[];
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function GaugeChart({ gauges, backgroundToken, onPlotContextMenu }: GaugeChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/HeatmapChart.d.ts

@@ -0,0 +1,41 @@
+export interface HeatmapCell {
+    x: string;
+    y: string;
+    value: number;
+}
+/**
+ * Values on a uniform grid: `w` columns × `h` rows, row-major (row 0 the first
+ * Y label, at the top); NaN = an empty cell.
+ */
+export interface HeatGrid {
+    w: number;
+    h: number;
+    values: Float32Array;
+    /** Column labels, or a label per column index (numbered columns: many). */
+    xLabels: string[] | ((i: number) => string);
+    yLabels: string[];
+}
+export interface HeatmapChartProps {
+    /** Labelled cells (correlation, binned, count, raw)… */
+    cells?: HeatmapCell[];
+    xLabels?: string[];
+    yLabels?: string[];
+    /** …or a grid of values (matrix). */
+    grid?: HeatGrid;
+    showValues?: boolean;
+    colorScheme?: 'diverging' | 'plasma' | 'viridis';
+    vMin?: number;
+    vMax?: number;
+    /** Where each column sits on X (ascending), for cells sized by value. */
+    xCentres?: Float64Array;
+    /** Where each row sits on Y, top row first (descending), for cells sized by value. */
+    yCentres?: Float64Array;
+    /** Isolines at this many levels across the colour range (0: none). */
+    contours?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function HeatmapChart({ cells, xLabels, yLabels, grid, showValues, colorScheme, vMin, vMax, xCentres, yCentres, contours, backgroundToken, onPlotContextMenu, }: HeatmapChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/HistogramChart.d.ts

@@ -0,0 +1,15 @@
+export interface HistogramChartProps {
+    values: ArrayLike<number>;
+    label: string;
+    bins?: number;
+    color?: string;
+    showNormal?: boolean;
+    logY?: boolean;
+    height?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function HistogramChart({ values, label, bins: binsProp, color, showNormal, logY, height, backgroundToken, onPlotContextMenu, }: HistogramChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/LossCurveChart.d.ts

@@ -0,0 +1,17 @@
+export interface LossSeries {
+    label: string;
+    color: string;
+    values: ArrayLike<number>;
+    axis: 'left' | 'right';
+}
+export interface LossCurveChartProps {
+    xValues: ArrayLike<number>;
+    series: LossSeries[];
+    xLabel?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function LossCurveChart({ xValues, series, xLabel, backgroundToken, onPlotContextMenu, }: LossCurveChartProps): import("react/jsx-runtime").JSX.Element;