@tranding-custom-chart/financial 0.0.0-stage → 2.1.0

package/dist/indicators/heikin-ashi.js

@@ -0,0 +1,36 @@
+/**
+ * @file packages/chart-financial/src/indicators/heikin-ashi.ts
+ * Transforms standard OHLCV candlesticks into smoothed Heikin-Ashi candles.
+ *
+ * Formulas:
+ * - Close_HA = (Open + High + Low + Close) / 4
+ * - Open_HA[0] = (Open[0] + Close[0]) / 2
+ * - Open_HA[i] = (Open_HA[i-1] + Close_HA[i-1]) / 2
+ * - High_HA = max(High, Open_HA, Close_HA)
+ * - Low_HA = min(Low, Open_HA, Close_HA)
+ */
+export function computeHeikinAshi(bars) {
+    if (bars.length === 0)
+        return [];
+    const result = [];
+    for (let i = 0; i < bars.length; i++) {
+        const bar = bars[i];
+        const haClose = (bar.open + bar.high + bar.low + bar.close) / 4;
+        const haOpen = i === 0
+            ? (bar.open + bar.close) / 2
+            : (result[i - 1].open + result[i - 1].close) / 2;
+        const haHigh = Math.max(bar.high, haOpen, haClose);
+        const haLow = Math.min(bar.low, haOpen, haClose);
+        result.push({
+            time: bar.time,
+            open: haOpen,
+            high: haHigh,
+            low: haLow,
+            close: haClose,
+            volume: bar.volume,
+            dateStr: bar.dateStr,
+            qualityFlags: bar.qualityFlags,
+        });
+    }
+    return result;
+}

package/dist/indicators/kagi.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file packages/chart-financial/src/indicators/kagi.ts
+ * Algorithmic Kagi line generation from sequential OHLCV bars.
+ * Kagi charts filter time and noise, indicating trend reversals and Yang (bullish) / Yin (bearish) inflections.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export interface KagiSegment extends OHLCVBar {
+    readonly isYang: boolean;
+    readonly isUp: boolean;
+    readonly originalIndex: number;
+}
+export interface KagiOptions {
+    readonly reversalAmount?: number | undefined;
+    readonly reversalPercent?: number | undefined;
+}
+/**
+ * Computes Kagi trend segments from standard OHLCV bars.
+ */
+export declare function computeKagi(bars: readonly OHLCVBar[], options?: KagiOptions): readonly KagiSegment[];
+//# sourceMappingURL=kagi.d.ts.map

package/dist/indicators/kagi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kagi.d.ts","sourceRoot":"","sources":["../../src/indicators/kagi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,MAAM,WAAW,WAAY,SAAQ,QAAQ;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,OAAO,GAAE,WAAgB,GACxB,SAAS,WAAW,EAAE,CAsHxB"}

package/dist/indicators/kagi.js

