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

package/src/data-fetchers/dataBuffer.effects.ts

@@ -1,118 +0,0 @@
-import { Context, Effect, pipe, Schedule } from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-
-import type { KLineData, SymbolSpec } from '../controllers/types'
-import { KLineChartError } from '../errors'
-import type { TimeShareData } from '../types/price'
-
-// ── KLine fetch service tag ──
-// Tag: 定义 Effect 服务接口
-
-export class KLineFetchService extends Context.Tag('@klc/KLineFetchService')<
-  KLineFetchService,
-  {
-    readonly fetch: (
-      spec: SymbolSpec,
-      startTs: number,
-      endTs: number,
-    ) => EffectType<ReadonlyArray<KLineData>, unknown>
-  }
->() {}
-
-// ── TimeShare fetch service tag ──
-
-export class TimeShareFetchService extends Context.Tag('@klc/TimeShareFetchService')<
-  TimeShareFetchService,
-  {
-    readonly fetch: (
-      spec: SymbolSpec,
-      date?: number,
-    ) => EffectType<ReadonlyArray<TimeShareData>, unknown>
-  }
->() {}
-
-// ── Constants ──
-
-export const MS_PER_DAY = 86_400_000
-const REQUEST_TIMEOUT = '15 seconds'
-const FETCH_MAX_RETRIES = 2 // 最大重试次数
-
-// ── Helpers ──
-
-const PERIOD_INITIAL_DAYS: Record<string, number> = {
-  '1min': 3,
-  '5min': 30,
-  '15min': 60,
-  '30min': 90,
-  '60min': 180,
-  daily: 365,
-  weekly: 365,
-  monthly: 365,
-  quarterly: 365,
-  yearly: 365,
-  timeshare: 1,
-}
-
-export function getPeriodDays(period?: string): number {
-  return PERIOD_INITIAL_DAYS[period ?? 'daily'] ?? 365
-}
-
-export function formatDate(ts: number): string {
-  const d = new Date(ts)
-  const y = d.getFullYear()
-  const m = String(d.getMonth() + 1).padStart(2, '0')
-  const day = String(d.getDate()).padStart(2, '0')
-  return `${y}-${m}-${day}`
-}
-
-// ── Retry schedule: exponential backoff ~1s / ~2s ──
-
-const retrySchedule = pipe(
-  Schedule.exponential('1 seconds'),
-  Schedule.compose(Schedule.recurs(FETCH_MAX_RETRIES)),
-)
-
-// ── KLine fetch Effect (retry + timeout + empty-data check) ──
-
-export const fetchKLine = (
-  spec: SymbolSpec,
-  startTs: number,
-  endTs: number,
-): EffectType<ReadonlyArray<KLineData>, unknown, KLineFetchService> =>
-  pipe(
-    Effect.gen(function* () {
-      const { fetch } = yield* KLineFetchService // 获取 Service 实例
-      const data = yield* pipe(fetch(spec, startTs, endTs), Effect.timeout(REQUEST_TIMEOUT))
-      if (data.length === 0) {
-        return yield* Effect.fail(
-          new KLineChartError(
-            'FETCH_FAILED',
-            `[DataBuffer] empty data for ${spec.symbol} ${formatDate(startTs)}~${formatDate(endTs)}`,
-          ),
-        )
-      }
-      return data
-    }),
-    Effect.retry(retrySchedule), // 上个 Error 时触发
-    Effect.tapError((err) =>
-      Effect.logError(`[DataBuffer] fetch failed: ${(err as Error).message}`),
-    ),
-  )
-
-// ── TimeShare fetch Effect (retry + timeout) ──
-
-export const fetchTimeShare = (
-  spec: SymbolSpec,
-  date?: number,
-): EffectType<ReadonlyArray<TimeShareData>, unknown, TimeShareFetchService> =>
-  pipe(
-    Effect.gen(function* () {
-      const { fetch } = yield* TimeShareFetchService // 获取服务实例
-      const data = yield* pipe(fetch(spec, date), Effect.timeout(REQUEST_TIMEOUT))
-      return data
-    }),
-    Effect.retry(retrySchedule),
-    Effect.tapError((err) =>
-      Effect.logError(`[TimeShareBuffer] fetch failed: ${(err as Error).message}`),
-    ),
-  )

