ohlcv-indicators 1.9.3 → 1.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohlcv-indicators",
-  "version": "1.9.3",
+  "version": "1.9.4",
   "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

@@ -6,17 +6,25 @@ export const bollingerBands = (main, index, size, times, bollingerBandsStudies =
     const value = main.verticalOhlcv.close[index]
 
     if (!main.instances.hasOwnProperty(`bollinger_bands`)) {
-        main.instances[`bollinger_bands`] = {
+
+        Object.assign(main.instances, {bollinger_bands: {
             instance: new FasterBollingerBands(size, times),
             heightInstance: bollingerBandsStudies ? new FasterSMA(size) : null
-        };
-        main.verticalOhlcv[`bollinger_bands_upper`] = new Array(main.len).fill(null);
-        main.verticalOhlcv[`bollinger_bands_middle`] = new Array(main.len).fill(null);
-        main.verticalOhlcv[`bollinger_bands_lower`] = new Array(main.len).fill(null);
+        }})
+
+
+        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)
+        })
 
         if (bollingerBandsStudies) {
-            main.verticalOhlcv[`bollinger_bands_range`] = new Array(main.len).fill(null);
-            main.verticalOhlcv[`bollinger_bands_height`] = new Array(main.len).fill(null);
+
+            Object.assign(main.verticalOhlcv, {
+                bollinger_bands_range: new Array(main.len).fill(null),
+                bollinger_bands_height: new Array(main.len).fill(null),
+            })
         }
     }
 
@@ -27,13 +35,15 @@ export const bollingerBands = (main, index, size, times, bollingerBandsStudies =
     try {
         result = instance.getResult();
     } catch (err) {
-        result = { upper: null, middle: null, lower: null };
+       //do nothing
     }
 
+    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[index] = upper;
+    main.verticalOhlcv.bollinger_bands_middle[index] = middle;
+    main.verticalOhlcv.bollinger_bands_lower[index] = lower;
 
     if (!bollingerBandsStudies) return true;
 
@@ -41,21 +51,23 @@ export const bollingerBands = (main, index, size, times, bollingerBandsStudies =
     let height = null;
     let heightMean;
 
-    if (upper !== null && lower !== null) {
-        range = (value - lower) / (upper - lower);
-        height = upper - lower;
+    range = (value - lower) / (upper - lower);
+    height = upper - lower;
 
-        heightInstance.update(height);
+    heightInstance.update(height);
 
-        try {
-            heightMean = heightInstance.getResult();
-        } catch (err) {
-            heightMean = null;
-        }
+    try {
+        heightMean = heightInstance.getResult();
+    } catch (err) {
+        //do nothing
     }
 
-    main.verticalOhlcv[`bollinger_bands_range`][index] = range;
-    main.verticalOhlcv[`bollinger_bands_height`][index] = classifySize(height, heightMean, 1.5);
+    main.verticalOhlcv.bollinger_bands_range[index] = range;
 
+    if(heightMean)
+    {
+        main.verticalOhlcv.bollinger_bands_height[index] = classifySize(height, heightMean, 1.5);
+    }
+    
     return true;
 };

package/src/moving-averages/donchianChannel.js

@@ -1,19 +1,23 @@
 const avg = (h, l) => (h + l) / 2;
 
 export const donchianChannels = (main, index, size, offset) => {
-    const { verticalOhlcv } = main;
-    const highs = verticalOhlcv.high;
-    const lows = verticalOhlcv.low;
+
+    const highs = main.verticalOhlcv.high;
+    const lows = main.verticalOhlcv.low;
 
     // If we don't have enough data to fill one size ending at (index - offset), return
     if ((index - offset) < (size - 1)) return true;
 
     // Ensure that the required arrays exist
     if (!main.instances.hasOwnProperty('donchian_channels')) {
+        
         main.instances['donchian_channels'] = {};
-        verticalOhlcv['donchian_channel_upper'] = new Array(main.len).fill(null);
-        verticalOhlcv['donchian_channel_basis'] = new Array(main.len).fill(null);
-        verticalOhlcv['donchian_channel_lower'] = new Array(main.len).fill(null);
+
+        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),
+        })
     }
 
 