@@ -0,0 +1,122 @@
+/**
+ * @file packages/chart-financial/src/indicators/kagi.ts
+ * Algorithmic Kagi line generation from sequential OHLCV bars.
+ * Kagi charts filter time and noise, indicating trend reversals and Yang (bullish) / Yin (bearish) inflections.
+ */
+/**
+ * Computes Kagi trend segments from standard OHLCV bars.
+ */
+export function computeKagi(bars, options = {}) {
+    if (bars.length === 0)
+        return [];
+    const firstClose = bars[0].close;
+    const reversalPct = options.reversalPercent ?? 0.01;
+    const reversalThreshold = options.reversalAmount && options.reversalAmount > 0
+        ? options.reversalAmount
+        : Math.max(0.1, Number((firstClose * reversalPct).toFixed(2)));
+    const segments = [];
+    let currentStartPrice = firstClose;
+    let currentEndPrice = firstClose;
+    let currentDirection = null;
+    let isYang = true;
+    let lastShoulder = firstClose; // Previous peak
+    let lastWaist = firstClose; // Previous trough
+    for (let i = 1; i < bars.length; i++) {
+        const bar = bars[i];
+        const price = bar.close;
+        if (currentDirection === null) {
+            if (price >= currentStartPrice + reversalThreshold) {
+                currentDirection = 'up';
+                currentEndPrice = price;
+                lastShoulder = price;
+            }
+            else if (price <= currentStartPrice - reversalThreshold) {
+                currentDirection = 'down';
+                currentEndPrice = price;
+                lastWaist = price;
+                isYang = false;
+            }
+            continue;
+        }
+        if (currentDirection === 'up') {
+            if (price > currentEndPrice) {
+                // Continue upward trend
+                currentEndPrice = price;
+                if (!isYang && price > lastShoulder) {
+                    isYang = true; // Breakout above shoulder turns Yang
+                }
+            }
+            else if (price <= currentEndPrice - reversalThreshold) {
+                // Reversal downwards
+                segments.push({
+                    time: bar.time,
+                    open: currentStartPrice,
+                    high: currentEndPrice,
+                    low: currentStartPrice,
+                    close: currentEndPrice,
+                    volume: bar.volume ?? 0,
+                    isYang,
+                    isUp: true,
+                    originalIndex: i - 1,
+                    dateStr: bar.dateStr,
+                });
+                lastShoulder = currentEndPrice;
+                currentStartPrice = currentEndPrice;
+                currentEndPrice = price;
+                currentDirection = 'down';
+                if (isYang && price < lastWaist) {
+                    isYang = false; // Breakdown below waist turns Yin
+                }
+            }
+        }
+        else {
+            // currentDirection === 'down'
+            if (price < currentEndPrice) {
+                // Continue downward trend
+                currentEndPrice = price;
+                if (isYang && price < lastWaist) {
+                    isYang = false; // Breakdown below waist turns Yin
+                }
+            }
+            else if (price >= currentEndPrice + reversalThreshold) {
+                // Reversal upwards
+                segments.push({
+                    time: bar.time,
+                    open: currentStartPrice,
+                    high: currentStartPrice,
+                    low: currentEndPrice,
+                    close: currentEndPrice,
+                    volume: bar.volume ?? 0,
+                    isYang,
+                    isUp: false,
+                    originalIndex: i - 1,
+                    dateStr: bar.dateStr,
+                });
+                lastWaist = currentEndPrice;
+                currentStartPrice = currentEndPrice;
+                currentEndPrice = price;
+                currentDirection = 'up';
+                if (!isYang && price > lastShoulder) {
+                    isYang = true; // Breakout above shoulder turns Yang
+                }
+            }
+        }
+    }
+    // Push terminal active segment
+    if (currentDirection !== null) {
+        const lastBar = bars[bars.length - 1];
+        segments.push({
+            time: lastBar.time,
+            open: currentStartPrice,
+            high: Math.max(currentStartPrice, currentEndPrice),
+            low: Math.min(currentStartPrice, currentEndPrice),
+            close: currentEndPrice,
+            volume: lastBar.volume ?? 0,
+            isYang,
+            isUp: currentEndPrice >= currentStartPrice,
+            originalIndex: bars.length - 1,
+            dateStr: lastBar.dateStr,
+        });
+    }
+    return segments;
+}

package/dist/indicators/line-break.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file packages/chart-financial/src/indicators/line-break.ts
+ * Algorithmic Three-Line Break (TLB) chart generation.
+ * Filters minor oscillations, adding new blocks only when price exceeds the extreme of the prior N lines.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export interface LineBreakBar extends OHLCVBar {
+    readonly isUp: boolean;
+    readonly originalIndex: number;
+}
+export interface LineBreakOptions {
+    readonly lineCount?: number | undefined;
+}
+/**
+ * Computes Three-Line Break (TLB) bars from sequential OHLCV bars.
+ */
+export declare function computeLineBreak(bars: readonly OHLCVBar[], options?: LineBreakOptions): readonly LineBreakBar[];
+//# sourceMappingURL=line-break.d.ts.map

package/dist/indicators/line-break.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-break.d.ts","sourceRoot":"","sources":["../../src/indicators/line-break.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,MAAM,WAAW,YAAa,SAAQ,QAAQ;IAC5C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,OAAO,GAAE,gBAAqB,GAC7B,SAAS,YAAY,EAAE,CAoEzB"}

package/dist/indicators/line-break.js

