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

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"}

package/dist/indicators/supertrend.js

@@ -0,0 +1,88 @@
+/**
+ * @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 { computeATR } from './atr.js';
+export function computeSupertrend(bars, options = {}) {
+    const { period = 10, multiplier = 3.0 } = options;
+    if (bars.length === 0) {
+        return { points: [], period, multiplier };
+    }
+    const atrPoints = computeATR(bars, period);
+    const points = [];
+    let prevFinalUpper = 0;
+    let prevFinalLower = 0;
+    let prevDirection = 1;
+    for (let i = 0; i < bars.length; i++) {
+        const bar = bars[i];
+        const atr = atrPoints[i]?.atr ?? 0;
+        const hl2 = (bar.high + bar.low) / 2;
+        const basicUpper = hl2 + multiplier * atr;
+        const basicLower = hl2 - multiplier * atr;
+        let finalUpper = basicUpper;
+        let finalLower = basicLower;
+        if (i > 0) {
+            const prevBar = bars[i - 1];
+            // Final Upper Band
+            if (basicUpper < prevFinalUpper || prevBar.close > prevFinalUpper) {
+                finalUpper = basicUpper;
+            }
+            else {
+                finalUpper = prevFinalUpper;
+            }
+            // Final Lower Band
+            if (basicLower > prevFinalLower || prevBar.close < prevFinalLower) {
+                finalLower = basicLower;
+            }
+            else {
+                finalLower = prevFinalLower;
+            }
+        }
+        else {
+            prevFinalUpper = basicUpper;
+            prevFinalLower = basicLower;
+        }
+        // Determine Direction
+        let direction = prevDirection;
+        if (i === 0) {
+            direction = bar.close >= hl2 ? 1 : -1;
+        }
+        else {
+            if (prevDirection === 1) {
+                if (bar.close < finalLower) {
+                    direction = -1;
+                }
+                else {
+                    direction = 1;
+                }
+            }
+            else {
+                if (bar.close > finalUpper) {
+                    direction = 1;
+                }
+                else {
+                    direction = -1;
+                }
+            }
+        }
+        const isReversal = i > 0 && direction !== prevDirection;
+        const supertrendVal = direction === 1 ? finalLower : finalUpper;
+        points.push({
+            time: bar.time,
+            supertrend: supertrendVal,
+            direction,
+            upperBand: finalUpper,
+            lowerBand: finalLower,
+            isReversal,
+        });
+        prevFinalUpper = finalUpper;
+        prevFinalLower = finalLower;
+        prevDirection = direction;
+    }
+    return {
+        points,
+        period,
+        multiplier,
+    };
+}

package/dist/indicators/volume-profile.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file packages/chart-financial/src/indicators/volume-profile.ts
+ * Algorithmic Visible Range Volume Profile (VRVP) calculation.
+ * Distributes traded volume into discrete price bins, identifying Point of Control (POC)
+ * and the 70% Value Area (VAH and VAL).
+ */
+import type { OHLCVBar, VolumeProfileBin, VolumeProfileResult, VolumeProfileOptions } from '@tranding-custom-chart/core';
+export type { VolumeProfileBin, VolumeProfileResult, VolumeProfileOptions };
+export declare function computeVolumeProfile(bars: readonly OHLCVBar[], options?: VolumeProfileOptions): VolumeProfileResult;
+//# sourceMappingURL=volume-profile.d.ts.map

package/dist/indicators/volume-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume-profile.d.ts","sourceRoot":"","sources":["../../src/indicators/volume-profile.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,QAAQ,EACR,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AAErC,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAC;AAE5E,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,OAAO,GAAE,oBAAyB,GACjC,mBAAmB,CAmJrB"}

package/dist/indicators/volume-profile.js