@@ -37,9 +41,9 @@ export const donchianChannels = (main, index, size, offset) => {
     const placementIndex = index;
 
     if (placementIndex >= 0 && placementIndex < main.len) {
-        verticalOhlcv['donchian_channel_upper'][placementIndex] = upper;
-        verticalOhlcv['donchian_channel_basis'][placementIndex] = basis;
-        verticalOhlcv['donchian_channel_lower'][placementIndex] = lower;
+        main.verticalOhlcv['donchian_channel_upper'][placementIndex] = upper;
+        main.verticalOhlcv['donchian_channel_basis'][placementIndex] = basis;
+        main.verticalOhlcv['donchian_channel_lower'][placementIndex] = lower;
     }
 
     return true;

package/src/moving-averages/macd.js

@@ -14,33 +14,29 @@ export const macd = (main, index, fastLine = 12, slowLine = 26, signalLine = 9)
             new FasterEMA(signalLine)
         );
 
-        main.verticalOhlcv['macd_diff'] = new Array(main.len).fill(null);
-        main.verticalOhlcv['macd_dea'] = new Array(main.len).fill(null);
-        main.verticalOhlcv['macd_histogram'] = new Array(main.len).fill(null);
+        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),
+        })
     }
 
     const macdInstance = main.instances[`macd`];
     macdInstance.update(value);
 
     let macdResult;
+    
     try {
         macdResult = macdInstance.getResult();
     } catch (err) {
-        macdResult = { macd: null, signal: null, histogram: null };
+        //do nothing
     }
 
-    const { macd, signal, histogram } = macdResult;
 
