ohlcv-indicators 3.3.2 → 3.3.5

package/index.js

@@ -1,11 +1,10 @@
-import { parseOhlcvToVertical } from './src/utilities/parsing-utilities.js'
+import { mainLoop } from './src/core-functions/mainLoop.js'
 import { correlation } from './src/studies/correlation.js'
-import { validateDate } from './src/utilities/validators.js'
-import { isAlreadyComputed } from './src/utilities/validators.js'
-import { divideByMultiplier } from './src/utilities/numberUtilities.js'
-import { getMovingAveragesParams } from './src/moving-averages/movingAverages.js'
-import { verticalToHorizontal } from './src/utilities/dataParsingUtilities.js'
-import { pushToMain } from './src/utilities/pushToMain.js'
+import { isAlreadyComputed, validateArray, validateObject, validateArrayOptions, validateBoolean, validateNumber } 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'
 
 /**
  * Class OHLCV_INDICATORS
@@ -16,43 +15,44 @@ import { pushToMain } from './src/utilities/pushToMain.js'
  * OHLCV datasets.
  */
 
-const validMagnitudeValues = [0.001, 0.002, 0.0025, 0.005, 0.01, 0.02, 0.025, 0.05, 0.1, 0.20, 0.25, 0.5, 1, 2, 2.5, 5, 10]
-
 export default class OHLCV_INDICATORS {
     constructor({input, ticker = null, precision = true, inputParams = null}) {
 
-        if(!Array.isArray(input)) throw Error('input OHLCV must be an array: ' + ticker)
+        validateArray(input, 'input', (ticker !== null) ? `contructor ${ticker}` : 'constuctor')
         if(input.length === 0) throw Error('input OHLCV must not be empty: ' + ticker)
-        if(!input[0].hasOwnProperty('close')) throw Error('input OHLCV array objects require at least close property: ' + ticker)
-        this.hasVolume = ((typeof input[0].volume === 'number' && input[0].volume > 0) || (typeof input[0].volume === 'string' && input[0].volume)) ? true : false
 
+        validateBoolean(precision, 'precision', 'constructor')
+
+        this.firstRow = input[0]
+        
+        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.lastComputedIndex = 0
         this.input = input
-        this.inputTypes = (this.hasVolume) ? {open: '', high: '', low: '', close: '', volume: ''} : {open: '', high: '', low: '', close: ''}
-        this.priceBased = ['open', 'high', 'low', 'close']
+        this.priceBased = new Set(['open', 'high', 'low', 'close'])
         this.len = input.length
-        this.lastIndexReplace = false 
         this.instances = {}
         this.crossPairsList = []
         this.verticalOhlcv = {}
+        this.verticalOhlcvKeyNames = []
 
-        this.studies = {}
         this.utilities = {
             correlation
         }
 
         this.invalidValueIndex = -1
-
         this.precision = precision
-        this.precisionMultiplier = (this.precision === true) ? 0 : 1
-
-        this.autoMinMaxKeys = []
-        this.minMaxRanges = {}   
-        
+        this.precisionMultiplier = calcPrecisionMultiplier(this, this.firstRow)
+        this.ScaledGroups = {}
         
-        if(Array.isArray(inputParams))
+        if(inputParams !== null)
         {
+            validateArray(inputParams, 'inputParams', 'constructor')
             this.inputParams = inputParams
             this.compute()
         }
@@ -62,7 +62,6 @@ export default class OHLCV_INDICATORS {
 
         this.pushToMain = ({index, key, value}) => pushToMain({main: this, index, key, value})
         
-
         return this 
     }
 
@@ -82,13 +81,12 @@ export default class OHLCV_INDICATORS {
         const shouldSlice = invalidValueIndex >= 0 && skipNull;
         const sliceLength = len - (invalidValueIndex + 1);
       
-
         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)) {
+          if (precision && priceBased.has(key)) {
             newArr = newArr.map(v => (v == null ? null : v / precisionMultiplier));
           }
           result[key] = newArr;
@@ -103,9 +101,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)
     }
     
     
