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

package/src/chartTypes/__tests__/pointAndFigure.test.ts

@@ -3,165 +3,165 @@ import { createPointAndFigure } from '../pointAndFigure'
 import type { OHLCV } from '../types'
 
 const bar = (i: number, o: number, h: number, l: number, c: number, v = 100): OHLCV => ({
-    timestamp: 1_700_000_000_000 + i * 60_000,
-    open: o,
-    high: h,
-    low: l,
-    close: c,
-    volume: v,
+  timestamp: 1_700_000_000_000 + i * 60_000,
+  open: o,
+  high: h,
+  low: l,
+  close: c,
+  volume: v,
 })
 
 describe('pointAndFigure', () => {
-    it('simple uptrend produces a single X column (batch includes in-progress)', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform(
-            [
-                bar(0, 100, 100, 100, 100),
-                bar(1, 100, 110, 100, 110),
-                bar(2, 110, 120, 110, 120),
-                bar(3, 120, 130, 120, 130),
-            ],
-            { boxSize: 10, reversal: 3 },
-        )
-        expect(out).toHaveLength(1)
-        expect(out[0]!.meta?.direction).toBe('up')
-        expect(out[0]!.high).toBeGreaterThan(out[0]!.low)
-    })
+  it('simple uptrend produces a single X column (batch includes in-progress)', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform(
+      [
+        bar(0, 100, 100, 100, 100),
+        bar(1, 100, 110, 100, 110),
+        bar(2, 110, 120, 110, 120),
+        bar(3, 120, 130, 120, 130),
+      ],
+      { boxSize: 10, reversal: 3 },
+    )
+    expect(out).toHaveLength(1)
+    expect(out[0]!.meta?.direction).toBe('up')
+    expect(out[0]!.high).toBeGreaterThan(out[0]!.low)
+  })
 
-    it('a 3-box reversal closes the X column and opens an O column', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform(
-            [
-                bar(0, 100, 100, 100, 100),
-                bar(1, 100, 130, 100, 130), // big X column up to 130
-                bar(2, 130, 130, 90, 90), // drops 40 (4 boxes), reversal of 3 met
-            ],
-            { boxSize: 10, reversal: 3 },
-        )
-        const directions = out.map((b) => b.meta?.direction)
-        expect(directions).toContain('up')
-        expect(directions).toContain('down')
-        // First (closed) column is the X.
-        expect(out[0]!.meta?.direction).toBe('up')
-    })
+  it('a 3-box reversal closes the X column and opens an O column', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform(
+      [
+        bar(0, 100, 100, 100, 100),
+        bar(1, 100, 130, 100, 130), // big X column up to 130
+        bar(2, 130, 130, 90, 90), // drops 40 (4 boxes), reversal of 3 met
+      ],
+      { boxSize: 10, reversal: 3 },
+    )
+    const directions = out.map((b) => b.meta?.direction)
+    expect(directions).toContain('up')
+    expect(directions).toContain('down')
+    // First (closed) column is the X.
+    expect(out[0]!.meta?.direction).toBe('up')
+  })
 
-    it('a 2-box reversal stays in the same X column (no flip)', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform(
-            [
-                bar(0, 100, 100, 100, 100),
-                bar(1, 100, 130, 100, 130),
-                bar(2, 130, 130, 115, 115), // only 1.5 boxes down — below threshold
-            ],
-            { boxSize: 10, reversal: 3 },
-        )
-        // Only the in-progress X column should be present.
-        expect(out).toHaveLength(1)
-        expect(out[0]!.meta?.direction).toBe('up')
-    })
+  it('a 2-box reversal stays in the same X column (no flip)', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform(
+      [
+        bar(0, 100, 100, 100, 100),
+        bar(1, 100, 130, 100, 130),
+        bar(2, 130, 130, 115, 115), // only 1.5 boxes down — below threshold
+      ],
+      { boxSize: 10, reversal: 3 },
+    )
+    // Only the in-progress X column should be present.
+    expect(out).toHaveLength(1)
+    expect(out[0]!.meta?.direction).toBe('up')
+  })
 
