oakscriptjs 0.1.6 → 0.1.7

package/dist/index.js

@@ -25,12 +25,15 @@ __export(src_exports, {
   Series: () => Series,
   SimpleInputAdapter: () => SimpleInputAdapter,
   VERSION: () => VERSION,
+  ZigZag: () => ZigZag,
   abs: () => abs,
+  alertcondition: () => alertcondition,
   array: () => array_exports,
   atr: () => atr2,
   avg: () => avg,
   bb: () => bb2,
   box: () => box_exports,
+  calculateZigZag: () => calculateZigZag,
   ceil: () => ceil,
   change: () => change2,
   chartPoint: () => chartpoint_exports,
@@ -51,6 +54,7 @@ __export(src_exports, {
   getHigh: () => getHigh,
   getLow: () => getLow,
   getOpen: () => getOpen,
+  getSourceSeries: () => getSourceSeries,
   hline: () => hline,
   indicator: () => indicator,
   info: () => info,
@@ -69,8 +73,9 @@ __export(src_exports, {
   matrix: () => matrix_exports,
   max: () => max2,
   min: () => min2,
-  na: () => na,
+  na: () => isNA,
   new_color: () => new_color2,
+  nz: () => nz,
   ohlcFromBars: () => ohlcFromBars,
   plot: () => plot2,
   plotHelper: () => plot,
@@ -94,12 +99,12 @@ __export(src_exports, {
   time: () => time_exports,
   tr: () => tr2,
   vwap: () => vwap2,
-  xloc: () => xloc
+  xloc: () => xloc,
+  zigZagDefaults: () => defaultSettings
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/types/index.ts
-var na = null;
 var xloc = {
   /** X-coordinates are bar indices */
   bar_index: "bar_index",
@@ -174,27 +179,29 @@ __export(ta_exports, {
 });
 function sma(source, length2) {
   const result = [];
+  const len = Math.floor(length2);
   for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
+    if (i < len - 1) {
       result.push(NaN);
     } else {
       let sum4 = 0;
-      for (let j = 0; j < length2; j++) {
+      for (let j = 0; j < len; j++) {
         sum4 += source[i - j];
       }
-      result.push(sum4 / length2);
+      result.push(sum4 / len);
     }
   }
   return result;
 }
 function ema(source, length2) {
   const result = [];
-  const multiplier = 2 / (length2 + 1);
+  const len = Math.floor(length2);
+  const multiplier = 2 / (len + 1);
   let ema3 = 0;
-  for (let i = 0; i < Math.min(length2, source.length); i++) {
+  for (let i = 0; i < Math.min(len, source.length); i++) {
     ema3 += source[i];
   }
-  ema3 = ema3 / Math.min(length2, source.length);
+  ema3 = ema3 / Math.min(len, source.length);
   for (let i = 0; i < source.length; i++) {
     if (i === 0) {
       result.push(source[i]);
@@ -254,17 +261,18 @@ function bb(series, length2, mult2) {
 }
 function stdev(source, length2) {
   const result = [];
-  const avg4 = sma(source, length2);
+  const len = Math.floor(length2);
+  const avg4 = sma(source, len);
   for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
+    if (i < len - 1) {
       result.push(NaN);
     } else {
       let sumSquares = 0;
-      for (let j = 0; j < length2; j++) {
+      for (let j = 0; j < len; j++) {
         const diff2 = source[i - j] - avg4[i];
         sumSquares += diff2 * diff2;
       }
-      result.push(Math.sqrt(sumSquares / length2));
+      result.push(Math.sqrt(sumSquares / len));
     }
   }
   return result;
@@ -393,17 +401,34 @@ function supertrend(factor, atrPeriod, high, low, close, wicks = false) {
 }
 function rma(source, length2) {
   const result = [];
-  const alpha = 1 / length2;
-  let rmaValue = 0;
-  for (let i = 0; i < Math.min(length2, source.length); i++) {
-    rmaValue += source[i];
+  const len = Math.floor(length2);
+  const alpha = 1 / len;
+  let firstValidIndex = -1;
+  let validCount = 0;
+  let initSum = 0;
+  for (let i = 0; i < source.length; i++) {
+    const val = source[i];
+    if (val !== void 0 && !isNaN(val)) {
+      initSum += val;
+      validCount++;
+      if (validCount === len) {
+        firstValidIndex = i;
+        break;
+      }
+    }
   }
-  rmaValue = rmaValue / Math.min(length2, source.length);
+  let rmaValue = validCount > 0 ? initSum / validCount : NaN;
+  let rmaInitialized = firstValidIndex >= 0;
   for (let i = 0; i < source.length; i++) {
-    if (i === 0) {
+    if (!rmaInitialized || i < firstValidIndex) {
+      result.push(NaN);
+    } else if (i === firstValidIndex) {
       result.push(rmaValue);
     } else {
-      rmaValue = alpha * source[i] + (1 - alpha) * rmaValue;
+      const val = source[i];
+      if (val !== void 0 && !isNaN(val)) {
+        rmaValue = alpha * val + (1 - alpha) * rmaValue;
+      }
       result.push(rmaValue);
     }
   }
@@ -411,14 +436,15 @@ function rma(source, length2) {
 }
 function wma(source, length2) {
   const result = [];
+  const len = Math.floor(length2);
   for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
+    if (i < len - 1) {
       result.push(NaN);
     } else {
       let sum4 = 0;
       let weightSum = 0;
-      for (let j = 0; j < length2; j++) {
-        const weight = length2 - j;
+      for (let j = 0; j < len; j++) {
+        const weight = len - j;
         sum4 += source[i - j] * weight;
         weightSum += weight;
       }
@@ -658,12 +684,13 @@ function vwma(source, length2, volume) {
 }
 function linreg(source, length2, offset = 0) {
   const result = [];
+  const len = Math.floor(length2);
   for (let i = 0; i < source.length; i++) {
-    if (i < length2 - 1) {
+    if (i < len - 1) {
       result.push(NaN);
     } else {
       let hasNaN = false;
-      for (let j = 0; j < length2; j++) {
+      for (let j = 0; j < len; j++) {
         if (isNaN(source[i - j])) {
           hasNaN = true;
           break;
@@ -676,17 +703,17 @@ function linreg(source, length2, offset = 0) {
         let sumY = 0;
         let sumXY = 0;
         let sumX2 = 0;
-        for (let j = 0; j < length2; j++) {
+        for (let j = 0; j < len; j++) {
           const x2 = j;
-          const y = source[i - (length2 - 1 - j)];
+          const y = source[i - (len - 1 - j)];
           sumX += x2;
           sumY += y;
           sumXY += x2 * y;
           sumX2 += x2 * x2;
         }
-        const slope = (length2 * sumXY - sumX * sumY) / (length2 * sumX2 - sumX * sumX);
-        const intercept = (sumY - slope * sumX) / length2;
-        const x = length2 - 1 - offset;
+        const slope = (len * sumXY - sumX * sumY) / (len * sumX2 - sumX * sumX);
+        const intercept = (sumY - slope * sumX) / len;
+        const x = len - 1 - offset;
         result.push(intercept + slope * x);
       }
     }
@@ -775,8 +802,8 @@ function cci(source, length2) {
     if (isNaN(smaValues[i]) || isNaN(devValues[i]) || devValues[i] === 0) {
       result.push(NaN);
     } else {
-      const cci2 = (source[i] - smaValues[i]) / (0.015 * devValues[i]);
-      result.push(cci2);
+      const cci3 = (source[i] - smaValues[i]) / (0.015 * devValues[i]);
+      result.push(cci3);
     }
   }
   return result;
@@ -1237,9 +1264,9 @@ function vwap(source, volume) {
   }
   return result;
 }
-function alma(source, length2 = 9, offset = 0.85, sigma = 6) {
+function alma(source, length2 = 9, offset = 0.85, sigma = 6, floor2 = false) {
   const result = [];
-  const m = Math.floor(offset * (length2 - 1));
+  const m = floor2 ? Math.floor(offset * (length2 - 1)) : offset * (length2 - 1);
   const s = length2 / sigma;
   const weights = [];
   let weightSum = 0;
@@ -2241,6 +2268,38 @@ var Series = class _Series {
     });
   }
   // ============================================
+  // Conditional Selection
+  // ============================================
+  /**
+   * Bar-by-bar conditional selection (ternary operator for Series)
+   * Uses this Series as the condition (truthy = nonzero, falsy = zero/NaN)
+   *
+   * @param trueValue - Value or Series to use when condition is truthy
+   * @param falseValue - Value or Series to use when condition is falsy
+   * @returns New Series with bar-by-bar selected values
+   *
+   * @example
+   * ```typescript
+   * // PineScript: result = condition ? trueVal : falseVal
+   * const result = condition.iff(trueVal, falseVal);
+   *
+   * // Example: RSI formula uses ternary for edge cases
+   * // rsi = down == 0 ? 100 : up == 0 ? 0 : formula
+   * const rsi = down.eq(0).iff(100, up.eq(0).iff(0, formula));
+   * ```
+   */
+  iff(trueValue, falseValue) {
+    return new _Series(this.dataSource, (bar, i, data) => {
+      const condition = this.extractor(bar, i, data);
+      const isTruthy = condition !== 0 && !Number.isNaN(condition);
+      if (isTruthy) {
+        return typeof trueValue === "number" ? trueValue : trueValue.extractor(bar, i, data);
+      } else {
+        return typeof falseValue === "number" ? falseValue : falseValue.extractor(bar, i, data);
+      }
+    });
+  }
+  // ============================================
   // Offset/History
   // ============================================
   /**
@@ -5166,6 +5225,7 @@ __export(ta_series_exports, {
   alma: () => alma2,
   atr: () => atr2,
   bb: () => bb2,
+  cci: () => cci2,
   change: () => change2,
   cross: () => cross2,
   crossover: () => crossover2,
@@ -5183,8 +5243,10 @@ __export(ta_series_exports, {
   rma: () => rma2,
   roc: () => roc2,
   rsi: () => rsi2,
+  sar: () => sar2,
   sma: () => sma2,
   stdev: () => stdev3,
+  stoch: () => stoch2,
   supertrend: () => supertrend2,
   ta: () => ta,
   tr: () => tr2,
@@ -5254,11 +5316,19 @@ function atr2(bars, length2) {
   const result = atr(length2, high, low, close);
   return Series.fromArray(bars, result);
 }
-function tr2(bars) {
+function tr2(bars, handle_na = false) {
   const high = bars.map((b2) => b2.high);
   const low = bars.map((b2) => b2.low);
   const close = bars.map((b2) => b2.close);
-  const result = tr(false, high, low, close);
+  const result = tr(handle_na, high, low, close);
+  return Series.fromArray(bars, result);
+}
+function stoch2(source, high, low, length2) {
+  const bars = source.bars;
+  const sourceValues = source.toArray();
+  const highValues = high.toArray();
+  const lowValues = low.toArray();
+  const result = stoch(sourceValues, highValues, lowValues, length2);
   return Series.fromArray(bars, result);
 }
 function crossover2(source1, source2) {
@@ -5385,10 +5455,10 @@ function linreg2(source, length2, offset = 0) {
   const result = linreg(sourceValues, length2, offset);
   return Series.fromArray(bars, result);
 }
-function alma2(source, length2 = 9, offset = 0.85, sigma = 6) {
+function alma2(source, length2 = 9, offset = 0.85, sigma = 6, floor2 = false) {
   const bars = source.bars;
   const sourceValues = source.toArray();
-  const result = alma(sourceValues, length2, offset, sigma);
+  const result = alma(sourceValues, length2, offset, sigma, floor2);
   return Series.fromArray(bars, result);
 }
 function zigzag2(bars, deviation = 5, depth = 10, backstep = 3) {
@@ -5408,6 +5478,19 @@ function zigzag2(bars, deviation = 5, depth = 10, backstep = 3) {
     Series.fromArray(bars, pivotVals.map((b2) => b2 ? 1 : 0))
   ];
 }
+function cci2(source, length2) {
+  const bars = source.bars;
+  const sourceValues = source.toArray();
+  const result = cci(sourceValues, length2);
+  return Series.fromArray(bars, result);
+}
+function sar2(bars, start = 0.02, inc = 0.02, max5 = 0.2) {
+  const high = bars.map((b2) => b2.high);
+  const low = bars.map((b2) => b2.low);
+  const close = bars.map((b2) => b2.close);
+  const result = sar(start, inc, max5, high, low, close);
+  return Series.fromArray(bars, result);
+}
 var ta = {
   sma: sma2,
   ema: ema2,
@@ -5420,6 +5503,7 @@ var ta = {
   stdev: stdev3,
   atr: atr2,
   tr: tr2,
+  stoch: stoch2,
   crossover: crossover2,
   crossunder: crossunder2,
   cross: cross2,
@@ -5436,10 +5520,18 @@ var ta = {
   ichimoku: ichimoku2,
   linreg: linreg2,
   alma: alma2,
-  zigzag: zigzag2
+  zigzag: zigzag2,
+  cci: cci2,
+  sar: sar2
 };
 
 // src/utils/index.ts
+function isNA(value) {
+  return value === null || value === void 0 || Number.isNaN(value);
+}
+function nz(value, defaultValue = 0) {
+  return isNA(value) ? defaultValue : value;
+}
 function ohlcFromBars(bars) {
   return {
     open: bars.map((b2) => b2.open),
@@ -5460,6 +5552,229 @@ function getLow(ohlc) {
 function getOpen(ohlc) {
   return ohlc.open;
 }
+function getSourceSeries(bars, source = "close") {
+  const open = new Series(bars, (bar) => bar.open);
+  const high = new Series(bars, (bar) => bar.high);
+  const low = new Series(bars, (bar) => bar.low);
+  const close = new Series(bars, (bar) => bar.close);
+  switch (source) {
+    case "open":
+      return open;
+    case "high":
+      return high;
+    case "low":
+      return low;
+    case "close":
+      return close;
+    case "hl2":
+      return high.add(low).div(2);
+    case "hlc3":
+      return high.add(low).add(close).div(3);
+    case "ohlc4":
+      return open.add(high).add(low).add(close).div(4);
+    case "hlcc4":
+      return high.add(low).add(close).add(close).div(4);
+    default:
+      return close;
+  }
+}
+
+// src/lib/zigzag/zigzag.ts
+var defaultSettings = {
+  devThreshold: 5,
+  depth: 10,
+  lineColor: "#2962FF",
+  extendLast: true,
+  displayReversalPrice: true,
+  displayCumulativeVolume: true,
+  displayReversalPriceChange: true,
+  differencePriceMode: "Absolute",
+  allowZigZagOnOneBar: true
+};
+var ZigZag = class {
+  settings;
+  pivots = [];
+  sumVol = 0;
+  highBuffer = [];
+  lowBuffer = [];
+  timeBuffer = [];
+  barCount = 0;
+  constructor(settings) {
+    this.settings = { ...defaultSettings, ...settings };
+  }
+  /**
+   * Process a single bar, detecting pivots.
+   * Must be called sequentially for each bar.
+   * @returns true if a new pivot was detected or updated
+   */
+  update(bar, barIndex) {
+    this.highBuffer.push(bar.high);
+    this.lowBuffer.push(bar.low);
+    this.timeBuffer.push(bar.time);
+    this.barCount++;
+    const depth = Math.max(2, Math.floor(this.settings.depth / 2));
+    this.sumVol += bar.volume ?? 0;
+    if (this.barCount < depth * 2 + 1)
+      return false;
+    let somethingChanged = this.tryFindPivot(true, depth, barIndex);
+    somethingChanged = this.tryFindPivot(
+      false,
+      depth,
+      barIndex,
+      this.settings.allowZigZagOnOneBar || !somethingChanged
+    ) || somethingChanged;
+    return somethingChanged;
+  }
+  /**
+   * Get the last confirmed pivot
+   */
+  lastPivot() {
+    if (this.pivots.length === 0)
+      return null;
+    const last2 = this.pivots[this.pivots.length - 1];
+    return last2 !== void 0 ? last2 : null;
+  }
+  /**
+   * Get extension line to current bar (if extendLast enabled)
+   */
+  getExtension(currentBar, barIndex) {
+    if (!this.settings.extendLast)
+      return null;
+    const last2 = this.lastPivot();
+    if (!last2)
+      return null;
+    const isHigh = !last2.isHigh;
+    const price = isHigh ? currentBar.high : currentBar.low;
+    return {
+      isHigh,
+      volume: this.sumVol,
+      start: last2.end,
+      end: { time: currentBar.time, barIndex, price }
+    };
+  }
+  // ============ Private Methods ============
+  tryFindPivot(isHigh, depth, currentBarIndex, registerPivot = true) {
+    const point = this.findPivotPoint(isHigh, depth, currentBarIndex);
+    if (!point || !registerPivot)
+      return false;
+    return this.newPivotPointFound(isHigh, point);
+  }
+  /**
+   * Check if a bar from `depth` bars back is a pivot point.
+   * A pivot high has prices below it on both sides.
+   * A pivot low has prices above it on both sides.
+   */
+  findPivotPoint(isHigh, depth, currentBarIndex) {
+    const buffer = isHigh ? this.highBuffer : this.lowBuffer;
+    const pivotBufferIdx = buffer.length - 1 - depth;
+    if (pivotBufferIdx < depth)
+      return null;
+    const pivotPrice = buffer[pivotBufferIdx];
+    if (pivotPrice === void 0)
+      return null;
+    for (let i = pivotBufferIdx + 1; i < buffer.length; i++) {
+      const price = buffer[i];
+      if (price === void 0)
+        return null;
+      if (isHigh) {
+        if (price > pivotPrice)
+          return null;
+      } else {
+        if (price < pivotPrice)
+          return null;
+      }
+    }
+    for (let i = pivotBufferIdx - depth; i < pivotBufferIdx; i++) {
+      const price = buffer[i];
+      if (price === void 0)
+        return null;
+      if (isHigh) {
+        if (price >= pivotPrice)
+          return null;
+      } else {
+        if (price <= pivotPrice)
+          return null;
+      }
+    }
+    const pivotBarIndex = currentBarIndex - depth;
+    const pivotTime = this.timeBuffer[pivotBufferIdx];
+    if (pivotTime === void 0)
+      return null;
+    return {
+      time: pivotTime,
+      barIndex: pivotBarIndex,
+      price: pivotPrice
+    };
+  }
+  /**
+   * Calculate percentage deviation from base price to new price
+   */
+  calcDev(basePrice, price) {
+    return 100 * (price - basePrice) / Math.abs(basePrice);
+  }
+  /**
+   * Handle a newly detected pivot point.
+   * Either updates existing pivot (if same direction) or adds new pivot (if direction changed).
+   */
+  newPivotPointFound(isHigh, point) {
+    const last2 = this.lastPivot();
+    if (!last2) {
+      this.pivots.push({
+        isHigh,
+        volume: this.sumVol,
+        start: point,
+        end: point
+      });
+      this.sumVol = 0;
+      return true;
+    }
+    if (last2.isHigh === isHigh) {
+      const isMoreExtreme = isHigh ? point.price > last2.end.price : point.price < last2.end.price;
+      if (isMoreExtreme) {
+        last2.end = point;
+        last2.volume += this.sumVol;
+        this.sumVol = 0;
+        return true;
+      }
+    } else {
+      const dev2 = this.calcDev(last2.end.price, point.price);
+      const threshold = this.settings.devThreshold;
+      const meetsThreshold = last2.isHigh ? dev2 <= -threshold : dev2 >= threshold;
+      if (meetsThreshold) {
+        this.pivots.push({
+          isHigh,
+          volume: this.sumVol,
+          start: last2.end,
+          end: point
+        });
+        this.sumVol = 0;
+        return true;
+      }
+    }
+    return false;
+  }
+};
+function calculateZigZag(bars, settings) {
+  if (bars.length === 0) {
+    return { pivots: [], extension: null };
+  }
+  const zz = new ZigZag(settings);
+  for (let i = 0; i < bars.length; i++) {
+    const bar = bars[i];
+    if (bar !== void 0) {
+      zz.update(bar, i);
+    }
+  }
+  const lastBar = bars[bars.length - 1];
+  if (lastBar === void 0) {
+    return { pivots: zz.pivots, extension: null };
+  }
+  const extension = zz.getExtension(lastBar, bars.length - 1);
+  return {
+    pivots: zz.pivots,
+    extension
+  };
+}
 
 // src/indicator.ts
 function indicator(metadata, setup) {
@@ -5579,7 +5894,7 @@ var input = {
       defaultValue,
       value: defaultValue,
       title: options.title,
-      options: ["open", "high", "low", "close", "hl2", "hlc3", "ohlc4"]
+      options: ["open", "high", "low", "close", "hl2", "hlc3", "ohlc4", "hlcc4"]
     };
   },
   /**
@@ -6175,3 +6490,5 @@ var info = {
     indicator: ["indicator", "input", "plotHelper", "createPlot"]
   }
 };
+function alertcondition(_condition, _title, _message) {
+}