@@ -113,165 +109,130 @@ 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(change) {
-
-        //if change is a valid object and change.date is after the last row in this.input[this.input.length - 1].date pushes change to this.input using the parseOhlcvToVertical function.
+    compute() {
 
-
-        //stops the compute if compute is called from getData, getDataAsCols or getLastValues an isComputed is false
-        if(this.isComputed === true && !change)
-        {
-            return this
+        // If we've already computed, bail out immediately
+        if (this.isComputed) {
+          return this;
         }
-        else{
-            this.isComputed = false
-        }
-
-        //checks the first row in OHLCV input to verify if the date property is valid
-        this.isValidDate = this.input[0].hasOwnProperty('date') && validateDate(this.input[0].date)
-
-         //compute method can be used to process indicators if no arguments are provided
-         //compute method can be called to access the .verticalOhlcv object
-         //compute method is called automatically if getLastValues or getDate methods are called
-        if (this.len > this.lastComputedIndex && !change) {
-            parseOhlcvToVertical(this.input, this, 0);
-        }        
-
-        //compute method can be used to add new or update the last datapoints if a new OHLCV object is passed with a valid date property
-        //valid date properties: "2024-12-16 15:45:00" or "2024-12-16"
-        if (change && typeof change === 'object') {
-
-            if (!['open', 'high', 'low', 'close', 'volume', 'date'].every(f => Object.keys(change).includes(f))) {
-                throw Error('Invalid OHLCV object sent in "compute". Correct usage: .compute({open: 108.25, high: 108.410004, low: 108.25, close: 99999999, volume: 875903, date: "2024-12-16 15:45:00" || "2024-12-16"})');
-            }            
-            if(!this.isValidDate)
-            {
-                throw Error('All the OHLCV rows require a valid date property to access the compute change method. Correct date format: "2024-12-16 15:45:00" or "2024-12-16"')
-            }
-            if(!validateDate(change.date))
-            {
-                throw Error('The date in the new OHLCV row is invalid. Correct date format: "2024-12-16 15:45:00" or "2024-12-16"')
-            }
-
-            const { date: changeDate } = change;
-            const lastIndex = this.len - 1;
-            const inputDate = this.input[lastIndex]?.date;
-    
-            //fallback if .compute(change) is triggered before .compute() alone
-            if (this.lastComputedIndex === 0) {
-                this.compute()
-            }
-
-
-            if (inputDate !== changeDate) {
-                // Add new item
-                this.len++
-                this.input.push(change)
-                parseOhlcvToVertical(this.input, this, this.len)
-            } else {
-                // Modify the last item
-                this.input[lastIndex] = change
-                parseOhlcvToVertical(this.input, this, lastIndex)
-            }
+      
+        // Mark as “in progress”
+        this.isComputed = false;
+      
+        // Figure out whether there’s a date field in the inputs
+        
+      
+        // 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.isComputed = true;
 
+          //flushing after mainLoop
+          this.input = []
+          this.instances = {}
+          this.firstRow = []
         }
-    
-
-    
+      
         return this;
-    }
+    }      
     
     
 
-    crossPairs(arr)
+    crossPairs(arr = [])
     {
+
+        const methodName = 'crossPairs'
+
         isAlreadyComputed(this)
 
+        validateArray(arr, 'arr', methodName)
+
         this.crossPairsList = [...this.crossPairsList, ...arr]
-        this.inputParams.push({key: 'crossPairs', params: [this.crossPairsList]})
+        this.inputParams.push({key: methodName, params: [this.crossPairsList]})
         
         return this
     }
 
 
-    lag(colKeys = ['close'], lags = 1) {
+    lag(colKeys = ['close'], lookback = 1) {
 
-        isAlreadyComputed(this)
+        const methodName = 'lag'
 
-        if(!Array.isArray(colKeys))
-        {
-            throw new Error('Param "colKeys" must be a valid array of keyNames in lag.')
-        }
-        if(typeof lags !== 'number' || !Number.isInteger(lags) || lags < 0)
-        {
-            throw new Error(`Param "lags" must be a integer greater or equal to 0: ${JSON.stringify(colKeys)}`)
-        }
+        isAlreadyComputed(this)
 
+        validateArray(colKeys, 'colKeys', methodName)
+        validateNumber(lookback, {min:1, max: this.len, allowDecimals: false}, 'lookback', methodName)
 
-        this.inputParams.push({key: 'lag', params: [colKeys, lags]})
+        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);
             }
         }
         
         return this;
     }
     