-    it('alternating chop emits multiple columns at the reversal threshold', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform(
-            [
-                bar(0, 100, 100, 100, 100),
-                bar(1, 100, 130, 100, 130), // X up to 130
-                bar(2, 130, 130, 90, 90), // O down (reverse, 4 boxes)
-                bar(3, 90, 130, 90, 130), // X back up (reverse from O, 4 boxes)
-                bar(4, 130, 130, 90, 90), // O down again
-            ],
-            { boxSize: 10, reversal: 3 },
-        )
-        const closed = out.filter((b) => b.sourceBarIndexEnd < 4)
-        // Expect at least 3 alternating-direction closed columns.
-        expect(closed.length).toBeGreaterThanOrEqual(3)
-        const dirs = closed.map((b) => b.meta?.direction)
-        // No two consecutive closed columns have the same direction.
-        for (let i = 1; i < dirs.length; i++) {
-            expect(dirs[i]).not.toBe(dirs[i - 1])
-        }
-    })
+  it('alternating chop emits multiple columns at the reversal threshold', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform(
+      [
+        bar(0, 100, 100, 100, 100),
+        bar(1, 100, 130, 100, 130), // X up to 130
+        bar(2, 130, 130, 90, 90), // O down (reverse, 4 boxes)
+        bar(3, 90, 130, 90, 130), // X back up (reverse from O, 4 boxes)
+        bar(4, 130, 130, 90, 90), // O down again
+      ],
+      { boxSize: 10, reversal: 3 },
+    )
+    const closed = out.filter((b) => b.sourceBarIndexEnd < 4)
+    // Expect at least 3 alternating-direction closed columns.
+    expect(closed.length).toBeGreaterThanOrEqual(3)
+    const dirs = closed.map((b) => b.meta?.direction)
+    // No two consecutive closed columns have the same direction.
+    for (let i = 1; i < dirs.length; i++) {
+      expect(dirs[i]).not.toBe(dirs[i - 1])
+    }
+  })
 
-    it('first bar seeds an X column with low/high snapped to box boundaries', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform([bar(0, 103, 117, 102, 115)], { boxSize: 5, reversal: 3 })
-        expect(out).toHaveLength(1)
-        // low 102 -> 100 (floor of 5), high 117 -> 115 (floor of 5).
-        expect(out[0]!.low).toBeCloseTo(100, 10)
-        expect(out[0]!.high).toBeCloseTo(115, 10)
-        expect(out[0]!.meta?.direction).toBe('up')
-    })
+  it('first bar seeds an X column with low/high snapped to box boundaries', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform([bar(0, 103, 117, 102, 115)], { boxSize: 5, reversal: 3 })
+    expect(out).toHaveLength(1)
+    // low 102 -> 100 (floor of 5), high 117 -> 115 (floor of 5).
+    expect(out[0]!.low).toBeCloseTo(100, 10)
+    expect(out[0]!.high).toBeCloseTo(115, 10)
+    expect(out[0]!.meta?.direction).toBe('up')
+  })
 
-    it('column open and close match the column endpoints', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform(
-            [bar(0, 100, 100, 100, 100), bar(1, 100, 130, 100, 130)],
-            { boxSize: 10, reversal: 3 },
-        )
-        const col = out[0]!
-        // X column: open = start price, close = end price = high.
-        expect(col.open).toBeLessThanOrEqual(col.close)
-        expect(col.close).toBe(col.high)
+  it('column open and close match the column endpoints', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform([bar(0, 100, 100, 100, 100), bar(1, 100, 130, 100, 130)], {
+      boxSize: 10,
+      reversal: 3,
     })
+    const col = out[0]!
+    // X column: open = start price, close = end price = high.
+    expect(col.open).toBeLessThanOrEqual(col.close)
+    expect(col.close).toBe(col.high)
+  })
 
-    it('reversal exactly at threshold triggers a flip (>=, not >)', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform(
-            [
-                bar(0, 100, 100, 100, 100),
-                bar(1, 100, 130, 100, 130),
-                bar(2, 130, 130, 100, 100), // exactly 3 boxes (30) down — at threshold
-            ],
-            { boxSize: 10, reversal: 3 },
-        )
-        const dirs = out.map((b) => b.meta?.direction)
-        expect(dirs).toContain('up')
-        expect(dirs).toContain('down')
-    })
+  it('reversal exactly at threshold triggers a flip (>=, not >)', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform(
+      [
+        bar(0, 100, 100, 100, 100),
+        bar(1, 100, 130, 100, 130),
+        bar(2, 130, 130, 100, 100), // exactly 3 boxes (30) down — at threshold
+      ],
+      { boxSize: 10, reversal: 3 },
+    )
+    const dirs = out.map((b) => b.meta?.direction)
+    expect(dirs).toContain('up')
+    expect(dirs).toContain('down')
+  })
 
