@363045841yyt/klinechart-core 0.8.7 → 0.8.9

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

@@ -1,7 +1,12 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi, beforeEach } from 'vitest'
 import { IndicatorRegistry } from '../indicatorRegistry'
+import { clearRegisteredIndicatorDefinitionsForTest } from '../indicatorDefinitionRegistry'
 import type { IndicatorMetadata } from '../indicatorMetadata'
 
+beforeEach(() => {
+  clearRegisteredIndicatorDefinitionsForTest()
+})
+
 function createMeta(overrides: Partial<IndicatorMetadata> = {}): IndicatorMetadata {
   return {
     name: 'rsi',
@@ -17,7 +22,7 @@ function createMeta(overrides: Partial<IndicatorMetadata> = {}): IndicatorMetada
 
 describe('IndicatorRegistry', () => {
   it('resolves indicators by name, displayName, aliases, and case-insensitive ids', () => {
-    const registry = new IndicatorRegistry()
+    const registry = new IndicatorRegistry(false)
     const meta = createMeta()
 
     registry.register(meta)
@@ -30,7 +35,7 @@ describe('IndicatorRegistry', () => {
   })
 
   it('throws for missing required metadata fields', () => {
-    const registry = new IndicatorRegistry()
+    const registry = new IndicatorRegistry(false)
 
     expect(() => registry.register(createMeta({ name: '' }))).toThrow('Indicator name is required')
     expect(() => registry.register(createMeta({ displayName: '' }))).toThrow("displayName is required")
@@ -38,7 +43,7 @@ describe('IndicatorRegistry', () => {
   })
 
   it('replaces old aliases when unregistering', () => {
-    const registry = new IndicatorRegistry()
+    const registry = new IndicatorRegistry(false)
     const meta = createMeta()
 
     registry.register(meta)
@@ -51,7 +56,7 @@ describe('IndicatorRegistry', () => {
   })
 
   it('returns required metadata or throws a descriptive error', () => {
-    const registry = new IndicatorRegistry()
+    const registry = new IndicatorRegistry(false)
     const meta = createMeta()
 
     registry.register(meta)

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

@@ -1,11 +1,11 @@
 import { describe, it, expect, vi, beforeEach, beforeAll } from 'vitest'
 import { IndicatorScheduler } from '../scheduler'
 import { getBuiltinIndicatorDefinitions, loadBuiltinIndicators } from '../registerBuiltins'
-import { MA_STATE_KEY, EMPTY_MA_STATE, type MARenderState } from '../maState'
-import { BOLL_STATE_KEY, EMPTY_BOLL_STATE, type BOLLRenderState } from '../bollState'
-import { EXPMA_STATE_KEY, EMPTY_EXPMA_STATE, type EXPMARenderState } from '../expmaState'
-import { ENE_STATE_KEY, EMPTY_ENE_STATE, type ENERenderState } from '../eneState'
-import { createRSIStateKey, EMPTY_RSI_STATE, type RSIRenderState } from '../rsiState'
+import { MA_STATE_KEY, EMPTY_MA_STATE, type MARenderState } from '../state/maState'
+import { BOLL_STATE_KEY, EMPTY_BOLL_STATE, type BOLLRenderState } from '../state/bollState'
+import { EXPMA_STATE_KEY, EMPTY_EXPMA_STATE, type EXPMARenderState } from '../state/expmaState'
+import { ENE_STATE_KEY, EMPTY_ENE_STATE, type ENERenderState } from '../state/eneState'
+import { createRSIStateKey, EMPTY_RSI_STATE, type RSIRenderState } from '../state/rsiState'
 import type { IndicatorMetadata } from '../indicatorMetadata'
 import type { KLineData } from '@/types/price'
 import type { PluginHost } from '@/plugin'
@@ -131,7 +131,7 @@ describe('IndicatorScheduler', () => {
   let mockHost: PluginHost
 
   beforeEach(() => {
-    scheduler = new IndicatorScheduler()
+    scheduler = new IndicatorScheduler(false)
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
     registerTestIndicators(scheduler)
@@ -144,7 +144,7 @@ describe('IndicatorScheduler', () => {
     })
 
     it('should accept plugin host', () => {
-      const newScheduler = new IndicatorScheduler()
+      const newScheduler = new IndicatorScheduler(false)
       newScheduler.setPluginHost(mockHost)
       // Should not throw
       expect(() => newScheduler.recompute()).not.toThrow()
@@ -426,7 +426,7 @@ describe('BOLL State in scheduler', () => {
   let mockHost: PluginHost
 
   beforeEach(() => {
-    scheduler = new IndicatorScheduler()
+    scheduler = new IndicatorScheduler(false)
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
     registerTestIndicators(scheduler)
@@ -509,7 +509,7 @@ describe('EXPMA State in scheduler', () => {
   let mockHost: PluginHost
 
   beforeEach(() => {
-    scheduler = new IndicatorScheduler()
+    scheduler = new IndicatorScheduler(false)
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
     registerTestIndicators(scheduler)
@@ -563,7 +563,7 @@ describe('ENE State in scheduler', () => {
   let mockHost: PluginHost
 
   beforeEach(() => {
-    scheduler = new IndicatorScheduler()
+    scheduler = new IndicatorScheduler(false)
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
     registerTestIndicators(scheduler)
@@ -620,7 +620,7 @@ describe('Per-indicator dirty flags', () => {
   let mockHost: PluginHost
 
   beforeEach(() => {
-    scheduler = new IndicatorScheduler()
+    scheduler = new IndicatorScheduler(false)
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
     registerTestIndicators(scheduler)
@@ -769,7 +769,7 @@ describe('RSI State in scheduler', () => {
   let mockHost: PluginHost
 
   beforeEach(() => {
-    scheduler = new IndicatorScheduler()
+    scheduler = new IndicatorScheduler(false)
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
     registerTestIndicators(scheduler)

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

@@ -9,30 +9,64 @@ import {
 } from '../soa'
 import {
   calcBOLLData,
-  calcBOLLDataSoA,
   calcEXPMAData,
-  calcEXPMADataSoA,
   calcENEData,
-  calcENEDataSoA,
   calcMAData,
-  calcMADataSoA,
   calcRSIData,
-  calcRSIDataSoA,
   calcCCIData,
-  calcCCIDataSoA,
   calcSTOCHData,
-  calcSTOCHDataSoA,
   calcMOMData,
-  calcMOMDataSoA,
   calcWMSRData,
-  calcWMSRDataSoA,
   calcKSTData,
-  calcKSTDataSoA,
   calcFASTKData,
-  calcFASTKDataSoA,
   calcMACDData,
-  calcMACDDataSoA,
 } from '../calculators'
+import type {
+  BOLLPoint,
+  EXPMAPoint,
+  ENEPoint,
+  STOCHPoint,
+  KSTPoint,
+  MACDPoint,
+} from '../calculators'
+
+// SoA wrapper functions (test-only — convert SoA → AoS before computing)
+function calcBOLLDataSoA(layout: KLineSoALayout, period: number, multiplier: number): BOLLPoint[] {
+  return calcBOLLData(SharedKLineBuffer.toKLineData(layout), period, multiplier)
+}
+function calcEXPMADataSoA(layout: KLineSoALayout, fastPeriod: number, slowPeriod: number): EXPMAPoint[] {
+  return calcEXPMAData(SharedKLineBuffer.toKLineData(layout), fastPeriod, slowPeriod)
+}
+function calcENEDataSoA(layout: KLineSoALayout, period: number, deviation: number): ENEPoint[] {
+  return calcENEData(SharedKLineBuffer.toKLineData(layout), period, deviation)
+}
+function calcMADataSoA(layout: KLineSoALayout, period: number): (number | undefined)[] {
+  return calcMAData(SharedKLineBuffer.toKLineData(layout), period)
+}
+function calcRSIDataSoA(layout: KLineSoALayout, period: number): (number | undefined)[] {
+  return calcRSIData(SharedKLineBuffer.toKLineData(layout), period)
+}
+function calcCCIDataSoA(layout: KLineSoALayout, period: number): (number | undefined)[] {
+  return calcCCIData(SharedKLineBuffer.toKLineData(layout), period)
+}
+function calcSTOCHDataSoA(layout: KLineSoALayout, n: number, m: number): STOCHPoint[] {
+  return calcSTOCHData(SharedKLineBuffer.toKLineData(layout), n, m)
+}
+function calcMOMDataSoA(layout: KLineSoALayout, period: number): (number | undefined)[] {
+  return calcMOMData(SharedKLineBuffer.toKLineData(layout), period)
+}
+function calcWMSRDataSoA(layout: KLineSoALayout, period: number): (number | undefined)[] {
+  return calcWMSRData(SharedKLineBuffer.toKLineData(layout), period)
+}
+function calcKSTDataSoA(layout: KLineSoALayout, roc1: number, roc2: number, roc3: number, roc4: number, signalPeriod: number): KSTPoint[] {
+  return calcKSTData(SharedKLineBuffer.toKLineData(layout), roc1, roc2, roc3, roc4, signalPeriod)
+}
+function calcFASTKDataSoA(layout: KLineSoALayout, period: number): (number | undefined)[] {
+  return calcFASTKData(SharedKLineBuffer.toKLineData(layout), period)
+}
+function calcMACDDataSoA(layout: KLineSoALayout, fastPeriod: number, slowPeriod: number, signalPeriod: number): MACDPoint[] {
+  return calcMACDData(SharedKLineBuffer.toKLineData(layout), fastPeriod, slowPeriod, signalPeriod)
+}
 
 /**
  * 生成测试用的 K线数据

package/src/engine/indicators/calculators/_shared.ts

@@ -0,0 +1,44 @@
+export function _computeEMASeries(values: (number | undefined)[], period: number): (number | undefined)[] {
+    const n = values.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return result
+
+    const alpha = 2 / (period + 1)
+
+    let i = 0
+    while (i < n && values[i] === undefined) i++
+    if (i >= n) return result
+
+    let ema = values[i]!
+    result[i] = ema
+    for (let t = i + 1; t < n; t++) {
+        const v = values[t]
+        if (v === undefined) continue
+        ema = v * alpha + ema * (1 - alpha)
+        result[t] = ema
+    }
+    return result
+}
+
+export function _computeWMAOnNumbers(values: (number | undefined)[], period: number): (number | undefined)[] {
+    const n = values.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || n < period) return result
+
+    const denom = (period * (period + 1)) / 2
+
+    for (let t = period - 1; t < n; t++) {
+        let sw = 0
+        let valid = true
+        for (let k = 0; k < period; k++) {
+            const v = values[t - period + 1 + k]
+            if (v === undefined) {
+                valid = false
+                break
+            }
+            sw += (k + 1) * v
+        }
+        if (valid) result[t] = sw / denom
+    }
+    return result
+}

package/src/engine/indicators/calculators/bands.ts

@@ -0,0 +1,365 @@
+import type { KLineData } from '../../../types/price'
+import { _computeEMASeries } from './_shared'
+import { calcATRData } from './volatility'
+
+export interface BOLLPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcBOLLData(
+    data: KLineData[],
+    period: number,
+    multiplier: number
+): BOLLPoint[] {
+    const result: BOLLPoint[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    let sum = 0
+    const window: number[] = []
+
+    for (let i = 0; i < period; i++) {
+        const item = data[i]
+        if (!item) return result
+        const close = item.close
+        window.push(close)
+        sum += close
+    }
+
+    for (let i = period - 1; i < data.length; i++) {
+        const item = data[i]
+        if (!item) continue
+
+        if (i >= period) {
+            const oldVal = window.shift()
+            if (oldVal !== undefined) sum -= oldVal
+            const close = item.close
+            window.push(close)
+            sum += close
+        }
+
+        const ma = sum / period
+
+        let variance = 0
+        for (let j = 0; j < period; j++) {
+            const wVal = window[j]
+            if (wVal !== undefined) {
+                variance += Math.pow(wVal - ma, 2)
+            }
+        }
+        const stdDev = Math.sqrt(variance / period)
+
+        result[i] = {
+            upper: ma + multiplier * stdDev,
+            middle: ma,
+            lower: ma - multiplier * stdDev,
+        }
+    }
+
+    return result
+}
+
+export interface ENEPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcENEData(
+    data: KLineData[],
+    period: number,
+    deviation: number
+): ENEPoint[] {
+    const result: ENEPoint[] = new Array(data.length)
+
+    if (data.length < period) return result
+
+    let sum = 0
+
+    for (let i = 0; i < period; i++) {
+        const item = data[i]
+        if (!item) return result
+        sum += item.close
+    }
+
+    const firstMA = sum / period
+    const firstDeviation = deviation / 100
+    result[period - 1] = {
+        upper: firstMA * (1 + firstDeviation),
+        middle: firstMA,
+        lower: firstMA * (1 - firstDeviation),
+    }
+
+    for (let i = period; i < data.length; i++) {
+        const prevItem = data[i - period]
+        const currItem = data[i]
+        if (!prevItem || !currItem) continue
+
+        sum = sum - prevItem.close + currItem.close
+        const ma = sum / period
+        const dev = deviation / 100
+
+        result[i] = {
+            upper: ma * (1 + dev),
+            middle: ma,
+            lower: ma * (1 - dev),
+        }
+    }
+
+    return result
+}
+
+export interface SARPoint {
+    value: number
+    trend: 'up' | 'down'
+}
+
+export function calcSARData(
+    data: KLineData[],
+    step: number,
+    maxStep: number,
+): (SARPoint | undefined)[] {
+    const n = data.length
+    const result: (SARPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n < 2 || step <= 0 || maxStep <= 0) return result
+
+    let trend: 'up' | 'down' = data[1]!.close >= data[0]!.close ? 'up' : 'down'
+    let sar = trend === 'up' ? data[0]!.low : data[0]!.high
+    let ep = trend === 'up' ? data[0]!.high : data[0]!.low
+    let af = step
+
+    result[0] = { value: sar, trend }
+
+    for (let t = 1; t < n; t++) {
+        const bar = data[t]!
+        sar = sar + af * (ep - sar)
+
+        if (trend === 'up') {
+            const cap1 = data[t - 1]!.low
+            const cap2 = t >= 2 ? data[t - 2]!.low : cap1
+            sar = Math.min(sar, cap1, cap2)
+        } else {
+            const cap1 = data[t - 1]!.high
+            const cap2 = t >= 2 ? data[t - 2]!.high : cap1
+            sar = Math.max(sar, cap1, cap2)
+        }
+
+        if (trend === 'up' && bar.low < sar) {
+            trend = 'down'
+            sar = ep
+            ep = bar.low
+            af = step
+        } else if (trend === 'down' && bar.high > sar) {
+            trend = 'up'
+            sar = ep
+            ep = bar.high
+            af = step
+        } else {
+            if (trend === 'up' && bar.high > ep) {
+                ep = bar.high
+                af = Math.min(af + step, maxStep)
+            } else if (trend === 'down' && bar.low < ep) {
+                ep = bar.low
+                af = Math.min(af + step, maxStep)
+            }
+        }
+
+        result[t] = { value: sar, trend }
+    }
+
+    return result
+}
+
+export interface SuperTrendPoint {
+    value: number
+    trend: 'up' | 'down'
+}
+
+export function calcSuperTrendData(
+    data: KLineData[],
+    atrPeriod: number,
+    multiplier: number,
+): (SuperTrendPoint | undefined)[] {
+    const n = data.length
+    const result: (SuperTrendPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || atrPeriod <= 0 || multiplier <= 0) return result
+
+    const atr = calcATRData(data, atrPeriod)
+
+    let trend: 'up' | 'down' = 'up'
+    let prevUpper = Infinity
+    let prevLower = -Infinity
+
+    for (let t = 0; t < n; t++) {
+        const bar = data[t]!
+        const a = atr[t]
+        if (a === undefined) continue
+
+        const hl2 = (bar.high + bar.low) / 2
+        const upperBasic = hl2 + multiplier * a
+        const lowerBasic = hl2 - multiplier * a
+
+        const prevClose = t > 0 ? data[t - 1]!.close : bar.close
+        const upper = (upperBasic < prevUpper || prevClose > prevUpper) ? upperBasic : prevUpper
+        const lower = (lowerBasic > prevLower || prevClose < prevLower) ? lowerBasic : prevLower
+
+        if (trend === 'up' && bar.close < lower) {
+            trend = 'down'
+        } else if (trend === 'down' && bar.close > upper) {
+            trend = 'up'
+        }
+
+        result[t] = { value: trend === 'up' ? lower : upper, trend }
+
+        prevUpper = upper
+        prevLower = lower
+    }
+
+    return result
+}
+
+export interface KeltnerPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcKeltnerData(
+    data: KLineData[],
+    emaPeriod: number,
+    atrPeriod: number,
+    multiplier: number,
+): (KeltnerPoint | undefined)[] {
+    const n = data.length
+    const result: (KeltnerPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || emaPeriod <= 0 || atrPeriod <= 0) return result
+
+    const closes = new Array<number | undefined>(n)
+    for (let i = 0; i < n; i++) closes[i] = data[i]!.close
+
+    const ema = _computeEMASeries(closes, emaPeriod)
+    const atr = calcATRData(data, atrPeriod)
+
+    for (let t = 0; t < n; t++) {
+        const m = ema[t]
+        const a = atr[t]
+        if (m === undefined || a === undefined) continue
+        result[t] = {
+            upper: m + multiplier * a,
+            middle: m,
+            lower: m - multiplier * a,
+        }
+    }
+    return result
+}
+
+export interface DonchianPoint {
+    upper: number
+    middle: number
+    lower: number
+}
+
+export function calcDonchianData(
+    data: KLineData[],
+    period: number,
+): (DonchianPoint | undefined)[] {
+    const n = data.length
+    const result: (DonchianPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || n < period) return result
+
+    for (let t = period - 1; t < n; t++) {
+        let hi = -Infinity
+        let lo = Infinity
+        for (let k = 0; k < period; k++) {
+            const bar = data[t - k]!
+            if (bar.high > hi) hi = bar.high
+            if (bar.low < lo) lo = bar.low
+        }
+        result[t] = { upper: hi, middle: (hi + lo) / 2, lower: lo }
+    }
+    return result
+}
+
+export interface IchimokuPoint {
+    tenkan?: number
+    kijun?: number
+    spanA?: number
+    spanB?: number
+    chikou?: number
+}
+
+function _rollingMidline(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n < period || period <= 0) return result
+    for (let t = period - 1; t < n; t++) {
+        let hi = -Infinity
+        let lo = Infinity
+        for (let k = 0; k < period; k++) {
+            const bar = data[t - k]!
+            if (bar.high > hi) hi = bar.high
+            if (bar.low < lo) lo = bar.low
+        }
+        result[t] = (hi + lo) / 2
+    }
+    return result
+}
+
+export function calcIchimokuData(
+    data: KLineData[],
+    tenkanPeriod: number,
+    kijunPeriod: number,
+    spanBPeriod: number,
+    displacement: number,
+): (IchimokuPoint | undefined)[] {
+    const n = data.length
+    const totalLen = n + displacement
+    const result: (IchimokuPoint | undefined)[] = new Array(totalLen).fill(undefined)
+    if (n === 0 || tenkanPeriod <= 0 || kijunPeriod <= 0 || spanBPeriod <= 0) {
+        return result.slice(0, n)
+    }
+
+    const tenkan = _rollingMidline(data, tenkanPeriod)
+    const kijun = _rollingMidline(data, kijunPeriod)
+    const spanBSource = _rollingMidline(data, spanBPeriod)
+
+    for (let t = 0; t < n; t++) {
+        const point: IchimokuPoint = {}
+        if (tenkan[t] !== undefined) point.tenkan = tenkan[t]
+        if (kijun[t] !== undefined) point.kijun = kijun[t]
+
+        const src = t - displacement
+        if (src >= 0) {
+            if (tenkan[src] !== undefined && kijun[src] !== undefined) {
+                point.spanA = (tenkan[src]! + kijun[src]!) / 2
+            }
+            if (spanBSource[src] !== undefined) {
+                point.spanB = spanBSource[src]
+            }
+        }
+
+        const future = t + displacement
+        if (future < n) point.chikou = data[future]!.close
+
+        result[t] = point
+    }
+
+    for (let f = 0; f < displacement; f++) {
+        const t = n + f
+        const src = t - displacement
+        const point: IchimokuPoint = {}
+        if (src >= 0 && src < n) {
+            if (tenkan[src] !== undefined && kijun[src] !== undefined) {
+                point.spanA = (tenkan[src]! + kijun[src]!) / 2
+            }
+            if (spanBSource[src] !== undefined) {
+                point.spanB = spanBSource[src]
+            }
+        }
+        result[t] = point
+    }
+
+    return result
+}

package/src/engine/indicators/calculators/index.ts

@@ -0,0 +1,37 @@
+export type { MAFlags } from './movingAverages'
+export { DEFAULT_MA_PERIODS, calcMAData } from './movingAverages'
+export type { EXPMAPoint } from './movingAverages'
+export { calcEXPMAData, calcWMAData, calcDEMAData, calcTEMAData, calcHMAData, calcKAMAData } from './movingAverages'
+
+export type { BOLLPoint } from './bands'
+export { calcBOLLData } from './bands'
+export type { ENEPoint } from './bands'
+export { calcENEData } from './bands'
+export type { SARPoint } from './bands'
+export { calcSARData } from './bands'
+export type { SuperTrendPoint } from './bands'
+export { calcSuperTrendData } from './bands'
+export type { KeltnerPoint } from './bands'
+export { calcKeltnerData } from './bands'
+export type { DonchianPoint } from './bands'
+export { calcDonchianData } from './bands'
+export type { IchimokuPoint } from './bands'
+export { calcIchimokuData } from './bands'
+
+export { calcRSIData, calcCCIData } from './oscillators'
+export type { STOCHPoint } from './oscillators'
+export { calcSTOCHData, calcMOMData, calcWMSRData } from './oscillators'
+export type { KSTPoint, MACDPoint } from './oscillators'
+export { calcKSTData, calcFASTKData, calcMACDData } from './oscillators'
+export { calcROCData } from './oscillators'
+export type { TRIXResult } from './oscillators'
+export { calcTRIXData } from './oscillators'
+
+export { calcATRData, calcHVData, calcParkinsonData, calcChaikinVolData } from './volatility'
+
+export { calcVMAData, calcOBVData, calcPVTData, calcVWAPData, calcCMFData, calcMFIData } from './volume'
+export type { VolumeProfileBin, VolumeProfileResult } from './volume'
+export { calcVolumeProfileData } from './volume'
+
+export type { PivotPoint, FibPoint, SwingPoint, StructureEventKind, StructureEvent, StructureSnapshot, ZoneKind, Zone } from './patterns'
+export { calcPivotData, calcFibData, calcStructureData, calcZonesData } from './patterns'