ohlcv-indicators 3.3.2 → 3.3.4

package/src/utilities/numberUtilities.js

@@ -1,14 +1,12 @@
+// Helper to clean non-numeric characters (except "-" at the start and decimal point)
+export const sanitizeDirtyNumberString = str => str.replace(/(?!^-)[^0-9.]/g, '');
 
-export const calcMagnitude = (number, magnitudeLevel = 0.1) => {
-
-    const factor = 1 / magnitudeLevel
-
-    return Math.round(number * factor) / factor
+export const numberFormater = {
+  number: n => n,
+  numberCleanString: n => Number(n),
+  numberDirtyString: n => Number(sanitizeDirtyNumberString(n))
 }
 
-// Helper to clean non-numeric characters (except "-" at the start and decimal point)
-export const cleanNumStr = str => str.replace(/(?!^-)[^0-9.]/g, '');
-
 export const divideByMultiplier = ({row, precisionMultiplier, priceBased}) => {
     const output = {}
 
@@ -26,4 +24,47 @@ export const divideByMultiplier = ({row, precisionMultiplier, priceBased}) => {
     }
 
     return output
-} 
+} 
+
+// Parses a number from either a numeric or string input, applying a multiplier to fix precision issues
+export const parseNumber = (num, type, precisionMultiplier) => {
+  const addMultiplier = cNum => precisionMultiplier > 1 ? cNum * precisionMultiplier : cNum;
+
+  return addMultiplier(numberFormater[type](num))
+
+};
+
+export const classifyNum = (num, throwError = false) => {
+  // 1) true numbers
+  if (typeof num === 'number' && !Number.isNaN(num)) {
+    return 'number';
+  }
+
+  // 2) strings
+  if (typeof num === 'string') {
+    const str = num.trim();
+    const cleanRe = /^-?\d+(\.\d+)?$/;
+
+    // a) clean numeric string: only digits and an optional single period
+    if (cleanRe.test(str)) {
+      return 'numberCleanString';
+    }
+
+    // b) dirty numeric string: contains non-digits (dollar, commas, letters, etc.)
+    //    but once you strip those out, you're left with a valid number
+    const stripped = str.replace(/[^0-9.]/g, '');
+    if (stripped && cleanRe.test(stripped)) {
+      return 'numberDirtyString';
+    }
+  }
+
+
+  if(throwError)
+  {
+    throw new TypeError(
+      'Invalid input: expected a number or numeric string'
+    );
+  }
+
+  return typeof num
+};

package/src/utilities/precisionMultiplier.js

@@ -0,0 +1,24 @@
+export const calcPrecisionMultiplier = (main, firstRow) => {
+    const {precision, priceBased} = main
+
+    if(precision === false) return 1
+
+    let output = 1
+    const priceBasedValues = Object.entries(firstRow).filter(([k, _]) => priceBased.includes(k)).map(([_, v]) => v)
+
+
+    for(const value of priceBasedValues)
+    {
+        const [, decimals = ''] = String(value).split('.')
+        const decimalPrecision = Math.max(4, decimals.length)
+        const multiplier = decimalPrecision > 1 ? Math.pow(10, decimalPrecision - 1) : 1
+
+        if(multiplier > output)
+        {
+            output = multiplier
+        }
+    }
+
+    return output
+
+}

package/src/utilities/validators.js

