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

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

@@ -1,117 +1,117 @@
-import { describe, it, expect } from 'vitest'
-import { calcHVData, calcParkinsonData, calcChaikinVolData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-
-describe('calcHVData — Historical Volatility', () => {
-    it('empty returns empty', () => {
-        expect(calcHVData(empty, 20, 252)).toEqual([])
-    })
-
-    it('period <= 0 or annualization <= 0 returns all undefined', () => {
-        const out1 = calcHVData(pureUptrend, 0, 252)
-        for (const v of out1) expect(v).toBeUndefined()
-        const out2 = calcHVData(pureUptrend, 20, 0)
-        for (const v of out2) expect(v).toBeUndefined()
-    })
-
-    it('on constantPrice HV = 0 (no return variance)', () => {
-        const out = calcHVData(constantPrice, 10, 252)
-        for (let t = 10; t < out.length; t++) {
-            expect(out[t]).toBeCloseTo(0, 9)
-        }
-    })
-
-    it('on pureUptrend HV > 0 once warm-up complete', () => {
-        const out = calcHVData(pureUptrend, 10, 252)
-        for (let t = 10; t < out.length; t++) {
-            expect(out[t]).toBeGreaterThanOrEqual(0)
-        }
-    })
-
-    it('HV ≥ 0 always', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            for (const v of calcHVData(fx, 10, 252)) {
-                if (v !== undefined) expect(v).toBeGreaterThanOrEqual(0)
-            }
-        }
-    })
-
-    it('higher annualization → higher HV value (sqrt scaling)', () => {
-        const low = calcHVData(spikeAtBar19, 10, 100)
-        const high = calcHVData(spikeAtBar19, 10, 400)
-        for (let t = 10; t < low.length; t++) {
-            if (low[t] !== undefined && high[t] !== undefined) {
-                expect(high[t]).toBeCloseTo(low[t]! * 2, 9) // sqrt(400)/sqrt(100) = 2
-            }
-        }
-    })
-})
-
-describe('calcParkinsonData — Parkinson Volatility', () => {
-    it('empty returns empty', () => {
-        expect(calcParkinsonData(empty, 20, 252)).toEqual([])
-    })
-
-    it('on constantPrice (H=L) Parkinson = 0', () => {
-        const out = calcParkinsonData(constantPrice, 10, 252)
-        for (let t = 9; t < out.length; t++) {
-            expect(out[t]).toBeCloseTo(0, 9)
-        }
-    })
-
-    it('Parkinson ≥ 0 always', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            for (const v of calcParkinsonData(fx, 10, 252)) {
-                if (v !== undefined) expect(v).toBeGreaterThanOrEqual(0)
-            }
-        }
-    })
-
-    it('on spike fixture Parkinson responds to the spike bar', () => {
-        const out = calcParkinsonData(spikeAtBar19, 5, 252)
-        const preSpike = out[18]
-        const atSpike = out[19]
-        if (preSpike !== undefined && atSpike !== undefined) {
-            expect(atSpike).toBeGreaterThanOrEqual(preSpike)
-        }
-    })
-})
-
-describe('calcChaikinVolData — Chaikin Volatility', () => {
-    it('empty returns empty', () => {
-        expect(calcChaikinVolData(empty, 10, 10)).toEqual([])
-    })
-
-    it('on constantPrice ChaikinVol stays at 0 (EMA(H-L) constant)', () => {
-        const out = calcChaikinVolData(constantPrice, 10, 10)
-        for (let t = 10; t < out.length; t++) {
-            if (out[t] !== undefined) expect(out[t]).toBeCloseTo(0, 6)
-        }
-    })
-
-    it('values finite or undefined', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            for (const v of calcChaikinVolData(fx, 10, 10)) {
-                if (v !== undefined) expect(Number.isFinite(v)).toBe(true)
-            }
-        }
-    })
-
-    it('extensional consistency on spike fixture', () => {
-        const full = calcChaikinVolData(spikeAtBar19, 5, 5)
-        for (let n = 12; n < spikeAtBar19.length; n++) {
-            const partial = calcChaikinVolData(spikeAtBar19.slice(0, n), 5, 5)
-            for (let i = 0; i < n; i++) {
-                if (full[i] !== undefined && partial[i] !== undefined) {
-                    expect(partial[i]).toBeCloseTo(full[i]!, 9)
-                }
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcHVData, calcParkinsonData, calcChaikinVolData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcHVData — Historical Volatility', () => {
+    it('empty returns empty', () => {
+        expect(calcHVData(empty, 20, 252)).toEqual([])
+    })
+
+    it('period <= 0 or annualization <= 0 returns all undefined', () => {
+        const out1 = calcHVData(pureUptrend, 0, 252)
+        for (const v of out1) expect(v).toBeUndefined()
+        const out2 = calcHVData(pureUptrend, 20, 0)
+        for (const v of out2) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice HV = 0 (no return variance)', () => {
+        const out = calcHVData(constantPrice, 10, 252)
+        for (let t = 10; t < out.length; t++) {
+            expect(out[t]).toBeCloseTo(0, 9)
+        }
+    })
+
+    it('on pureUptrend HV > 0 once warm-up complete', () => {
+        const out = calcHVData(pureUptrend, 10, 252)
+        for (let t = 10; t < out.length; t++) {
+            expect(out[t]).toBeGreaterThanOrEqual(0)
+        }
+    })
+
+    it('HV ≥ 0 always', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            for (const v of calcHVData(fx, 10, 252)) {
+                if (v !== undefined) expect(v).toBeGreaterThanOrEqual(0)
+            }
+        }
+    })
+
+    it('higher annualization → higher HV value (sqrt scaling)', () => {
+        const low = calcHVData(spikeAtBar19, 10, 100)
+        const high = calcHVData(spikeAtBar19, 10, 400)
+        for (let t = 10; t < low.length; t++) {
+            if (low[t] !== undefined && high[t] !== undefined) {
+                expect(high[t]).toBeCloseTo(low[t]! * 2, 9) // sqrt(400)/sqrt(100) = 2
+            }
+        }
+    })
+})
+
+describe('calcParkinsonData — Parkinson Volatility', () => {
+    it('empty returns empty', () => {
+        expect(calcParkinsonData(empty, 20, 252)).toEqual([])
+    })
+
+    it('on constantPrice (H=L) Parkinson = 0', () => {
+        const out = calcParkinsonData(constantPrice, 10, 252)
+        for (let t = 9; t < out.length; t++) {
+            expect(out[t]).toBeCloseTo(0, 9)
+        }
+    })
+
+    it('Parkinson ≥ 0 always', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            for (const v of calcParkinsonData(fx, 10, 252)) {
+                if (v !== undefined) expect(v).toBeGreaterThanOrEqual(0)
+            }
+        }
+    })
+
+    it('on spike fixture Parkinson responds to the spike bar', () => {
+        const out = calcParkinsonData(spikeAtBar19, 5, 252)
+        const preSpike = out[18]
+        const atSpike = out[19]
+        if (preSpike !== undefined && atSpike !== undefined) {
+            expect(atSpike).toBeGreaterThanOrEqual(preSpike)
+        }
+    })
+})
+
+describe('calcChaikinVolData — Chaikin Volatility', () => {
+    it('empty returns empty', () => {
+        expect(calcChaikinVolData(empty, 10, 10)).toEqual([])
+    })
+
+    it('on constantPrice ChaikinVol stays at 0 (EMA(H-L) constant)', () => {
+        const out = calcChaikinVolData(constantPrice, 10, 10)
+        for (let t = 10; t < out.length; t++) {
+            if (out[t] !== undefined) expect(out[t]).toBeCloseTo(0, 6)
+        }
+    })
+
+    it('values finite or undefined', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            for (const v of calcChaikinVolData(fx, 10, 10)) {
+                if (v !== undefined) expect(Number.isFinite(v)).toBe(true)
+            }
+        }
+    })
+
+    it('extensional consistency on spike fixture', () => {
+        const full = calcChaikinVolData(spikeAtBar19, 5, 5)
+        for (let n = 12; n < spikeAtBar19.length; n++) {
+            const partial = calcChaikinVolData(spikeAtBar19.slice(0, n), 5, 5)
+            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__/volume.test.ts

@@ -1,115 +1,115 @@
-import { describe, it, expect } from 'vitest'
-import { calcVMAData, calcOBVData, calcPVTData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-
-describe('calcVMAData', () => {
-    it('empty returns empty', () => {
-        expect(calcVMAData(empty, 5)).toEqual([])
-    })
-
-    it('shorter than period returns all undefined', () => {
-        const out = calcVMAData(pureUptrend.slice(0, 3), 5)
-        for (const v of out) expect(v).toBeUndefined()
-    })
-
-    it('period <= 0 returns all undefined', () => {
-        const out = calcVMAData(pureUptrend, 0)
-        for (const v of out) expect(v).toBeUndefined()
-    })
-
-    it('on constantPrice (volume=1000) VMA = 1000 after warm-up', () => {
-        const out = calcVMAData(constantPrice, 5)
-        for (let t = 4; t < out.length; t++) {
-            expect(out[t]).toBe(1000)
-        }
-    })
-
-    it('mathematical exactness: VMA = mean of last `period` volumes', () => {
-        const period = 5
-        const out = calcVMAData(pureUptrend, period)
-        for (let t = period - 1; t < out.length; t++) {
-            let sum = 0
-            for (let k = 0; k < period; k++) sum += pureUptrend[t - k]!.volume ?? 0
-            expect(out[t]!).toBeCloseTo(sum / period, 9)
-        }
-    })
-})
-
-describe('calcOBVData', () => {
-    it('empty returns empty', () => {
-        expect(calcOBVData(empty)).toEqual([])
-    })
-
-    it('starts at 0', () => {
-        const out = calcOBVData(pureUptrend)
-        expect(out[0]).toBe(0)
-    })
-
-    it('on pureUptrend OBV monotonically increases (every Δclose > 0 → +volume)', () => {
-        const out = calcOBVData(pureUptrend)
-        for (let t = 1; t < out.length; t++) {
-            expect(out[t]!).toBeGreaterThanOrEqual(out[t - 1]!)
-        }
-    })
-
-    it('on pureDowntrend OBV monotonically decreases', () => {
-        const out = calcOBVData(pureDowntrend)
-        for (let t = 1; t < out.length; t++) {
-            expect(out[t]!).toBeLessThanOrEqual(out[t - 1]!)
-        }
-    })
-
-    it('on constantPrice (no Δclose) OBV stays at 0', () => {
-        const out = calcOBVData(constantPrice)
-        for (const v of out) expect(v).toBe(0)
-    })
-
-    it('extensional consistency on spike fixture', () => {
-        const full = calcOBVData(spikeAtBar19)
-        for (let n = 5; n < spikeAtBar19.length; n++) {
-            const partial = calcOBVData(spikeAtBar19.slice(0, n))
-            for (let i = 0; i < n; i++) {
-                expect(partial[i]).toBe(full[i])
-            }
-        }
-    })
-})
-
-describe('calcPVTData', () => {
-    it('empty returns empty', () => {
-        expect(calcPVTData(empty)).toEqual([])
-    })
-
-    it('starts at 0', () => {
-        expect(calcPVTData(pureUptrend)[0]).toBe(0)
-    })
-
-    it('on constantPrice PVT stays at 0', () => {
-        const out = calcPVTData(constantPrice)
-        for (const v of out) expect(v).toBe(0)
-    })
-
-    it('on pureUptrend PVT monotonically increases', () => {
-        const out = calcPVTData(pureUptrend)
-        for (let t = 1; t < out.length; t++) {
-            expect(out[t]!).toBeGreaterThanOrEqual(out[t - 1]!)
-        }
-    })
-
-    it('extensional consistency', () => {
-        const full = calcPVTData(sideways)
-        for (let n = 5; n < sideways.length; n++) {
-            const partial = calcPVTData(sideways.slice(0, n))
-            for (let i = 0; i < n; i++) {
-                expect(partial[i]).toBeCloseTo(full[i]!, 9)
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcVMAData, calcOBVData, calcPVTData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcVMAData', () => {
+    it('empty returns empty', () => {
+        expect(calcVMAData(empty, 5)).toEqual([])
+    })
+
+    it('shorter than period returns all undefined', () => {
+        const out = calcVMAData(pureUptrend.slice(0, 3), 5)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('period <= 0 returns all undefined', () => {
+        const out = calcVMAData(pureUptrend, 0)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice (volume=1000) VMA = 1000 after warm-up', () => {
+        const out = calcVMAData(constantPrice, 5)
+        for (let t = 4; t < out.length; t++) {
+            expect(out[t]).toBe(1000)
+        }
+    })
+
+    it('mathematical exactness: VMA = mean of last `period` volumes', () => {
+        const period = 5
+        const out = calcVMAData(pureUptrend, period)
+        for (let t = period - 1; t < out.length; t++) {
+            let sum = 0
+            for (let k = 0; k < period; k++) sum += pureUptrend[t - k]!.volume ?? 0
+            expect(out[t]!).toBeCloseTo(sum / period, 9)
+        }
+    })
+})
+
+describe('calcOBVData', () => {
+    it('empty returns empty', () => {
+        expect(calcOBVData(empty)).toEqual([])
+    })
+
+    it('starts at 0', () => {
+        const out = calcOBVData(pureUptrend)
+        expect(out[0]).toBe(0)
+    })
+
+    it('on pureUptrend OBV monotonically increases (every Δclose > 0 → +volume)', () => {
+        const out = calcOBVData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeGreaterThanOrEqual(out[t - 1]!)
+        }
+    })
+
+    it('on pureDowntrend OBV monotonically decreases', () => {
+        const out = calcOBVData(pureDowntrend)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeLessThanOrEqual(out[t - 1]!)
+        }
+    })
+
+    it('on constantPrice (no Δclose) OBV stays at 0', () => {
+        const out = calcOBVData(constantPrice)
+        for (const v of out) expect(v).toBe(0)
+    })
+
+    it('extensional consistency on spike fixture', () => {
+        const full = calcOBVData(spikeAtBar19)
+        for (let n = 5; n < spikeAtBar19.length; n++) {
+            const partial = calcOBVData(spikeAtBar19.slice(0, n))
+            for (let i = 0; i < n; i++) {
+                expect(partial[i]).toBe(full[i])
+            }
+        }
+    })
+})
+
+describe('calcPVTData', () => {
+    it('empty returns empty', () => {
+        expect(calcPVTData(empty)).toEqual([])
+    })
+
+    it('starts at 0', () => {
+        expect(calcPVTData(pureUptrend)[0]).toBe(0)
+    })
+
+    it('on constantPrice PVT stays at 0', () => {
+        const out = calcPVTData(constantPrice)
+        for (const v of out) expect(v).toBe(0)
+    })
+
+    it('on pureUptrend PVT monotonically increases', () => {
+        const out = calcPVTData(pureUptrend)
+        for (let t = 1; t < out.length; t++) {
+            expect(out[t]!).toBeGreaterThanOrEqual(out[t - 1]!)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcPVTData(sideways)
+        for (let n = 5; n < sideways.length; n++) {
+            const partial = calcPVTData(sideways.slice(0, n))
+            for (let i = 0; i < n; i++) {
+                expect(partial[i]).toBeCloseTo(full[i]!, 9)
+            }
+        }
+    })
+})

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

@@ -1,74 +1,74 @@
-import { describe, it, expect } from 'vitest'
-import { calcVolumeProfileData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-
-describe('calcVolumeProfileData', () => {
-    it('empty returns empty profile', () => {
-        const result = calcVolumeProfileData(empty, 24, 0, 0.7)
-        expect(result.bins).toEqual([])
-        expect(result.totalVolume).toBe(0)
-    })
-
-    it('bins <= 0 returns empty', () => {
-        const result = calcVolumeProfileData(pureUptrend, 0, 0, 0.7)
-        expect(result.bins).toEqual([])
-    })
-
-    it('on constantPrice (H=L=100): degenerate range → empty bins (no meaningful distribution)', () => {
-        const result = calcVolumeProfileData(constantPrice, 10, 0, 0.7)
-        // When priceMax === priceMin, the binning has no range; the function returns empty bins
-        expect(result.bins).toEqual([])
-        expect(result.totalVolume).toBe(0)
-    })
-
-    it('on pureUptrend: total volume = sum of bar volumes', () => {
-        const result = calcVolumeProfileData(pureUptrend, 24, 0, 0.7)
-        let expectedTotal = 0
-        for (const bar of pureUptrend) expectedTotal += bar.volume ?? 0
-        expect(result.totalVolume).toBeCloseTo(expectedTotal, 6)
-    })
-
-    it('POC is within [val, vah] (value area contains POC)', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            const result = calcVolumeProfileData(fx, 20, 0, 0.7)
-            if (result.bins.length === 0) continue
-            expect(result.poc).toBeGreaterThanOrEqual(result.val)
-            expect(result.poc).toBeLessThanOrEqual(result.vah)
-        }
-    })
-
-    it('VAH >= VAL invariant', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            const result = calcVolumeProfileData(fx, 20, 0, 0.7)
-            expect(result.vah).toBeGreaterThanOrEqual(result.val)
-        }
-    })
-
-    it('value area sums to >= valueAreaPercent of total volume', () => {
-        const result = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
-        const vaVolume = result.bins
-            .filter((b) => b.priceLow >= result.val - 1e-9 && b.priceHigh <= result.vah + 1e-9)
-            .reduce((a, b) => a + b.volume, 0)
-        expect(vaVolume).toBeGreaterThanOrEqual(result.totalVolume * 0.7 - 1e-6)
-    })
-
-    it('bins cover [priceMin, priceMax] contiguously', () => {
-        const result = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
-        for (let i = 1; i < result.bins.length; i++) {
-            expect(result.bins[i]!.priceLow).toBeCloseTo(result.bins[i - 1]!.priceHigh, 9)
-        }
-    })
-
-    it('lookback limits the data window', () => {
-        const full = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
-        const last10 = calcVolumeProfileData(pureUptrend, 20, 10, 0.7)
-        // Lookback should use less data → lower total volume
-        expect(last10.totalVolume).toBeLessThan(full.totalVolume)
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcVolumeProfileData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcVolumeProfileData', () => {
+    it('empty returns empty profile', () => {
+        const result = calcVolumeProfileData(empty, 24, 0, 0.7)
+        expect(result.bins).toEqual([])
+        expect(result.totalVolume).toBe(0)
+    })
+
+    it('bins <= 0 returns empty', () => {
+        const result = calcVolumeProfileData(pureUptrend, 0, 0, 0.7)
+        expect(result.bins).toEqual([])
+    })
+
+    it('on constantPrice (H=L=100): degenerate range → empty bins (no meaningful distribution)', () => {
+        const result = calcVolumeProfileData(constantPrice, 10, 0, 0.7)
+        // When priceMax === priceMin, the binning has no range; the function returns empty bins
+        expect(result.bins).toEqual([])
+        expect(result.totalVolume).toBe(0)
+    })
+
+    it('on pureUptrend: total volume = sum of bar volumes', () => {
+        const result = calcVolumeProfileData(pureUptrend, 24, 0, 0.7)
+        let expectedTotal = 0
+        for (const bar of pureUptrend) expectedTotal += bar.volume ?? 0
+        expect(result.totalVolume).toBeCloseTo(expectedTotal, 6)
+    })
+
+    it('POC is within [val, vah] (value area contains POC)', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const result = calcVolumeProfileData(fx, 20, 0, 0.7)
+            if (result.bins.length === 0) continue
+            expect(result.poc).toBeGreaterThanOrEqual(result.val)
+            expect(result.poc).toBeLessThanOrEqual(result.vah)
+        }
+    })
+
+    it('VAH >= VAL invariant', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const result = calcVolumeProfileData(fx, 20, 0, 0.7)
+            expect(result.vah).toBeGreaterThanOrEqual(result.val)
+        }
+    })
+
+    it('value area sums to >= valueAreaPercent of total volume', () => {
+        const result = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
+        const vaVolume = result.bins
+            .filter((b) => b.priceLow >= result.val - 1e-9 && b.priceHigh <= result.vah + 1e-9)
+            .reduce((a, b) => a + b.volume, 0)
+        expect(vaVolume).toBeGreaterThanOrEqual(result.totalVolume * 0.7 - 1e-6)
+    })
+
+    it('bins cover [priceMin, priceMax] contiguously', () => {
+        const result = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
+        for (let i = 1; i < result.bins.length; i++) {
+            expect(result.bins[i]!.priceLow).toBeCloseTo(result.bins[i - 1]!.priceHigh, 9)
+        }
+    })
+
+    it('lookback limits the data window', () => {
+        const full = calcVolumeProfileData(pureUptrend, 20, 0, 0.7)
+        const last10 = calcVolumeProfileData(pureUptrend, 20, 10, 0.7)
+        // Lookback should use less data → lower total volume
+        expect(last10.totalVolume).toBeLessThan(full.totalVolume)
+    })
+})