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

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

@@ -0,0 +1,167 @@
+import { describe, it, expect } from 'vitest'
+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,
+})
+
+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('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('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('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('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('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([])
+    })
+})

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

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+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,
+})
+
+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('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('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('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('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('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([])
+    })
+})

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

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest'
+import { createRenko } from '../renko'
+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,
+})
+
+describe('renko', () => {
+    it('rising prices emit up-bricks', () => {
+        const r = createRenko()
+        // Anchor at close 100, then push close up 30 (3 bricks of 10).
+        const out = r.transform([bar(0, 100, 100, 100, 100), bar(1, 100, 130, 100, 130)], { brickSize: 10 })
+        expect(out).toHaveLength(3)
+        for (const b of out) {
+            expect(b.meta?.direction).toBe('up')
+            expect(b.close).toBeGreaterThan(b.open)
+        }
+        // Brick closes form a 10-unit ladder.
+        expect(out[0]!.close - out[0]!.open).toBeCloseTo(10, 10)
+        expect(out[2]!.close).toBeCloseTo(130, 10)
+    })
+
+    it('falling prices emit down-bricks', () => {
+        const r = createRenko()
+        const out = r.transform([bar(0, 100, 100, 100, 100), bar(1, 100, 100, 70, 70)], { brickSize: 10 })
+        expect(out).toHaveLength(3)
+        for (const b of out) {
+            expect(b.meta?.direction).toBe('down')
+            expect(b.close).toBeLessThan(b.open)
+        }
+        expect(out[2]!.close).toBeCloseTo(70, 10)
+    })
+
+    it('sideways prices within brickSize emit no bricks', () => {
+        const r = createRenko()
+        const out = r.transform(
+            [
+                bar(0, 100, 100, 100, 100),
+                bar(1, 100, 105, 95, 103),
+                bar(2, 103, 106, 98, 102),
+                bar(3, 102, 109, 100, 108),
+            ],
+            { brickSize: 10 },
+        )
+        expect(out).toHaveLength(0)
+    })
+
+    it('reversal requires 2x brickSize after an up-brick', () => {
+        const r = createRenko()
+        // Anchor at 100, push up to 110 (one up-brick from 100->110).
+        // Then a 1x brickSize move down (to 100) should NOT reverse.
+        const out1 = r.transform(
+            [bar(0, 100, 100, 100, 100), bar(1, 100, 110, 100, 110), bar(2, 110, 110, 100, 100)],
+            { brickSize: 10 },
+        )
+        // Only the original up-brick should be emitted.
+        expect(out1).toHaveLength(1)
+        expect(out1[0]!.meta?.direction).toBe('up')
+
+        // 2x brickSize move down DOES reverse (down to 90 = 110 - 20).
+        const r2 = createRenko()
+        const out2 = r2.transform(
+            [bar(0, 100, 100, 100, 100), bar(1, 100, 110, 100, 110), bar(2, 110, 110, 90, 90)],
+            { brickSize: 10 },
+        )
+        expect(out2.length).toBeGreaterThanOrEqual(2)
+        expect(out2[0]!.meta?.direction).toBe('up')
+        expect(out2[1]!.meta?.direction).toBe('down')
+    })
+
+    it('ATR mode produces brick size from rolling ATR (no bricks until window fills)', () => {
+        const r = createRenko()
+        // ATR period 3 — no bricks until the third bar's TR fills the window.
+        const series: OHLCV[] = [
+            bar(0, 100, 102, 99, 101),
+            bar(1, 101, 103, 100, 102),
+            bar(2, 102, 104, 101, 103),
+            bar(3, 103, 120, 102, 119),
+        ]
+        const out = r.transform(series, { useATR: { period: 3 } })
+        // After bar 3 the window has 4 TR values; brickSize is the rolling mean
+        // of the last 3. Should emit at least one up-brick from the +16 move.
+        expect(out.length).toBeGreaterThan(0)
+        for (const b of out) {
+            expect(b.meta?.direction).toBe('up')
+            expect(b.meta?.brickSize).toBeGreaterThan(0)
+        }
+    })
+
+    it('incremental mode matches batch mode on a random series', () => {
+        let seed = 99
+        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) * 6
+            const close = price + drift
+            const high = Math.max(price, close) + rand() * 2
+            const low = Math.min(price, close) - rand() * 2
+            series.push(bar(i, price, high, low, close, Math.floor(rand() * 100)))
+            price = close
+        }
+        const batch = createRenko().transform(series, { brickSize: 3 })
+        const inc = createRenko()
+        const incremental: ReturnType<typeof inc.transform> = []
+        // Prime config via transform on empty array (sets activeConfig)…
+        inc.transform([], { brickSize: 3 })
+        for (const b of series) {
+            for (const out of inc.appendBar!(b)) incremental.push(out)
+        }
+        expect(incremental.length).toBe(batch.length)
+        for (let i = 0; i < batch.length; i++) {
+            expect(batch[i]!.open).toBeCloseTo(incremental[i]!.open, 10)
+            expect(batch[i]!.close).toBeCloseTo(incremental[i]!.close, 10)
+            expect(batch[i]!.meta?.direction).toBe(incremental[i]!.meta?.direction)
+        }
+    })
+
+    it('large gap close emits multiple bricks from one input bar', () => {
+        const r = createRenko()
+        const out = r.transform([bar(0, 100, 100, 100, 100), bar(1, 100, 200, 100, 200)], { brickSize: 10 })
+        // 100 -> 200 across one bar should emit 10 up-bricks.
+        expect(out).toHaveLength(10)
+        // Only the first brick from that source bar carries its volume; the
+        // rest are zero (see file header comment).
+        expect(out[0]!.volume).toBe(100)
+        expect(out[1]!.volume).toBe(0)
+        expect(out[9]!.close).toBeCloseTo(200, 10)
+    })
+
+    it('empty input yields empty output', () => {
+        const r = createRenko()
+        const out = r.transform([], { brickSize: 5 })
+        expect(out).toEqual([])
+    })
+
+    it('throws on invalid config', () => {
+        expect(() => createRenko().transform([], { brickSize: 0 })).toThrow()
+        expect(() => createRenko().transform([], {})).toThrow()
+        expect(() => createRenko().transform([], { useATR: { period: 0 } })).toThrow()
+    })
+
+    it('reset() drops state so the next series starts fresh', () => {
+        const r = createRenko()
+        r.transform([bar(0, 100, 100, 100, 100), bar(1, 100, 150, 100, 150)], { brickSize: 10 })
+        r.reset!()
+        // After reset the next bar anchors the new series — no bricks yet.
+        const out = r.appendBar!(bar(2, 200, 200, 200, 200))
+        expect(out).toHaveLength(0)
+    })
+})

