@363045841yyt/klinechart-core 0.8.14 → 0.9.0-alpha.0

package/src/data-fetchers/gotdx.ts

@@ -1,224 +0,0 @@
-import type { KLineData, TimeShareData } from '../controllers/types'
-import { KLineChartError } from '../errors'
-
-import { DataFetcher } from './fetcherDefinitionRegistry'
-import type { FetchConfig, TimeShareFetchConfig } from './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,
-}
-
-const BASE_URL = 'http://127.0.0.1:8080'
-
-function getShanghaiDateYYYYMMDD(): number {
-  const formatter = new Intl.DateTimeFormat('zh-CN', {
-    timeZone: 'Asia/Shanghai',
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-  })
-  const parts = formatter.formatToParts(new Date())
-  let y = '',
-    m = '',
-    d = ''
-  for (const p of parts) {
-    if (p.type === 'year') y = p.value
-    else if (p.type === 'month') m = p.value
-    else if (p.type === 'day') d = p.value
-  }
-  return +y * 10000 + +m * 100 + +d
-}
-
-async function fetchGotdxHistoryTick(
-  _source: string,
-  config: TimeShareFetchConfig,
-): Promise<ReadonlyArray<TimeShareData>> {
-  const body = {
-    date: config.date ?? getShanghaiDateYYYYMMDD(),
-    market: config.symbol.startsWith('6') || config.symbol.startsWith('9') ? 1 : 0,
-    code: config.symbol,
-  }
-  const res = await fetch(`${BASE_URL}/api/stock/history-tick`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-  if (!res.ok)
-    throw new KLineChartError(
-      'FETCH_FAILED',
-      `[gotdx] history-tick failed: ${res.status} ${res.statusText}`,
-    )
-  const list: Array<{ timestamp: string; Price: number; Avg: number; Vol: number }> =
-    await res.json()
-  return list.map((item) => ({
-    timestamp: new Date(item.timestamp).getTime(),
-    price: item.Price,
-    average: item.Avg,
-    volume: item.Vol,
-    amount: item.Price * item.Vol,
-  }))
-}
-
-interface SecurityBar {
-  Last: number
-  Open: number
-  Close: number
-  High: number
-  Low: number
-  Vol: number
-  Amount: number
-  Turnover: number
-  RisePrice: number
-  RiseRate: number
-  Amplitude: 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,
-    amplitude: item.Amplitude,
-    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,
-  }
-}
-
-async function fetchGotdx(_source: string, config: FetchConfig): Promise<ReadonlyArray<KLineData>> {
-  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(`${BASE_URL}/api/ex/kline-by-date`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    })
-    if (!res.ok)
-      throw new KLineChartError(
-        'FETCH_FAILED',
-        `[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(`${BASE_URL}/api/stock/kline-by-date`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-  if (!res.ok)
-    throw new KLineChartError(
-      'FETCH_FAILED',
-      `[gotdx] stock/kline-by-date failed: ${res.status} ${res.statusText}`,
-    )
-  const list: SecurityBar[] = await res.json()
-  return list.map((item) => mapBar(item, config.symbol))
-}
-
-@DataFetcher({
-  name: 'gotdx',
-  displayName: 'GOTDX',
-  description: 'TDX data source via local proxy',
-  version: '1.0.0',
-  capabilities: [
-    '1min',
-    '5min',
-    '15min',
-    '30min',
-    '60min',
-    'daily',
-    'weekly',
-    'monthly',
-    'quarterly',
-    'yearly',
-  ],
-})
-class GotdxFetcher {
-  static fetcher = fetchGotdx
-  static timeShareFetcher = fetchGotdxHistoryTick
-}

package/src/data-fetchers/kLineDataStore.ts

@@ -1,96 +0,0 @@
-import type { KLineData } from '../controllers/types'
-import { createSignal, type Signal } from '../reactivity/signal'
-
-import type { DataWindow, DataChange } from './dataBufferTypes'
-
-export interface MergeResult {
-  readonly prependedCount: number
-  readonly advancedEarliest: boolean
-}
-
-function mergeSortedData(existing: KLineData[], incoming: KLineData[]): KLineData[] {
-  if (existing.length === 0) return [...incoming]
-  if (incoming.length === 0) return [...existing]
-
-  const tsSet = new Set<number>(existing.map((d) => d.timestamp))
-  const unique = incoming.filter((d) => !tsSet.has(d.timestamp))
-  if (unique.length === 0) return existing
-
-  const merged = [...existing, ...unique]
-  merged.sort((a, b) => a.timestamp - b.timestamp)
-  return merged
-}
-
-export class KLineDataStore {
-  private _data: KLineData[] = []
-  private _dataSignal: Signal<DataChange>
-  private _loadedWindow: DataWindow | null = null
-
-  constructor() {
-    this._dataSignal = createSignal<DataChange>({ data: [], prependedCount: 0 })
-  }
-
-  get data(): Signal<DataChange> {
-    return this._dataSignal
-  }
-
-  get loadedWindow(): DataWindow | null {
-    return this._loadedWindow
-  }
-
-  getRawData(): KLineData[] {
-    return this._data
-  }
-
-  merge(incoming: ReadonlyArray<KLineData>): MergeResult {
-    if (incoming.length === 0) return { prependedCount: 0, advancedEarliest: false }
-
-    const oldLength = this._data.length
-    const oldEarliestTs = oldLength > 0 ? this._data[0]!.timestamp : null
-    const merged = mergeSortedData(this._data, [...incoming])
-    const newEarliestTs = merged[0]?.timestamp ?? null
-    const advancedEarliest =
-      oldEarliestTs !== null && newEarliestTs !== null && newEarliestTs < oldEarliestTs
-
-    let prependedCount = 0
-    if (oldLength > 0 && merged.length > oldLength && advancedEarliest) {
-      prependedCount = merged.findIndex((d) => d.timestamp === oldEarliestTs)
-    }
-
-    this._data = merged
-    this._updateWindow()
-    this._dataSignal.set({ data: [...merged], prependedCount })
-
-    return { prependedCount, advancedEarliest }
-  }
-
-  setInlineData(data: KLineData[]): void {
-    this._data = [...data]
-    this._dataSignal.set({ data: [...data], prependedCount: 0 })
-    this._loadedWindow =
-      data.length > 0
-        ? { earliestTs: data[0]!.timestamp, latestTs: data[data.length - 1]!.timestamp }
-        : null
-  }
-
-  reset(): void {
-    this._data = []
-    this._loadedWindow = null
-    this._dataSignal.set({ data: [], prependedCount: 0 })
-  }
-
-  private _updateWindow(): void {
-    if (this._data.length > 0) {
-      const earliest = this._data[0]!.timestamp
-      const latest = this._data[this._data.length - 1]!.timestamp
-      if (!this._loadedWindow) {
-        this._loadedWindow = { earliestTs: earliest, latestTs: latest }
-      } else {
-        this._loadedWindow = {
-          earliestTs: Math.min(this._loadedWindow.earliestTs, earliest),
-          latestTs: Math.max(this._loadedWindow.latestTs, latest),
-        }
-      }
-    }
-  }
-}

package/src/data-fetchers/timeShareBuffer.ts

@@ -1,137 +0,0 @@
-import { Effect, Fiber, pipe } from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-
-import type { SymbolSpec } from '../controllers/types'
-import { createSignal, type Signal } from '../reactivity/signal'
-import type { TimeShareData } from '../types/price'
-
-import { fetchTimeShare, TimeShareFetchService } from './dataBuffer.effects'
-import type { DataBufferLike, DataWindow, DataChange } from './dataBufferTypes'
-import { routerTimeShareFetcher } from './router'
-import type { TimeShareFetcherFn } from './types'
-
-
-
-export class TimeShareBuffer implements DataBufferLike {
-  // 当前持有的分时数据数组（内部可变副本）
-  private _data: TimeShareData[] = []
-  // 向外部广播只读数据快照的信号
-  private _dataSignal = createSignal<DataChange>({ data: [], prependedCount: 0 })
-  // 是否正在加载中，外部 UI 绑定用
-  private _loadingSignal = createSignal<boolean>(false)
-  // 可选的自定义 fetcher，优先级大于默认 fectcher
-  private _fetcher: TimeShareFetcherFn | null = null
-  // 指定查询的历史日期（0 = 当天）
-  private _queryDate = 0
-  // 请求序号，每次 load() 递增
-  private _requestSeq = 0
-  // 当前运行的 fetch Fiber 句柄，用于随时中断旧请求
-  private _fetchFiber: Fiber.RuntimeFiber<readonly TimeShareData[], unknown> | null = null
-  // 实例是否已销毁，阻止后续任何操作
-  private _disposed = false
-
-  get data(): Signal<DataChange> {
-    return this._dataSignal
-  }
-
-  get loading(): Signal<boolean> {
-    return this._loadingSignal
-  }
-
-  get loadedWindow(): DataWindow | null {
-    if (this._data.length === 0) return null
-    return {
-      earliestTs: this._data[0]!.timestamp,
-      latestTs: this._data[this._data.length - 1]!.timestamp,
-    }
-  }
-
-  getRawData(): TimeShareData[] {
-    return this._data
-  }
-
-  setFetcher(fetcher: TimeShareFetcherFn | null): void {
-    this._fetcher = fetcher
-  }
-
-  setQueryDate(date: number): void {
-    this._queryDate = date
-  }
-
-  getFetcher(): TimeShareFetcherFn | null {
-    return this._fetcher
-  }
-
-  getQueryDate(): number {
-    return this._queryDate
-  }
-
-  load(spec: SymbolSpec): void {
-    if (this._disposed) return
-
-    if (this._fetchFiber) {
-      Fiber.interrupt(this._fetchFiber)
-      this._fetchFiber = null
-    }
-
-    const requestSeq = ++this._requestSeq
-    this._loadingSignal.set(true)
-
-    const timeShareService: {
-      readonly fetch: (
-        s: SymbolSpec,
-        date?: number,
-      ) => EffectType<ReadonlyArray<TimeShareData>, unknown>
-    } = {
-      fetch: (s, date) =>
-        Effect.tryPromise(() => {
-          const fetcher = this._fetcher ?? routerTimeShareFetcher
-          return fetcher(s.source ?? 'gotdx', {
-            symbol: s.symbol,
-            exchange: s.exchange,
-            date,
-          })
-        }),
-    }
-
-    const effect = pipe(
-      fetchTimeShare(spec, this._queryDate || undefined),
-      Effect.provideService(TimeShareFetchService, timeShareService),
-      Effect.tap((data) =>
-        Effect.sync(() => {
-          if (this._disposed) return
-          this._queryDate = 0
-          this._data = [...data]
-          this._dataSignal.set({ data: [...data], prependedCount: 0 })
-        }),
-      ),
-      Effect.ensuring(
-        Effect.sync(() => {
-          if (requestSeq === this._requestSeq) {
-            this._loadingSignal.set(false)
-          }
-        }),
-      ),
-    )
-
-    this._fetchFiber = Effect.runFork(effect)
-  }
-
-  setInlineData(data: unknown[]): void {
-    if (this._disposed) return
-    this._data = data as TimeShareData[]
-    this._dataSignal.set({ data: [...(data as TimeShareData[])], prependedCount: 0 })
-  }
-
-  // 销毁实例
-  dispose(): void {
-    this._disposed = true
-    this._requestSeq++
-    if (this._fetchFiber) {
-      Fiber.interrupt(this._fetchFiber)
-      this._fetchFiber = null
-    }
-    this._data = []
-    this._loadingSignal.set(false)
-  }
-}

package/src/data-fetchers/tradingview.ts

@@ -1,79 +0,0 @@
-import type { KLineData } from '../controllers/types'
-import { KLineChartError } from '../errors'
-
-import { DataFetcher } from './fetcherDefinitionRegistry'
-import type { FetchConfig } from './types'
-
-const PERIOD_TO_TIMEFRAME: Record<string, string> = {
-  daily: '1d',
-  weekly: '1w',
-  monthly: '1M',
-  '5min': '5m',
-  '15min': '15m',
-  '30min': '30m',
-  '60min': '60m',
-}
-
-const ADJUST_TO_TV: Record<string, string | undefined> = {
-  qfq: 'dividends',
-  splits: 'splits',
-  none: 'none',
-}
-
-const BASE_URL = 'http://localhost:8000'
-
-async function fetchTradingview(
-  _source: string,
-  config: FetchConfig,
-): Promise<ReadonlyArray<KLineData>> {
-  const timeframe = PERIOD_TO_TIMEFRAME[config.period] ?? '1d'
-  const startDate = config.startDate.split('T')[0]
-  const endDate = config.endDate.split('T')[0]
-  const tvAdjust = ADJUST_TO_TV[config.adjust]
-  const exchangeQ = config.exchange ? `&exchange=${config.exchange}` : ''
-  const adjustQ = tvAdjust ? `&adjust=${tvAdjust}` : ''
-  const url = `${BASE_URL}/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) {
-      throw new KLineChartError(
-        'FETCH_FAILED',
-        `[tradingview] fetch failed: ${res.status} ${res.statusText}`,
-      )
-    }
-    const json = await res.json()
-    if (!json.success) {
-      throw new KLineChartError('FETCH_FAILED', `[tradingview] API error: ${json.error_msg}`)
-    }
-    if (json.warning) {
-      console.warn(`[tradingview] ${json.warning}`)
-    }
-    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,
-      close: item.close as number,
-      volume: (item.volume as number) ?? 0,
-      stockCode: config.symbol,
-    })) as KLineData[]
-  } catch (err) {
-    console.warn('[tradingview] network error:', err)
-    throw err
-  }
-}
-
-@DataFetcher({
-  name: 'tradingview',
-  displayName: 'TradingView',
-  description: 'TradingView-style data source via local proxy',
-  version: '1.0.0',
-  capabilities: ['daily', 'weekly', 'monthly', '5min', '15min', '30min', '60min'],
-})
-class TradingviewFetcher {
-  static fetcher = fetchTradingview
-}
-
-/** @deprecated Use `TradingviewFetcher.fetcher` directly or rely on routerDataFetcher. */
-const tradingviewDataFetcher = fetchTradingview

