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

package/src/engine/indicators/__tests__/cmf-mfi.test.ts

@@ -1,100 +1,100 @@
-import { describe, it, expect } from 'vitest'
-import { calcCMFData, calcMFIData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-
-describe('calcCMFData', () => {
-    it('empty returns empty', () => {
-        expect(calcCMFData(empty, 20)).toEqual([])
-    })
-
-    it('period <= 0 returns all undefined', () => {
-        const out = calcCMFData(pureUptrend, 0)
-        for (const v of out) expect(v).toBeUndefined()
-    })
-
-    it('CMF ∈ [-1, 1] for all defined values', () => {
-        for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
-            for (const v of calcCMFData(fx, 10)) {
-                if (v !== undefined) {
-                    expect(v).toBeGreaterThanOrEqual(-1)
-                    expect(v).toBeLessThanOrEqual(1)
-                }
-            }
-        }
-    })
-
-    it('on pureUptrend (close=high+1-1=center) CMF stays near 0', () => {
-        // close = 100+i, high = 101+i, low = 99+i → close midway → MFM ≈ 0
-        const out = calcCMFData(pureUptrend, 10)
-        for (let t = 9; t < out.length; t++) {
-            expect(out[t]).toBeCloseTo(0, 9)
-        }
-    })
-
-    it('extensional consistency', () => {
-        const full = calcCMFData(pureUptrend, 10)
-        for (let n = 11; n < pureUptrend.length; n++) {
-            const partial = calcCMFData(pureUptrend.slice(0, n), 10)
-            for (let i = 0; i < n; i++) {
-                if (full[i] !== undefined && partial[i] !== undefined) {
-                    expect(partial[i]).toBeCloseTo(full[i]!, 9)
-                }
-            }
-        }
-    })
-})
-
-describe('calcMFIData', () => {
-    it('empty returns empty', () => {
-        expect(calcMFIData(empty, 14)).toEqual([])
-    })
-
-    it('shorter than period+1 returns all undefined', () => {
-        const out = calcMFIData(pureUptrend.slice(0, 10), 14)
-        for (const v of out) expect(v).toBeUndefined()
-    })
-
-    it('MFI ∈ [0, 100] for all defined values', () => {
-        for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
-            for (const v of calcMFIData(fx, 7)) {
-                if (v !== undefined) {
-                    expect(v).toBeGreaterThanOrEqual(0)
-                    expect(v).toBeLessThanOrEqual(100)
-                }
-            }
-        }
-    })
-
-    it('on pureUptrend MFI = 100 (all positive money flow, no negative)', () => {
-        const out = calcMFIData(pureUptrend, 14)
-        for (let t = 14; t < out.length; t++) {
-            expect(out[t]).toBe(100)
-        }
-    })
-
-    it('on pureDowntrend MFI = 0 (all negative money flow)', () => {
-        const out = calcMFIData(pureDowntrend, 14)
-        for (let t = 14; t < out.length; t++) {
-            expect(out[t]).toBe(0)
-        }
-    })
-
-    it('extensional consistency', () => {
-        const full = calcMFIData(sideways, 7)
-        for (let n = 10; n < sideways.length; n++) {
-            const partial = calcMFIData(sideways.slice(0, n), 7)
-            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 { calcCMFData, calcMFIData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcCMFData', () => {
+    it('empty returns empty', () => {
+        expect(calcCMFData(empty, 20)).toEqual([])
+    })
+
+    it('period <= 0 returns all undefined', () => {
+        const out = calcCMFData(pureUptrend, 0)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('CMF ∈ [-1, 1] for all defined values', () => {
+        for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+            for (const v of calcCMFData(fx, 10)) {
+                if (v !== undefined) {
+                    expect(v).toBeGreaterThanOrEqual(-1)
+                    expect(v).toBeLessThanOrEqual(1)
+                }
+            }
+        }
+    })
+
+    it('on pureUptrend (close=high+1-1=center) CMF stays near 0', () => {
+        // close = 100+i, high = 101+i, low = 99+i → close midway → MFM ≈ 0
+        const out = calcCMFData(pureUptrend, 10)
+        for (let t = 9; t < out.length; t++) {
+            expect(out[t]).toBeCloseTo(0, 9)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcCMFData(pureUptrend, 10)
+        for (let n = 11; n < pureUptrend.length; n++) {
+            const partial = calcCMFData(pureUptrend.slice(0, n), 10)
+            for (let i = 0; i < n; i++) {
+                if (full[i] !== undefined && partial[i] !== undefined) {
+                    expect(partial[i]).toBeCloseTo(full[i]!, 9)
+                }
+            }
+        }
+    })
+})
+
+describe('calcMFIData', () => {
+    it('empty returns empty', () => {
+        expect(calcMFIData(empty, 14)).toEqual([])
+    })
+
+    it('shorter than period+1 returns all undefined', () => {
+        const out = calcMFIData(pureUptrend.slice(0, 10), 14)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('MFI ∈ [0, 100] for all defined values', () => {
+        for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+            for (const v of calcMFIData(fx, 7)) {
+                if (v !== undefined) {
+                    expect(v).toBeGreaterThanOrEqual(0)
+                    expect(v).toBeLessThanOrEqual(100)
+                }
+            }
+        }
+    })
+
+    it('on pureUptrend MFI = 100 (all positive money flow, no negative)', () => {
+        const out = calcMFIData(pureUptrend, 14)
+        for (let t = 14; t < out.length; t++) {
+            expect(out[t]).toBe(100)
+        }
+    })
+
+    it('on pureDowntrend MFI = 0 (all negative money flow)', () => {
+        const out = calcMFIData(pureDowntrend, 14)
+        for (let t = 14; t < out.length; t++) {
+            expect(out[t]).toBe(0)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcMFIData(sideways, 7)
+        for (let n = 10; n < sideways.length; n++) {
+            const partial = calcMFIData(sideways.slice(0, n), 7)
+            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__/dema.test.ts

@@ -1,73 +1,73 @@
-import { describe, it, expect } from 'vitest'
-import { calcDEMAData } from '../calculators'
-import {
-    empty,
-    singleBar,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-import { DEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
-import {
-    assertFiniteOrUndefined,
-} from './_propertyAssertions'
-
-describe('calcDEMAData — Double Exponential Moving Average', () => {
-    describe('edge cases', () => {
-        it('empty returns empty array', () => {
-            expect(calcDEMAData(empty, 20)).toEqual([])
-        })
-
-        it('single bar produces a single defined value (EMA seed = first close)', () => {
-            const out = calcDEMAData(singleBar, 20)
-            expect(out).toHaveLength(1)
-            expect(out[0]).toBeCloseTo(100, 9)
-        })
-
-        it('period = 0 or negative returns all undefined', () => {
-            const zero = calcDEMAData(pureUptrend, 0)
-            for (const v of zero) expect(v).toBeUndefined()
-            const neg = calcDEMAData(pureUptrend, -1)
-            for (const v of neg) expect(v).toBeUndefined()
-        })
-    })
-
-    describe('golden values', () => {
-        it('constantPrice → DEMA(20) = 100 throughout (zero lag at steady state)', () => {
-            assertSeriesClose(calcDEMAData(constantPrice, 20), DEMA_GOLDEN.constantPrice!.series)
-        })
-    })
-
-    describe('mathematical properties', () => {
-        it('all values finite', () => {
-            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
-                assertFiniteOrUndefined(calcDEMAData(fx, 20), 'DEMA series')
-            }
-        })
-
-        it('on linear input close=100+t, DEMA converges toward close[t] (zero-lag property)', () => {
-            // 30-bar fixture isn't enough for full convergence with period=20,
-            // but DEMA should be closer to close[t] than EMA would be.
-            // Just verify monotonic increase tracking the uptrend.
-            const out = calcDEMAData(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 (no leak from later bars into earlier values)', () => {
-            const full = calcDEMAData(pureUptrend, 20)
-            for (let n = 5; n < pureUptrend.length; n++) {
-                const partial = calcDEMAData(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)
-                    }
-                }
-            }
-        })
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcDEMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { DEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcDEMAData — Double Exponential Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcDEMAData(empty, 20)).toEqual([])
+        })
+
+        it('single bar produces a single defined value (EMA seed = first close)', () => {
+            const out = calcDEMAData(singleBar, 20)
+            expect(out).toHaveLength(1)
+            expect(out[0]).toBeCloseTo(100, 9)
+        })
+
+        it('period = 0 or negative returns all undefined', () => {
+            const zero = calcDEMAData(pureUptrend, 0)
+            for (const v of zero) expect(v).toBeUndefined()
+            const neg = calcDEMAData(pureUptrend, -1)
+            for (const v of neg) expect(v).toBeUndefined()
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → DEMA(20) = 100 throughout (zero lag at steady state)', () => {
+            assertSeriesClose(calcDEMAData(constantPrice, 20), DEMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcDEMAData(fx, 20), 'DEMA series')
+            }
+        })
+
+        it('on linear input close=100+t, DEMA converges toward close[t] (zero-lag property)', () => {
+            // 30-bar fixture isn't enough for full convergence with period=20,
+            // but DEMA should be closer to close[t] than EMA would be.
+            // Just verify monotonic increase tracking the uptrend.
+            const out = calcDEMAData(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 (no leak from later bars into earlier values)', () => {
+            const full = calcDEMAData(pureUptrend, 20)
+            for (let n = 5; n < pureUptrend.length; n++) {
+                const partial = calcDEMAData(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__/donchian.test.ts

@@ -1,70 +1,70 @@
-import { describe, it, expect } from 'vitest'
-import { calcDonchianData } from '../calculators'
-import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-
-describe('calcDonchianData', () => {
-    it('empty returns empty', () => {
-        expect(calcDonchianData(empty, 20)).toEqual([])
-    })
-
-    it('shorter than period returns all undefined', () => {
-        const out = calcDonchianData(constantPrice.slice(0, 5), 20)
-        for (const v of out) expect(v).toBeUndefined()
-    })
-
-    it('period <= 0 returns all undefined', () => {
-        const out = calcDonchianData(pureUptrend, 0)
-        for (const v of out) expect(v).toBeUndefined()
-    })
-
-    it('on constantPrice (H=L=100) all bands collapse to 100', () => {
-        const out = calcDonchianData(constantPrice, 20)
-        const valid = out.filter((p) => p !== undefined)
-        expect(valid.length).toBeGreaterThan(0)
-        for (const p of valid) {
-            expect(p!.upper).toBe(100)
-            expect(p!.middle).toBe(100)
-            expect(p!.lower).toBe(100)
-        }
-    })
-
-    it('upper >= middle >= lower invariant', () => {
-        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
-            const out = calcDonchianData(fx, 20)
-            for (const p of out) {
-                if (!p) continue
-                expect(p.upper).toBeGreaterThanOrEqual(p.middle)
-                expect(p.middle).toBeGreaterThanOrEqual(p.lower)
-                expect(p.middle).toBeCloseTo((p.upper + p.lower) / 2, 9)
-            }
-        }
-    })
-
-    it('on pureUptrend, upper at index t equals high[t] (newest is always the maximum)', () => {
-        const out = calcDonchianData(pureUptrend, 20)
-        for (let t = 19; t < out.length; t++) {
-            expect(out[t]!.upper).toBe(pureUptrend[t]!.high)
-        }
-    })
-
-    it('extensional consistency', () => {
-        const full = calcDonchianData(pureUptrend, 20)
-        for (let n = 20; n < pureUptrend.length; n++) {
-            const partial = calcDonchianData(pureUptrend.slice(0, n), 20)
-            for (let i = 0; i < n; i++) {
-                const f = full[i]
-                const p = partial[i]
-                if (f && p) {
-                    expect(p.upper).toBe(f.upper)
-                    expect(p.lower).toBe(f.lower)
-                }
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcDonchianData } from '../calculators'
+import {
+    empty,
+    constantPrice,
+    pureUptrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+
+describe('calcDonchianData', () => {
+    it('empty returns empty', () => {
+        expect(calcDonchianData(empty, 20)).toEqual([])
+    })
+
+    it('shorter than period returns all undefined', () => {
+        const out = calcDonchianData(constantPrice.slice(0, 5), 20)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('period <= 0 returns all undefined', () => {
+        const out = calcDonchianData(pureUptrend, 0)
+        for (const v of out) expect(v).toBeUndefined()
+    })
+
+    it('on constantPrice (H=L=100) all bands collapse to 100', () => {
+        const out = calcDonchianData(constantPrice, 20)
+        const valid = out.filter((p) => p !== undefined)
+        expect(valid.length).toBeGreaterThan(0)
+        for (const p of valid) {
+            expect(p!.upper).toBe(100)
+            expect(p!.middle).toBe(100)
+            expect(p!.lower).toBe(100)
+        }
+    })
+
+    it('upper >= middle >= lower invariant', () => {
+        for (const fx of [pureUptrend, sideways, spikeAtBar19]) {
+            const out = calcDonchianData(fx, 20)
+            for (const p of out) {
+                if (!p) continue
+                expect(p.upper).toBeGreaterThanOrEqual(p.middle)
+                expect(p.middle).toBeGreaterThanOrEqual(p.lower)
+                expect(p.middle).toBeCloseTo((p.upper + p.lower) / 2, 9)
+            }
+        }
+    })
+
+    it('on pureUptrend, upper at index t equals high[t] (newest is always the maximum)', () => {
+        const out = calcDonchianData(pureUptrend, 20)
+        for (let t = 19; t < out.length; t++) {
+            expect(out[t]!.upper).toBe(pureUptrend[t]!.high)
+        }
+    })
+
+    it('extensional consistency', () => {
+        const full = calcDonchianData(pureUptrend, 20)
+        for (let n = 20; n < pureUptrend.length; n++) {
+            const partial = calcDonchianData(pureUptrend.slice(0, n), 20)
+            for (let i = 0; i < n; i++) {
+                const f = full[i]
+                const p = partial[i]
+                if (f && p) {
+                    expect(p.upper).toBe(f.upper)
+                    expect(p.lower).toBe(f.lower)
+                }
+            }
+        }
+    })
+})

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

@@ -1,73 +1,73 @@
-import { describe, it, expect } from 'vitest'
-import { calcHMAData } from '../calculators'
-import {
-    empty,
-    singleBar,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-import { HMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
-import {
-    assertFiniteOrUndefined,
-} from './_propertyAssertions'
-
-describe('calcHMAData — Hull Moving Average', () => {
-    describe('edge cases', () => {
-        it('empty returns empty array', () => {
-            expect(calcHMAData(empty, 9)).toEqual([])
-        })
-
-        it('single bar with period 9 returns [undefined]', () => {
-            expect(calcHMAData(singleBar, 9)).toEqual([undefined])
-        })
-
-        it('period = 0 returns all undefined', () => {
-            const zero = calcHMAData(pureUptrend, 0)
-            for (const v of zero) expect(v).toBeUndefined()
-        })
-
-        it('period = 1 returns close[t] (WMA of WMA of single value is itself)', () => {
-            const out = calcHMAData(pureUptrend, 1)
-            for (let i = 0; i < out.length; i++) {
-                expect(out[i]).toBeCloseTo(pureUptrend[i]!.close, 9)
-            }
-        })
-    })
-
-    describe('golden values', () => {
-        it('constantPrice → HMA(9) = 100 after warm-up', () => {
-            assertSeriesClose(calcHMAData(constantPrice, 9), HMA_GOLDEN.constantPrice!.series)
-        })
-    })
-
-    describe('mathematical properties', () => {
-        it('all values finite (or undefined in warm-up)', () => {
-            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
-                assertFiniteOrUndefined(calcHMAData(fx, 9), 'HMA series')
-            }
-        })
-
-        it('HMA(9) on pureUptrend tracks linear motion with very low lag', () => {
-            const out = calcHMAData(pureUptrend, 9)
-            const tail = out.slice(11).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 = calcHMAData(pureUptrend, 9)
-            for (let n = 12; n < pureUptrend.length; n++) {
-                const partial = calcHMAData(pureUptrend.slice(0, n), 9)
-                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 { calcHMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { HMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcHMAData — Hull Moving Average', () => {
+    describe('edge cases', () => {
+        it('empty returns empty array', () => {
+            expect(calcHMAData(empty, 9)).toEqual([])
+        })
+
+        it('single bar with period 9 returns [undefined]', () => {
+            expect(calcHMAData(singleBar, 9)).toEqual([undefined])
+        })
+
+        it('period = 0 returns all undefined', () => {
+            const zero = calcHMAData(pureUptrend, 0)
+            for (const v of zero) expect(v).toBeUndefined()
+        })
+
+        it('period = 1 returns close[t] (WMA of WMA of single value is itself)', () => {
+            const out = calcHMAData(pureUptrend, 1)
+            for (let i = 0; i < out.length; i++) {
+                expect(out[i]).toBeCloseTo(pureUptrend[i]!.close, 9)
+            }
+        })
+    })
+
+    describe('golden values', () => {
+        it('constantPrice → HMA(9) = 100 after warm-up', () => {
+            assertSeriesClose(calcHMAData(constantPrice, 9), HMA_GOLDEN.constantPrice!.series)
+        })
+    })
+
+    describe('mathematical properties', () => {
+        it('all values finite (or undefined in warm-up)', () => {
+            for (const fx of [pureUptrend, pureDowntrend, sideways, spikeAtBar19]) {
+                assertFiniteOrUndefined(calcHMAData(fx, 9), 'HMA series')
+            }
+        })
+
+        it('HMA(9) on pureUptrend tracks linear motion with very low lag', () => {
+            const out = calcHMAData(pureUptrend, 9)
+            const tail = out.slice(11).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 = calcHMAData(pureUptrend, 9)
+            for (let n = 12; n < pureUptrend.length; n++) {
+                const partial = calcHMAData(pureUptrend.slice(0, n), 9)
+                for (let i = 0; i < n; i++) {
+                    if (full[i] !== undefined && partial[i] !== undefined) {
+                        expect(partial[i]).toBeCloseTo(full[i]!, 9)
+                    }
+                }
+            }
+        })
+    })
+})