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

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

@@ -1,105 +1,105 @@
-import { describe, it, expect } from 'vitest'
-import { calcIchimokuData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-} from './__fixtures__/synthetic'
-
-describe('calcIchimokuData', () => {
-    it('empty returns empty', () => {
-        expect(calcIchimokuData(empty, 9, 26, 52, 26)).toEqual([])
-    })
-
-    it('on constantPrice (H=L=100) all lines collapse to 100', () => {
-        // Only constantPrice (30 bars) is shorter than spanBPeriod=52, so use small periods for this test
-        const out = calcIchimokuData(constantPrice, 5, 10, 15, 5)
-        // Test data is 30 bars, so spanA/B/chikou exist within the window
-        const valid = out.filter((p): p is NonNullable<typeof p> => p !== undefined)
-        expect(valid.length).toBe(constantPrice.length)
-        // After warm-up, tenkan and kijun should both be 100
-        for (let t = 15; t < out.length - 5; t++) {
-            const p = out[t]!
-            if (p.tenkan !== undefined) expect(p.tenkan).toBe(100)
-            if (p.kijun !== undefined) expect(p.kijun).toBe(100)
-            if (p.spanA !== undefined) expect(p.spanA).toBe(100)
-            if (p.spanB !== undefined) expect(p.spanB).toBe(100)
-            if (p.chikou !== undefined) expect(p.chikou).toBe(100)
-        }
-    })
-
-    it('uptrend: spanA > spanB once cloud is established (bullish cloud)', () => {
-        const out = calcIchimokuData(pureUptrend, 5, 10, 15, 5)
-        let bullishCount = 0
-        let bearishCount = 0
-        for (const p of out) {
-            if (p && p.spanA !== undefined && p.spanB !== undefined) {
-                if (p.spanA > p.spanB) bullishCount++
-                else if (p.spanA < p.spanB) bearishCount++
-            }
-        }
-        expect(bullishCount).toBeGreaterThan(bearishCount)
-    })
-
-    it('downtrend: spanA < spanB once cloud is established (bearish cloud)', () => {
-        const out = calcIchimokuData(pureDowntrend, 5, 10, 15, 5)
-        let bullishCount = 0
-        let bearishCount = 0
-        for (const p of out) {
-            if (p && p.spanA !== undefined && p.spanB !== undefined) {
-                if (p.spanA > p.spanB) bullishCount++
-                else if (p.spanA < p.spanB) bearishCount++
-            }
-        }
-        expect(bearishCount).toBeGreaterThan(bullishCount)
-    })
-
-    it('chikou at bar t equals close[t+displacement] when in range, undefined otherwise', () => {
-        const displacement = 5
-        const out = calcIchimokuData(pureUptrend, 5, 10, 15, displacement)
-        for (let t = 0; t < pureUptrend.length; t++) {
-            const p = out[t]!
-            if (t + displacement < pureUptrend.length) {
-                expect(p.chikou).toBe(pureUptrend[t + displacement]!.close)
-            } else {
-                expect(p.chikou).toBeUndefined()
-            }
-        }
-    })
-
-    it('tenkan/kijun midline equals (max(high) + min(low)) / 2 over the period', () => {
-        const period = 9
-        const out = calcIchimokuData(pureUptrend, period, 26, 52, 26)
-        for (let t = period - 1; t < pureUptrend.length; t++) {
-            let hi = -Infinity
-            let lo = Infinity
-            for (let k = 0; k < period; k++) {
-                const bar = pureUptrend[t - k]!
-                if (bar.high > hi) hi = bar.high
-                if (bar.low < lo) lo = bar.low
-            }
-            expect(out[t]!.tenkan).toBeCloseTo((hi + lo) / 2, 9)
-        }
-    })
-
-    it('extensional consistency on sideways fixture', () => {
-        const full = calcIchimokuData(sideways, 5, 10, 15, 5)
-        for (let n = 16; n < sideways.length; n++) {
-            const partial = calcIchimokuData(sideways.slice(0, n), 5, 10, 15, 5)
-            for (let i = 0; i < n; i++) {
-                const f = full[i]
-                const p = partial[i]
-                if (f && p) {
-                    if (f.tenkan !== undefined && p.tenkan !== undefined) {
-                        expect(p.tenkan).toBeCloseTo(f.tenkan, 9)
-                    }
-                    if (f.kijun !== undefined && p.kijun !== undefined) {
-                        expect(p.kijun).toBeCloseTo(f.kijun, 9)
-                    }
-                }
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcIchimokuData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+} from './__fixtures__/synthetic'
+
+describe('calcIchimokuData', () => {
+    it('empty returns empty', () => {
+        expect(calcIchimokuData(empty, 9, 26, 52, 26)).toEqual([])
+    })
+
+    it('on constantPrice (H=L=100) all lines collapse to 100', () => {
+        // Only constantPrice (30 bars) is shorter than spanBPeriod=52, so use small periods for this test
+        const out = calcIchimokuData(constantPrice, 5, 10, 15, 5)
+        // Test data is 30 bars, so spanA/B/chikou exist within the window
+        const valid = out.filter((p): p is NonNullable<typeof p> => p !== undefined)
+        expect(valid.length).toBe(constantPrice.length)
+        // After warm-up, tenkan and kijun should both be 100
+        for (let t = 15; t < out.length - 5; t++) {
+            const p = out[t]!
+            if (p.tenkan !== undefined) expect(p.tenkan).toBe(100)
+            if (p.kijun !== undefined) expect(p.kijun).toBe(100)
+            if (p.spanA !== undefined) expect(p.spanA).toBe(100)
+            if (p.spanB !== undefined) expect(p.spanB).toBe(100)
+            if (p.chikou !== undefined) expect(p.chikou).toBe(100)
+        }
+    })
+
+    it('uptrend: spanA > spanB once cloud is established (bullish cloud)', () => {
+        const out = calcIchimokuData(pureUptrend, 5, 10, 15, 5)
+        let bullishCount = 0
+        let bearishCount = 0
+        for (const p of out) {
+            if (p && p.spanA !== undefined && p.spanB !== undefined) {
+                if (p.spanA > p.spanB) bullishCount++
+                else if (p.spanA < p.spanB) bearishCount++
+            }
+        }
+        expect(bullishCount).toBeGreaterThan(bearishCount)
+    })
+
+    it('downtrend: spanA < spanB once cloud is established (bearish cloud)', () => {
+        const out = calcIchimokuData(pureDowntrend, 5, 10, 15, 5)
+        let bullishCount = 0
+        let bearishCount = 0
+        for (const p of out) {
+            if (p && p.spanA !== undefined && p.spanB !== undefined) {
+                if (p.spanA > p.spanB) bullishCount++
+                else if (p.spanA < p.spanB) bearishCount++
+            }
+        }
+        expect(bearishCount).toBeGreaterThan(bullishCount)
+    })
+
+    it('chikou at bar t equals close[t+displacement] when in range, undefined otherwise', () => {
+        const displacement = 5
+        const out = calcIchimokuData(pureUptrend, 5, 10, 15, displacement)
+        for (let t = 0; t < pureUptrend.length; t++) {
+            const p = out[t]!
+            if (t + displacement < pureUptrend.length) {
+                expect(p.chikou).toBe(pureUptrend[t + displacement]!.close)
+            } else {
+                expect(p.chikou).toBeUndefined()
+            }
+        }
+    })
+
+    it('tenkan/kijun midline equals (max(high) + min(low)) / 2 over the period', () => {
+        const period = 9
+        const out = calcIchimokuData(pureUptrend, period, 26, 52, 26)
+        for (let t = period - 1; t < pureUptrend.length; t++) {
+            let hi = -Infinity
+            let lo = Infinity
+            for (let k = 0; k < period; k++) {
+                const bar = pureUptrend[t - k]!
+                if (bar.high > hi) hi = bar.high
+                if (bar.low < lo) lo = bar.low
+            }
+            expect(out[t]!.tenkan).toBeCloseTo((hi + lo) / 2, 9)
+        }
+    })
+
+    it('extensional consistency on sideways fixture', () => {
+        const full = calcIchimokuData(sideways, 5, 10, 15, 5)
+        for (let n = 16; n < sideways.length; n++) {
+            const partial = calcIchimokuData(sideways.slice(0, n), 5, 10, 15, 5)
+            for (let i = 0; i < n; i++) {
+                const f = full[i]
+                const p = partial[i]
+                if (f && p) {
+                    if (f.tenkan !== undefined && p.tenkan !== undefined) {
+                        expect(p.tenkan).toBeCloseTo(f.tenkan, 9)
+                    }
+                    if (f.kijun !== undefined && p.kijun !== undefined) {
+                        expect(p.kijun).toBeCloseTo(f.kijun, 9)
+                    }
+                }
+            }
+        }
+    })
+})

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

@@ -1,80 +1,80 @@
-import { describe, it, expect } from 'vitest'
-import { calcKAMAData } from '../calculators'
-import {
-    empty,
-    singleBar,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-import { KAMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
-import {
-    assertFiniteOrUndefined,
-} from './_propertyAssertions'
-
-describe('calcKAMAData — Kaufman Adaptive Moving Average', () => {
-    describe('edge cases', () => {
-        it('empty returns empty array', () => {
-            expect(calcKAMAData(empty, 10, 2, 30)).toEqual([])
-        })
-
-        it('single bar returns [undefined]', () => {
-            expect(calcKAMAData(singleBar, 10, 2, 30)).toEqual([undefined])
-        })
-
-        it('n <= period returns all undefined', () => {
-            const tiny = constantPrice.slice(0, 10)
-            const out = calcKAMAData(tiny, 10, 2, 30)
-            for (const v of out) expect(v).toBeUndefined()
-        })
-
-        it('period = 0 or negative returns all undefined', () => {
-            expect(calcKAMAData(pureUptrend, 0, 2, 30)).toEqual(
-                Array.from({ length: pureUptrend.length }, () => undefined),
-            )
-            expect(calcKAMAData(pureUptrend, -1, 2, 30)).toEqual(
-                Array.from({ length: pureUptrend.length }, () => undefined),
-            )
-        })
-    })
-
-    describe('golden values', () => {
-        it('constantPrice → KAMA stays at 100 once seeded', () => {
-            assertSeriesClose(calcKAMAData(constantPrice, 10, 2, 30), KAMA_GOLDEN.constantPrice!.series)
-        })
-    })
-
-    describe('mathematical properties', () => {
-        it('all values finite', () => {
-            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
-                assertFiniteOrUndefined(calcKAMAData(fx, 10, 2, 30), 'KAMA series')
-            }
-        })
-
-        it('on pureUptrend ER ≈ 1 → KAMA tracks close[t] closely', () => {
-            // Linear uptrend has direction = period and volSum = period (all changes = 1),
-            // so ER = 1 every step → SC = fastSC² = (2/3)² = 4/9 ≈ 0.444
-            const out = calcKAMAData(pureUptrend, 10, 2, 30)
-            // Tail values should be close to close[t]; difference monotonically shrinks
-            const tail = out.slice(15)
-            for (let i = 1; i < tail.length; i++) {
-                if (tail[i] === undefined || tail[i - 1] === undefined) continue
-                expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
-            }
-        })
-
-        it('extensional consistency', () => {
-            const full = calcKAMAData(pureUptrend, 10, 2, 30)
-            for (let n = 12; n < pureUptrend.length; n++) {
-                const partial = calcKAMAData(pureUptrend.slice(0, n), 10, 2, 30)
-                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 { calcKAMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { KAMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcKAMAData — Kaufman Adaptive Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcKAMAData(empty, 10, 2, 30)).toEqual([])
+        })
+
+        it('single bar returns [undefined]', () => {
+            expect(calcKAMAData(singleBar, 10, 2, 30)).toEqual([undefined])
+        })
+
+        it('n <= period returns all undefined', () => {
+            const tiny = constantPrice.slice(0, 10)
+            const out = calcKAMAData(tiny, 10, 2, 30)
+            for (const v of out) expect(v).toBeUndefined()
+        })
+
+        it('period = 0 or negative returns all undefined', () => {
+            expect(calcKAMAData(pureUptrend, 0, 2, 30)).toEqual(
+                Array.from({ length: pureUptrend.length }, () => undefined),
+            )
+            expect(calcKAMAData(pureUptrend, -1, 2, 30)).toEqual(
+                Array.from({ length: pureUptrend.length }, () => undefined),
+            )
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → KAMA stays at 100 once seeded', () => {
+            assertSeriesClose(calcKAMAData(constantPrice, 10, 2, 30), KAMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcKAMAData(fx, 10, 2, 30), 'KAMA series')
+            }
+        })
+
+        it('on pureUptrend ER ≈ 1 → KAMA tracks close[t] closely', () => {
+            // Linear uptrend has direction = period and volSum = period (all changes = 1),
+            // so ER = 1 every step → SC = fastSC² = (2/3)² = 4/9 ≈ 0.444
+            const out = calcKAMAData(pureUptrend, 10, 2, 30)
+            // Tail values should be close to close[t]; difference monotonically shrinks
+            const tail = out.slice(15)
+            for (let i = 1; i < tail.length; i++) {
+                if (tail[i] === undefined || tail[i - 1] === undefined) continue
+                expect(tail[i]!).toBeGreaterThan(tail[i - 1]!)
+            }
+        })
+
+        it('extensional consistency', () => {
+            const full = calcKAMAData(pureUptrend, 10, 2, 30)
+            for (let n = 12; n < pureUptrend.length; n++) {
+                const partial = calcKAMAData(pureUptrend.slice(0, n), 10, 2, 30)
+                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__/keltner.test.ts

@@ -1,65 +1,65 @@
-import { describe, it, expect } from 'vitest'
-import { calcKeltnerData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-
-describe('calcKeltnerData', () => {
-    it('empty returns empty', () => {
-        expect(calcKeltnerData(empty, 20, 10, 2)).toEqual([])
-    })
-
-    it('on constantPrice all bands collapse to 100 (ATR=0 → no band width)', () => {
-        const out = calcKeltnerData(constantPrice, 20, 10, 2)
-        const valid = out.filter((p) => p !== undefined)
-        expect(valid.length).toBeGreaterThan(0)
-        for (const p of valid) {
-            expect(p!.middle).toBeCloseTo(100, 9)
-            expect(p!.upper).toBeCloseTo(100, 9)
-            expect(p!.lower).toBeCloseTo(100, 9)
-        }
-    })
-
-    it('upper >= middle >= lower invariant', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            const out = calcKeltnerData(fx, 20, 10, 2)
-            for (const p of out) {
-                if (!p) continue
-                expect(p.upper).toBeGreaterThanOrEqual(p.middle)
-                expect(p.middle).toBeGreaterThanOrEqual(p.lower)
-            }
-        }
-    })
-
-    it('larger multiplier widens the band', () => {
-        const narrow = calcKeltnerData(spikeAtBar19, 20, 10, 1)
-        const wide = calcKeltnerData(spikeAtBar19, 20, 10, 4)
-        for (let i = 15; i < narrow.length; i++) {
-            const n = narrow[i]
-            const w = wide[i]
-            if (n && w) {
-                expect(w.upper - w.lower).toBeGreaterThanOrEqual(n.upper - n.lower)
-            }
-        }
-    })
-
-    it('extensional consistency', () => {
-        const full = calcKeltnerData(pureUptrend, 20, 10, 2)
-        for (let n = 15; n < pureUptrend.length; n++) {
-            const partial = calcKeltnerData(pureUptrend.slice(0, n), 20, 10, 2)
-            for (let i = 0; i < n; i++) {
-                const f = full[i]
-                const p = partial[i]
-                if (f && p) {
-                    expect(p.middle).toBeCloseTo(f.middle, 9)
-                    expect(p.upper).toBeCloseTo(f.upper, 9)
-                    expect(p.lower).toBeCloseTo(f.lower, 9)
-                }
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcKeltnerData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcKeltnerData', () => {
+    it('empty returns empty', () => {
+        expect(calcKeltnerData(empty, 20, 10, 2)).toEqual([])
+    })
+
+    it('on constantPrice all bands collapse to 100 (ATR=0 → no band width)', () => {
+        const out = calcKeltnerData(constantPrice, 20, 10, 2)
+        const valid = out.filter((p) => p !== undefined)
+        expect(valid.length).toBeGreaterThan(0)
+        for (const p of valid) {
+            expect(p!.middle).toBeCloseTo(100, 9)
+            expect(p!.upper).toBeCloseTo(100, 9)
+            expect(p!.lower).toBeCloseTo(100, 9)
+        }
+    })
+
+    it('upper >= middle >= lower invariant', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const out = calcKeltnerData(fx, 20, 10, 2)
+            for (const p of out) {
+                if (!p) continue
+                expect(p.upper).toBeGreaterThanOrEqual(p.middle)
+                expect(p.middle).toBeGreaterThanOrEqual(p.lower)
+            }
+        }
+    })
+
+    it('larger multiplier widens the band', () => {
+        const narrow = calcKeltnerData(spikeAtBar19, 20, 10, 1)
+        const wide = calcKeltnerData(spikeAtBar19, 20, 10, 4)
+        for (let i = 15; i < narrow.length; i++) {
+            const n = narrow[i]
+            const w = wide[i]
+            if (n && w) {
+                expect(w.upper - w.lower).toBeGreaterThanOrEqual(n.upper - n.lower)
+            }
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcKeltnerData(pureUptrend, 20, 10, 2)
+        for (let n = 15; n < pureUptrend.length; n++) {
+            const partial = calcKeltnerData(pureUptrend.slice(0, n), 20, 10, 2)
+            for (let i = 0; i < n; i++) {
+                const f = full[i]
+                const p = partial[i]
+                if (f && p) {
+                    expect(p.middle).toBeCloseTo(f.middle, 9)
+                    expect(p.upper).toBeCloseTo(f.upper, 9)
+                    expect(p.lower).toBeCloseTo(f.lower, 9)
+                }
+            }
+        }
+    })
+})