@@ -0,0 +1,73 @@
+/**
+ * @file packages/chart-financial/src/indicators/line-break.ts
+ * Algorithmic Three-Line Break (TLB) chart generation.
+ * Filters minor oscillations, adding new blocks only when price exceeds the extreme of the prior N lines.
+ */
+/**
+ * Computes Three-Line Break (TLB) bars from sequential OHLCV bars.
+ */
+export function computeLineBreak(bars, options = {}) {
+    if (bars.length === 0)
+        return [];
+    const lineCount = Math.max(1, options.lineCount ?? 3);
+    const result = [];
+    // Seed with initial bar
+    const first = bars[0];
+    result.push({
+        time: first.time,
+        open: first.open,
+        high: Math.max(first.open, first.close),
+        low: Math.min(first.open, first.close),
+        close: first.close,
+        volume: first.volume ?? 0,
+        isUp: first.close >= first.open,
+        originalIndex: 0,
+        dateStr: first.dateStr,
+    });
+    for (let i = 1; i < bars.length; i++) {
+        const bar = bars[i];
+        const price = bar.close;
+        // Check extremes of recent N lines
+        const recent = result.slice(-lineCount);
+        let highestHigh = -Infinity;
+        let lowestLow = Infinity;
+        for (const line of recent) {
+            const top = Math.max(line.open, line.close);
+            const bottom = Math.min(line.open, line.close);
+            if (top > highestHigh)
+                highestHigh = top;
+            if (bottom < lowestLow)
+                lowestLow = bottom;
+        }
+        const lastLine = result[result.length - 1];
+        if (price > highestHigh) {
+            // New up line
+            result.push({
+                time: bar.time,
+                open: lastLine.isUp ? lastLine.close : lastLine.open,
+                high: price,
+                low: lastLine.isUp ? lastLine.close : lastLine.open,
+                close: price,
+                volume: bar.volume ?? 0,
+                isUp: true,
+                originalIndex: i,
+                dateStr: bar.dateStr,
+            });
+        }
+        else if (price < lowestLow) {
+            // New down line
+            result.push({
+                time: bar.time,
+                open: !lastLine.isUp ? lastLine.close : lastLine.open,
+                high: !lastLine.isUp ? lastLine.close : lastLine.open,
+                low: price,
+                close: price,
+                volume: bar.volume ?? 0,
+                isUp: false,
+                originalIndex: i,
+                dateStr: bar.dateStr,
+            });
+        }
+    }
+    return result;
+}