@@ -1,6 +1,3 @@
-export const validateDate = dateString => typeof dateString === 'string' &&  /^\d{4}-\d{2}-\d{2}/.test(dateString)
-
-
 export const validateInputParams = main => {
 
     const {inputParams, len} = main
@@ -16,5 +13,79 @@ export const validateInputParams = main => {
 }
 
 export const isAlreadyComputed = main => {
-    if(main.lastComputedIndex !== 0) throw Error('ohlcv is already computed, you can not add new indicators after "compute", "getLastValues" , "getDataAsCols" or "getData" methods are called.')
-}
+    if(main.isComputed === true) throw Error('ohlcv is already computed, you can not add new indicators after "compute", "getLastValues" , "getDataAsCols" or "getData" methods are called.')
+}
+
+export const validateArray = (arr, paramName, callerName) => {
+    
+    if(!Array.isArray(arr))
+    {
+        throw new Error(`Param "${paramName}" must be an array in "${callerName}".`)
+    }
+
+    return true
+}
+
+export const validateObject = (obj, paramName, callerName) => {
+    
+    if(!Boolean(obj) || !typeof obj == 'object')
+    {
+        throw new Error(`Param "${paramName}" must be an object in "${callerName}".`)
+    }
+
+    return true
+}
+
+export const validateArrayOptions  = (arrayOptions, value, paramName, callerName) => {
+
+    validateArray(arrayOptions, 'arrayOptions', `${callerName}.${paramName}.validateArrayOptions`)
+
+    if(!arrayOptions.includes(value.toString()))
+    {
+        throw new Error(`Param "${paramName}" must be any of the following values [${arrayOptions.join(', ')}] in "${callerName}".`)
+    }
+
+    return true
+}
+
+export const validateBoolean = (value, paramName, callerName) => {
+
+    if(typeof value !== 'boolean')
+    {
+        throw new Error(`Param "${paramName}" must be an boolean in "${callerName}".`)
+    }
+
+    return true
+}
+
+export const validateNumber = (value, options, paramName, callerName) => {
+
+    validateObject(options, 'options', `${callerName}.${paramName}.validateNumber`)
+
+    const {allowDecimals = false, min, max} = options
+
+    const label = (allowDecimals) ? 'number' : 'integer'
+
+    if(typeof value !== 'number' || (allowDecimals === false && !Number.isInteger(value)))
+    {
+        throw new Error(`Param "${paramName}" must be an integer in "${callerName}".`)
+    }
+
+    if(typeof min !== 'number' || typeof max !== 'number' || min >= max)
+    {
+        throw new Error(`Param "min" must be a valid ${label} lower than "max" "${callerName}.${paramName}.validateNumber".`)
+    }
+
+    if(value < min)
+    {
+        throw new Error(`Param "${paramName}" must be an ${label} greater than or equal to ${min} in "${callerName}".`)
+    }
+
+    if(value > max)
+    {
+        throw new Error(`Param "${paramName}" must be an ${label} lower than or equal to ${max} in "${callerName}".`)
+    }
+
+    return true
+}
+

package/src/utilities/{dataParsingUtilities.js → verticalToHorizontal.js}

@@ -9,24 +9,24 @@ export const verticalToHorizontal = (
   const keys = Object.keys(obj);
   if (keys.length === 0) return [];
   
-  const startIndex = skipNull && invalidValueIndex >= 0 ? invalidValueIndex + 1 : 0;
-  const endIndex = obj[keys[0]].length;
-  const len = endIndex - startIndex;
-  const result = new Array(len);
+  const startIndex = skipNull && invalidValueIndex >= 0 ? invalidValueIndex + 1 : 0
+  const endIndex = obj[keys[0]].length
+  const len = endIndex - startIndex
+  const result = new Array(len)
 
   
   for (let i = startIndex; i < endIndex; i++) {
     const row = {};
     for (let j = 0; j < keys.length; j++) {
-      const key = keys[j];
-      const value = obj[key][i];
+      const key = keys[j]
+      const value = obj[key][i]
 
       row[key] = (precision && priceBased.includes(key)) ? value / precisionMultiplier : value
       
     }
 
-    result[i - startIndex] = row;
+    result[i - startIndex] = row
   }
   
-  return result;
+  return result
 };

package/src/studies/candleVectors.js