-    it('empty input yields empty output', () => {
-        const pf = createPointAndFigure()
-        const out = pf.transform([], { boxSize: 10, reversal: 3 })
-        expect(out).toEqual([])
-    })
+  it('empty input yields empty output', () => {
+    const pf = createPointAndFigure()
+    const out = pf.transform([], { boxSize: 10, reversal: 3 })
+    expect(out).toEqual([])
+  })
 
-    it('throws on invalid config', () => {
-        expect(() => createPointAndFigure().transform([], { boxSize: 0, reversal: 3 })).toThrow()
-        expect(() => createPointAndFigure().transform([], { boxSize: 10, reversal: 0 })).toThrow()
-    })
+  it('throws on invalid config', () => {
+    expect(() => createPointAndFigure().transform([], { boxSize: 0, reversal: 3 })).toThrow()
+    expect(() => createPointAndFigure().transform([], { boxSize: 10, reversal: 0 })).toThrow()
+  })
 
-    it('incremental closed columns match batch closed columns', () => {
-        const series: OHLCV[] = [
-            bar(0, 100, 100, 100, 100),
-            bar(1, 100, 130, 100, 130),
-            bar(2, 130, 130, 90, 90),
-            bar(3, 90, 130, 90, 130),
-            bar(4, 130, 130, 100, 100),
-            bar(5, 100, 140, 100, 140),
-        ]
-        const batch = createPointAndFigure().transform(series, { boxSize: 10, reversal: 3 })
-        const inc = createPointAndFigure()
-        inc.transform([], { boxSize: 10, reversal: 3 })
-        const incremental: ReturnType<typeof inc.transform> = []
-        for (const b of series) {
-            for (const out of inc.appendBar!(b)) incremental.push(out)
-        }
-        // Batch may include a final in-progress column. Compare CLOSED prefix.
-        const batchClosed = batch.slice(0, incremental.length)
-        expect(incremental.length).toBe(batchClosed.length)
-        for (let i = 0; i < batchClosed.length; i++) {
-            expect(batchClosed[i]!.open).toBeCloseTo(incremental[i]!.open, 10)
-            expect(batchClosed[i]!.close).toBeCloseTo(incremental[i]!.close, 10)
-            expect(batchClosed[i]!.meta?.direction).toBe(incremental[i]!.meta?.direction)
-        }
-    })
+  it('incremental closed columns match batch closed columns', () => {
+    const series: OHLCV[] = [
+      bar(0, 100, 100, 100, 100),
+      bar(1, 100, 130, 100, 130),
+      bar(2, 130, 130, 90, 90),
+      bar(3, 90, 130, 90, 130),
+      bar(4, 130, 130, 100, 100),
+      bar(5, 100, 140, 100, 140),
+    ]
+    const batch = createPointAndFigure().transform(series, { boxSize: 10, reversal: 3 })
+    const inc = createPointAndFigure()
+    inc.transform([], { boxSize: 10, reversal: 3 })
+    const incremental: ReturnType<typeof inc.transform> = []
+    for (const b of series) {
+      for (const out of inc.appendBar!(b)) incremental.push(out)
+    }
+    // Batch may include a final in-progress column. Compare CLOSED prefix.
+    const batchClosed = batch.slice(0, incremental.length)
+    expect(incremental.length).toBe(batchClosed.length)
+    for (let i = 0; i < batchClosed.length; i++) {
+      expect(batchClosed[i]!.open).toBeCloseTo(incremental[i]!.open, 10)
+      expect(batchClosed[i]!.close).toBeCloseTo(incremental[i]!.close, 10)
+      expect(batchClosed[i]!.meta?.direction).toBe(incremental[i]!.meta?.direction)
+    }
+  })
 