package/src/engine/indicators/calculators.ts

@@ -1 +0,0 @@
-export * from './calculators/index'

package/src/indicators/alma.ts

@@ -1,64 +0,0 @@
-import { KLineChartError } from '../errors'
-/**
- * ALMA — Arnaud Legoux Moving Average.
- *
- * Public reference: Legoux & Beneduce, "ALMA Indicator Description" (2009).
- *
- * Weighted MA where weights are a Gaussian centred at `offset * (period-1)`
- * (default 0.85 = near the right edge), spread parameter `sigma` (default 6).
- *
- *   m       = offset * (period - 1)
- *   s       = period / sigma
- *   w[k]    = exp(-(k - m)^2 / (2 * s^2))   for k in 0..period-1
- *   alma[i] = sum(w[k] * price[i - k]) / sum(w[k])
- *
- * `offset` near 1 follows price tightly (short lag); near 0 smooths heavily.
- * `sigma` controls the bell width — lower = sharper centre.
- *
- * Output length === input length. Indices < period - 1 are NaN.
- */
-
-export interface AlmaOptions {
-  period: number
-  /** Default 0.85 — fractional position of the Gaussian centre, in [0, 1]. */
-  offset?: number
-  /** Default 6 — bell width parameter. Must be > 0. */
-  sigma?: number
-}
-
-export function computeALMA(prices: ReadonlyArray<number>, opts: AlmaOptions): Float64Array {
-  const { period } = opts
-  const offset = opts.offset ?? 0.85
-  const sigma = opts.sigma ?? 6
-  if (period < 1 || !Number.isFinite(period))
-    throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeALMA: period must be >= 1')
-  if (sigma <= 0 || !Number.isFinite(sigma))
-    throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeALMA: sigma must be > 0')
-  if (offset < 0 || offset > 1)
-    throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeALMA: offset must be in [0, 1]')
-
-  const out = new Float64Array(prices.length)
-  const m = offset * (period - 1)
-  const s = period / sigma
-  const denom = 2 * s * s
-  const weights = new Float64Array(period)
-  let wsum = 0
-  for (let k = 0; k < period; k++) {
-    const w = Math.exp(-((k - m) * (k - m)) / denom)
-    weights[k] = w
-    wsum += w
-  }
-
-  for (let i = 0; i < prices.length; i++) {
-    if (i < period - 1) {
-      out[i] = Number.NaN
-      continue
-    }
-    let acc = 0
-    for (let k = 0; k < period; k++) {
-      acc += (weights[k] as number) * (prices[i - k] as number)
-    }
-    out[i] = acc / wsum
-  }
-  return out
-}

