@forgecharts/sdk 1.1.27 → 1.1.28

package/src/renderers/LineRenderer.ts

@@ -1,77 +0,0 @@
-import type { OHLCV, SeriesOptions, Viewport, Rect, ChartColors } from '@forgecharts/types';
-import type { IRenderer } from '../types/IRenderer';
-import { mapRange } from '@forgecharts/utils';
-import { hexToRgba } from '@forgecharts/utils';
-
-/**
- * LineRenderer — draws close prices as a line or area series.
- */
-export class LineRenderer implements IRenderer {
-  private readonly _colors: ChartColors;
-
-  constructor(colors: ChartColors) {
-    this._colors = colors;
-  }
-
-  draw(
-    ctx: CanvasRenderingContext2D,
-    bars: readonly OHLCV[],
-    viewport: Viewport,
-    rect: Rect,
-    options: SeriesOptions,
-  ): void {
-    if (options.type !== 'line' && options.type !== 'area') return;
-    if (bars.length < 2) return;
-
-    const color = options.color ?? '#58a6ff';
-    const lineWidth = options.lineWidth ?? 2;
-    const isArea = options.type === 'area';
-
-    const plotW = rect.width - 70;
-    const plotH = rect.height - 30;
-
-    const points = bars.map((bar) => ({
-      x: mapRange(bar.time, viewport.timeRange.from, viewport.timeRange.to, 0, plotW),
-      y: mapRange(bar.close, viewport.priceRange.max, viewport.priceRange.min, 0, plotH),
-    }));
-
-    // Line path
-    ctx.beginPath();
-    ctx.strokeStyle = color;
-    ctx.lineWidth = lineWidth;
-    this._applyLineStyle(ctx, options.lineStyle ?? 'solid');
-
-    const first = points[0]!;
-    ctx.moveTo(first.x, first.y);
-    for (let i = 1; i < points.length; i++) {
-      ctx.lineTo(points[i]!.x, points[i]!.y);
-    }
-    ctx.stroke();
-    ctx.setLineDash([]);
-
-    // Area fill
-    if (isArea) {
-      ctx.beginPath();
-      ctx.moveTo(first.x, plotH);
-      ctx.lineTo(first.x, first.y);
-      for (let i = 1; i < points.length; i++) {
-        ctx.lineTo(points[i]!.x, points[i]!.y);
-      }
-      const last = points[points.length - 1]!;
-      ctx.lineTo(last.x, plotH);
-      ctx.closePath();
-
-      const gradient = ctx.createLinearGradient(0, 0, 0, plotH);
-      gradient.addColorStop(0, hexToRgba(color, 0.3));
-      gradient.addColorStop(1, hexToRgba(color, 0.0));
-      ctx.fillStyle = gradient;
-      ctx.fill();
-    }
-  }
-
-  private _applyLineStyle(ctx: CanvasRenderingContext2D, style: string): void {
-    if (style === 'dashed') ctx.setLineDash([6, 3]);
-    else if (style === 'dotted') ctx.setLineDash([2, 3]);
-    else ctx.setLineDash([]);
-  }
-}

package/src/theme/colors.ts

@@ -1,21 +0,0 @@
-import type { ChartColors } from '@forgecharts/types';
-
-export const DARK_COLORS: ChartColors = {
-  background: '#000000',
-  backgroundSecondary: '#0a0a0a',
-  text: '#ffffff',
-  textMuted: '#888888',
-  grid: '#2a2a2a',
-  border: '#333333',
-  crosshair: '#ffffff',
-};
-
-export const LIGHT_COLORS: ChartColors = {
-  background: '#ffffff',
-  backgroundSecondary: '#f5f5f5',
-  text: '#000000',
-  textMuted: '#666666',
-  grid: '#e8e8e8',
-  border: '#cccccc',
-  crosshair: '#000000',
-};

package/src/tools/barDivergenceCheck.ts