-    it('reset() returns to a seed state', () => {
-        const pf = createPointAndFigure()
-        pf.transform([bar(0, 100, 130, 100, 130)], { boxSize: 10, reversal: 3 })
-        pf.reset!()
-        const out = pf.appendBar!(bar(1, 200, 215, 200, 215))
-        // No closed columns yet; in-progress is now an X anchored at 200/215.
-        expect(out).toEqual([])
-    })
+  it('reset() returns to a seed state', () => {
+    const pf = createPointAndFigure()
+    pf.transform([bar(0, 100, 130, 100, 130)], { boxSize: 10, reversal: 3 })
+    pf.reset!()
+    const out = pf.appendBar!(bar(1, 200, 215, 200, 215))
+    // No closed columns yet; in-progress is now an X anchored at 200/215.
+    expect(out).toEqual([])
+  })
 })

package/src/chartTypes/__tests__/rangeBars.test.ts

@@ -3,144 +3,144 @@ import { createRangeBars } from '../rangeBars'
 import type { OHLCV } from '../types'
 
 const bar = (i: number, o: number, h: number, l: number, c: number, v = 100): OHLCV => ({
-    timestamp: 1_700_000_000_000 + i * 60_000,
-    open: o,
-    high: h,
-    low: l,
-    close: c,
-    volume: v,
+  timestamp: 1_700_000_000_000 + i * 60_000,
+  open: o,
+  high: h,
+  low: l,
+  close: c,
+  volume: v,
 })
 
 describe('rangeBars', () => {
-    it('simple trending input produces range bars whose span = range', () => {
-        const r = createRangeBars()
-        const out = r.transform(
-            [
-                bar(0, 100, 102, 99, 101),
-                bar(1, 101, 105, 100, 104),
-                bar(2, 104, 110, 103, 109),
-                bar(3, 109, 115, 108, 114),
-            ],
-            { range: 5 },
-        )
-        // The closed bars must each have span === 5 (within fp tolerance).
-        const closedBars = out.slice(0, -1)
-        for (const b of closedBars) {
-            expect(b.high - b.low).toBeCloseTo(5, 8)
-        }
-    })
+  it('simple trending input produces range bars whose span = range', () => {
+    const r = createRangeBars()
+    const out = r.transform(
+      [
+        bar(0, 100, 102, 99, 101),
+        bar(1, 101, 105, 100, 104),
+        bar(2, 104, 110, 103, 109),
+        bar(3, 109, 115, 108, 114),
+      ],
+      { range: 5 },
+    )
+    // The closed bars must each have span === 5 (within fp tolerance).
+    const closedBars = out.slice(0, -1)
+    for (const b of closedBars) {
+      expect(b.high - b.low).toBeCloseTo(5, 8)
+    }
+  })
 
-    it('sideways input within range emits no closed bars', () => {
-        const r = createRangeBars()
-        const out = r.transform(
-            [bar(0, 100, 101, 99, 100), bar(1, 100, 102, 99, 101), bar(2, 101, 102, 99, 100)],
-            { range: 10 },
-        )
-        // Only the in-progress bar should be present.
-        expect(out).toHaveLength(1)
-    })
+  it('sideways input within range emits no closed bars', () => {
+    const r = createRangeBars()
+    const out = r.transform(
+      [bar(0, 100, 101, 99, 100), bar(1, 100, 102, 99, 101), bar(2, 101, 102, 99, 100)],
+      { range: 10 },
+    )
+    // Only the in-progress bar should be present.
+    expect(out).toHaveLength(1)
+  })
 
-    it('first bar establishes the first range', () => {
-        const r = createRangeBars()
-        const out = r.transform([bar(0, 100, 101, 99, 100)], { range: 10 })
-        expect(out).toHaveLength(1)
-        expect(out[0]!.open).toBe(100)
-    })
+  it('first bar establishes the first range', () => {
+    const r = createRangeBars()
+    const out = r.transform([bar(0, 100, 101, 99, 100)], { range: 10 })
+    expect(out).toHaveLength(1)
+    expect(out[0]!.open).toBe(100)
+  })
 
-    it('input bar exceeding range splits into multiple output bars', () => {
-        const r = createRangeBars()
-        // A wide input bar spanning 50 units with range 10 should split into ~5 bars.
-        const out = r.transform([bar(0, 100, 150, 100, 150)], { range: 10 })
-        const closed = out.filter((b) => Math.abs(b.high - b.low - 10) < 1e-6)
-        expect(closed.length).toBeGreaterThanOrEqual(4)
-    })
+  it('input bar exceeding range splits into multiple output bars', () => {
+    const r = createRangeBars()
+    // A wide input bar spanning 50 units with range 10 should split into ~5 bars.
+    const out = r.transform([bar(0, 100, 150, 100, 150)], { range: 10 })
+    const closed = out.filter((b) => Math.abs(b.high - b.low - 10) < 1e-6)
+    expect(closed.length).toBeGreaterThanOrEqual(4)
+  })
 
-    it('exact-range boundary triggers immediate close', () => {
-        const r = createRangeBars()
-        // Single bar with H - L == 10 exactly.
-        const out = r.transform([bar(0, 100, 110, 100, 110)], { range: 10 })
-        // At least one bar must have closed.
-        const closed = out.filter((_, i, arr) => i < arr.length - 1)
-        expect(closed.length).toBeGreaterThanOrEqual(1)
-    })
+  it('exact-range boundary triggers immediate close', () => {
+    const r = createRangeBars()
+    // Single bar with H - L == 10 exactly.
+    const out = r.transform([bar(0, 100, 110, 100, 110)], { range: 10 })
+    // At least one bar must have closed.
+    const closed = out.filter((_, i, arr) => i < arr.length - 1)
+    expect(closed.length).toBeGreaterThanOrEqual(1)
+  })
 
-    it('volume is aggregated across input bars within one range bar', () => {
-        const r = createRangeBars()
-        // Three sideways bars accumulate into one open range bar.
-        const out = r.transform(
-            [bar(0, 100, 101, 99, 100, 50), bar(1, 100, 102, 99, 101, 60), bar(2, 101, 102, 99, 100, 70)],
-            { range: 10 },
-        )
-        // The only present bar (the open one) should hold the summed volume.
-        expect(out).toHaveLength(1)
-        expect(out[0]!.volume).toBe(50 + 60 + 70)
-    })
+  it('volume is aggregated across input bars within one range bar', () => {
+    const r = createRangeBars()
+    // Three sideways bars accumulate into one open range bar.
+    const out = r.transform(
+      [bar(0, 100, 101, 99, 100, 50), bar(1, 100, 102, 99, 101, 60), bar(2, 101, 102, 99, 100, 70)],
+      { range: 10 },
+    )
+    // The only present bar (the open one) should hold the summed volume.
+    expect(out).toHaveLength(1)
+    expect(out[0]!.volume).toBe(50 + 60 + 70)
+  })
 
-    it('split input bar distributes volume proportionally (no spike on first)', () => {
-        const r = createRangeBars()
-        const out = r.transform([bar(0, 100, 150, 100, 150, 500)], { range: 10 })
-        const closed = out.slice(0, -1)
-        expect(closed.length).toBeGreaterThan(1)
-        // No single closed bar should hold all the volume.
-        for (const b of closed) {
-            expect(b.volume).toBeLessThan(500)
-        }
-        // The sum across closed + open should not exceed the input volume.
-        const total = out.reduce((s, b) => s + b.volume, 0)
-        expect(total).toBeLessThanOrEqual(500 + 1e-6)
-    })
+  it('split input bar distributes volume proportionally (no spike on first)', () => {
+    const r = createRangeBars()
+    const out = r.transform([bar(0, 100, 150, 100, 150, 500)], { range: 10 })
+    const closed = out.slice(0, -1)
+    expect(closed.length).toBeGreaterThan(1)
+    // No single closed bar should hold all the volume.
+    for (const b of closed) {
+      expect(b.volume).toBeLessThan(500)
+    }
+    // The sum across closed + open should not exceed the input volume.
+    const total = out.reduce((s, b) => s + b.volume, 0)
+    expect(total).toBeLessThanOrEqual(500 + 1e-6)
+  })
 
-    it('empty input yields empty output', () => {
-        const r = createRangeBars()
-        const out = r.transform([], { range: 5 })
-        expect(out).toEqual([])
-    })
+  it('empty input yields empty output', () => {
+    const r = createRangeBars()
+    const out = r.transform([], { range: 5 })
+    expect(out).toEqual([])
+  })
 
-    it('throws on invalid range', () => {
-        expect(() => createRangeBars().transform([], { range: 0 })).toThrow()
-        expect(() => createRangeBars().transform([], { range: -1 })).toThrow()
-    })
+  it('throws on invalid range', () => {
+    expect(() => createRangeBars().transform([], { range: 0 })).toThrow()
+    expect(() => createRangeBars().transform([], { range: -1 })).toThrow()
+  })
 
-    it('incremental closed bars match batch closed bars on a random series', () => {
-        let seed = 7
-        const rand = () => {
-            seed = (seed * 1103515245 + 12345) & 0x7fffffff
-            return seed / 0x7fffffff
-        }
-        const series: OHLCV[] = []
-        let price = 100
-        for (let i = 0; i < 30; i++) {
-            const drift = (rand() - 0.5) * 4
-            const close = price + drift
-            const high = Math.max(price, close) + rand() * 1.5
-            const low = Math.min(price, close) - rand() * 1.5
-            series.push(bar(i, price, high, low, close, Math.floor(rand() * 100)))
-            price = close
-        }
-        const batch = createRangeBars().transform(series, { range: 3 })
-        const inc = createRangeBars()
-        inc.transform([], { range: 3 })
-        const incremental: ReturnType<typeof inc.transform> = []
-        for (const b of series) {
-            for (const out of inc.appendBar!(b)) incremental.push(out)
-        }
-        // Batch includes the final in-progress bar. Compare closed prefix.
-        const batchClosed = batch.slice(0, incremental.length)
-        expect(incremental.length).toBe(batchClosed.length)
-        for (let i = 0; i < batchClosed.length; i++) {
-            expect(batchClosed[i]!.open).toBeCloseTo(incremental[i]!.open, 8)
-            expect(batchClosed[i]!.close).toBeCloseTo(incremental[i]!.close, 8)
-            // Span equals range within fp tolerance for every closed bar.
-            expect(Math.abs(incremental[i]!.high - incremental[i]!.low - 3)).toBeLessThan(1e-6)
-        }
-    })
+  it('incremental closed bars match batch closed bars on a random series', () => {
+    let seed = 7
+    const rand = () => {
+      seed = (seed * 1103515245 + 12345) & 0x7fffffff
+      return seed / 0x7fffffff
+    }
+    const series: OHLCV[] = []
+    let price = 100
+    for (let i = 0; i < 30; i++) {
+      const drift = (rand() - 0.5) * 4
+      const close = price + drift
+      const high = Math.max(price, close) + rand() * 1.5
+      const low = Math.min(price, close) - rand() * 1.5
+      series.push(bar(i, price, high, low, close, Math.floor(rand() * 100)))
+      price = close
+    }
+    const batch = createRangeBars().transform(series, { range: 3 })
+    const inc = createRangeBars()
+    inc.transform([], { range: 3 })
+    const incremental: ReturnType<typeof inc.transform> = []
+    for (const b of series) {
+      for (const out of inc.appendBar!(b)) incremental.push(out)
+    }
+    // Batch includes the final in-progress bar. Compare closed prefix.
+    const batchClosed = batch.slice(0, incremental.length)
+    expect(incremental.length).toBe(batchClosed.length)
+    for (let i = 0; i < batchClosed.length; i++) {
+      expect(batchClosed[i]!.open).toBeCloseTo(incremental[i]!.open, 8)
+      expect(batchClosed[i]!.close).toBeCloseTo(incremental[i]!.close, 8)
+      // Span equals range within fp tolerance for every closed bar.
+      expect(Math.abs(incremental[i]!.high - incremental[i]!.low - 3)).toBeLessThan(1e-6)
+    }
+  })
 
-    it('reset() drops state so the next series starts clean', () => {
-        const r = createRangeBars()
-        r.transform([bar(0, 100, 110, 100, 110)], { range: 10 })
-        r.reset!()
-        const out = r.appendBar!(bar(1, 200, 201, 199, 200))
-        // First post-reset bar should not have closed anything (range not met).
-        expect(out).toEqual([])
-    })
+  it('reset() drops state so the next series starts clean', () => {
+    const r = createRangeBars()
+    r.transform([bar(0, 100, 110, 100, 110)], { range: 10 })
+    r.reset!()
+    const out = r.appendBar!(bar(1, 200, 201, 199, 200))
+    // First post-reset bar should not have closed anything (range not met).
+    expect(out).toEqual([])
+  })
 })