package/src/indicators/awesomeOscillator.ts

@@ -1,57 +0,0 @@
-import { KLineChartError } from '../errors'
-/**
- * Awesome Oscillator — Bill Williams.
- *
- *   median[i] = (high[i] + low[i]) / 2
- *   AO[i]     = SMA(median, fast) - SMA(median, slow)
- *
- * Defaults: fast=5, slow=34.
- *
- * Output: `Float64Array` of length === input. NaN leading.
- */
-
-export interface AwesomeOscillatorOptions {
-  fast?: number
-  slow?: number
-}
-
-export function computeAwesomeOscillator(
-  bars: ReadonlyArray<{ high: number; low: number }>,
-  opts: AwesomeOscillatorOptions = {},
-): Float64Array {
-  const fast = opts.fast ?? 5
-  const slow = opts.slow ?? 34
-  if (fast < 1 || slow < 1 || fast >= slow) {
-    throw new KLineChartError(
-      'INDICATOR_INVALID_PARAM',
-      'computeAwesomeOscillator: require 1 <= fast < slow',
-    )
-  }
-  const n = bars.length
-  const med = new Float64Array(n)
-  for (let i = 0; i < n; i++) {
-    const b = bars[i] as { high: number; low: number }
-    med[i] = (b.high + b.low) / 2
-  }
-  const sf = simpleSMA(med, fast)
-  const ss = simpleSMA(med, slow)
-  const out = new Float64Array(n)
-  for (let i = 0; i < n; i++) {
-    const a = sf[i] as number
-    const b = ss[i] as number
-    out[i] = Number.isNaN(a) || Number.isNaN(b) ? Number.NaN : a - b
-  }
-  return out
-}
-
-function simpleSMA(input: Float64Array, period: number): Float64Array {
-  const n = input.length
-  const out = new Float64Array(n)
-  let acc = 0
-  for (let i = 0; i < n; i++) {
-    acc += input[i] as number
-    if (i >= period) acc -= input[i - period] as number
-    out[i] = i < period - 1 ? Number.NaN : acc / period
-  }
-  return out
-}

