@363045841yyt/klinechart-core 0.7.3

package/src/engine/utils/tickPosition.ts

@@ -0,0 +1,214 @@
+import { calculateTickCount } from './tickCount'
+import { fromLog, logFormulaForPriceRange, toLog } from '../scale/logFormula'
+
+export interface TickPosition {
+    index: number
+    t: number
+    y: number
+}
+
+export type ScaleType = 'linear' | 'log'
+
+export interface CalculateTickPositionsOptions {
+    height: number
+    paddingTop: number
+    paddingBottom: number
+    isMain?: boolean
+    hideEdgeTicks?: boolean
+    scaleType?: ScaleType
+}
+
+export function calculateTickPositions(
+    options: CalculateTickPositionsOptions
+): TickPosition[] {
+    const { height, paddingTop, paddingBottom, isMain, hideEdgeTicks } = options
+
+    const yStart = paddingTop
+    const yEnd = Math.max(paddingTop, height - paddingBottom)
+    const viewH = Math.max(0, yEnd - yStart)
+
+    const ticks = calculateTickCount(height, isMain)
+    const positions: TickPosition[] = []
+
+    for (let i = 0; i < ticks; i++) {
+        if (hideEdgeTicks && (i === 0 || i === ticks - 1)) continue
+
+        const t = ticks <= 1 ? 0 : i / (ticks - 1)
+        const y = yStart + t * viewH
+
+        positions.push({ index: i, t, y })
+    }
+
+    return positions
+}
+
+export interface TickPositionWithValue extends TickPosition {
+    value: number
+}
+
+export interface CalculateValueTickPositionsOptions extends CalculateTickPositionsOptions {
+    valueMin: number
+    valueMax: number
+    logBase?: number
+}
+
+const LOG_EPSILON = 1e-10
+const LOG_ROUND_CANDIDATES = [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 7.5, 8, 10]
+
+function roundLogTickValue(value: number): number {
+    if (!Number.isFinite(value) || value <= 0) {
+        return value
+    }
+
+    const exp = Math.floor(Math.log10(value))
+    const magnitude = Math.pow(10, exp)
+    const normalized = value / magnitude
+
+    let best = LOG_ROUND_CANDIDATES[0]
+    let minDiff = Infinity
+    for (const candidate of LOG_ROUND_CANDIDATES) {
+        const diff = Math.abs(candidate - normalized)
+        if (diff < minDiff) {
+            minDiff = diff
+            best = candidate
+        }
+    }
+
+    return best * magnitude
+}
+
+function generatePixelUniformLogTicks(options: {
+    height: number
+    paddingTop: number
+    paddingBottom: number
+    valueMin: number
+    valueMax: number
+    targetCount: number
+}): TickPositionWithValue[] {
+    const { height, paddingTop, paddingBottom, valueMin, valueMax, targetCount } = options
+
+    const effectiveMin = Math.max(valueMin, LOG_EPSILON)
+    const effectiveMax = Math.max(valueMax, effectiveMin * 1.001)
+    const yStart = paddingTop
+    const yEnd = Math.max(paddingTop, height - paddingBottom)
+    const viewH = Math.max(0, yEnd - yStart)
+
+    if (viewH <= 0) {
+        return []
+    }
+
+    const formula = logFormulaForPriceRange({ minPrice: effectiveMin, maxPrice: effectiveMax })
+    const logMin = toLog(effectiveMin, formula)
+    const logMax = toLog(effectiveMax, formula)
+    const logRange = logMax - logMin
+
+    if (!Number.isFinite(logRange) || Math.abs(logRange) < 1e-10) {
+        return []
+    }
+
+    const total = Math.max(2, targetCount)
+    const spacingPx = total <= 1 ? viewH : viewH / (total - 1)
+    const minSpacingPx = spacingPx * 0.6
+    const maxRoundShiftPx = spacingPx * 0.15
+
+    const positions: TickPositionWithValue[] = []
+    let prevY: number | null = null
+
+    for (let i = 0; i < total; i++) {
+        const idealT = total <= 1 ? 0 : i / (total - 1)
+        const idealY = yStart + idealT * viewH
+        const logical = logMax - idealT * logRange
+        const rawValue = fromLog(logical, formula)
+
+        let value = rawValue
+        let t = idealT
+        let y = idealY
+
+        const roundedValue = roundLogTickValue(rawValue)
+        if (Number.isFinite(roundedValue) && roundedValue > 0) {
+            const roundedLogical = toLog(roundedValue, formula)
+            const roundedT = (logMax - roundedLogical) / logRange
+            const roundedY = yStart + roundedT * viewH
+
+            if (Number.isFinite(roundedY) && Math.abs(roundedY - idealY) <= maxRoundShiftPx) {
+                value = roundedValue
+                t = roundedT
+                y = roundedY
+            }
+        }
+
+        if (y < yStart - 0.5 || y > yEnd + 0.5) {
+            continue
+        }
+
+        if (prevY !== null && Math.abs(y - prevY) < minSpacingPx) {
+            continue
+        }
+
+        positions.push({ index: positions.length, t, y, value })
+        prevY = y
+    }
+
+    return positions
+}
+
+// calculateValueTickPositions 缓存
+let _cvtpCacheKey = ''
+let _cvtpCacheResult: TickPositionWithValue[] = []
+
+function buildCvtpCacheKey(options: CalculateValueTickPositionsOptions): string {
+    return `${options.valueMin}:${options.valueMax}:${options.height}:${options.paddingTop}:${options.paddingBottom}:${options.isMain}:${options.scaleType ?? 'linear'}:${options.hideEdgeTicks ?? false}`
+}
+
+export function calculateValueTickPositions(
+    options: CalculateValueTickPositionsOptions
+): TickPositionWithValue[] {
+    // 缓存命中：所有参数相同则直接返回
+    const key = buildCvtpCacheKey(options)
+    if (key === _cvtpCacheKey) return _cvtpCacheResult
+
+    const { valueMin, valueMax, scaleType = 'linear' } = options
+
+    if (scaleType === 'log') {
+        if (valueMin <= 0) {
+            // 递归调用走线性路径，线性路径会更新缓存
+            return calculateValueTickPositions({ ...options, scaleType: 'linear' })
+        }
+
+        const effectiveMin = Math.max(valueMin, LOG_EPSILON)
+        const effectiveMax = Math.max(valueMax, effectiveMin * 1.001)
+        const { height, paddingTop, paddingBottom, isMain, hideEdgeTicks } = options
+        const targetCount = Math.max(2, calculateTickCount(height, isMain))
+
+        let positions = generatePixelUniformLogTicks({
+            height,
+            paddingTop,
+            paddingBottom,
+            valueMin: effectiveMin,
+            valueMax: effectiveMax,
+            targetCount,
+        })
+
+        if (hideEdgeTicks && positions.length > 2) {
+            positions = positions.slice(1, -1)
+        }
+
+        const result = positions.map((position, index) => ({ ...position, index }))
+        _cvtpCacheKey = key
+        _cvtpCacheResult = result
+        return result
+    }
+
+    const basePositions = calculateTickPositions(options)
+    const totalTicks = calculateTickCount(options.height, options.isMain)
+    const valueRange = valueMax - valueMin || 1
+
+    const result = basePositions.map((pos) => {
+        const step = valueRange / Math.max(1, totalTicks - 1)
+        const value = valueMax - step * pos.index
+        return { ...pos, value }
+    })
+    _cvtpCacheKey = key
+    _cvtpCacheResult = result
+    return result
+}

