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

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,17 +139,26 @@ 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
 
+                if (incoming.length === 0) {
+                    throw new Error(
+                        `[DataBuffer] empty data for ${spec.symbol} ${formatDate(startTs)}~${formatDate(endTs)}`,
+                    )
+                }
+
                 const oldLength = this._data.length
                 const oldEarliestTs = oldLength > 0 ? this._data[0]!.timestamp : null
                 const merged = mergeSortedData(this._data, [...incoming])
@@ -161,16 +189,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/gotdx.ts

@@ -0,0 +1,138 @@
+import type { DataFetcher, KLineData } from '../controllers/types'
+
+const PERIOD_TO_CATEGORY: Record<string, number> = {
+  '1min': 8,
+  '5min': 0,
+  '15min': 1,
+  '30min': 2,
+  '60min': 3,
+  daily: 4,
+  weekly: 5,
+  monthly: 6,
+  quarterly: 10,
+  yearly: 11,
+}
+
+const ADJUST_MAP: Record<string, number> = {
+  none: 0,
+  qfq: 1,
+  hfq: 2,
+  splits: 0,
+}
+
+const EXCHANGE_EX_CATEGORY: Record<string, number> = {
+  US: 74,
+  HK: 71,
+  SG: 78,
+  DE: 73,
+}
+
+interface SecurityBar {
+  Last: number
+  Open: number
+  Close: number
+  High: number
+  Low: number
+  Vol: number
+  Amount: number
+  Turnover: number
+  RisePrice: number
+  RiseRate: number
+  Year: number
+  Month: number
+  Day: number
+  Hour: number
+  Minute: number
+  DateTime: string
+  UpCount: number
+  DownCount: number
+}
+
+interface ExKLineItem {
+  DateTime: string
+  Open: number
+  High: number
+  Low: number
+  Close: number
+  Amount: number
+  Vol: number
+}
+
+function mapBar(item: SecurityBar, code: string): KLineData {
+  const ts = new Date(item.DateTime).getTime()
+  return {
+    timestamp: ts,
+    date: item.DateTime.split('T')[0],
+    open: item.Open,
+    high: item.High,
+    low: item.Low,
+    close: item.Close,
+    volume: item.Vol,
+    turnover: item.Amount,
+    turnoverRate: item.Turnover,
+    changeAmount: item.RisePrice,
+    changePercent: item.RiseRate,
+    stockCode: code,
+  }
+}
+
+function mapExItem(item: ExKLineItem, code: string): KLineData {
+  const ts = new Date(item.DateTime).getTime()
+  return {
+    timestamp: ts,
+    date: item.DateTime.split('T')[0],
+    open: item.Open,
+    high: item.High,
+    low: item.Low,
+    close: item.Close,
+    volume: item.Vol,
+    turnover: item.Amount,
+    stockCode: code,
+  }
+}
+
+export const gotdxDataFetcher: DataFetcher = async (source, config) => {
+  const baseUrl = source === 'gotdx' ? 'http://127.0.0.1:8080' : ''
+
+  if (config.exchange && config.exchange in EXCHANGE_EX_CATEGORY) {
+    const category = EXCHANGE_EX_CATEGORY[config.exchange]
+    const period = PERIOD_TO_CATEGORY[config.period] ?? 4
+    const body = {
+      category,
+      code: config.symbol,
+      period,
+      start_date: config.startDate,
+      end_date: config.endDate,
+      times: 1,
+    }
+    const res = await fetch(`${baseUrl}/api/ex/kline-by-date`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+    if (!res.ok) throw new Error(`[gotdx] ex/kline-by-date failed: ${res.status} ${res.statusText}`)
+    const list: ExKLineItem[] = await res.json()
+    return list.map((item) => mapExItem(item, config.symbol))
+  }
+
+  const market = config.symbol.startsWith('6') || config.symbol.startsWith('9') ? 1 : 0
+  const category = PERIOD_TO_CATEGORY[config.period] ?? 4
+  const adjust = ADJUST_MAP[config.adjust] ?? 0
+  const body = {
+    market,
+    code: config.symbol,
+    category,
+    start_date: config.startDate,
+    end_date: config.endDate,
+    times: 1,
+    adjust,
+  }
+  const res = await fetch(`${baseUrl}/api/stock/kline-by-date`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) throw new Error(`[gotdx] stock/kline-by-date failed: ${res.status} ${res.statusText}`)
+  const list: SecurityBar[] = await res.json()
+  return list.map((item) => mapBar(item, config.symbol))
+}

package/src/data-fetchers/hundred-mock.ts

@@ -6,13 +6,43 @@ export const hundredMockDataFetcher: DataFetcher = async (_source, config) => {
   const end = new Date(config.endDate).getTime()
   const dayMs = 86400000
   const totalDays = Math.floor((end - start) / dayMs) + 1
+  if (totalDays <= 0) return []
+
+  const basePrice = 12.5
   const data: KLineData[] = []
-  let price = 10 + Math.random() * 5
+
+  if (totalDays === 1) {
+    data.push({
+      timestamp: start,
+      open: basePrice,
+      high: basePrice,
+      low: basePrice,
+      close: basePrice,
+      volume: Math.round(Math.random() * 10000000 + 1000000),
+    })
+    return data
+  }
+
+  const meanReversionStrength = 0.005
+
+  // raw random walk with mean reversion (close prices before bridge)
+  const rawWalk: number[] = [basePrice]
+  for (let i = 1; i < totalDays; i++) {
+    const prev = rawWalk[i - 1]!
+    const reversion = meanReversionStrength * (basePrice - prev)
+    const change = (Math.random() - 0.48) * prev * 0.06 + reversion
+    rawWalk.push(prev + change)
+  }
+
+  // Brownian bridge: subtract linear drift so last close = basePrice
+  const finalOffset = rawWalk[totalDays - 1]! - basePrice
   for (let i = 0; i < totalDays; i++) {
+    const bridge = finalOffset * (i / (totalDays - 1))
+    const close = Math.round((rawWalk[i]! - bridge) * 100) / 100
+
     const ts = start + i * dayMs
-    const change = (Math.random() - 0.48) * price * 0.06
-    const open = price
-    const close = Math.round((open + change) * 100) / 100
+    const open = i === 0 ? basePrice : data[i - 1]!.close
+
     const high = Math.round(Math.max(open, close) * (1 + Math.random() * 0.03) * 100) / 100
     const low = Math.round(Math.min(open, close) * (1 - Math.random() * 0.03) * 100) / 100
     const volume = Math.round(Math.random() * 10000000 + 1000000)
@@ -25,7 +55,7 @@ export const hundredMockDataFetcher: DataFetcher = async (_source, config) => {
       volume,
       turnover: Math.round((volume * (open + close)) / 2),
     })
-    price = close
   }
+
   return data
 }

