@363045841yyt/klinechart-core 0.8.12 → 0.8.13-alpha.0

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

@@ -1,110 +1,126 @@
 import { describe, it, expect } from 'vitest'
 import { calcStructureData } from '../calculators'
 import type { KLineData } from '@/types/price'
-import {
-    empty,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-} from './__fixtures__/synthetic'
+import { empty, pureUptrend, pureDowntrend, sideways } from './__fixtures__/synthetic'
 
 // Build a fixture with a clear swing high, swing low, and breakout
 function buildPyramidFixture(): KLineData[] {
-    const result: KLineData[] = []
-    let close = 100
-    const T0 = 1_700_000_000_000
-    // Up 0..9
-    for (let i = 0; i < 10; i++) {
-        close += 1
-        result.push({ timestamp: T0 + i * 60000, open: close, high: close + 0.5, low: close - 0.5, close, volume: 100 })
-    }
-    // Down 10..19 (creates swing high at ~bar 9)
-    for (let i = 10; i < 20; i++) {
-        close -= 1
-        result.push({ timestamp: T0 + i * 60000, open: close, high: close + 0.5, low: close - 0.5, close, volume: 100 })
-    }
-    // Up again to break swing high (creates BOS at the breakout bar)
-    for (let i = 20; i < 35; i++) {
-        close += 1
-        result.push({ timestamp: T0 + i * 60000, open: close, high: close + 0.5, low: close - 0.5, close, volume: 100 })
-    }
-    return result
+  const result: KLineData[] = []
+  let close = 100
+  const T0 = 1_700_000_000_000
+  // Up 0..9
+  for (let i = 0; i < 10; i++) {
+    close += 1
+    result.push({
+      timestamp: T0 + i * 60000,
+      open: close,
+      high: close + 0.5,
+      low: close - 0.5,
+      close,
+      volume: 100,
+    })
+  }
+  // Down 10..19 (creates swing high at ~bar 9)
+  for (let i = 10; i < 20; i++) {
+    close -= 1
+    result.push({
+      timestamp: T0 + i * 60000,
+      open: close,
+      high: close + 0.5,
+      low: close - 0.5,
+      close,
+      volume: 100,
+    })
+  }
+  // Up again to break swing high (creates BOS at the breakout bar)
+  for (let i = 20; i < 35; i++) {
+    close += 1
+    result.push({
+      timestamp: T0 + i * 60000,
+      open: close,
+      high: close + 0.5,
+      low: close - 0.5,
+      close,
+      volume: 100,
+    })
+  }
+  return result
 }
 
 describe('calcStructureData', () => {
-    it('empty data → empty snapshot', () => {
-        const snap = calcStructureData(empty, 2, 2, 'close')
-        expect(snap.swings).toEqual([])
-        expect(snap.events).toEqual([])
-        expect(snap.trend).toBe('range')
-    })
+  it('empty data → empty snapshot', () => {
+    const snap = calcStructureData(empty, 2, 2, 'close')
+    expect(snap.swings).toEqual([])
+    expect(snap.events).toEqual([])
+    expect(snap.trend).toBe('range')
+  })
 
-    it('on pureUptrend (monotonic): no internal swings, no events', () => {
-        const snap = calcStructureData(pureUptrend, 2, 2, 'close')
-        // Monotonic uptrend has no local extrema inside the window
-        expect(snap.swings.length).toBe(0)
-        expect(snap.events.length).toBe(0)
-    })
+  it('on pureUptrend (monotonic): no internal swings, no events', () => {
+    const snap = calcStructureData(pureUptrend, 2, 2, 'close')
+    // Monotonic uptrend has no local extrema inside the window
+    expect(snap.swings.length).toBe(0)
+    expect(snap.events.length).toBe(0)
+  })
 
-    it('on pureDowntrend (monotonic): no internal swings', () => {
-        const snap = calcStructureData(pureDowntrend, 2, 2, 'close')
-        expect(snap.swings.length).toBe(0)
-    })
+  it('on pureDowntrend (monotonic): no internal swings', () => {
+    const snap = calcStructureData(pureDowntrend, 2, 2, 'close')
+    expect(snap.swings.length).toBe(0)
+  })
 
-    it('on pyramid fixture: produces alternating swing highs and lows with valid labels', () => {
-        const data = buildPyramidFixture()
-        const snap = calcStructureData(data, 2, 2, 'close')
-        expect(snap.swings.length).toBeGreaterThan(0)
-        for (const s of snap.swings) {
-            expect(['HH', 'HL', 'LH', 'LL']).toContain(s.label)
-        }
-    })
+  it('on pyramid fixture: produces alternating swing highs and lows with valid labels', () => {
+    const data = buildPyramidFixture()
+    const snap = calcStructureData(data, 2, 2, 'close')
+    expect(snap.swings.length).toBeGreaterThan(0)
+    for (const s of snap.swings) {
+      expect(['HH', 'HL', 'LH', 'LL']).toContain(s.label)
+    }
+  })
 
-    it('pyramid fixture: detects a BOS when uptrend breaks prior swing high', () => {
-        const data = buildPyramidFixture()
-        const snap = calcStructureData(data, 2, 2, 'close')
-        // Should have at least one swing
-        expect(snap.swings.length).toBeGreaterThan(0)
-        // Should detect a BOS or CHOCH event during the second uptrend
-        const upEvents = snap.events.filter((e) => e.direction === 'up')
-        expect(upEvents.length).toBeGreaterThanOrEqual(1)
-    })
+  it('pyramid fixture: detects a BOS when uptrend breaks prior swing high', () => {
+    const data = buildPyramidFixture()
+    const snap = calcStructureData(data, 2, 2, 'close')
+    // Should have at least one swing
+    expect(snap.swings.length).toBeGreaterThan(0)
+    // Should detect a BOS or CHOCH event during the second uptrend
+    const upEvents = snap.events.filter((e) => e.direction === 'up')
+    expect(upEvents.length).toBeGreaterThanOrEqual(1)
+  })
 
-    it('breakoutSource = wick vs close produces (possibly) different event timing', () => {
-        const data = buildPyramidFixture()
-        const closeSnap = calcStructureData(data, 2, 2, 'close')
-        const wickSnap = calcStructureData(data, 2, 2, 'wick')
-        // Both should produce at least one event; their indices may differ
-        expect(closeSnap.events.length).toBeGreaterThanOrEqual(0)
-        expect(wickSnap.events.length).toBeGreaterThanOrEqual(0)
-    })
+  it('breakoutSource = wick vs close produces (possibly) different event timing', () => {
+    const data = buildPyramidFixture()
+    const closeSnap = calcStructureData(data, 2, 2, 'close')
+    const wickSnap = calcStructureData(data, 2, 2, 'wick')
+    // Both should produce at least one event; their indices may differ
+    expect(closeSnap.events.length).toBeGreaterThanOrEqual(0)
+    expect(wickSnap.events.length).toBeGreaterThanOrEqual(0)
+  })
 
-    it('swing.confirmed is false within rightWindow of latest bar', () => {
-        const data = buildPyramidFixture()
-        const right = 2
-        const snap = calcStructureData(data, 2, right, 'close')
-        for (const s of snap.swings) {
-            if (s.index + right >= data.length) {
-                expect(s.confirmed).toBe(false)
-            } else {
-                expect(s.confirmed).toBe(true)
-            }
-        }
-    })
+  it('swing.confirmed is false within rightWindow of latest bar', () => {
+    const data = buildPyramidFixture()
+    const right = 2
+    const snap = calcStructureData(data, 2, right, 'close')
+    for (const s of snap.swings) {
+      if (s.index + right >= data.length) {
+        expect(s.confirmed).toBe(false)
+      } else {
+        expect(s.confirmed).toBe(true)
+      }
+    }
+  })
 
-    it('extensional consistency on pyramid fixture', () => {
-        const data = buildPyramidFixture()
-        const full = calcStructureData(data, 2, 2, 'close')
-        for (let n = 15; n < data.length; n++) {
-            const partial = calcStructureData(data.slice(0, n), 2, 2, 'close')
-            // Confirmed swings in the prefix should match the full version
-            const fullConfirmedInPrefix = full.swings.filter((s) => s.confirmed && s.index + 2 < n)
-            const partialConfirmed = partial.swings.filter((s) => s.confirmed)
-            for (const fs of fullConfirmedInPrefix) {
-                const match = partialConfirmed.find((s) => s.index === fs.index && s.kind === fs.kind)
-                expect(match).toBeDefined()
-                if (match) expect(match.price).toBeCloseTo(fs.price, 9)
-            }
-        }
-    })
+  it('extensional consistency on pyramid fixture', () => {
+    const data = buildPyramidFixture()
+    const full = calcStructureData(data, 2, 2, 'close')
+    for (let n = 15; n < data.length; n++) {
+      const partial = calcStructureData(data.slice(0, n), 2, 2, 'close')
+      // Confirmed swings in the prefix should match the full version
+      const fullConfirmedInPrefix = full.swings.filter((s) => s.confirmed && s.index + 2 < n)
+      const partialConfirmed = partial.swings.filter((s) => s.confirmed)
+      for (const fs of fullConfirmedInPrefix) {
+        const match = partialConfirmed.find((s) => s.index === fs.index && s.kind === fs.kind)
+        expect(match).toBeDefined()
+        if (match) expect(match.price).toBeCloseTo(fs.price, 9)
+      }
+    }
+  })
 })

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

