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

package/dist/chartTypes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chartTypes/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAClF,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAA"}

package/dist/chartTypes/index.js

@@ -0,0 +1,5 @@
+export { createHeikinAshi } from './heikinAshi';
+export { createRenko } from './renko';
+export { createPointAndFigure } from './pointAndFigure';
+export { createRangeBars } from './rangeBars';
+//# sourceMappingURL=index.js.map

package/dist/chartTypes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/chartTypes/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAoB,MAAM,SAAS,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAA6B,MAAM,kBAAkB,CAAA;AAClF,OAAO,EAAE,eAAe,EAAwB,MAAM,aAAa,CAAA"}

package/dist/chartTypes/pointAndFigure.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Point & Figure (P&F) — classic three-box-reversal column chart.
+ *
+ * P&F is the oldest non-time chart type still in use (de Villiers documented
+ * it in 1933, traders were drawing it on graph paper a century before that).
+ * It is a column chart: each column is either rising X's or falling O's, and
+ * we move to a new column only when price reverses by `reversal × boxSize`.
+ *
+ * ## Algorithm (classic 3-box reversal)
+ *
+ *  - State: current column `direction`, current column extent `[low, high]`.
+ *  - For each new input bar with `[H, L]`:
+ *
+ *    - If column is X (up):
+ *        * If `H >= high + boxSize`: extend the X column up to the highest box
+ *          containing `H` (i.e. set `high := floor(H / boxSize) * boxSize`).
+ *        * Else if `L <= high - reversal * boxSize`: reverse — start a new O
+ *          column. The new column starts **one box below** the prior X
+ *          column's high, and goes down to the lowest box `>= L`. The "one
+ *          box below" rule is the classical de Villiers convention and is
+ *          what TradingView uses.
+ *        * Else: bar does nothing.
+ *
+ *    - Symmetric for an O (down) column.
+ *
+ *  - First-ever input bar seeds the chart with an X column anchored on the
+ *    bar's `low` rounded down to a box boundary, extended up to `H` rounded
+ *    down to a box boundary. (Some traditions start with the high; we use
+ *    low-anchored which is more deterministic for a single bar.)
+ *
+ * ## Why this is lossy by design
+ *
+ * P&F deletes time entirely. Two bars produced at very different times can
+ * land in the same column. We therefore set every output column's
+ * `timestamp` to the timestamp of the source bar that **closed** the column
+ * (i.e. the last bar that touched it). This gives downstream tooltips a
+ * meaningful anchor while honouring the lossy semantics.
+ *
+ * ## OHLCV mapping for one column
+ *
+ *  - `open`  = starting box price (column entry)
+ *  - `close` = final box price (column exit / current frontier)
+ *  - `high`  = max box price reached in this column
+ *  - `low`   = min box price reached in this column
+ *  - `volume`= sum of input bar volumes that touched this column
+ *
+ * For an X column `close === high` and `open === low`. For an O column
+ * `close === low` and `open === high`. We populate `meta.direction` so
+ * renderers can colour distinctly.
+ *
+ * ## Reversal vs extension at the exact threshold
+ *
+ * If a bar simultaneously satisfies both extension and reversal — e.g. an X
+ * column where `H >= high + boxSize` AND `L <= high - reversal * boxSize` —
+ * **extension wins** (we follow the direction-of-momentum rule). This avoids
+ * "chop" in volatile bars but is a deliberate trade-off; some older systems
+ * give reversal priority on the basis of "the down move came second". We
+ * pick extension because it matches modern interactive P&F implementations
+ * including TradingView.
+ *
+ * ## Emission strategy
+ *
+ * Each completed column emits exactly **one** TransformedBar — the column's
+ * snapshot at the moment it closed. While a column is still "open" (i.e. it
+ * is the current column being extended) it does NOT appear in the output.
+ * `appendBar` therefore returns `[]` for bars that only extend the current
+ * column, and `[completedColumn, ...]` for bars that trigger a reversal.
+ *
+ * In batch mode `transform()` returns every column INCLUDING the in-progress
+ * final column so the user sees the full picture. This is the only place
+ * where batch and incremental diverge — and it's intentional, because there
+ * is no streaming convention to "tentatively emit" a still-open column.
+ * Tests assert that *closed* columns match between modes.
+ */
+import type { ChartTypeTransform } from './types';
+export interface PointAndFigureConfig {
+    /** Box height in price units. Must be > 0. */
+    boxSize: number;
+    /** Reversal in number of boxes. Classic value is 3. Must be >= 1. */
+    reversal: number;
+}
+export declare function createPointAndFigure(): ChartTypeTransform<PointAndFigureConfig>;
+//# sourceMappingURL=pointAndFigure.d.ts.map

