velo-plot 1.12.0 → 1.19.0

package/dist/react.js

@@ -0,0 +1,31 @@
+import { c as k } from "./createStackedChart-BPooTQ9z.js";
+import { S as x, u as C } from "./createStackedChart-BPooTQ9z.js";
+import { useRef as n, useState as a, useEffect as m, useCallback as f } from "react";
+function A(c) {
+  const s = n(null), r = n(null), [i, l] = a(null), [d, u] = a(!1), o = n(c);
+  o.current = c, m(() => {
+    const t = s.current;
+    if (!t) return;
+    const e = k({
+      ...o.current,
+      container: t
+    });
+    return r.current = e, l(e), e.whenReady().then(() => u(!0)), () => {
+      u(!1), e.destroy(), r.current = null, l(null);
+    };
+  }, []);
+  const R = f((t) => {
+    var e;
+    (e = r.current) == null || e.fitAll(t);
+  }, []), S = f(() => {
+    var t;
+    (t = r.current) == null || t.resetAll();
+  }, []);
+  return { containerRef: s, stack: i, isReady: d, fitAll: R, resetAll: S };
+}
+export {
+  x as SciPlot,
+  C as useSciPlot,
+  A as useStackedPlot
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sources":["../src/react/useStackedPlot.ts"],"sourcesContent":["/**\n * useStackedPlot - React hook for multi-pane stacked charts\n */\n\nimport {\n  useEffect,\n  useRef,\n  useState,\n  useCallback,\n  type RefObject,\n} from \"react\";\nimport { createStackedChart } from \"../core/stacked\";\nimport type { StackedChart, StackedChartOptions } from \"../core/stacked\";\nimport type { Range } from \"../types\";\n\nexport interface UseStackedPlotOptions extends Omit<StackedChartOptions, \"container\"> {}\n\nexport interface UseStackedPlotReturn {\n  containerRef: RefObject<HTMLDivElement>;\n  stack: StackedChart | null;\n  isReady: boolean;\n  fitAll: (options?: { x?: Range; padding?: number }) => void;\n  resetAll: () => void;\n}\n\nexport function useStackedPlot(\n  options: UseStackedPlotOptions,\n): UseStackedPlotReturn {\n  const containerRef = useRef<HTMLDivElement>(null);\n  const stackRef = useRef<StackedChart | null>(null);\n  const [stack, setStack] = useState<StackedChart | null>(null);\n  const [isReady, setIsReady] = useState(false);\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n\n  useEffect(() => {\n    const el = containerRef.current;\n    if (!el) return;\n\n    const created = createStackedChart({\n      ...optionsRef.current,\n      container: el,\n    });\n    stackRef.current = created;\n    setStack(created);\n\n    created.whenReady().then(() => setIsReady(true));\n\n    return () => {\n      setIsReady(false);\n      created.destroy();\n      stackRef.current = null;\n      setStack(null);\n    };\n  }, []);\n\n  const fitAll = useCallback((opts?: { x?: Range; padding?: number }) => {\n    stackRef.current?.fitAll(opts);\n  }, []);\n\n  const resetAll = useCallback(() => {\n    stackRef.current?.resetAll();\n  }, []);\n\n  return { containerRef, stack, isReady, fitAll, resetAll };\n}\n"],"names":["useStackedPlot","options","containerRef","useRef","stackRef","stack","setStack","useState","isReady","setIsReady","optionsRef","useEffect","el","created","createStackedChart","fitAll","useCallback","opts","_a","resetAll"],"mappings":";;;AAyBO,SAASA,EACdC,GACsB;AACtB,QAAMC,IAAeC,EAAuB,IAAI,GAC1CC,IAAWD,EAA4B,IAAI,GAC3C,CAACE,GAAOC,CAAQ,IAAIC,EAA8B,IAAI,GACtD,CAACC,GAASC,CAAU,IAAIF,EAAS,EAAK,GACtCG,IAAaP,EAAOF,CAAO;AACjC,EAAAS,EAAW,UAAUT,GAErBU,EAAU,MAAM;AACd,UAAMC,IAAKV,EAAa;AACxB,QAAI,CAACU,EAAI;AAET,UAAMC,IAAUC,EAAmB;AAAA,MACjC,GAAGJ,EAAW;AAAA,MACd,WAAWE;AAAA,IAAA,CACZ;AACD,WAAAR,EAAS,UAAUS,GACnBP,EAASO,CAAO,GAEhBA,EAAQ,YAAY,KAAK,MAAMJ,EAAW,EAAI,CAAC,GAExC,MAAM;AACX,MAAAA,EAAW,EAAK,GAChBI,EAAQ,QAAA,GACRT,EAAS,UAAU,MACnBE,EAAS,IAAI;AAAA,IACf;AAAA,EACF,GAAG,CAAA,CAAE;AAEL,QAAMS,IAASC,EAAY,CAACC,MAA2C;;AACrE,KAAAC,IAAAd,EAAS,YAAT,QAAAc,EAAkB,OAAOD;AAAA,EAC3B,GAAG,CAAA,CAAE,GAECE,IAAWH,EAAY,MAAM;;AACjC,KAAAE,IAAAd,EAAS,YAAT,QAAAc,EAAkB;AAAA,EACpB,GAAG,CAAA,CAAE;AAEL,SAAO,EAAE,cAAAhB,GAAc,OAAAG,GAAO,SAAAG,GAAS,QAAAO,GAAQ,UAAAI,EAAA;AACjD;"}

package/dist/renderer/CandlestickRenderer.d.ts

