ohlcv-indicators 3.4.8 → 3.4.9

package/dist/ohlcv-indicators.min.js

@@ -2905,29 +2905,44 @@ var OHLCV_INDICATORS;
                 });
             },
             atr: function(t, e, r, n) {
-                var o = n.lag, i = t.verticalOhlcv, a = t.instances, u = "atr_".concat(r);
+                var o = n.lag, i = n.tp, a = n.sl, u = t.verticalOhlcv, l = t.instances, c = "atr_".concat(r);
                 if (0 === e) {
-                    var l = t.instances, c = t.verticalOhlcv, s = t.arrayTypes, f = t.len, y = t.priceBased;
-                    l[u] = new Yt(r, jt), c[u] = new Float64Array(f).fill(NaN), y.add(u), o > 0 && t.lag([ u ], o), 
-                    s[u] = "Float64Array";
+                    var s = t.instances, f = t.verticalOhlcv, y = t.arrayTypes, p = t.len, h = t.priceBased;
+                    s[c] = new Yt(r, jt);
+                    var v = [ c ];
+                    null !== i && v.push("".concat(c, "_tp")), null !== a && v.push("".concat(c, "_sl"));
+                    for (var m = 0, d = v; m < d.length; m++) {
+                        var b = d[m];
+                        h.add(b), f[b] = new Float64Array(p).fill(NaN), y[b] = "Float64Array";
+                    }
+                    o > 0 && t.lag(v, o);
                 }
                 // Retrieve the current price value.
-                                var p = {
-                    high: i.high[e],
-                    low: i.low[e],
-                    close: i.close[e]
-                }, h = a[u];
+                                var g = {
+                    high: u.high[e],
+                    low: u.low[e],
+                    close: u.close[e]
+                }, w = l[c];
                 // Update the moving average instance.
-                h.update(p);
-                var v = NaN;
+                w.update(g);
+                var O = NaN;
                 try {
-                    v = h.getResult();
+                    O = w.getResult();
                 } catch (t) {}
+                return null !== i && t.pushToMain({
+                    index: e,
+                    key: "".concat(c, "_tp"),
+                    value: Number.isNaN(O) ? NaN : g.close + O * i
+                }), null !== a && t.pushToMain({
+                    index: e,
+                    key: "".concat(c, "_sl"),
+                    value: Number.isNaN(O) ? NaN : g.close - O * a
+                }), 
                 // Always push the MA value (even if NaN).
-                                return t.pushToMain({
+                t.pushToMain({
                     index: e,
-                    key: u,
-                    value: v
+                    key: c,
+                    value: O
                 }), !0;
             },
             ema: Ce,
@@ -3931,15 +3946,25 @@ var OHLCV_INDICATORS;
                         max: this.len,
                         allowDecimals: !1
                     }, "size", r), s(e, "options", r);
-                    var n = e.lag, o = void 0 === n ? 0 : n;
+                    var n = e.lag, o = void 0 === n ? 0 : n, i = e.tp, a = void 0 === i ? null : i, u = e.sl, c = void 0 === u ? null : u;
                     return p(o, {
                         min: 0,
                         max: this.len,
                         allowDecimals: !1
-                    }, "options.lag", r), this.inputParams.push({
+                    }, "options.lag", r), null !== a && p(a, {
+                        min: .01,
+                        max: 100,
+                        allowDecimals: !0
+                    }, "options.tp", r), null !== c && p(c, {
+                        min: .01,
+                        max: 100,
+                        allowDecimals: !0
+                    }, "options.tp", r), this.inputParams.push({
                         key: r,
                         params: [ t, {
-                            lag: o
+                            lag: o,
+                            tp: a,
+                            sl: c
                         } ]
                     }), this;
                 }

package/index.js

@@ -268,11 +268,14 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {lag = 0} = options
+        const {lag = 0, tp = null, sl = null} = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [size, {lag}]})
+        if(tp !== null) validateNumber(tp, {min: 0.01, max: 100, allowDecimals: true}, 'options.tp', methodName)
+        if(sl !== null) validateNumber(sl, {min: 0.01, max: 100, allowDecimals: true}, 'options.tp', methodName)
+
+        this.inputParams.push({key: methodName, params: [size, {lag, tp, sl}]})
 
         return this
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.4.8",
+  "version": "3.4.9",
   "description": "A JavaScript library featuring optimized trading indicators for OHLCV arrays [{open, high, low, close, value}]. This library is optimized for backtesting and trading bot development.",
   "main": "index.js",
   "type": "module",

package/src/volatility/atr.js

@@ -1,7 +1,7 @@
 
 import {FasterATR, FasterWSMA} from 'trading-signals';
 
-export const atr = (main, index, size, {lag}) => {
+export const atr = (main, index, size, {lag, tp, sl}) => {
   const { verticalOhlcv, instances } = main
   const keyName = `atr_${size}`
 
@@ -10,20 +10,35 @@ export const atr = (main, index, size, {lag}) => {
     const {instances, verticalOhlcv, arrayTypes, len, priceBased} = main
 
     instances[keyName] = new FasterATR(size, FasterWSMA)
-    verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
+    
+    const keyNames = [keyName]
 
-    priceBased.add(keyName)
+    if(tp !== null)
+    {
+      keyNames.push(`${keyName}_tp`)
+    }
 
-    if(lag > 0)
+    if(sl !== null)
     {
-      main.lag([keyName], lag)
+       keyNames.push(`${keyName}_sl`)
     }
 
-    arrayTypes[keyName] = 'Float64Array'
+    for(const k of keyNames)
+    {
+      priceBased.add(k)
+      verticalOhlcv[k] = new Float64Array(len).fill(NaN)
+      arrayTypes[k] = 'Float64Array'
+    }
+    
+
+    if(lag > 0)
+    {
+      main.lag(keyNames, lag)
+    }
   }
 
   // Retrieve the current price value.
-  const value = {
+  const curr = {
       high: verticalOhlcv.high[index],
       low: verticalOhlcv.low[index],
       close: verticalOhlcv.close[index],
@@ -31,16 +46,26 @@ export const atr = (main, index, size, {lag}) => {
   const instance = instances[keyName]
 
   // Update the moving average instance.
-  instance.update(value);
-  let currMa = NaN;
+  instance.update(curr);
+  let currAtr = NaN;
   try {
-    currMa = instance.getResult();
+    currAtr = instance.getResult();
   } catch (err) {
 
   }
 
+  if(tp !== null)
+  {
+    main.pushToMain({ index, key: `${keyName}_tp`, value: (!Number.isNaN(currAtr)) ? curr.close + (currAtr*tp) : NaN });
+  }
+
+  if(sl !== null)
+  {
+    main.pushToMain({ index, key: `${keyName}_sl`, value: (!Number.isNaN(currAtr)) ? curr.close - (currAtr*sl) : NaN });
+  }
+
   // Always push the MA value (even if NaN).
-  main.pushToMain({ index, key: keyName, value: currMa });
+  main.pushToMain({ index, key: keyName, value: currAtr });
 
   return true;
 }