package/src/data-fetchers/dataBuffer.ts

@@ -1,205 +0,0 @@
-import { Effect, pipe } from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-
-import type { DataFetcher, KLineData, SymbolSpec } from '../controllers/types'
-import { createSignal, type Signal } from '../reactivity/signal'
-
-import {
-  fetchKLine,
-  KLineFetchService,
-  getPeriodDays,
-  formatDate,
-  MS_PER_DAY,
-} from './dataBuffer.effects'
-import type { DataBufferLike, DataWindow, DataChange, KLineBuffer } from './dataBufferTypes'
-import { FetchScheduler } from './fetchScheduler'
-import { KLineDataStore } from './kLineDataStore'
-import { TimeKeyIndex } from './timeKeyIndex'
-
-export class DataBuffer implements KLineBuffer {
-  private _store = new KLineDataStore()
-  private _scheduler = new FetchScheduler()
-  private _keyIndex = new TimeKeyIndex()
-  private _fetcher: DataFetcher | null = null
-  private _requestFetch:
-    | ((spec: SymbolSpec, startTs: number, endTs: number) => Promise<ReadonlyArray<KLineData>>)
-    | null = null
-  private _currentSpec: SymbolSpec | null = null
-  private _attemptedBoundaries: Set<number> = new Set()
-  private _disposed = false
-
-  constructor() {}
-
-  get data(): Signal<DataChange> {
-    return this._store.data
-  }
-
-  get loading(): Signal<boolean> {
-    return this._scheduler.loading
-  }
-
-  get currentSpec(): SymbolSpec | null {
-    return this._currentSpec
-  }
-
-  get loadedWindow(): DataWindow | null {
-    return this._store.loadedWindow
-  }
-
-  getRawData(): KLineData[] {
-    return this._store.getRawData()
-  }
-
-  getMonthKeys(): Int32Array | null {
-    return this._keyIndex.monthKeys
-  }
-
-  getDayKeys(): Int32Array | null {
-    return this._keyIndex.dayKeys
-  }
-
-  setFetcher(fetcher: DataFetcher | null): void {
-    this._fetcher = fetcher
-  }
-
-  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._store.reset()
-    this._scheduler.reset()
-    this._keyIndex.reset()
-    this._attemptedBoundaries.clear()
-    if (initialStartTs !== undefined) {
-      this._loadInitialRange(initialStartTs, Date.now())
-    } else {
-      this._loadInitial()
-    }
-  }
-
-  ensureRange(requestStartTs: number, _requestEndTs: number): void {
-    if (this._disposed || (!this._requestFetch && !this._fetcher) || !this._currentSpec) return
-    if (this._currentSpec.incremental === false) return
-    if (!this._currentSpec.source) return
-    const window = this._store.loadedWindow
-    if (!window) return
-
-    if (requestStartTs >= window.earliestTs) return
-
-    const incrementalEnd = window.earliestTs
-    if (this._attemptedBoundaries.has(incrementalEnd)) return
-
-    this._attemptedBoundaries.add(incrementalEnd)
-    this._fetchAndMerge(requestStartTs, incrementalEnd)
-  }
-
-  setInlineData(data: unknown[]): void {
-    if (this._disposed) return
-    this._store.setInlineData(data as KLineData[])
-    this._scheduler.reset()
-    this._attemptedBoundaries.clear()
-    this._keyIndex.recompute(this._store.getRawData())
-  }
-
-  setCurrentSpec(spec: SymbolSpec): void {
-    this._currentSpec = spec
-  }
-
-  dispose(): void {
-    this._disposed = true
-    this._scheduler.dispose()
-    this._store.reset()
-    this._keyIndex.reset()
-    this._attemptedBoundaries.clear()
-  }
-
-  // ── Private ──
-
-  private _loadInitial(): void {
-    if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
-    if (!this._currentSpec.source) return
-
-    const now = Date.now()
-    const days = getPeriodDays(this._currentSpec.period)
-    const startDate = now - days * MS_PER_DAY
-
-    this._fetchAndMerge(startDate, now)
-  }
-
-  private _loadInitialRange(startTs: number, endTs: number): void {
-    if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
-    if (!this._currentSpec.source) return
-    this._fetchAndMerge(startTs, endTs)
-  }
-
-  private _fetchAndMerge(startTs: number, endTs: number): void {
-    if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
-    if (this._currentSpec.incremental === false) return
-
-    const spec = this._currentSpec
-    const requestFetch = this._requestFetch
-    const fetcher = this._fetcher
-    const disposed = (): boolean => this._disposed
-
-    const fetchEffect = (): Promise<ReadonlyArray<KLineData>> => {
-      const service: {
-        readonly fetch: (
-          s: SymbolSpec,
-          start: number,
-          end: number,
-        ) => EffectType<ReadonlyArray<KLineData>, unknown>
-      } = {
-        fetch: (s, start, end) =>
-          Effect.tryPromise({
-            try: () => {
-              if (!s.source) {
-                return Promise.reject(
-                  new Error(`[DataBuffer] source is required for symbol "${s.symbol}"`),
-                )
-              }
-              if (requestFetch) {
-                return requestFetch(s, start, end)
-              }
-              return (fetcher as NonNullable<DataFetcher>)(s.source, {
-                symbol: s.symbol,
-                startDate: formatDate(start),
-                endDate: formatDate(end),
-                period: s.period ?? 'daily',
-                adjust: s.adjust ?? 'none',
-                exchange: s.exchange,
-              })
-            },
-            catch: (e) => e,
-          }),
-      }
-
-      return pipe(
-        fetchKLine(spec, startTs, endTs),
-        Effect.provideService(KLineFetchService, service),
-        Effect.runPromise,
-      )
-    }
-
-    this._scheduler
-      .run(fetchEffect)
-      .then((incoming) => {
-        if (disposed()) return
-
-        const result = this._store.merge(incoming)
-        this._keyIndex.recompute(this._store.getRawData())
-
-        if (!result.advancedEarliest) {
-          this._attemptedBoundaries.delete(endTs)
-        }
-      })
-      .catch(() => {
-        this._attemptedBoundaries.delete(endTs)
-      })
-  }
-}

