ohlcv-indicators 3.5.77 → 3.5.79

package/dist/ohlcv-indicators.min.js.LICENSE.txt

@@ -0,0 +1,23 @@
+/*!
+ * Portions adapted from trading-signals 5.0.4.
+ * MIT License
+ * Copyright (c) 2020 Benny Neugebauer
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */

package/index.js

@@ -6,16 +6,14 @@ import {
     validateArrayOptions, 
     validateBoolean, 
     validateNumber, 
-    validateArrayOfRanges,
     validateInputParams,
     validateString
 } from './src/utilities/validators.js'
 import { verticalToHorizontal } from './src/utilities/verticalToHorizontal.js'
-import { pushToMain } from './src/core-functions/pushToMain.js'
 import { assignTypes } from './src/utilities/assignTypes.js'
 import { dateOutputFormaters } from './src/utilities/dateUtilities.js'
-import { defaultMapColsCallback } from './src/studies/mapCols.js'
 import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
+import { CONFIG_VERSION, copyConfig, freezeConfig, registerMapCallback, resolveMapCallback, exportInputParams } from './src/utilities/config.js'
 
 /**
  * Class OHLCV_INDICATORS
@@ -26,14 +24,41 @@ import { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
  */
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, inputParams = null, chunkProcess = 2000, precision = false, useFullNames = false}) {
+    constructor({input, ticker = null, chunkProcess = 2000, config = {}}) {
+
+        if (config === null || Array.isArray(config) || typeof config !== 'object') {
+            throw new TypeError('Constructor "config" must be a plain object.')
+        }
+        const savedConfig = copyConfig(config)
+        const configKeys = ['schemaVersion', 'precision', 'useFullNames', 'inputParams', 'dateFormat', 'skipNull', 'timeZone']
+        for (const key of Object.keys(savedConfig)) {
+            if (!configKeys.includes(key)) throw new Error(`Unknown configuration option "${key}".`)
+        }
+        const {
+            schemaVersion = CONFIG_VERSION,
+            precision = false,
+            useFullNames = false,
+            inputParams = null,
+            dateFormat = 'milliseconds',
+            skipNull = true,
+            timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone
+        } = savedConfig
+
+        if (schemaVersion !== CONFIG_VERSION) throw new Error(`Unsupported configuration schemaVersion: ${schemaVersion}.`)
+        validateBoolean(skipNull, 'config.skipNull', 'constructor')
+        validateString(dateFormat, 'config.dateFormat', 'constructor')
+        validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'config.dateFormat', 'constructor')
+        validateString(timeZone, 'config.timeZone', 'constructor')
+        const resolvedTimeZone = new Intl.DateTimeFormat('en-US', { timeZone }).resolvedOptions().timeZone
+        this.config = Object.freeze({ schemaVersion, precision, useFullNames, dateFormat, skipNull, timeZone: resolvedTimeZone })
+        this.timeZone = resolvedTimeZone
 
         validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
 
         validateNumber(chunkProcess, {min: 100, max: 50000, allowDecimals: false}, 'chunkProcess', 'constructor')
         validateBoolean(precision, 'precision', 'contructor')
-        validateBoolean(precision, 'useFullNames', 'contructor')
+        validateBoolean(useFullNames, 'config.useFullNames', 'constructor')
 
         this.chunkProcess = chunkProcess
         
@@ -57,6 +82,8 @@ export default class OHLCV_INDICATORS {
 
         this.dateType = this.inputTypes.date ? this.inputTypes.date : null;
         this.isComputed = false
+        this.isComputing = false
+        this.executionParams = []
 
         this.instances = {}
         this.verticalOhlcv = {}
@@ -68,17 +95,19 @@ export default class OHLCV_INDICATORS {
         this.scaledGroups = {}
         this.isAlreadyComputed = new Set()
 
-        this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
+        this.pushToMain = ({index, key, value}) => {
+            this.verticalOhlcv[key][index] = value
+        }
         
         if(inputParams !== null)
         {
             validateInputParams(inputParams, this.len)
-            this.inputParams = inputParams.sort((a, b) => a.order - b.order)
+            this.inputParams = freezeConfig(copyConfig(inputParams))
             this.compute()
         }
         else
         {
-            this.inputParams = []
+            this.inputParams = Object.freeze([])
         }
 
         
@@ -87,12 +116,27 @@ export default class OHLCV_INDICATORS {
     }
 
 
+    static registerMapCallback(name, callback) {
+        registerMapCallback(name, callback)
+        return this
+    }
+
+    exportConfig() {
+        return { ...this.config, inputParams: exportInputParams(this.inputParams) }
+    }
+
+    _registerIndicator(job) {
+        isAlreadyComputed(this)
+        this.inputParams = Object.freeze([...this.inputParams, freezeConfig(copyConfig(job, true))])
+        return this
+    }
+
     getData(options = {}) {
 
         //getData method returns the last object (row) of the new OHLCV with indicators: {open, high, low, close, rsi_14, bollinger_bands_upper}
         this.compute()
 
-        const {skipNull = true, dateFormat = 'milliseconds'} = options
+        const {skipNull = this.config.skipNull, dateFormat = this.config.dateFormat} = options
 
         validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getData')
         validateObject(options, 'options', 'getData')
@@ -110,7 +154,7 @@ export default class OHLCV_INDICATORS {
 
         this.compute()
 
-        const {dateFormat = 'milliseconds'} = options
+        const {dateFormat = this.config.dateFormat} = options
         
         validateArrayOptions(Object.keys(dateOutputFormaters), dateFormat, 'dateFormat', 'getData')
 
@@ -129,7 +173,13 @@ export default class OHLCV_INDICATORS {
           return this;
         }
 
-        this.inputParams = this.inputParams.sort((a, b) => a.order - b.order)
+        if (this.isComputing) throw new Error('Computation is already in progress.')
+
+        this.executionParams = copyConfig(this.inputParams, true)
+            .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;
@@ -140,7 +190,12 @@ export default class OHLCV_INDICATORS {
         // Only run the full loop once (or when new data appears later,
         // if you extend this to reset isComputed elsewhere)
         if (this.len > 0) {
-            mainLoop(this.input, this)
+            this.isComputing = true
+            try {
+                mainLoop(this.input, this)
+            } finally {
+                this.isComputing = false
+            }
 
             this.isComputed = true;
 
@@ -188,7 +243,7 @@ export default class OHLCV_INDICATORS {
 
         this.isAlreadyComputed.add(methodName)
 
-        this.inputParams.push({key: methodName, params: [arr, {limit, oneHot}]})
+        this._registerIndicator({key: methodName, params: [arr, {limit, oneHot}]})
         
         return this
     }
@@ -202,7 +257,7 @@ export default class OHLCV_INDICATORS {
         validateArray(colKeys, 'colKeys', methodName)
         validateNumber(lookback, {min:1, max: this.len, allowDecimals: false}, 'lookback', methodName)
 
-        this.inputParams.push({key: methodName, params: [colKeys, lookback]})
+        this._registerIndicator({key: methodName, params: [colKeys, lookback]})
         
         return this;
     }
@@ -224,7 +279,7 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag}]})
  
         return this
     }
@@ -245,7 +300,7 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [{lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [{lag}]})
  
         return this
     }
@@ -265,7 +320,7 @@ export default class OHLCV_INDICATORS {
         validateBoolean(retLogs, 'options.retLogs', methodName)
 
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag, retLogs}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag, retLogs}]})
 
         return this
     }
