@363045841yyt/klinechart-core 0.8.8 → 0.8.9

package/src/engine/indicators/calculators/patterns.ts

@@ -0,0 +1,287 @@
+import type { KLineData } from '../../../types/price'
+
+export interface PivotPoint {
+    pp: number
+    r1: number
+    r2: number
+    r3: number
+    s1: number
+    s2: number
+    s3: number
+}
+
+export function calcPivotData(data: KLineData[]): (PivotPoint | undefined)[] {
+    const n = data.length
+    const result: (PivotPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n < 2) return result
+    for (let t = 1; t < n; t++) {
+        const p = data[t - 1]!
+        const pp = (p.high + p.low + p.close) / 3
+        const range = p.high - p.low
+        result[t] = {
+            pp,
+            r1: 2 * pp - p.low,
+            s1: 2 * pp - p.high,
+            r2: pp + range,
+            s2: pp - range,
+            r3: p.high + 2 * (pp - p.low),
+            s3: p.low - 2 * (p.high - pp),
+        }
+    }
+    return result
+}
+
+export interface FibPoint {
+    high: number
+    low: number
+    direction: 'up' | 'down'
+    level236: number
+    level382: number
+    level500: number
+    level618: number
+    level786: number
+}
+
+export function calcFibData(data: KLineData[], period: number): (FibPoint | undefined)[] {
+    const n = data.length
+    const result: (FibPoint | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || n < period) return result
+
+    for (let t = period - 1; t < n; t++) {
+        let hi = -Infinity
+        let lo = Infinity
+        let hiIdx = t
+        let loIdx = t
+        for (let k = 0; k < period; k++) {
+            const bar = data[t - k]!
+            if (bar.high > hi) { hi = bar.high; hiIdx = t - k }
+            if (bar.low < lo) { lo = bar.low; loIdx = t - k }
+        }
+        const direction: 'up' | 'down' = hiIdx >= loIdx ? 'up' : 'down'
+        const range = hi - lo
+        const level = (frac: number) =>
+            direction === 'up' ? hi - range * frac : lo + range * frac
+        result[t] = {
+            high: hi,
+            low: lo,
+            direction,
+            level236: level(0.236),
+            level382: level(0.382),
+            level500: level(0.5),
+            level618: level(0.618),
+            level786: level(0.786),
+        }
+    }
+    return result
+}
+
+export interface SwingPoint {
+    index: number
+    price: number
+    kind: 'high' | 'low'
+    label: 'HH' | 'HL' | 'LH' | 'LL'
+    confirmed: boolean
+}
+
+export type StructureEventKind = 'BOS' | 'CHOCH'
+
+export interface StructureEvent {
+    kind: StructureEventKind
+    index: number
+    triggerPrice: number
+    brokenLevel: number
+    brokenSwingIndex: number
+    direction: 'up' | 'down'
+}
+
+export interface StructureSnapshot {
+    swings: SwingPoint[]
+    events: StructureEvent[]
+    trend: 'up' | 'down' | 'range'
+}
+
+function isExtremum(
+    data: KLineData[],
+    i: number,
+    left: number,
+    right: number,
+    kind: 'high' | 'low',
+): boolean {
+    const n = data.length
+    if (i < left || i + right >= n) return false
+    const center = kind === 'high' ? data[i]!.high : data[i]!.low
+    for (let k = 1; k <= left; k++) {
+        const v = kind === 'high' ? data[i - k]!.high : data[i - k]!.low
+        if (kind === 'high' ? v >= center : v <= center) return false
+    }
+    for (let k = 1; k <= right; k++) {
+        const v = kind === 'high' ? data[i + k]!.high : data[i + k]!.low
+        if (kind === 'high' ? v >= center : v <= center) return false
+    }
+    return true
+}
+
+export function calcStructureData(
+    data: KLineData[],
+    leftWindow: number,
+    rightWindow: number,
+    breakoutSource: 'close' | 'wick',
+): StructureSnapshot {
+    const n = data.length
+    if (n === 0 || leftWindow < 0 || rightWindow < 0) {
+        return { swings: [], events: [], trend: 'range' }
+    }
+
+    const rawSwings: { index: number; price: number; kind: 'high' | 'low'; confirmed: boolean }[] = []
+    for (let i = 0; i < n; i++) {
+        const bar = data[i]!
+        if (isExtremum(data, i, leftWindow, rightWindow, 'high')) {
+            rawSwings.push({ index: i, price: bar.high, kind: 'high', confirmed: i + rightWindow < n })
+        }
+        if (isExtremum(data, i, leftWindow, rightWindow, 'low')) {
+            rawSwings.push({ index: i, price: bar.low, kind: 'low', confirmed: i + rightWindow < n })
+        }
+    }
+    rawSwings.sort((a, b) => a.index - b.index)
+
+    const swings: SwingPoint[] = []
+    let lastHigh: { index: number; price: number } | null = null
+    let lastLow: { index: number; price: number } | null = null
+    for (const s of rawSwings) {
+        let label: 'HH' | 'HL' | 'LH' | 'LL'
+        if (s.kind === 'high') {
+            label = lastHigh && s.price > lastHigh.price ? 'HH' : 'LH'
+            lastHigh = { index: s.index, price: s.price }
+        } else {
+            label = lastLow && s.price > lastLow.price ? 'HL' : 'LL'
+            lastLow = { index: s.index, price: s.price }
+        }
+        swings.push({ ...s, label })
+    }
+
+    const events: StructureEvent[] = []
+    let trend: 'up' | 'down' | 'range' = 'range'
+    let lastSwingHigh: { index: number; price: number } | null = null
+    let lastSwingLow: { index: number; price: number } | null = null
+    const confirmedSwings = swings.filter((s) => s.confirmed)
+    let swingCursor = 0
+
+    for (let t = 0; t < n; t++) {
+        while (swingCursor < confirmedSwings.length && confirmedSwings[swingCursor]!.index + rightWindow <= t) {
+            const s = confirmedSwings[swingCursor]!
+            if (s.kind === 'high') lastSwingHigh = { index: s.index, price: s.price }
+            else lastSwingLow = { index: s.index, price: s.price }
+            swingCursor++
+        }
+
+        const bar = data[t]!
+        const upBreakPrice = breakoutSource === 'close' ? bar.close : bar.high
+        const downBreakPrice = breakoutSource === 'close' ? bar.close : bar.low
+
+        if (lastSwingHigh && upBreakPrice > lastSwingHigh.price) {
+            const kind: StructureEventKind = trend === 'down' ? 'CHOCH' : 'BOS'
+            events.push({
+                kind,
+                index: t,
+                triggerPrice: upBreakPrice,
+                brokenLevel: lastSwingHigh.price,
+                brokenSwingIndex: lastSwingHigh.index,
+                direction: 'up',
+            })
+            trend = 'up'
+            lastSwingHigh = null
+        } else if (lastSwingLow && downBreakPrice < lastSwingLow.price) {
+            const kind: StructureEventKind = trend === 'up' ? 'CHOCH' : 'BOS'
+            events.push({
+                kind,
+                index: t,
+                triggerPrice: downBreakPrice,
+                brokenLevel: lastSwingLow.price,
+                brokenSwingIndex: lastSwingLow.index,
+                direction: 'down',
+            })
+            trend = 'down'
+            lastSwingLow = null
+        }
+    }
+
+    return { swings, events, trend }
+}
+
+export type ZoneKind = 'FVG_BULL' | 'FVG_BEAR' | 'OB_BULL' | 'OB_BEAR'
+
+export interface Zone {
+    kind: ZoneKind
+    startIndex: number
+    endIndex?: number
+    high: number
+    low: number
+}
+
+export function calcZonesData(
+    data: KLineData[],
+    obLookback: number,
+    structureLeftWindow: number,
+    structureRightWindow: number,
+    breakoutSource: 'close' | 'wick',
+): Zone[] {
+    const n = data.length
+    if (n < 3) return []
+    const zones: Zone[] = []
+
+    for (let t = 2; t < n; t++) {
+        const a = data[t - 2]!
+        const c = data[t]!
+        if (a.high < c.low) {
+            zones.push({
+                kind: 'FVG_BULL',
+                startIndex: t - 1,
+                high: c.low,
+                low: a.high,
+            })
+        }
+        if (a.low > c.high) {
+            zones.push({
+                kind: 'FVG_BEAR',
+                startIndex: t - 1,
+                high: a.low,
+                low: c.high,
+            })
+        }
+    }
+
+    const struct = calcStructureData(data, structureLeftWindow, structureRightWindow, breakoutSource)
+    for (const ev of struct.events) {
+        if (ev.kind !== 'BOS') continue
+        const start = Math.max(0, ev.index - obLookback)
+        if (ev.direction === 'up') {
+            for (let k = ev.index - 1; k >= start; k--) {
+                const bar = data[k]!
+                if (bar.close < bar.open) {
+                    zones.push({ kind: 'OB_BULL', startIndex: k, high: bar.high, low: bar.low })
+                    break
+                }
+            }
+        } else {
+            for (let k = ev.index - 1; k >= start; k--) {
+                const bar = data[k]!
+                if (bar.close > bar.open) {
+                    zones.push({ kind: 'OB_BEAR', startIndex: k, high: bar.high, low: bar.low })
+                    break
+                }
+            }
+        }
+    }
+
+    for (const zone of zones) {
+        for (let t = zone.startIndex + 1; t < n; t++) {
+            const bar = data[t]!
+            if (bar.low <= zone.high && bar.high >= zone.low) {
+                zone.endIndex = t
+                break
+            }
+        }
+    }
+
+    return zones
+}

