@363045841yyt/klinechart-core 0.8.1-alpha.4 → 0.8.1

package/src/controllers/createChartController.ts

@@ -31,16 +31,15 @@ import type {
     DataFetcher,
 } from './types'
 import type { CustomMarkerEntity } from '../engine/marker/registry'
-import {
-    Chart,
-    type ChartOptions,
-    type ViewportState as LegacyViewportState,
-    type IndicatorInstance as LegacyIndicatorInstance,
-    type SubPaneInfo as LegacySubPaneInfo,
-    type DrawingObject as LegacyDrawingObject,
-    type DrawingToolType as LegacyDrawingToolType,
-    type InteractionSnapshot as LegacyInteractionSnapshot,
-} from '../engine/chart'
+import { Chart, type InteractionSnapshot as LegacyInteractionSnapshot } from '../engine/chart'
+import type {
+    ChartOptions,
+    ViewportState as LegacyViewportState,
+    IndicatorInstance as LegacyIndicatorInstance,
+    SubPaneInfo as LegacySubPaneInfo,
+    DrawingObject as LegacyDrawingObject,
+    DrawingToolType as LegacyDrawingToolType,
+} from '../engine/chartTypes'
 import { zoomLevelToKWidth, kGapFromKWidth } from '../engine/utils/zoom'
 
 // Plugin-backed drawings expose `kind` instead of legacy `type`.
@@ -371,6 +370,8 @@ export function createChartController(opts: ChartMountOptions): ChartController
         Readonly<Record<string, number>>
     >({})
     const interactionState: Signal<InteractionSnapshot> = createSignal(INITIAL_INTERACTION)
+    const comparisonColors: Signal<ReadonlyMap<string, string>> = createSignal<ReadonlyMap<string, string>>(new Map())
+    const comparisonLoading: Signal<boolean> = createSignal(false)
 
     // -------------------------------------------------------------------
     // Apply initial render state + seed data
@@ -477,6 +478,20 @@ export function createChartController(opts: ChartMountOptions): ChartController
         ),
     )
 
+    // comparisonColors
+    unsubs.push(
+        chart.comparisonColors.subscribe(() =>
+            comparisonColors.set(new Map(chart.comparisonColors.peek())),
+        ),
+    )
+
+    // comparisonLoading
+    unsubs.push(
+        chart.comparisonLoading.subscribe(() =>
+            comparisonLoading.set(chart.comparisonLoading.peek()),
+        ),
+    )
+
     // -------------------------------------------------------------------
     // Lifecycle guard
     // -------------------------------------------------------------------
@@ -501,6 +516,16 @@ export function createChartController(opts: ChartMountOptions): ChartController
         chart.setSymbols(next)
     }
 