package/src/data-fetchers/dataBufferTypes.ts

@@ -1,51 +0,0 @@
-import type { KLineData, SymbolSpec, DataFetcher } from '../controllers/types'
-import type { Signal } from '../reactivity/signal'
-import type { TimeShareData } from '../types/price'
-
-import type { TimeShareFetcherFn } from './types'
-
-export interface DataWindow {
-  earliestTs: number
-  latestTs: number
-}
-
-/** 数据变更描述：在一次数据更新中携带数据本身和变更元数据 */
-export interface DataChange {
-  readonly data: ReadonlyArray<unknown>
-  /** 本次新增了多少根 K 线到头部（向左滚动加载的历史数据） */
-  readonly prependedCount: number
-}
-
-export interface DataBufferLike {
-  readonly data: Signal<DataChange>
-  readonly loading: Signal<boolean>
-  readonly loadedWindow: DataWindow | null
-  getRawData(): unknown[]
-  setInlineData(data: unknown[]): void
-  dispose(): void
-}
-
-export interface KLineBuffer extends DataBufferLike {
-  readonly currentSpec: SymbolSpec | null
-  getRawData(): KLineData[]
-  getMonthKeys(): Int32Array | null
-  getDayKeys(): Int32Array | null
-  setFetcher(fetcher: DataFetcher | null): void
-  setRequestFetch(
-    fn:
-      | ((spec: SymbolSpec, startTs: number, endTs: number) => Promise<ReadonlyArray<KLineData>>)
-      | null,
-  ): void
-  setSymbol(spec: SymbolSpec, initialStartTs?: number): void
-  setCurrentSpec(spec: SymbolSpec): void
-  ensureRange(requestStartTs: number, requestEndTs: number): void
-}
-
-export interface TimeShareBuffer extends DataBufferLike {
-  getRawData(): TimeShareData[]
-  setFetcher(fetcher: TimeShareFetcherFn | null): void
-  setQueryDate(date: number): void
-  getFetcher(): TimeShareFetcherFn | null
-  getQueryDate(): number
-  load(spec: SymbolSpec): void
-}

package/src/data-fetchers/fetchScheduler.ts