package/dist/indicators/macd.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file packages/chart-financial/src/indicators/macd.ts
+ * Moving Average Convergence Divergence (MACD) calculation.
+ * Outputs MACD Line, Signal Line, and Histogram oscillator.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export interface MACDResult {
+    readonly macd: readonly (number | null)[];
+    readonly signal: readonly (number | null)[];
+    readonly histogram: readonly (number | null)[];
+}
+export declare function computeMACD(bars: readonly OHLCVBar[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number): MACDResult;
+//# sourceMappingURL=macd.d.ts.map

package/dist/indicators/macd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"macd.d.ts","sourceRoot":"","sources":["../../src/indicators/macd.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAG5D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;CAChD;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,UAAU,SAAK,EACf,UAAU,SAAK,EACf,YAAY,SAAI,GACf,UAAU,CA4DZ"}

package/dist/indicators/macd.js

@@ -0,0 +1,60 @@
+/**
+ * @file packages/chart-financial/src/indicators/macd.ts
+ * Moving Average Convergence Divergence (MACD) calculation.
+ * Outputs MACD Line, Signal Line, and Histogram oscillator.
+ */
+import { computeEMA } from './ema.js';
+export function computeMACD(bars, fastPeriod = 12, slowPeriod = 26, signalPeriod = 9) {
+    const n = bars.length;
+    if (n === 0) {
+        return { macd: [], signal: [], histogram: [] };
+    }
+    const fastEMA = computeEMA(bars, fastPeriod);
+    const slowEMA = computeEMA(bars, slowPeriod);
+    const macdLine = new Array(n).fill(null);
+    for (let i = 0; i < n; i++) {
+        const f = fastEMA[i];
+        const s = slowEMA[i];
+        if (f !== null && f !== undefined && s !== null && s !== undefined) {
+            macdLine[i] = f - s;
+        }
+    }
+    // Compute Signal Line as EMA over valid MACD values
+    const signalLine = new Array(n).fill(null);
+    const validMacdIndices = [];
+    for (let i = 0; i < n; i++) {
+        if (macdLine[i] !== null) {
+            validMacdIndices.push(i);
+        }
+    }
+    if (validMacdIndices.length >= signalPeriod) {
+        // Synthetic bar series to reuse standard EMA logic
+        const dummyBars = validMacdIndices.map((idx) => ({
+            time: bars[idx].time,
+            open: macdLine[idx],
+            high: macdLine[idx],
+            low: macdLine[idx],
+            close: macdLine[idx],
+            volume: null,
+        }));
+        const signalValues = computeEMA(dummyBars, signalPeriod);
+        for (let k = 0; k < validMacdIndices.length; k++) {
+            const origIdx = validMacdIndices[k];
+            signalLine[origIdx] = signalValues[k];
+        }
+    }
+    // Compute Histogram: MACD Line - Signal Line
+    const histogram = new Array(n).fill(null);
+    for (let i = 0; i < n; i++) {
+        const m = macdLine[i];
+        const s = signalLine[i];
+        if (m !== null && m !== undefined && s !== null && s !== undefined) {
+            histogram[i] = m - s;
+        }
+    }
+    return {
+        macd: macdLine,
+        signal: signalLine,
+        histogram,
+    };
+}

package/dist/indicators/renko.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file packages/chart-financial/src/indicators/renko.ts
+ * Algorithmic Renko brick generation from OHLCV bar observations.
+ * Renko filters time and minor fluctuations, creating bricks of a fixed price size.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export interface RenkoBrick extends OHLCVBar {
+    readonly isUp: boolean;
+    readonly originalIndex: number;
+}
+export interface RenkoOptions {
+    readonly brickSize?: number | undefined;
+}
+/**
+ * Computes Renko bricks from standard OHLCV bars.
+ * Each brick represents a fixed price movement (brickSize).
+ */
+export declare function computeRenko(bars: readonly OHLCVBar[], options?: RenkoOptions): readonly RenkoBrick[];
+//# sourceMappingURL=renko.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renko.d.ts","sourceRoot":"","sources":["../../src/indicators/renko.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,MAAM,WAAW,UAAW,SAAQ,QAAQ;IAC1C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,OAAO,GAAE,YAAiB,GACzB,SAAS,UAAU,EAAE,CA6EvB"}

package/dist/indicators/renko.js

@@ -0,0 +1,84 @@
+/**
+ * @file packages/chart-financial/src/indicators/renko.ts
+ * Algorithmic Renko brick generation from OHLCV bar observations.
+ * Renko filters time and minor fluctuations, creating bricks of a fixed price size.
+ */
+/**
+ * Computes Renko bricks from standard OHLCV bars.
+ * Each brick represents a fixed price movement (brickSize).
+ */
+export function computeRenko(bars, options = {}) {
+    if (bars.length === 0)
+        return [];
+    // Determine brick size
+    let brickSize = options.brickSize;
+    if (!brickSize || brickSize <= 0) {
+        // Dynamic default: 1% of the starting close or median range
+        const firstClose = bars[0]?.close ?? 100;
+        brickSize = Math.max(0.1, Number((firstClose * 0.005).toFixed(2)));
+    }
+    const bricks = [];
+    let lastBrickPrice = Math.floor(bars[0].close / brickSize) * brickSize;
+    let lastDirection = null;
+    for (let i = 0; i < bars.length; i++) {
+        const bar = bars[i];
+        const price = bar.close;
+        while (true) {
+            if (price >= lastBrickPrice + brickSize) {
+                // Up brick
+                const open = lastBrickPrice;
+                const close = lastBrickPrice + brickSize;
+                bricks.push({
+                    time: bar.time,
+                    open,
+                    high: close,
+                    low: open,
+                    close,
+                    volume: bar.volume ? Math.round(bar.volume / 2) : 0,
+                    isUp: true,
+                    originalIndex: i,
+                    dateStr: bar.dateStr,
+                });
+                lastBrickPrice = close;
+                lastDirection = 'up';
+            }
+            else if (price <= lastBrickPrice - brickSize) {
+                // Down brick
+                const open = lastBrickPrice;
+                const close = lastBrickPrice - brickSize;
+                bricks.push({
+                    time: bar.time,
+                    open,
+                    high: open,
+                    low: close,
+                    close,
+                    volume: bar.volume ? Math.round(bar.volume / 2) : 0,
+                    isUp: false,
+                    originalIndex: i,
+                    dateStr: bar.dateStr,
+                });
+                lastBrickPrice = close;
+                lastDirection = 'down';
+            }
+            else {
+                break;
+            }
+        }
+    }
+    // If no brick triggered (e.g. range was too narrow), create at least one baseline brick
+    if (bricks.length === 0 && bars.length > 0) {
+        const b = bars[0];
+        bricks.push({
+            time: b.time,
+            open: b.open,
+            high: Math.max(b.open, b.close),
+            low: Math.min(b.open, b.close),
+            close: b.close,
+            volume: b.volume ?? 0,
+            isUp: b.close >= b.open,
+            originalIndex: 0,
+            dateStr: b.dateStr,
+        });
+    }
+    return bricks;
+}

package/dist/indicators/rsi.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file packages/chart-financial/src/indicators/rsi.ts
+ * Relative Strength Index (RSI) using Wilder's smoothed moving average.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export declare function computeRSI(bars: readonly OHLCVBar[], period?: number): (number | null)[];
+//# sourceMappingURL=rsi.d.ts.map

package/dist/indicators/rsi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsi.d.ts","sourceRoot":"","sources":["../../src/indicators/rsi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,MAAM,SAAK,GACV,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAgDnB"}

package/dist/indicators/rsi.js

@@ -0,0 +1,47 @@
+/**
+ * @file packages/chart-financial/src/indicators/rsi.ts
+ * Relative Strength Index (RSI) using Wilder's smoothed moving average.
+ */
+export function computeRSI(bars, period = 14) {
+    if (period <= 0 || bars.length <= period) {
+        return bars.map(() => null);
+    }
+    const result = new Array(bars.length).fill(null);
+    // Compute initial average gain and loss over first 'period' price changes
+    let totalGain = 0;
+    let totalLoss = 0;
+    for (let i = 1; i <= period; i++) {
+        const change = bars[i].close - bars[i - 1].close;
+        if (change > 0) {
+            totalGain += change;
+        }
+        else {
+            totalLoss += Math.abs(change);
+        }
+    }
+    let avgGain = totalGain / period;
+    let avgLoss = totalLoss / period;
+    if (avgLoss === 0) {
+        result[period] = 100;
+    }
+    else {
+        const rs = avgGain / avgLoss;
+        result[period] = 100 - 100 / (1 + rs);
+    }
+    // Smooth subsequent values using Wilder's technique
+    for (let i = period + 1; i < bars.length; i++) {
+        const change = bars[i].close - bars[i - 1].close;
+        const gain = change > 0 ? change : 0;
+        const loss = change < 0 ? Math.abs(change) : 0;
+        avgGain = (avgGain * (period - 1) + gain) / period;
+        avgLoss = (avgLoss * (period - 1) + loss) / period;
+        if (avgLoss === 0) {
+            result[i] = 100;
+        }
+        else {
+            const rs = avgGain / avgLoss;
+            result[i] = 100 - 100 / (1 + rs);
+        }
+    }
+    return result;
+}

package/dist/indicators/sma.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file packages/chart-financial/src/indicators/sma.ts
+ * Simple Moving Average (SMA) computation with transparent warm-up and incremental updates.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+/**
+ * Computes SMA over close prices.
+ * Returns an array of equal length to bars, with `null` for the warm-up periods.
+ */
+export declare function computeSMA(bars: readonly OHLCVBar[], period: number): (number | null)[];
+/**
+ * Updates the latest trailing SMA value when the current live candle updates.
+ */
+export declare function updateTrailingSMA(bars: readonly OHLCVBar[], period: number, updatedClose: number): number | null;
+//# sourceMappingURL=sma.d.ts.map

package/dist/indicators/sma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sma.d.ts","sourceRoot":"","sources":["../../src/indicators/sma.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D;;;GAGG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAqBnB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,MAAM,GAAG,IAAI,CAQf"}

package/dist/indicators/sma.js

@@ -0,0 +1,37 @@
+/**
+ * @file packages/chart-financial/src/indicators/sma.ts
+ * Simple Moving Average (SMA) computation with transparent warm-up and incremental updates.
+ */
+/**
+ * Computes SMA over close prices.
+ * Returns an array of equal length to bars, with `null` for the warm-up periods.
+ */
+export function computeSMA(bars, period) {
+    if (period <= 0 || bars.length < period) {
+        return bars.map(() => null);
+    }
+    const result = new Array(bars.length).fill(null);
+    let windowSum = 0;
+    for (let i = 0; i < bars.length; i++) {
+        windowSum += bars[i].close;
+        if (i >= period) {
+            windowSum -= bars[i - period].close;
+        }
+        if (i >= period - 1) {
+            result[i] = windowSum / period;
+        }
+    }
+    return result;
+}
+/**
+ * Updates the latest trailing SMA value when the current live candle updates.
+ */
+export function updateTrailingSMA(bars, period, updatedClose) {
+    if (period <= 0 || bars.length < period)
+        return null;
+    let sum = updatedClose;
+    for (let i = 1; i < period; i++) {
+        sum += bars[bars.length - 1 - i].close;
+    }
+    return sum / period;
+}

package/dist/indicators/supertrend.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file packages/chart-financial/src/indicators/supertrend.ts
+ * Algorithmic Supertrend calculation engine.
+ * Computes ATR-based dynamic trailing stop bands and trend direction (1 = Bullish, -1 = Bearish).
+ */
+import type { OHLCVBar, SupertrendResult, SupertrendOptions } from '@tranding-custom-chart/core';
+export declare function computeSupertrend(bars: readonly OHLCVBar[], options?: SupertrendOptions): SupertrendResult;
+//# sourceMappingURL=supertrend.d.ts.map

package/dist/indicators/supertrend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supertrend.d.ts","sourceRoot":"","sources":["../../src/indicators/supertrend.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,QAAQ,EAER,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAGrC,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CAuFlB"}