@@ -285,7 +340,7 @@ export default class OHLCV_INDICATORS {
         validateBoolean(retLogs, 'options.retLogs', methodName)
 
 
-        this.inputParams.push({key: methodName, order: 0, params: [size, {lag, retLogs}]})
+        this._registerIndicator({key: methodName, order: 0, params: [size, {lag, retLogs}]})
 
         return this
     }
@@ -304,7 +359,7 @@ export default class OHLCV_INDICATORS {
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -322,7 +377,7 @@ export default class OHLCV_INDICATORS {
         validateString(target, 'options.target', methodName)
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
-        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
+        this._registerIndicator({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -348,30 +403,7 @@ export default class OHLCV_INDICATORS {
 
         const order = 0
 
-        this.inputParams.push({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag, bothNull, retLogs}]})
-
-        return this
-    }
-
-    vidya(size = 14, momentum = 20, options = {}) {
-
-        const methodName = 'vidya'
-
-        isAlreadyComputed(this)
-
-        validateNumber(size, {min: 2, max: this.len, allowDecimals: false}, 'size', methodName)
-        validateNumber(momentum, {min: 1, max: this.len, allowDecimals: false}, 'momentum', methodName)
-        validateObject(options, 'options', methodName)
-
-        const {target = 'close', lag = 0, atrLength = 200, bandDistance = 2, liquidityLookback = 20} = options
-
-        validateString(target, 'options.target', methodName)
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
-        validateNumber(bandDistance, {min: 0.01, max: 10, allowDecimals: true}, 'options.bandDistance', methodName)
-        validateNumber(atrLength, {min: 2, max: this.len, allowDecimals: false}, 'options.atrLength', methodName)
-        validateNumber(liquidityLookback, {min: 1, max: this.len, allowDecimals: false}, 'options.liquidityLookback', methodName)
-
-        this.inputParams.push({key: methodName, params: [size, momentum, {target, lag}]})
+        this._registerIndicator({key: methodName, order, params: [smoothLength, afterSmoothLength, {lag, bothNull, retLogs}]})
 
         return this
     }
@@ -379,6 +411,8 @@ export default class OHLCV_INDICATORS {
     stochastic(kPeriod = 14, kSlowingPeriod = 3, dPeriod = 3, options = {}){
         const methodName = 'stochastic'
 
+        isAlreadyComputed(this)
+
         const {len: max} = this
 
         validateNumber(kPeriod, {min: 1, max, allowDecimals: false}, 'kPeriod', methodName)
@@ -391,7 +425,7 @@ export default class OHLCV_INDICATORS {
         validateNumber(lag, {min: 0, max, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(retLogs, 'retLogs', methodName)
 
-        this.inputParams.push({key: methodName, params: [kPeriod, kSlowingPeriod, dPeriod, {lag, retLogs}]})
+        this._registerIndicator({key: methodName, params: [kPeriod, kSlowingPeriod, dPeriod, {lag, retLogs}]})
 
         return this
     }
@@ -415,7 +449,7 @@ export default class OHLCV_INDICATORS {
         const instanceKey = `${fast}_${slow}_${signal}${target === 'close' ? '' : `_${target}`}`
         const precomputed = {instanceKey}
 
-        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
+        this._registerIndicator({key: methodName, params: [fast, slow, signal, {target, lag, precomputed}]})
         
         return this
 
@@ -434,7 +468,7 @@ export default class OHLCV_INDICATORS {
 
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
   
-        this.inputParams.push({key: methodName, params: [size, stdDev, {lag}]});
+        this._registerIndicator({key: methodName, params: [size, stdDev, {lag}]});
     
         return this;
     }
@@ -454,7 +488,7 @@ export default class OHLCV_INDICATORS {
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
         validateBoolean(retLogs, 'retLogs', methodName)
 
-        this.inputParams.push({key: methodName, params: [size, {target, lag, retLogs}]})
+        this._registerIndicator({key: methodName, params: [size, {target, lag, retLogs}]})
 
         return this
     }
@@ -472,7 +506,7 @@ export default class OHLCV_INDICATORS {
       
         validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
       
-        this.inputParams.push({ key: methodName, order: 0, params: [size, offset, {lag}] });
+        this._registerIndicator({ key: methodName, order: 0, params: [size, offset, {lag}] });
       
         return this;
     }
@@ -492,11 +526,12 @@ export default class OHLCV_INDICATORS {
         validateNumber(slowsize, {min: fastsize, max: this.len, allowDecimals: false}, 'slowsize', 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, 'retLogs', methodName)
 
-        this.inputParams.push({key: methodName, order: 0, params: [fastsize, slowsize, {lag}]})
+        this._registerIndicator({key: methodName, order: 0, params: [fastsize, slowsize, {lag, retLogs}]})
         return this           
     }
     dateTime(options = {})
@@ -530,12 +565,12 @@ export default class OHLCV_INDICATORS {
             colKeys: Object.keys(colKeySizes)
         }
 
-        this.inputParams.push({key: methodName, order: 0, params: [{lag, oneHot, precompute}]})
+        this._registerIndicator({key: methodName, order: 0, params: [{lag, oneHot, precompute}]})
         return this           
     }
 
-    priceFeatures(options = {}) {
-        let methodName = 'priceFeatures'
+    candleFeatures(options = {}) {
+        let methodName = 'candleFeatures'
 
         isAlreadyComputed(this)
 
@@ -548,76 +583,8 @@ export default class OHLCV_INDICATORS {
         validateBoolean(retLogs, 'retLogs', methodName)
 
 
-        this.inputParams.push({key: methodName, params: [{lag, colKeys, retLogs}]})
-
-        return this
-    }
-
-    scaler(type = 'zscore', size, options = {})
-    {
-        let methodName = 'scaler'
-
-        isAlreadyComputed(this)
-
-        validateArrayOptions(['minmax', 'zscore', 'byfeature'], type, 'options.type', methodName)
-        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
-
-        const longName = `${methodName}(${type}, ${size}, options = {})`
-        
-        validateObject(options, 'options', longName)
-
-        const {minMaxRange = null, lag = false,  colKeys = [], weights = {}, euclideanWeights = false, byFeatureRange = null, offset = 0} = options
-
-         validateNumber(offset, {min: 0, max: this.len, allowDecimals: false}, 'offset', methodName)
-
-
-        validateArray(colKeys, 'options.colKeys', longName)
-        validateBoolean(lag, 'options.lag', longName)
-        
-        
-        validateObject(weights, 'options.weights', longName)
-
-        const lookback = lag ? size - 1 : 0
-
-        if(colKeys.length === 0) {
-            throw new Error(`The property "options.colKeys" must be an array with target keys in ${longName}.`)
-        }
-
-
-
-        for(const [key, arr] of Object.entries(weights)) {
-            validateArray(arr, `options.weights.${key}`)
-
-            if(!lag && arr.size > 0) {
-                throw new Error(`If "options.lag" is set to false "options.weights.${key}" can only contain 1 item (float) in ${longName}.`)
-            }
-
-            if(arr.length > size) {
-                throw new Error(`The length of the property "options.weights.${key}" can not be longer than "size" in ${longName}.`)
-            }
-
-            for(let x = 0; x < arr.length; x++) {
-                const val = arr[x]
-                validateNumber(val, {min: 0.01, max: 10, allowDecimals: true}, `options.weights.${key}[${x}]`, longName)
-            }
-
-        }
-
-        if (type !== 'byfeature') {
-
-            if(!byFeatureRange == null) {
-                throw new Error('"options.byFeatureRange" is only valid when "type" is "byfeature".')
-            }
-        }
-        else {
-            validateArrayOfRanges(byFeatureRange, 'options.byFeatureRange', longName)
-        }
-        
-        if(['minmax', 'byfeature'].includes(type)) {
-            validateArrayOfRanges(minMaxRange, 'options.minMaxRange', longName)
-        }
+        this._registerIndicator({key: methodName, params: [{lag, colKeys, retLogs}]})
 
-        this.inputParams.push({key: methodName, params: [size, colKeys, {type, minMaxRange, lookback, weights, euclideanWeights, byFeatureRange, offset}]})
         return this
     }
 
@@ -629,12 +596,14 @@ export default class OHLCV_INDICATORS {
 
         if(typeof callback === 'undefined' || callback === null)
         {
-            callback = defaultMapColsCallback
+            callback = 'default'
         }
 
         validateObject(options, 'options', methodName)
 
-        const {lag = 0, isPriceBased = false} = options
+        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)
@@ -644,8 +613,8 @@ export default class OHLCV_INDICATORS {
             throw new Error(`Invalid param: If "mapCols.options.isPriceBased" is true, the "constructor.precision" param must be also true.`)
         }
 
-        this.inputParams.push({key: methodName, params: [newCols, callback, {lag, isPriceBased}]})
+        this._registerIndicator({key: methodName, params: [newCols, callback, {lag, isPriceBased, callbackParams: savedCallbackParams}]})
 
         return this
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.77",
+  "version": "3.5.79",
   "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/core-functions/initializeColumns.js

@@ -0,0 +1,40 @@
+import { buildArray } from '../utilities/assignTypes.js';
+import { validateNumber } from '../utilities/validators.js';
+
+// Called once by each indicator, inside its index === 0 block.
+export const initializeColumns = (main, columns, { lag = 0 } = {}) => {
+  const keyNames = [];
+  const lagKeys = [];
+
+  for (const {
+    key,
+    type = 'Float64Array',
+    fill,
+    enabled = true,
+    priceBased = false,
+    includeInLag = true
+  } of columns) {
+    if (!enabled) continue;
+
+    if (Object.prototype.hasOwnProperty.call(main.verticalOhlcv, key)) {
+      throw new Error(`Output column "${key}" already exists in verticalOhlcv.`);
+    }
+
+    // Integer arrays cannot represent the default missing value, NaN.
+    if (/^(?:Int|Uint)/.test(type) && fill === undefined) {
+      throw new Error(`Integer output column "${key}" requires an explicit fill value.`);
+    }
+
+    main.verticalOhlcv[key] = buildArray(type, main.len, fill);
+    if (priceBased) main.priceBased.add(key);
+    keyNames.push(key);
+    if (includeInLag) lagKeys.push(key);
+  }
+
+  if (lag > 0 && lagKeys.length > 0) {
+    validateNumber(lag, { min: 1, max: main.len }, 'lag', 'initializeColumns');
+    main.executionParams.push({ key: 'lag', params: [lagKeys, lag] });
+  }
+
+  return keyNames;
+};

package/src/core-functions/mainLoop.js

@@ -4,7 +4,6 @@ import { rsi } from "../oscillators/rsi.js";
 import { stochastic } from "../oscillators/stochastic.js";
 import { movingAverages } from "../moving-averages/movingAverages.js";
 import { heikenAshi } from "../moving-averages/heikenAshi.js";
-import { vidya } from "../moving-averages/vidya.js";
 import { macd } from "../moving-averages/macd.js";
 import { relativeVolume } from "../moving-averages/relativeVolume.js";
 import { donchianChannels } from "../moving-averages/donchianChannel.js";
@@ -14,7 +13,6 @@ import { volumeDelta } from "../oscillators/volumeDelta.js";
 import { lag } from "../studies/lag.js";
 import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
-import { scaler } from "../machine-learning/scaler.js";
 import { atr } from "../volatility/atr.js";
 import { adx } from "../volatility/adx.js";
 import { mapCols } from "../studies/mapCols.js";
@@ -22,12 +20,12 @@ 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 { priceFeatures } from "../studies/priceFeatures.js";
+import { candleFeatures } from "../studies/candleFeatures.js";
 
 
 // Map indicator keys to their respective functions
 const mainFunctions = {
-  priceFeatures,
+  candleFeatures,
   dateTime,
   heikenAshi,
   rsi,
@@ -36,7 +34,6 @@ const mainFunctions = {
   adx,
   ema: movingAverages,
   sma: movingAverages,
-  vidya,
   macd,
   volumeDelta,
   relativeVolume,
@@ -44,7 +41,6 @@ const mainFunctions = {
   bollingerBands,
   volumeOscillator,
   mapCols,
-  scaler,
   crossPairs,
   lag
 };
@@ -58,17 +54,33 @@ export const mainLoop = (input, main) => {
     inputTypes, 
     chunkProcess, 
     precisionMultiplier,
-    inputParams
+    executionParams
   } = main;
 
 
-  validateInputParams(inputParams, len)
+  validateInputParams(executionParams, len)
+  for (const { key } of executionParams) {
+    if (!Object.prototype.hasOwnProperty.call(mainFunctions, key)) {
+      throw new Error(`Unknown indicator "${key}" in configuration.`)
+    }
+  }
 
   for(const key of Object.keys(inputTypes))
   {
     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 }
+      })
+
   // Process each row in the input
   for (let chunkStart = 0; chunkStart < len; chunkStart += chunkProcess) {
 
@@ -77,25 +89,36 @@ export const mainLoop = (input, main) => {
       for (let index = chunkStart; index < chunkEnd; index++) {
         const curr = input[index]
       
-        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)})
+        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
+        } else {
+          for(const [key, formaterKey] of Object.entries(inputTypes))
           {
-            main.pushToMain({index, key, value})
+            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})
+            }
           }
         }
 
@@ -104,7 +127,7 @@ export const mainLoop = (input, main) => {
         main.pushToMain({index, key: 'mid_price', value: midPrice})
     
         // Process these indicators separately (ensuring their execution in the order of initialization)
-        for (const { key, params} of inputParams)
+        for (const { key, params} of executionParams)
         {
           mainFunctions[key](main, index, ...params)
         }

package/src/core-functions/pushToMain.js

@@ -2,9 +2,7 @@ export const pushToMain = ({main, index, key, value}) => {
 
     const {verticalOhlcv} = main
 
-    verticalOhlcv[key][index] = value    
-
-    return true
+    verticalOhlcv[key][index] = value
 }
 
 export const areKeyValuesValid = (main, index, keyNames) => {