ohlcv-indicators 2.0.4 → 2.0.6

package/src/moving-averages/bollingerBands.js

@@ -1,82 +1,132 @@
-import {FasterBollingerBands, FasterSMA} from 'trading-signals';
+import { FasterBollingerBands, FasterSMA } from 'trading-signals';
 import { classifySize } from '../utilities/classification.js';
 
-let defaultTarget = 'close'
-
-export const bollingerBands = (main, index, size, times, options) => {
-
-    const {height, range, target} = options
-    let suffix = (target === defaultTarget) ? '' : `_${target}`
-
-    if (index === 0) {
-
-        if(!main.verticalOhlcv.hasOwnProperty(target))
-        {
-            throw new Error(`bollingerBands could not find target "${target}"`)
-        }
-
-        Object.assign(main.instances, {
-            [`bollinger_bands${suffix}`]: {
-                instance: new FasterBollingerBands(size, times),
-                heightInstance: height ? new FasterSMA(size) : 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 defaultTarget = 'close';
 
-    
-    const { instance, heightInstance } = main.instances[`bollinger_bands${suffix}`]
-    const value = main.verticalOhlcv[target][index]
-    instance.update(value, main.lastIndexReplace)
+export const bollingerBands = (main, index, size, stdDev, options) => {
+  // Destructure options; ensure range and zScore default to empty arrays if not provided.
+  const { height, range = [], zScore = [], target } = options;
+  const suffix = target === defaultTarget ? '' : `_${target}`;
+  const indicatorKey = `${size}_${stdDev}${suffix}`;
+  let prefix; // Will be computed during initialization
 
-    let result;
-    try {
-        result = instance.getResult();
-    } catch (err) {
-       //do nothing
+  // Initialize indicator instances and output arrays on the first call.
+  if (index === 0) {
+    if (!(target in main.verticalOhlcv)) {
+      throw new Error(`bollingerBands could not find target "${target}"`);
     }
 
-    if(!result) return true
+    const numberOfIndicators = main.inputParams.filter(o => o.key === 'bollingerBands').length;
+    // Choose a prefix based on the number of indicators.
+    prefix = numberOfIndicators > 1
+      ? `bollinger_bands_${indicatorKey}`
+      : `bollinger_bands${suffix}`;
+
+    // Ensure the container exists.
+    if (!main.instances.bollinger_bands) {
+      main.instances.bollinger_bands = {
+        numberOfIndicators,
+        settings: {}
+      };
+    }
 
-    const { upper, middle, lower } = result;
-    main.verticalOhlcv[`bollinger_bands_upper${suffix}`][index] = upper;
-    main.verticalOhlcv[`bollinger_bands_middle${suffix}`][index] = middle;
-    main.verticalOhlcv[`bollinger_bands_lower${suffix}`][index] = lower;
+    // Create the Bollinger Bands (and optional height) indicator instance.
+    main.instances.bollinger_bands.settings[indicatorKey] = {
+      instance: new FasterBollingerBands(size, stdDev),
+      heightInstance: height >= size ? new FasterSMA(height) : null
+    };
 
-    if (!height && !range) return true;
+    // Build the base output arrays.
+    const ohlcvSetup = {
+      [`${prefix}_upper`]: [...main.nullArray],
+      [`${prefix}_middle`]: [...main.nullArray],
+      [`${prefix}_lower`]: [...main.nullArray],
+      ...(height >= size && { [`${prefix}_height`]: [...main.nullArray] })
+    };
 
-    let rangeValue = null;
-    let heightValue = null;
-    let heightMean;
 
-    rangeValue = (value - lower) / (upper - lower);
-    heightValue = upper - lower;
 
-    heightInstance.update(heightValue, main.lastIndexReplace);
 
-    try {
-        heightMean = heightInstance.getResult();
-    } catch (err) {
-        //do nothing
+    // Set up additional arrays for each range property.
+    for (const rangeKey of range) {
+      if (!(rangeKey in main.verticalOhlcv) || !main.priceBased.includes(rangeKey)) {
+        throw new Error(`Invalid range item value "${rangeKey}" property for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`);
+      }
+      ohlcvSetup[`${prefix}_range_${rangeKey}`] = [...main.nullArray];
     }
 
-    main.verticalOhlcv[`bollinger_bands_range${suffix}`][index] = rangeValue;
+    // Set up additional arrays for each zScore property.
+    for (const zScoreKey of zScore) {
+      if (!(zScoreKey in main.verticalOhlcv) || !main.priceBased.includes(zScoreKey)) {
+        throw new Error(`Invalid zScore item value "${zScoreKey}" for bollingerBands. Only price based key names are accepted:\n${JSON.stringify(main.priceBased)}`);
+      }
+      ohlcvSetup[`${prefix}_zscore_${zScoreKey}`] = [...main.nullArray];
+    }
 
-    if(heightMean)
-    {
-        main.verticalOhlcv[`bollinger_bands_height${suffix}`][index] = classifySize(heightValue, heightMean, 1.5);
+    // Merge the new arrays into verticalOhlcv.
+    Object.assign(main.verticalOhlcv, ohlcvSetup);
+  }
+
+  // For subsequent calls, if prefix wasn’t computed (i.e. index > 0), derive it.
+  if (!prefix) {
+    const num = main.instances.bollinger_bands.numberOfIndicators;
+    prefix = num > 1 ? `bollinger_bands_${indicatorKey}` : `bollinger_bands${suffix}`;
+  }
+  // Use the same prefix for output keys.
+  const subPrefix = prefix;
+
+  // Retrieve the indicator instance(s) and update with the current value.
+  const { instance, heightInstance } = main.instances.bollinger_bands.settings[indicatorKey];
+  const value = main.verticalOhlcv[target][index];
+  instance.update(value, main.lastIndexReplace);
+
+  let result;
+  try {
+    result = instance.getResult();
+  } catch (err) {
+    // If the result is not available yet, simply exit.
+  }
+  if (!result) return true;
+
+  const { upper, middle, lower } = result;
+  main.pushToMain({index, key: `${subPrefix}_upper`, value: upper})
+  main.pushToMain({index, key: `${subPrefix}_middle`, value: middle})
+  main.pushToMain({index, key: `${subPrefix}_lower`, value: lower})
+
+  // Exit early if neither height nor range are requested.
+  if (!height && !range) return true;
+
+  // Process height if a height instance exists.
+  if (heightInstance) {
+    const heightValue = upper - lower;
+    heightInstance.update(heightValue, main.lastIndexReplace);
+    let heightMean;
+    try {
+      heightMean = heightInstance.getResult();
+    } catch (err) {
+      // Swallow error if the height result is not ready.
+    }
+    if (heightMean) {
+      main.pushToMain({index, key: `${subPrefix}_height`, value: classifySize(heightValue, heightMean, 0.5, 7)})
     }
-    
-    return true;
+  }
+
+  // Process each range property.
+  for (const rangeKey of range) {
+    const rangeValue = (main.verticalOhlcv[rangeKey][index] - lower) / (upper - lower);
+    main.pushToMain({index, key: `${subPrefix}_range_${rangeKey}`, value: rangeValue})
+  }
+
+  // Process each zScore property.
+  for (const zScoreKey of zScore) {
+    const denominator = upper - lower;
+    const zScoreValue = denominator !== 0
+      ? (2 * stdDev * (main.verticalOhlcv[zScoreKey][index] - middle)) / denominator
+      : 0;
+
+      
+    main.pushToMain({index, key: `${subPrefix}_zscore_${zScoreKey}`, value: zScoreValue})
+  }
+
+  return true;
 };

package/src/moving-averages/donchianChannel.js

@@ -1,43 +1,112 @@
-export const donchianChannels = (main, index, size, offset) => {
+import { FasterSMA } from 'trading-signals';
+import { classifySize } from '../utilities/classification.js';
 
-    const highs = main.verticalOhlcv.high;
-    const lows = main.verticalOhlcv.low;
+export const donchianChannels = (main, index, size, offset, options) => {
+  const { height, range } = options;
+  const indicatorKey = `${size}_${offset}`;
 
-    // Ensure that the required arrays exist
-    if (index === 0) {
+  // Initialization: create output arrays and indicator instance on the first call.
+  if (index === 0) {
+    const numberOfIndicators = main.inputParams.filter(o => o.key === 'donchianChannels').length;
+    const prefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
 
-        Object.assign(main.verticalOhlcv, {
-            donchian_channel_upper: [...main.nullArray],
-            donchian_channel_basis: [...main.nullArray],
-            donchian_channel_lower: [...main.nullArray],
-        })
+    Object.assign(main.verticalOhlcv, {
+      [`${prefix}_upper`]: [...main.nullArray],
+      [`${prefix}_basis`]: [...main.nullArray],
+      [`${prefix}_lower`]: [...main.nullArray],
+      ...(height && { [`${prefix}_height`]: [...main.nullArray] }),
+      ...(range && { [`${prefix}_range`]: [...main.nullArray] })
+    });
+
+    if (!main.instances.hasOwnProperty('donchian_channel')) {
+      main.instances.donchian_channel = { numberOfIndicators, settings: {} };
     }
 
+    // In addition to your heightInstance, also initialize deques for highs and lows.
+    main.instances.donchian_channel.settings[indicatorKey] = {
+      heightInstance: height
+        ? new FasterSMA(typeof height === 'number' && height > 0 ? height : size)
+        : null,
+      maxDeque: [], // will hold indices for highs in descending order
+      minDeque: []  // will hold indices for lows in ascending order
+    };
+  }
+
+  const numberOfIndicators = main.instances.donchian_channel.numberOfIndicators;
+  const subPrefix = numberOfIndicators > 1 ? `donchian_channel_${indicatorKey}` : 'donchian_channel';
+  const state = main.instances.donchian_channel.settings[indicatorKey];
+  const { heightInstance, maxDeque, minDeque } = state;
+
+  // Compute the “current bar index” for the window.
+  // Note: We use index - offset so that the window is built on the proper part of the array.
+  const currentBarIdx = index - offset;
+  const endIdx = currentBarIdx + 1;    // currentBarIdx is inclusive
+  const startIdx = endIdx - size;        // window: [startIdx, endIdx)
+
+  // If the window is not fully available, exit early.
+  if (startIdx < 0 || endIdx > main.len) return true;
 
-    // Compute the slice start and end to get exactly 'size' bars
-    const endIdx = (index - offset) + 1;          // inclusive end of the slice
-    const startIdx = endIdx - size;             // start index for slicing
+  const highs = main.verticalOhlcv.high;
+  const lows = main.verticalOhlcv.low;
 
-    // If any of these indices is out of bounds, return
-    if (startIdx < 0 || endIdx > main.len) return true;
+  // **Update the maximum deque:**
+  // Remove indices that are out of the current window.
+  while (maxDeque.length && maxDeque[0] < startIdx) {
+    maxDeque.shift();
+  }
+  // Remove indices whose corresponding high value is less than or equal to the current high.
+  while (maxDeque.length && highs[maxDeque[maxDeque.length - 1]] <= highs[currentBarIdx]) {
+    maxDeque.pop();
+  }
+  // Add the current index.
+  maxDeque.push(currentBarIdx);
 
-    // Extract the relevant chunks of data
-    const highChunk = highs.slice(startIdx, endIdx)
-    const lowChunk = lows.slice(startIdx, endIdx)
+  // **Update the minimum deque:**
+  // Remove indices that are out of the current window.
+  while (minDeque.length && minDeque[0] < startIdx) {
+    minDeque.shift();
+  }
+  // Remove indices whose corresponding low value is greater than or equal to the current low.
+  while (minDeque.length && lows[minDeque[minDeque.length - 1]] >= lows[currentBarIdx]) {
+    minDeque.pop();
+  }
+  // Add the current index.
+  minDeque.push(currentBarIdx);
 
-    // Compute the Donchian channels
-    const upper = Math.max(...highChunk);
-    const lower = Math.min(...lowChunk);
-    const basis = (upper + lower) / 2;
+  // Now the maximum high is at the front of maxDeque and the minimum low is at the front of minDeque.
+  const upper = highs[maxDeque[0]];
+  const lower = lows[minDeque[0]];
+  const basis = (upper + lower) / 2;
+  const close = main.verticalOhlcv.close[index];
+  const rangeValue = (close - lower) / (upper - lower);
+  const heightValue = upper - lower;
 
-    // Place the result at index
-    const placementIndex = index;
+  // Update the height indicator if requested.
+  if (height && heightInstance) {
+    heightInstance.update(heightValue, main.lastIndexReplace);
+  }
+
+  // Update the computed values in the output arrays.
+
+  main.pushToMain({index, key: `${subPrefix}_upper`, value: upper})
+  main.pushToMain({index, key: `${subPrefix}_basis`, value: basis})
+  main.pushToMain({index, key: `${subPrefix}_lower`, value: lower})
+
+  if (range) {
+    main.pushToMain({index, key: `${subPrefix}_range`, value: rangeValue})
+  }
+  if (height && heightInstance) {
+    let heightMean;
+    try {
+      heightMean = heightInstance.getResult();
+    } catch (err) {
+      // Ignore errors if the result isn't ready.
+    }
+    if (heightMean) {
 
-    if (placementIndex >= 0 && placementIndex < main.len) {
-        main.verticalOhlcv['donchian_channel_upper'][placementIndex] = upper;
-        main.verticalOhlcv['donchian_channel_basis'][placementIndex] = basis;
-        main.verticalOhlcv['donchian_channel_lower'][placementIndex] = lower;
+      main.pushToMain({index, key: `${subPrefix}_height`, value: classifySize(heightValue, heightMean, 1.5)})
     }
+  }
 
-    return true;
+  return true;
 };

package/src/moving-averages/ema.js

@@ -26,7 +26,7 @@ export const ema = (main, index, size, target) => {
 
   if(currEma)
   {
-    main.verticalOhlcv[keyName][index] = currEma
+    main.pushToMain({index, key: keyName, value: currEma})
   }
 
 }

package/src/moving-averages/macd.js

@@ -1,27 +1,56 @@
 import {FasterEMA, FasterMACD} from 'trading-signals';
 
-export const macd = (main, index, fast, slow, signal) => {
+const defaultTarget = 'close'
 
-    const value = main.verticalOhlcv.close[index]
+export const macd = (main, index, fast, slow, signal, options) => {
+
+    const {target} = options
+    const suffix = target === defaultTarget ? '' : `_${target}`;
+    const indicatorKey = `${fast}_${slow}_${signal}${suffix}`;
 
     if (index === 0) {
 
-        main.crossPairsList.push({fast: 'macd_diff', slow: 'macd_dea', isDefault: true});
+        if(!main.verticalOhlcv.hasOwnProperty(target))
+        {
+            throw new Error(`Target property ${target} not found in verticalOhlcv for macd.`)
+        }
+
+        const numberOfIndicators = main.inputParams.filter(o => o.key === 'macd').length;
+        const prefix =
+          numberOfIndicators > 1
+            ? `macd_${indicatorKey}`
+            : `macd${suffix}`;
+
+        main.crossPairsList.push({fast: `${prefix}_diff`, slow: `${prefix}_dea`, isDefault: true});
+
+        if(!main.instances.hasOwnProperty('macd'))
+        {
+            main.instances.macd = {
+                numberOfIndicators,
+                settings: {}
+              }
+        }
 
-        main.instances['macd'] = new FasterMACD(
+        main.instances.macd.settings[indicatorKey] = new FasterMACD(
             new FasterEMA(fast),
             new FasterEMA(slow),
             new FasterEMA(signal)
         );
 
         Object.assign(main.verticalOhlcv, {
-            macd_diff: [...main.nullArray],
-            macd_dea: [...main.nullArray],
-            macd_histogram: [...main.nullArray],
+            [`${prefix}_diff`]: [...main.nullArray],
+            [`${prefix}_dea`]: [...main.nullArray],
+            [`${prefix}_histogram`]: [...main.nullArray],
         })
     }
 
-    const macdInstance = main.instances[`macd`];
+    
+    const subPrefix = main.instances.macd.numberOfIndicators > 1
+        ? `macd_${indicatorKey}`
+        : `macd${suffix}`;
+
+    const macdInstance = main.instances.macd.settings[indicatorKey];
+    const value = main.verticalOhlcv[target][index]
     macdInstance.update(value, main.lastIndexReplace);
 
     let macdResult;
@@ -34,9 +63,10 @@ export const macd = (main, index, fast, slow, signal) => {
 
 
     if (macdResult) {
-        main.verticalOhlcv['macd_diff'][index] = macdResult.macd;
-        main.verticalOhlcv['macd_dea'][index] = macdResult.signal;
-        main.verticalOhlcv['macd_histogram'][index] = macdResult.histogram;
+
+        main.pushToMain({index, key: `${subPrefix}_diff`, value: macdResult.macd})
+        main.pushToMain({index, key: `${subPrefix}_dea`, value: macdResult.signal})
+        main.pushToMain({index, key: `${subPrefix}_histogram`, value: macdResult.histogram})
     }
 
     return true;

package/src/moving-averages/relativeVolume.js

@@ -2,39 +2,43 @@ import {FasterSMA} from 'trading-signals';
 
 export const relativeVolume = (main, index, size = 10) => {
 
-    const value = main.verticalOhlcv.volume[index]
+    const key = `relative_volume_${size}`
 
     if (index === 0) {
-        main.instances[`relative_volume_${size}`] = {
+        main.instances[key] = {
             instance: new FasterSMA(size),
             prevRelativeVolumeSma: null
         }
 
         Object.assign(main.verticalOhlcv, {
-            [`relative_volume_${size}`]: [...main.nullArray],
+            [key]: [...main.nullArray],
         })
     }
 
-    const smaInstance = main.instances[`relative_volume_${size}`].instance
+
+    const value = main.verticalOhlcv.volume[index]
+    
+    const smaInstance = main.instances[key].instance
     smaInstance.update(value, main.lastIndexReplace)
 
     let smaValue;
     try {
         smaValue = smaInstance.getResult()
+
+        
     } catch (err) {
         //do nothing
     }
 
-    const {prevRelativeVolumeSma} = main.instances[`relative_volume_${size}`]
-
-    if (smaValue !== null && prevRelativeVolumeSma !== null) {
-        main.verticalOhlcv[`relative_volume_${size}`][index] = value / prevRelativeVolumeSma;
-    } else {
-        main.verticalOhlcv[`relative_volume_${size}`][index] = null;
-    }
+    const {prevRelativeVolumeSma} = main.instances[key]
 
+    main.pushToMain({
+        index, 
+        key,
+        value: (smaValue !== null && prevRelativeVolumeSma !== null) ? value / prevRelativeVolumeSma : null
+    })
 
-    main.instances[`relative_volume_${size}`].prevRelativeVolumeSma = smaValue
+    main.instances[key].prevRelativeVolumeSma = smaValue
 
     return true;
 };

package/src/moving-averages/sma.js

@@ -27,7 +27,7 @@ export const sma = (main, index, size, target) => {
 
   if(currSma)
   {
-    main.verticalOhlcv[keyName][index] = currSma
+    main.pushToMain({index, key: keyName, value: currSma})
   }
 
 }

package/src/oscillators/rsi.js

@@ -35,7 +35,7 @@ export const rsi = (main, index, size) => {
     
     if(currentRsi)
     {
-        main.verticalOhlcv[`rsi_${size}`][index] = currentRsi
+        main.pushToMain({index, key: `rsi_${size}`, value: currentRsi})
         main.instances[`rsi_sma_${size}`].update(currentRsi, main.lastIndexReplace)
     }
 
@@ -49,7 +49,7 @@ export const rsi = (main, index, size) => {
 
     if(smoothedRsi)
     {
-        main.verticalOhlcv[`rsi_sma_${size}`][index] = smoothedRsi
+        main.pushToMain({index, key: `rsi_sma_${size}`, value: smoothedRsi})
     }
 
     return true

package/src/oscillators/volumeOscillator.js

@@ -3,6 +3,7 @@ import { FasterEMA } from 'trading-signals';
 export const volumeOscillator = (main, index, fast, slow) => {
 
     const value = main.verticalOhlcv.volume[index]
+    const key = 'volume_oscillator'
 
     if (index === 0) {
 
@@ -13,11 +14,11 @@ export const volumeOscillator = (main, index, fast, slow) => {
             }
         })
 
-        main.verticalOhlcv[`volume_oscillator`] = [...main.nullArray];
-        main.crossPairsList.push({ fast: `volume_oscillator`, slow: 0, isDefault: true });
+        main.verticalOhlcv[key] = [...main.nullArray];
+        main.crossPairsList.push({ fast: key, slow: 0, isDefault: true });
     }
 
-    const { fastEMA, slowEMA } = main.instances[`volume_oscillator`];
+    const { fastEMA, slowEMA } = main.instances[key];
 
     fastEMA.update(value, main.lastIndexReplace);
     slowEMA.update(value, main.lastIndexReplace);
@@ -38,9 +39,10 @@ export const volumeOscillator = (main, index, fast, slow) => {
     }
 
     if (typeof fastValue === 'number' && typeof slowValue === 'number' && slowValue !== 0) {
-        main.verticalOhlcv[`volume_oscillator`][index] = 100 * (fastValue - slowValue) / slowValue
+
+        main.pushToMain({index, key, value:  100 * (fastValue - slowValue) / slowValue})
     } else {
-        main.verticalOhlcv[`volume_oscillator`][index] = null;
+        main.pushToMain({index, key, value:  null})
     }
 
     return true;

package/src/studies/candleStudies.js

@@ -112,45 +112,54 @@ export const candleStudies = (main, index, size, classify = true, classification
             // If there's not enough data, means remain null
         }
 
-        main.verticalOhlcv.candle_body_size[index] = isUp
-            ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
-            : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0;
+        main.pushToMain({
+            index, 
+            key: 'candle_body_size', 
+            value: isUp 
+                ? classifySize(candleBodySize, bodySizeMean, 2, changeLevel)
+                : -Math.abs(classifySize(candleBodySize, bodySizeMean, 2, changeLevel)) || 0
+        })
+
+        
 
-        main.verticalOhlcv.candle_gap_size[index] = isUp
+        main.pushToMain({index, key: 'candle_gap_size', value: isUp
             ? classifySize(gapSize, gapMean, 2, changeLevel)
-            : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(gapSize, gapMean, 2, changeLevel)) || 0})
+
 
-        main.verticalOhlcv.candle_close_direction[index] = isUp
+        main.pushToMain({index, key: 'candle_close_direction', value: isUp
             ? classifySize(closeDirection, closeDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(closeDirection, closeDirectionMean, 2, changeLevel)) || 0})
 
-        main.verticalOhlcv.candle_high_direction[index] = isUp
+
+        main.pushToMain({index, key: 'candle_high_direction', value: isUp
             ? classifySize(highDirection, highDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(highDirection, highDirectionMean, 2, changeLevel)) || 0})
 
-        main.verticalOhlcv.candle_low_direction[index] = isUp
+        main.pushToMain({index, key: 'candle_low_direction', value: isUp
             ? classifySize(lowDirection, lowDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(lowDirection, lowDirectionMean, 2, changeLevel)) || 0})
 
-        main.verticalOhlcv.candle_open_direction[index] = isUp
+        main.pushToMain({index, key: 'candle_open_direction', value: isUp
             ? classifySize(openDirection, openDirectionMean, 2, changeLevel)
-            : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0;
+            : -Math.abs(classifySize(openDirection, openDirectionMean, 2, changeLevel)) || 0})
+
+        main.pushToMain({index, key: 'candle_top_size', value: classifySize(topSize, topSizeMean, 0.5, sizeLevel)})
+        main.pushToMain({index, key: 'candle_bottom_size', value: classifySize(bottomSize, bottomSizeMean, 0.5, sizeLevel)})
+        main.pushToMain({index, key: 'candle_shadow_size', value: 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.pushToMain({index, key: 'candle_body_size', value: isUp ? candleBodySize : -candleBodySize})
+        main.pushToMain({index, key: 'candle_gap_size', value: isUp ? gapSize : -gapSize})
+        main.pushToMain({index, key: 'candle_close_direction', value: isUp ? closeDirection : -closeDirection})
+        main.pushToMain({index, key: 'candle_high_direction', value: isUp ? highDirection : -highDirection})
+        main.pushToMain({index, key: 'candle_low_direction', value: isUp ? lowDirection : -lowDirection})
+        main.pushToMain({index, key: 'candle_open_direction', value: isUp ? openDirection : -openDirection})
+        main.pushToMain({index, key: 'candle_top_size', value: topSize})
+        main.pushToMain({index, key: 'candle_bottom_size', value: bottomSize})
+        main.pushToMain({index, key: 'candle_shadow_size', value: shadowSize})
     }
 
     return true;

package/src/studies/dateTime.js

@@ -48,15 +48,14 @@ export const dateTime = (main, index) => {
         main.instances.dateTime.sessionIntradayIndexCount = 0
     }
 
-
-    main.verticalOhlcv.session_daily_index[index] = main.instances.dateTime.sessionDailyIndexCount
-    main.verticalOhlcv.session_intraday_index[index] =  main.instances.dateTime.sessionIntradayIndexCount
-    main.verticalOhlcv.day_of_the_week[index] = day_of_the_week
-    main.verticalOhlcv.day_of_the_month[index] = day_of_the_month
-    main.verticalOhlcv.week_of_the_month[index] = week_of_the_month
-    main.verticalOhlcv.month[index] = month
-    main.verticalOhlcv.year[index] = year
-    main.verticalOhlcv.hour[index] = hour
+    main.pushToMain({index, key: 'session_daily_index', value:  main.instances.dateTime.sessionDailyIndexCount})
+    main.pushToMain({index, key: 'session_intraday_index', value: main.instances.dateTime.sessionIntradayIndexCount})
+    main.pushToMain({index, key: 'day_of_the_week', value: day_of_the_week})
+    main.pushToMain({index, key: 'day_of_the_month', value: day_of_the_month})
+    main.pushToMain({index, key: 'week_of_the_month', value: week_of_the_month})
+    main.pushToMain({index, key: 'month', value: month})
+    main.pushToMain({index, key: 'year', value: year})
+    main.pushToMain({index, key: 'hour', value: hour})
 
 }