@@ -1,121 +0,0 @@
-const diff = (a, b) => (a - b)
-
-import { calcZScore } from "../utilities/classification.js"
-
-export const candleVectors = (main, index, size, {patternSize, lag, autoMinMax}) => {
-
-    const { verticalOhlcv, instances, lastIndexReplace } = main
-
-    if(index === 0)
-    {
-        const {nullArray} = main
-
-        const bodyVectors = [
-
-            ['close', 'open'], ['close', 'high'], ['close', 'low'],
-            ['open', 'high'], ['open', 'low'], 
-            ['high', 'low']
-            
-        ]
-
-        //curr vs prev
-        const lookBackVectors = [
-            ['open', 'open'],
-            ['high', 'high'],
-            ['low', 'low'],
-            ['close', 'close'],
-            ...bodyVectors
-        ]
-
-        const lookBackVectorKeyNames = []
-        const lookBackVectorsSetup = {}
-
-        for(let x = 0; x < patternSize; x++)
-        {
-            for(const [currK, prevK] of lookBackVectors)
-            {
-                lookBackVectorKeyNames.push(`candle_change_${x+1}_${currK}_${prevK}`)
-                lookBackVectorsSetup[`candle_change_${x+1}_${currK}_${prevK}`] = [...nullArray]
-
-                if(autoMinMax)
-                {
-                    main.autoMinMaxKeys.push(`candle_change_${x+1}_${currK}_${prevK}`)
-                }
-            }
-        }
-        
-
-        const bodyVectorKeyNames = []
-        const bodyVectorSetup = {}
-
-        for(const [a, b] of bodyVectors)
-        {
-            bodyVectorKeyNames.push(`candle_body_${a}_${b}`)
-            bodyVectorSetup[`candle_body_${a}_${b}`] = [...nullArray]
-
-            if(autoMinMax)
-            {
-                main.autoMinMaxKeys.push(`candle_body_${a}_${b}`)
-            }
-        }
-
-        const keyNames = [...bodyVectorKeyNames, ...lookBackVectorKeyNames]
-
-        Object.assign(verticalOhlcv, {...bodyVectorSetup, ...lookBackVectorsSetup})
-
-        Object.assign(instances, {
-            candleVectors: {
-                bodyVectors,
-                lookBackVectors,
-                keyNames,
-                arrayChunk: {...Object.fromEntries(keyNames.map(v => [v, []]))}  
-            }
-        })
-
-        if(lag > 0)
-        {
-            main.lag(keyNames, lag)
-        }
-        
-    }
-
-    const {bodyVectors, lookBackVectors, arrayChunk} = instances.candleVectors
-
-    for(let x = 0; x < bodyVectors.length; x++)
-    {
-        const [k2, k1] = bodyVectors[x]
-        const v2 = verticalOhlcv[k2][index]
-        const v1 = verticalOhlcv[k1][index]
-        const key = `candle_body_${k2}_${k1}`
-        const difference = diff(v2, v1)
-
-        const zScore = calcZScore(arrayChunk, key, size, difference, lastIndexReplace)
-    
-        main.pushToMain({index, key, value: zScore})
-    }
-
-    for(let x = 0; x < patternSize; x++)
-    {
-        for(const [currK, prevK] of lookBackVectors)
-        {
-            const currV = verticalOhlcv[currK][index]
-            const prevV = verticalOhlcv[prevK][index-(x+1)]
-            const key = `candle_change_${x+1}_${currK}_${prevK}`
-
-            if(typeof prevV === 'undefined')
-            {
-                main.pushToMain({index, key, value: null})
-                continue
-            }
-
-            const difference = diff(currV, prevV)
-            const zScore = calcZScore(arrayChunk, key, size, difference, lastIndexReplace)
-    
-            main.pushToMain({index, key, value: zScore})
-        }
-    }
-
-    return true
-}
-
-

package/src/studies/priceVariations.js