package/dist/chartTypes/pointAndFigure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointAndFigure.d.ts","sourceRoot":"","sources":["../../src/chartTypes/pointAndFigure.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAyB,MAAM,SAAS,CAAA;AAExE,MAAM,WAAW,oBAAoB;IACjC,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAA;CACnB;AA8CD,wBAAgB,oBAAoB,IAAI,kBAAkB,CAAC,oBAAoB,CAAC,CAoJ/E"}

package/dist/chartTypes/pointAndFigure.js

@@ -0,0 +1,159 @@
+import { KLineChartError } from '../errors';
+/**
+ * Convert an internal column to a `TransformedBar`. We compute `open`, `close`,
+ * `high`, `low` from the column's two endpoints (P&F columns are monotonic in
+ * one direction so the two endpoints are the extremes).
+ */
+const columnToBar = (col) => {
+    const open = col.startPrice;
+    const close = col.endPrice;
+    const high = Math.max(open, close);
+    const low = Math.min(open, close);
+    return {
+        timestamp: col.timestamp,
+        open,
+        high,
+        low,
+        close,
+        volume: col.volume,
+        sourceBarIndexStart: col.sourceStart,
+        sourceBarIndexEnd: col.sourceEnd,
+        meta: { direction: col.direction },
+    };
+};
+export function createPointAndFigure() {
+    let state = { column: null, nextIndex: 0, closedColumns: [] };
+    let activeConfig = { boxSize: 1, reversal: 3 };
+    /** Snap `p` down to the nearest box boundary. */
+    const floorToBox = (p, box) => Math.floor(p / box) * box;
+    /** Snap `p` up to the nearest box boundary. */
+    const ceilToBox = (p, box) => Math.ceil(p / box) * box;
+    /**
+     * Process one input bar and return any column(s) that **closed** as a
+     * result. The in-progress column is held in `state.column` and is NOT
+     * returned until it closes (i.e. a reversal pushes it into closedColumns).
+     */
+    const consumeBar = (bar) => {
+        const sourceIndex = state.nextIndex;
+        state.nextIndex = sourceIndex + 1;
+        const { boxSize, reversal } = activeConfig;
+        const closed = [];
+        // Seed: no current column. Anchor an X column on the bar's low/high
+        // rounded to box boundaries. If high-low rounds to the same box (very
+        // narrow bar) we still create a degenerate column of height zero so
+        // the chart has a starting point — it will be extended by future bars.
+        if (state.column === null) {
+            const start = floorToBox(bar.low, boxSize);
+            const end = floorToBox(bar.high, boxSize);
+            state.column = {
+                direction: 'up',
+                startPrice: start,
+                endPrice: end,
+                sourceStart: sourceIndex,
+                sourceEnd: sourceIndex,
+                volume: bar.volume,
+                timestamp: bar.timestamp,
+            };
+            return closed;
+        }
+        const col = state.column;
+        if (col.direction === 'up') {
+            // Try extension first (extension wins ties — see file header).
+            const newHigh = floorToBox(bar.high, boxSize);
+            if (newHigh >= col.endPrice + boxSize) {
+                col.endPrice = newHigh;
+                col.sourceEnd = sourceIndex;
+                col.volume += bar.volume;
+                col.timestamp = bar.timestamp;
+                return closed;
+            }
+            // Then reversal.
+            if (bar.low <= col.endPrice - reversal * boxSize) {
+                // Close the X column.
+                closed.push(columnToBar(col));
+                state.closedColumns.push(closed[closed.length - 1]);
+                // Start a new O column ONE box below the X column's high.
+                const newColumnStart = col.endPrice - boxSize;
+                const newColumnEnd = ceilToBox(bar.low, boxSize);
+                state.column = {
+                    direction: 'down',
+                    startPrice: newColumnStart,
+                    endPrice: newColumnEnd <= newColumnStart ? newColumnEnd : newColumnStart,
+                    sourceStart: sourceIndex,
+                    sourceEnd: sourceIndex,
+                    volume: bar.volume,
+                    timestamp: bar.timestamp,
+                };
+                return closed;
+            }
+            // Bar does nothing — still attribute volume + advance source range
+            // so the column's metadata reflects the bars that touched it.
+            col.sourceEnd = sourceIndex;
+            col.volume += bar.volume;
+            col.timestamp = bar.timestamp;
+            return closed;
+        }
+        // col.direction === 'down'
+        const newLow = ceilToBox(bar.low, boxSize);
+        if (newLow <= col.endPrice - boxSize) {
+            col.endPrice = newLow;
+            col.sourceEnd = sourceIndex;
+            col.volume += bar.volume;
+            col.timestamp = bar.timestamp;
+            return closed;
+        }
+        if (bar.high >= col.endPrice + reversal * boxSize) {
+            closed.push(columnToBar(col));
+            state.closedColumns.push(closed[closed.length - 1]);
+            const newColumnStart = col.endPrice + boxSize;
+            const newColumnEnd = floorToBox(bar.high, boxSize);
+            state.column = {
+                direction: 'up',
+                startPrice: newColumnStart,
+                endPrice: newColumnEnd >= newColumnStart ? newColumnEnd : newColumnStart,
+                sourceStart: sourceIndex,
+                sourceEnd: sourceIndex,
+                volume: bar.volume,
+                timestamp: bar.timestamp,
+            };
+            return closed;
+        }
+        col.sourceEnd = sourceIndex;
+        col.volume += bar.volume;
+        col.timestamp = bar.timestamp;
+        return closed;
+    };
+    const resetState = () => {
+        state = { column: null, nextIndex: 0, closedColumns: [] };
+    };
+    return {
+        typeId: 'point-and-figure',
+        transform(input, config) {
+            if (config.boxSize <= 0) {
+                throw new KLineChartError('CHART_TYPE_CONFIG_INVALID', 'createPointAndFigure: boxSize must be > 0');
+            }
+            if (config.reversal < 1 || !Number.isFinite(config.reversal)) {
+                throw new KLineChartError('CHART_TYPE_CONFIG_INVALID', 'createPointAndFigure: reversal must be >= 1');
+            }
+            activeConfig = config;
+            resetState();
+            for (const bar of input) {
+                consumeBar(bar);
+            }
+            // Batch mode includes the currently-open column as the last entry —
+            // see file header. Incremental mode does not.
+            const out = state.closedColumns.slice();
+            if (state.column !== null) {
+                out.push(columnToBar(state.column));
+            }
+            return out;
+        },
+        appendBar(bar) {
+            return consumeBar(bar);
+        },
+        reset() {
+            resetState();
+        },
+    };
+}
+//# sourceMappingURL=pointAndFigure.js.map