@@ -6,7 +6,7 @@
  * Each candle is represented by a body (box) and a wick (line/thin box)
  * Returns a Float32Array of interleaved [x, y] coordinates for TRIANGLES
  */
-export declare function interleaveCandlestickData(x: Float32Array | Float64Array, open: Float32Array | Float64Array, high: Float32Array | Float64Array, low: Float32Array | Float64Array, close: Float32Array | Float64Array, width: number): {
+export declare function interleaveCandlestickData(x: Float32Array | Float64Array, open: Float32Array | Float64Array, high: Float32Array | Float64Array, low: Float32Array | Float64Array, close: Float32Array | Float64Array, width: number, hollow?: boolean): {
     bullish: Float32Array;
     bearish: Float32Array;
 };

package/dist/renderer/ChartSeriesRenderer.d.ts

@@ -0,0 +1,6 @@
+import { NativeWebGLRenderer } from './NativeWebGLRenderer';
+import { GpuChartRenderer } from './GpuChartRenderer';
+
+export type ChartSeriesRenderer = NativeWebGLRenderer | GpuChartRenderer;
+export type ChartRendererBackend = "webgl" | "webgpu";
+export declare function getRendererBackend(renderer: ChartSeriesRenderer): ChartRendererBackend;

package/dist/renderer/GpuChartRenderer.d.ts

@@ -0,0 +1,23 @@
+import { GpuRenderer, GpuRendererOptions } from '../gpu/adapter/gpuRenderer';
+import { NativeRenderOptions, NativeSeriesRenderData } from './native/types';
+
+export declare class GpuChartRenderer {
+    private gpu;
+    private dpr;
+    private readonly canvas;
+    constructor(gpu: GpuRenderer, canvas: HTMLCanvasElement);
+    get available(): boolean;
+    get backend(): "webgpu" | "webgl";
+    setDPR(dpr: number): void;
+    createBuffer(id: string, data: Float32Array): void;
+    updateBuffer(id: string, data: Float32Array, offsetInBytes: number): boolean;
+    getBuffer(id: string): WebGLBuffer | undefined;
+    deleteBuffer(id: string): void;
+    createColormapTexture(id: string, data: Uint8Array): void;
+    getTexture(id: string): WebGLTexture | undefined;
+    render(series: NativeSeriesRenderData[], options: NativeRenderOptions): void;
+    resize(): void;
+    getLimits(): Record<string, unknown>;
+    destroy(): void;
+}
+export declare function createGpuChartRenderer(canvas: HTMLCanvasElement, options?: GpuRendererOptions): Promise<GpuChartRenderer | null>;

package/dist/renderer/index.d.ts

@@ -3,7 +3,10 @@
  */
 export { NativeWebGLRenderer, interleaveData, interleaveStepData, interleaveBandData, interleaveErrorData, interleaveBoxPlotData, interleaveWaterfallData, parseColor, type NativeSeriesRenderData, type NativeRenderOptions, } from './NativeWebGLRenderer';
 export { type IWebGLRenderer, type SeriesRenderData, type RenderOptions, createRenderer, createNativeRenderer, } from './RendererInterface';
+export { GpuChartRenderer, createGpuChartRenderer } from './GpuChartRenderer';
 export { WebGPURenderer, type WebGPURendererOptions } from './WebGPURenderer';
+export type { ChartSeriesRenderer, ChartRendererBackend } from './ChartSeriesRenderer';
+export { getRendererBackend } from './ChartSeriesRenderer';
 export * from './shaders';
 export * from './radar';
 export { interleaveBarData, calculateBarWidth } from './BarRenderer';

package/dist/renderer/spike/WebGLGridSpike.d.ts

@@ -0,0 +1,40 @@
+/**
+ * WebGL grid spike — batched GL_LINES renderer for axis grid lines.
+ * Labels remain on Canvas 2D; this spike covers grid lines only.
+ * @module renderer/spike/WebGLGridSpike
+ */
+export interface GridLineSpec {
+    /** Plot area in CSS pixels */
+    plotArea: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Pixel X positions for vertical grid lines */
+    xLines: number[];
+    /** Pixel Y positions for horizontal grid lines */
+    yLines: number[];
+    /** Canvas width (physical pixels) */
+    width: number;
+    /** Canvas height (physical pixels) */
+    height: number;
+    /** Line color RGBA 0–1 */
+    color?: [number, number, number, number];
+    /** Line width in pixels */
+    lineWidth?: number;
+}
+/** Build interleaved [x,y] vertex pairs for GL_LINES from tick pixel positions */
+export declare function buildGridLineVertices(spec: GridLineSpec): Float32Array;
+export declare class WebGLGridSpike {
+    private gl;
+    private program;
+    private buffer;
+    private aPosition;
+    private uResolution;
+    private uColor;
+    constructor(canvas: HTMLCanvasElement);
+    /** Upload vertices and draw grid lines */
+    draw(spec: GridLineSpec): number;
+    destroy(): void;
+}

package/dist/testing/baselines/v1.15.0.json.d.ts

@@ -0,0 +1,51 @@
+declare const _default: {
+  "version": "1.17.0",
+  "recordedAt": "2026-07-05",
+  "notes": "Stage 1 baselines. Headless CI uses effective FPS (render throughput when rAF throttled) via scripts/benchmark-scenario-eval.mjs smoke floors.",
+  "regressionThreshold": 0.10,
+  "webgpuMinFpsRatio": 0.95,
+  "scenarios": {
+    "line-1m-pan": {
+      "minAvgFps": 50,
+      "maxAvgFrameTimeMs": 20,
+      "points": 1000000,
+      "description": "1M line points, continuous pan/zoom simulation"
+    },
+    "candlestick-500k": {
+      "minAvgFps": 45,
+      "maxAvgFrameTimeMs": 22,
+      "points": 500000,
+      "description": "500k OHLC bars with PluginVirtualization"
+    },
+    "stack-5pane-resize": {
+      "minAvgFps": 48,
+      "maxAvgFrameTimeMs": 21,
+      "description": "5-pane stack divider drag (batched overlay redraw)"
+    },
+    "line-200k-webgl": {
+      "minAvgFps": 45,
+      "description": "200k line WebGL baseline for renderer compare"
+    },
+    "line-200k-webgpu": {
+      "minAvgFps": 42,
+      "description": "200k line WebGPU — target ≥95% of WebGL FPS"
+    },
+    "boxplot-5k-webgpu": {
+      "minAvgFps": 50,
+      "description": "5k boxplot series on WebGPU chart path"
+    },
+    "grid-canvas2d-dpr2": {
+      "maxAvgFrameUs": 1200,
+      "dpr": 2,
+      "description": "Canvas 2D grid+minor at 1920×1080 @2x"
+    },
+    "grid-webgl-dpr2": {
+      "maxAvgFrameUs": 400,
+      "dpr": 2,
+      "description": "WebGL grid spike lines only @2x"
+    }
+  }
+}
+;
+
+export default _default;

package/dist/testing/gridSpikeBenchmark.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Grid rendering benchmark — Canvas 2D vs WebGL spike comparison.
+ * @module testing/gridSpikeBenchmark
+ */
+export interface GridBenchmarkResult {
+    backend: "canvas2d" | "webgl";
+    dpr: number;
+    width: number;
+    height: number;
+    xTicks: number;
+    yTicks: number;
+    lineSegments: number;
+    avgFrameUs: number;
+    p95FrameUs: number;
+    frames: number;
+}
+export interface GridCompareResult {
+    canvas2d: GridBenchmarkResult;
+    webgl: GridBenchmarkResult | null;
+    /** Positive = WebGL faster */
+    gainPercent: number;
+    recommendation: "implement" | "defer";
+}
+/** Benchmark Canvas 2D grid via OverlayRenderer.drawGrid */
+export declare function benchmarkCanvasGrid(options?: {
+    width?: number;
+    height?: number;
+    dpr?: number;
+    xTickCount?: number;
+    yTickCount?: number;
+    frames?: number;
+    showMinor?: boolean;
+}): GridBenchmarkResult;
+/** Benchmark WebGL grid spike (returns null if WebGL unavailable) */
+export declare function benchmarkWebGLGrid(options?: {
+    width?: number;
+    height?: number;
+    dpr?: number;
+    xTickCount?: number;
+    yTickCount?: number;
+    frames?: number;
+}): GridBenchmarkResult | null;
+/** Compare backends; recommends implement if WebGL ≥20% faster */
+export declare function compareGridBackends(options?: {
+    dpr?: number;
+    frames?: number;
+}): GridCompareResult;
+/** Vertex builder smoke test (no GL required) */
+export declare function countGridVertices(xTickCount: number, yTickCount: number): number;

package/dist/testing/index.d.ts

@@ -68,6 +68,8 @@ export interface BenchmarkResult {
     pointsRendered: number;
     /** Points per second throughput */
     throughput: number;
+    /** Render-only throughput (1000 / avgFrameTime); can exceed wall FPS */
+    renderFps?: number;
 }
 export interface BenchmarkOptions {
     /** Duration of benchmark in ms (default: 5000) */
@@ -223,3 +225,6 @@ export declare function waitForFrames(count?: number): Promise<void>;
  * Wait for a specified duration
  */
 export declare function waitFor(ms: number): Promise<void>;
+export { benchmarkCanvasGrid, benchmarkWebGLGrid, compareGridBackends, countGridVertices, type GridBenchmarkResult, type GridCompareResult, } from './gridSpikeBenchmark';
+export { getBaseline, compareScenarioToBaseline, buildStage1Report, effectiveBenchmarkFps, HEADLESS_LOW_FRAME_THRESHOLD, SMOKE_FLOORS, type Stage1ScenarioResult, type Stage1BrowserReport, } from './stage1BrowserBench';
+export { evaluateRendererCompare, type RendererCompareResult, } from './rendererBenchmark';

package/dist/testing/rendererBenchmark.d.ts

@@ -0,0 +1,13 @@
+import { BenchmarkResult } from './index';
+
+export interface RendererCompareResult {
+    webgl: BenchmarkResult;
+    webgpu: BenchmarkResult | null;
+    webgpuActive: boolean;
+    /** webgpuFps / webglFps — ≥1 means WebGPU is faster or equal */
+    fpsRatio: number;
+    /** Meets ADR target: WebGPU ≥ 95% of WebGL FPS */
+    meetsTarget: boolean;
+    recommendation: "webgpu-ready" | "webgl-faster" | "webgpu-unavailable";
+}
+export declare function evaluateRendererCompare(webgl: BenchmarkResult, webgpu: BenchmarkResult | null, webgpuActive: boolean, minRatio?: number): RendererCompareResult;

package/dist/testing/stage1BrowserBench.d.ts

@@ -0,0 +1,42 @@
+import { BenchmarkResult } from './index';
+import { default as baseline } from './baselines/v1.15.0.json';
+
+export interface Stage1ScenarioResult {
+    id: string;
+    benchmark: BenchmarkResult;
+    passed: boolean;
+    failures: string[];
+    baselineMinFps?: number;
+}
+export interface Stage1BrowserReport {
+    timestamp: number;
+    version: string;
+    scenarios: Stage1ScenarioResult[];
+    allPassed: boolean;
+    regressionThreshold: number;
+}
+export interface BaselineScenario {
+    minAvgFps?: number;
+    maxAvgFrameTimeMs?: number;
+    maxAvgFrameUs?: number;
+    dpr?: number;
+    points?: number;
+    description?: string;
+}
+/** When wall-clock frame count is below this, headless rAF is unreliable — use renderFps. */
+export declare const HEADLESS_LOW_FRAME_THRESHOLD = 30;
+/** Headless smoke floors (renderFps or effective FPS). Desktop uses baseline minAvgFps. */
+export declare const SMOKE_FLOORS: Record<string, number>;
+/** Pick wall or render FPS depending on headless throttling artifacts. */
+export declare function effectiveBenchmarkFps(result: Pick<BenchmarkResult, "avgFps" | "renderFps" | "frameCount">, isHeadless: boolean): number;
+export declare function getBaseline(): typeof baseline;
+/** Compare a benchmark result against v1.15 baseline for a scenario */
+export declare function compareScenarioToBaseline(scenarioId: string, result: BenchmarkResult | {
+    avgFrameUs: number;
+    backend?: string;
+}): {
+    passed: boolean;
+    failures: string[];
+};
+/** Build a full Stage 1 report from scenario results */
+export declare function buildStage1Report(scenarios: Stage1ScenarioResult[]): Stage1BrowserReport;

package/dist/types.d.ts

@@ -69,6 +69,8 @@ export interface AxisOptions {
     labelRotation?: number;
     /** Target number of tick divisions on this axis (default: 8 for X, 6 for Y) */
     tickCount?: number;
+    /** Trading time scale (Stage 2) — business-day gaps, session presets */
+    timeScale?: import('./core/time/TimeScale').TimeScaleOptions;
 }
 export type SeriesType = "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "area" | "bar" | "heatmap" | "candlestick" | "polar" | "radar" | "boxplot" | "waterfall" | "gauge" | "sankey" | "ternary" | "indicator";
 /** Step mode defines where the step occurs */
@@ -202,6 +204,8 @@ export interface SeriesOptions {
     maxPoints?: number;
     /** Identifier for stacking series (same ID will be stacked together) */
     stackId?: string;
+    /** Buy/sell markers on candlestick series (Stage 2.14) */
+    markers?: import('./core/chart/candlestickMarkers').CandlestickMarker[];
 }
 export interface SeriesUpdateData {
     /** New X values */
@@ -509,7 +513,14 @@ export interface ChartOptions {
     container: HTMLDivElement;
     /** Stable chart id (used by sync groups; auto-generated if omitted) */
     id?: string;
-    /** Renderer backend selection (default: 'webgl') */
+    /**
+     * Renderer backend selection (default: `'webgl'`).
+     * `'webgl'` uses WebGL2 via `NativeWebGLRenderer`.
+     * `'webgpu'` uses the GPU abstraction layer (WebGPU when available, otherwise
+     * falls back to WebGL2 with a console warning). Use `chart.getActiveRenderer()`
+     * to inspect the runtime backend. Boxplot/waterfall series render on WebGL only.
+     * @see docs/adr/001-webgpu-renderer-strategy.md
+     */
     renderer?: "webgl" | "webgpu";
     /** X-axis configuration */
     xAxis?: AxisOptions;
@@ -752,6 +763,15 @@ export interface ChartEventMap {
     dataLoading: DataLoadingEvent;
     deltaMeasure: DeltaMeasurement;
     peakMeasure: PeakMeasurement;
+    /** Price alert triggered (Stage 2.18) */
+    alert: {
+        id: string;
+        price: number;
+        direction: "above" | "below" | "cross";
+        seriesId?: string;
+        triggeredAt: number;
+        triggerPrice: number;
+    };
 }
 /** GPU uniform values */
 export interface Uniforms {

package/dist/utils-BK5UUXxj.js

@@ -0,0 +1,172 @@
+const x = [
+  { symbol: "p", factor: 1e-12 },
+  { symbol: "n", factor: 1e-9 },
+  { symbol: "µ", factor: 1e-6 },
+  { symbol: "m", factor: 1e-3 },
+  { symbol: "", factor: 1 },
+  { symbol: "k", factor: 1e3 },
+  { symbol: "M", factor: 1e6 },
+  { symbol: "G", factor: 1e9 }
+];
+function g(t) {
+  const e = Math.abs(t);
+  if (e === 0)
+    return { symbol: "", factor: 1 };
+  for (let n = x.length - 1; n >= 0; n--) {
+    const r = x[n], o = e / r.factor;
+    if (o >= 1 && o < 1e3)
+      return r;
+  }
+  return { symbol: "", factor: 1 };
+}
+function F(t, e, n = 2) {
+  const r = g(t);
+  return `${(t / r.factor).toFixed(n)} ${r.symbol}${e}`;
+}
+function w(t, e = 3) {
+  return Math.abs(t) < 1e-3 || Math.abs(t) >= 1e6 ? t.toExponential(e) : t.toFixed(e);
+}
+function I(t, e = 2) {
+  return t.toExponential(e);
+}
+function v(t, e = 1e-3) {
+  const n = t instanceof Array ? new Float32Array(t) : t;
+  if (n.length < 3) return [];
+  const r = [];
+  let o = 0, i = 1, f = Math.sign(n[1] - n[0]), l = 0;
+  for (let a = 2; a < n.length; a++) {
+    const c = Math.sign(n[a] - n[a - 1]);
+    if (c !== 0 && c !== f) {
+      if (l++, l >= 2) {
+        const s = n[o], h = n[a];
+        Math.abs(h - s) < e && (r.push({
+          number: i,
+          startIndex: o,
+          endIndex: a,
+          direction: n[o + 1] > n[o] ? 1 : -1
+        }), i++, o = a, l = 0);
+      }
+      f = c;
+    }
+  }
+  return o < n.length - 1 && r.push({
+    number: i,
+    startIndex: o,
+    endIndex: n.length - 1,
+    direction: n[o + 1] > n[o] ? 1 : -1
+  }), r;
+}
+function D(t) {
+  const e = [], n = 360 / Math.max(t, 1);
+  for (let r = 0; r < t; r++) {
+    const o = r * n % 360;
+    e.push(`hsl(${o}, 70%, 55%)`);
+  }
+  return e;
+}
+function S(t, e, n = {}) {
+  const { minProminence: r = 0, type: o = "both" } = n, i = [], f = t instanceof Array ? new Float32Array(t) : t, l = e instanceof Array ? new Float32Array(e) : e;
+  for (let a = 1; a < l.length - 1; a++) {
+    const c = l[a - 1], s = l[a], h = l[a + 1];
+    if (s > c && s > h) {
+      const y = Math.min(s - c, s - h);
+      y >= r && (o === "both" || o === "max") && i.push({ index: a, x: f[a], y: s, type: "max", prominence: y });
+    }
+    if (s < c && s < h) {
+      const y = Math.min(c - s, h - s);
+      y >= r && (o === "both" || o === "min") && i.push({ index: a, x: f[a], y: s, type: "min", prominence: y });
+    }
+  }
+  return i;
+}
+function k(t) {
+  let e = 0, n = -1;
+  const r = t instanceof Array ? t : Array.from(t);
+  for (let o = 0; o < r.length; o++)
+    isFinite(r[o]) || (e++, n === -1 && (n = o));
+  return {
+    valid: e === 0,
+    invalidCount: e,
+    firstInvalidIndex: n
+  };
+}
+function C(t) {
+  const e = t instanceof Array ? t : Array.from(t), n = e.length;
+  if (n === 0)
+    return { min: 0, max: 0, mean: 0, stdDev: 0, count: 0 };
+  let r = e[0], o = e[0], i = 0;
+  for (let c = 0; c < n; c++) {
+    const s = e[c];
+    s < r && (r = s), s > o && (o = s), i += s;
+  }
+  const f = i / n;
+  let l = 0;
+  for (let c = 0; c < n; c++) {
+    const s = e[c] - f;
+    l += s * s;
+  }
+  const a = Math.sqrt(l / n);
+  return { min: r, max: o, mean: f, stdDev: a, count: n };
+}
+function E(t, e) {
+  const n = t instanceof Array ? new Float32Array(t) : t, r = new Float32Array(n.length), o = Math.floor(e / 2);
+  for (let i = 0; i < n.length; i++) {
+    let f = 0, l = 0;
+    for (let a = Math.max(0, i - o); a <= Math.min(n.length - 1, i + o); a++)
+      f += n[a], l++;
+    r[i] = f / l;
+  }
+  return r;
+}
+function B(t, e, n) {
+  const r = t.length;
+  if (n >= r || n < 3)
+    return { x: new Float32Array(t), y: new Float32Array(e) };
+  const o = new Float32Array(n), i = new Float32Array(n);
+  o[0] = t[0], i[0] = e[0];
+  const f = (r - 2) / (n - 2);
+  let l = 0, a = 1;
+  for (let c = 0; c < n - 2; c++) {
+    const s = Math.floor((c + 1) * f) + 1, h = Math.floor((c + 2) * f) + 1, y = Math.min(Math.floor((c + 3) * f) + 1, r);
+    let b = 0, u = 0, d = 0;
+    for (let m = h; m < y; m++)
+      b += t[m], u += e[m], d++;
+    d > 0 && (b /= d, u /= d);
+    let p = -1, A = s;
+    for (let m = s; m < h && m < r; m++) {
+      const M = Math.abs(
+        (t[l] - b) * (e[m] - e[l]) - (t[l] - t[m]) * (u - e[l])
+      );
+      M > p && (p = M, A = m);
+    }
+    o[a] = t[A], i[a] = e[A], a++, l = A;
+  }
+  return o[n - 1] = t[r - 1], i[n - 1] = e[r - 1], { x: o, y: i };
+}
+function V(t, e, n, r) {
+  const o = t.length, i = new Float32Array(o);
+  let f = 0, l = o - 1, a = 1 / 0, c = 1 / 0;
+  for (let u = 0; u < o; u++) {
+    const d = Math.abs(t[u] - n), p = Math.abs(t[u] - r);
+    d < a && (a = d, f = u), p < c && (c = p, l = u);
+  }
+  const s = e[f], y = (e[l] - s) / (t[l] - t[f]), b = s - y * t[f];
+  for (let u = 0; u < o; u++)
+    i[u] = e[u] - (y * t[u] + b);
+  return i;
+}
+export {
+  v as a,
+  S as b,
+  C as c,
+  B as d,
+  w as e,
+  F as f,
+  D as g,
+  I as h,
+  g as i,
+  E as m,
+  V as s,
+  k as v
+};
+//# sourceMappingURL=utils-BK5UUXxj.js.map

package/dist/utils-BK5UUXxj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-BK5UUXxj.js","sources":["../src/plugins/analysis/utils.ts"],"sourcesContent":["/**\n * Data Analysis Utilities\n *\n * General-purpose utilities for scientific data formatting,\n * cycle detection, peak detection, and data validation.\n */\n\n// ============================================\n// Unit Prefixes\n// ============================================\n\ntype SIPrefix = 'p' | 'n' | 'µ' | 'm' | '' | 'k' | 'M' | 'G';\n\nexport interface PrefixInfo {\n  symbol: SIPrefix;\n  factor: number;\n}\n\nconst SI_PREFIXES: PrefixInfo[] = [\n  { symbol: 'p', factor: 1e-12 },\n  { symbol: 'n', factor: 1e-9 },\n  { symbol: 'µ', factor: 1e-6 },\n  { symbol: 'm', factor: 1e-3 },\n  { symbol: '', factor: 1 },\n  { symbol: 'k', factor: 1e3 },\n  { symbol: 'M', factor: 1e6 },\n  { symbol: 'G', factor: 1e9 },\n];\n\n/**\n * Find the best SI prefix for a value\n */\nexport function getBestPrefix(value: number): PrefixInfo {\n  const absValue = Math.abs(value);\n\n  if (absValue === 0) {\n    return { symbol: '', factor: 1 };\n  }\n\n  // Find prefix where value becomes 1-999\n  for (let i = SI_PREFIXES.length - 1; i >= 0; i--) {\n    const prefix = SI_PREFIXES[i];\n    const scaled = absValue / prefix.factor;\n    if (scaled >= 1 && scaled < 1000) {\n      return prefix;\n    }\n  }\n\n  // Default to base unit\n  return { symbol: '', factor: 1 };\n}\n\n/**\n * Format a value with automatic SI prefix\n *\n * @example\n * formatWithPrefix(0.000001, 'A') // \"1.00 µA\"\n * formatWithPrefix(0.5, 'V')      // \"500 mV\"\n * formatWithPrefix(1500, 'm')     // \"1.50 km\"\n */\nexport function formatWithPrefix(\n  value: number,\n  unit: string,\n  decimals = 2\n): string {\n  const prefix = getBestPrefix(value);\n  const scaled = value / prefix.factor;\n  return `${scaled.toFixed(decimals)} ${prefix.symbol}${unit}`;\n}\n\n/**\n * Format a numeric value with specified decimals\n * Automatically switches to scientific notation for very large/small values\n */\nexport function formatValue(value: number, decimals = 3): string {\n  if (Math.abs(value) < 0.001 || Math.abs(value) >= 1e6) {\n    return value.toExponential(decimals);\n  }\n  return value.toFixed(decimals);\n}\n\n/**\n * Format value in scientific notation\n */\nexport function formatScientific(value: number, decimals = 2): string {\n  return value.toExponential(decimals);\n}\n\n// ============================================\n// Cycle Detection\n// ============================================\n\nexport interface CycleInfo {\n  /** Cycle number (1-indexed) */\n  number: number;\n  /** Start index in data array */\n  startIndex: number;\n  /** End index in data array */\n  endIndex: number;\n  /** Direction at start: 1 = forward, -1 = reverse */\n  direction: 1 | -1;\n}\n\n/**\n * Detect cycles in oscillating data\n *\n * A cycle is complete when the signal returns to its starting value\n * after going through both sweep directions. Useful for:\n * - Cyclic voltammetry data\n * - Periodic signals\n * - Oscillation analysis\n *\n * @param signal - The signal data (e.g., potential, position, etc.)\n * @param tolerance - How close to starting value to consider a cycle complete\n */\nexport function detectCycles(\n  signal: Float32Array | Float64Array | number[],\n  tolerance = 0.001\n): CycleInfo[] {\n  const data = signal instanceof Array ? new Float32Array(signal) : signal;\n  \n  if (data.length < 3) return [];\n\n  const cycles: CycleInfo[] = [];\n  let cycleStart = 0;\n  let cycleNumber = 1;\n\n  // Determine initial direction\n  let prevDirection = Math.sign(data[1] - data[0]);\n  let directionChanges = 0;\n\n  for (let i = 2; i < data.length; i++) {\n    const direction = Math.sign(data[i] - data[i - 1]);\n\n    // Skip if no movement\n    if (direction === 0) continue;\n\n    // Direction change detected\n    if (direction !== prevDirection) {\n      directionChanges++;\n\n      // After 2 direction changes, check if we're back at start\n      if (directionChanges >= 2) {\n        const startValue = data[cycleStart];\n        const currentValue = data[i];\n\n        if (Math.abs(currentValue - startValue) < tolerance) {\n          cycles.push({\n            number: cycleNumber,\n            startIndex: cycleStart,\n            endIndex: i,\n            direction: data[cycleStart + 1] > data[cycleStart] ? 1 : -1,\n          });\n\n          cycleNumber++;\n          cycleStart = i;\n          directionChanges = 0;\n        }\n      }\n\n      prevDirection = direction;\n    }\n  }\n\n  // Handle last incomplete cycle\n  if (cycleStart < data.length - 1) {\n    cycles.push({\n      number: cycleNumber,\n      startIndex: cycleStart,\n      endIndex: data.length - 1,\n      direction: data[cycleStart + 1] > data[cycleStart] ? 1 : -1,\n    });\n  }\n\n  return cycles;\n}\n\n/**\n * Generate distinct colors for cycles/series\n *\n * Uses HSL color space to generate evenly distributed hues\n */\nexport function generateCycleColors(count: number): string[] {\n  const colors: string[] = [];\n  const hueStep = 360 / Math.max(count, 1);\n\n  for (let i = 0; i < count; i++) {\n    const hue = (i * hueStep) % 360;\n    colors.push(`hsl(${hue}, 70%, 55%)`);\n  }\n\n  return colors;\n}\n\n// ============================================\n// Peak Detection\n// ============================================\n\nexport interface Peak {\n  /** Index in data array */\n  index: number;\n  /** X value at peak */\n  x: number;\n  /** Y value at peak */\n  y: number;\n  /** Peak type */\n  type: 'max' | 'min';\n  /** Prominence of the peak */\n  prominence: number;\n}\n\n/**\n * Detect peaks (local maxima and minima) in data\n *\n * Uses simple local extrema detection with optional prominence filtering.\n * Useful for:\n * - Signal peak detection\n * - Finding local maxima/minima\n * - Feature extraction\n *\n * @param x - X values (independent variable)\n * @param y - Y values (dependent variable)\n * @param options - Detection options\n */\nexport function detectPeaks(\n  x: Float32Array | Float64Array | number[],\n  y: Float32Array | Float64Array | number[],\n  options: {\n    /** Minimum prominence to be considered a peak */\n    minProminence?: number;\n    /** Only return 'max' or 'min' peaks */\n    type?: 'max' | 'min' | 'both';\n  } = {}\n): Peak[] {\n  const { minProminence = 0, type = 'both' } = options;\n  const peaks: Peak[] = [];\n\n  const xData = x instanceof Array ? new Float32Array(x) : x;\n  const yData = y instanceof Array ? new Float32Array(y) : y;\n\n  for (let i = 1; i < yData.length - 1; i++) {\n    const prev = yData[i - 1];\n    const curr = yData[i];\n    const next = yData[i + 1];\n\n    // Local maximum\n    if (curr > prev && curr > next) {\n      const prominence = Math.min(curr - prev, curr - next);\n      if (prominence >= minProminence && (type === 'both' || type === 'max')) {\n        peaks.push({ index: i, x: xData[i], y: curr, type: 'max', prominence });\n      }\n    }\n\n    // Local minimum\n    if (curr < prev && curr < next) {\n      const prominence = Math.min(prev - curr, next - curr);\n      if (prominence >= minProminence && (type === 'both' || type === 'min')) {\n        peaks.push({ index: i, x: xData[i], y: curr, type: 'min', prominence });\n      }\n    }\n  }\n\n  return peaks;\n}\n\n// ============================================\n// Data Validation\n// ============================================\n\nexport interface ValidationResult {\n  /** Whether all data is valid */\n  valid: boolean;\n  /** Number of invalid values (NaN, Infinity, etc.) */\n  invalidCount: number;\n  /** Index of first invalid value (-1 if all valid) */\n  firstInvalidIndex: number;\n}\n\n/**\n * Validate that data contains only finite numbers\n *\n * Checks for NaN, Infinity, and -Infinity values.\n * Useful for data quality checks before rendering.\n */\nexport function validateData(\n  data: Float32Array | Float64Array | number[]\n): ValidationResult {\n  let invalidCount = 0;\n  let firstInvalidIndex = -1;\n\n  const arr = data instanceof Array ? data : Array.from(data);\n\n  for (let i = 0; i < arr.length; i++) {\n    if (!isFinite(arr[i])) {\n      invalidCount++;\n      if (firstInvalidIndex === -1) {\n        firstInvalidIndex = i;\n      }\n    }\n  }\n\n  return {\n    valid: invalidCount === 0,\n    invalidCount,\n    firstInvalidIndex,\n  };\n}\n\n// ============================================\n// Data Statistics\n// ============================================\n\nexport interface DataStats {\n  min: number;\n  max: number;\n  mean: number;\n  stdDev: number;\n  count: number;\n}\n\n/**\n * Calculate basic statistics for a dataset\n */\nexport function calculateStats(\n  data: Float32Array | Float64Array | number[]\n): DataStats {\n  const arr = data instanceof Array ? data : Array.from(data);\n  const count = arr.length;\n\n  if (count === 0) {\n    return { min: 0, max: 0, mean: 0, stdDev: 0, count: 0 };\n  }\n\n  let min = arr[0];\n  let max = arr[0];\n  let sum = 0;\n\n  for (let i = 0; i < count; i++) {\n    const val = arr[i];\n    if (val < min) min = val;\n    if (val > max) max = val;\n    sum += val;\n  }\n\n  const mean = sum / count;\n\n  // Calculate standard deviation\n  let sumSquaredDiff = 0;\n  for (let i = 0; i < count; i++) {\n    const diff = arr[i] - mean;\n    sumSquaredDiff += diff * diff;\n  }\n  const stdDev = Math.sqrt(sumSquaredDiff / count);\n\n  return { min, max, mean, stdDev, count };\n}\n\n// ============================================\n// Data Smoothing\n// ============================================\n\n/**\n * Apply moving average smoothing to data\n *\n * @param data - Input data array\n * @param windowSize - Number of points to average (must be odd)\n */\nexport function movingAverage(\n  data: Float32Array | Float64Array | number[],\n  windowSize: number\n): Float32Array {\n  const arr = data instanceof Array ? new Float32Array(data) : data;\n  const result = new Float32Array(arr.length);\n  const halfWindow = Math.floor(windowSize / 2);\n\n  for (let i = 0; i < arr.length; i++) {\n    let sum = 0;\n    let count = 0;\n\n    for (let j = Math.max(0, i - halfWindow); j <= Math.min(arr.length - 1, i + halfWindow); j++) {\n      sum += arr[j];\n      count++;\n    }\n\n    result[i] = sum / count;\n  }\n\n  return result;\n}\n\n/**\n * Downsample data using LTTB (Largest Triangle Three Buckets) algorithm\n *\n * Preserves visual characteristics while reducing point count.\n * Ideal for rendering large datasets efficiently.\n *\n * @param x - X values\n * @param y - Y values\n * @param targetPoints - Desired number of output points\n */\nexport function downsampleLTTB(\n  x: Float32Array | Float64Array,\n  y: Float32Array | Float64Array,\n  targetPoints: number\n): { x: Float32Array; y: Float32Array } {\n  const dataLength = x.length;\n\n  if (targetPoints >= dataLength || targetPoints < 3) {\n    return { x: new Float32Array(x), y: new Float32Array(y) };\n  }\n\n  const sampledX = new Float32Array(targetPoints);\n  const sampledY = new Float32Array(targetPoints);\n\n  // Always include first point\n  sampledX[0] = x[0];\n  sampledY[0] = y[0];\n\n  const bucketSize = (dataLength - 2) / (targetPoints - 2);\n\n  let a = 0; // Previous selected point index\n  let sampledIndex = 1;\n\n  for (let i = 0; i < targetPoints - 2; i++) {\n    // Calculate bucket range\n    const bucketStart = Math.floor((i + 1) * bucketSize) + 1;\n    const bucketEnd = Math.floor((i + 2) * bucketSize) + 1;\n    const nextBucketEnd = Math.min(Math.floor((i + 3) * bucketSize) + 1, dataLength);\n\n    // Calculate average of next bucket for comparison\n    let avgX = 0;\n    let avgY = 0;\n    let avgCount = 0;\n\n    for (let j = bucketEnd; j < nextBucketEnd; j++) {\n      avgX += x[j];\n      avgY += y[j];\n      avgCount++;\n    }\n\n    if (avgCount > 0) {\n      avgX /= avgCount;\n      avgY /= avgCount;\n    }\n\n    // Find point in current bucket with largest triangle area\n    let maxArea = -1;\n    let maxAreaIndex = bucketStart;\n\n    for (let j = bucketStart; j < bucketEnd && j < dataLength; j++) {\n      // Triangle area calculation\n      const area = Math.abs(\n        (x[a] - avgX) * (y[j] - y[a]) - (x[a] - x[j]) * (avgY - y[a])\n      );\n\n      if (area > maxArea) {\n        maxArea = area;\n        maxAreaIndex = j;\n      }\n    }\n\n    sampledX[sampledIndex] = x[maxAreaIndex];\n    sampledY[sampledIndex] = y[maxAreaIndex];\n    sampledIndex++;\n    a = maxAreaIndex;\n  }\n\n  // Always include last point\n  sampledX[targetPoints - 1] = x[dataLength - 1];\n  sampledY[targetPoints - 1] = y[dataLength - 1];\n\n  return { x: sampledX, y: sampledY };\n}\n\n/**\n * Subtract a linear baseline from data\n * \n * @param x - X data\n * @param y - Y data\n * @param x1 - Start of baseline segment\n * @param x2 - End of baseline segment\n */\nexport function subtractBaseline(\n  x: Float32Array | number[],\n  y: Float32Array | number[],\n  x1: number,\n  x2: number\n): Float32Array {\n  const n = x.length;\n  const result = new Float32Array(n);\n\n  // Find points near x1 and x2 to determine baseline\n  let i1 = 0, i2 = n - 1;\n  let minDist1 = Infinity, minDist2 = Infinity;\n\n  for (let i = 0; i < n; i++) {\n    const d1 = Math.abs(x[i] - x1);\n    const d2 = Math.abs(x[i] - x2);\n    if (d1 < minDist1) { minDist1 = d1; i1 = i; }\n    if (d2 < minDist2) { minDist2 = d2; i2 = i; }\n  }\n\n  const y1 = y[i1];\n  const y2 = y[i2];\n  const slope = (y2 - y1) / (x[i2] - x[i1]);\n  const intercept = y1 - slope * x[i1];\n\n  for (let i = 0; i < n; i++) {\n    result[i] = y[i] - (slope * x[i] + intercept);\n  }\n\n  return result;\n}\n"],"names":["SI_PREFIXES","getBestPrefix","value","absValue","i","prefix","scaled","formatWithPrefix","unit","decimals","formatValue","formatScientific","detectCycles","signal","tolerance","data","cycles","cycleStart","cycleNumber","prevDirection","directionChanges","direction","startValue","currentValue","generateCycleColors","count","colors","hueStep","hue","detectPeaks","x","y","options","minProminence","type","peaks","xData","yData","prev","curr","next","prominence","validateData","invalidCount","firstInvalidIndex","arr","calculateStats","min","max","sum","val","mean","sumSquaredDiff","diff","stdDev","movingAverage","windowSize","result","halfWindow","j","downsampleLTTB","targetPoints","dataLength","sampledX","sampledY","bucketSize","a","sampledIndex","bucketStart","bucketEnd","nextBucketEnd","avgX","avgY","avgCount","maxArea","maxAreaIndex","area","subtractBaseline","x1","x2","n","i1","i2","minDist1","minDist2","d1","d2","y1","slope","intercept"],"mappings":"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"}