@@ -1,65 +1,59 @@
 import { describe, it, expect } from 'vitest'
 import { calcSuperTrendData } from '../calculators'
-import {
-    empty,
-    pureUptrend,
-    pureDowntrend,
-    spikeAtBar19,
-    gapUp,
-} from './__fixtures__/synthetic'
+import { empty, pureUptrend, pureDowntrend, spikeAtBar19, gapUp } from './__fixtures__/synthetic'
 
 describe('calcSuperTrendData', () => {
-    it('empty returns empty', () => {
-        expect(calcSuperTrendData(empty, 10, 3)).toEqual([])
-    })
+  it('empty returns empty', () => {
+    expect(calcSuperTrendData(empty, 10, 3)).toEqual([])
+  })
 
-    it('atrPeriod <= 0 returns all undefined', () => {
-        const out = calcSuperTrendData(pureUptrend, 0, 3)
-        for (const v of out) expect(v).toBeUndefined()
-    })
+  it('atrPeriod <= 0 returns all undefined', () => {
+    const out = calcSuperTrendData(pureUptrend, 0, 3)
+    for (const v of out) expect(v).toBeUndefined()
+  })
 
-    it('multiplier <= 0 returns all undefined', () => {
-        const out = calcSuperTrendData(pureUptrend, 10, 0)
-        for (const v of out) expect(v).toBeUndefined()
-    })
+  it('multiplier <= 0 returns all undefined', () => {
+    const out = calcSuperTrendData(pureUptrend, 10, 0)
+    for (const v of out) expect(v).toBeUndefined()
+  })
 
-    it('on pureUptrend SuperTrend trend stays up after warm-up', () => {
-        const out = calcSuperTrendData(pureUptrend, 10, 3)
-        const valid = out.filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
-        expect(valid.length).toBeGreaterThan(5)
-        // All trends should be up since price keeps rising
-        for (const p of valid) {
-            expect(p.trend).toBe('up')
-        }
-    })
+  it('on pureUptrend SuperTrend trend stays up after warm-up', () => {
+    const out = calcSuperTrendData(pureUptrend, 10, 3)
+    const valid = out.filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
+    expect(valid.length).toBeGreaterThan(5)
+    // All trends should be up since price keeps rising
+    for (const p of valid) {
+      expect(p.trend).toBe('up')
+    }
+  })
 
-    it('on pureDowntrend SuperTrend trend stays down', () => {
-        const out = calcSuperTrendData(pureDowntrend, 10, 3)
-        const valid = out.filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
-        // Most of post-warm-up should be down
-        const downCount = valid.filter((p) => p.trend === 'down').length
-        expect(downCount).toBeGreaterThan(valid.length / 2)
-    })
+  it('on pureDowntrend SuperTrend trend stays down', () => {
+    const out = calcSuperTrendData(pureDowntrend, 10, 3)
+    const valid = out.filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
+    // Most of post-warm-up should be down
+    const downCount = valid.filter((p) => p.trend === 'down').length
+    expect(downCount).toBeGreaterThan(valid.length / 2)
+  })
 
-    it('extensional consistency', () => {
-        const full = calcSuperTrendData(gapUp, 10, 3)
-        for (let n = 12; n < gapUp.length; n++) {
-            const partial = calcSuperTrendData(gapUp.slice(0, n), 10, 3)
-            for (let i = 0; i < n; i++) {
-                const f = full[i]
-                const p = partial[i]
-                if (f && p) {
-                    expect(p.value).toBeCloseTo(f.value, 9)
-                    expect(p.trend).toBe(f.trend)
-                }
-            }
+  it('extensional consistency', () => {
+    const full = calcSuperTrendData(gapUp, 10, 3)
+    for (let n = 12; n < gapUp.length; n++) {
+      const partial = calcSuperTrendData(gapUp.slice(0, n), 10, 3)
+      for (let i = 0; i < n; i++) {
+        const f = full[i]
+        const p = partial[i]
+        if (f && p) {
+          expect(p.value).toBeCloseTo(f.value, 9)
+          expect(p.trend).toBe(f.trend)
         }
-    })
+      }
+    }
+  })
 
-    it('trend flips on spike fixture', () => {
-        const out = calcSuperTrendData(spikeAtBar19, 10, 3)
-        const valid = out.filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
-        const trends = new Set(valid.map((p) => p.trend))
-        expect(trends.size).toBeGreaterThanOrEqual(1)
-    })
+  it('trend flips on spike fixture', () => {
+    const out = calcSuperTrendData(spikeAtBar19, 10, 3)
+    const valid = out.filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
+    const trends = new Set(valid.map((p) => p.trend))
+    expect(trends.size).toBeGreaterThanOrEqual(1)
+  })
 })

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

@@ -1,68 +1,66 @@
 import { describe, it, expect } from 'vitest'
 import { calcTEMAData } from '../calculators'
 import {
-    empty,
-    singleBar,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
+  empty,
+  singleBar,
+  constantPrice,
+  pureUptrend,
+  pureDowntrend,
+  sideways,
+  spikeAtBar19,
 } from './__fixtures__/synthetic'
 import { TEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
-import {
-    assertFiniteOrUndefined,
-} from './_propertyAssertions'
+import { assertFiniteOrUndefined } from './_propertyAssertions'
 
 describe('calcTEMAData — Triple Exponential Moving Average', () => {
-    describe('edge cases', () => {
-        it('empty returns empty array', () => {
-            expect(calcTEMAData(empty, 20)).toEqual([])
-        })
+  describe('edge cases', () => {
+    it('empty returns empty array', () => {
+      expect(calcTEMAData(empty, 20)).toEqual([])
+    })
 
-        it('single bar produces a single defined value', () => {
-            const out = calcTEMAData(singleBar, 20)
-            expect(out).toHaveLength(1)
-            expect(out[0]).toBeCloseTo(100, 9)
-        })
+    it('single bar produces a single defined value', () => {
+      const out = calcTEMAData(singleBar, 20)
+      expect(out).toHaveLength(1)
+      expect(out[0]).toBeCloseTo(100, 9)
+    })
 
-        it('period = 0 returns all undefined', () => {
-            const zero = calcTEMAData(pureUptrend, 0)
-            for (const v of zero) expect(v).toBeUndefined()
-        })
+    it('period = 0 returns all undefined', () => {
+      const zero = calcTEMAData(pureUptrend, 0)
+      for (const v of zero) expect(v).toBeUndefined()
     })
+  })
 
-    describe('golden values', () => {
-        it('constantPrice → TEMA(20) = 100 throughout', () => {
-            assertSeriesClose(calcTEMAData(constantPrice, 20), TEMA_GOLDEN.constantPrice!.series)
-        })
+  describe('golden values', () => {
+    it('constantPrice → TEMA(20) = 100 throughout', () => {
+      assertSeriesClose(calcTEMAData(constantPrice, 20), TEMA_GOLDEN.constantPrice!.series)
     })
+  })
 
-    describe('mathematical properties', () => {
-        it('all values finite', () => {
-            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
-                assertFiniteOrUndefined(calcTEMAData(fx, 20), 'TEMA series')
-            }
-        })
+  describe('mathematical properties', () => {
+    it('all values finite', () => {
+      for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+        assertFiniteOrUndefined(calcTEMAData(fx, 20), 'TEMA series')
+      }
+    })
 
-        it('tracks uptrend monotonically once warmed', () => {
-            const out = calcTEMAData(pureUptrend, 20)
-            const tail = out.slice(20).filter((v): v is number => v !== undefined)
-            for (let i = 1; i < tail.length; i++) {
-                expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
-            }
-        })
+    it('tracks uptrend monotonically once warmed', () => {
+      const out = calcTEMAData(pureUptrend, 20)
+      const tail = out.slice(20).filter((v): v is number => v !== undefined)
+      for (let i = 1; i < tail.length; i++) {
+        expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
+      }
+    })
 
-        it('extensional consistency', () => {
-            const full = calcTEMAData(pureUptrend, 20)
-            for (let n = 5; n < pureUptrend.length; n++) {
-                const partial = calcTEMAData(pureUptrend.slice(0, n), 20)
-                for (let i = 0; i < n; i++) {
-                    if (full[i] !== undefined && partial[i] !== undefined) {
-                        expect(partial[i]).toBeCloseTo(full[i]!, 9)
-                    }
-                }
-            }
-        })
+    it('extensional consistency', () => {
+      const full = calcTEMAData(pureUptrend, 20)
+      for (let n = 5; n < pureUptrend.length; n++) {
+        const partial = calcTEMAData(pureUptrend.slice(0, n), 20)
+        for (let i = 0; i < n; i++) {
+          if (full[i] !== undefined && partial[i] !== undefined) {
+            expect(partial[i]).toBeCloseTo(full[i]!, 9)
+          }
+        }
+      }
     })
+  })
 })

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

@@ -1,70 +1,70 @@
 import { describe, it, expect } from 'vitest'
 import { calcTRIXData } from '../calculators'
 import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
+  empty,
+  constantPrice,
+  pureUptrend,
+  pureDowntrend,
+  sideways,
 } from './__fixtures__/synthetic'
 
 describe('calcTRIXData', () => {
-    it('empty returns empty result', () => {
-        const out = calcTRIXData(empty, 15, 9)
-        expect(out.series).toEqual([])
-        expect(out.signalSeries).toEqual([])
-    })
+  it('empty returns empty result', () => {
+    const out = calcTRIXData(empty, 15, 9)
+    expect(out.series).toEqual([])
+    expect(out.signalSeries).toEqual([])
+  })
 
-    it('period <= 0 returns empty series', () => {
-        const out = calcTRIXData(pureUptrend, 0, 9)
-        for (const v of out.series) expect(v).toBeUndefined()
-    })
+  it('period <= 0 returns empty series', () => {
+    const out = calcTRIXData(pureUptrend, 0, 9)
+    for (const v of out.series) expect(v).toBeUndefined()
+  })
 
-    it('on constantPrice TRIX = 0 (constant EMA3 → no change)', () => {
-        const out = calcTRIXData(constantPrice, 15, 9)
-        for (let t = 1; t < out.series.length; t++) {
-            if (out.series[t] !== undefined) expect(out.series[t]).toBeCloseTo(0, 9)
-        }
-    })
+  it('on constantPrice TRIX = 0 (constant EMA3 → no change)', () => {
+    const out = calcTRIXData(constantPrice, 15, 9)
+    for (let t = 1; t < out.series.length; t++) {
+      if (out.series[t] !== undefined) expect(out.series[t]).toBeCloseTo(0, 9)
+    }
+  })
 
-    it('on pureUptrend TRIX > 0 once warmed', () => {
-        const out = calcTRIXData(pureUptrend, 5, 3)
-        const tail = out.series.slice(10).filter((v): v is number => v !== undefined)
-        expect(tail.length).toBeGreaterThan(0)
-        for (const v of tail) {
-            expect(v).toBeGreaterThan(0)
-        }
-    })
+  it('on pureUptrend TRIX > 0 once warmed', () => {
+    const out = calcTRIXData(pureUptrend, 5, 3)
+    const tail = out.series.slice(10).filter((v): v is number => v !== undefined)
+    expect(tail.length).toBeGreaterThan(0)
+    for (const v of tail) {
+      expect(v).toBeGreaterThan(0)
+    }
+  })
 
-    it('on pureDowntrend TRIX < 0 once warmed', () => {
-        const out = calcTRIXData(pureDowntrend, 5, 3)
-        const tail = out.series.slice(10).filter((v): v is number => v !== undefined)
-        for (const v of tail) {
-            expect(v).toBeLessThan(0)
-        }
-    })
+  it('on pureDowntrend TRIX < 0 once warmed', () => {
+    const out = calcTRIXData(pureDowntrend, 5, 3)
+    const tail = out.series.slice(10).filter((v): v is number => v !== undefined)
+    for (const v of tail) {
+      expect(v).toBeLessThan(0)
+    }
+  })
 
-    it('signal series is a smoothing of TRIX (less volatile)', () => {
-        const out = calcTRIXData(sideways, 5, 3)
-        // Both should have defined tails; signal range should not exceed series range
-        const series = out.series.filter((v): v is number => v !== undefined)
-        const signal = out.signalSeries.filter((v): v is number => v !== undefined)
-        if (series.length >= 5 && signal.length >= 5) {
-            const seriesRange = Math.max(...series) - Math.min(...series)
-            const signalRange = Math.max(...signal) - Math.min(...signal)
-            expect(signalRange).toBeLessThanOrEqual(seriesRange + 1e-9)
-        }
-    })
+  it('signal series is a smoothing of TRIX (less volatile)', () => {
+    const out = calcTRIXData(sideways, 5, 3)
+    // Both should have defined tails; signal range should not exceed series range
+    const series = out.series.filter((v): v is number => v !== undefined)
+    const signal = out.signalSeries.filter((v): v is number => v !== undefined)
+    if (series.length >= 5 && signal.length >= 5) {
+      const seriesRange = Math.max(...series) - Math.min(...series)
+      const signalRange = Math.max(...signal) - Math.min(...signal)
+      expect(signalRange).toBeLessThanOrEqual(seriesRange + 1e-9)
+    }
+  })
 
-    it('extensional consistency', () => {
-        const full = calcTRIXData(pureUptrend, 5, 3)
-        for (let n = 10; n < pureUptrend.length; n++) {
-            const partial = calcTRIXData(pureUptrend.slice(0, n), 5, 3)
-            for (let i = 0; i < n; i++) {
-                if (full.series[i] !== undefined && partial.series[i] !== undefined) {
-                    expect(partial.series[i]).toBeCloseTo(full.series[i]!, 9)
-                }
-            }
+  it('extensional consistency', () => {
+    const full = calcTRIXData(pureUptrend, 5, 3)
+    for (let n = 10; n < pureUptrend.length; n++) {
+      const partial = calcTRIXData(pureUptrend.slice(0, n), 5, 3)
+      for (let i = 0; i < n; i++) {
+        if (full.series[i] !== undefined && partial.series[i] !== undefined) {
+          expect(partial.series[i]).toBeCloseTo(full.series[i]!, 9)
         }
-    })
+      }
+    }
+  })
 })