@@ -1,305 +0,0 @@
-/**
- * First-Divergence Bar Comparison Tool
- *
- * Compares OHLCV bars from multiple data sources (provider REST, database,
- * aggregated from 1m, SDK engine) and reports the **first** mismatch found.
- *
- * Usage:
- *
- *   import { compareSources, checkAllSources, formatReport } from '@forgecharts/sdk/tools/barDivergenceCheck';
- *
- *   const report = compareSources(
- *     { source: 'provider',   bars: providerBars   },
- *     { source: 'database',   bars: databaseBars   },
- *     '1h',
- *     'BINANCE:BTCUSDT',
- *     from,
- *     to,
- *   );
- *
- *   if (report.diverged) console.log(formatReport(report));
- *
- * All bar arrays are expected to contain Unix **second** timestamps in the
- * `time` field (matching the CandleBar.time convention).  Use `from`/`to`
- * as Unix seconds to scope the comparison window.
- */
-
-import { getBucketStart } from '@forgecharts/shared';
-
-// ─── Public types ─────────────────────────────────────────────────────────────
-
-/** Identifies which pipeline stage produced a bar array. */
-export type BarSource = 'provider' | 'database' | 'aggregated' | 'sdk';
-
-/** Minimal OHLCV shape accepted by the divergence checker. */
-export interface OhlcvBar {
-  /** Unix seconds (same as CandleBar.time). */
-  time: number;
-  open: number;
-  high: number;
-  low: number;
-  close: number;
-  volume?: number;
-}
-
-/** A labelled set of bars from one pipeline source. */
-export interface SourceBars {
-  source: BarSource;
-  bars: readonly OhlcvBar[];
-}
-
-/** A single field-level difference between two bars at the same timestamp. */
-export interface FieldDiff {
-  field: 'open' | 'high' | 'low' | 'close' | 'volume';
-  valueA: number;
-  valueB: number;
-  /** valueA − valueB */
-  delta: number;
-}
-
-/** Full description of a single mismatched candle. */
-export interface BarMismatch {
-  /** Unix seconds — the candle open time where divergence was first detected. */
-  time: number;
-  /** Canonical candle-open boundary in milliseconds for the given timeframe. */
-  bucketStartMs: number;
-  sourceA: BarSource;
-  sourceB: BarSource;
-  /** OHLCV field deltas — empty when the only problem is a missing bar. */
-  differences: FieldDiff[];
-  /**
-   * True when the two bars carry the same `time` but their canonical
-   * `bucketStart` values differ — indicates a misaligned timestamp on one side.
-   */
-  bucketMismatch: boolean;
-  /** Human-readable diagnostic notes. */
-  notes: string[];
-}
-
-/** Summary of a pairwise source comparison. */
-export interface DivergenceReport {
-  symbol: string;
-  timeframe: string;
-  /** Unix seconds — inclusive window start. */
-  from: number;
-  /** Unix seconds — inclusive window end. */
-  to: number;
-  diverged: boolean;
-  /** The first mismatch found, or null when the sources are identical. */
-  firstMismatch: BarMismatch | null;
-  totalMismatches: number;
-  /** Number of bars from source A inside [from, to]. */
-  sourceACount: number;
-  /** Number of bars from source B inside [from, to]. */
-  sourceBCount: number;
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-/** Index bars by their Unix-second open time for O(1) lookup. */
-function indexByTime(bars: readonly OhlcvBar[]): Map<number, OhlcvBar> {
-  const map = new Map<number, OhlcvBar>();
-  for (const bar of bars) {
-    // Last-write-wins if the source has duplicate timestamps
-    map.set(bar.time, bar);
-  }
-  return map;
-}
-
-/**
- * Compare two numeric values with a floating-point epsilon tolerance.
- * Returns true when they differ by more than the tolerance.
- */
-function differ(a: number, b: number, eps = 1e-9): boolean {
-  return Math.abs(a - b) > eps;
-}
-
-// ─── Core comparison ──────────────────────────────────────────────────────────
-
-/**
- * Compare all timestamps from both sources inside [from, to] and return the
- * first mismatch found, scanning oldest-first.
- *
- * Mismatch criteria (any one triggers a report):
- *   1. Bar present in one source but absent in the other.
- *   2. OHLCV field values differ by more than floating-point epsilon.
- *   3. Canonical `getBucketStart` for the bar's time differs between sources
- *      (indicates one source has a misaligned timestamp).
- *
- * @param a          Source A bars.
- * @param b          Source B bars.
- * @param timeframe  Canonical timeframe label (e.g. `'1h'`, `'1w'`).
- * @param symbol     Symbol string — stored in the report for identification.
- * @param from       Window start, Unix seconds (inclusive).
- * @param to         Window end, Unix seconds (inclusive).
- */
-export function compareSources(
-  a: SourceBars,
-  b: SourceBars,
-  timeframe: string,
-  symbol: string,
-  from: number,
-  to: number,
-): DivergenceReport {
-  const aIndex = indexByTime(a.bars);
-  const bIndex = indexByTime(b.bars);
-
-  // All timestamps seen in either source, filtered to the requested window
-  const allTimes = new Set([...aIndex.keys(), ...bIndex.keys()]);
-  const sortedTimes = Array.from(allTimes)
-    .filter(t => t >= from && t <= to)
-    .sort((x, y) => x - y);
-
-  let totalMismatches = 0;
-  let firstMismatch: BarMismatch | null = null;
-
-  const countA = a.bars.filter(bar => bar.time >= from && bar.time <= to).length;
-  const countB = b.bars.filter(bar => bar.time >= from && bar.time <= to).length;
-
-  for (const time of sortedTimes) {
-    const barA = aIndex.get(time);
-    const barB = bIndex.get(time);
-
-    // ── Missing bar ────────────────────────────────────────────────────────
-    if (!barA || !barB) {
-      totalMismatches++;
-      if (!firstMismatch) {
-        const notes: string[] = [];
-        if (!barA) notes.push(`${a.source} is missing bar at time=${time}`);
-        if (!barB) notes.push(`${b.source} is missing bar at time=${time}`);
-        firstMismatch = {
-          time,
-          bucketStartMs: getBucketStart(time * 1000, timeframe),
-          sourceA: a.source,
-          sourceB: b.source,
-          differences: [],
-          bucketMismatch: false,
-          notes,
-        };
-      }
-      continue;
-    }
-
-    // ── OHLCV field comparison ─────────────────────────────────────────────
-    const diffs: FieldDiff[] = [];
-    const OHLCV_FIELDS: Array<'open' | 'high' | 'low' | 'close' | 'volume'> = [
-      'open', 'high', 'low', 'close', 'volume',
-    ];
-    for (const field of OHLCV_FIELDS) {
-      const vA = barA[field] ?? 0;
-      const vB = barB[field] ?? 0;
-      if (differ(vA, vB)) {
-        diffs.push({ field, valueA: vA, valueB: vB, delta: vA - vB });
-      }
-    }
-
-    // ── Bucket alignment comparison ────────────────────────────────────────
-    const bucketA = getBucketStart(barA.time * 1000, timeframe);
-    const bucketB = getBucketStart(barB.time * 1000, timeframe);
-    const bucketMismatch = bucketA !== bucketB;
-
-    const notes: string[] = [];
-    if (bucketMismatch) {
-      notes.push(
-        `bucket start mismatch: ${a.source}=${bucketA}ms vs ${b.source}=${bucketB}ms ` +
-        `(delta=${bucketA - bucketB} ms)`,
-      );
-    }
-    for (const diff of diffs) {
-      notes.push(
-        `${diff.field}: ${a.source}=${diff.valueA} vs ${b.source}=${diff.valueB} ` +
-        `(delta=${diff.delta.toPrecision(6)})`,
-      );
-    }
-
-    if (diffs.length > 0 || bucketMismatch) {
-      totalMismatches++;
-      if (!firstMismatch) {
-        firstMismatch = {
-          time,
-          bucketStartMs: bucketA,
-          sourceA: a.source,
-          sourceB: b.source,
-          differences: diffs,
-          bucketMismatch,
-          notes,
-        };
-      }
-    }
-  }
-
-  return {
-    symbol,
-    timeframe,
-    from,
-    to,
-    diverged: totalMismatches > 0,
-    firstMismatch,
-    totalMismatches,
-    sourceACount: countA,
-    sourceBCount: countB,
-  };
-}
-
-/**
- * Run all pairwise comparisons across every combination of the provided sources.
- *
- * For N sources this produces N*(N-1)/2 reports.  Use `formatReport` to render
- * each one for console output.
- */
-export function checkAllSources(
-  sources: SourceBars[],
-  symbol: string,
-  timeframe: string,
-  from: number,
-  to: number,
-): DivergenceReport[] {
-  const reports: DivergenceReport[] = [];
-  for (let i = 0; i < sources.length; i++) {
-    for (let j = i + 1; j < sources.length; j++) {
-      reports.push(compareSources(sources[i]!, sources[j]!, timeframe, symbol, from, to));
-    }
-  }
-  return reports;
-}
-
-// ─── Formatter ───────────────────────────────────────────────────────────────
-
-/**
- * Render a `DivergenceReport` as a multi-line human-readable string suitable
- * for console output or log files.
- *
- * @example
- * const report = compareSources(a, b, '1h', 'BINANCE:BTCUSDT', from, to);
- * console.log(formatReport(report));
- */
-export function formatReport(report: DivergenceReport): string {
-  const lines: string[] = [];
-
-  const status = report.diverged
-    ? `DIVERGED (${report.totalMismatches} mismatch${report.totalMismatches === 1 ? '' : 'es'})`
-    : 'IDENTICAL';
-
-  lines.push('─'.repeat(72));
-  lines.push(`Bar Divergence Report — ${status}`);
-  lines.push(`  Symbol    : ${report.symbol}`);
-  lines.push(`  Timeframe : ${report.timeframe}`);
-  lines.push(`  Window    : ${report.from} → ${report.to} (Unix seconds)`);
-  lines.push(`  Bars      : sourceA=${report.sourceACount}  sourceB=${report.sourceBCount}`);
-
-  if (report.firstMismatch) {
-    const m = report.firstMismatch;
-    lines.push('');
-    lines.push(`  First mismatch at time=${m.time} (bucketStart=${m.bucketStartMs} ms)`);
-    lines.push(`  Sources  : ${m.sourceA}  vs  ${m.sourceB}`);
-    if (m.bucketMismatch) {
-      lines.push(`  ✗ Bucket alignment differs`);
-    }
-    for (const note of m.notes) {
-      lines.push(`  · ${note}`);
-    }
-  }
-
-  lines.push('─'.repeat(72));
-  return lines.join('\n');
-}

package/src/trading/TradingOverlayStore.ts

@@ -1,161 +0,0 @@
-/**
- * TradingOverlayStore
- *
- * Shared, mode-agnostic store for trade overlay state.
- * Used by both unmanaged mode (externally supplied data) and managed mode
- * (internally generated data from the managed trading service).
- *
- * Supports:
- *   - Full replace  (setOrders / setPositions)
- *   - Incremental   (upsertOrder / upsertPosition / pushExecution)
- *   - Remove by id  (removeOrder / removePosition)
- *
- * Subscribers are notified via callbacks registered with onChange().
- * The store is intentionally free of React/DOM dependencies so it can be
- * consumed from any rendering layer (canvas, React, etc.).
- *
- * @example
- * ```ts
- * const store = new TradingOverlayStore();
- *
- * // Subscribe to changes (e.g. trigger a canvas repaint)
- * store.onChange(() => chart.markDirty());
- *
- * // Feed data
- * store.setOrders([...]);
- * store.upsertOrder({ id: 'o1', role: 'entry', side: 'buy', ... });
- * store.removeOrder('o1');
- * ```
- */
-
-import type { ChartOrder, ChartPosition, ExecutionFill } from './tradingTypes';
-
-type ChangeListener = () => void;
-
-export class TradingOverlayStore {
-  private _orders    = new Map<string, ChartOrder>();
-  private _positions = new Map<string, ChartPosition>();
-  private _fills:      ExecutionFill[] = [];
-
-  private _listeners: ChangeListener[] = [];
-
-  // ── Change subscription ──────────────────────────────────────────────────────
-
-  /**
-   * Register a callback that fires whenever any state changes.
-   * Returns an unsubscribe function.
-   */
-  onChange(listener: ChangeListener): () => void {
-    this._listeners.push(listener);
-    return () => {
-      this._listeners = this._listeners.filter(l => l !== listener);
-    };
-  }
-
-  private _notify(): void {
-    for (const l of this._listeners) l();
-  }
-
-  // ── Orders ───────────────────────────────────────────────────────────────────
-
-  /** Replace the entire order set. */
-  setOrders(orders: ChartOrder[]): void {
-    this._orders.clear();
-    for (const o of orders) this._orders.set(o.id, o);
-    this._notify();
-  }
-
-  /**
-   * Insert or replace a single order.
-   * Matching is done by `order.id`.
-   */
-  upsertOrder(order: ChartOrder): void {
-    this._orders.set(order.id, order);
-    this._notify();
-  }
-
-  /** Remove an order by id. Silent no-op if not found. */
-  removeOrder(orderId: string): void {
-    if (this._orders.delete(orderId)) this._notify();
-  }
-
-  /** Returns a snapshot of all orders as an array (insertion order). */
-  getOrders(): ChartOrder[] {
-    return Array.from(this._orders.values());
-  }
-
-  /** Returns orders that share the given `groupId`. */
-  getOrdersByGroup(groupId: string): ChartOrder[] {
-    return this.getOrders().filter(o => o.groupId === groupId);
-  }
-
-  // ── Positions ────────────────────────────────────────────────────────────────
-
-  /** Replace the entire position set. */
-  setPositions(positions: ChartPosition[]): void {
-    this._positions.clear();
-    for (const p of positions) this._positions.set(p.id, p);
-    this._notify();
-  }
-
-  /**
-   * Insert or replace a single position.
-   * Matching is done by `position.id`.
-   */
-  upsertPosition(position: ChartPosition): void {
-    this._positions.set(position.id, position);
-    this._notify();
-  }
-
-  /** Remove a position by id. Silent no-op if not found. */
-  removePosition(positionId: string): void {
-    if (this._positions.delete(positionId)) this._notify();
-  }
-
-  /** Returns a snapshot of all positions as an array (insertion order). */
-  getPositions(): ChartPosition[] {
-    return Array.from(this._positions.values());
-  }
-
-  // ── Fills ────────────────────────────────────────────────────────────────────
-
-  /**
-   * Append an execution fill to the fill log.
-   * Fills are append-only — they are never updated or removed.
-   */
-  pushExecution(fill: ExecutionFill): void {
-    this._fills.push(fill);
-    this._notify();
-  }
-
-  /** Returns all fills in insertion (chronological) order. */
-  getFills(): readonly ExecutionFill[] {
-    return this._fills;
-  }
-
-  /** Returns fills associated with a specific order id. */
-  getFillsByOrder(orderId: string): ExecutionFill[] {
-    return this._fills.filter(f => f.orderId === orderId);
-  }
-
-  // ── Bulk clear ───────────────────────────────────────────────────────────────
-
-  /** Wipes all overlay state (orders, positions, fills). */
-  clear(): void {
-    this._orders.clear();
-    this._positions.clear();
-    this._fills = [];
-    this._notify();
-  }
-
-  // ── Snapshot ─────────────────────────────────────────────────────────────────
-
-  /** Returns the full overlay state as a plain object — useful for debug / serialisation. */
-  snapshot(): { orders: ChartOrder[]; positions: ChartPosition[]; fills: readonly ExecutionFill[] } {
-    return {
-      orders:    this.getOrders(),
-      positions: this.getPositions(),
-      fills:     this.getFills(),
-    };
-  }
-}