velo-plot 1.15.0 → 1.19.0

package/dist/velo-plot.js

@@ -1,32 +1,32 @@
-import { A as r, h as s, D as n, k as t, j as i, L as g, d as l, N as c, P as o, S as E, c as m, N as T, J as u, f as A, l as N, e as P, g as d, n as f, p as L } from "./ChartCore-BimVvUEg.js";
-import { E as p } from "./axisFormat-B7o_uIEA.js";
-import { h as C, f as I, c as M, d as R, g as _, r as x } from "./index.core-C_-CFftD.js";
+import { A as r, D as s, h as t, x as n, u as i, L as g, n as o, N as c, a3 as l, S as E, c as m, N as u, a2 as T, o as A, y as N, f, j as L, z as P, t as d } from "./ChartCore-DQ691eXH.js";
+import { E as S } from "./axisFormat-B7o_uIEA.js";
+import { h as x, f as C, c as I, d as M, g as R, r as _ } from "./index.core-BtGFYMOu.js";
 export {
   r as AnimationEngine,
   s as DARK_THEME,
-  n as DEFAULT_ANIMATION_CONFIG,
-  t as DEFAULT_THEME,
-  p as EventEmitter,
+  t as DEFAULT_ANIMATION_CONFIG,
+  n as DEFAULT_THEME,
+  S as EventEmitter,
   i as LIGHT_THEME,
   g as LinearScale,
-  l as LogScale,
+  o as LogScale,
   c as NativeWebGLRenderer,
-  o as PluginManagerImpl,
+  l as PluginManagerImpl,
   E as Series,
   m as createChart,
-  C as createConfigurablePlugin,
-  T as createNativeRenderer,
-  I as createPlugin,
-  u as createPluginContext,
-  M as createRenderer,
+  x as createConfigurablePlugin,
+  u as createNativeRenderer,
+  C as createPlugin,
+  T as createPluginContext,
+  I as createRenderer,
   A as createScale,
   N as createTheme,
-  R as definePlugin,
-  P as easings,
-  _ as getPluginRegistry,
-  d as getSharedAnimationEngine,
-  f as getThemeByName,
-  L as parseColor,
-  x as registerPlugin
+  M as definePlugin,
+  f as easings,
+  R as getPluginRegistry,
+  L as getSharedAnimationEngine,
+  P as getThemeByName,
+  d as parseColor,
+  _ as registerPlugin
 };
 //# sourceMappingURL=velo-plot.js.map

package/dist/workers/downsample.d.ts