package/src/engine/utils/zoom.ts

@@ -0,0 +1,83 @@
+import { getPhysicalKLineConfig } from './klineConfig'
+
+/**
+ * 缩放计算纯函数
+ * 无副作用、无 DOM 访问，供 Vue 层直接调用
+ */
+
+export interface ZoomConfig {
+  minKWidth: number
+  maxKWidth: number
+  zoomLevelCount: number
+  dpr: number
+}
+
+export interface ZoomResult {
+  targetLevel: number
+  newKWidth: number
+  newKGap: number
+  newScrollLeft: number
+}
+
+const PHYS_K_GAP_MAX = 3
+
+/** 将缩放级别转换为 K 线宽度（逻辑像素） */
+export function zoomLevelToKWidth(level: number, config: ZoomConfig): number {
+  const t = (level - 1) / (config.zoomLevelCount - 1)
+  return config.minKWidth + t * (config.maxKWidth - config.minKWidth)
+}
+
+/** 根据K线宽度和DPR推导间隙（逻辑像素），K线越窄间距越小 */
+export function kGapFromKWidth(kWidth: number, dpr: number): number {
+  const kWidthPx = Math.round(kWidth * dpr)
+  const kGapPx = Math.max(1, Math.min(PHYS_K_GAP_MAX, Math.round(kWidthPx * 0.6)))
+  return kGapPx / dpr
+}
+
+/**
+ * 缩放一级（+1 放大 / -1 缩小）
+ * 返回新状态或 null（已达边界）
+ */
+export function computeZoom(
+  delta: number,
+  mouseX: number,
+  scrollLeft: number,
+  currentLevel: number,
+  currentKWidth: number,
+  currentKGap: number,
+  config: ZoomConfig,
+): ZoomResult | null {
+  const targetLevel = Math.max(1, Math.min(config.zoomLevelCount, currentLevel + delta))
+  if (targetLevel === currentLevel) return null
+
+  const newKWidth = zoomLevelToKWidth(targetLevel, config)
+  const newKGap = kGapFromKWidth(newKWidth, config.dpr)
+
+  const oldConfig = getPhysicalKLineConfig(currentKWidth, currentKGap, config.dpr)
+  const newConfig = getPhysicalKLineConfig(newKWidth, newKGap, config.dpr)
+  const anchorWorldPx = Math.round((scrollLeft + mouseX) * config.dpr)
+  const anchorSlotFloat = (anchorWorldPx - oldConfig.startXPx) / oldConfig.unitPx
+  const newAnchorWorldPx = newConfig.startXPx + anchorSlotFloat * newConfig.unitPx
+  const newScrollLeft = newAnchorWorldPx / config.dpr - mouseX
+
+  return { targetLevel, newKWidth, newKGap, newScrollLeft }
+}
+
+/**
+ * 缩放到指定级别
+ * 返回新状态或 null（级别不变或无效）
+ */
+export function computeZoomToLevel(
+  targetLevel: number,
+  anchorX: number,
+  scrollLeft: number,
+  currentLevel: number,
+  currentKWidth: number,
+  currentKGap: number,
+  config: ZoomConfig,
+): ZoomResult | null {
+  const clamped = Math.max(1, Math.min(config.zoomLevelCount, Math.round(targetLevel)))
+  const delta = clamped - currentLevel
+  if (delta === 0) return null
+  return computeZoom(delta, anchorX, scrollLeft, currentLevel, currentKWidth, currentKGap, config)
+}

