ohlcv-indicators 1.9.8 → 2.0.0

package/index.js

@@ -1,39 +1,28 @@
-import { parseOhlcvToVertical, defaultStudyOptions } from './src/utilities/parsing-utilities.js'
+import { parseOhlcvToVertical } from './src/utilities/parsing-utilities.js'
 import { correlation } from './src/studies/correlation.js'
 import { setIndicatorsFromInputParams } from './src/utilities/setIndicatorsFromInputParams.js'
+import { validateDate } from './src/utilities/validators.js'
+import { isAlreadyComputed } from './src/utilities/validators.js'
 
 export default class OHLCV_INDICATORS {
-    constructor({input, ticker = null, studyOptions = null}) {
+    constructor({input, ticker = null}) {
 
-        if(!Array.isArray(input)) throw Error('input ohlcv must be an array: ' + ticker)
-        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)
+        if(!Array.isArray(input)) throw Error('input OHLCV must be an array: ' + ticker)
+        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.lastComputedIndex = 0
 
         this.input = input
-        this.priceBased = ['open', 'high', 'low', 'close', 'mid_price_open_close', 'mid_price_high_low']
+        this.priceBased = ['open', 'high', 'low', 'close']
         this.len = input.length
-        this.studyOptions = (studyOptions === null) ? defaultStudyOptions : studyOptions
+        this.lastIndexReplace = false 
         this.instances = {}
         this.crossPairsList = []
         this.verticalOhlcv = {}
 
-        this.inputParams = {
-            crossPairs: null,
-            lag: null,
-            relativeVolume: null,
-            ema: null,
-            sma: null,
-            macd: null,
-            bollingerBands: null,
-            rsi: null,
-            donchianChannels: null,
-            candlesStudies: null,
-            volumeOscillator: null,
-        }
+        this.inputParams = []
 
-        
         this.studies = {}
         this.utilities = {
             correlation
@@ -44,9 +33,11 @@ export default class OHLCV_INDICATORS {
     
         return this 
     }
-    
+
+
     getData() {
 
+        //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 {verticalOhlcv} = this
@@ -94,30 +85,57 @@ export default class OHLCV_INDICATORS {
     }
 
     compute(change) {
-        if (change) {
+
+        //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();
+                this.compute()
             }
-    
+
+
             if (inputDate !== changeDate) {
                 // Add new item
-                this.len++;
-                this.input.push(change);
-                parseOhlcvToVertical(this.input, this, this.len);
+                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);
+                this.input[lastIndex] = change
+                parseOhlcvToVertical(this.input, this, lastIndex)
             }
+
         }
     
-        if (this.len > this.lastComputedIndex && !change) {
-            parseOhlcvToVertical(this.input, this, 0);
-        }
+
     
         return this;
     }
@@ -126,9 +144,11 @@ export default class OHLCV_INDICATORS {
 
     crossPairs(arr)
     {
+        isAlreadyComputed(this)
+
         this.crossPairsList = [...this.crossPairsList, ...arr]
-        this.inputParams.crossPairs ??= []
-        this.inputParams.crossPairs.push([this.crossPairsList])
+
+        this.inputParams.push({key: 'crossPairs', params: [this.crossPairsList]})
         
         return this
     }
@@ -136,8 +156,9 @@ export default class OHLCV_INDICATORS {
 
     lag(colKeys = ['close'], lags = 1) {
 
-        this.inputParams.lag ??= []
-        this.inputParams.lag.push([colKeys, lags])
+        isAlreadyComputed(this)
+
+        this.inputParams.push({key: 'lag', params: [colKeys, lags]})
 
         for(let x = 0; x < colKeys.length; x++)
         {
@@ -154,38 +175,44 @@ export default class OHLCV_INDICATORS {
     
     relativeVolume(size) {
 
-        this.inputParams.relativeVolume ??= []
-        this.inputParams.relativeVolume.push([size])
+        isAlreadyComputed(this)
+
+        this.inputParams.push({key: 'relativeVolume', params: [size]})
  
         return this
     }
 
     ema(size) {
 
+        isAlreadyComputed(this)
+
         if (typeof size !== 'number' || size <= 0) {
             throw new Error('"size" must be a positive number in ema.');
         }
 
-        this.inputParams.ema ??= []
-        this.inputParams.ema.push([size])
+        this.inputParams.push({key: 'ema', params: [size]})
         this.priceBased.push(`ema_${size}`)
 
         return this
     }
     sma(size) {
 
+        isAlreadyComputed(this)
+
         if (typeof size !== 'number' || size <= 0) {
             throw new Error('"size" must be a positive number in sma.');
         }
 
-        this.inputParams.sma ??= []
-        this.inputParams.sma.push([size])
+
+        this.inputParams.push({key: 'sma', params: [size]})
         this.priceBased.push(`sma_${size}`)
 
         return this 
     }
     macd(fast = 12, slow = 26, signal = 9) {
 
+        isAlreadyComputed(this)
+
         if (typeof fast !== 'number' || fast <= 0) {
             throw new Error('"fast" must be a positive number in macd.');
         }
@@ -196,23 +223,32 @@ export default class OHLCV_INDICATORS {
             throw new Error('"signal" must be a positive number in macd.');
         }
 
-        this.inputParams.macd ??= []
-        this.inputParams.macd.push([fast, slow, signal])
+        this.inputParams.push({key: 'macd', params: [fast, slow, signal]})
         
         return this
 
     }
-    bollingerBands(size = 20, times = 2, bollingerBandsStudies) {
+    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 {target = 'close', height = false, range = false} = options
+
         // Validate size and times
         if (typeof size !== 'number' || size <= 0) {
-            throw new Error('Invalid parameter: "size" must be a positive number in bollingerBands.');
+            throw new Error('"size" must be a positive number in bollingerBands.');
         }
-        if (typeof times !== 'number' || times <= 0) {
-            throw new Error('Invalid parameter: "times" must be a positive number in bollingerBands.');
+        if (typeof stdDev !== 'number' || stdDev <= 0) {
+            throw new Error('"stdDev" must be a positive number in bollingerBands.');
         }
     
-        this.inputParams.bollingerBands ??= [];
-        this.inputParams.bollingerBands.push([size, times, bollingerBandsStudies]);
+        this.inputParams.push({key: 'bollingerBands', params: [size, stdDev, {target, height, range}]});
         this.priceBased.push('bollinger_bands_middle', 'bollinger_bands_upper', 'bollinger_bands_lower');
     
         return this;
@@ -220,18 +256,21 @@ export default class OHLCV_INDICATORS {
     
     rsi(size)
     {
+        isAlreadyComputed(this)
+
         // Validate size and times
         if (typeof size !== 'number' || size <= 0) {
             throw new Error('"size" must be a positive number in rsi.');
         }
 
-        this.inputParams.rsi ??= []
-        this.inputParams.rsi.push([size])
+        this.inputParams.push({key: 'rsi', params: [size]})
 
         return this
     }
     donchianChannels(size = 20, offset = 0)
     {
+        isAlreadyComputed(this)
+
         if (typeof size !== 'number' || size <= 0) {
             throw new Error('"size" must be a positive number or 0 in donchianChannels.');
         }
@@ -240,31 +279,32 @@ export default class OHLCV_INDICATORS {
             throw new Error('"offset" must be a positive number or 0 in donchianChannels.');
         }
 
-        this.inputParams.donchianChannels ??= []
-        this.inputParams.donchianChannels.push([size, offset])
+        this.inputParams.push({key: 'donchianChannels', params: [size, offset]})
         this.priceBased.push('donchian_channel_upper', 'donchian_channel_lower', 'donchian_channel_basis')
 
         return this       
     }
-    candlesStudies(size = 20, classify = true, classificationLevels)
+    candleStudies(size = 20, classify = true, classificationLevels)
     {
 
+        isAlreadyComputed(this)
+
         if (typeof size !== 'number' || size <= 0) {
-            throw new Error('"size" must be a positive number or 0 in candlesStudies.');
+            throw new Error('"size" must be a positive number or 0 in candleStudies.');
         }
 
         if (typeof classify !== 'boolean') {
-            throw new Error('"classify" must be a true or false in candlesStudies.');
+            throw new Error('"classify" must be a true or false in candleStudies.');
         }
 
-        this.inputParams.candlesStudies ??= []
-        this.inputParams.candlesStudies.push([size, classify, classificationLevels])
+        this.inputParams.push({key: 'candleStudies', params: [size, classify, classificationLevels]})
         return this       
     }
 
     volumeOscillator(fastSize = 5, slowSize = 10)
     {
 
+        isAlreadyComputed(this)
 
         if (typeof fastSize !== 'number' || fastSize <= 0) {
             throw new Error('fastSize" must be a positive number in volumeOscillator.');
@@ -274,9 +314,21 @@ export default class OHLCV_INDICATORS {
             throw new Error('"slowSize" must be a positive number greater than the "fastSize" in volumeOscillator.');
         }
 
+        this.inputParams.push({key: 'volumeOscillator', params: [fastSize, slowSize]})
+        return this           
+    }
+    dateTime()
+    {
+        isAlreadyComputed(this)
+
+        this.inputParams.push({key: 'dateTime', params: []})
+        return this           
+    }
+    priceVariations()
+    {
+        isAlreadyComputed(this)
 
-        this.inputParams.volumeOscillator ??= []
-        this.inputParams.volumeOscillator.push([fastSize, slowSize])
+        this.inputParams.push({key: 'priceVariations', params: []})
         return this           
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.9.8",
+  "version": "2.0.0",
   "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/moving-averages/bollingerBands.js

@@ -1,35 +1,44 @@
 import {FasterBollingerBands, FasterSMA} from 'trading-signals';
 import { classifySize } from '../utilities/classification.js';
 
-export const bollingerBands = (main, index, size, times, bollingerBandsStudies = false) => {
+let defaultTarget = 'close'
 
-    const value = main.verticalOhlcv.close[index]
+export const bollingerBands = (main, index, size, times, options) => {
 
-    if (index === 0) {
+    const {height, range, target} = options
+    let suffix = (target === defaultTarget) ? '' : `_${target}`
 
-        Object.assign(main.instances, {bollinger_bands: {
-            instance: new FasterBollingerBands(size, times),
-            heightInstance: bollingerBandsStudies ? new FasterSMA(size) : null
-        }})
+    if (index === 0) {
 
+        if(!main.verticalOhlcv.hasOwnProperty(target))
+        {
+            throw new Error(`bollingerBands could not find target "${target}"`)
+        }
 
-        Object.assign(main.verticalOhlcv, {
-            bollinger_bands_upper: new Array(main.len).fill(null),
-            bollinger_bands_middle: new Array(main.len).fill(null),
-            bollinger_bands_lower: new Array(main.len).fill(null)
+        Object.assign(main.instances, {
+            [`bollinger_bands${suffix}`]: {
+                instance: new FasterBollingerBands(size, times),
+                heightInstance: height ? new FasterSMA(size) : null
+            }
         })
-
-        if (bollingerBandsStudies) {
-
-            Object.assign(main.verticalOhlcv, {
-                bollinger_bands_range: new Array(main.len).fill(null),
-                bollinger_bands_height: new Array(main.len).fill(null),
+        
+        Object.assign(main.verticalOhlcv, {
+            [`bollinger_bands_upper${suffix}`]: [...main.nullArray],
+            [`bollinger_bands_middle${suffix}`]: [...main.nullArray],
+            [`bollinger_bands_lower${suffix}`]: [...main.nullArray],
+            ...(height && {
+                [`bollinger_bands_height${suffix}`]: [...main.nullArray]
+            }),
+            ...(range && {
+                [`bollinger_bands_range${suffix}`]: [...main.nullArray],
             })
-        }
+        })
     }
 
-    const { instance, heightInstance } = main.instances[`bollinger_bands`];
-    instance.update(value);
+    
+    const { instance, heightInstance } = main.instances[`bollinger_bands${suffix}`]
+    const value = main.verticalOhlcv[target][index]
+    instance.update(value, main.lastIndexReplace)
 
     let result;
     try {
@@ -41,20 +50,20 @@ export const bollingerBands = (main, index, size, times, bollingerBandsStudies =
     if(!result) return true
 
     const { upper, middle, lower } = result;
-    main.verticalOhlcv.bollinger_bands_upper[index] = upper;
-    main.verticalOhlcv.bollinger_bands_middle[index] = middle;
-    main.verticalOhlcv.bollinger_bands_lower[index] = lower;
+    main.verticalOhlcv[`bollinger_bands_upper${suffix}`][index] = upper;
+    main.verticalOhlcv[`bollinger_bands_middle${suffix}`][index] = middle;
+    main.verticalOhlcv[`bollinger_bands_lower${suffix}`][index] = lower;
 
-    if (!bollingerBandsStudies) return true;
+    if (!height && !range) return true;
 
-    let range = null;
-    let height = null;
+    let rangeValue = null;
+    let heightValue = null;
     let heightMean;
 
-    range = (value - lower) / (upper - lower);
-    height = upper - lower;
+    rangeValue = (value - lower) / (upper - lower);
+    heightValue = upper - lower;
 
-    heightInstance.update(height);
+    heightInstance.update(heightValue, main.lastIndexReplace);
 
     try {
         heightMean = heightInstance.getResult();
@@ -62,11 +71,11 @@ export const bollingerBands = (main, index, size, times, bollingerBandsStudies =
         //do nothing
     }
 
-    main.verticalOhlcv.bollinger_bands_range[index] = range;
+    main.verticalOhlcv[`bollinger_bands_range${suffix}`][index] = rangeValue;
 
     if(heightMean)
     {
-        main.verticalOhlcv.bollinger_bands_height[index] = classifySize(height, heightMean, 1.5);
+        main.verticalOhlcv[`bollinger_bands_height${suffix}`][index] = classifySize(heightValue, heightMean, 1.5);
     }
     
     return true;

package/src/moving-averages/donchianChannel.js

@@ -1,5 +1,3 @@
-const avg = (h, l) => (h + l) / 2;
-
 export const donchianChannels = (main, index, size, offset) => {
 
     const highs = main.verticalOhlcv.high;
@@ -7,13 +5,11 @@ export const donchianChannels = (main, index, size, offset) => {
 
     // Ensure that the required arrays exist
     if (index === 0) {
-        
-        main.instances['donchian_channels'] = {};
 
         Object.assign(main.verticalOhlcv, {
-            donchian_channel_upper: new Array(main.len).fill(null),
-            donchian_channel_basis: new Array(main.len).fill(null),
-            donchian_channel_lower: new Array(main.len).fill(null),
+            donchian_channel_upper: [...main.nullArray],
+            donchian_channel_basis: [...main.nullArray],
+            donchian_channel_lower: [...main.nullArray],
         })
     }
 
@@ -32,7 +28,7 @@ export const donchianChannels = (main, index, size, offset) => {
     // Compute the Donchian channels
     const upper = Math.max(...highChunk);
     const lower = Math.min(...lowChunk);
-    const basis = avg(upper, lower);
+    const basis = (upper + lower) / 2;
 
     // Place the result at index
     const placementIndex = index;

package/src/moving-averages/ema.js

@@ -8,11 +8,11 @@ export const ema = (main, index, size) => {
   if(index === 0)
   {
       main.instances[`ema_${size}`] = new FasterEMA(size)
-      main.verticalOhlcv[`ema_${size}`] = new Array(main.len).fill(null)
+      main.verticalOhlcv[`ema_${size}`] = [...main.nullArray]
   }
 
   let currSma
-  main.instances[`ema_${size}`].update(value)
+  main.instances[`ema_${size}`].update(value, main.lastIndexReplace)
 
   try{
     currSma = main.instances[`ema_${size}`].getResult()

package/src/moving-averages/macd.js

@@ -15,14 +15,14 @@ export const macd = (main, index, fast, slow, signal) => {
         );
 
         Object.assign(main.verticalOhlcv, {
-            macd_diff: new Array(main.len).fill(null),
-            macd_dea: new Array(main.len).fill(null),
-            macd_histogram: new Array(main.len).fill(null),
+            macd_diff: [...main.nullArray],
+            macd_dea: [...main.nullArray],
+            macd_histogram: [...main.nullArray],
         })
     }
 
     const macdInstance = main.instances[`macd`];
-    macdInstance.update(value);
+    macdInstance.update(value, main.lastIndexReplace);
 
     let macdResult;
     

package/src/moving-averages/relativeVolume.js

@@ -5,16 +5,18 @@ export const relativeVolume = (main, index, size = 10) => {
     const value = main.verticalOhlcv.volume[index]
 
     if (index === 0) {
-        main.instances[`relative_volume_${size}`] = new FasterSMA(size);
+        main.instances[`relative_volume_${size}`] = {
+            instance: new FasterSMA(size),
+            prevRelativeVolumeSma: null
+        }
 
         Object.assign(main.verticalOhlcv, {
-            [`relative_volume_${size}`]: new Array(main.len).fill(null),
-            [`relative_volume_sma_${size}`]: new Array(main.len).fill(null)
+            [`relative_volume_${size}`]: [...main.nullArray],
         })
     }
 
-    const smaInstance = main.instances[`relative_volume_${size}`]
-    smaInstance.update(value)
+    const smaInstance = main.instances[`relative_volume_${size}`].instance
+    smaInstance.update(value, main.lastIndexReplace)
 
     let smaValue;
     try {
@@ -23,13 +25,16 @@ export const relativeVolume = (main, index, size = 10) => {
         //do nothing
     }
 
-    main.verticalOhlcv[`relative_volume_sma_${size}`][index] = smaValue;
+    const {prevRelativeVolumeSma} = main.instances[`relative_volume_${size}`]
 
-    if (smaValue !== null && typeof main.verticalOhlcv[`relative_volume_sma_${size}`][index - 1] === 'number') {
-        main.verticalOhlcv[`relative_volume_${size}`][index] = value / main.verticalOhlcv[`relative_volume_sma_${size}`][index - 1];
+    if (smaValue !== null && prevRelativeVolumeSma !== null) {
+        main.verticalOhlcv[`relative_volume_${size}`][index] = value / prevRelativeVolumeSma;
     } else {
         main.verticalOhlcv[`relative_volume_${size}`][index] = null;
     }
 
+
+    main.instances[`relative_volume_${size}`].prevRelativeVolumeSma = smaValue
+
     return true;
 };

package/src/moving-averages/sma.js

@@ -8,11 +8,11 @@ export const sma = (main, index, size) => {
   if(index === 0)
   {
       main.instances[`sma_${size}`] = new FasterSMA(size)
-      main.verticalOhlcv[`sma_${size}`] = new Array(main.len).fill(null)
+      main.verticalOhlcv[`sma_${size}`] = [...main.nullArray]
   }
 
   let currSma
-  main.instances[`sma_${size}`].update(value)
+  main.instances[`sma_${size}`].update(value, main.lastIndexReplace)
 
   try{
     currSma = main.instances[`sma_${size}`].getResult()

package/src/oscillators/rsi.js

@@ -16,15 +16,15 @@ export const rsi = (main, index, size) => {
         })
 
         Object.assign(main.verticalOhlcv, {
-            [`rsi_${size}`]: new Array(main.len).fill(null),
-            [`rsi_sma_${size}`]: new Array(main.len).fill(null)
+            [`rsi_${size}`]: [...main.nullArray],
+            [`rsi_sma_${size}`]: [...main.nullArray]
         })
     }
     
     let currentRsi
     let smoothedRsi
 
-    main.instances[`rsi_${size}`].update(value)
+    main.instances[`rsi_${size}`].update(value, main.lastIndexReplace)
 
     try
     {
@@ -36,7 +36,7 @@ export const rsi = (main, index, size) => {
     if(currentRsi)
     {
         main.verticalOhlcv[`rsi_${size}`][index] = currentRsi
-        main.instances[`rsi_sma_${size}`].update(currentRsi)
+        main.instances[`rsi_sma_${size}`].update(currentRsi, main.lastIndexReplace)
     }
 
     try

package/src/oscillators/volumeOscillator.js

@@ -13,14 +13,14 @@ export const volumeOscillator = (main, index, fast, slow) => {
             }
         })
 
-        main.verticalOhlcv[`volume_oscillator`] = new Array(main.len).fill(null);
+        main.verticalOhlcv[`volume_oscillator`] = [...main.nullArray];
         main.crossPairsList.push({ fast: `volume_oscillator`, slow: 0 });
     }
 
     const { fastEMA, slowEMA } = main.instances[`volume_oscillator`];
 
-    fastEMA.update(value);
-    slowEMA.update(value);
+    fastEMA.update(value, main.lastIndexReplace);
+    slowEMA.update(value, main.lastIndexReplace);
 
     let fastValue = null;
     let slowValue = null;