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

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

@@ -1,110 +1,110 @@
-import { describe, it, expect } from 'vitest'
-import { calcStructureData } from '../calculators'
-import type { KLineData } from '@/types/price'
-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
-}
-
-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('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 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('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('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)
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcStructureData } from '../calculators'
+import type { KLineData } from '@/types/price'
+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
+}
+
+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('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 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('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('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,65 @@
-import { describe, it, expect } from 'vitest'
-import { calcSuperTrendData } from '../calculators'
-import {
-    empty,
-    pureUptrend,
-    pureDowntrend,
-    spikeAtBar19,
-    gapUp,
-} from './__fixtures__/synthetic'
-
-describe('calcSuperTrendData', () => {
-    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('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 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('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)
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcSuperTrendData } from '../calculators'
+import {
+    empty,
+    pureUptrend,
+    pureDowntrend,
+    spikeAtBar19,
+    gapUp,
+} from './__fixtures__/synthetic'
+
+describe('calcSuperTrendData', () => {
+    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('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 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('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,68 @@
-import { describe, it, expect } from 'vitest'
-import { calcTEMAData } from '../calculators'
-import {
-    empty,
-    singleBar,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
-    spikeAtBar19,
-} from './__fixtures__/synthetic'
-import { TEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
-import {
-    assertFiniteOrUndefined,
-} from './_propertyAssertions'
-
-describe('calcTEMAData — Triple Exponential Moving Average', () => {
-    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('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('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('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)
-                    }
-                }
-            }
-        })
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcTEMAData } from '../calculators'
+import {
+    empty,
+    singleBar,
+    constantPrice,
+    pureUptrend,
+    pureDowntrend,
+    sideways,
+    spikeAtBar19,
+} from './__fixtures__/synthetic'
+import { TEMA_GOLDEN, assertSeriesClose } from './__fixtures__/golden'
+import {
+    assertFiniteOrUndefined,
+} from './_propertyAssertions'
+
+describe('calcTEMAData — Triple Exponential Moving Average', () => {
+    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('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('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('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,
-} 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('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 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('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)
-                }
-            }
-        }
-    })
-})
+import { describe, it, expect } from 'vitest'
+import { calcTRIXData } from '../calculators'
+import {
+    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('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 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('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)
+                }
+            }
+        }
+    })
+})