-    if (macd !== null) {
-        main.verticalOhlcv['macd_diff'][index] = macd;
-    }
-
-    if (signal !== null) {
-        main.verticalOhlcv['macd_dea'][index] = signal;
-    }
-
-    if (histogram !== null) {
-        main.verticalOhlcv['macd_histogram'][index] = histogram;
+    if (macdResult) {
+        main.verticalOhlcv['macd_diff'][index] = macdResult.macd;
+        main.verticalOhlcv['macd_dea'][index] = macdResult.signal;
+        main.verticalOhlcv['macd_histogram'][index] = macdResult.histogram;
     }
 
     return true;

package/src/moving-averages/relativeVolume.js

@@ -6,8 +6,11 @@ export const relativeVolume = (main, index, size = 10) => {
 
     if (!main.instances.hasOwnProperty(`relative_volume_${size}`)) {
         main.instances[`relative_volume_${size}`] = new FasterSMA(size);
-        main.verticalOhlcv[`relative_volume_${size}`] = new Array(main.len).fill(null);
-        main.verticalOhlcv[`relative_volume_sma_${size}`] = new Array(main.len).fill(null);
+
+        Object.assign(main.verticalOhlcv, {
+            [`relative_volume_${size}`]: new Array(main.len).fill(null),
+            [`relative_volume_sma_${size}`]: new Array(main.len).fill(null)
+        })
     }
 
     const smaInstance = main.instances[`relative_volume_${size}`]
@@ -17,7 +20,7 @@ export const relativeVolume = (main, index, size = 10) => {
     try {
         smaValue = smaInstance.getResult()
     } catch (err) {
-        smaValue = null;
+        //do nothing
     }
 
     main.verticalOhlcv[`relative_volume_sma_${size}`][index] = smaValue;

package/src/moving-averages/sma.js

@@ -18,7 +18,7 @@ export const sma = (main, index, size) => {
     currSma = main.instances[`sma_${size}`].getResult()
   } catch(err)
   {
-    currSma = null
+    //do nothing
   }
 
   if(currSma)

package/src/oscillators/rsi.js

@@ -9,10 +9,16 @@ export const rsi = (main, index, size) => {
     if(!main.instances.hasOwnProperty(`rsi_${size}`))
     {
         main.autoCrossPairsList.push({fast: `rsi_${size}`, slow: `rsi_sma_${size}`})
-        main.instances[`rsi_${size}`] = new FasterRSI(size)
-        main.instances[`rsi_sma_${size}`] = new FasterSMA(size)
-        main.verticalOhlcv[`rsi_${size}`] = new Array(main.len).fill(null)
-        main.verticalOhlcv[`rsi_sma_${size}`] = new Array(main.len).fill(null)
+
+        Object.assign(main.instances, {
+            [`rsi_${size}`]: new FasterRSI(size),
+            [`rsi_sma_${size}`]: new FasterSMA(size)
+        })
+
+        Object.assign(main.verticalOhlcv, {
+            [`rsi_${size}`]: new Array(main.len).fill(null),
+            [`rsi_sma_${size}`]: new Array(main.len).fill(null)
+        })
     }
     
     let currentRsi

package/src/oscillators/volumeOscillator.js

@@ -5,10 +5,14 @@ export const volumeOscillator = (main, index, fastSize = 5, slowSize = 10) => {
     const value = main.verticalOhlcv.volume[index]
 
     if (!main.instances.hasOwnProperty(`volume_oscillator`)) {
-        main.instances[`volume_oscillator`] = {
-            fastEMA: new FasterEMA(fastSize),
-            slowEMA: new FasterEMA(slowSize)
-        };
+
+        Object.assign(main.instances, {
+            volume_oscillator: {
+                fastEMA: new FasterEMA(fastSize),
+                slowEMA: new FasterEMA(slowSize)
+            }
+        })
+
         main.verticalOhlcv[`volume_oscillator`] = new Array(main.len).fill(null);
         main.autoCrossPairsList.push({ fast: `volume_oscillator`, slow: 0 });
     }

package/src/studies/candleStudies.js

@@ -3,54 +3,39 @@ import { classifySize } from '../utilities/classification.js';
 
 export const candlesStudies = (main, index, size, classify = true, classificationLevels = {}) => {
 
-
-
     const { changeLevel = 7, sizeLevel = 5 } = classificationLevels;
 
-    // Ensure arrays exist in main.verticalOhlcv
-    const fields = [
-        'candle_gap_size',
-        'candle_body_size',
-        'candle_top_size',
-        'candle_bottom_size',
-        'candle_shadow_size',
-        'candle_close_direction',
-        'candle_high_direction',
-        'candle_low_direction',
-        'candle_open_direction'
-    ];
-
-    for (const field of fields) {
-        if (!main.verticalOhlcv.hasOwnProperty(field)) {
-            main.verticalOhlcv[field] = new Array(main.len).fill(null);
-        }
+    if(index === 0)
+    {
+        Object.assign(main.verticalOhlcv, {
+            candle_gap_size: new Array(main.len).fill(null),
+            candle_body_size: new Array(main.len).fill(null),
+            candle_top_size: new Array(main.len).fill(null),
+            candle_bottom_size: new Array(main.len).fill(null),
+            candle_shadow_size: new Array(main.len).fill(null),
+            candle_close_direction: new Array(main.len).fill(null),
+            candle_high_direction: new Array(main.len).fill(null),
+            candle_low_direction: new Array(main.len).fill(null),
+            candle_open_direction: new Array(main.len).fill(null),          
+        })
     }
 
     // Ensure instances exist if classification is enabled
-    if (classify) {
-        const instanceNames = [
-            'topInstance',
-            'bottomInstance',
-            'gapInstance',
-            'bodySizeInstance',
-            'shadowSizeInstance',
-            'closeDirectionInstance',
-            'highDirectionInstance',
-            'lowDirectionInstance',
-            'openDirectionInstance'
-        ];
-
-        // Create a namespace for candle studies if it doesn't exist
-        if (!main.instances.hasOwnProperty('candleStudies')) {
-            main.instances.candleStudies = {};
-        }
-
-        // Create instances if they don't exist
-        for (const name of instanceNames) {
-            if (!main.instances.candleStudies.hasOwnProperty(name)) {
-                main.instances.candleStudies[name] = new FasterSMA(size);
+    if (classify && index === 0) {
+
+        Object.assign(main.instances, {
+            candleStudies: {
+                topInstance: new FasterSMA(size),
+                bottomInstance: new FasterSMA(size),
+                gapInstance: new FasterSMA(size),
+                bodySizeInstance: new FasterSMA(size),
+                shadowSizeInstance: new FasterSMA(size),
+                closeDirectionInstance: new FasterSMA(size),
+                highDirectionInstance: new FasterSMA(size),
+                lowDirectionInstance: new FasterSMA(size),
+                openDirectionInstance: new FasterSMA(size)             
             }
-        }
+        })
     }
 
     // If we do not have a previous candle, we cannot compute differences
@@ -127,45 +112,45 @@ export const candlesStudies = (main, index, size, classify = true, classificatio
             // If there's not enough data, means remain null
         }
 
-        main.verticalOhlcv['candle_body_size'][index] = isUp
+        main.verticalOhlcv.candle_body_size[index] = isUp
             ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
             : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_gap_size'][index] = isUp
+        main.verticalOhlcv.candle_gap_size[index] = isUp
             ? classifySize(gapSize, gapMean, 2, changeLevel)
             : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_close_direction'][index] = isUp
+        main.verticalOhlcv.candle_close_direction[index] = isUp
             ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_high_direction'][index] = isUp
+        main.verticalOhlcv.candle_high_direction[index] = isUp
             ? classifySize(highDirection, highDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_low_direction'][index] = isUp
+        main.verticalOhlcv.candle_low_direction[index] = isUp
             ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_open_direction'][index] = isUp
+        main.verticalOhlcv.candle_open_direction[index] = isUp
             ? classifySize(openDirection, openDirectionMean, 2, changeLevel)
             : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0;
 
-        main.verticalOhlcv['candle_top_size'][index] = classifySize(topSize, topSizeMean, 0.5, sizeLevel);
-        main.verticalOhlcv['candle_bottom_size'][index] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel);
-        main.verticalOhlcv['candle_shadow_size'][index] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel);
+        main.verticalOhlcv.candle_top_size[index] = classifySize(topSize, topSizeMean, 0.5, sizeLevel);
+        main.verticalOhlcv.candle_bottom_size[index] = classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel);
+        main.verticalOhlcv.candle_shadow_size[index] = classifySize(shadowSize, shadowSizeMean, 0.5, sizeLevel);
     } else {
         // Without classification, just store raw values
-        main.verticalOhlcv['candle_body_size'][index] = isUp ? candleBodySize : -candleBodySize;
-        main.verticalOhlcv['candle_gap_size'][index] = isUp ? gapSize : -gapSize;
-        main.verticalOhlcv['candle_close_direction'][index] = isUp ? closeDirection : -closeDirection;
-        main.verticalOhlcv['candle_high_direction'][index] = isUp ? highDirection : -highDirection;
-        main.verticalOhlcv['candle_low_direction'][index] = isUp ? lowDirection : -lowDirection;
-        main.verticalOhlcv['candle_open_direction'][index] = isUp ? openDirection : -openDirection;
-
-        main.verticalOhlcv['candle_top_size'][index] = topSize;
-        main.verticalOhlcv['candle_bottom_size'][index] = bottomSize;
-        main.verticalOhlcv['candle_shadow_size'][index] = shadowSize;
+        main.verticalOhlcv.candle_body_size[index] = isUp ? candleBodySize : -candleBodySize;
+        main.verticalOhlcv.candle_gap_size[index] = isUp ? gapSize : -gapSize;
+        main.verticalOhlcv.candle_close_direction[index] = isUp ? closeDirection : -closeDirection;
+        main.verticalOhlcv.candle_high_direction[index] = isUp ? highDirection : -highDirection;
+        main.verticalOhlcv.candle_low_direction[index] = isUp ? lowDirection : -lowDirection;
+        main.verticalOhlcv.candle_open_direction[index] = isUp ? openDirection : -openDirection;
+
+        main.verticalOhlcv.candle_top_size[index] = topSize;
+        main.verticalOhlcv.candle_bottom_size[index] = bottomSize;
+        main.verticalOhlcv.candle_shadow_size[index] = shadowSize;
     }
 
     return true;

package/src/studies/findCrosses.js

@@ -3,8 +3,69 @@ const gt = (f, s) => f > s
 const lt = (f, s) => f < s
 
 
+
+export const crossPairs = (main, arr) => {
+    
+    const {verticalOhlcv} = main
+
+    const x = {}
+    const c = {}
+
+    for (const { fast, slow, count } of arr) {
+        // Validate parameters
+        if (!fast || !slow) continue;
+    
+        // Prepare slowNumArr if 'slow' is a number
+        if (typeof slow === 'number') {
+
+            main.verticalOhlcv[slow] = new Array(main.len).fill(slow)
+        }
+    
+        const crossName = `${fast}_x_${slow}`
+        const countName = `${fast}_c_${slow}`
+
+        const splitCount = arr => (typeof count !== 'undefined') ? (arr.slice(-count)).filter(o => o === 1 || o === -1).length : 0
+
+        //cross already exists
+        if(verticalOhlcv[crossName])
+        {
+            const cross = verticalOhlcv[crossName]
+            x[crossName] = cross    
+            
+            if(typeof count !== 'undefined')
+            {
+                c[countName] = splitCount(cross)
+            }
+            
+        }
+        //cross created from 2 columns
+        else if ((verticalOhlcv[fast] || fast === 'price') && verticalOhlcv[slow]) {
+
+            const cross = (fast === 'price') 
+            ? findCrosses({
+                fast: verticalOhlcv.close, 
+                high: verticalOhlcv.high, 
+                low: verticalOhlcv.low, 
+                slow: verticalOhlcv[slow]}
+            ) 
+            : findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow]})
+
+            x[crossName] = cross
+
+            if(typeof count !== 'undefined')
+            {
+                c[countName] = splitCount(cross)
+            }
+
+        }
+    }
+
+    return {x, c}
+}
+
+
 // Function to find crosses between two arrays: fast and slow
-export const findCrosses = ({fast, high, low, slow}) => {
+const findCrosses = ({fast, high, low, slow}) => {
     // Map states based on comparison of fast and slow arrays
 
     const dataLength = fast.length
@@ -80,131 +141,48 @@ export const findCrosses = ({fast, high, low, slow}) => {
 
 
 const flatGroupsToNumArr = groups => {
-
-    const groupLengths = groups.map(g => g.length)
-
-    return groups.map((group, gIndex) => {
-        let initialValue = groupLengths[gIndex]
-
-        return group.map((s, i) => {
-            let v = initialValue - i
-
-            if(s === 0.5)
-            {
-                v = 0
-            }
-            if(s === 1)
-            {
-                v = v * 1
-            }
-            if(s === 0)
-            {
-                v = v * -1
-            }
-
-            return v
-        }).reverse()
-    }).flat()
-}
-
-
-// Helper function to group consecutive values
-export const groupConsecutiveValues = arr => {
-    if (arr.length === 0) return []
-
-    return arr.reduce((acc, currentValue, index, array) => {
-        if (index === 0) {
-            // Start the first group with the first element
-            acc.push([currentValue])
-        } else {
-            // Get the previous value
-            const prevValue = array[index - 1]
-            const currentGroup = acc[acc.length - 1]
-
-            // Check the direction of the previous and current values
-            if (currentValue !== prevValue) {
-                // Start a new group if the direction changes
-                acc.push([currentValue]);
-            } else {
-                // Otherwise, add to the current group
-                currentGroup.push(currentValue);
-            }
-        }
-        return acc
-    }, [])
-}
-
-
-
-export const crossPairs = (main, arr) => {
-
-
-
-    const {verticalOhlcv, len} = main
-    const slowNumArrCache = {};
-    const x = {}
-    const c = {}
-
-    for (const { fast, slow, count } of arr) {
-        // Validate parameters
-        if (!fast || !slow) continue;
+    const result = [];
     
-        // Prepare slowNumArr if 'slow' is a number
-        if (typeof slow === 'number' && !slowNumArrCache[slow]) {
-
-            slowNumArrCache[slow] = Array(len).fill(slow)
+    for (const group of groups) {
+        const length = group.length;
+        
+        for (let i = length - 1; i >= 0; i--) {
+            const s = group[i];
+            const offset = length - i;
+            result.push(
+                s === 0.5 ? 0 : offset * (s === 1 ? 1 : -1)
+            );
         }
+    }
     
-        const crossName = `${fast}_x_${slow}`
-        const countName = `${fast}_c_${slow}`
-
-        const splitCount = arr => (typeof count !== 'undefined') ? (arr.slice(-count)).filter(o => o === 1 || o === -1).length : 0
-
-        //cross already exists
-        if(verticalOhlcv[crossName])
-        {
-            const cross = verticalOhlcv[crossName]
-            x[crossName] = cross    
-            
-            if(typeof count !== 'undefined')
-            {
-                c[countName] = splitCount(cross)
-            }
-            
-        }
-        //cross created from 2 columns
-        else if ((verticalOhlcv[fast] || fast === 'price') && verticalOhlcv[slow]) {
-
-            const cross = (fast === 'price') 
-            ? findCrosses({
-                fast: verticalOhlcv.close, 
-                high: verticalOhlcv.high, 
-                low: verticalOhlcv.low, 
-                slow: verticalOhlcv[slow]}
-            ) 
-            : findCrosses({fast: verticalOhlcv[fast], slow: verticalOhlcv[slow]})
+    return result;
+}
 
-            x[crossName] = cross
 
-            if(typeof count !== 'undefined')
-            {
-                c[countName] = splitCount(cross)
-            }
+// Helper function to group consecutive values
+const groupConsecutiveValues = (arr) => {
+    const length = arr.length;
+    if (length === 0) return [];
 
-        }
-        //cross created from 1 column and an number
-        else if (verticalOhlcv[fast] && slowNumArrCache[slow]) {
-            const cross = findCrosses({fast: verticalOhlcv[fast], slow: slowNumArrCache[slow]})
-            x[crossName] = cross
+    const result = [];
+    let currentGroup = [arr[0]];
 
-            if(typeof count !== 'undefined'){
-                c[countName] = splitCount(cross)
-            }
+    for (let i = 1; i < length; i++) {
+        const currentValue = arr[i];
+        const prevValue = arr[i - 1];
 
+        if (currentValue === prevValue) {
+            // Same value, continue the current group
+            currentGroup.push(currentValue);
         } else {
-            throw Error(`Missing ohlcv properties for ${fast} or ${slow}`);
+            // Value changed, finalize the current group and start a new one
+            result.push(currentGroup);
+            currentGroup = [currentValue];
         }
     }
 
-    return {x, c}
-}
+    // Push the last group
+    result.push(currentGroup);
+
+    return result;
+};

package/src/utilities/parsing-utilities.js

@@ -25,13 +25,13 @@ const indicatorFunctions = {
 const validateFirstDate = (arr) => arr[0].hasOwnProperty('date') && typeof arr[0].date === 'string' && /^\d{4}-\d{2}-\d{2}/.test(arr[0].date)
 
 export const defaultStudyOptions = {
-    midPriceOpenClose: false,
-    midPriceHighLow: false,
-    sessionIndex: false,
-    sessionIntradayIndex: false,
-    dayOfTheWeek: false,
-    dayOfTheMonth: false,
-    weekOfTheMonth: false
+    midPriceOpenClose: true,
+    midPriceHighLow: true,
+    sessionIndex: true,
+    sessionIntradayIndex: true,
+    dayOfTheWeek: true,
+    dayOfTheMonth: true,
+    weekOfTheMonth: true
 }
 
 const getDateInfo = (dateString) => {
@@ -49,8 +49,8 @@ const getDateInfo = (dateString) => {
     };
 }
 
-export const parseOhlcvToVertical = (input, main) => {
-    const { len, studyOptions, inputParams } = main
+export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
+    const { len, studyOptions = {}, inputParams } = main
 
     if (studyOptions) {
         const studyOptionKeys = Object.keys(studyOptions)
@@ -79,46 +79,70 @@ export const parseOhlcvToVertical = (input, main) => {
     const numberColsKeysSet = new Set(numberColsKeys)
     const vert = main.verticalOhlcv
 
-    // Initialize arrays for numerical columns
-    for (let i = 0; i < numberColsKeys.length; i++) {
-        vert[numberColsKeys[i]] = new Array(len)
-    }
+    let isValidDate = false
+    if (startIndex === 0) {
+        // Fresh initialization
+        // Initialize arrays for numerical columns
+        for (let i = 0; i < numberColsKeys.length; i++) {
+            vert[numberColsKeys[i]] = new Array(len)
+        }
 
-    // Extract other keys and initialize their arrays
-    const inputKeys = Object.keys(input[0])
-    const otherKeys = []
-    for (let i = 0; i < inputKeys.length; i++) {
-        const key = inputKeys[i]
-        if (!numberColsKeysSet.has(key)) {
-            vert[key] = new Array(len)
-            otherKeys.push(key)
+        // Extract other keys and initialize their arrays
+        const inputKeys = Object.keys(input[0])
+        const otherKeys = []
+        for (let i = 0; i < inputKeys.length; i++) {
+            const key = inputKeys[i]
+            if (!numberColsKeysSet.has(key)) {
+                vert[key] = new Array(len)
+                otherKeys.push(key)
+            }
         }
-    }
+        main.otherKeys = otherKeys
 
-    const isValidDate = validateFirstDate(input)
-    let prevDateStr
-    let sessionIndexCount = 0
-    let sessionIntradayIndexCount = 0
+        isValidDate = validateFirstDate(input)
 
-    // Initialize date-related arrays if necessary
-    if (isValidDate) {
-        if (sessionIndex) {
-            main.verticalOhlcv['session_index'] = new Array(len)
-        }
-        if (sessionIntradayIndex) {
-            main.verticalOhlcv['session_intraday_index'] = new Array(len)
-        }
-        if (dayOfTheWeek) {
-            main.verticalOhlcv['day_of_the_week'] = new Array(len)
+        if (isValidDate) {
+            if (sessionIndex) {
+                vert['session_index'] = new Array(len)
+            }
+            if (sessionIntradayIndex) {
+                vert['session_intraday_index'] = new Array(len)
+            }
+            if (dayOfTheWeek) {
+                vert['day_of_the_week'] = new Array(len)
+            }
+            if (dayOfTheMonth) {
+                vert['day_of_the_month'] = new Array(len)
+            }
+            if (weekOfTheMonth) {
+                vert['week_of_the_month'] = new Array(len)
+            }
+
+            main.prevDateStr = input[0].date.slice(0, 10)
+            main.sessionIndexCount = 0
+            main.sessionIntradayIndexCount = 0
+            main.cachedDayInfo = getDateInfo(main.prevDateStr)
+        } else {
+            // If no valid date, ensure these are null
+            main.prevDateStr = null
+            main.sessionIndexCount = null
+            main.sessionIntradayIndexCount = null
+            main.cachedDayInfo = null
         }
-        if (dayOfTheMonth) {
-            main.verticalOhlcv['day_of_the_month'] = new Array(len)
+    } else {
+        // startIndex > 0
+        // We assume arrays and keys are already set
+        if (!main.otherKeys) {
+            throw new Error("otherKeys not found in main. Ensure you run with startIndex=0 first to initialize.")
         }
-        if (weekOfTheMonth) {
-            main.verticalOhlcv['week_of_the_month'] = new Array(len)
+
+        // Validate that state variables needed are present
+        if (!main.hasOwnProperty('prevDateStr')) {
+            throw new Error("prevDateStr missing in main. Make sure to store state after initial run.")
         }
 
-        prevDateStr = input[0].date.slice(0, 10)
+        // If we had a valid date initially, we continue with date computations
+        isValidDate = main.prevDateStr !== null
     }
 
     // Pre-process indicator params
@@ -152,14 +176,19 @@ export const parseOhlcvToVertical = (input, main) => {
 
     // References for other keys arrays
     const otherArrays = {}
-    for (let i = 0; i < otherKeys.length; i++) {
-        const k = otherKeys[i]
+    for (let i = 0; i < main.otherKeys.length; i++) {
+        const k = main.otherKeys[i]
         otherArrays[k] = vert[k]
     }
 
-    // Cached date info for the current date
-    let cachedDayInfo = getDateInfo(prevDateStr) // initial date info if needed
-    for (let x = 0; x < len; x++) {
+    // For date/session logic, use previously stored state if startIndex > 0
+    let prevDateStr = main.prevDateStr
+    let sessionIndexCount = main.sessionIndexCount
+    let sessionIntradayIndexCount = main.sessionIntradayIndexCount
+    let cachedDayInfo = main.cachedDayInfo
+
+    // Compute indicators and fill data from startIndex to len
+    for (let x = startIndex; x < len; x++) {
         const current = input[x]
 
         // Assign OHLCV
@@ -184,8 +213,8 @@ export const parseOhlcvToVertical = (input, main) => {
         }
 
         // Other keys
-        for (let i = 0; i < otherKeys.length; i++) {
-            const k = otherKeys[i]
+        for (let i = 0; i < main.otherKeys.length; i++) {
+            const k = main.otherKeys[i]
             otherArrays[k][x] = current[k]
         }
 
@@ -200,26 +229,32 @@ export const parseOhlcvToVertical = (input, main) => {
             }
 
             if (dayOfTheWeek) {
-                main.verticalOhlcv.day_of_the_week[x] = cachedDayInfo.day_of_the_week
+                vert.day_of_the_week[x] = cachedDayInfo.day_of_the_week
             }
 
             if (dayOfTheMonth) {
-                main.verticalOhlcv.day_of_the_month[x] = cachedDayInfo.day_of_the_month
+                vert.day_of_the_month[x] = cachedDayInfo.day_of_the_month
             }
 
             if (weekOfTheMonth) {
-                main.verticalOhlcv.week_of_the_month[x] = cachedDayInfo.week_of_the_month
+                vert.week_of_the_month[x] = cachedDayInfo.week_of_the_month
             }
 
             if (sessionIndex) {
-                main.verticalOhlcv.session_index[x] = sessionIndexCount
+                vert.session_index[x] = sessionIndexCount
             }
 
             if (sessionIntradayIndex) {
-                main.verticalOhlcv.session_intraday_index[x] = sessionIntradayIndexCount
+                vert.session_intraday_index[x] = sessionIntradayIndexCount
             }
 
             sessionIntradayIndexCount++
         }
     }
+
+    // Store current state so that we can continue from here in subsequent calls
+    main.prevDateStr = prevDateStr
+    main.sessionIndexCount = sessionIndexCount
+    main.sessionIntradayIndexCount = sessionIntradayIndexCount
+    main.cachedDayInfo = cachedDayInfo
 }