ohlcv-indicators 2.1.9 → 2.2.1

package/src/moving-averages/movingAverages.js

@@ -4,102 +4,106 @@ import { classifyBoll } from '../utilities/classification.js'
 
 const indicatorClasses = {ema: FasterEMA, sma: FasterSMA} 
 
-export const movingAverages = (main, index, indicatorName, size, {target, diff}) => {
-
-  const {verticalOhlcv, instances, priceBased, lastIndexReplace} = main
-  let suffix =  (typeof target === 'string' && verticalOhlcv.hasOwnProperty(target) && target !== 'close') ? `_${target}` : ''
-  const keyName = `${indicatorName}_${size}${suffix}`
-  const diffKeyName = `${indicatorName}_${size}_diff${suffix}`
-
-  if(index === 0)
-  {
-      const {nullArray} = main
-
-      if(!verticalOhlcv.hasOwnProperty(target))
-      {
-          throw new Error(`Target property ${target} not found in verticalOhlcv for ${indicatorName}.`)
-      }
+export const movingAverages = (main, index, indicatorName, size, { target, diff }) => {
+  const { verticalOhlcv, instances, priceBased, lastIndexReplace } = main;
+  let suffix =
+    typeof target === 'string' &&
+    verticalOhlcv.hasOwnProperty(target) &&
+    target !== 'close'
+      ? `_${target}`
+      : '';
+  const keyName = `${indicatorName}_${size}${suffix}`;
+  const diffKeyName = `${indicatorName}_${size}_diff${suffix}`;
+
+  if (index === 0) {
+    const { nullArray } = main;
+
+    if (!verticalOhlcv.hasOwnProperty(target)) {
+      throw new Error(
+        `Target property ${target} not found in verticalOhlcv for ${indicatorName}.`
+      );
+    }
 
-      instances[keyName] = {
-        maInstance: new indicatorClasses[indicatorName](size)
-      }
+    // Create the main moving average instance.
+    instances[keyName] = {
+      maInstance: new indicatorClasses[indicatorName](size)
+    };
 
-      verticalOhlcv[keyName] = [...nullArray]
+    verticalOhlcv[keyName] = [...nullArray];
 
-      if(diff !== null)
-      {
-        instances[keyName].diffInstance = new FasterBollingerBands(diff.size, diff.stdDev)
+    // If diff configuration is provided, create the diff indicator.
+    if (diff !== null) {
+      instances[keyName].diffInstance = new FasterBollingerBands(
+        diff.size,
+        diff.stdDev
+      );
 
-        const lagDiffArr = []
+      const lagDiffArr = [];
 
-        for(const targetKey of diff.targets)
-        {
-          verticalOhlcv[`${diffKeyName}_${targetKey}`] = [...nullArray]
+      for (const targetKey of diff.targets) {
+        verticalOhlcv[`${diffKeyName}_${targetKey}`] = [...nullArray];
 
-          if(diff.lag > 0)
-          {
-            lagDiffArr.push(`${diffKeyName}_${targetKey}`)
-          }
+        if (diff.lag > 0) {
+          lagDiffArr.push(`${diffKeyName}_${targetKey}`);
         }
+      }
 
-        if(diff.lag > 0)
-        {
-          console.log(lagDiffArr, diff.lag)
-          main.lag(lagDiffArr, diff.lag)
-        }
+      if (diff.lag > 0) {
+        main.lag(lagDiffArr, diff.lag);
       }
+    }
 
-      priceBased.push(keyName)
+    priceBased.push(keyName);
   }
 
-  const value = verticalOhlcv[target][index]
-  const {maInstance, diffInstance} = instances[keyName]
-  maInstance.update(value, lastIndexReplace)
-
-  let currMa
-
-  try{
-    currMa = maInstance.getResult()
-  } catch(err)
-  {
-    //do nothing
+  // Retrieve the current price value.
+  const value = verticalOhlcv[target][index];
+  const { maInstance, diffInstance } = instances[keyName];
+
+  // Update the moving average instance.
+  maInstance.update(value, lastIndexReplace);
+  let currMa = null;
+  try {
+    currMa = maInstance.getResult();
+  } catch (err) {
+    currMa = null;
   }
 
-  if(currMa)
-  {
-    main.pushToMain({index, key: keyName, value: currMa})
-
-    if(diff === null)
-    {
-      return true
-    }
+  // Always push the MA value (even if null).
+  main.pushToMain({ index, key: keyName, value: currMa });
 
-    for(const targetKey of diff.targets)
-    {
-
-      const diffValue = (target === targetKey) ? value - currMa : verticalOhlcv[targetKey][index]
-
-      diffInstance.update(Math.abs(diffValue), lastIndexReplace)
+  // Process the diff values if a diff is requested.
+  if (diff !== null) {
+    for (const targetKey of diff.targets) {
+      // Compute diffValue only if we have a valid MA value.
+      let diffValue = null;
+      if (currMa !== null && typeof currMa === 'number') {
+        diffValue = target === targetKey ? value - currMa : verticalOhlcv[targetKey][index];
+      }
 
-      let diffBoll
+      // Update the diff indicator only if diffValue is a valid number.
+      if (diffValue !== null && typeof diffValue === 'number') {
+        diffInstance.update(Math.abs(diffValue), lastIndexReplace);
+      }
 
+      let diffBoll = null;
       try {
-        diffBoll = diffInstance.getResult()
-      } catch(err)
-      {
-        diffBoll = null
+        diffBoll = diffInstance.getResult();
+      } catch (err) {
+        diffBoll = null;
       }
 
-      main.pushToMain({index, key: `${diffKeyName}_${targetKey}`, value: classifyBoll(diffValue, diffBoll, diff.scale)})      
-
+      const classified = classifyBoll(diffValue, diffBoll, diff.scale);
+      main.pushToMain({
+        index,
+        key: `${diffKeyName}_${targetKey}`,
+        value: classified
+      });
     }
-
-
-
   }
 
-}
-
+  return true;
+};
 
 
 export const getMovingAveragesParams = (indicatorName, size, options, validMagnitudeValues) => {

package/src/moving-averages/relativeVolume.js

@@ -1,61 +1,43 @@
-import {FasterSMA} from 'trading-signals';
+import { FasterSMA } from 'trading-signals';
 import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-export const relativeVolume = (main, index, size = 10, {scale}) => {
-
-    const key = `relative_volume_${size}`
-    const {instances, verticalOhlcv, lastIndexReplace} = main
-
-    if (index === 0) {
-
-        const {nullArray} = main
-
-        instances[key] = {
-            instance: new FasterSMA(size),
-            prevRelativeVolumeSma: null
-        }
-
-        Object.assign(verticalOhlcv, {
-            [key]: [...nullArray],
-        })
-    }
-
-
-    const value = verticalOhlcv.volume[index]
-    
-    const smaInstance = instances[key].instance
-    smaInstance.update(value, lastIndexReplace)
-
-    let smaValue;
-    try {
-        smaValue = smaInstance.getResult()
-
-        
-    } catch (err) {
-        //do nothing
-    }
-
-    const {prevRelativeVolumeSma} = instances[key]
-
-    let currRelativeVolume = null
-
-    if(smaValue !== null && prevRelativeVolumeSma !== null && typeof smaValue !== 'undefined' && prevRelativeVolumeSma !== 'undefined')
-    {
-        currRelativeVolume = value / prevRelativeVolumeSma
-
-        if(scale)
-        {
-            currRelativeVolume = calcMagnitude(currRelativeVolume, scale)
-        }
+export const relativeVolume = (main, index, size = 10, { scale }) => {
+  const key = `relative_volume_${size}`;
+  const { instances, verticalOhlcv, lastIndexReplace } = main;
+
+  if (index === 0) {
+    const { nullArray } = main;
+    instances[key] = {
+      instance: new FasterSMA(size),
+      prevRelativeVolumeSma: null
+    };
+    verticalOhlcv[key] = [...nullArray];
+  }
+
+  const value = verticalOhlcv.volume[index];
+  const smaInstance = instances[key].instance;
+  smaInstance.update(value, lastIndexReplace);
+
+  let smaValue = null;
+  try {
+    smaValue = smaInstance.getResult();
+  } catch (err) {
+    smaValue = null;
+  }
+
+  const prevSma = instances[key].prevRelativeVolumeSma;
+  let currRelativeVolume = null;
+
+  // Only calculate relative volume if both current SMA and previous SMA are valid numbers and prevSma is not zero.
+  if (typeof smaValue === 'number' && typeof prevSma === 'number' && prevSma !== 0) {
+    currRelativeVolume = value / prevSma;
+    if (scale) {
+      currRelativeVolume = calcMagnitude(currRelativeVolume, scale);
     }
+  }
 
-    main.pushToMain({
-        index, 
-        key,
-        value: currRelativeVolume
-    })
-
-    instances[key].prevRelativeVolumeSma = smaValue
+  main.pushToMain({ index, key, value: currRelativeVolume });
+  instances[key].prevRelativeVolumeSma = smaValue;
 
-    return true;
+  return true;
 };

package/src/oscillators/rsi.js

@@ -1,77 +1,71 @@
-import {FasterRSI} from 'trading-signals';
+import { FasterRSI } from 'trading-signals';
 import { FasterSMA } from 'trading-signals';
 import { calcMagnitude } from '../utilities/numberUtilities.js';
 
-const defaultTarget = 'close'
+const defaultTarget = 'close';
 
-export const rsi = (main, index, size, {scale, target}) => {
-    
-    const {verticalOhlcv, instances, lastIndexReplace} = main
-    const suffix = (target === defaultTarget) ? '' : `_${target}`
-    const rsiKey = `rsi_${size}${suffix}`
-    const rsiSmaKey = `rsi_sma_${size}${suffix}`
+export const rsi = (main, index, size, { scale, target }) => {
+  const { verticalOhlcv, instances, lastIndexReplace } = main;
+  const suffix = target === defaultTarget ? '' : `_${target}`;
+  const rsiKey = `rsi_${size}${suffix}`;
+  const rsiSmaKey = `rsi_sma_${size}${suffix}`;
 
-    if(index === 0)
-    {
-        const {crossPairsList, nullArray} = main
+  // Initialization on the first index.
+  if (index === 0) {
+    const { crossPairsList, nullArray } = main;
 
-        if(!verticalOhlcv.hasOwnProperty(target))
-        {
-            throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`)
-        }
+    if (!verticalOhlcv.hasOwnProperty(target)) {
+      throw new Error(`Target property ${target} not found in verticalOhlcv for rsi.`);
+    }
 
-        crossPairsList.push({fast: rsiKey, slow: rsiSmaKey, isDefault: true})
+    crossPairsList.push({ fast: rsiKey, slow: rsiSmaKey, isDefault: true });
 
-        Object.assign(instances, {
-            [rsiKey]: new FasterRSI(size),
-            [rsiSmaKey]: new FasterSMA(size)
-        })
+    Object.assign(instances, {
+      [rsiKey]: new FasterRSI(size),
+      [rsiSmaKey]: new FasterSMA(size)
+    });
 
-        Object.assign(verticalOhlcv, {
-            [rsiKey]: [...nullArray],
-            [rsiSmaKey]: [...nullArray],
-        })
-    }
+    Object.assign(verticalOhlcv, {
+      [rsiKey]: [...nullArray],
+      [rsiSmaKey]: [...nullArray],
+    });
+  }
 
-    const value = verticalOhlcv[target][index]
-    let currentRsi
-    let smoothedRsi
+  const value = verticalOhlcv[target][index];
+  let currentRsi = null;
+  let smoothedRsi = null;
 
-    instances[rsiKey].update(value, lastIndexReplace)
+  // Update the RSI indicator.
+  instances[rsiKey].update(value, lastIndexReplace);
 
-    try
-    {
-        currentRsi = instances[rsiKey].getResult()
-    } catch(err) {
-        currentRsi = null
-    }
-    
-    if(currentRsi)
-    {
-        if(scale)
-        {
-            currentRsi = calcMagnitude(currentRsi, scale)
-        }
-
-        main.pushToMain({index, key: rsiKey, value: currentRsi})
-        instances[rsiSmaKey].update(currentRsi, lastIndexReplace)
-    }
+  try {
+    currentRsi = instances[rsiKey].getResult();
+  } catch (err) {
+    currentRsi = null;
+  }
 
-    try
-    {
-        smoothedRsi = instances[rsiSmaKey].getResult()
-    } catch(err)
-    {
-        smoothedRsi = null
-    }
+  if (currentRsi !== null && typeof currentRsi === 'number' && scale) {
+    currentRsi = calcMagnitude(currentRsi, scale);
+  }
 
-    if(smoothedRsi)
-    {
-        if(scale)
-        {
-            smoothedRsi = calcMagnitude(smoothedRsi, scale)
-        }
+  // Always push the RSI value, using null as a fallback.
+  main.pushToMain({ index, key: rsiKey, value: currentRsi });
 
-        main.pushToMain({index, key: rsiSmaKey, value: smoothedRsi})
-    }
-}
+  // Update the SMA indicator only if a valid RSI value is available.
+  if (currentRsi !== null && typeof currentRsi === 'number') {
+    instances[rsiSmaKey].update(currentRsi, lastIndexReplace);
+  }
+
+  try {
+    smoothedRsi = instances[rsiSmaKey].getResult();
+  } catch (err) {
+    smoothedRsi = null;
+  }
+
+  if (smoothedRsi !== null && typeof smoothedRsi === 'number' && scale) {
+    smoothedRsi = calcMagnitude(smoothedRsi, scale);
+  }
+
+  // Always push the smoothed RSI value.
+  main.pushToMain({ index, key: rsiSmaKey, value: smoothedRsi });
+};

package/src/studies/lag.js

@@ -49,9 +49,11 @@ export const lag = (main, index) => {
                 const key = `${colKey}_lag_${lag}`;
                 const laggedIndex = index - lag;
 
-                if(laggedIndex <= 0) break
+                const value = (laggedIndex <= 0 || typeof currentColumn[laggedIndex] === 'undefined') 
+                    ? null 
+                    : currentColumn[laggedIndex]
 
-                main.pushToMain({index, key, value: currentColumn[laggedIndex]})
+                main.pushToMain({index, key, value})
             }
         }
     }

package/src/utilities/dataParsingUtilities.js

@@ -14,6 +14,8 @@ export const verticalToHorizontal = (
   const len = endIndex - startIndex;
   
   const result = new Array(len);
+
+  console.log({skipNull, invalidValueIndex, len})
   
   for (let i = startIndex; i < endIndex; i++) {
     const row = {};
@@ -21,7 +23,7 @@ export const verticalToHorizontal = (
       const key = keys[j];
       const value = obj[key][i];
 
-      if(value === null || value === NaN || typeof value === 'undefined')
+      if(value === null || typeof value === 'undefined')
       {
         row[key] = null
       }