@@ -32,3 +32,41 @@ export declare function minMaxDownsample(x: Float32Array | Float64Array, y: Floa
  * Calculate optimal target points based on canvas width
  */
 export declare function calculateTargetPoints(dataLength: number, canvasWidth: number, pointsPerPixel?: number): number;
+export interface OhlcDownsampleResult {
+    x: Float32Array;
+    open: Float32Array;
+    high: Float32Array;
+    low: Float32Array;
+    close: Float32Array;
+    indices: Uint32Array;
+}
+/**
+ * Aggregate OHLC bars into fewer buckets while preserving extremes.
+ * Each bucket: open=first open, close=last close, high=max high, low=min low, x=last x.
+ */
+export declare function ohlcMinMaxDownsample(x: Float32Array | Float64Array, open: Float32Array | Float64Array, high: Float32Array | Float64Array, low: Float32Array | Float64Array, close: Float32Array | Float64Array, targetBars: number): OhlcDownsampleResult;
+/** Binary search lower bound: first index where x[i] >= value */
+export declare function lowerBoundX(x: Float32Array | Float64Array, value: number): number;
+/** Binary search upper bound: first index where x[i] > value */
+export declare function upperBoundX(x: Float32Array | Float64Array, value: number): number;
+export interface ViewportSlice {
+    x: Float32Array;
+    y?: Float32Array;
+    open?: Float32Array;
+    high?: Float32Array;
+    low?: Float32Array;
+    close?: Float32Array;
+    start: number;
+    end: number;
+}
+/**
+ * Slice sorted x-series to visible range plus buffer (fraction of visible width).
+ */
+export declare function sliceSeriesToViewport(source: {
+    x: Float32Array | Float64Array;
+    y?: Float32Array | Float64Array;
+    open?: Float32Array | Float64Array;
+    high?: Float32Array | Float64Array;
+    low?: Float32Array | Float64Array;
+    close?: Float32Array | Float64Array;
+}, xMin: number, xMax: number, bufferRatio?: number): ViewportSlice;

package/dist/workers/downsampleAsync.d.ts

@@ -0,0 +1,6 @@
+import { OhlcDownsampleResult, DownsampleResult } from './downsample';
+
+export declare function downsampleAsync(x: Float32Array, y: Float32Array, targetPoints: number, algorithm?: "lttb" | "minmax"): Promise<DownsampleResult>;
+export declare function ohlcDownsampleAsync(x: Float32Array, open: Float32Array, high: Float32Array, low: Float32Array, close: Float32Array, targetBars: number): Promise<OhlcDownsampleResult>;
+export declare function destroyDownsamplePool(): void;
+export declare function getDownsamplePoolSize(): number;

package/dist/workers/indicator.worker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Indicator calculations in a Web Worker.
+ * @module workers/indicator.worker
+ */
+interface IndicatorTask {
+    id: string;
+    type: "indicator";
+    indicator: "rsi" | "macd" | "bollingerBands" | "sma" | "ema";
+    data: Float32Array | Float64Array;
+    period?: number;
+    fastPeriod?: number;
+    slowPeriod?: number;
+    signalPeriod?: number;
+    stdDev?: number;
+}
+interface IndicatorResultMessage {
+    id: string;
+    type: "indicator-result";
+    indicator: string;
+    values: Float32Array;
+    signal?: Float32Array;
+    upper?: Float32Array;
+    lower?: Float32Array;
+    histogram?: Float32Array;
+    duration: number;
+}
+interface ErrorMessage {
+    id: string;
+    type: "error";
+    error: string;
+}
+export type { IndicatorTask, IndicatorResultMessage, ErrorMessage };

package/dist/workers/indicatorsAsync.d.ts

@@ -0,0 +1,26 @@
+import { IndicatorResult } from '../plugins/analysis/indicators';
+
+/** Async RSI — non-blocking for large datasets */
+export declare function rsiAsync(data: Float32Array | Float64Array | number[], period?: number): Promise<IndicatorResult & {
+    duration: number;
+}>;
+/** Async SMA */
+export declare function smaAsync(data: Float32Array | Float64Array | number[], period?: number): Promise<IndicatorResult & {
+    duration: number;
+}>;
+/** Async EMA */
+export declare function emaAsync(data: Float32Array | Float64Array | number[], period?: number): Promise<IndicatorResult & {
+    duration: number;
+}>;
+/** Async MACD */
+export declare function macdAsync(data: Float32Array | Float64Array | number[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number): Promise<IndicatorResult & {
+    duration: number;
+}>;
+/** Async Bollinger Bands */
+export declare function bollingerBandsAsync(data: Float32Array | Float64Array | number[], period?: number, stdDev?: number): Promise<IndicatorResult & {
+    duration: number;
+}>;
+/** Destroy the shared indicator worker pool (for tests) */
+export declare function destroyIndicatorPool(): void;
+/** Exposed for tests */
+export declare function getIndicatorPoolSize(): number;

package/dist/workers/pool.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generic worker pool with round-robin dispatch and sync fallback.
+ * @module workers/pool
+ */
+export interface WorkerPoolOptions {
+    /** Number of workers (default: 2) */
+    poolSize?: number;
+    /** Run tasks on main thread when Worker is unavailable */
+    syncFallback?: boolean;
+}
+export declare class WorkerPool<TMessage extends {
+    id: string;
+}, TResult = unknown> {
+    private workers;
+    private pending;
+    private nextWorker;
+    private readonly poolSize;
+    private readonly syncFallback;
+    private readonly workerFactory;
+    private readonly syncHandler?;
+    private destroyed;
+    constructor(workerFactory: () => Worker, options?: WorkerPoolOptions & {
+        syncHandler?: (task: TMessage) => TResult | Promise<TResult>;
+    });
+    private removeWorker;
+    private workerErrorMessage;
+    private rejectPendingWithSyncFallback;
+    private spawnWorker;
+    /** Dispatch a task to the pool. Falls back to syncHandler when no workers exist. */
+    run(task: TMessage): Promise<TResult>;
+    size(): number;
+    pendingCount(): number;
+    destroy(): void;
+}
+/** Generate a unique task id */
+export declare function nextTaskId(prefix?: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "velo-plot",
-  "version": "1.15.0",
+  "version": "1.19.0",
   "author": "jigonzalez930209",
   "license": "MIT",
   "repository": {
@@ -173,11 +173,13 @@
     "react-dom": ">=16.8.0"
   },
   "devDependencies": {
+    "@playwright/test": "^1.52.0",
     "@types/node": "^25.0.3",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",
     "@vitest/coverage-v8": "^3.2.6",
     "happy-dom": "^20.10.6",
+    "playwright": "^1.52.0",
     "typescript": "^5.2.2",
     "vite": "^5.0.0",
     "vite-plugin-dts": "^3.6.0",
@@ -192,6 +194,14 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
+    "test:dom": "vitest run .dom.test.ts",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "test:e2e:headed": "playwright test --headed",
+    "test:browser-bench": "node scripts/browser-benchmark.mjs",
+    "test:browser-bench:headed": "HEADED=1 node scripts/browser-benchmark.mjs",
+    "test:all": "pnpm test && pnpm test:dom && pnpm test:e2e && pnpm test:browser-bench",
+    "test:bench-regression": "node scripts/compare-benchmark-regression.mjs",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
     "docs:preview": "vitepress preview docs"