package/src/indicators/dpo.ts

@@ -1,38 +0,0 @@
-import { KLineChartError } from '../errors'
-/**
- * DPO — Detrended Price Oscillator.
- *
- *   shift = floor(period / 2) + 1
- *   sma   = SMA(close, period)
- *   DPO[i] = close[i - shift] - sma[i]
- *
- * The shift makes DPO a centred oscillator: the trend (SMA) is removed
- * at a centred lag so the result is a cleaner cycle indicator.
- *
- * Output: `Float64Array` length === input. NaN until index >= period + shift.
- */
-
-export interface DpoOptions {
-  period: number
-}
-
-export function computeDPO(prices: ReadonlyArray<number>, opts: DpoOptions): Float64Array {
-  const { period } = opts
-  if (period < 2 || !Number.isFinite(period))
-    throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeDPO: period must be >= 2')
-  const n = prices.length
-  const out = new Float64Array(n)
-  out.fill(Number.NaN)
-  const shift = Math.floor(period / 2) + 1
-
-  let acc = 0
-  for (let i = 0; i < n; i++) {
-    acc += prices[i] as number
-    if (i >= period) acc -= prices[i - period] as number
-    if (i < period - 1) continue
-    const sma = acc / period
-    const back = i - shift
-    if (back >= 0) out[i] = (prices[back] as number) - sma
-  }
-  return out
-}