@363045841yyt/klinechart-core 0.7.3 → 0.7.5-alpha.2

package/src/engine/theme/fonts.ts

@@ -1,20 +1,20 @@
-/**
- * 图表字体配置
- * 字体栈：Trebuchet MS (Windows系统字体) -> Roboto -> Ubuntu -> 通用无衬线字体
- * 通过 Google Fonts CDN 加载 Roboto 和 Ubuntu
- */
-
-/** 数字和文本的标准字体栈 */
-export const FONT_FAMILY = '"Trebuchet MS", Roboto, Ubuntu, sans-serif'
-
-/** 获取指定字号的字体字符串，用于 Canvas ctx.font */
-export function getFont(size: number, options?: { bold?: boolean }): string {
-    const weight = options?.bold ? 'bold ' : ''
-    return `${weight}${size}px ${FONT_FAMILY}`
-}
-
-export function setCanvasFont(ctx: CanvasRenderingContext2D, font: string): void {
-    if (ctx.font !== font) {
-        ctx.font = font
-    }
-}
+/**
+ * 图表字体配置
+ * 字体栈：Trebuchet MS (Windows系统字体) -> Roboto -> Ubuntu -> 通用无衬线字体
+ * 通过 Google Fonts CDN 加载 Roboto 和 Ubuntu
+ */
+
+/** 数字和文本的标准字体栈 */
+export const FONT_FAMILY = '"Trebuchet MS", Roboto, Ubuntu, sans-serif'
+
+/** 获取指定字号的字体字符串，用于 Canvas ctx.font */
+export function getFont(size: number, options?: { bold?: boolean }): string {
+    const weight = options?.bold ? 'bold ' : ''
+    return `${weight}${size}px ${FONT_FAMILY}`
+}
+
+export function setCanvasFont(ctx: CanvasRenderingContext2D, font: string): void {
+    if (ctx.font !== font) {
+        ctx.font = font
+    }
+}

package/src/engine/utils/klineConfig.ts

@@ -1,49 +1,49 @@
-/**
- * K 线物理像素配置工具函数
- * 用于统一渲染、交互、视口计算的坐标系统
- */
-
-/**
- * 计算奇数化后的 K 线宽度（物理像素），确保影线能完美居中显示
- * @param kWidth K 线宽度（逻辑像素）
- * @param dpr 设备像素比
- * @returns 奇数化后的物理像素宽度
- */
-export function calcKWidthPx(kWidth: number, dpr: number): number {
-    let kWidthPx = Math.round(kWidth * dpr)
-    if (kWidthPx % 2 === 0) {
-        kWidthPx += 1
-    }
-    return Math.max(1, kWidthPx)
-}
-
-/**
- * 获取图表渲染使用的物理像素配置
- * @param kWidth K 线宽度（逻辑像素）
- * @param kGap K 线间隙（逻辑像素）
- * @param dpr 设备像素比
- * @returns 物理像素和逻辑像素的配置对象
- */
-export function getPhysicalKLineConfig(kWidth: number, kGap: number, dpr: number) {
-    const kWidthPx = calcKWidthPx(kWidth, dpr)
-    const kGapPx = Math.round(kGap * dpr)
-    const unitPx = kWidthPx + kGapPx
-    const startXPx = kGapPx
-
-    // 转回逻辑像素（供需要逻辑像素的地方使用）
-    const kWidthLogical = kWidthPx / dpr
-    const kGapLogical = kGapPx / dpr
-    const unitLogical = unitPx / dpr
-    const startXLogical = startXPx / dpr
-
-    return {
-        kWidthPx,
-        kGapPx,
-        unitPx,
-        startXPx,
-        kWidthLogical,
-        kGapLogical,
-        unitLogical,
-        startXLogical,
-    }
-}
+/**
+ * K 线物理像素配置工具函数
+ * 用于统一渲染、交互、视口计算的坐标系统
+ */
+
+/**
+ * 计算奇数化后的 K 线宽度（物理像素），确保影线能完美居中显示
+ * @param kWidth K 线宽度（逻辑像素）
+ * @param dpr 设备像素比
+ * @returns 奇数化后的物理像素宽度
+ */
+export function calcKWidthPx(kWidth: number, dpr: number): number {
+    let kWidthPx = Math.round(kWidth * dpr)
+    if (kWidthPx % 2 === 0) {
+        kWidthPx += 1
+    }
+    return Math.max(1, kWidthPx)
+}
+
+/**
+ * 获取图表渲染使用的物理像素配置
+ * @param kWidth K 线宽度（逻辑像素）
+ * @param kGap K 线间隙（逻辑像素）
+ * @param dpr 设备像素比
+ * @returns 物理像素和逻辑像素的配置对象
+ */
+export function getPhysicalKLineConfig(kWidth: number, kGap: number, dpr: number) {
+    const kWidthPx = calcKWidthPx(kWidth, dpr)
+    const kGapPx = Math.round(kGap * dpr)
+    const unitPx = kWidthPx + kGapPx
+    const startXPx = kGapPx
+
+    // 转回逻辑像素（供需要逻辑像素的地方使用）
+    const kWidthLogical = kWidthPx / dpr
+    const kGapLogical = kGapPx / dpr
+    const unitLogical = unitPx / dpr
+    const startXLogical = startXPx / dpr
+
+    return {
+        kWidthPx,
+        kGapPx,
+        unitPx,
+        startXPx,
+        kWidthLogical,
+        kGapLogical,
+        unitLogical,
+        startXLogical,
+    }
+}

package/src/engine/utils/tickCount.ts

@@ -1,11 +1,11 @@
-/**
- * 根据面板高度计算网格线/价格标签数量
- * 刻度间距固定约 60px
- * @param height 面板高度（逻辑像素）
- * @param isMain 是否为主图面板（暂未使用，保留参数兼容）
- * @returns tick 数量
- */
-export function calculateTickCount(height: number, isMain?: boolean): number {
-    const tickSpacing = 60  // 固定间距
-    return Math.max(3, Math.round(height / tickSpacing) + 1)
-}
+/**
+ * 根据面板高度计算网格线/价格标签数量
+ * 刻度间距固定约 60px
+ * @param height 面板高度（逻辑像素）
+ * @param isMain 是否为主图面板（暂未使用，保留参数兼容）
+ * @returns tick 数量
+ */
+export function calculateTickCount(height: number, isMain?: boolean): number {
+    const tickSpacing = 60  // 固定间距
+    return Math.max(3, Math.round(height / tickSpacing) + 1)
+}

package/src/engine/utils/tickPosition.ts

@@ -1,214 +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
-}
+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
+}