ohlcv-indicators 3.5.79 → 3.5.80

package/index.js

@@ -13,7 +13,7 @@ import { verticalToHorizontal } from './src/utilities/verticalToHorizontal.js'
 import { assignTypes } from './src/utilities/assignTypes.js'
 import { dateOutputFormaters } from './src/utilities/dateUtilities.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
-import { CONFIG_VERSION, copyConfig, freezeConfig, registerMapCallback, resolveMapCallback, exportInputParams } from './src/utilities/config.js'
+import { CONFIG_VERSION, copyConfig, freezeConfig } from './src/utilities/config.js'
 
 /**
  * Class OHLCV_INDICATORS
@@ -116,18 +116,13 @@ export default class OHLCV_INDICATORS {
     }
 
 
-    static registerMapCallback(name, callback) {
-        registerMapCallback(name, callback)
-        return this
-    }
-
     exportConfig() {
-        return { ...this.config, inputParams: exportInputParams(this.inputParams) }
+        return { ...this.config, inputParams: copyConfig(this.inputParams) }
     }
 
     _registerIndicator(job) {
         isAlreadyComputed(this)
-        this.inputParams = Object.freeze([...this.inputParams, freezeConfig(copyConfig(job, true))])
+        this.inputParams = Object.freeze([...this.inputParams, freezeConfig(copyConfig(job))])
         return this
     }
 
@@ -175,11 +170,8 @@ export default class OHLCV_INDICATORS {
 
         if (this.isComputing) throw new Error('Computation is already in progress.')
 
-        this.executionParams = copyConfig(this.inputParams, true)
+        this.executionParams = copyConfig(this.inputParams)
             .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
-        for (const job of this.executionParams) {
-            if (job.key === 'mapCols') job.params[1] = resolveMapCallback(job.params[1])
-        }
       
         // Mark as “in progress”
         this.isComputed = false;
@@ -255,6 +247,13 @@ export default class OHLCV_INDICATORS {
 
         isAlreadyComputed(this)
         validateArray(colKeys, 'colKeys', methodName)
+
+        const invalidItem = colKeys.find(v => typeof v !== 'string' || v === '')
+
+        if(invalidItem !== undefined) {
+            throw new Error(`Invalid item "${invalidItem}" (column name) in "colKeys" array param of "${methodName}()".`)
+        }
+
         validateNumber(lookback, {min:1, max: this.len, allowDecimals: false}, 'lookback', methodName)
 
         this._registerIndicator({key: methodName, params: [colKeys, lookback]})
@@ -275,11 +274,12 @@ 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, retLogs = false } = options;
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
 
-        this._registerIndicator({key: methodName, order: 0, params: [size, {lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag, retLogs}]})
  
         return this
     }
@@ -354,12 +354,13 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', lag = 0} = options
+        const {target = 'close', lag = 0, retLogs = false} = options
 
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
 
-        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag, retLogs}]})
 
         return this
     }
@@ -372,12 +373,13 @@ export default class OHLCV_INDICATORS {
         validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
         validateObject(options, 'options', methodName)
 
-        const {target = 'close', lag = 0} = options
+        const {target = 'close', lag = 0, retLogs = false} = options
 
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
 
-        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag, retLogs}]})
 
         return this
     }
@@ -464,11 +466,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(stdDev, {min: 0.01, max: 50, allowDecimals: true}, 'stdDev', methodName)
         validateObject(options, 'options', methodName)
 
-        const { lag = 0} = options
+        const { lag = 0, retLogs = false } = options
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
   
-        this._registerIndicator({key: methodName, params: [size, stdDev, {lag}]});
+        this._registerIndicator({key: methodName, params: [size, stdDev, {lag, retLogs}]});
     
         return this;
     }
@@ -492,6 +495,21 @@ export default class OHLCV_INDICATORS {
 
         return this
     }
+    mfi(size = 14, options = {}) {
+        const methodName = 'mfi'
+
+        isAlreadyComputed(this)
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateObject(options, 'options', methodName)
+
+        const {lag = 0, retLogs = false} = options
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
+
+        this._registerIndicator({key: methodName, params: [size, {lag, retLogs}]})
+        return this
+    }
+
     donchianChannels(size = 20, offset = 0, options = {}) {
 
         const methodName = 'donchianChannels'
@@ -502,11 +520,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(offset, {min: 0, max: this.len, allowDecimals: false}, 'offset', methodName)
       
         validateObject(options, 'options', methodName)
-        const {  lag = 0} = options;
+        const { lag = 0, retLogs = false } = options;
       
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(retLogs, 'options.retLogs', methodName)
       
-        this._registerIndicator({ key: methodName, order: 0, params: [size, offset, {lag}] });
+        this._registerIndicator({ key: methodName, order: 0, params: [size, offset, {lag, retLogs}] });
       
         return this;
     }
@@ -588,33 +607,4 @@ export default class OHLCV_INDICATORS {
         return this
     }
 
-    mapCols(newCols = ['change'], callback = null, options = {}) {
-
-        isAlreadyComputed(this)
-
-        const methodName = 'mapCols'
-
-        if(typeof callback === 'undefined' || callback === null)
-        {
-            callback = 'default'
-        }
-
-        validateObject(options, 'options', methodName)
-
-        const {lag = 0, isPriceBased = false, callbackParams = {}} = options
-        resolveMapCallback(callback)
-        const savedCallbackParams = copyConfig(callbackParams)
-
-        validateArray(newCols, 'newCols', methodName)
-        validateNumber(lag, {min: 0, allowDecimals: false}, 'options.lag', methodName)
-        validateBoolean(isPriceBased, 'isPriceBased', 'mapCols')
-
-        if(this.precision === false && isPriceBased) {
-            throw new Error(`Invalid param: If "mapCols.options.isPriceBased" is true, the "constructor.precision" param must be also true.`)
-        }
-
-        this._registerIndicator({key: methodName, params: [newCols, callback, {lag, isPriceBased, callbackParams: savedCallbackParams}]})
-
-        return this
-    }
 }

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.79",
+  "version": "3.5.80",
   "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",
   "scripts": {
     "test": "node test/test.js",
+    "test-benchmark": "npm test -- --benchmark --rows 20000 --repeats 9",
     "build": "npx webpack",
     "cross": "node src/studies/findCrosses2.js"
   },
   "author": "https://jaimelias.com/",
   "license": "ISC",
-  "dependencies": {
-    "ohlcv-indicators": "^3.5.72",
-    "trading-signals": "^5.0.4"
-  },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "@babel/plugin-proposal-class-properties": "^7.18.6",

package/src/core-functions/mainLoop.js

@@ -1,6 +1,7 @@
 import { areKeyValuesValid } from "./pushToMain.js";
 import { validateInputParams } from "../utilities/validators.js";
 import { rsi } from "../oscillators/rsi.js";
+import { mfi } from "../oscillators/mfi.js";
 import { stochastic } from "../oscillators/stochastic.js";
 import { movingAverages } from "../moving-averages/movingAverages.js";
 import { heikenAshi } from "../moving-averages/heikenAshi.js";
@@ -15,12 +16,12 @@ import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
 import { atr } from "../volatility/atr.js";
 import { adx } from "../volatility/adx.js";
-import { mapCols } from "../studies/mapCols.js";
 
 import { buildArray } from "../utilities/assignTypes.js";
 import {  inputNumberFormatter } from "../utilities/numberUtilities.js";
 import { dateFormaters } from "../utilities/dateUtilities.js";
 import { candleFeatures } from "../studies/candleFeatures.js";
+import { getPrecisionDecimals } from "../utilities/precisionMultiplier.js";
 
 
 // Map indicator keys to their respective functions
@@ -29,6 +30,7 @@ const mainFunctions = {
   dateTime,
   heikenAshi,
   rsi,
+  mfi,
   stochastic,
   atr,
   adx,
@@ -40,7 +42,6 @@ const mainFunctions = {
   donchianChannels,
   bollingerBands,
   volumeOscillator,
-  mapCols,
   crossPairs,
   lag
 };
@@ -70,16 +71,16 @@ export const mainLoop = (input, main) => {
     verticalOhlcv[key] = buildArray(arrayTypes[key], len)
   }
 
-  // Callbacks can modify inputTypes through main; retain dynamic lookup for them.
-  const inputColumns = executionParams.some(({ key }) => key === 'mapCols')
-    ? null
-    : Object.entries(inputTypes).map(([key, formatterKey]) => {
-        const numeric = inputNumberFormatter.hasOwnProperty(formatterKey)
-        const formatter = numeric
-          ? inputNumberFormatter[formatterKey]
-          : dateFormaters.hasOwnProperty(formatterKey) ? dateFormaters[formatterKey] : null
-        return { key, formatter, numeric }
-      })
+  const inputColumns = Object.entries(inputTypes).map(([key, formatterKey]) => {
+    const numeric = inputNumberFormatter.hasOwnProperty(formatterKey)
+    const formatter = numeric
+      ? inputNumberFormatter[formatterKey]
+      : dateFormaters.hasOwnProperty(formatterKey) ? dateFormaters[formatterKey] : null
+    return { key, formatter, numeric }
+  })
+  const precisionDecimals = typeof precisionMultiplier === 'number'
+    ? getPrecisionDecimals(precisionMultiplier) : undefined
+  let validationColumns = null
 
   // Process each row in the input
   for (let chunkStart = 0; chunkStart < len; chunkStart += chunkProcess) {
@@ -89,37 +90,13 @@ export const mainLoop = (input, main) => {
       for (let index = chunkStart; index < chunkEnd; index++) {
         const curr = input[index]
       
-        if (inputColumns !== null) {
-          for (const { key, formatter, numeric } of inputColumns) {
-            const value = curr[key]
-            if (typeof value === 'undefined') continue
-
-            const formattedValue = formatter === null ? value
-              : numeric ? formatter(value, precisionMultiplier) : formatter(value)
-            main.pushToMain({ index, key, value: formattedValue })
-          }
-        } else {
-          for(const [key, formaterKey] of Object.entries(inputTypes))
-          {
-            let value = curr[key]
-
-            if(typeof value === 'undefined') continue
-
-            if(inputNumberFormatter.hasOwnProperty(formaterKey))
-            {
-              const formatedValue = inputNumberFormatter[formaterKey](value, precisionMultiplier)
-
-              main.pushToMain({index, key, value: formatedValue})
-            }
-            else if(dateFormaters.hasOwnProperty(formaterKey))
-            {
-              main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
-            }
-            else
-            {
-              main.pushToMain({index, key, value})
-            }
-          }
+        for (const { key, formatter, numeric } of inputColumns) {
+          const value = curr[key]
+          if (typeof value === 'undefined') continue
+
+          const formattedValue = formatter === null ? value
+            : numeric ? formatter(value, precisionMultiplier, precisionDecimals) : formatter(value)
+          main.pushToMain({ index, key, value: formattedValue })
         }
 
         const midPrice = (verticalOhlcv.open[index] + verticalOhlcv.close[index]) / 2
@@ -134,10 +111,13 @@ export const mainLoop = (input, main) => {
       
         input[index] = null //flusing data
 
-        const keyNames = Object.keys(verticalOhlcv)
+        // All built-in outputs (including generated lags) exist after row zero.
+        if (validationColumns === null) {
+          validationColumns = Object.values(verticalOhlcv)
+        }
 
-        // if any value at this index is missing/NaN/null, mark it invalid
-        if (!areKeyValuesValid(main, index, keyNames)) {
+        // Preserve the missing/NaN/null predicate, including Infinity behavior.
+        if (!areKeyValuesValid(validationColumns, index)) {
           main.invalidValueIndex = index
         }
       }

package/src/core-functions/pushToMain.js

@@ -5,29 +5,12 @@ export const pushToMain = ({main, index, key, value}) => {
     verticalOhlcv[key][index] = value
 }
 
-export const areKeyValuesValid = (main, index, keyNames) => {
-    
-    if(keyNames.length === 0) return false
+export const areKeyValuesValid = (columns, index) => {
 
-    const {verticalOhlcv} = main
-
-    let output = true
-
-    for(let x = 0 ; x < keyNames.length; x++)
-    {
-        const key = keyNames[x]
-        if(!verticalOhlcv.hasOwnProperty(key)) {
-            output = false
-            break
-        }
-
-        const val = verticalOhlcv[key][index]
-
-        if (val == null || Number.isNaN(val)) {
-            output = false
-            break
-        }
+    if (columns.length === 0) return false
+    for (let x = 0; x < columns.length; x++) {
+        const val = columns[x][index]
+        if (val == null || Number.isNaN(val)) return false
     }
-
-    return output
-}
+    return true
+}

package/src/core-indicators/README.md

@@ -1,11 +1,9 @@
 # Core indicators
 
-Local numeric replacements for the `Faster*` implementations used from
-`trading-signals@5.0.4`. The existing constructor arguments, `update(value,
+Local numeric `Faster*` indicator implementations. The existing constructor arguments, `update(value,
 replace?)`, `isStable`, and `getResult()` interface remain available. The
 numeric series also retain result/extrema and replacement semantics. These
-are not replacements for the arbitrary-precision `Big` classes or a promise
-of compatibility with other trading-signals versions.
+use ordinary JavaScript numbers, not arbitrary-precision decimal arithmetic.
 
 ```js
 import { FasterEMA } from './index.js'
@@ -45,11 +43,12 @@ of previously supplied objects. Private buffer layouts intentionally differ.
 
 ## Verification
 
-`npm test` compares the core classes directly with the installed
-trading-signals reference, checks bounded retained storage, and exercises all
-public indicators, precision/log modes, lags, callbacks, and config replay.
-The dependency is retained as a regression oracle; production source imports
-only these local classes. Preserve the reference version in the lockfile.
+`npm test` checks known core results and fixed behavior traces captured before
+runtime optimizations, checks bounded retained storage, and exercises all
+public indicators, precision/log modes, lags, and config replay.
+These checks are self-contained: no third-party indicator library or test
+oracle is installed. Preserve the trace expectations unless intentionally
+changing the corresponding behavior.
 
 `node test/test.js --baseline /path/to/original/index.js --benchmark` also
 compares the full pipeline with a pre-change checkout. Benchmarks report

package/src/core-indicators/indicator.js

@@ -1,5 +1,4 @@
 /*!
- * Portions adapted from trading-signals 5.0.4.
  * MIT License
  * Copyright (c) 2020 Benny Neugebauer
  *

package/src/moving-averages/bollingerBands.js

@@ -1,11 +1,13 @@
 import { FasterBollingerBands } from '../core-indicators/index.js'
 import { validateInputValues } from '../utilities/validators.js'
 import { initializeColumns } from '../core-functions/initializeColumns.js'
+import { mathLog } from '../utilities/math.js'
 
-export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
+export const bollingerBands = (main, index, size, stdDev, { lag, retLogs = false } = {}) => {
   const { verticalOhlcv, instances, useFullNames } = main
   const indicatorKey = `${size}_${stdDev}`
-  const prefix = 'bollinger_bands'
+  const instanceKey = `${retLogs ? 'ret_log_' : ''}${indicatorKey}`
+  const prefix = `${retLogs ? 'ret_log_' : ''}bollinger_bands`
   const target = 'close'
 
   // Initialization on the first call.
@@ -31,25 +33,28 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
       }
     }
 
-    instances.bollinger_bands.settings[indicatorKey] = new FasterBollingerBands(size, stdDev)
+    instances.bollinger_bands.settings[instanceKey] = new FasterBollingerBands(size, stdDev)
 
     const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-    const keyNames = [
+    const keyNames = retLogs ? [
+      `${prefix}_width${suffix}`,
+      `${prefix}_position${suffix}`,
+    ] : [
       `${prefix}_upper${suffix}`,
       `${prefix}_middle${suffix}`,
       `${prefix}_lower${suffix}`,
     ]
 
     initializeColumns(main, keyNames.map(key => ({
-      key, priceBased: priceBased.has(target)
+      key, priceBased: !retLogs && priceBased.has(target)
     })), { lag })
   }
 
   const { numberOfIndicators } = instances.bollinger_bands
   const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-  const instance = instances.bollinger_bands.settings[indicatorKey]
+  const instance = instances.bollinger_bands.settings[instanceKey]
   const value = verticalOhlcv[target][index]
   instance.update(value)
 
@@ -59,6 +64,24 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
   const middle = result?.middle ?? NaN
   const lower = result?.lower ?? NaN
 
+  if (retLogs) {
+    let width = NaN
+    let position = NaN
+    const rangeRatio = upper / lower
+    if (lower > 0 && upper >= lower && Number.isFinite(upper) && Number.isFinite(rangeRatio)) {
+      const logRange = mathLog(rangeRatio, 1)
+      width = logRange / 2
+      const locationRatio = value / lower
+      if (logRange > 0 && value > 0 && locationRatio > 0 && Number.isFinite(locationRatio)) {
+        const normalized = 2 * mathLog(locationRatio, 1) / logRange - 1
+        if (Number.isFinite(normalized)) position = normalized
+      }
+    }
+    main.pushToMain({ index, key: `${prefix}_width${suffix}`, value: width })
+    main.pushToMain({ index, key: `${prefix}_position${suffix}`, value: position })
+    return
+  }
+
   main.pushToMain({ index, key: `${prefix}_upper${suffix}`, value: upper })
   main.pushToMain({ index, key: `${prefix}_middle${suffix}`, value: middle })
   main.pushToMain({ index, key: `${prefix}_lower${suffix}`, value: lower })

package/src/moving-averages/donchianChannel.js

@@ -1,36 +1,40 @@
 import { validateInputValues } from '../utilities/validators.js'
 import { initializeColumns } from '../core-functions/initializeColumns.js'
+import { mathLog } from '../utilities/math.js'
 
 export const donchianChannels = (main, index, size, offset, options) => {
   const { verticalOhlcv, instances, len, inputParams, useFullNames } = main
-  const { lag: outputLag = 0 } = options
+  const { lag: outputLag = 0, retLogs = false } = options
   const indicatorKey = `${size}_${offset}`
+  const instanceKey = `${retLogs ? 'ret_log_' : ''}${indicatorKey}`
+  const prefix = `${retLogs ? 'ret_log_' : ''}donchian_channel`
 
   // ---- INIT (only at first bar) ----
   if (index === 0) {
     validateInputValues({ high: true, low: true }, verticalOhlcv, index, 'donchianChannels')
+    if (retLogs) validateInputValues({ close: true }, verticalOhlcv, index, 'donchianChannels')
 
     const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length
     const useIndexedKeys = numberOfIndicators > 1 || useFullNames
 
     const getKey = name =>
       useIndexedKeys
-        ? `donchian_channel_${name}_${indicatorKey}`
-        : `donchian_channel_${name}`
+        ? `${prefix}_${name}_${indicatorKey}`
+        : `${prefix}_${name}`
 
-    const keys = ['upper', 'basis', 'lower'].map(getKey)
+    const keys = (retLogs ? ['width', 'position'] : ['upper', 'basis', 'lower']).map(getKey)
 
     if (!instances.donchian_channel) {
       instances.donchian_channel = { numberOfIndicators, settings: {} }
     }
 
     instances.donchian_channel.numberOfIndicators = numberOfIndicators
-    instances.donchian_channel.settings[indicatorKey] = {
+    instances.donchian_channel.settings[instanceKey] = {
       maxDeque: { indices: [], head: 0, length: 0 },
       minDeque: { indices: [], head: 0, length: 0 }
     }
 
-    initializeColumns(main, keys.map(key => ({ key, priceBased: true })), { lag: outputLag })
+    initializeColumns(main, keys.map(key => ({ key, priceBased: !retLogs })), { lag: outputLag })
   }
 
   // ---- PER-BAR COMPUTATION ----
@@ -39,10 +43,10 @@ export const donchianChannels = (main, index, size, offset, options) => {
 
   const getKey = name =>
     useIndexedKeys
-      ? `donchian_channel_${name}_${indicatorKey}`
-      : `donchian_channel_${name}`
+      ? `${prefix}_${name}_${indicatorKey}`
+      : `${prefix}_${name}`
 
-  const { maxDeque, minDeque } = settings[indicatorKey]
+  const { maxDeque, minDeque } = settings[instanceKey]
   const current = index - offset
   const start = current - size + 1
 
@@ -74,6 +78,27 @@ export const donchianChannels = (main, index, size, offset, options) => {
   const hasBounds = maxDeque.length && minDeque.length
   const upper = hasBounds ? highs[maxDeque.indices[maxDeque.head]] : NaN
   const lower = hasBounds ? lows[minDeque.indices[minDeque.head]] : NaN
+
+  if (retLogs) {
+    let width = NaN
+    let position = NaN
+    const rangeRatio = upper / lower
+    if (lower > 0 && upper >= lower && Number.isFinite(upper) && Number.isFinite(rangeRatio)) {
+      const logRange = mathLog(rangeRatio, 1)
+      width = logRange / 2
+      // Offset applies to the channel window, not to the current close.
+      const close = verticalOhlcv.close[index]
+      const locationRatio = close / lower
+      if (logRange > 0 && close > 0 && locationRatio > 0 && Number.isFinite(locationRatio)) {
+        const normalized = 2 * mathLog(locationRatio, 1) / logRange - 1
+        if (Number.isFinite(normalized)) position = normalized
+      }
+    }
+    main.pushToMain({ index, key: getKey('width'), value: width })
+    main.pushToMain({ index, key: getKey('position'), value: position })
+    return
+  }
+
   const basis = hasBounds ? (upper + lower) / 2 : NaN
 
   main.pushToMain({ index, key: getKey('upper'), value: upper })

package/src/moving-averages/heikenAshi.js

@@ -13,7 +13,6 @@ export const heikenAshi = (
 ) => {
   const { verticalOhlcv, instances, scaledGroups } = main;
   const indicatorKey = `${smoothLength}_${afterSmoothLength}`;
-  const ohlcKeys = ['open', 'high', 'low', 'close'];
 
   const getRet = (next, prev) => retLogs
     ? Math.log(next / prev)
@@ -25,13 +24,6 @@ export const heikenAshi = (
 
   const getKey = key => `${prefix}heiken_ashi_${key}${paramsKey}`;
 
-  const featureKeys = [
-    'body',
-    'upper_wick',
-    'lower_wick',
-    'range'
-  ];
-
   const crossKey = bothNull
     ? 'heiken_ashi_cross'
     : `heiken_ashi_cross_${indicatorKey}`;
@@ -43,6 +35,8 @@ export const heikenAshi = (
   // ---- INIT ----
   if (index === 0) {
     validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'heikenAshi');
+    const ohlcKeys = ['open', 'high', 'low', 'close'];
+    const featureKeys = ['body', 'upper_wick', 'lower_wick', 'range'];
 
     instances[instanceKey] = {
       emaPre: !bothNull
@@ -206,18 +200,15 @@ export const heikenAshi = (
   const bodyTop = Math.max(smOpen, smClose);
   const bodyBottom = Math.min(smOpen, smClose);
 
-  const row = {
-    [getKey('body')]: getRet(smClose, smOpen),
-    [getKey('upper_wick')]: getRet(smHigh, bodyTop),
-    [getKey('lower_wick')]: getRet(bodyBottom, smLow),
-    [getKey('range')]: getRet(smHigh, smLow),
-  };
+  const body = getRet(smClose, smOpen);
+  const upperWick = getRet(smHigh, bodyTop);
+  const lowerWick = getRet(bodyBottom, smLow);
+  const range = getRet(smHigh, smLow);
 
-  for (const [key, value] of Object.entries(row)) {
-    if (!isBadNumber(value)) {
-      main.pushToMain({ index, key, value });
-    }
-  }
+  if (!isBadNumber(body)) main.pushToMain({ index, key: getKey('body'), value: body });
+  if (!isBadNumber(upperWick)) main.pushToMain({ index, key: getKey('upper_wick'), value: upperWick });
+  if (!isBadNumber(lowerWick)) main.pushToMain({ index, key: getKey('lower_wick'), value: lowerWick });
+  if (!isBadNumber(range)) main.pushToMain({ index, key: getKey('range'), value: range });
 
   // Do not add return logs to cross.
   main.pushToMain({ index, key: crossKey, value: cross });