package/src/engine/viewport/viewport.ts

@@ -0,0 +1,67 @@
+import type { KLineData } from '../../types/price'
+import type { PriceRange } from '../scale/price'
+import { getPhysicalKLineConfig } from '../utils/klineConfig'
+
+/**
+ * 计算当前视口可见的 K 线索引范围（使用物理像素对齐）。
+ *
+ * - 所有计算在物理像素空间进行，确保与 calcKLinePositions 一致
+ * - 会额外在左右各扩展 1 根（start-1/end+1），用于避免边缘裁剪带来的”断线/缺一根”观感
+ *
+ * @param scrollLeft 容器当前横向滚动量（逻辑像素）
+ * @param viewWidth  绘图区域宽度（plotWidth，逻辑像素，不含右侧 yAxis）
+ * @param kWidth     单根 K 线宽度（逻辑像素）
+ * @param kGap       K 线间距（逻辑像素）
+ * @param totalDataCount 数据总条数
+ * @param dpr        设备像素比
+ */
+export function getVisibleRange(
+    scrollLeft: number,
+    viewWidth: number,
+    kWidth: number,
+    kGap: number,
+    totalDataCount: number,
+    dpr: number = 1
+): { start: number; end: number } {
+    // 使用统一的物理像素配置，确保与 calcKLinePositions 完全一致
+    const { unitPx, startXPx } = getPhysicalKLineConfig(kWidth, kGap, dpr)
+
+    // scrollLeft 和 viewWidth 转换到物理像素空间
+    const scrollLeftPx = scrollLeft * dpr
+    const viewWidthPx = viewWidth * dpr
+
+    // 计算可见范围（物理像素空间整数运算）
+    const start = Math.max(0, Math.floor((scrollLeftPx - startXPx) / unitPx) - 1)
+    const end = Math.min(totalDataCount, Math.ceil((scrollLeftPx + viewWidthPx - startXPx) / unitPx) + 1)
+
+    return { start, end }
+}
+
+/**
+ * 计算指定索引区间内的价格范围（max/min）。
+ *
+ * 主要用途：
+ * - 为 pane 的 y 轴缩放与刻度提供 priceRange
+ * - 为渲染器（网格线、极值标注等）提供可视区参考范围
+ *
+ * 注意：
+ * - `endIndex` 为开区间（不包含）
+ * - 若区间内无有效数据，会返回兜底范围 `{ maxPrice: 100, minPrice: 0 }`
+ */
+export function getVisiblePriceRange(data: KLineData[], startIndex: number, endIndex: number): PriceRange {
+    let maxPrice = -Infinity
+    let minPrice = Infinity
+
+    for (let i = startIndex; i < endIndex && i < data.length; i++) {
+        const e = data[i]
+        if (!e) continue
+        if (e.high > maxPrice) maxPrice = e.high
+        if (e.low < minPrice) minPrice = e.low
+    }
+
+    if (!Number.isFinite(maxPrice) || !Number.isFinite(minPrice)) {
+        return { maxPrice: 100, minPrice: 0 }
+    }
+
+    return { maxPrice, minPrice }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './reactivity'
+export * from './controllers'
+export { VERSION } from './version'

package/src/plugin/ConfigManager.ts

@@ -0,0 +1,93 @@
+/**
+ * 配置管理器
+ */
+
+type ConfigStore = Map<string, Map<string, unknown>>
+
+export class ConfigManager {
+  private configs: ConfigStore = new Map()
+  private defaults: Map<string, Record<string, unknown>> = new Map()
+
+  /**
+   * 注册插件的默认配置
+   */
+  registerDefaults(pluginName: string, defaults: Record<string, unknown>): void {
+    this.defaults.set(pluginName, { ...defaults })
+
+    // 初始化配置
+    if (!this.configs.has(pluginName)) {
+      this.configs.set(pluginName, new Map())
+    }
+
+    // 应用默认值
+    const config = this.configs.get(pluginName)!
+    for (const [key, value] of Object.entries(defaults)) {
+      if (!config.has(key)) {
+        config.set(key, value)
+      }
+    }
+  }
+
+  /**
+   * 获取配置
+   */
+  get<K = unknown>(pluginName: string, key: string, defaultValue?: K): K {
+    const pluginConfig = this.configs.get(pluginName)
+    if (pluginConfig?.has(key)) {
+      return pluginConfig.get(key) as K
+    }
+
+    // 尝试默认值
+    const defaults = this.defaults.get(pluginName)
+    if (defaults && key in defaults) {
+      return defaults[key] as K
+    }
+
+    return defaultValue as K
+  }
+
+  /**
+   * 设置配置
+   */
+  set(pluginName: string, key: string, value: unknown): void {
+    if (!this.configs.has(pluginName)) {
+      this.configs.set(pluginName, new Map())
+    }
+    this.configs.get(pluginName)!.set(key, value)
+  }
+
+  /**
+   * 批量设置配置
+   */
+  setAll(pluginName: string, config: Record<string, unknown>): void {
+    for (const [key, value] of Object.entries(config)) {
+      this.set(pluginName, key, value)
+    }
+  }
+
+  /**
+   * 获取插件所有配置
+   */
+  getAll(pluginName: string): Record<string, unknown> {
+    const config = this.configs.get(pluginName)
+    const defaults = this.defaults.get(pluginName) || {}
+
+    return {
+      ...defaults,
+      ...(config ? Object.fromEntries(config) : {}),
+    }
+  }
+
+  /**
+   * 清除插件配置
+   */
+  clear(pluginName?: string): void {
+    if (pluginName) {
+      this.configs.delete(pluginName)
+      this.defaults.delete(pluginName)
+    } else {
+      this.configs.clear()
+      this.defaults.clear()
+    }
+  }
+}

package/src/plugin/EventBus.ts

@@ -0,0 +1,77 @@
+/**
+ * 事件总线实现
+ */
+import type { EventHandler } from './types'
+
+type EventMap = Map<string, Set<EventHandler>>
+
+export class EventBus {
+  private listeners: EventMap = new Map()
+
+  /**
+   * 订阅事件
+   */
+  on<T = unknown>(event: string, handler: EventHandler<T>): void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set())
+    }
+    this.listeners.get(event)!.add(handler as EventHandler)
+  }
+
+  /**
+   * 取消订阅
+   */
+  off<T = unknown>(event: string, handler: EventHandler<T>): void {
+    const handlers = this.listeners.get(event)
+    if (handlers) {
+      handlers.delete(handler as EventHandler)
+    }
+  }
+
+  /**
+   * 发布事件
+   */
+  emit<T = unknown>(event: string, data: T): void {
+    const handlers = this.listeners.get(event)
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data)
+        } catch (error) {
+          console.error(`[EventBus] Error in handler for "${event}":`, error)
+        }
+      })
+    }
+  }
+
+  /**
+   * 订阅一次性事件
+   *
+   * 注册一个仅在事件首次触发时执行的回调。回调执行后会自动从监听队列中移除，
+   * 确保后续相同事件的 emit 不会再触发该逻辑。
+   *
+   * @param event - 事件名称
+   * @param handler - 待执行的回调函数
+   */
+  once<T = unknown>(event: string, handler: EventHandler<T>): void {
+    const wrapper: EventHandler<T> = (data) => {
+      this.off(event, wrapper)
+      handler(data)
+    }
+    this.on(event, wrapper)
+  }
+
+  /**
+   * 清除所有事件监听
+   */
+  clear(): void {
+    this.listeners.clear()
+  }
+
+  /**
+   * 获取事件的监听器数量
+   */
+  listenerCount(event: string): number {
+    return this.listeners.get(event)?.size ?? 0
+  }
+}

