@363045841yyt/klinechart-core 0.8.10-alpha.2 → 0.8.10

package/src/data-fetchers/dataBuffer.ts

@@ -1,41 +1,15 @@
 import { createSignal, type Signal } from '../reactivity/signal'
 import type { DataFetcher, KLineData, SymbolSpec } from '../controllers/types'
 import type { DataBufferLike } from './dataBufferTypes'
+import { Effect, pipe } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
+import { fetchKLine, KLineFetchService, getPeriodDays, formatDate, MS_PER_DAY } from './dataBuffer.effects'
 
 export interface DataWindow {
     earliestTs: number
     latestTs: number
 }
 
-const MS_PER_DAY = 86_400_000
-const FETCH_MAX_RETRIES = 2
-
-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
-}
-
-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}`
-}
-
 function mergeSortedData(
     existing: KLineData[],
     incoming: KLineData[],
@@ -62,6 +36,7 @@ export class DataBuffer implements DataBufferLike {
     private _loadedWindow: DataWindow | null = null
     private _pendingFetch: Promise<void> | null = null
     private _disposed = false
+    // 已尝试请求过的边界时间戳集合，防止同一个时间段重复请求
     private _attemptedBoundaries: Set<number> = new Set()
     private _monthKeys: Int32Array | null = null
     private _dayKeys: Int32Array | null = null
@@ -157,57 +132,61 @@ export class DataBuffer implements DataBufferLike {
         this.fetchRange(requestStartTs, incrementalEnd)
     }
 
-	private loadInitial(): void {
-		if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
+    private loadInitial(): void {
+        if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
 
-		const now = Date.now()
-		const days = getPeriodDays(this._currentSpec.period)
-		const startDate = now - days * MS_PER_DAY
-		const endDate = now
+        const now = Date.now()
+        const days = getPeriodDays(this._currentSpec.period)
+        const startDate = now - days * MS_PER_DAY
+        const endDate = now
 
-		this.fetchRange(startDate, endDate)
-	}
+        this.fetchRange(startDate, endDate)
+    }
 
     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 {
+    private fetchRange(startTs: number, endTs: number): void {
         if ((!this._requestFetch && !this._fetcher) || !this._currentSpec || this._disposed) return
 
         if (this._pendingFetch) {
             this._pendingFetch = this._pendingFetch.then(() => {
                 if (this._disposed) return
-                return this.fetchRange(startTs, endTs, retryCount)
+                return this.fetchRange(startTs, endTs)
             })
             return
         }
 
         const spec = this._currentSpec
-        const fetcher = this._fetcher
-
         this._loadingSignal.set(true)
 
-        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 service: { readonly fetch: (spec: SymbolSpec, startTs: number, endTs: number) => EffectType<ReadonlyArray<KLineData>, unknown> } = {
+            fetch: (s, start, end) =>
+                Effect.tryPromise(() => {
+                    if (this._requestFetch) {
+                        return this._requestFetch(s, start, end)
+                    }
+                    // 未定义 Fetcher 走 gotdx fallback 获取
+                    return (this._fetcher as NonNullable<DataFetcher>)(s.source ?? 'gotdx', {
+                        symbol: s.symbol,
+                        startDate: formatDate(start),
+                        endDate: formatDate(end),
+                        period: s.period ?? 'daily',
+                        adjust: s.adjust ?? 'none',
+                        exchange: s.exchange,
+                    })
+                }),
+        }
 
-                if (incoming.length === 0) {
-                    throw new Error(
-                        `[DataBuffer] empty data for ${spec.symbol} ${formatDate(startTs)}~${formatDate(endTs)}`,
-                    )
-                }
+        this._pendingFetch = pipe(
+            fetchKLine(spec, startTs, endTs),
+            Effect.provideService(KLineFetchService, service),
+            Effect.runPromise, // 链式传递返回值, Effect -> Promise -> run
+        )
+            .then((incoming) => {
+                if (this._disposed) return
 
                 const oldLength = this._data.length
                 const oldEarliestTs = oldLength > 0 ? this._data[0]!.timestamp : null
@@ -245,35 +224,15 @@ export class DataBuffer implements DataBufferLike {
                     }
                 }
             })
-        }
-
-        const attempt = (count: number): Promise<void> => {
-            return doFetch().catch((err) => {
-                if (this._disposed) return
-
-                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)
+            .catch(() => {
                 this._attemptedBoundaries.delete(endTs)
             })
-        }
-
-        this._pendingFetch = attempt(retryCount).finally(() => {
-            this._pendingFetch = null
-            if (!this._disposed) {
-                this._loadingSignal.set(false)
-            }
-        })
+            .finally(() => {
+                this._pendingFetch = null
+                if (!this._disposed) {
+                    this._loadingSignal.set(false)
+                }
+            })
     }
 
     /**

package/src/data-fetchers/index.ts

@@ -8,5 +8,12 @@ export { TimeShareBuffer } from './timeShareBuffer'
 export type { DataBufferLike } from './dataBufferTypes'
 export { getRegisteredFetcher, getTimeShareFetcher, fetcherSupportsTimeShare } from './fetcherDefinitionRegistry'
 export type { TimeShareFetcherFn, TimeShareFetchConfig } from './types'
+export {
+  getPeriodDays,
+  fetchKLine,
+  fetchTimeShare,
+  KLineFetchService,
+  TimeShareFetchService,
+} from './dataBuffer.effects'
 import './gotdx'
 import './tradingview'

package/src/data-fetchers/timeShareBuffer.ts

@@ -5,14 +5,26 @@ import type { TimeShareFetcherFn } from './types'
 import type { DataBufferLike } from './dataBufferTypes'
 import type { DataWindow } from './dataBuffer'
 import { routerTimeShareFetcher } from './router'
+import { Effect, Fiber, pipe } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
+import { fetchTimeShare, TimeShareFetchService } from './dataBuffer.effects'
 
 export class TimeShareBuffer implements DataBufferLike {
+  // 当前持有的分时数据数组（内部可变副本）
   private _data: TimeShareData[] = []
+  // 向外部广播只读数据快照的信号
   private _dataSignal = createSignal<ReadonlyArray<TimeShareData>>([])
+  // 是否正在加载中，外部 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<ReadonlyArray<unknown>> {
@@ -51,30 +63,52 @@ export class TimeShareBuffer implements DataBufferLike {
     return this._queryDate
   }
 
-  async load(spec: SymbolSpec): Promise<void> {
+  load(spec: SymbolSpec): void {
     if (this._disposed) return
-    const fetcher = this._fetcher ?? routerTimeShareFetcher
+
+    if (this._fetchFiber) {
+      Fiber.interrupt(this._fetchFiber)
+      this._fetchFiber = null
+    }
+
     const requestSeq = ++this._requestSeq
     this._loadingSignal.set(true)
 
-    try {
-      const data = await fetcher(spec.source ?? 'gotdx', {
-        symbol: spec.symbol,
-        exchange: spec.exchange,
-        date: this._queryDate || undefined,
-      })
-      this._queryDate = 0
-
-      if (requestSeq !== this._requestSeq) return
-      if (this._disposed) return
-
-      this._data = [...data]
-      this._dataSignal.set([...data])
-    } finally {
-      if (requestSeq === this._requestSeq) {
-        this._loadingSignal.set(false)
-      }
+    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])
+        }),
+      ),
+      Effect.ensuring(
+        Effect.sync(() => {
+          if (requestSeq === this._requestSeq) {
+            this._loadingSignal.set(false)
+          }
+        }),
+      ),
+    )
+
+    this._fetchFiber = Effect.runFork(effect)
   }
 
   setInlineData(data: unknown[]): void {
@@ -83,9 +117,14 @@ export class TimeShareBuffer implements DataBufferLike {
     this._dataSignal.set([...(data as TimeShareData[])])
   }
 
+  // 销毁实例
   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/engine/__tests__/paneRenderer.resize.test.ts

@@ -16,6 +16,7 @@ describe('PaneRenderer resize DPR mapping', () => {
       pane,
       {
         rightAxisWidth: 80,
+        leftAxisWidth: 60,
         yPaddingPx: 0,
         priceLabelWidth: 60,
       },
@@ -44,6 +45,7 @@ describe('PaneRenderer resize DPR mapping', () => {
       pane,
       {
         rightAxisWidth: 100,
+        leftAxisWidth: 60,
         yPaddingPx: 0,
         priceLabelWidth: 70,
       },
@@ -77,6 +79,7 @@ describe('PaneRenderer resize DPR mapping', () => {
       pane,
       {
         rightAxisWidth: 100,
+        leftAxisWidth: 60,
         yPaddingPx: 0,
         priceLabelWidth: 70,
       },

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

@@ -6,7 +6,12 @@ import type { IndicatorScheduler } from '../indicators/scheduler'
 function createMockScheduler(): Partial<IndicatorScheduler> {
   return {
     getIndicatorMetadata: vi.fn((_id: string) => ({
-      rendererFactory: vi.fn(() => ({ name: 'custom_rsi_rsi_0' })),
+      name: _id,
+      displayName: 'Test',
+      category: 'sub' as const,
+      stateKey: _id,
+      defaultPaneId: 'sub',
+      rendererFactory: vi.fn(() => ({ name: 'custom_rsi_rsi_0', paneId: 'sub', priority: 0, draw: vi.fn() })),
       updateConfig: vi.fn(),
       scale: { indicatorKey: 'test', label: 'Test', decimals: 2 },
     })),
@@ -88,8 +93,13 @@ describe('SubPaneManager', () => {
     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' })),
+        getIndicatorMetadata: vi.fn((_id: string) => ({
+          name: _id,
+          displayName: 'Test',
+          category: 'sub' as const,
+          stateKey: _id,
+          defaultPaneId: 'sub',
+          rendererFactory: vi.fn(() => ({ name: 'custom_rsi_rsi_0', paneId: 'sub', priority: 0, draw: vi.fn() })),
           updateConfig: updateConfigSpy,
           scale: { indicatorKey: 'test', label: 'Test', decimals: 2 },
         })),

package/src/engine/data/chartDataManager.ts

@@ -1,7 +1,8 @@
 import type { KLineData, TimeShareData } from '../../types/price'
 import type { SymbolSpec, DataFetcher, CustomDataSource } from '../../controllers/types'
 import { createSignal, type Signal } from '../../reactivity/signal'
-import { DataBuffer, getPeriodDays } from '../../data-fetchers/dataBuffer'
+import { DataBuffer } from '../../data-fetchers/dataBuffer'
+import { getPeriodDays } from '../../data-fetchers/dataBuffer.effects'
 import { TimeShareBuffer } from '../../data-fetchers/timeShareBuffer'
 import type { DataBufferLike } from '../../data-fetchers/dataBufferTypes'
 import type { TimeShareFetcherFn } from '../../data-fetchers/types'

package/src/engine/drawing/AnchorCollector.ts

@@ -0,0 +1,57 @@
+import type { DrawingToolId } from './toolConfig'
+import { getAnchorCountForTool } from './toolConfig'
+import type { DrawingAnchorInput } from './coordinateUtils'
+
+/**
+ * Accumulates pointer anchors until the required count is reached for a given tool.
+ * Single-anchor tools are not managed here — they create immediately on first click.
+ */
+export class AnchorCollector {
+  pendingAnchors: DrawingAnchorInput[] = []
+
+  /** Returns true when the tool uses multiple anchors (2 or 3). */
+  isMultiAnchorTool(toolId: DrawingToolId): boolean {
+    const count = getAnchorCountForTool(toolId)
+    return count === 2 || count === 3
+  }
+
+  /** Returns the required anchor count for the given tool, or null for single-anchor / cursor. */
+  getRequiredCount(toolId: DrawingToolId): number | null {
+    return getAnchorCountForTool(toolId)
+  }
+
+  /** 当前已累积的锚点数量 */
+  getPendingCount(): number {
+    return this.pendingAnchors.length
+  }
+
+  /**
+   * Add an anchor for the given tool.
+   * @returns the full anchor list if the required count is reached (caller should create drawing),
+   *          or null if still accumulating.
+   */
+  addAnchor(anchor: DrawingAnchorInput, toolId: DrawingToolId): DrawingAnchorInput[] | null {
+    const required = this.getRequiredCount(toolId)
+    if (required === null) return null
+
+    this.pendingAnchors.push(anchor)
+
+    if (this.pendingAnchors.length >= required) {
+      const result = [...this.pendingAnchors]
+      this.pendingAnchors = []
+      return result
+    }
+
+    return null
+  }
+
+  /** Peek at the first pending anchor without modifying state. */
+  getFirst(): DrawingAnchorInput | undefined {
+    return this.pendingAnchors[0]
+  }
+
+  /** 清空累积的锚点 */
+  reset(): void {
+    this.pendingAnchors = []
+  }
+}

package/src/engine/drawing/DragHandler.ts

@@ -0,0 +1,121 @@
+import type { DrawingObject, DrawingAnchor } from '../../plugin'
+import type { DrawingChartAdapter } from '../../controllers/types'
+import { resolveAnchorFromPointer, anchorToScreen, screenToAnchor } from './coordinateUtils'
+
+// ---- Types ----
+
+export interface DragState {
+  drawingId: string
+  anchorIndex?: number
+  snapshot: DrawingAnchor[]
+  startMouse: { x: number; y: number }
+}
+
+/**
+ * Manages drag state and handles drag-move mutations for drawings.
+ * Does NOT own the drawings array — the caller retrieves and writes back.
+ */
+export class DragHandler {
+  private dragState: DragState | null = null
+
+  /** 当前是否有未结束的拖拽 */
+  isDragging(): boolean {
+    return this.dragState !== null
+  }
+
+  /** 拖拽中的图元 ID */
+  getDraggingDrawingId(): string | null {
+    return this.dragState?.drawingId ?? null
+  }
+
+  /**
+   * 开始拖拽。
+   * @param drawing 拖拽的图元
+   * @param anchorIndex 拖拽单个锚点时传锚点下标；拖拽整线时不传
+   * @param mouseX 起始鼠标 X（屏幕 px）
+   * @param mouseY 起始鼠标 Y（屏幕 px）
+   */
+  startDrag(
+    drawing: DrawingObject,
+    anchorIndex: number | undefined,
+    mouseX: number,
+    mouseY: number,
+  ): void {
+    this.dragState = {
+      drawingId: drawing.id,
+      anchorIndex,
+      snapshot: drawing.anchors.map((a) => ({ ...a })),
+      startMouse: { x: mouseX, y: mouseY },
+    }
+  }
+
+  /**
+   * Handle drag-move for the given drawing, mutating its anchors.
+   * @returns a new DrawingObject reference with updated anchors, or null if drag state is stale.
+   */
+  handleDragMove(
+    drawing: DrawingObject,
+    e: PointerEvent,
+    container: HTMLElement,
+    adapter: DrawingChartAdapter,
+  ): DrawingObject | null {
+    if (!this.dragState) return null
+
+    const newAnchor = resolveAnchorFromPointer(e, container, adapter)
+    const updatedAnchors = [...drawing.anchors]
+
+    if (this.dragState.anchorIndex !== undefined) {
+      // Dragging a single anchor point
+      if (!newAnchor) return null
+      const idx = this.dragState.anchorIndex
+
+      updatedAnchors[idx] = {
+        ...updatedAnchors[idx]!,
+        index: newAnchor.index,
+        time: newAnchor.time,
+        price: newAnchor.price,
+      }
+
+      // flat-line: third anchor's index/time follows the second
+      if (drawing.kind === 'flat-line' && idx === 1 && updatedAnchors.length >= 3) {
+        updatedAnchors[2] = {
+          ...updatedAnchors[2]!,
+          index: newAnchor.index,
+          time: newAnchor.time,
+        }
+      }
+    } else {
+      // Dragging the entire line — offset all anchors by mouse delta
+      const rect = container.getBoundingClientRect()
+      const mouseX = e.clientX - rect.left
+      const mouseY = e.clientY - rect.top
+      const dx = mouseX - this.dragState.startMouse.x
+      const dy = mouseY - this.dragState.startMouse.y
+
+      for (let i = 0; i < drawing.anchors.length; i++) {
+        const snap = this.dragState.snapshot[i]!
+        const snapScreen = anchorToScreen(snap, adapter)
+        if (!snapScreen) continue
+
+        const targetX = snapScreen.x + dx
+        const targetY = snapScreen.y + dy
+        const newFromScreen = screenToAnchor(targetX, targetY, adapter)
+        if (newFromScreen) {
+          updatedAnchors[i] = {
+            ...updatedAnchors[i]!,
+            index: newFromScreen.index,
+            time: newFromScreen.time,
+            price: newFromScreen.price,
+          }
+        }
+      }
+    }
+
+    return { ...drawing, anchors: updatedAnchors }
+  }
+
+  /** 结束拖拽，清空状态 */
+  endDrag(): void {
+    this.dragState = null
+  }
+}