package/src/chartTypes/heikinAshi.ts

@@ -0,0 +1,116 @@
+/**
+ * Heikin Ashi — "average bar" smoothing of an OHLCV series.
+ *
+ * Heikin Ashi (平均足) was popularised by Munehisa Homma; the modern formula
+ * is the one taught by Dan Valcu. It produces a one-to-one transform — each
+ * input bar yields exactly one output bar — but the values are smoothed so
+ * trends visually persist through noise.
+ *
+ * ## Formula
+ *
+ *     HA_close[i]  = (O[i] + H[i] + L[i] + C[i]) / 4
+ *     HA_open[i]   = (HA_open[i-1] + HA_close[i-1]) / 2          for i >= 1
+ *     HA_open[0]   = (O[0] + C[0]) / 2                            (seed)
+ *     HA_high[i]   = max(H[i], HA_open[i], HA_close[i])
+ *     HA_low[i]    = min(L[i], HA_open[i], HA_close[i])
+ *     HA_volume[i] = V[i]                                         (unchanged)
+ *
+ * The seed for `HA_open[0]` is the standard convention used by all major
+ * charting platforms (TradingView, MetaTrader). An alternative seed of
+ * `O[0]` exists in some older books but produces a slightly different shape
+ * for the first bar; we follow the modern convention.
+ *
+ * ## Trade-offs
+ *
+ *  - Volume is **not** smoothed. Smoothing volume distorts indicators that
+ *    consume the derived series (OBV, VWAP, CMF), so we keep it raw. This
+ *    matches TradingView's behaviour.
+ *  - Output `timestamp` equals input `timestamp` — Heikin Ashi does not
+ *    re-bucket time.
+ *
+ * ## Statefulness
+ *
+ * The transform carries `HA_open[i-1]` and `HA_close[i-1]` between calls so
+ * `appendBar` produces the same result as a batch `transform` over the same
+ * series. The `reset()` method clears that carry.
+ */
+
+import type { ChartTypeTransform, OHLCV, TransformedBar } from './types'
+
+/** Heikin Ashi has no configuration. The empty type makes the contract explicit. */
+export type HeikinAshiConfig = Record<string, never>
+
+interface HAState {
+    /** Previous HA_open. */
+    prevOpen: number
+    /** Previous HA_close. */
+    prevClose: number
+    /** Index of the next input bar (i.e. count of bars consumed so far). */
+    nextIndex: number
+}
+
+/**
+ * Build a Heikin Ashi transform. The returned object is stateful — `transform`
+ * resets state before running, `appendBar` mutates state, `reset` clears it.
+ *
+ * The factory pattern (rather than a singleton) matches the controller style
+ * elsewhere in this package — multiple panes can each hold their own
+ * independent transform without crossed state.
+ */
+export function createHeikinAshi(): ChartTypeTransform<HeikinAshiConfig> {
+    let state: HAState | null = null
+
+    /**
+     * Compute one HA bar. `prev` is `null` for the very first bar in a series,
+     * which triggers the seed `HA_open = (O + C) / 2`.
+     */
+    const computeBar = (
+        bar: OHLCV,
+        prev: { prevOpen: number; prevClose: number } | null,
+        sourceIndex: number,
+    ): TransformedBar => {
+        const haClose = (bar.open + bar.high + bar.low + bar.close) / 4
+        const haOpen = prev === null ? (bar.open + bar.close) / 2 : (prev.prevOpen + prev.prevClose) / 2
+        const haHigh = Math.max(bar.high, haOpen, haClose)
+        const haLow = Math.min(bar.low, haOpen, haClose)
+        return {
+            timestamp: bar.timestamp,
+            open: haOpen,
+            high: haHigh,
+            low: haLow,
+            close: haClose,
+            volume: bar.volume,
+            sourceBarIndexStart: sourceIndex,
+            sourceBarIndexEnd: sourceIndex,
+        }
+    }
+
+    return {
+        typeId: 'heikin-ashi',
+
+        transform(input: ReadonlyArray<OHLCV>): ReadonlyArray<TransformedBar> {
+            state = null
+            const out: TransformedBar[] = []
+            for (let i = 0; i < input.length; i++) {
+                const bar = input[i]
+                if (!bar) continue
+                const ha = computeBar(bar, state === null ? null : { prevOpen: state.prevOpen, prevClose: state.prevClose }, i)
+                out.push(ha)
+                state = { prevOpen: ha.open, prevClose: ha.close, nextIndex: i + 1 }
+            }
+            return out
+        },
+
+        appendBar(bar: OHLCV): ReadonlyArray<TransformedBar> {
+            const prev = state === null ? null : { prevOpen: state.prevOpen, prevClose: state.prevClose }
+            const nextIndex = state === null ? 0 : state.nextIndex
+            const ha = computeBar(bar, prev, nextIndex)
+            state = { prevOpen: ha.open, prevClose: ha.close, nextIndex: nextIndex + 1 }
+            return [ha]
+        },
+
+        reset(): void {
+            state = null
+        },
+    }
+}

package/src/chartTypes/index.ts

@@ -0,0 +1,5 @@
+export type { OHLCV, TransformedBar, ChartTypeTransform } from './types'
+export { createHeikinAshi } from './heikinAshi'
+export { createRenko, type RenkoConfig } from './renko'
+export { createPointAndFigure, type PointAndFigureConfig } from './pointAndFigure'
+export { createRangeBars, type RangeBarsConfig } from './rangeBars'