package/src/engine/indicators/calculators/volatility.ts

@@ -0,0 +1,150 @@
+import type { KLineData } from '../../../types/price'
+import { _computeEMASeries } from './_shared'
+
+export function calcATRData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0) return result
+
+    if (period === 1) {
+        const first = data[0]!
+        result[0] = first.high - first.low
+        let prevClose = first.close
+        for (let i = 1; i < n; i++) {
+            const cur = data[i]!
+            const tr = Math.max(
+                cur.high - cur.low,
+                Math.abs(cur.high - prevClose),
+                Math.abs(cur.low - prevClose),
+            )
+            result[i] = tr
+            prevClose = cur.close
+        }
+        return result
+    }
+
+    if (n < period) return result
+
+    const first = data[0]!
+    let sumTR = first.high - first.low
+    let prevClose = first.close
+
+    for (let i = 1; i < period; i++) {
+        const cur = data[i]!
+        sumTR += Math.max(
+            cur.high - cur.low,
+            Math.abs(cur.high - prevClose),
+            Math.abs(cur.low - prevClose),
+        )
+        prevClose = cur.close
+    }
+
+    let atr = sumTR / period
+    result[period - 1] = atr
+
+    const periodMinusOne = period - 1
+    for (let i = period; i < n; i++) {
+        const cur = data[i]!
+        const tr = Math.max(
+            cur.high - cur.low,
+            Math.abs(cur.high - prevClose),
+            Math.abs(cur.low - prevClose),
+        )
+        atr = (periodMinusOne * atr + tr) / period
+        result[i] = atr
+        prevClose = cur.close
+    }
+
+    return result
+}
+
+export function calcHVData(
+    data: KLineData[],
+    period: number,
+    annualizationFactor: number,
+): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n < 2 || period <= 0 || annualizationFactor <= 0) return result
+
+    const logReturns: number[] = new Array(n)
+    logReturns[0] = 0
+    for (let t = 1; t < n; t++) {
+        const prev = data[t - 1]!.close
+        const cur = data[t]!.close
+        logReturns[t] = (prev > 0 && cur > 0) ? Math.log(cur / prev) : 0
+    }
+
+    const annScale = Math.sqrt(annualizationFactor)
+    for (let t = period; t < n; t++) {
+        let sum = 0
+        for (let k = 1; k <= period; k++) sum += logReturns[t - period + k]!
+        const mean = sum / period
+        let varSum = 0
+        for (let k = 1; k <= period; k++) {
+            const diff = logReturns[t - period + k]! - mean
+            varSum += diff * diff
+        }
+        const std = Math.sqrt(varSum / (period - 1 > 0 ? period - 1 : 1))
+        result[t] = std * annScale * 100
+    }
+
+    return result
+}
+
+export function calcParkinsonData(
+    data: KLineData[],
+    period: number,
+    annualizationFactor: number,
+): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || annualizationFactor <= 0 || n < period) return result
+
+    const factor = 1 / (4 * Math.log(2))
+    const annScale = Math.sqrt(annualizationFactor)
+
+    const hlLogSq: number[] = new Array(n)
+    for (let i = 0; i < n; i++) {
+        const bar = data[i]!
+        if (bar.high > 0 && bar.low > 0) {
+            const ln = Math.log(bar.high / bar.low)
+            hlLogSq[i] = ln * ln
+        } else {
+            hlLogSq[i] = 0
+        }
+    }
+
+    for (let t = period - 1; t < n; t++) {
+        let sum = 0
+        for (let k = 0; k < period; k++) sum += hlLogSq[t - k]!
+        const mean = sum / period
+        result[t] = Math.sqrt(factor * mean) * annScale * 100
+    }
+
+    return result
+}
+
+export function calcChaikinVolData(
+    data: KLineData[],
+    emaPeriod: number,
+    rocPeriod: number,
+): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || emaPeriod <= 0 || rocPeriod <= 0) return result
+
+    const hl: (number | undefined)[] = new Array(n)
+    for (let i = 0; i < n; i++) hl[i] = data[i]!.high - data[i]!.low
+
+    const emaSeries = _computeEMASeries(hl, emaPeriod)
+
+    for (let t = rocPeriod; t < n; t++) {
+        const cur = emaSeries[t]
+        const prev = emaSeries[t - rocPeriod]
+        if (cur === undefined || prev === undefined || prev === 0) continue
+        result[t] = (cur - prev) / prev * 100
+    }
+
+    return result
+}