@@ -1,23 +0,0 @@
-export const priceVariations = (main, index) => {
-
-
-    if(index === 0)
-    {
-        main.priceBased = [...new Set([...main.priceBased, 'mid_price_open_close', 'mid_price_high_low'])]
-
-        Object.assign(main.verticalOhlcv, {
-            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.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/classification.js

@@ -1,75 +0,0 @@
-import { calcMagnitude } from "./numberUtilities.js"
-
-/**
- * Classifies a given value relative to provided Bollinger band thresholds.
- *
- * The function evaluates the input value against the lower, middle, and upper thresholds
- * of the Bollinger bands. If the value is below the lower threshold, it returns 0.
- * If the value exceeds the upper threshold, it returns 1 (or -1 if the value is negative).
- * For values within the bands, it calculates a normalized magnitude between 0 and 1 (or 0 and -1 for negatives)
- * based on the position within the range, rounded to one decimal place.
- * Additionally, if the value is nearly equal to the middle threshold (within a small tolerance),
- * the function returns 0.5 or -0.5 depending on the sign of the value.
- *
- * @param {number} value - The value to classify.
- * @param {Object} bollingerBands - An object containing Bollinger band thresholds.
- * @param {number} bollingerBands.upper - The upper band threshold.
- * @param {number} bollingerBands.middle - The middle band value.
- * @param {number} bollingerBands.lower - The lower band threshold.
- * @returns {number|null} The classified value, or null if inputs are invalid or if upper equals lower.
- */
-
-
-export const classifyBoll = (value, bollingerBands, scale = 0.05, autoMinMax = false) => {
-
-  // Validate that value and bollingerBands are not null/undefined
-  if (value == null || bollingerBands == null) return null
-
-  const positive = value >= 0
-  const absValue = Math.abs(value)
-
-  const { upper, lower } = bollingerBands
-
-  const rangeValue = (absValue - lower) / (upper - lower)
-  let magnitude = calcMagnitude(rangeValue, scale)
-
-  if(magnitude === 0)
-  {
-    return (positive) ? 0.01 : -0.01
-  }
-
-  if(autoMinMax)
-  {
-    return positive ? Math.min(magnitude, 1) : Math.max(-magnitude, -1)
-  }
-  else {
-    return positive ? magnitude : -magnitude
-  }
-
-}
-
-
-export const calcZScore = (arrayChunk, key, size, difference, lastIndexReplace) => {
-  const positive = difference > 0
-  const absValue = Math.abs(difference)
-
-  if (lastIndexReplace) {
-    arrayChunk[key][arrayChunk[key].length - 1] = absValue
-  } else {
-    arrayChunk[key].push(absValue)
-  }
-
-  if (arrayChunk[key].length > size) {
-    arrayChunk[key].shift()  // Maintain array size
-  }
-
-  if (arrayChunk[key].length < size) return null
-
-  const mean = arrayChunk[key].reduce((sum, value) => sum + value, 0) / size
-  const stdDev = Math.sqrt(
-    arrayChunk[key].reduce((sum, value) => sum + (value - mean) ** 2, 0) / size
-  )
-
-  const zScore = (absValue - mean) / stdDev
-  return (positive) ?  zScore : -zScore
-}

package/src/utilities/parsing-utilities.js

@@ -1,189 +0,0 @@
-import { validateInputParams } from "./validators.js";
-import { rsi } from "../oscillators/rsi.js";
-import { movingAverages } from "../moving-averages/movingAverages.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 { candleVectors } from "../studies/candleVectors.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 { cleanNumStr } from "./numberUtilities.js";
-
-// Map indicator keys to their respective functions
-const indicatorFunctions = {
-  dateTime,
-  priceVariations,
-  rsi,
-  movingAverages,
-  macd,
-  relativeVolume,
-  donchianChannels,
-  bollingerBands,
-  volumeOscillator,
-  candleVectors
-};
-
-// 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}`);
-    }
-
-    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 {
-      throw new Error(`Invalid property "${key}" in ohlcv array. ${main.ticker}`);
-    }
-
-    // Determine precisionMultiplier if not already set
-    if (main.precisionMultiplier === 0  && main.precision === true) {
-      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) => {
-
-  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
-  }
-}
-
-export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
-  const { len, inputParams, hasVolume } = main;
-
-  //do not move nullArray from here
-  main.nullArray = new Array(len).fill(null);
-
-  const BASE_KEYS = ['open', 'high', 'low', 'close'];
-
-  if(hasVolume)
-  {
-    BASE_KEYS.push('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
-    //sets volume to 0
-    const { open, high, low, close, ...rest } = current
-    const {precisionMultiplier} = main
-
-    const parsedOpen = parseNumber(open, main.inputTypes.open, precisionMultiplier)
-    const parsedHigh = parseNumber(high, main.inputTypes.high, precisionMultiplier)
-    const parsedLow = parseNumber(low, main.inputTypes.low, precisionMultiplier)
-    const parsedClose = parseNumber(close, main.inputTypes.close, precisionMultiplier)
-    
-
-    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})
-
-    if(hasVolume)
-    {
-      const {volume} = current 
-      const parsedVolume = parseVolume (volume, main.inputTypes.volume)
-      main.pushToMain({index: x, key: 'volume', value: parsedVolume})
-    } else{
-      delete rest.volume
-    }
-
-
-
-    // Populate any extra keys identified during initialization
-    for (const key of main.otherKeys) {
-      main.pushToMain({index: x, key, value: rest[key]})
-    }
-
-    // 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);
-    }
-
-    // Process these indicators separately (ensuring their execution order)
-    lag(main, x);
-    crossPairs(main, x);
-
-    main.lastComputedIndex++;
-  }
-};

