ohlcv-indicators 2.0.5 → 2.0.7

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})
 
 }
 

package/src/studies/findCrosses.js

@@ -188,7 +188,7 @@ export const crossPairs = (main, index) => {
             main.instances[crossName].update({fast: fastValue, slow: slowValue})
         }
 
-        main.verticalOhlcv[crossName][index] = main.instances[crossName].getResult()
+        main.pushToMain({index, key: crossName, value: main.instances[crossName].getResult()})
     }
 
 }

package/src/studies/lag.js

@@ -8,6 +8,19 @@ export const lag = (main, index) => {
 
         const params = findParams.map(o => o.params)
 
+        for (const [colKeys, lags] of params)
+        {
+            for (const colKey of colKeys)
+            {
+                if(main.priceBased.includes(colKey))
+                {
+                    for (let lag = 1; lag <= lags; lag++) {
+                        main.priceBased.push(`${colKey}_lag_${lag}`)
+                    }
+                }
+            }
+        }
+
         main.instances.lag = {
             lagParams: params
         }
@@ -33,7 +46,7 @@ export const lag = (main, index) => {
 
                 if(laggedIndex <= 0) break
     
-                main.verticalOhlcv[key][index] = currentColumn[laggedIndex]
+                main.pushToMain({index, key, value: currentColumn[laggedIndex]})
             }
         }
     }

package/src/studies/priceVariations.js

@@ -9,14 +9,15 @@ export const priceVariations = (main, index) => {
             mid_price_open_close: [...main.nullArray],
             mid_price_high_low: [...main.nullArray]
         })
+
+
     }
 
     const open = main.verticalOhlcv.open[index]
     const high = main.verticalOhlcv.high[index]
     const low = main.verticalOhlcv.low[index]
     const close = main.verticalOhlcv.close[index]
-
-    main.verticalOhlcv.mid_price_open_close[index] = (open + close) / 2
-    main.verticalOhlcv.mid_price_high_low[index] = (high + low) / 2
-
+    
+    main.pushToMain({index, key: 'mid_price_open_close', value: (open + close) / 2})
+    main.pushToMain({index, key: 'mid_price_high_low', value: (high + low) / 2})
 }

package/src/utilities/parsing-utilities.js

@@ -1,110 +1,174 @@
-import { validateInputParams } from "./validators.js"
-import { rsi } from "../oscillators/rsi.js"
-import { sma } from "../moving-averages/sma.js"
-import { ema } from "../moving-averages/ema.js"
-import { macd } from "../moving-averages/macd.js"
-import { relativeVolume } from "../moving-averages/relativeVolume.js"
-import { donchianChannels } from "../moving-averages/donchianChannel.js"
-import { bollingerBands } from "../moving-averages/bollingerBands.js"
-import { volumeOscillator } from "../oscillators/volumeOscillator.js"
-import { candleStudies } from "../studies/candleStudies.js"
-import { lag } from "../studies/lag.js"
-import {crossPairs} from "../studies/findCrosses.js"
-import { dateTime } from "../studies/dateTime.js"
-import { priceVariations } from "../studies/priceVariations.js"
-
-
+import { validateInputParams } from "./validators.js";
+import { rsi } from "../oscillators/rsi.js";
+import { sma } from "../moving-averages/sma.js";
+import { ema } from "../moving-averages/ema.js";
+import { macd } from "../moving-averages/macd.js";
+import { relativeVolume } from "../moving-averages/relativeVolume.js";
+import { donchianChannels } from "../moving-averages/donchianChannel.js";
+import { bollingerBands } from "../moving-averages/bollingerBands.js";
+import { volumeOscillator } from "../oscillators/volumeOscillator.js";
+import { candleStudies } from "../studies/candleStudies.js";
+import { lag } from "../studies/lag.js";
+import { crossPairs } from "../studies/findCrosses.js";
+import { dateTime } from "../studies/dateTime.js";
+import { priceVariations } from "../studies/priceVariations.js";
+
+// Helper to clean non-numeric characters (except "-" at the start and decimal point)
+const cleanNumStr = str => str.replace(/(?!^-)[^0-9.]/g, '');
+
+// Map indicator keys to their respective functions
 const indicatorFunctions = {
-    dateTime,
-    priceVariations,
-    rsi,
-    sma,
-    ema,
-    macd,
-    relativeVolume,
-    donchianChannels,
-    bollingerBands,
-    volumeOscillator,
-    candleStudies
-}
-
-
-export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
-    const { len, inputParams } = main
-
-    main.nullArray = new Array(len).fill(null)
-
-    if (startIndex === 0) {
-
-        validateInputParams(main)
-
-        const baseKeys = ['open', 'high', 'low', 'close', 'volume'];
-        const baseKeysSet = new Set(baseKeys);
+  dateTime,
+  priceVariations,
+  rsi,
+  sma,
+  ema,
+  macd,
+  relativeVolume,
+  donchianChannels,
+  bollingerBands,
+  volumeOscillator,
+  candleStudies
+};
 