package/src/engine/indicators/calculators/volume.ts

@@ -0,0 +1,248 @@
+import type { KLineData } from '../../../types/price'
+
+export function calcVMAData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || n < period) return result
+    let sum = 0
+    for (let i = 0; i < period; i++) sum += data[i]!.volume ?? 0
+    result[period - 1] = sum / period
+    for (let t = period; t < n; t++) {
+        sum += (data[t]!.volume ?? 0) - (data[t - period]!.volume ?? 0)
+        result[t] = sum / period
+    }
+    return result
+}
+
+export function calcOBVData(data: KLineData[]): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0) return result
+    let obv = 0
+    result[0] = 0
+    for (let t = 1; t < n; t++) {
+        const cur = data[t]!
+        const prev = data[t - 1]!
+        if (cur.close > prev.close) obv += cur.volume ?? 0
+        else if (cur.close < prev.close) obv -= cur.volume ?? 0
+        result[t] = obv
+    }
+    return result
+}
+
+export function calcPVTData(data: KLineData[]): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0) return result
+    let pvt = 0
+    result[0] = 0
+    for (let t = 1; t < n; t++) {
+        const prevClose = data[t - 1]!.close
+        if (prevClose === 0) {
+            result[t] = pvt
+            continue
+        }
+        pvt += ((data[t]!.close - prevClose) / prevClose) * (data[t]!.volume ?? 0)
+        result[t] = pvt
+    }
+    return result
+}
+
+export function calcVWAPData(
+    data: KLineData[],
+    sessionResetGapMs: number,
+): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0) return result
+
+    let cumPV = 0
+    let cumV = 0
+    let prevTs = data[0]!.timestamp
+
+    for (let t = 0; t < n; t++) {
+        const bar = data[t]!
+        if (sessionResetGapMs > 0 && t > 0 && bar.timestamp - prevTs > sessionResetGapMs) {
+            cumPV = 0
+            cumV = 0
+        }
+        const tp = (bar.high + bar.low + bar.close) / 3
+        cumPV += tp * (bar.volume ?? 0)
+        cumV += bar.volume ?? 0
+        result[t] = cumV > 0 ? cumPV / cumV : tp
+        prevTs = bar.timestamp
+    }
+
+    return result
+}
+
+export function calcCMFData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n === 0 || period <= 0 || n < period) return result
+
+    const mfv: number[] = new Array(n)
+    for (let i = 0; i < n; i++) {
+        const bar = data[i]!
+        const range = bar.high - bar.low
+        const mfm = range > 0 ? ((bar.close - bar.low) - (bar.high - bar.close)) / range : 0
+        mfv[i] = mfm * (bar.volume ?? 0)
+    }
+
+    let sumMFV = 0
+    let sumV = 0
+    for (let i = 0; i < period; i++) {
+        sumMFV += mfv[i]!
+        sumV += data[i]!.volume ?? 0
+    }
+    result[period - 1] = sumV > 0 ? sumMFV / sumV : 0
+
+    for (let t = period; t < n; t++) {
+        sumMFV += mfv[t]! - mfv[t - period]!
+        sumV += (data[t]!.volume ?? 0) - (data[t - period]!.volume ?? 0)
+        result[t] = sumV > 0 ? sumMFV / sumV : 0
+    }
+    return result
+}
+
+export function calcMFIData(data: KLineData[], period: number): (number | undefined)[] {
+    const n = data.length
+    const result: (number | undefined)[] = new Array(n).fill(undefined)
+    if (n < period + 1 || period <= 0) return result
+
+    const tp: number[] = new Array(n)
+    for (let i = 0; i < n; i++) tp[i] = (data[i]!.high + data[i]!.low + data[i]!.close) / 3
+
+    const pmfArr: number[] = new Array(n)
+    const nmfArr: number[] = new Array(n)
+    pmfArr[0] = 0
+    nmfArr[0] = 0
+    for (let i = 1; i < n; i++) {
+        const rmf = tp[i]! * (data[i]!.volume ?? 0)
+        if (tp[i]! > tp[i - 1]!) {
+            pmfArr[i] = rmf
+            nmfArr[i] = 0
+        } else if (tp[i]! < tp[i - 1]!) {
+            pmfArr[i] = 0
+            nmfArr[i] = rmf
+        } else {
+            pmfArr[i] = 0
+            nmfArr[i] = 0
+        }
+    }
+
+    let pSum = 0
+    let nSum = 0
+    for (let i = 1; i <= period; i++) {
+        pSum += pmfArr[i]!
+        nSum += nmfArr[i]!
+    }
+    result[period] = nSum > 0 ? 100 - 100 / (1 + pSum / nSum) : 100
+
+    for (let t = period + 1; t < n; t++) {
+        pSum += pmfArr[t]! - pmfArr[t - period]!
+        nSum += nmfArr[t]! - nmfArr[t - period]!
+        result[t] = nSum > 0 ? 100 - 100 / (1 + pSum / nSum) : 100
+    }
+    return result
+}
+
+export interface VolumeProfileBin {
+    priceLow: number
+    priceHigh: number
+    volume: number
+}
+
+export interface VolumeProfileResult {
+    bins: VolumeProfileBin[]
+    poc: number
+    vah: number
+    val: number
+    totalVolume: number
+}
+
+export function calcVolumeProfileData(
+    data: KLineData[],
+    bins: number,
+    lookback: number,
+    valueAreaPercent: number,
+): VolumeProfileResult {
+    const n = data.length
+    if (n === 0 || bins <= 0) {
+        return { bins: [], poc: 0, vah: 0, val: 0, totalVolume: 0 }
+    }
+
+    const startIdx = lookback > 0 ? Math.max(0, n - lookback) : 0
+    let priceMin = Infinity
+    let priceMax = -Infinity
+    for (let i = startIdx; i < n; i++) {
+        const bar = data[i]!
+        if (bar.low < priceMin) priceMin = bar.low
+        if (bar.high > priceMax) priceMax = bar.high
+    }
+    if (!Number.isFinite(priceMin) || !Number.isFinite(priceMax) || priceMax <= priceMin) {
+        return { bins: [], poc: priceMin, vah: priceMin, val: priceMin, totalVolume: 0 }
+    }
+
+    const binWidth = (priceMax - priceMin) / bins
+    const binVolumes: number[] = new Array(bins).fill(0)
+
+    for (let i = startIdx; i < n; i++) {
+        const bar = data[i]!
+        const barRange = bar.high - bar.low
+        if (barRange <= 0) {
+            const binIdx = Math.min(bins - 1, Math.max(0, Math.floor((bar.close - priceMin) / binWidth)))
+            binVolumes[binIdx]! += bar.volume ?? 0
+            continue
+        }
+        const volPerPrice = (bar.volume ?? 0) / barRange
+        const startBin = Math.max(0, Math.floor((bar.low - priceMin) / binWidth))
+        const endBin = Math.min(bins - 1, Math.floor((bar.high - priceMin) / binWidth))
+        for (let b = startBin; b <= endBin; b++) {
+            const binLow = priceMin + b * binWidth
+            const binHigh = binLow + binWidth
+            const overlapLow = Math.max(bar.low, binLow)
+            const overlapHigh = Math.min(bar.high, binHigh)
+            const overlap = overlapHigh - overlapLow
+            if (overlap > 0) {
+                binVolumes[b]! += overlap * volPerPrice
+            }
+        }
+    }
+
+    const binsArr: VolumeProfileBin[] = binVolumes.map((v, b) => ({
+        priceLow: priceMin + b * binWidth,
+        priceHigh: priceMin + (b + 1) * binWidth,
+        volume: v,
+    }))
+
+    let pocBinIdx = 0
+    for (let b = 1; b < bins; b++) {
+        if (binVolumes[b]! > binVolumes[pocBinIdx]!) pocBinIdx = b
+    }
+    const poc = (binsArr[pocBinIdx]!.priceLow + binsArr[pocBinIdx]!.priceHigh) / 2
+
+    const totalVolume = binVolumes.reduce((a, b) => a + b, 0)
+
+    const target = totalVolume * valueAreaPercent
+    let acc = binVolumes[pocBinIdx]!
+    let lo = pocBinIdx
+    let hi = pocBinIdx
+    while (acc < target && (lo > 0 || hi < bins - 1)) {
+        const loCand = lo > 0 ? binVolumes[lo - 1]! : -Infinity
+        const hiCand = hi < bins - 1 ? binVolumes[hi + 1]! : -Infinity
+        if (loCand >= hiCand && lo > 0) {
+            lo--
+            acc += binVolumes[lo]!
+        } else if (hi < bins - 1) {
+            hi++
+            acc += binVolumes[hi]!
+        } else {
+            break
+        }
+    }
+    const val = binsArr[lo]!.priceLow
+    const vah = binsArr[hi]!.priceHigh
+
+    return { bins: binsArr, poc, vah, val, totalVolume }
+}