package/src/utilities/pushToMain.js

@@ -1,63 +0,0 @@
-export const pushToMain = ({main, index, key, value}) => {
-
-    const {precision, priceBased, minMaxRanges, verticalOhlcv, autoMinMaxKeys, precisionMultiplier} = main
-
-    if(value === null || typeof value === 'undefined')
-    {
-        main.invalidValueIndex = index //do not use let for main.invalidValueIndex
-
-        for(const k of Object.keys(minMaxRanges))
-        {
-            minMaxRanges[k] = {min: Infinity, max: -Infinity}
-        }
-
-        verticalOhlcv[key][index] = null
-        return false
-    }
-
-    verticalOhlcv[key][index] = value    
-
-    if(typeof value === 'number' && !key.includes('_x_'))
-    {
-        const keyInAutoMinMax = autoMinMaxKeys.includes(key)
-
-        if(key.includes('_diff_') && keyInAutoMinMax)
-        {
-            if(!minMaxRanges.hasOwnProperty(key) || (minMaxRanges[key].min === Infinity || minMaxRanges[key].max === -Infinity))
-            {
-                minMaxRanges[key] = { min: -1, max: 1}
-            }
-        }
-        else if(key.startsWith('candle_') && keyInAutoMinMax)
-        {
-            minMaxRanges[key] = { min: -3, max: 3}
-        }
-        else if(key.includes('_range_') && keyInAutoMinMax)
-        {
-            minMaxRanges[key] = { min: 0, max: 1 }
-        }
-        else if(key.startsWith('rsi_') && keyInAutoMinMax)
-        {
-            minMaxRanges[key] = { min: 0, max: 1 }
-        }
-        else {
-            const newValue = (precision && priceBased.includes(key)) ? (value / precisionMultiplier) : value
-
-            if(!minMaxRanges.hasOwnProperty(key))
-            {
-                minMaxRanges[key] = { min: Infinity, max: -Infinity }
-            }
-
-            if(newValue < minMaxRanges[key].min)
-            {
-                minMaxRanges[key].min = newValue
-            }
-            if(newValue > minMaxRanges[key].max)
-            {
-                minMaxRanges[key].max = newValue
-            }
-        }
-    }
-
-    return true
-}