@@ -1,53 +0,0 @@
-import { createSignal, type Signal } from '../reactivity/signal'
-
-export class FetchScheduler {
-  private _chain: Promise<void> | null = null
-  private _loadingSignal: Signal<boolean>
-  private _disposed = false
-
-  constructor() {
-    this._loadingSignal = createSignal<boolean>(false)
-  }
-
-  get loading(): Signal<boolean> {
-    return this._loadingSignal
-  }
-
-  run<T>(task: () => Promise<T>): Promise<T> {
-    if (this._disposed) {
-      return Promise.reject(new Error('FetchScheduler disposed'))
-    }
-
-    const execute = async (): Promise<T> => {
-      this._loadingSignal.set(true)
-      try {
-        return await task()
-      } finally {
-        this._chain = null
-        if (!this._disposed) this._loadingSignal.set(false)
-      }
-    }
-
-    if (this._chain) {
-      return new Promise<T>((resolve, reject) => {
-        this._chain = this._chain!.then(() => {
-          execute().then(resolve, reject)
-        })
-      })
-    }
-
-    const promise = execute()
-    this._chain = promise.then(() => undefined, () => undefined)
-    return promise
-  }
-
-  reset(): void {
-    this._chain = null
-    this._loadingSignal.set(false)
-  }
-
-  dispose(): void {
-    this._disposed = true
-    this._chain = null
-  }
-}

package/src/data-fetchers/fetcherDefinitionRegistry.ts

@@ -1,80 +0,0 @@
-import { KLineChartError } from '../errors'
-
-import type {
-  DataFetcherDefinitionConfig,
-  DataFetcherDefinition,
-  DataFetcherFn,
-  TimeShareFetcherFn,
-} from './types'
-
-type DataFetcherClass = {
-  new(...args: never[]): unknown
-  fetcher: DataFetcherFn
-  timeShareFetcher?: TimeShareFetcherFn
-}
-
-const definitions = new Map<string, DataFetcherDefinition>()
-
-/**
- * 数据源注册装饰器
- * 通过类装饰器将数据源自动注册到全局 definitions Map
- * 使用 `import './xxx'` 副作用导入即可触发注册，无需显式引用类
- */
-export function DataFetcher(config: DataFetcherDefinitionConfig) {
-  return function <T extends DataFetcherClass>(value: T, context: ClassDecoratorContext<T>): T {
-    // addInitializer 在类实例化时执行回调
-    context.addInitializer(function (this: T) {
-      // 校验：注册的数据源必须暴露静态 fetcher 方法
-      if (typeof this.fetcher !== 'function') {
-        throw new KLineChartError(
-          'NOT_REGISTERED',
-          `[DataFetcher] '${config.name}' definition must expose static fetcher`,
-        )
-      }
-      // 将数据源名称 -> 配置 + fetcher 函数写入全局注册表
-      // 之后业务代码通过 routerDataFetcher(config.name) 按名称查询
-      definitions.set(config.name, {
-        ...config,
-        fetcher: this.fetcher,
-        timeShareFetcher: this.timeShareFetcher,
-      })
-    })
-    // 返回原类，不改变类本身
-    return value
-  }
-}
-
-export function getRegisteredFetcher(name: string): DataFetcherDefinition | undefined {
-  return definitions.get(name)
-}
-
-export function getRegisteredFetcherNames(): string[] {
-  return [...definitions.keys()]
-}
-
-function getRegisteredFetchers(): DataFetcherDefinition[] {
-  return [...definitions.values()]
-}
-
-function fetcherHasCapability(name: string, capability: string): boolean {
-  return definitions.get(name)?.capabilities?.includes(capability) ?? false
-}
-
-export function fetcherSupportsPeriod(name: string, period: string): boolean {
-  const def = definitions.get(name)
-  if (!def) return false
-  if (!def.capabilities || def.capabilities.length === 0) return false
-  return def.capabilities.includes('*') || def.capabilities.includes(period)
-}
-
-export function getTimeShareFetcher(name: string): TimeShareFetcherFn | undefined {
-  return definitions.get(name)?.timeShareFetcher
-}
-
-export function fetcherSupportsTimeShare(name: string): boolean {
-  return typeof definitions.get(name)?.timeShareFetcher === 'function'
-}
-
-export function clearRegisteredFetchersForTest(): void {
-  definitions.clear()
-}