@363045841yyt/klinechart-core 0.8.13 → 0.8.14-alpha.2

package/src/engine/data/comparisonManager.ts

@@ -0,0 +1,211 @@
+import type { KLineData, SymbolSpec, DataFetcher } from '../../controllers/types'
+import { createSignal, type Signal } from '../../reactivity/signal'
+
+const COMPARISON_PALETTE = [
+  '#f59e0b',
+  '#8b5cf6',
+  '#06b6d4',
+  '#ec4899',
+  '#84cc16',
+  '#f97316',
+]
+const DEFAULT_COMPARISON_COLOR = '#f59e0b'
+const BUF_COMPARISON = 'cmp'
+
+export interface ComparisonHooks {
+  createComparisonBuffer(
+    spec: SymbolSpec,
+  ): { key: string; buffer: import('../../data-fetchers/dataBufferTypes').KLineBuffer }
+  disposeBuffer(key: string): void
+  getKLineBuffer(key: string): import('../../data-fetchers/dataBufferTypes').KLineBuffer | undefined
+  hasKLineBuffer(key: string): boolean
+  getKLineBufferKeys(): string[]
+  scheduleDraw(): void
+}
+
+export class ComparisonManager {
+  private _specs: SymbolSpec[] = []
+  private _data = new Map<string, KLineData[]>()
+  private _colors: Map<string, string> = new Map()
+  private _colorsSignal = createSignal<ReadonlyMap<string, string>>(new Map())
+  private _loadingSignal = createSignal<boolean>(false)
+  private _cmpLoadingUnsubs = new Map<string, () => void>()
+  private _hooks: ComparisonHooks
+
+  constructor(hooks: ComparisonHooks) {
+    this._hooks = hooks
+  }
+
+  get specs(): SymbolSpec[] {
+    return this._specs
+  }
+
+  get data(): Map<string, KLineData[]> {
+    return this._data
+  }
+
+  get colorsSignal(): Signal<ReadonlyMap<string, string>> {
+    return this._colorsSignal
+  }
+
+  get loadingSignal(): Signal<boolean> {
+    return this._loadingSignal
+  }
+
+  getColors(): Map<string, string> {
+    return this._colors
+  }
+
+  syncBuffers(specs: ReadonlyArray<SymbolSpec>, mainEarliest?: number): void {
+    this._specs = [...specs]
+    const nextKeys = new Set(specs.map((s) => s.symbol))
+
+    for (const key of this._hooks.getKLineBufferKeys()) {
+      if (!key.startsWith(BUF_COMPARISON)) continue
+      const symbol = key.split(':')[1]!
+      if (nextKeys.has(symbol)) continue
+      this._hooks.disposeBuffer(key)
+      this._data.delete(symbol)
+    }
+
+    for (const spec of specs) {
+      const key = `cmp:${spec.symbol}:${spec.period ?? 'daily'}`
+      const symbol = spec.symbol
+      let buf = this._hooks.getKLineBuffer(key)
+      if (!buf) {
+        const created = this._hooks.createComparisonBuffer(spec)
+        buf = created.buffer
+
+        const b = buf
+        const unsub = b.data.subscribe(() => {
+          this._data.set(symbol, [...b.getRawData()])
+          this._hooks.scheduleDraw()
+        })
+        this._cmpLoadingUnsubs.set(key, unsub)
+
+        const unsubLoading = buf.loading.subscribe(() => this._recomputeLoading())
+        this._cmpLoadingUnsubs.set(`loading:${key}`, unsubLoading)
+      }
+      buf.setSymbol(spec, mainEarliest)
+    }
+  }
+
+  clearAll(): void {
+    for (const key of this._hooks.getKLineBufferKeys()) {
+      if (key.startsWith(BUF_COMPARISON)) {
+        this._hooks.disposeBuffer(key)
+      }
+    }
+    this._data.clear()
+    this._colors.clear()
+    this._colorsSignal.set(new Map())
+    this._loadingSignal.set(false)
+    this._specs = []
+  }
+
+  addSymbol(spec: SymbolSpec, onComplete: () => void): void {
+    const symbol = spec.symbol
+
+    for (const k of this._hooks.getKLineBufferKeys()) {
+      if (k.startsWith(BUF_COMPARISON) && k.split(':')[1] === symbol) return
+    }
+
+    this._specs.push(spec)
+
+    const color =
+      COMPARISON_PALETTE[this._colors.size % COMPARISON_PALETTE.length] ??
+      DEFAULT_COMPARISON_COLOR
+    this._colors.set(symbol, color)
+    this._colorsSignal.set(new Map(this._colors))
+
+    const key = `cmp:${symbol}:${spec.period ?? 'daily'}`
+
+    if (!this._hooks.hasKLineBuffer(key)) {
+      const created = this._hooks.createComparisonBuffer(spec)
+      const buf = created.buffer
+
+      const unsub = buf.data.subscribe(() => {
+        this._data.set(symbol, [...buf.getRawData()])
+        this._hooks.scheduleDraw()
+      })
+      this._cmpLoadingUnsubs.set(key, unsub)
+
+      const unsubLoading = buf.loading.subscribe(() => this._recomputeLoading())
+      this._cmpLoadingUnsubs.set(`loading:${key}`, unsubLoading)
+
+      buf.setSymbol(spec)
+    }
+
+    onComplete()
+  }
+
+  setData(symbol: string, data: KLineData[], onNewBuffer: (key: string) => void): void {
+    const period = 'daily'
+    const key = `cmp:${symbol}:${period}`
+
+    const existing = this._hooks.getKLineBuffer(key)
+    if (!existing) {
+      const buffer = this._hooks.createComparisonBuffer({
+        symbol,
+        period,
+      }).buffer
+
+      const unsub = buffer.data.subscribe(() => {
+        this._data.set(symbol, [...buffer.getRawData()])
+        this._hooks.scheduleDraw()
+      })
+      this._cmpLoadingUnsubs.set(key, unsub)
+
+      const unsubLoading = buffer.loading.subscribe(() => this._recomputeLoading())
+      this._cmpLoadingUnsubs.set(`loading:${key}`, unsubLoading)
+
+      const color =
+        COMPARISON_PALETTE[this._colors.size % COMPARISON_PALETTE.length] ??
+        DEFAULT_COMPARISON_COLOR
+      this._colors.set(symbol, color)
+      this._colorsSignal.set(new Map(this._colors))
+
+      const spec: SymbolSpec = { symbol, period }
+      this._specs.push(spec)
+
+      buffer.setInlineData(data)
+      onNewBuffer(key)
+      return
+    }
+    existing.setInlineData(data)
+  }
+
+  removeSymbol(symbol: string): boolean {
+    let found = false
+    for (const key of this._hooks.getKLineBufferKeys()) {
+      if (key.startsWith(BUF_COMPARISON) && key.split(':')[1] === symbol) {
+        this._hooks.disposeBuffer(key)
+        found = true
+        break
+      }
+    }
+    if (!found) return false
+
+    this._data.delete(symbol)
+    this._colors.delete(symbol)
+    this._colorsSignal.set(new Map(this._colors))
+    this._specs = this._specs.filter((s) => s.symbol !== symbol)
+    this._recomputeLoading()
+    return true
+  }
+
+  ensureRange(firstVisibleTs: number, windowEarliestTs: number): void {
+    for (const key of this._hooks.getKLineBufferKeys()) {
+      if (key.startsWith(BUF_COMPARISON)) {
+        this._hooks.getKLineBuffer(key)?.ensureRange(firstVisibleTs, windowEarliestTs)
+      }
+    }
+  }
+
+  private _recomputeLoading(): void {
+    const anyLoading = [...this._hooks.getKLineBufferKeys()].some(
+      (k) => k.startsWith(BUF_COMPARISON) && this._hooks.getKLineBuffer(k)?.loading.peek(),
+    )
+    this._loadingSignal.set(anyLoading)
+  }
+}