@@ -0,0 +1,134 @@
+/**
+ * @file packages/chart-financial/src/indicators/volume-profile.ts
+ * Algorithmic Visible Range Volume Profile (VRVP) calculation.
+ * Distributes traded volume into discrete price bins, identifying Point of Control (POC)
+ * and the 70% Value Area (VAH and VAL).
+ */
+export function computeVolumeProfile(bars, options = {}) {
+    if (bars.length === 0) {
+        return {
+            bins: [],
+            pocPrice: 0,
+            pocVolume: 0,
+            vahPrice: 0,
+            valPrice: 0,
+            totalVolume: 0,
+        };
+    }
+    const { binCount = 24, valueAreaRatio = 0.7 } = options;
+    let minPrice = Infinity;
+    let maxPrice = -Infinity;
+    let overallVolume = 0;
+    for (const b of bars) {
+        if (b.low < minPrice)
+            minPrice = b.low;
+        if (b.high > maxPrice)
+            maxPrice = b.high;
+        overallVolume += b.volume ?? 0;
+    }
+    if (maxPrice <= minPrice || overallVolume === 0) {
+        return {
+            bins: [],
+            pocPrice: minPrice,
+            pocVolume: 0,
+            vahPrice: maxPrice,
+            valPrice: minPrice,
+            totalVolume: overallVolume,
+        };
+    }
+    const priceSpan = maxPrice - minPrice;
+    const binStep = priceSpan / binCount;
+    // Initialize bins
+    const rawBins = [];
+    for (let k = 0; k < binCount; k++) {
+        const low = minPrice + k * binStep;
+        const high = low + binStep;
+        rawBins.push({
+            priceLow: low,
+            priceHigh: high,
+            priceMid: (low + high) / 2,
+            buyVolume: 0,
+            sellVolume: 0,
+            totalVolume: 0,
+        });
+    }
+    // Allocate bar volume across bins
+    for (const b of bars) {
+        const vol = b.volume ?? 0;
+        if (vol <= 0)
+            continue;
+        const isUp = b.close >= b.open;
+        const barLow = b.low;
+        const barHigh = b.high;
+        // Find overlapping bins
+        const startBin = Math.max(0, Math.min(binCount - 1, Math.floor((barLow - minPrice) / binStep)));
+        const endBin = Math.max(0, Math.min(binCount - 1, Math.floor((barHigh - minPrice) / binStep)));
+        const binsTouched = endBin - startBin + 1;
+        const volPerBin = vol / binsTouched;
+        for (let idx = startBin; idx <= endBin; idx++) {
+            const target = rawBins[idx];
+            if (isUp) {
+                target.buyVolume += volPerBin;
+            }
+            else {
+                target.sellVolume += volPerBin;
+            }
+            target.totalVolume += volPerBin;
+        }
+    }
+    // Find Point of Control (POC)
+    let pocIdx = 0;
+    let maxBinVol = -1;
+    for (let k = 0; k < binCount; k++) {
+        if (rawBins[k].totalVolume > maxBinVol) {
+            maxBinVol = rawBins[k].totalVolume;
+            pocIdx = k;
+        }
+    }
+    const pocPrice = rawBins[pocIdx].priceMid;
+    const pocVolume = rawBins[pocIdx].totalVolume;
+    // Determine Value Area (70% total volume radiating outward from POC)
+    const targetVAVolume = overallVolume * valueAreaRatio;
+    let currentVAVolume = pocVolume;
+    let upIdx = pocIdx;
+    let downIdx = pocIdx;
+    while (currentVAVolume < targetVAVolume && (upIdx < binCount - 1 || downIdx > 0)) {
+        const nextUpVol = upIdx < binCount - 1 ? rawBins[upIdx + 1].totalVolume : -1;
+        const nextDownVol = downIdx > 0 ? rawBins[downIdx - 1].totalVolume : -1;
+        if (nextUpVol >= nextDownVol && upIdx < binCount - 1) {
+            upIdx++;
+            currentVAVolume += nextUpVol;
+        }
+        else if (downIdx > 0) {
+            downIdx--;
+            currentVAVolume += nextDownVol;
+        }
+        else if (upIdx < binCount - 1) {
+            upIdx++;
+            currentVAVolume += nextUpVol;
+        }
+        else {
+            break;
+        }
+    }
+    const valPrice = rawBins[downIdx].priceLow;
+    const vahPrice = rawBins[upIdx].priceHigh;
+    const resultBins = rawBins.map((rb, idx) => ({
+        priceLow: Number(rb.priceLow.toFixed(2)),
+        priceHigh: Number(rb.priceHigh.toFixed(2)),
+        priceMid: Number(rb.priceMid.toFixed(2)),
+        buyVolume: Math.round(rb.buyVolume),
+        sellVolume: Math.round(rb.sellVolume),
+        totalVolume: Math.round(rb.totalVolume),
+        isValueArea: idx >= downIdx && idx <= upIdx,
+        isPOC: idx === pocIdx,
+    }));
+    return {
+        bins: resultBins,
+        pocPrice: Number(pocPrice.toFixed(2)),
+        pocVolume: Math.round(pocVolume),
+        vahPrice: Number(vahPrice.toFixed(2)),
+        valPrice: Number(valPrice.toFixed(2)),
+        totalVolume: Math.round(overallVolume),
+    };
+}