+    function addComparisonSymbol(spec: SymbolSpec): void {
+        if (disposed) return
+        chart.addComparisonSymbol(spec)
+    }
+
+    function removeComparisonSymbol(symbol: string): void {
+        if (disposed) return
+        chart.removeComparisonSymbol(symbol)
+    }
+
     function setDataFetcher(fetcher: DataFetcher | null): void {
         if (disposed) return
         chart.setDataFetcher(fetcher)
@@ -783,8 +808,12 @@ export function createChartController(opts: ChartMountOptions): ChartController
         paneRatios,
         paneLayout,
         interactionState,
+        comparisonColors,
+        comparisonLoading,
         catalog: DEFAULT_INDICATOR_CATALOG,
         setSymbols,
+        addComparisonSymbol,
+        removeComparisonSymbol,
         setDataFetcher,
         setData,
         appendData,

package/src/controllers/types.ts

@@ -10,7 +10,7 @@
 
 import type { Signal } from '../reactivity'
 import type { CustomMarkerEntity, MarkerEntity } from '../engine/marker/registry'
-import type { PaneSpec } from '../engine/chart'
+import type { PaneSpec } from '../engine/chartTypes'
 
 // Controller-owned public surface. Legacy engine types may mirror these
 // shapes internally, but adapters depend only on core-defined contracts.
@@ -71,6 +71,7 @@ export interface KLineData {
     changePercent?: number
     changeAmount?: number
     turnoverRate?: number
+    date?: string
 }
 
 export type { PaneSpec }
@@ -242,12 +243,16 @@ export interface ChartController extends DrawingChartAdapter {
     readonly paneRatios: Signal<Readonly<Record<string, number>>>
     readonly paneLayout: Signal<ReadonlyArray<PaneSpec>>
     readonly interactionState: Signal<InteractionSnapshot>
+    readonly comparisonColors: Signal<ReadonlyMap<string, string>>
+    readonly comparisonLoading: Signal<boolean>
 
     // indicator catalog (static — adapters use for picker UI)
     readonly catalog: ReadonlyArray<IndicatorDefinition>
 
     // ---- Data ----
     setSymbols(next: ReadonlyArray<SymbolSpec>): void
+    addComparisonSymbol(spec: SymbolSpec): void
+    removeComparisonSymbol(symbol: string): void
     setDataFetcher(fetcher: DataFetcher | null): void
     setData(next: ReadonlyArray<KLineData>): void
     appendData(next: ReadonlyArray<KLineData>): void

package/src/data-fetchers/baostock.ts

@@ -11,13 +11,13 @@ const periodMap: Record<string, string> = { daily: 'd', weekly: 'w', monthly: 'm
     const res = await fetch(url)
     console.log(res)
     if (!res.ok) {
-      console.warn(`[baostock] fetch failed: ${res.status} ${res.statusText}`)
-      return []
+      throw new Error(`[baostock] fetch failed: ${res.status} ${res.statusText}`)
     }
     const json = await res.json()
     console.log(json)
     return (json.data ?? json).map((item: Record<string, unknown>) => ({
       timestamp: new Date(item.date as string).getTime(),
+      date: item.date as string,
       open: Number(item.open),
       high: Number(item.high),
       low: Number(item.low),
@@ -29,6 +29,6 @@ const periodMap: Record<string, string> = { daily: 'd', weekly: 'w', monthly: 'm
     })) as KLineData[]
   } catch (err) {
     console.warn('[baostock] network error:', err)
-    return []
+    throw err
   }
 }

package/src/data-fetchers/dataBuffer.ts

@@ -9,6 +9,7 @@ export interface DataWindow {
 const MS_PER_DAY = 86_400_000
 const INITIAL_LOAD_DAYS = 365
 const INCREMENTAL_LOAD_DAYS = 90
+const FETCH_MAX_RETRIES = 2
 
 function formatDate(ts: number): string {
     const d = new Date(ts)
@@ -39,6 +40,7 @@ export class DataBuffer {
     private _dataSignal: Signal<ReadonlyArray<KLineData>>
     private _loadingSignal: Signal<boolean>
     private _fetcher: DataFetcher | null = null
+    private _requestFetch: ((spec: SymbolSpec, startTs: number, endTs: number) => Promise<ReadonlyArray<KLineData>>) | null = null
     private _currentSpec: SymbolSpec | null = null
     private _loadedWindow: DataWindow | null = null
     private _pendingFetch: Promise<void> | null = null
@@ -60,6 +62,10 @@ export class DataBuffer {
         return this._loadingSignal
     }
 
+    get currentSpec(): SymbolSpec | null {
+        return this._currentSpec
+    }
+
     get loadedWindow(): DataWindow | null {
         return this._loadedWindow
     }
@@ -68,17 +74,25 @@ export class DataBuffer {
         this._fetcher = fetcher
     }
 
-    setSymbol(spec: SymbolSpec): void {
+    setRequestFetch(fn: ((spec: SymbolSpec, startTs: number, endTs: number) => Promise<ReadonlyArray<KLineData>>) | null): void {
+        this._requestFetch = fn
+    }
+
+    setSymbol(spec: SymbolSpec, initialStartTs?: number): void {
         this._currentSpec = spec
         this._data = []
         this._loadedWindow = null
         this._attemptedBoundaries.clear()
         this._dataSignal.set([])
-        this.loadInitial()
+        if (initialStartTs !== undefined) {
+            this.loadInitialRange(initialStartTs, Date.now())
+        } else {
+            this.loadInitial()
+        }
     }
 
     ensureRange(requestStartTs: number, _requestEndTs: number): void {
-        if (this._disposed || !this._fetcher || !this._currentSpec) return
+        if (this._disposed || (!this._requestFetch && !this._fetcher) || !this._currentSpec) return
         if (!this._loadedWindow) return
 
         if (requestStartTs >= this._loadedWindow.earliestTs) return
@@ -95,7 +109,7 @@ export class DataBuffer {
     }
 
     private loadInitial(): void {
-        if (!this._fetcher || !this._currentSpec || this._disposed) return
+        if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
 
         const now = Date.now()
         const startDate = now - INITIAL_LOAD_DAYS * MS_PER_DAY
@@ -104,13 +118,18 @@ export class DataBuffer {
         this.fetchRange(startDate, endDate)
     }
 
-    private fetchRange(startTs: number, endTs: number): void {
-        if (!this._fetcher || !this._currentSpec || this._disposed) return
+    private loadInitialRange(startTs: number, endTs: number): void {
+        if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
+        this.fetchRange(startTs, endTs)
+    }
+
+    private fetchRange(startTs: number, endTs: number, retryCount = 0): void {
+        if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
 
         if (this._pendingFetch) {
             this._pendingFetch = this._pendingFetch.then(() => {
                 if (this._disposed) return
-                this.fetchRange(startTs, endTs)
+                return this.fetchRange(startTs, endTs, retryCount)
             })
             return
         }
@@ -120,15 +139,18 @@ export class DataBuffer {
 
         this._loadingSignal.set(true)
 
-        this._pendingFetch = fetcher(spec.source ?? 'baostock', {
-            symbol: spec.symbol,
-            startDate: formatDate(startTs),
-            endDate: formatDate(endTs),
-            period: spec.period ?? 'daily',
-            adjust: spec.adjust ?? 'none',
-            exchange: spec.exchange,
-        })
-            .then((incoming) => {
+        const doFetch = (): Promise<void> => {
+            const fetchPromise = this._requestFetch
+                ? this._requestFetch(spec, startTs, endTs)
+                : (fetcher as NonNullable<DataFetcher>)(spec.source ?? 'baostock', {
+                    symbol: spec.symbol,
+                    startDate: formatDate(startTs),
+                    endDate: formatDate(endTs),
+                    period: spec.period ?? 'daily',
+                    adjust: spec.adjust ?? 'none',
+                    exchange: spec.exchange,
+                })
+            return fetchPromise.then((incoming) => {
                 if (this._disposed) return
 
                 const oldLength = this._data.length
@@ -161,16 +183,35 @@ export class DataBuffer {
                     }
                 }
             })
-            .catch((err) => {
+        }
+
+        const attempt = (count: number): Promise<void> => {
+            return doFetch().catch((err) => {
                 if (this._disposed) return
-                console.error('[DataBuffer] fetch failed:', err)
-            })
-            .finally(() => {
-                this._pendingFetch = null
-                if (!this._disposed) {
-                    this._loadingSignal.set(false)
+
+                if (count < FETCH_MAX_RETRIES) {
+                    const delay = Math.pow(2, count) * 1000
+                    console.warn(
+                        `[DataBuffer] fetch failed, retry ${count + 1}/${FETCH_MAX_RETRIES} in ${delay}ms:`,
+                        err,
+                    )
+                    return new Promise<void>((resolve) => setTimeout(resolve, delay)).then(() => {
+                        if (this._disposed) return
+                        return attempt(count + 1)
+                    })
                 }
+
+                console.error(`[DataBuffer] fetch failed after ${FETCH_MAX_RETRIES + 1} attempts:`, err)
+                this._attemptedBoundaries.delete(endTs)
             })
+        }
+
+        this._pendingFetch = attempt(retryCount).finally(() => {
+            this._pendingFetch = null
+            if (!this._disposed) {
+                this._loadingSignal.set(false)
+            }
+        })
     }
 
     dispose(): void {

package/src/data-fetchers/tradingview.ts

@@ -21,13 +21,11 @@ export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
   try {
     const res = await fetch(url)
     if (!res.ok) {
-      console.warn(`[tradingview] fetch failed: ${res.status} ${res.statusText}`)
-      return []
+      throw new Error(`[tradingview] fetch failed: ${res.status} ${res.statusText}`)
     }
     const json = await res.json()
     if (!json.success) {
-      console.warn(`[tradingview] API error: ${json.error_msg}`)
-      return []
+      throw new Error(`[tradingview] API error: ${json.error_msg}`)
     }
     if (json.warning) {
       console.warn(`[tradingview] ${json.warning}`)
@@ -35,6 +33,7 @@ export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
 
     return (json.data ?? []).map((item: Record<string, unknown>) => ({
       timestamp: item.ts_open as number,
+      date: item.date as string,
       open: item.open as number,
       high: item.high as number,
       low: item.low as number,
@@ -44,6 +43,6 @@ export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
     })) as KLineData[]
   } catch (err) {
     console.warn('[tradingview] network error:', err)
-    return []
+    throw err
   }
 }

package/src/engine/__tests__/subPaneManager.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { SubPaneManager, type SubPaneContext } from '../subPaneManager'
+import type { SubIndicatorType } from '../renderers/Indicator'
+import type { IndicatorScheduler } from '../indicators/scheduler'
+
+function createMockScheduler(): Partial<IndicatorScheduler> {
+  return {
+    getIndicatorMetadata: vi.fn((_id: string) => ({
+      rendererFactory: vi.fn(() => ({ name: 'custom_rsi_rsi_0' })),
+      updateConfig: vi.fn(),
+      scale: { indicatorKey: 'test', label: 'Test', decimals: 2 },
+    })),
+    onSubPaneChanged: vi.fn(),
+  }
+}
+
+function createMockContext(): SubPaneContext {
+  const scheduler = createMockScheduler()
+  return {
+    getIndicatorScheduler: vi.fn(() => scheduler as unknown as IndicatorScheduler),
+    hasPane: vi.fn(() => false),
+    upsertPane: vi.fn(),
+    getRenderer: vi.fn(),
+    useRenderer: vi.fn(),
+    removeRenderer: vi.fn(),
+    removePaneDefinition: vi.fn(),
+    updateRendererConfig: vi.fn(),
+    getRightAxisWidth: vi.fn(() => 60),
+    getPriceLabelWidth: vi.fn(() => 60),
+    getYPaddingPx: vi.fn(() => 4),
+    getCrosshairPos: vi.fn(() => null),
+    getCrosshairPrice: vi.fn(() => null),
+    getActivePaneId: vi.fn(() => null),
+  }
+}
+
+describe('SubPaneManager', () => {
+  let manager: SubPaneManager
+  let ctx: SubPaneContext
+
+  beforeEach(() => {
+    manager = new SubPaneManager()
+    ctx = createMockContext()
+    vi.clearAllMocks()
+  })
+
+  describe('updateParams', () => {
+    it('should update paneTitle renderer config with new params and indicatorId', () => {
+      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
+        period1: 6,
+        period2: 12,
+        period3: 24,
+      })
+
+      const entry = manager.getByPaneId('RSI_0')
+      expect(entry).toBeDefined()
+      vi.clearAllMocks()
+
+      const newParams = { period1: 10, period2: 20, period3: 30 }
+      manager.updateParams(ctx, 'RSI_0', newParams)
+
+      expect(ctx.updateRendererConfig).toHaveBeenCalledWith(
+        entry!.paneTitleRendererName,
+        { params: newParams, indicatorId: 'RSI' },
+      )
+    })
+
+    it('should update main indicator renderer config with new params', () => {
+      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
+        period1: 6,
+        period2: 12,
+        period3: 24,
+      })
+
+      const entry = manager.getByPaneId('RSI_0')
+      expect(entry).toBeDefined()
+      vi.clearAllMocks()
+
+      const newParams = { period1: 10, period2: 20, period3: 30 }
+      manager.updateParams(ctx, 'RSI_0', newParams)
+
+      expect(ctx.updateRendererConfig).toHaveBeenCalledWith(
+        entry!.rendererName,
+        newParams,
+      )
+    })
+
+    it('should update scheduler config via definition.updateConfig', () => {
+      const updateConfigSpy = vi.fn()
+      const customScheduler: Partial<IndicatorScheduler> = {
+        getIndicatorMetadata: vi.fn(() => ({
+          rendererFactory: vi.fn(() => ({ name: 'custom_rsi_rsi_0' })),
+          updateConfig: updateConfigSpy,
+          scale: { indicatorKey: 'test', label: 'Test', decimals: 2 },
+        })),
+        onSubPaneChanged: vi.fn(),
+      }
+      const customCtx: SubPaneContext = {
+        ...ctx,
+        getIndicatorScheduler: vi.fn(() => customScheduler as unknown as IndicatorScheduler),
+      }
+
+      manager.create(customCtx, 'RSI_0', 'RSI' as SubIndicatorType, {
+        period1: 6,
+        period2: 12,
+        period3: 24,
+      })
+
+      const newParams = { period1: 10, period2: 20, period3: 30 }
+      manager.updateParams(customCtx, 'RSI_0', newParams)
+
+      expect(updateConfigSpy).toHaveBeenCalled()
+    })
+
+    it('should update entry params in the manager', () => {
+      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
+        period1: 6,
+        period2: 12,
+        period3: 24,
+      })
+
+      const newParams = { period1: 10, period2: 20, period3: 30 }
+      manager.updateParams(ctx, 'RSI_0', newParams)
+
+      const entry = manager.getByPaneId('RSI_0')
+      expect(entry?.params).toEqual(newParams)
+    })
+
+    it('should fire entries signal on update', () => {
+      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
+        period1: 6,
+        period2: 12,
+        period3: 24,
+      })
+
+      const listener = vi.fn()
+      manager.entriesSignal.subscribe(listener)
+      vi.clearAllMocks()
+
+      const newParams = { period1: 10, period2: 20, period3: 30 }
+      manager.updateParams(ctx, 'RSI_0', newParams)
+
+      expect(listener).toHaveBeenCalledTimes(1)
+    })
+
+    it('should silently skip when paneId does not exist', () => {
+      const newParams = { period1: 10, period2: 20, period3: 30 }
+      manager.updateParams(ctx, 'NONEXISTENT', newParams)
+
+      expect(ctx.updateRendererConfig).not.toHaveBeenCalled()
+      expect(ctx.getIndicatorScheduler().onSubPaneChanged).not.toHaveBeenCalled()
+    })
+  })
+})