-    relativeVolume(size, options = {}) {
+    relativeVolume(size = 10, options = {}) {
 
-        if(this.hasVolume === false) {
+        const methodName = 'relativeVolume'
+
+        if(!this.inputTypes.hasOwnProperty('volume')) {
             throw new Error('If "relativeVolume" is called the input ohlcv must contain valid volume properties.')
         }
 
         isAlreadyComputed(this)
 
-        const {scale = null} = options
+        validateNumber(size, {min:1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateObject(options, 'options', methodName)
 
-        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
+        const { lag = 0} = options;
 
-            throw new Error(`"scale" value in relativeVolume must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
-        }
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
 
-        this.inputParams.push({key: 'relativeVolume', params: [size, {scale}]})
+        this.inputParams.push({key: methodName, params: [size, {lag}]})
  
         return this
     }
 
-    ema(size, options = {}) {
+    ema(size = 5, options = {}) {
+
+        const methodName = 'ema'
 
         isAlreadyComputed(this)
 
-        const optionArgs = getMovingAveragesParams('ema', size, options, validMagnitudeValues)
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateObject(options, 'options', methodName)
+
+        const {target = 'close', lag = 0} = options
 
-        this.inputParams.push({key: 'movingAverages', params: ['ema', size, optionArgs]})
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+
+        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
-    sma(size, options = {}) {
+    sma(size = 5, options = {}) {
+
+        const methodName = 'sma'
 
         isAlreadyComputed(this)
 
-        const optionArgs = getMovingAveragesParams('sma', size, options, validMagnitudeValues)
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateObject(options, 'options', methodName)
 
-        this.inputParams.push({key: 'movingAverages', params: ['sma', size, optionArgs]})
+        const {target = 'close', lag = 0} = options
+
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+
+        this.inputParams.push({key: methodName, params: [methodName, size, {target, lag}]})
 
         return this
     }
@@ -279,223 +240,140 @@ export default class OHLCV_INDICATORS {
     
     macd(fast = 12, slow = 26, signal = 9, options = {}) {
 
-        isAlreadyComputed(this)
+        const methodName = 'macd'
 
-        if (typeof fast !== 'number' || fast <= 0) {
-            throw new Error('"fast" must be a positive number in macd.');
-        }
-        if (typeof slow !== 'number' || slow <= fast) {
-            throw new Error('"slow" must be a positive number greater than "fast" in macd.');
-        }
-        if (typeof signal !== 'number' || signal <= 0) {
-            throw new Error('"signal" must be a positive number in macd.');
-        }
+        isAlreadyComputed(this)
 
-        if(typeof options !== 'object')
-        {
-            throw new Error('"options" must be an object in macd. eg: {target}');
-        }
+        validateNumber(fast, {min: 1, max: this.len, allowDecimals: false}, 'fast', methodName)
+        validateNumber(slow, {min: 1, max: this.len, allowDecimals: false}, 'slow', methodName)
+        validateNumber(signal, {min: 1, max: this.len, allowDecimals: false}, 'signal', methodName)
+        validateObject(options, 'options', methodName)
 
-        const {target = 'close'} = options
+        const {target = 'close', lag = 0} = options
+        
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
 
-        this.inputParams.push({key: 'macd', params: [fast, slow, signal, {target}]})
+        this.inputParams.push({key: methodName, params: [fast, slow, signal, {target, lag}]})
         
         return this
 
     }
     bollingerBands(size = 20, stdDev = 2, options = {}) {
 
-        isAlreadyComputed(this)
-
-        if(!options || typeof options !== 'object')
-        {
-            throw new Error('"options" must be an object in bollingerBands. eg: {target, height, range}');
-        }
+        const methodName = 'bollingerBands'
 
-        const {target = 'close', height = false, range = [],  scale = null, lag = 0, autoMinMax = false} = options
-
-        // Validate size and times
-        if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number in bollingerBands.');
-        }
-        if (typeof stdDev !== 'number' || stdDev <= 0) {
-            throw new Error('"stdDev" must be a positive number in bollingerBands.');
-        }
-        if (!Array.isArray(range)) {
-            throw new Error('If set, "range" must be a array of column names in bollingerBands.');
-        }
-        if (typeof lag !== 'number') {
-
-            throw new Error(`"lag" value must be a number in bollingerBands.`);
-        }
+        isAlreadyComputed(this)
+        
+        validateNumber(size, {min:1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateNumber(stdDev, {min: 0.01, max: 50, allowDecimals: true}, 'stdDev', methodName)
+        validateObject(options, 'options', methodName)
 
-        if (typeof autoMinMax !== 'boolean') {
+        const {target = 'close', height = false, range = [],  lag = 0} = options
 
-            throw new Error(`"autoMinMax" value in rsi must be a number in bollingerBands.`);
-        }
-    
-        if (typeof height !== 'boolean') {
-            throw new Error('"height" must be a boolean in bollingerBands.');
-        }
-        else
-        {
-            if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
 
-                throw new Error(`"scale" value in bollingerBands must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
-            }           
-        }
+        validateArray(range, 'range', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateBoolean(height, 'height', methodName)
     
-        this.inputParams.push({key: 'bollingerBands', params: [size, stdDev, {target, height, scale, range, lag, autoMinMax}]});
+        this.inputParams.push({key: methodName, params: [size, stdDev, {target, height, range, lag}]});
     
         return this;
     }
     
-    rsi(size, options = {})
+    rsi(size = 14, options = {})
     {
-        isAlreadyComputed(this)
+        const methodName = 'rsi'
 
-        // Validate size and times
-        if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number in rsi.');
-        }
-
-        const {scale = null, target = 'close', lag = 0, autoMinMax = false} = options
-
-        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
-
-            throw new Error(`"scale" value in rsi must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
-        }
-
-        if (typeof lag !== 'number') {
-
-            throw new Error(`"lag" value in rsi must be a number in rsi.`);
-        }
+        isAlreadyComputed(this)
 
-        if (typeof autoMinMax !== 'boolean') {
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateObject(options, 'options', methodName)
+        
+        const {target = 'close', lag = 0} = options
 
-            throw new Error(`"autoMinMax" value in rsi must be a number in rsi.`);
-        }
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
 
-        this.inputParams.push({key: 'rsi', params: [size, {scale, target, lag, autoMinMax}]})
+        this.inputParams.push({key: methodName, params: [size, {target, lag}]})
 
         return this
     }
     donchianChannels(size = 20, offset = 0, options = {}) {
-        isAlreadyComputed(this);
-      
-        if (typeof size !== 'number' || size <= 0) {
-          throw new Error('"size" must be a positive number greater than 0 in donchianChannels.');
-        }
-      
-        if (typeof offset !== 'number' || offset < 0) {
-          throw new Error('"offset" must be a number greater than or equal to 0 in donchianChannels.');
-        }
-      
-        const { height = false, range = [], scale = null, lag = 0, autoMinMax = false} = options;
-      
-        if (!Array.isArray(range)) {
-          throw new Error('If set, "range" must be an array of column names in donchianChannels.');
-        }
 
-        if (typeof lag !== 'number') {
-            throw new Error(`"lag" value in rsi must be a number in donchianChannels.`);
-        }
-
-        if (typeof autoMinMax !== 'boolean') {
+        const methodName = 'donchianChannels'
 
-            throw new Error(`"autoMinMax" value in rsi must be a number in donchianChannels.`);
-        }
-      
-        if (typeof height !== 'boolean') {
-          throw new Error('"height" must be a boolean in donchianChannels.');
-        }
-        else
-        {
-
-            if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
+        isAlreadyComputed(this)
 
-                throw new Error(`"scale" value in donchianChannels must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
-            }        
-        }
+        
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateNumber(offset, {min: 0, max: this.len, allowDecimals: false}, 'offset', methodName)
       
-        this.inputParams.push({ key: 'donchianChannels', params: [size, offset, { height, range, scale, lag, autoMinMax }] });
+        validateObject(options, 'options', methodName)
+        const { height = false, range = [], lag = 0} = options;
       
-        return this;
-    }
-      
-
-    candleVectors(size = 200, options = {}) {
-        isAlreadyComputed(this);
+        validateArray(range, 'range', methodName)
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+        validateBoolean(height, 'height', methodName)
       
-        if (typeof size !== 'number' || size <= 0) {
-          throw new Error('"size" must be a positive number greater than 0 in candleVectors.');
-        }
+        this.inputParams.push({ key: methodName, params: [size, offset, { height, range, lag }] });
       
-        const { stdDev = 1, lag = 0, scale = 0.001, patternSize = 0, autoMinMax = false } = options;
-
-
-        if (typeof stdDev !== 'number' || stdDev <= 0) {
-            throw new Error('"stdDev" must be a positive number greater than 0 in candleVectors.');
-        }
-
-        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
-
-            throw new Error(`"scale" value in candleVectors must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
-        }
-
-        if (typeof patternSize !== 'number' || !Number.isInteger(patternSize) || patternSize < 0 ) {
-
-            throw new Error(`"patternSize" value in candleVectors must be a positive integer.`);
-        }
-        if (typeof autoMinMax !== 'boolean') {
-
-            throw new Error(`"autoMinMax" value in candleVectors must be boolean`);
-        }
-      
-        this.inputParams.push({ key: 'candleVectors', params: [size, {stdDev, patternSize, lag, scale, autoMinMax}] });
         return this;
-      }
+    }
       
 
     volumeOscillator(fastSize = 5, slowSize = 10, options = {})
     {
+        const methodName = 'volumeOscillator'
 
-        if(this.hasVolume === false) {
+        if(!this.inputTypes.hasOwnProperty('volume')) {
             throw new Error('If "volumeOscillator" is called the input ohlcv must contain valid volume properties.')
         }
 
         isAlreadyComputed(this)
 
-        if (typeof fastSize !== 'number' || fastSize <= 1) {
-            throw new Error('fastSize" must be a positive number greater than 1 in volumeOscillator.');
-        }
+        validateNumber(fastSize, {min: 1, max: this.len, allowDecimals: false}, 'fastSize', methodName)
+        validateNumber(slowSize, {min: fastSize, max: this.len, allowDecimals: false}, 'slowSize', methodName)
+        validateObject(options, 'options', methodName)
 
-        if (typeof slowSize !== 'number' || slowSize <= fastSize) {
-            throw new Error('"slowSize" must be a positive number greater than the "fastSize" in volumeOscillator.');
-        }
+        const {lag = 0} = options
 
-        const {scale = null} = options
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
 
-        if (typeof scale === 'number' && !validMagnitudeValues.includes(scale)) {
-
-            throw new Error(`"scale" value in volumeOscillator must be any of the following numbers: ${validMagnitudeValues.join(', ')}`);
-        }
-
-        this.inputParams.push({key: 'volumeOscillator', params: [fastSize, slowSize, {scale}]})
+        this.inputParams.push({key: methodName, params: [fastSize, slowSize, {lag}]})
         return this           
     }
-    dateTime()
+    dateTime(options = {})
     {
+
+        const methodName = 'dateTime'
+
         isAlreadyComputed(this)
 
-        this.inputParams.push({key: 'dateTime', params: []})
+        validateObject(options, 'options', methodName)
+
+        const {lag = 0} = options
+
+        validateNumber(lag, {min: 0, max: this.len, allowDecimals: false}, 'lag', methodName)
+
+        this.inputParams.push({key: methodName, params: [{lag}]})
         return this           
     }
-    priceVariations()
+
+    Scaler(size, colKeys, options)
     {
+        const methodName = 'Scaler'
+
         isAlreadyComputed(this)
 
-        this.inputParams.push({key: 'priceVariations', params: []})
-        return this           
+        validateNumber(size, {min: 1, max: this.len, allowDecimals: false}, 'size', methodName)
+        validateArray(colKeys, 'colKeys', methodName)
+
+        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)
+
+        this.inputParams.push({key: methodName, params: [size, colKeys, type, group, range, lag]})
+        return this
     }
 }

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.3.2",
+  "version": "3.3.5",
   "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",
-    "study": "node test/study.js",
-    "count": "node test/countUps.js",
     "build": "npx webpack",
     "cross": "node src/studies/findCrosses2.js"
   },