package/dist/chartTypes/pointAndFigure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointAndFigure.js","sourceRoot":"","sources":["../../src/chartTypes/pointAndFigure.ts"],"names":[],"mappings":"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"}

package/dist/chartTypes/rangeBars.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Range Bars — fixed-range price bars.
+ *
+ * Every output bar spans exactly `range` price units (high - low === range at
+ * close). When the active bar's range reaches the threshold it is closed and
+ * a new bar begins, opening at the trigger price. Time, like Renko and P&F,
+ * is collapsed.
+ *
+ * ## Why range bars over Renko
+ *
+ *  - **Renko** uses only the close; intra-bar wicks are invisible. Good for
+ *    long-term swing visualisation.
+ *  - **Range bars** use the entire (high, low) of every input bar. They show
+ *    intra-bar excursions and tend to be more responsive to spikes.
+ *
+ * ## Algorithm
+ *
+ * State carries the in-progress bar `{open, high, low, volume, ...}`. For each
+ * input bar:
+ *
+ *   1. Decide a *direction* for the input bar (`up` if close >= open, else
+ *      `down`). Range bars need a direction because OHLC bars don't carry the
+ *      tick-level path between low and high.
+ *   2. Merge the input bar into the open bar BUT only along the direction —
+ *      meaning we honour both high and low, but if the merged span exceeds
+ *      `range` we *carve* the range bar in the direction of motion.
+ *   3. Carving: an "up" input that pushes total span past `range` closes the
+ *      current bar at `low + range`. The carved excess starts the next bar
+ *      with `open = low + range`, and any remaining high above the carved
+ *      ceiling becomes the next bar's high (recursion).
+ *   4. Edge case: a single input bar with `high - low > range` walks the bar's
+ *      range in `range`-sized steps in the input's direction and emits one
+ *      output bar per full step.
+ *
+ * ## Direction heuristic for OHLC inputs
+ *
+ * When closing from a single input contribution, we use `input.close >= input.open`
+ * to choose the carve direction. This is the same heuristic TradingView uses
+ * with OHLC input — exact tick-by-tick directionality would require trades.
+ *
+ * ## Volume aggregation
+ *
+ * Volume is summed across every input bar that contributes any range. For a
+ * single input that produces multiple output bars (a split), the input's
+ * volume is divided proportionally to the price extent each output bar
+ * carves of the input bar's total H-L.
+ *
+ * ## Emission strategy
+ *
+ * `transform()` returns every closed bar PLUS the currently-open bar (mirrors
+ * a live chart). `appendBar()` returns only the bars that closed on this
+ * append — the open bar is held in state. Tests assert the closed prefix
+ * matches between modes.
+ */
+import type { ChartTypeTransform } from './types';
+export interface RangeBarsConfig {
+    /** Range height in price units. Must be > 0. */
+    range: number;
+}
+export declare function createRangeBars(): ChartTypeTransform<RangeBarsConfig>;
+//# sourceMappingURL=rangeBars.d.ts.map