-        // Fresh initialization
-        for (let i = 0; i < baseKeys.length; i++) {
-            main.verticalOhlcv[baseKeys[i]] = [...main.nullArray]
-        }
+// Processes the inputParams into a list of indicator calls
+const processIndicatorCalls = inputParams =>
+  Array.isArray(inputParams)
+    ? inputParams.map(({ key, params }) => ({
+        key,
+        fn: indicatorFunctions[key],
+        args: params
+      }))
+    : [];
+
+// Sets the input types for each key based on the first row of data
+const setInputTypes = (row0, main) => {
+  const isValidNumberString = str => /^(\d+(\.\d*)?|\.\d+)$/.test(str);
+
+  for (const key of Object.keys(main.inputTypes)) {
+    if (!(key in row0)) {
+      throw new Error(`Property "${key}" not found in ohlcv array. ${main.ticker}`);
+    }
 
-        const inputKeys = Object.keys(input[0]);
-        const otherKeys = [];
-        for (let i = 0; i < inputKeys.length; i++) {
-            const key = inputKeys[i]
-            if (!baseKeysSet.has(key)) {
-                main.verticalOhlcv[key] = [...main.nullArray]
-                otherKeys.push(key)
-            }
-        }
-        main.otherKeys = otherKeys;
+    let value = row0[key];
 
+    
 
+    if (typeof value === 'number' && value > 0) {
+      main.inputTypes[key] = 'number';
+    } else if (typeof value === 'string' && isValidNumberString(value)) {
+      main.inputTypes[key] = 'string';
+      value = cleanNumStr(value);
     } else {
-        if (!main.otherKeys) {
-            throw new Error("otherKeys not found in main. Ensure you run with startIndex=0 first to initialize.");
-        }
+      throw new Error(`Invalid property "${key}" in ohlcv array. ${main.ticker}`);
     }
 
-    const indicatorCalls = processIndicatorCalls(inputParams);
-
-
-    for (let x = startIndex; x < len; x++) {
-        const current = input[x];
-
-        main.verticalOhlcv.open[x] = current.open;
-        main.verticalOhlcv.high[x] = current.high;
-        main.verticalOhlcv.low[x] = current.low;
-        main.verticalOhlcv.close[x] = current.close;
-        main.verticalOhlcv.volume[x] = current.volume;
-
-        for (let i = 0; i < main.otherKeys.length; i++) {
-            const k = main.otherKeys[i];
-            main.verticalOhlcv[k][x] = current[k];
-        }
-
-        for (let i = 0; i < indicatorCalls.length; i++) {
-            const { fn, args, key } = indicatorCalls[i];
-            if (key === 'crossPairs' || key === 'lag') continue;
-
-            fn(main, x, ...args)
-        }
-
-        lag(main, x);
-        crossPairs(main, x);
-        main.lastComputedIndex++;
+    // Determine precisionMultiplier if not already set
+    if (main.precisionMultiplier === 0) {
+      const [, decimals = ''] = String(value).split('.');
+      const decimalPrecision = Math.max(4, decimals.length);
+      main.precisionMultiplier = decimalPrecision > 1 ? Math.pow(10, decimalPrecision - 1) : 1;
     }
+  }
 };
 
+// Parses a number from either a numeric or string input, applying a multiplier to fix precision issues
+const parseNumber = (num, type, precisionMultiplier) => {
+  const addMultiplier = cNum =>
+    precisionMultiplier > 1 ? cNum * precisionMultiplier : cNum;
+
+  if (type === 'number') {
+    return addMultiplier(num);
+  } else if (type === 'string') {
+    const cleanedStr = cleanNumStr(num);
+    return addMultiplier(Number(cleanedStr));
+  } else
+  {
+    return 0 // Optionally: throw an error if type is not recognized
+  }
+  
+};
+
+const parseVolume = (volume, type) => {
 
-const processIndicatorCalls = inputParams => {
-    if (!inputParams || typeof inputParams !== 'object') return []
+  if(type === 'number') return volume
+  else if(type === 'string'){
+    return Number(cleanNumStr(volume))
+  }
+  else
+  {
+    return 0 // Optionally: throw an error if type is not recognized
+  }
+}
 
-    const indicatorCalls = []
+export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
+  const { len, inputParams } = main;
+  main.nullArray = new Array(len).fill(null);
+
+  const BASE_KEYS = ['open', 'high', 'low', 'close', 'volume'];
+  const baseKeysSet = new Set(BASE_KEYS);
+
+  if (startIndex === 0) {
+    // Validate parameters and initialize base keys in verticalOhlcv
+    validateInputParams(main);
+    BASE_KEYS.forEach(key => {
+      main.verticalOhlcv[key] = [...main.nullArray];
+    });
+
+    // Identify any additional keys from the first input row and initialize them
+    const inputKeys = Object.keys(input[0]);
+    const otherKeys = inputKeys.filter(key => !baseKeysSet.has(key));
+    otherKeys.forEach(key => {
+      main.verticalOhlcv[key] = [...main.nullArray];
+    });
+    main.otherKeys = otherKeys;
+
+    // Set the input types once using the first row
+    setInputTypes(input[0], main);
+  } else if (!main.otherKeys) {
+    throw new Error(
+      "otherKeys not found in main. Ensure you run with startIndex=0 first to initialize."
+    );
+  }
+
+  // Prepare the list of indicator function calls
+  const indicatorCalls = processIndicatorCalls(inputParams);
+
+  // Process each row in the input
+  for (let x = startIndex; x < len; x++) {
+    const current = input[x];
+    // Destructure the base keys and use the rest for other properties
+    const { open, high, low, close, volume, ...rest } = current
+    const {precisionMultiplier} = main
+
+    const parsedOpen = parseNumber(open, main.inputTypes.open, precisionMultiplier)
+    const parsedHigh = parseNumber(open, main.inputTypes.high, precisionMultiplier)
+    const parsedLow = parseNumber(open, main.inputTypes.low, precisionMultiplier)
+    const parsedClose = parseNumber(open, main.inputTypes.close, precisionMultiplier)
+    const parsedVolume = parseVolume (volume, main.inputTypes.volume)
+
+    main.pushToMain({index: x, key: 'open', value: parsedOpen})
+    main.pushToMain({index: x, key: 'high', value: parsedHigh})
+    main.pushToMain({index: x, key: 'low', value: parsedLow})
+    main.pushToMain({index: x, key: 'close', value: parsedClose})
+    main.pushToMain({index: x, key: 'volume', value: parsedVolume})
+
+
+    // Populate any extra keys identified during initialization
+    for (const key of main.otherKeys) {
+      main.pushToMain({index: x, key, value: rest[key]})
+    }
 
-    for(let x = 0; x < inputParams.length; x++)
-    {
-        const {key, params} = inputParams[x]
-        indicatorCalls.push({key, fn: indicatorFunctions[key], args: params})
+    // Run all indicator functions except for the ones processed later
+    for (const { key, fn, args } of indicatorCalls) {
+      if (['crossPairs', 'lag'].includes(key)) continue;
+      fn(main, x, ...args);
     }
 
-    return indicatorCalls;
+    // Process these indicators separately (ensuring their execution order)
+    lag(main, x);
+    crossPairs(main, x);
+
+    main.lastComputedIndex++;
+  }
 };