ohlcv-indicators 3.3.4 → 3.3.6

package/index.js

@@ -1,12 +1,19 @@
 import { mainLoop } from './src/core-functions/mainLoop.js'
 import { correlation } from './src/studies/correlation.js'
-import { isAlreadyComputed, validateArray, validateObject, validateArrayOptions, validateBoolean, validateNumber } from './src/utilities/validators.js'
-import { divideByMultiplier } from './src/utilities/numberUtilities.js'
+import { 
+    isAlreadyComputed, 
+    validateArray, 
+    validateObject, 
+    validateArrayOptions, 
+    validateBoolean, 
+    validateNumber, 
+    validateArrayOfRanges
+} 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 { calcPrecisionMultiplier } from './src/utilities/precisionMultiplier.js'
-import { selectDateFormatter, dateFormaters } from './src/utilities/dateUtilities.js'
+import { buildArray } from './src/utilities/assignTypes.js'
 
 /**
  * Class OHLCV_INDICATORS
@@ -27,40 +34,35 @@ export default class OHLCV_INDICATORS {
 
         this.firstRow = input[0]
         
-        this.inputCols = Object.keys(this.firstRow)
-
         const {inputTypes, arrayTypes} = assignTypes(this.firstRow)
-        
+
         this.inputTypes = inputTypes
         this.arrayTypes = arrayTypes
-
-
         if(!this.firstRow.hasOwnProperty('close')) throw Error(`input OHLCV array objects require at least "close" property: ${ticker}`)
 
         this.dateType = this.inputTypes.date ? this.inputTypes.date : null;
         this.isComputed = false
         this.input = input
-        this.priceBased = ['open', 'high', 'low', 'close']
+        this.priceBased = new Set(['open', 'high', 'low', 'close'])
         this.len = input.length
         this.instances = {}
         this.crossPairsList = []
         this.verticalOhlcv = {}
+        this.verticalOhlcvKeyNames = []
+        this.verticalOhlcvTempCols = new Set()
 
-        this.studies = {}
         this.utilities = {
             correlation
         }
 
         this.invalidValueIndex = -1
-
         this.precision = precision
         this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
         this.ScaledGroups = {}
         
-        
         if(inputParams !== null)
         {
-            validateArray(inputParams, 'inputParams', 'constructor')
+            validateInputParams(inputParams, this.len)
             this.inputParams = inputParams
             this.compute()
         }
@@ -70,7 +72,6 @@ export default class OHLCV_INDICATORS {
 
         this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
         
-
         return this 
     }
 
@@ -84,21 +85,28 @@ export default class OHLCV_INDICATORS {
           invalidValueIndex,
           len,
           verticalOhlcv,
-          priceBased
-        } = this;
-        const result = {};
-        const shouldSlice = invalidValueIndex >= 0 && skipNull;
-        const sliceLength = len - (invalidValueIndex + 1);
+          priceBased,
+          arrayTypes,
+          verticalOhlcvTempCols
+        } = this
+        const result = {}
+        const startIndex = skipNull ? invalidValueIndex + 1 : 0
+        const newLen = len - startIndex
       
         for (const [key, arr] of Object.entries(verticalOhlcv)) {
-          // If slicing is needed, create a sliced copy, otherwise re-use the array.
-          let newArr = shouldSlice ? arr.slice(-sliceLength) : arr;
-      
-          // If this key is price based and precision is enabled, map over the array.
-          if (precision && priceBased.includes(key)) {
-            newArr = newArr.map(v => (v == null ? null : v / precisionMultiplier));
-          }
-          result[key] = newArr;
+
+            if(verticalOhlcvTempCols.has(key)) continue
+
+            const shouldApplyPrecision = priceBased.has(key) && precision
+            result[key] = buildArray(arrayTypes[key], newLen)
+
+            for (let x = startIndex; x < len; x++)
+            {
+                result[key][x] =  (shouldApplyPrecision) 
+                    ? arr[x] / precisionMultiplier 
+                    : arr[x]
+            }
+
         }
       
         return result;
@@ -110,9 +118,7 @@ export default class OHLCV_INDICATORS {
         //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 {precisionMultiplier, priceBased, precision, verticalOhlcv, invalidValueIndex} = this
-
-        return verticalToHorizontal(verticalOhlcv, skipNull, precision, precisionMultiplier, priceBased, invalidValueIndex)
+        return verticalToHorizontal(skipNull, this, 0)
     }
     
     
@@ -120,16 +126,7 @@ export default class OHLCV_INDICATORS {
 
         this.compute()
 
-        const {precisionMultiplier, priceBased, precision, verticalOhlcv, len} = this
-        const keyNames = Object.keys(verticalOhlcv)
-        const row = {}
-
-        for(const key of keyNames)
-        {
-            row[key] = verticalOhlcv[key][len - 1]
-        }
-     
-        return (precision) ? divideByMultiplier({row, precisionMultiplier, priceBased}) : row
+        return verticalToHorizontal(false, this, this.len - 1)[0]
     }
 
     compute() {
@@ -150,6 +147,11 @@ export default class OHLCV_INDICATORS {
         if (this.len > 0) {
           mainLoop(this.input, this);
           this.isComputed = true;
+
+          //flushing after mainLoop
+          this.input = []
+          this.instances = {}
+          this.firstRow = []
         }
       
         return this;
@@ -184,13 +186,11 @@ export default class OHLCV_INDICATORS {
 
         this.inputParams.push({key: methodName, params: [colKeys, lookback]})
 
-        for(let x = 0; x < colKeys.length; x++)
+        for(const key of colKeys)
         {
-            const key = colKeys[x]
-
-            if(this.priceBased.find(v => key === v))
+            if(this.priceBased.has(key))
             {
-                this.priceBased.push(key)
+                this.priceBased.add(key);
             }
         }
         
@@ -201,7 +201,7 @@ export default class OHLCV_INDICATORS {
 
         const methodName = 'relativeVolume'
 
-        if(!this.inputCols.includes('volume')) {
+        if(!this.inputTypes.hasOwnProperty('volume')) {
             throw new Error('If "relativeVolume" is called the input ohlcv must contain valid volume properties.')
         }
 
@@ -212,7 +212,7 @@ export default class OHLCV_INDICATORS {
 
         const { lag = 0} = options;
 
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [size, {lag}]})
  
@@ -230,7 +230,7 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', lag = 0} = options
 
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
 
@@ -247,7 +247,7 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', lag = 0} = options
 
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
 
@@ -268,7 +268,7 @@ export default class OHLCV_INDICATORS {
 
         const {target = 'close', lag = 0} = options
         
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag}]})
         
@@ -288,9 +288,9 @@ export default class OHLCV_INDICATORS {
         const {target = 'close', height = false, range = [],  lag = 0} = options
 
 
-        validateArray(range, 'range', methodName)
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
-        validateBoolean(height, 'height', methodName)
+        validateArray(range, 'options.range', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(height, 'options.height', methodName)
     
         this.inputParams.push({key: methodName, params: [size, stdDev, {target, height, range, lag}]});
     
@@ -308,7 +308,7 @@ export default class OHLCV_INDICATORS {
         
         const {target = 'close', lag = 0} = options
 
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [size, {target, lag}]})
 
@@ -327,9 +327,9 @@ export default class OHLCV_INDICATORS {
         validateObject(options, 'options', methodName)
         const { height = false, range = [], lag = 0} = options;
       
-        validateArray(range, 'range', methodName)
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
-        validateBoolean(height, 'height', methodName)
+        validateArray(range, 'options.range', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
+        validateBoolean(height, 'options.height', methodName)
       
         this.inputParams.push({ key: methodName, params: [size, offset, { height, range, lag }] });
       
@@ -341,7 +341,7 @@ export default class OHLCV_INDICATORS {
     {
         const methodName = 'volumeOscillator'
 
-        if(!this.inputCols.includes('volume')) {
+        if(!this.inputTypes.hasOwnProperty('volume')) {
             throw new Error('If "volumeOscillator" is called the input ohlcv must contain valid volume properties.')
         }
 
@@ -353,7 +353,7 @@ export default class OHLCV_INDICATORS {
 
         const {lag = 0} = options
 
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [fastSize, slowSize, {lag}]})
         return this           
@@ -369,7 +369,7 @@ export default class OHLCV_INDICATORS {
 
         const {lag = 0} = options
 
-        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'options.lag', methodName)
 
         this.inputParams.push({key: methodName, params: [{lag}]})
         return this           
@@ -386,9 +386,9 @@ export default class OHLCV_INDICATORS {
 
         const {group = false, range = [0, 1], lag = 0, type = 'minmax'} = options
 
-        validateBoolean(group, 'group', methodName)
-        validateArray(range, 'range', methodName)
-        validateArrayOptions(['minmax', 'zscore'], type, 'type', methodName)
+        validateBoolean(group, 'options.group', methodName)
+        validateArrayOfRanges(range, 'options.range', methodName)
+        validateArrayOptions(['minmax', 'zscore'], type, 'options.type', methodName)
 
         this.inputParams.push({key: methodName, params: [size, colKeys, type, group, range, lag]})
         return this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.3.4",
+  "version": "3.3.6",
   "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/mainLoop.js

@@ -29,41 +29,22 @@ const indicatorFunctions = {
   Scaler
 };
 
-// Processes the inputParams into a list of indicator calls
-const processIndicatorCalls = inputParams =>
-  Array.isArray(inputParams)
-    ? inputParams.map(({ key, params }) => ({
-        key,
-        fn: indicatorFunctions[key],
-        args: params
-      }))
-    : [];
 
 export const mainLoop = (input, main) => {
-  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes } = main;
+  const { len, inputParams, priceBased, precisionMultiplier, arrayTypes, verticalOhlcv, verticalOhlcvKeyNames, inputTypes } = main;
 
-  validateInputParams(main)
+  validateInputParams(inputParams, len)
 
-  for(const key of Object.keys(main.inputTypes))
+  for(const key of Object.keys(inputTypes))
   {
-    main.verticalOhlcv[key] = buildArray(arrayTypes[key], len)
+    verticalOhlcv[key] = buildArray(arrayTypes[key], len)
   }
 
-  // Prepare the list of indicator function calls
-  const indicatorCalls = processIndicatorCalls(inputParams);
-
   // Process each row in the input
-  for (let x = 0; x < len; x++) {
-    const curr = input[x]
-
-    processThisRow({x, main, curr, indicatorCalls, priceBased, precisionMultiplier})
-  }
-}
-
-const processThisRow = ({x, main, curr, indicatorCalls, priceBased, precisionMultiplier}) => {
-
-
-  for(const [key, formaterKey] of Object.entries(main.inputTypes))
+  for (let index = 0; index < len; index++) {
+    const curr = input[index]
+    
+    for(const [key, formaterKey] of Object.entries(inputTypes))
     {
       const value = curr[key]
 
@@ -71,30 +52,34 @@ const processThisRow = ({x, main, curr, indicatorCalls, priceBased, precisionMul
       {
         let formatedValue = numberFormater[formaterKey](value)
 
-        if(precisionMultiplier > 1 && priceBased.includes(key))
+        if(precisionMultiplier > 1 && priceBased.has(key))
         {
           formatedValue = formatedValue * precisionMultiplier
         }
 
-        main.pushToMain({index: x, key, value: formatedValue})
+        main.pushToMain({index, key, value: formatedValue})
       }
       else if(dateFormaters.hasOwnProperty(formaterKey))
       {
-        main.pushToMain({index: x, key, value: dateFormaters[formaterKey](value)})
+        main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
       }
       else
       {
-        main.pushToMain({index: x, key, value})
+        main.pushToMain({index, key, value})
       }
     }
+  
+      // Run all indicator functions except for the ones processed later
+      for (const { key, params } of inputParams) {
+        if (key === 'lag' || key === 'crossPairs') continue;
+        // resolve fn on-demand, no per-item object allocation here
+        indicatorFunctions[key](main, index, ...params)
+      }
+  
+      // Process these indicators separately (ensuring their execution order)
+      lag(main, index)
+      crossPairs(main, index)
+  }
 
-    // Run all indicator functions except for the ones processed later
-    for (const { key, fn, args } of indicatorCalls) {
-      if (['crossPairs', 'lag'].includes(key)) continue;
-      fn(main, x, ...args)
-    }
-
-    // Process these indicators separately (ensuring their execution order)
-    lag(main, x)
-    crossPairs(main, x)
-}
+  verticalOhlcvKeyNames.push(...Object.keys(verticalOhlcv))
+}

package/src/moving-averages/bollingerBands.js

@@ -17,7 +17,12 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
       throw new Error(`bollingerBands could not find target "${target}"`);
     }
 
-    const numberOfIndicators = inputParams.filter(o => o.key === 'bollingerBands').length;
+    let numberOfIndicators = 0
+
+    for (const o of inputParams) {
+      if (o.key === 'bollingerBands') numberOfIndicators++;
+    }
+
     prefix = numberOfIndicators > 1
       ? `bollinger_bands_${indicatorKey}`
       : `bollinger_bands${suffix}`;
@@ -45,7 +50,7 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
         throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
       }
       keyNames.push(`${prefix}_range_${rangeKey}`)
@@ -60,7 +65,9 @@ export const bollingerBands = (main, index, size, stdDev, { height, range = [],
       main.lag(keyNames, lag)
     }
 
-    priceBased.push(`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`);
+    [`${prefix}_upper`, `${prefix}_middle`, `${prefix}_lower`].forEach(v => {
+      priceBased.add(v)
+    })
 
     for(const key of keyNames)
     {

package/src/moving-averages/donchianChannel.js

@@ -6,7 +6,12 @@ export const donchianChannels = (main, index, size, offset, { height, range, lag
   // Initialization: create output arrays and indicator instance on the first call.
   if (index === 0) {
     const { inputParams, priceBased, arrayTypes} = main;
-    const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length;
+    let numberOfIndicators = 0
+
+    for (const o of inputParams) {
+      if (o.key === 'donchianChannels') numberOfIndicators++;
+    }
+
     const prefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
 
     const keyNames = [
@@ -27,7 +32,7 @@ export const donchianChannels = (main, index, size, offset, { height, range, lag
 
     // Set up additional arrays for each range property.
     for (const rangeKey of range) {
-      if (!(rangeKey in verticalOhlcv) || !priceBased.includes(rangeKey)) {
+      if (!(rangeKey in verticalOhlcv) || !priceBased.has(rangeKey)) {
         throw new Error(`Invalid range item value "${rangeKey}" property for donchianChannels. Only price based key names are accepted:\n${JSON.stringify(priceBased)}`);
       }
       keyNames.push(`${prefix}_range_${rangeKey}`)
@@ -42,7 +47,10 @@ export const donchianChannels = (main, index, size, offset, { height, range, lag
       main.lag(keyNames, lag)
     }
 
-    priceBased.push(`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`);
+
+    [`${prefix}_upper`, `${prefix}_basis`, `${prefix}_lower`].forEach(v => {
+      priceBased.add(v)
+    })
 
     instances.donchian_channel.settings[indicatorKey] = {
       maxDeque: [], // will hold indices for highs in descending order

package/src/moving-averages/macd.js

@@ -17,7 +17,12 @@ export const macd = (main, index, fast, slow, signal, {target, lag}) => {
       throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`);
     }
 
-    const numberOfIndicators = inputParams.filter(o => o.key === 'macd').length;
+    let numberOfIndicators = 0
+
+    for (const o of inputParams) {
+      if (o.key === 'macd') numberOfIndicators++;
+    }
+
     // Choose a display prefix based on the number of indicators.
     const displayPrefix = numberOfIndicators > 1 ? `macd_${fast}_${slow}_${signal}` : 'macd';
 
@@ -47,7 +52,9 @@ export const macd = (main, index, fast, slow, signal, {target, lag}) => {
       [histogramKey]: new Float64Array(len).fill(NaN),
     });
 
-    priceBased.push(diffKey, deaKey, histogramKey)
+    [diffKey, deaKey, histogramKey].forEach(v => {
+      priceBased.add(v)
+    })
 
     const keyNames = [diffKey, deaKey, histogramKey]
 

package/src/moving-averages/movingAverages.js

@@ -28,7 +28,8 @@ export const movingAverages = (main, index, indicatorName, size, { target, lag }
     };
 
     verticalOhlcv[keyName] = new Float64Array(len).fill(NaN)
-    priceBased.push(keyName);
+
+    priceBased.add(keyName);
 
     if(lag > 0)
     {

package/src/studies/findCrosses.js

@@ -132,19 +132,25 @@ class CrossInstance {
 
 export const crossPairs = (main, index) => {
 
-    const {verticalOhlcv, instances, len, arrayTypes} = main
+    const {verticalOhlcv, instances, len, arrayTypes, verticalOhlcvTempCols} = main
 
     if(index === 0)
     {
         const {inputParams} = main
-        const findParams = inputParams.filter(o => o.key === 'crossPairs')
 
-        if(typeof findParams !== 'object') return
-
-        instances.crossPairs = {crossPairsList: findParams.flatMap(o => o.params.flat())}
+        instances.crossPairsList = inputParams.reduce((acc, { key, params }) => {
+            if (key === 'crossPairs') {
+              for (const group of params) {
+                for (const pair of group) {
+                  acc.push(pair)
+                }
+              }
+            }
+            return acc;
+          }, [])
     }
 
-    const {crossPairsList} = instances.crossPairs
+    const {crossPairsList} = instances
 
     for (const { fast, slow } of crossPairsList)
     {
@@ -156,7 +162,8 @@ export const crossPairs = (main, index) => {
         {
             if(typeof slow === 'number')
             {
-                verticalOhlcv[slow] = new Int32Array(len).fill(slow)
+                verticalOhlcvTempCols.add(slow.toString())
+                verticalOhlcv[slow.toString()] = new Int32Array(len).fill(slow)
             }
             
             if(fast !== 'price' && !verticalOhlcv.hasOwnProperty(fast)) throw Error(`fast "${fast} not found in crossPairs"`)

package/src/studies/lag.js

@@ -7,20 +7,23 @@ export const lag = (main, index) => {
     if(index === 0)
     {
         const {inputParams} = main
-        const findParams = inputParams.filter(o => o.key === 'lag')
 
-        if(typeof findParams !== 'object') return
+        const params = []
 
-        const params = findParams.map(o => o.params)
+        for (const o of inputParams) {
+            if (o.key === 'lag') {
+                params.push(o.params)
+            }
+        }
 
         for (const [colKeys, lookback] of params)
         {
             for (const colKey of colKeys)
             {
-                if(priceBased.includes(colKey))
+                if(priceBased.has(colKey))
                 {
                     for (let step = 1; step <= lookback; step++) {
-                        priceBased.push(`${colKey}_lag_${step}`)
+                        priceBased.add(`${colKey}_lag_${step}`)
                     }
                 }
             }

package/src/studies/scaler.js

@@ -37,7 +37,7 @@ export const Scaler = (
         if (!verticalOhlcv.hasOwnProperty(target)) {
           throw new Error(`Target property "${target}" not found in verticalOhlcv`);
         }
-        if (!priceBased.includes(target)) {
+        if (!priceBased.has(target)) {
           throw new Error(`Column "${target}" is not priceBased and cannot be scaled.`);
         }
   

package/src/utilities/assignTypes.js

@@ -1,7 +1,7 @@
 import { classifyNum } from "./numberUtilities.js";
 import { selectDateFormatter } from "./dateUtilities.js";
 
-const numberKeys = ['open', 'high', 'low', 'close']
+const numberKeys = new Set(['open', 'high', 'low', 'close'])
 
 export const buildArray = (arrayType, len) => {
   if(arrayType === 'Array') return new Array(len).fill(null)
@@ -24,7 +24,7 @@ export const assignTypes = firstRow => {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Int32Array'
     }
-    else if(numberKeys.includes(colName))
+    else if(numberKeys.has(colName))
     {
       inputTypes[colName] = classifyNum(cellValue, true)
       arrayTypes[colName] = 'Float64Array'

package/src/utilities/numberUtilities.js

@@ -15,7 +15,7 @@ export const divideByMultiplier = ({row, precisionMultiplier, priceBased}) => {
 
         let newValue = value
 
-        if(priceBased.includes(key))
+        if(priceBased.has(key))
         {
             newValue = newValue / precisionMultiplier
         }

package/src/utilities/precisionMultiplier.js

@@ -4,7 +4,7 @@ export const calcPrecisionMultiplier = (main, firstRow) => {
     if(precision === false) return 1
 
     let output = 1
-    const priceBasedValues = Object.entries(firstRow).filter(([k, _]) => priceBased.includes(k)).map(([_, v]) => v)
+    const priceBasedValues = Object.entries(firstRow).filter(([k, _]) => priceBased.has(k)).map(([_, v]) => v)
 
 
     for(const value of priceBasedValues)

package/src/utilities/validators.js

@@ -1,6 +1,9 @@
-export const validateInputParams = main => {
+export const validateInputParams = (inputParams, len) => {
 
-    const {inputParams, len} = main
+    if(!Array.isArray(inputParams))
+    {
+        throw new Error('Property "inputParams" must be an "Array" or "Set".')
+    }
 
     for (const { params } of inputParams) {
         for (const v of params) {
@@ -89,3 +92,25 @@ export const validateNumber = (value, options, paramName, callerName) => {
     return true
 }
 
+export const validateArrayOfRanges = (range, paramName, callerName) => {
+
+    validateArray(range, paramName, callerName)
+
+    if (range.length !== 2) {
+        throw new Error(
+          `Invalid "${paramName}" array length: expected 2 items, but got ${range.length} in "${callerName}.${paramName}".`
+        );
+    }
+
+    const [min, max] = range
+
+    validateNumber(min, {min: -100, max, allowDecimals: false}, 'min', callerName)
+    validateNumber(max, {min: min, max: 100, allowDecimals: false}, 'max', callerName)
+
+    if(min === max)
+    {
+        throw new Error(`Invalid "min" can not be equal to "max" property in "${callerName}.${paramName}".`)
+    }
+
+    return true
+}