package/dist/chartTypes/rangeBars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rangeBars.d.ts","sourceRoot":"","sources":["../../src/chartTypes/rangeBars.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAyB,MAAM,SAAS,CAAA;AAExE,MAAM,WAAW,eAAe;IAC5B,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAA;CAChB;AA0CD,wBAAgB,eAAe,IAAI,kBAAkB,CAAC,eAAe,CAAC,CAuMrE"}

package/dist/chartTypes/rangeBars.js

@@ -0,0 +1,181 @@
+import { KLineChartError } from '../errors';
+const makeClosed = (open, high, low, close, volume, sourceStart, sourceEnd, timestamp) => {
+    const direction = close >= open ? 'up' : 'down';
+    return {
+        timestamp,
+        open,
+        high,
+        low,
+        close,
+        volume,
+        sourceBarIndexStart: sourceStart,
+        sourceBarIndexEnd: sourceEnd,
+        meta: { direction },
+    };
+};
+export function createRangeBars() {
+    let state = { open: null, nextIndex: 0, closed: [] };
+    let activeConfig = { range: 1 };
+    /**
+     * Merge one input bar into the open range bar, carving as many closed
+     * range bars as needed. Returns the bars that closed during this merge.
+     */
+    const consumeBar = (bar) => {
+        const sourceIndex = state.nextIndex;
+        state.nextIndex = sourceIndex + 1;
+        const range = activeConfig.range;
+        const closed = [];
+        const upward = bar.close >= bar.open;
+        const inputExtent = Math.max(bar.high - bar.low, 1e-12);
+        // Seed: no in-progress bar yet. Open one at the input's open. The
+        // input's full H/L participates immediately.
+        if (state.open === null) {
+            state.open = {
+                open: bar.open,
+                high: bar.open,
+                low: bar.open,
+                volume: 0,
+                sourceStart: sourceIndex,
+                sourceEnd: sourceIndex,
+                timestamp: bar.timestamp,
+            };
+        }
+        // Track how much input volume we've attributed so we can split it
+        // proportionally across any carved bars.
+        let inputVolUsed = 0;
+        // Repeatedly merge the input into the open bar; each iteration either
+        // (a) closes a bar and seeds a new open one from the carved-off
+        // remainder, or (b) finishes by absorbing the entire input range.
+        //
+        // We walk the input bar along its direction. `remainingHigh` and
+        // `remainingLow` shrink as we carve. We stop when no further range
+        // bar can be closed.
+        let remainingHigh = bar.high;
+        let remainingLow = bar.low;
+        let safety = 0;
+        while (safety++ < 1_000_000) {
+            const opened = state.open;
+            // Apply the remaining input extent to the open bar.
+            const mergedHigh = Math.max(opened.high, remainingHigh);
+            const mergedLow = Math.min(opened.low, remainingLow);
+            const span = mergedHigh - mergedLow;
+            if (span < range) {
+                // Whole remainder fits within range — absorb and stop.
+                opened.high = mergedHigh;
+                opened.low = mergedLow;
+                opened.sourceEnd = sourceIndex;
+                opened.timestamp = bar.timestamp;
+                // All remaining input volume goes here.
+                opened.volume += bar.volume - inputVolUsed;
+                inputVolUsed = bar.volume;
+                break;
+            }
+            // Span >= range. Carve a range bar in the direction of motion.
+            // For an up bar: close at low + range (we move up first).
+            // For a down bar: close at high - range.
+            let closePrice;
+            let closedHigh;
+            let closedLow;
+            if (upward) {
+                closedLow = mergedLow;
+                closedHigh = mergedLow + range;
+                closePrice = closedHigh;
+            }
+            else {
+                closedHigh = mergedHigh;
+                closedLow = mergedHigh - range;
+                closePrice = closedLow;
+            }
+            // Volume attributed to this carved bar: proportional to the
+            // input extent it covers, plus any volume already accumulated on
+            // the open bar from prior input bars.
+            const carvedExtent = Math.min(range, span);
+            const inputShare = (carvedExtent / inputExtent) * bar.volume;
+            const attribInput = Math.min(inputShare, bar.volume - inputVolUsed);
+            inputVolUsed += attribInput;
+            const closedVolume = opened.volume + attribInput;
+            closed.push(makeClosed(opened.open, closedHigh, closedLow, closePrice, closedVolume, opened.sourceStart, sourceIndex, bar.timestamp));
+            state.closed.push(closed[closed.length - 1]);
+            // Seed the next open bar at the carve boundary. The remaining
+            // input extent above (for up) or below (for down) the carve
+            // continues into the new bar.
+            if (upward) {
+                remainingLow = closePrice;
+                state.open = {
+                    open: closePrice,
+                    high: closePrice,
+                    low: closePrice,
+                    volume: 0,
+                    sourceStart: sourceIndex,
+                    sourceEnd: sourceIndex,
+                    timestamp: bar.timestamp,
+                };
+                // If the input bar's high is no greater than the carve
+                // ceiling, nothing more from this input remains for further
+                // carving.
+                if (remainingHigh <= closePrice) {
+                    // The new open bar already has open=closePrice; the
+                    // remaining high contributes nothing further. Stop.
+                    state.open.high = closePrice;
+                    state.open.low = closePrice;
+                    // Attribute leftover input volume to the now-current open.
+                    state.open.volume = bar.volume - inputVolUsed;
+                    inputVolUsed = bar.volume;
+                    break;
+                }
+            }
+            else {
+                remainingHigh = closePrice;
+                state.open = {
+                    open: closePrice,
+                    high: closePrice,
+                    low: closePrice,
+                    volume: 0,
+                    sourceStart: sourceIndex,
+                    sourceEnd: sourceIndex,
+                    timestamp: bar.timestamp,
+                };
+                if (remainingLow >= closePrice) {
+                    state.open.high = closePrice;
+                    state.open.low = closePrice;
+                    state.open.volume = bar.volume - inputVolUsed;
+                    inputVolUsed = bar.volume;
+                    break;
+                }
+            }
+        }
+        return closed;
+    };
+    const resetState = () => {
+        state = { open: null, nextIndex: 0, closed: [] };
+    };
+    return {
+        typeId: 'range-bars',
+        transform(input, config) {
+            if (config.range <= 0 || !Number.isFinite(config.range)) {
+                throw new KLineChartError('CHART_TYPE_CONFIG_INVALID', 'createRangeBars: range must be > 0');
+            }
+            activeConfig = config;
+            resetState();
+            for (const bar of input)
+                consumeBar(bar);
+            const out = state.closed.slice();
+            if (state.open !== null) {
+                // The trailing in-progress bar's "close" is its frontier — the
+                // direction of last accumulation. We pick high for "up" if
+                // close>=open, else low, matching candle semantics.
+                const o = state.open;
+                const close = o.high - o.open >= o.open - o.low ? o.high : o.low;
+                out.push(makeClosed(o.open, o.high, o.low, close, o.volume, o.sourceStart, o.sourceEnd, o.timestamp));
+            }
+            return out;
+        },
+        appendBar(bar) {
+            return consumeBar(bar);
+        },
+        reset() {
+            resetState();
+        },
+    };
+}
+//# sourceMappingURL=rangeBars.js.map