package/dist/indicators/vwap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file packages/chart-financial/src/indicators/vwap.ts
+ * Volume Weighted Average Price (VWAP) calculation with daily intraday session resets.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export declare function computeVWAP(bars: readonly OHLCVBar[]): readonly (number | null)[];
+//# sourceMappingURL=vwap.d.ts.map

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

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

package/dist/indicators/vwap.js

@@ -0,0 +1,33 @@
+/**
+ * @file packages/chart-financial/src/indicators/vwap.ts
+ * Volume Weighted Average Price (VWAP) calculation with daily intraday session resets.
+ */
+export function computeVWAP(bars) {
+    if (bars.length === 0)
+        return [];
+    const result = [];
+    let cumVolume = 0;
+    let cumTypicalPriceVolume = 0;
+    let lastSessionKey = '';
+    for (let i = 0; i < bars.length; i++) {
+        const bar = bars[i];
+        const vol = bar.volume ?? 0;
+        // Detect session reset by calendar day
+        const sessionKey = new Date(bar.time * 1000).toDateString();
+        if (sessionKey !== lastSessionKey) {
+            cumVolume = 0;
+            cumTypicalPriceVolume = 0;
+            lastSessionKey = sessionKey;
+        }
+        const typicalPrice = (bar.high + bar.low + bar.close) / 3;
+        cumVolume += vol;
+        cumTypicalPriceVolume += typicalPrice * vol;
+        if (cumVolume > 0) {
+            result.push(cumTypicalPriceVolume / cumVolume);
+        }
+        else {
+            result.push(typicalPrice);
+        }
+    }
+    return result;
+}

package/dist/indicators/wma.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file packages/chart-financial/src/indicators/wma.ts
+ * Weighted Moving Average (WMA) computation with linear weights.
+ */
+import type { OHLCVBar } from '@tranding-custom-chart/core';
+export declare function computeWMA(bars: readonly OHLCVBar[], period: number): readonly (number | null)[];
+//# sourceMappingURL=wma.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wma.d.ts","sourceRoot":"","sources":["../../src/indicators/wma.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,EAAE,MAAM,GACb,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAmB5B"}

package/dist/indicators/wma.js

@@ -0,0 +1,21 @@
+/**
+ * @file packages/chart-financial/src/indicators/wma.ts
+ * Weighted Moving Average (WMA) computation with linear weights.
+ */
+export function computeWMA(bars, period) {
+    if (period <= 0 || bars.length < period) {
+        return bars.map(() => null);
+    }
+    const result = new Array(bars.length).fill(null);
+    const weightDenominator = (period * (period + 1)) / 2;
+    for (let i = period - 1; i < bars.length; i++) {
+        let weightedSum = 0;
+        for (let k = 0; k < period; k++) {
+            const weight = period - k;
+            const barIndex = i - k;
+            weightedSum += bars[barIndex].close * weight;
+        }
+        result[i] = weightedSum / weightDenominator;
+    }
+    return result;
+}

package/dist/layout/pane-layout.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file packages/chart-financial/src/layout/pane-layout.ts
+ * Multi-pane vertical split layout manager (Price, Volume, Indicators).
+ */
+import type { Dimension, Padding } from '@tranding-custom-chart/core';
+export interface PaneDefinition {
+    readonly id: string;
+    readonly heightRatio: number;
+    readonly minHeight?: number | undefined;
+}
+export interface ComputedPaneLayout {
+    readonly id: string;
+    readonly top: number;
+    readonly bottom: number;
+    readonly height: number;
+    readonly padding: Padding;
+}
+export declare function computePaneLayouts(totalBounds: Dimension, padding: Padding, panes: readonly PaneDefinition[], paneGap?: number): readonly ComputedPaneLayout[];
+//# sourceMappingURL=pane-layout.d.ts.map

package/dist/layout/pane-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pane-layout.d.ts","sourceRoot":"","sources":["../../src/layout/pane-layout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAEtE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,SAAS,EACtB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,OAAO,SAAI,GACV,SAAS,kBAAkB,EAAE,CA0C/B"}