package/src/engine/data/fetchBatchScheduler.ts

@@ -0,0 +1,82 @@
+import type { DataFetcher, SymbolSpec, KLineData } from '../../controllers/types'
+
+interface PendingFetch {
+  source: string
+  spec: SymbolSpec
+  startTs: number
+  endTs: number
+  resolve: (data: ReadonlyArray<KLineData>) => void
+  reject: (err: Error) => void
+}
+
+function batchFormatDate(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}`
+}
+
+const CONCURRENCY = 4
+
+export class FetchBatchScheduler {
+  private _fetcher: DataFetcher | null = null
+  private _pending: Array<PendingFetch> = []
+  private _flushScheduled = false
+
+  setFetcher(fetcher: DataFetcher | null): void {
+    this._fetcher = fetcher
+  }
+
+  getFetcher(): DataFetcher | null {
+    return this._fetcher
+  }
+
+  createHandler(): (
+    spec: SymbolSpec,
+    startTs: number,
+    endTs: number,
+  ) => Promise<ReadonlyArray<KLineData>> {
+    return (spec, startTs, endTs) =>
+      new Promise<ReadonlyArray<KLineData>>((resolve, reject) => {
+        if (!spec.source) {
+          reject(
+            new Error(
+              `[DataFetcher] source is required but was not provided for symbol "${spec.symbol}"`,
+            ),
+          )
+          return
+        }
+        this._pending.push({ source: spec.source, spec, startTs, endTs, resolve, reject })
+        this._scheduleFlush()
+      })
+  }
+
+  private _scheduleFlush(): void {
+    if (this._flushScheduled) return
+    this._flushScheduled = true
+    Promise.resolve().then(() => this._flush())
+  }
+
+  private async _flush(): Promise<void> {
+    this._flushScheduled = false
+    const batch = this._pending.splice(0)
+    if (batch.length === 0 || !this._fetcher) return
+    const fetcher = this._fetcher
+    for (let i = 0; i < batch.length; i += CONCURRENCY) {
+      const chunk = batch.slice(i, i + CONCURRENCY)
+      await Promise.allSettled(
+        chunk.map(({ source, spec, startTs, endTs, resolve, reject }) =>
+          fetcher(source, {
+            symbol: spec.symbol,
+            startDate: batchFormatDate(startTs),
+            endDate: batchFormatDate(endTs),
+            period: spec.period ?? 'daily',
+            adjust: spec.adjust ?? 'none',
+            exchange: spec.exchange,
+          }).then(resolve, reject),
+        ),
+      )
+    }
+  }
+}

package/src/engine/data/incrementalLoadHint.ts

@@ -0,0 +1,105 @@
+import type { ChartDom } from '../chartTypes'
+import { getPhysicalKLineConfig } from '../utils/klineConfig'
+
+export interface HintDeps {
+  getOption: () => { kWidth: number; kGap: number }
+  getEffectiveDpr: () => number
+  getDom: () => ChartDom
+  getViewport: () => { viewHeight: number } | null
+}
+
+export class IncrementalLoadHint {
+  private _el: HTMLDivElement | null = null
+  private _timer: number | null = null
+
+  constructor(private deps: HintDeps) {}
+
+  show(count: number, leftBufferWidth: number): void {
+    if (count <= 0) return
+    const hint = this._ensure()
+    if (!hint) return
+    this._clearTimer()
+
+    const dpr = this.deps.getEffectiveDpr()
+    const opt = this.deps.getOption()
+    const { unitPx, startXPx } = getPhysicalKLineConfig(opt.kWidth, opt.kGap, dpr)
+
+    hint.style.left = `${leftBufferWidth}px`
+    const width = (startXPx + count * unitPx) / dpr
+    hint.style.width = `${Math.max(0, width)}px`
+    hint.style.height = `${Math.max(
+      0,
+      this.deps.getViewport()?.viewHeight ??
+        this.deps.getDom().container?.clientHeight ??
+        0,
+    )}px`
+    hint.getBoundingClientRect()
+
+    console.group('[LoadHint] show')
+    console.log('count:', count, 'leftBufferWidth:', leftBufferWidth)
+    console.log('dpr:', dpr, 'kWidth:', opt.kWidth, 'kGap:', opt.kGap)
+    console.log('unitPx:', unitPx, 'startXPx:', startXPx)
+    console.log('target left:', hint.style.left, 'target width:', hint.style.width)
+    const rect = hint.getBoundingClientRect()
+    console.log('hint rect:', rect)
+    const host = this.deps.getDom().scrollContent
+    if (host) console.log('host scrollLeft:', host.scrollLeft, 'scrollWidth:', host.scrollWidth)
+    console.groupEnd()
+    hint.style.opacity = '1'
+    hint.style.filter = 'blur(0px)'
+
+    this._timer = window.setTimeout(() => {
+      this._hide()
+      this._timer = null
+    }, 900)
+  }
+
+  hide(): void {
+    this._hide()
+  }
+
+  destroy(): void {
+    this._clearTimer()
+    this._el?.remove()
+    this._el = null
+  }
+
+  private _clearTimer(): void {
+    if (this._timer !== null) {
+      window.clearTimeout(this._timer)
+      this._timer = null
+    }
+  }
+
+  private _hide(): void {
+    if (!this._el) return
+    this._el.style.opacity = '0'
+    this._el.style.filter = 'blur(10px)'
+  }
+
+  private _ensure(): HTMLDivElement | null {
+    const host = this.deps.getDom().scrollContent ?? this.deps.getDom().container ?? null
+    if (!host) return null
+    if (this._el && this._el.isConnected) return this._el
+
+    const ownerDoc = host.ownerDocument
+    if (!ownerDoc) return null
+
+    const hint = ownerDoc.createElement('div')
+    hint.className = 'klc-incremental-load-hint'
+    hint.style.position = 'absolute'
+    hint.style.top = '0'
+    hint.style.height = '0px'
+    hint.style.width = '0px'
+    hint.style.pointerEvents = 'none'
+    hint.style.opacity = '0'
+    hint.style.filter = 'blur(10px)'
+    hint.style.transition = 'opacity 420ms ease, filter 420ms ease'
+    hint.style.background = 'rgba(71, 91, 132, 0.5)'
+    hint.style.zIndex = '3'
+    hint.style.willChange = 'opacity, filter, width'
+    host.appendChild(hint)
+    this._el = hint
+    return hint
+  }
+}

package/src/engine/data/scrollCompensator.ts

@@ -0,0 +1,93 @@
+import type { ChartDom, Viewport } from '../chartTypes'
+import { getPhysicalKLineConfig } from '../utils/klineConfig'
+
+export interface ScrollDeps {
+  getOption: () => { kWidth: number; kGap: number }
+  getEffectiveDpr: () => number
+  getCachedScrollLeft: () => number
+  setScrollLeft: (v: number) => void
+  getDom: () => ChartDom
+  getObservedSize: () => { width: number; height: number }
+  getViewport: () => Viewport | null
+}
+
+export class ScrollCompensator {
+  constructor(private deps: ScrollDeps) {}
+
+  compensatePrepend(count: number): void {
+    const dpr = this.deps.getEffectiveDpr()
+    const opt = this.deps.getOption()
+    const { unitPx } = getPhysicalKLineConfig(opt.kWidth, opt.kGap, dpr)
+    const compensation = (count * unitPx) / dpr
+    const nextScrollLeft = this.deps.getCachedScrollLeft() + compensation
+    this.deps.setScrollLeft(nextScrollLeft)
+  }
+
+  adjustScrollAfterDataChange(dataLength: number): void {
+    const scrollLeft = this.deps.getCachedScrollLeft()
+    if (scrollLeft < 0) return
+
+    if (scrollLeft <= 0) {
+      this.deps.setScrollLeft(this.getLeftLoadBufferWidth(dataLength))
+      return
+    }
+
+    const dpr = this.deps.getEffectiveDpr()
+    const opt = this.deps.getOption()
+    const { unitPx, startXPx } = getPhysicalKLineConfig(opt.kWidth, opt.kGap, dpr)
+    const totalDataWidth = (startXPx + dataLength * unitPx) / dpr
+    const leftBuffer = this.getLeftLoadBufferWidth(dataLength)
+    if (scrollLeft >= leftBuffer + totalDataWidth) {
+      this.deps.setScrollLeft(leftBuffer)
+    }
+  }
+
+  scrollToRight(dataLength: number): void {
+    if (dataLength === 0) return
+    const dpr = this.deps.getEffectiveDpr()
+    const opt = this.deps.getOption()
+    const { unitPx, startXPx } = getPhysicalKLineConfig(opt.kWidth, opt.kGap, dpr)
+    const lastKLineEndPx = (startXPx + dataLength * unitPx) / dpr
+    const viewport = this.deps.getViewport()
+    const clientWidth =
+      viewport?.viewWidth ??
+      (this.deps.getObservedSize().width > 0
+        ? this.deps.getObservedSize().width
+        : undefined) ??
+      Math.round(this.deps.getDom().container?.clientWidth ?? 0)
+    if (clientWidth <= 0) return
+
+    const leftBuffer = this.getLeftLoadBufferWidth(dataLength)
+    let target: number
+    if (lastKLineEndPx <= clientWidth) {
+      target = leftBuffer - (clientWidth - lastKLineEndPx)
+    } else {
+      target = leftBuffer + (lastKLineEndPx - clientWidth)
+    }
+    const contentWidth = this.getContentWidth(dataLength)
+    const maxScroll = Math.max(0, contentWidth - clientWidth)
+    const scrollLeft = Math.round(Math.max(0, Math.min(target, maxScroll)) * dpr) / dpr
+    this.deps.setScrollLeft(scrollLeft)
+  }
+
+  getLeftLoadBufferWidth(dataLength: number): number {
+    if (dataLength === 0) return 0
+    const vp = this.deps.getViewport()
+    return (
+      vp?.plotWidth ??
+      (this.deps.getObservedSize().width > 0 ? this.deps.getObservedSize().width : undefined) ??
+      Math.round(this.deps.getDom().container?.clientWidth ?? 0)
+    )
+  }
+
+  getContentWidth(dataLength: number): number {
+    if (dataLength === 0) return 0
+    const opt = this.deps.getOption()
+    const viewWidth = this.deps.getViewport()?.plotWidth ?? 0
+    const dpr = this.deps.getEffectiveDpr()
+    const { startXPx, unitPx } = getPhysicalKLineConfig(opt.kWidth, opt.kGap, dpr)
+    const TRAILING_SLOTS = 30
+    const dataPlotWidth = (startXPx + (dataLength + TRAILING_SLOTS) * unitPx) / dpr
+    return this.getLeftLoadBufferWidth(dataLength) + Math.max(dataPlotWidth, viewWidth)
+  }
+}

package/src/engine/draw/__tests__/pixelAlign.spec.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect } from 'vitest'
+
 import {
   roundToPhysicalPixel,
   alignToPhysicalPixelCenter,

package/src/engine/drawing/AnchorCollector.ts

@@ -1,6 +1,6 @@
+import type { DrawingAnchorInput } from './coordinateUtils'
 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.

package/src/engine/drawing/DragHandler.ts

@@ -1,5 +1,6 @@
-import type { DrawingObject, DrawingAnchor } from '../../plugin'
 import type { DrawingChartAdapter } from '../../controllers/types'
+import type { DrawingObject, DrawingAnchor } from '../../plugin'
+
 import { resolveAnchorFromPointer, anchorToScreen, screenToAnchor } from './coordinateUtils'
 
 // ---- Types ----

package/src/engine/drawing/DrawingState.ts

@@ -1,5 +1,5 @@
-import type { DrawingObject, DrawingStyle } from '../../plugin'
 import type { DrawingChartAdapter } from '../../controllers/types'
+import type { DrawingObject, DrawingStyle } from '../../plugin'
 
 const PREVIEW_ID = '__preview__'
 

package/src/engine/drawing/HitTester.ts

@@ -1,8 +1,9 @@
-import type { DrawingObject } from '../../plugin'
 import type { DrawingChartAdapter } from '../../controllers/types'
+import type { DrawingObject } from '../../plugin'
+
 import { anchorToScreen, pointToSegmentDist } from './coordinateUtils'
-import { getExtendMode } from './toolConfig'
 import { computeLinearRegression } from './linearRegression'
+import { getExtendMode } from './toolConfig'
 
 // ---- Types ----
 

package/src/engine/drawing/PreviewRenderer.ts

@@ -1,5 +1,7 @@
 import type { DrawingObject } from '../../plugin'
+
 import { PREVIEW_ID } from './DrawingState'
+import type { DrawingAnchorInput } from './coordinateUtils'
 import type { DrawingToolId } from './toolConfig'
 import {
   SINGLE_ANCHOR_TOOLS,
@@ -8,7 +10,6 @@ import {
   getDrawingKind,
   CHANNEL_KINDS,
 } from './toolConfig'
-import type { DrawingAnchorInput } from './coordinateUtils'
 
 /**
  * Constructs preview DrawingObject instances for various tool types.

package/src/engine/drawing/coordinateUtils.ts

@@ -1,5 +1,5 @@
-import type { DrawingAnchor } from '../../plugin'
 import type { DrawingChartAdapter } from '../../controllers/types'
+import type { DrawingAnchor } from '../../plugin'
 import { getPhysicalKLineConfig } from '../utils/klineConfig'
 
 // ---- Types ----

package/src/engine/drawing/interaction.ts

@@ -1,11 +1,11 @@
-import type { DrawingObject, DrawingKind, DrawingStyle } from '../../plugin'
 import type { DrawingChartAdapter } from '../../controllers/types'
+import type { DrawingObject, DrawingKind, DrawingStyle } from '../../plugin'
 
-import { DrawingState, PREVIEW_ID } from './DrawingState'
 import { AnchorCollector } from './AnchorCollector'
-import { PreviewRenderer } from './PreviewRenderer'
-import { HitTester } from './HitTester'
 import { DragHandler } from './DragHandler'
+import { DrawingState, PREVIEW_ID } from './DrawingState'
+import { HitTester } from './HitTester'
+import { PreviewRenderer } from './PreviewRenderer'
 import { resolveAnchorFromPointer } from './coordinateUtils'
 import type { DrawingAnchorInput } from './coordinateUtils'
 import type { DrawingToolId } from './toolConfig'

package/src/engine/drawing/plugin.ts

@@ -9,6 +9,9 @@ import type {
   XAxisRange,
 } from '../../plugin'
 import { RENDERER_PRIORITY } from '../../plugin'
+import type { KLineData } from '../../types/price'
+import { getPhysicalKLineConfig } from '../utils/klineConfig'
+
 import {
   DrawingStore,
   DrawingDefinitionRegistry,
@@ -16,8 +19,6 @@ import {
   registerDefaultDrawingDefinitions,
 } from './index'
 import type { PrimitiveRendererSet } from './index'
-import type { KLineData } from '../../types/price'
-import { getPhysicalKLineConfig } from '../utils/klineConfig'
 
 type SafeViewport = { scrollLeft: number; plotWidth: number; plotHeight: number }
 type ToScreenFn = (anchor: { index: number; price: number }) => { x: number; y: number }

package/src/engine/indicators/__tests__/__fixtures__/golden/index.ts

@@ -1,9 +1,9 @@
 import atrGolden from './atr.json'
-import wmaGolden from './wma.json'
 import demaGolden from './dema.json'
-import temaGolden from './tema.json'
 import hmaGolden from './hma.json'
 import kamaGolden from './kama.json'
+import temaGolden from './tema.json'
+import wmaGolden from './wma.json'
 
 export interface GoldenSeries {
   period: number

package/src/engine/indicators/__tests__/atr.test.ts

@@ -1,5 +1,8 @@
 import { describe, it, expect } from 'vitest'
+
 import { calcATRData } from '../calculators'
+
+import { ATR_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
 import {
   empty,
   singleBar,
@@ -11,7 +14,6 @@ import {
   spikeAtBar19,
   gapUp,
 } from './__fixtures__/synthetic'
-import { ATR_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
 import { assertNonNegative, assertFiniteOrUndefined } from './_propertyAssertions'
 
 describe('calcATRData — Wilder ATR(period)', () => {

package/src/engine/indicators/__tests__/calculators.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect } from 'vitest'
+
 import {
   calcMAData,
   calcBOLLData,
@@ -8,9 +9,10 @@ import {
   DEFAULT_MA_PERIODS,
 } from '../calculators'
 import { DEFAULT_BOLL_PERIOD, DEFAULT_BOLL_MULTIPLIER } from '../state/bollState'
-import { DEFAULT_EXPMA_FAST_PERIOD, DEFAULT_EXPMA_SLOW_PERIOD } from '../state/expmaState'
 import { DEFAULT_ENE_PERIOD, DEFAULT_ENE_DEVIATION } from '../state/eneState'
+import { DEFAULT_EXPMA_FAST_PERIOD, DEFAULT_EXPMA_SLOW_PERIOD } from '../state/expmaState'
 import { DEFAULT_RSI_PERIOD1, DEFAULT_RSI_PERIOD2, DEFAULT_RSI_PERIOD3 } from '../state/rsiState'
+
 import type { KLineData } from '@/types/price'
 
 /**

package/src/engine/indicators/__tests__/chartIndicatorManager.test.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect, vi, beforeAll, beforeEach } from 'vitest'
-import { ChartIndicatorManager, type IndicatorDependencies } from '../chartIndicatorManager'
+
 import { createPluginHost } from '../../../plugin/PluginHost'
 import { createSignal } from '../../../reactivity/signal'
 import type { VisibleRange } from '../../layout/pane'
 import { UpdateLevel } from '../../layout/pane'
+import { ChartIndicatorManager, type IndicatorDependencies } from '../chartIndicatorManager'
 import { loadBuiltinIndicators } from '../registerBuiltins'
 
 beforeAll(async () => {

package/src/engine/indicators/__tests__/cmf-mfi.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, expect } from 'vitest'
+
 import { calcCMFData, calcMFIData } from '../calculators'
+
 import {
   empty,
   constantPrice,

package/src/engine/indicators/__tests__/dema.test.ts

@@ -1,5 +1,8 @@
 import { describe, it, expect } from 'vitest'
+
 import { calcDEMAData } from '../calculators'
+
+import { DEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
 import {
   empty,
   singleBar,
@@ -9,7 +12,6 @@ import {
   sideways,
   spikeAtBar19,
 } from './__fixtures__/synthetic'
-import { DEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
 import { assertFiniteOrUndefined } from './_propertyAssertions'
 
 describe('calcDEMAData — Double Exponential Moving Average', () => {