package/dist/chartTypes/rangeBars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rangeBars.js","sourceRoot":"","sources":["../../src/chartTypes/rangeBars.ts"],"names":[],"mappings":"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"}

package/dist/chartTypes/renko.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Renko bricks — price-based bars that ignore time.
+ *
+ * A Renko chart drops a fixed-size "brick" every time price advances by one
+ * brick-size from the previous brick's close. Time is collapsed: a quiet hour
+ * may produce zero bricks, a volatile minute may produce ten.
+ *
+ * ## Modes
+ *
+ *  - **Fixed brick size** (`{ brickSize }`): the classic chart. Brick height
+ *    is constant across the entire series.
+ *  - **ATR-adaptive brick size** (`{ useATR: { period } }`): brick size is the
+ *    rolling ATR(period) over the *input* OHLCV series. We compute the full
+ *    ATR series upfront and then use, for each candidate brick, the **trailing
+ *    ATR at the source bar that triggered it**. This means brick height varies
+ *    along the chart — wider in volatile regimes, tighter in quiet ones —
+ *    which is the whole point of ATR mode.
+ *
+ *    Trade-off (documented because it's a real one): ATR bricks are NOT
+ *    uniform-height, so the chart loses the "every step is the same size"
+ *    visual property that classical Renko has. In return, the brick rhythm
+ *    adapts to volatility — a feature TradingView only offers in a separate
+ *    chart-type ("ATR Renko") and which requires the user to reload the
+ *    series to change. Our implementation supports flipping `useATR` on a
+ *    live transform incrementally — see §"Enhancements over TradingView".
+ *
+ * ## Classic reversal rule (the 2× brick-size requirement)
+ *
+ * Once a column of up-bricks has been emitted, a single brick-size reverse
+ * move is NOT enough to start a down-column — it must travel **2 × brickSize**
+ * in the opposite direction from the last brick's close. This is the
+ * "classic" Nison/Steve Nison rule. Without the 2× requirement the chart
+ * "flutters" — every wiggle near the brick-size threshold flips direction.
+ *
+ * In code:
+ *   - Continuation (same direction as last brick): need ≥ 1 × brickSize.
+ *   - Reversal (opposite direction): need ≥ 2 × brickSize.
+ *
+ * The very first brick has no "previous direction", so it uses the 1× rule.
+ *
+ * ## Brick shape
+ *
+ * Each brick is OHLCV-shaped to fit the candle renderer:
+ *
+ *     up-brick:   open = lastBrickClose
+ *                 close = lastBrickClose + brickSize
+ *                 high = close, low = open
+ *
+ *     down-brick: open = lastBrickClose
+ *                 close = lastBrickClose - brickSize
+ *                 high = open, low = close
+ *
+ * `volume` is the sum of input-bar volumes assigned to this brick. We use a
+ * simple rule: each input bar contributes all of its volume to **the first
+ * brick** it triggers in that bar. When one bar triggers N bricks (a gap),
+ * the bar's full volume goes on the first brick and the rest carry zero. This
+ * matches TradingView; the alternative (split evenly) creates phantom volume
+ * spikes when ATR mode changes brick sizes between bricks.
+ *
+ * ## Meta
+ *
+ * `meta.direction` is `'up'` or `'down'` for downstream colour selection.
+ * `meta.brickSize` is the brick height at the time of emission (especially
+ * meaningful in ATR mode).
+ */
+import type { ChartTypeTransform } from './types';
+/**
+ * Renko configuration.
+ *
+ * Exactly one of `brickSize` or `useATR` must be supplied. If both are present
+ * `useATR` wins (so callers can store both and toggle a flag).
+ */
+export interface RenkoConfig {
+    /** Fixed brick height in price units. Must be > 0. */
+    brickSize?: number;
+    /** ATR-adaptive mode. `period` is the ATR lookback. */
+    useATR?: {
+        period: number;
+    };
+}
+/**
+ * Build a Renko transform.
+ *
+ * The transform supports both `transform(input, config)` and `appendBar(bar)`.
+ * The config passed to `transform` is also captured for subsequent
+ * `appendBar` calls — so the typical flow is:
+ *
+ *     const r = createRenko()
+ *     const history = r.transform(historicalBars, { brickSize: 10 })
+ *     // ...later, as ticks arrive:
+ *     const newBricks = r.appendBar(liveBar)
+ */
+export declare function createRenko(): ChartTypeTransform<RenkoConfig>;
+//# sourceMappingURL=renko.d.ts.map

package/dist/chartTypes/renko.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renko.d.ts","sourceRoot":"","sources":["../../src/chartTypes/renko.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAyB,MAAM,SAAS,CAAA;AAExE;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IACxB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uDAAuD;IACvD,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9B;AA0BD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAgM7D"}