package/src/plugin/HookSystem.ts

@@ -0,0 +1,106 @@
+/**
+ * Hook 钩子系统实现
+ */
+import type { HookCallOptions, HookDescriptor, HookFn } from './types'
+
+export class HookSystem {
+  private hooks: Map<string, HookDescriptor[]> = new Map()
+
+  /**
+   * 注册钩子
+   */
+  tap<T = unknown, R = unknown>(
+    hookName: string,
+    fn: HookFn<T, R>,
+    priority = 0
+  ): void {
+    if (!this.hooks.has(hookName)) {
+      this.hooks.set(hookName, [])
+    }
+
+    const descriptors = this.hooks.get(hookName)!
+    descriptors.push({ name: hookName, fn: fn as HookFn, priority })
+
+    // 按优先级排序（数字小的先执行）
+    descriptors.sort((a, b) => a.priority - b.priority)
+  }
+
+  /**
+   * 移除钩子
+   */
+  untap(hookName: string, fn: HookFn): void {
+    const descriptors = this.hooks.get(hookName)
+    if (descriptors) {
+      const index = descriptors.findIndex((d) => d.fn === fn)
+      if (index !== -1) {
+        descriptors.splice(index, 1)
+      }
+    }
+  }
+
+  /**
+   * 触发钩子（异步）
+   */
+  async call<T = unknown, R = unknown>(
+    hookName: string,
+    context: T,
+    options?: HookCallOptions
+  ): Promise<R[]> {
+    const descriptors = this.hooks.get(hookName)
+    if (!descriptors || descriptors.length === 0) {
+      return []
+    }
+
+    const results: R[] = []
+    for (const { fn } of descriptors) {
+      try {
+        const result = await fn(context)
+        results.push(result as R)
+      } catch (error) {
+        console.error(`[HookSystem] Error in hook "${hookName}":`, error)
+        if (options?.throwOnError) {
+          throw error
+        }
+      }
+    }
+    return results
+  }
+
+  /**
+   * 触发钩子（同步）
+   */
+  callSync<T = unknown, R = unknown>(hookName: string, context: T, options?: HookCallOptions): R[] {
+    const descriptors = this.hooks.get(hookName)
+    if (!descriptors || descriptors.length === 0) {
+      return []
+    }
+
+    const results: R[] = []
+    for (const { fn } of descriptors) {
+      try {
+        const result = fn(context) as R
+        results.push(result)
+      } catch (error) {
+        console.error(`[HookSystem] Error in hook "${hookName}":`, error)
+        if (options?.throwOnError) {
+          throw error
+        }
+      }
+    }
+    return results
+  }
+
+  /**
+   * 清除所有钩子
+   */
+  clear(): void {
+    this.hooks.clear()
+  }
+
+  /**
+   * 获取钩子数量
+   */
+  hookCount(hookName: string): number {
+    return this.hooks.get(hookName)?.length ?? 0
+  }
+}