package/src/data-fetchers/index.ts

@@ -2,6 +2,7 @@ export { thousandMockDataFetcher } from './thousand-mock'
 export { hundredMockDataFetcher } from './hundred-mock'
 export { baostockDataFetcher } from './baostock'
 export { tradingviewDataFetcher } from './tradingview'
+export { gotdxDataFetcher } from './gotdx'
 export { routerDataFetcher } from './router'
 export { DataBuffer } from './dataBuffer'
 export type { DataWindow } from './dataBuffer'

package/src/data-fetchers/router.ts

@@ -1,5 +1,6 @@
 import type { DataFetcher } from '../controllers/types'
 import { baostockDataFetcher } from './baostock'
+import { gotdxDataFetcher } from './gotdx'
 import { hundredMockDataFetcher } from './hundred-mock'
 import { thousandMockDataFetcher } from './thousand-mock'
 import { tradingviewDataFetcher } from './tradingview'
@@ -8,6 +9,8 @@ export const routerDataFetcher: DataFetcher = (source, config) => {
   switch (source) {
     case 'baostock':
       return baostockDataFetcher(source, config)
+    case 'gotdx':
+      return gotdxDataFetcher(source, config)
     case 'tradingview':
       return tradingviewDataFetcher(source, config)
     case 'mock-100':

package/src/data-fetchers/thousand-mock.ts

@@ -5,26 +5,42 @@ export const thousandMockDataFetcher: DataFetcher = async (_source, _config) =>
   const data: KLineData[] = []
   const startTime = new Date('2020-01-01').getTime()
   const dayMs = 24 * 60 * 60 * 1000
-  let lastClose = 3000
-  for (let i = 0; i < 10000; i++) {
+  const totalDays = 10000
+
+  const basePrice = 3000
+  const meanReversionStrength = 0.0005
+  const volatility = 0.02
+
+  // raw random walk with mean reversion (close prices before bridge)
+  const rawWalk: number[] = [basePrice]
+  for (let i = 1; i < totalDays; i++) {
+    const prev = rawWalk[i - 1]!
+    const reversion = meanReversionStrength * (basePrice - prev)
+    const change = (Math.random() - 0.5) * 2 * volatility * prev + reversion
+    rawWalk.push(prev + change)
+  }
+
+  // Brownian bridge: subtract linear drift so last close = basePrice
+  const finalOffset = rawWalk[totalDays - 1]! - basePrice
+  for (let i = 0; i < totalDays; i++) {
+    const bridge = finalOffset * (i / (totalDays - 1))
+    const close = Math.round((rawWalk[i]! - bridge) * 100) / 100
+
     const timestamp = startTime + i * dayMs
-    const volatility = 0.02
-    const trend = 0.0001
-    const change = (Math.random() - 0.5) * 2 * volatility + trend
-    const open = lastClose
-    const close = open * (1 + change)
-    const high = Math.max(open, close) * (1 + Math.random() * 0.01)
-    const low = Math.min(open, close) * (1 - Math.random() * 0.01)
+    const open = i === 0 ? basePrice : data[i - 1]!.close
+
+    const high = Math.round(Math.max(open, close) * (1 + Math.random() * 0.01) * 100) / 100
+    const low = Math.round(Math.min(open, close) * (1 - Math.random() * 0.01) * 100) / 100
     const volume = Math.floor(1000000 + Math.random() * 5000000)
     data.push({
       timestamp,
-      open: parseFloat(open.toFixed(2)),
-      high: parseFloat(high.toFixed(2)),
-      low: parseFloat(low.toFixed(2)),
-      close: parseFloat(close.toFixed(2)),
+      open,
+      high,
+      low,
+      close,
       volume,
     })
-    lastClose = close
   }
+
   return data
 }

package/src/data-fetchers/tradingview.ts

@@ -16,18 +16,23 @@ export const tradingviewDataFetcher: DataFetcher = async (source, config) => {
   const startDate = config.startDate.split('T')[0]
   const endDate = config.endDate.split('T')[0]
 
+  const ADJUST_TO_TV: Record<string, string | undefined> = {
+    qfq: 'dividends',
+    splits: 'splits',
+    none: 'none',
+  }
+  const tvAdjust = ADJUST_TO_TV[config.adjust]
   const exchangeQ = config.exchange ? `&exchange=${config.exchange}` : ''
-  const url = `${baseUrl}/api/tradingview/kdata?symbol=${config.symbol}&timeframe=${timeframe}&start_date=${startDate}&end_date=${endDate}${exchangeQ}`
+  const adjustQ = tvAdjust ? `&adjust=${tvAdjust}` : ''
+  const url = `${baseUrl}/api/tradingview/kdata?symbol=${config.symbol}&timeframe=${timeframe}&start_date=${startDate}&end_date=${endDate}${exchangeQ}${adjustQ}`
   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 +40,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 +50,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()
+    })
+  })
+})