ohlcv-indicators 1.9.8 → 2.0.0

package/src/studies/candleStudies.js

@@ -1,22 +1,22 @@
 import { FasterSMA } from 'trading-signals';
 import { classifySize } from '../utilities/classification.js';
 
-export const candlesStudies = (main, index, size, classify = true, classificationLevels = {}) => {
+export const candleStudies = (main, index, size, classify = true, classificationLevels = {}) => {
 
     const { changeLevel = 7, sizeLevel = 5 } = classificationLevels;
 
     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),          
+            candle_gap_size: [...main.nullArray],
+            candle_body_size: [...main.nullArray],
+            candle_top_size: [...main.nullArray],
+            candle_bottom_size: [...main.nullArray],
+            candle_shadow_size: [...main.nullArray],
+            candle_close_direction: [...main.nullArray],
+            candle_high_direction: [...main.nullArray],
+            candle_low_direction: [...main.nullArray],
+            candle_open_direction: [...main.nullArray],          
         })
     }
 
@@ -44,7 +44,7 @@ export const candlesStudies = (main, index, size, classify = true, classificatio
     const prevLow = main.verticalOhlcv.low[index-1]
     const prevClose = main.verticalOhlcv.close[index-1]
 
-    if ([prevOpen, prevHigh, prevLow, prevClose].some(v => typeof v === 'undefined')) return true;
+    if (index === 0) return true;
 
     const currOpen = main.verticalOhlcv.open[index]
     const currHigh = main.verticalOhlcv.high[index]
@@ -88,15 +88,15 @@ export const candlesStudies = (main, index, size, classify = true, classificatio
         } = main.instances.candleStudies;
 
         // Update instances with current absolute values
-        topInstance.update(Math.abs(topSize));
-        bottomInstance.update(Math.abs(bottomSize));
-        shadowSizeInstance.update(Math.abs(shadowSize));
-        gapInstance.update(gapSize);
-        bodySizeInstance.update(candleBodySize);
-        closeDirectionInstance.update(closeDirection);
-        highDirectionInstance.update(highDirection);
-        lowDirectionInstance.update(lowDirection);
-        openDirectionInstance.update(openDirection);
+        topInstance.update(Math.abs(topSize), main.lastIndexReplace);
+        bottomInstance.update(Math.abs(bottomSize), main.lastIndexReplace);
+        shadowSizeInstance.update(Math.abs(shadowSize), main.lastIndexReplace);
+        gapInstance.update(gapSize, main.lastIndexReplace);
+        bodySizeInstance.update(candleBodySize, main.lastIndexReplace);
+        closeDirectionInstance.update(closeDirection, main.lastIndexReplace);
+        highDirectionInstance.update(highDirection, main.lastIndexReplace);
+        lowDirectionInstance.update(lowDirection, main.lastIndexReplace);
+        openDirectionInstance.update(openDirection, main.lastIndexReplace);
 
         try {
             topSizeMean = topInstance.getResult();

package/src/studies/dateTime.js

@@ -0,0 +1,86 @@
+export const dateTime = (main, index) => {
+
+    if(index === 0)
+    {
+
+        if(!main.isValidDate) throw Error('dateTime method found and invalid "date" in input ohlcv')
+
+        const index0DateStr = main.verticalOhlcv.date[0].slice(0, 10)
+
+        Object.assign(main.instances, {
+            dateTime: {
+                prevDateStr: index0DateStr,
+                sessionDailyIndexCount: 0,
+                sessionIntradayIndexCount: 0,
+                cachedDayInfo: index0DateStr
+            }
+        })
+
+        Object.assign(main.verticalOhlcv, {
+            day_of_the_week: [...main.nullArray],
+            day_of_the_month: [...main.nullArray],
+            week_of_the_month: [...main.nullArray],
+            hour: [...main.nullArray],
+            month: [...main.nullArray],
+            year: [...main.nullArray],
+            session_daily_index: [...main.nullArray],
+            session_intraday_index: [...main.nullArray],
+        })
+    }
+
+    const currDate = main.verticalOhlcv.date[index]
+    const {
+        day_of_the_week,
+        day_of_the_month,
+        week_of_the_month,
+        month,
+        year,
+        hour,
+    } = getDateInfo(currDate)
+
+
+    const currDateStr = currDate.slice(0, 10)
+
+    if(currDateStr !== main.instances.dateTime.prevDateStr)
+    {
+        main.instances.dateTime.prevDateStr = currDateStr
+        main.instances.dateTime.sessionDailyIndexCount++
+        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
+
+}
+
+
+
+const getDateInfo = dateString => {
+    const date = new Date(dateString)
+    const month = date.getMonth()
+    const year = date.getFullYear()
+    const hour = date.getHours()
+    const minute = date.getMinutes()
+    const day_of_the_week = date.getDay();
+    const day_of_the_month = date.getDate();
+    const firstDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1)
+    const dayOffset = firstDayOfMonth.getDay();
+    const week_of_the_month = Math.ceil((day_of_the_month + dayOffset) / 7)
+
+    return {
+        month,
+        year,
+        hour,
+        minute,
+        day_of_the_week,
+        day_of_the_month,
+        week_of_the_month,
+    }
+}

package/src/studies/findCrosses.js

@@ -12,18 +12,20 @@ class CrossInstance {
 
     constructor()
     {
-        this.interval = 0
-        this.prevState = 0.5
-        this.prevFast = null
-        this.prevSlow = null
-        this.prevHigh = null
-        this.prevLow = null
-        this.areHighAndLowUndefined = false
-        this.index = 0
-        this.crossIndexes = {
-            up: [],
-            down: []
-        }
+        Object.assign(this, {
+            interval: 0,
+            prevState: 0.5,
+            prevFast: null,
+            prevSlow: null,
+            prevHigh: null,
+            prevLow: null,
+            areHighAndLowUndefined: false,
+            index: 0,
+            crossIndexes: {
+                up: [],
+                down: []
+            }
+        })        
 
     }
     update({fast, high, slow, low})
@@ -113,12 +115,14 @@ class CrossInstance {
         if(this.interval === -1) this.crossIndexes.down.push(this.index)
 
         //save prev state
-        this.index++
-        this.prevState = currState
-        this.prevFast = fast
-        this.prevSlow = slow
-        this.prevHigh = high
-        this.prevLow = low
+        Object.assign(this, {
+            index: this.index + 1,
+            prevState: currState,
+            prevFast: fast,
+            prevSlow: slow,
+            prevHigh: high,
+            prevLow: low
+        })        
     }
 
     getResult()
@@ -128,11 +132,19 @@ class CrossInstance {
 
 }
 
-export const crossPairs = (main, index, arr) => {
+export const crossPairs = (main, index) => {
 
-    if(!arr) return
 
-    for (const { fast, slow } of arr)
+    if(index === 0)
+    {
+        const findParams = main.inputParams.filter(o => o.key === 'crossPairs')
+
+        if(typeof findParams !== 'object') return
+
+        main.instances.crossPairs = {crossPairsList: findParams.flatMap(o => o.params.flat())}
+    }
+
+    for (const { fast, slow } of main.instances.crossPairs.crossPairsList)
     {
         if (!fast || !slow) continue
 
@@ -150,7 +162,7 @@ export const crossPairs = (main, index, arr) => {
 
 
             main.instances[crossName] = new CrossInstance()
-            main.verticalOhlcv[crossName] = new Array(main.len).fill(null)
+            main.verticalOhlcv[crossName] = [...main.nullArray]
         }
 
         let fastValue

package/src/studies/lag.js

@@ -1,34 +1,43 @@
-export const lag = (main, index, params) => {
+export const lag = (main, index) => {
 
-    if(!params) return true
-
-    for(let p = 0; p < params.length; p++)
+    if(index === 0)
     {
-        const [colKeys, lags] = params[p]
+        const findParams = main.inputParams.filter(o => o.key === 'lag')
 
-        // Ensure arrays exist for each lag key before we populate
-        for (let x = 0; x < colKeys.length; x++) {
-            for (let lag = 1; lag <= lags; lag++) {
-                const key = `${colKeys[x]}_lag_${lag}`;
-                // If the array does not exist, initialize it
-                if (index === 0) {
-                    main.verticalOhlcv[key] = new Array(main.len).fill(null)
+        if(typeof findParams !== 'object') return
+
+        const params = findParams.map(o => o.params)
+
+        main.instances.lag = {
+            lagParams: params
+        }
+    }
+    
+    for (const [colKeys, lags] of main.instances.lag.lagParams) {
+    
+        for (const colKey of colKeys) {
+            const currentColumn = main.verticalOhlcv[colKey];
+    
+            // Initialize lagged arrays only on the first index
+            if (index === 0) {
+                for (let lag = 1; lag <= lags; lag++) {
+                    const key = `${colKey}_lag_${lag}`;
+                    main.verticalOhlcv[key] = [...main.nullArray];
                 }
+            }
 
-                // Compute the lagged index
+            // Populate lagged values
+            for (let lag = 1; lag <= lags; lag++) {
+                const key = `${colKey}_lag_${lag}`;
                 const laggedIndex = index - lag;
-                
-                // If laggedIndex is negative, we don't have a previous value
-                const value = (laggedIndex >= 0) 
-                    ? main.verticalOhlcv[colKeys[x]][laggedIndex] 
-                    : null;
-                
-                main.verticalOhlcv[key][index] = value;
+
+                if(laggedIndex <= 0) break
+    
+                main.verticalOhlcv[key][index] = currentColumn[laggedIndex]
             }
         }
     }
-
-
+    
 
 
 

package/src/studies/priceVariations.js

@@ -0,0 +1,22 @@
+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.verticalOhlcv.mid_price_open_close[index] = (open + close) / 2
+    main.verticalOhlcv.mid_price_high_low[index] = (high + low) / 2
+
+}

package/src/utilities/parsing-utilities.js

@@ -1,3 +1,4 @@
+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"
@@ -6,11 +7,16 @@ 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 { candlesStudies } from "../studies/candleStudies.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"
+
 
 const indicatorFunctions = {
+    dateTime,
+    priceVariations,
     rsi,
     sma,
     ema,
@@ -19,259 +25,86 @@ const indicatorFunctions = {
     donchianChannels,
     bollingerBands,
     volumeOscillator,
-    candlesStudies,
-    lag,
-}
-
-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: true,
-    midPriceHighLow: true,
-    sessionIndex: true,
-    sessionIntradayIndex: true,
-    dayOfTheWeek: true,
-    dayOfTheMonth: true,
-    weekOfTheMonth: true
+    candleStudies
 }
 
-const getDateInfo = (dateString) => {
-    const date = new Date(dateString);
-    const day_of_the_week = date.getDay();
-    const day_of_the_month = date.getDate();
-    const firstDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1);
-    const dayOffset = firstDayOfMonth.getDay();
-    const week_of_the_month = Math.ceil((day_of_the_month + dayOffset) / 7);
-
-    return {
-        day_of_the_week,
-        day_of_the_month,
-        week_of_the_month
-    };
-}
 
 export const parseOhlcvToVertical = (input, main, startIndex = 0) => {
-    const { len, studyOptions = {}, inputParams } = main
-
+    const { len, inputParams } = main
 
+    main.nullArray = new Array(len).fill(null)
 
+    if (startIndex === 0) {
 
-    if (studyOptions) {
-        const studyOptionKeys = Object.keys(studyOptions)
-        for (let i = 0; i < studyOptionKeys.length; i++) {
-            const k = studyOptionKeys[i]
-            if (!defaultStudyOptions.hasOwnProperty(k)) {
-                throw new Error(`Key ${k} not found in defaultStudyOptions. Available options: ${Object.keys(defaultStudyOptions).join(', ')}`)
-            }
-        }
-    }
-
-    const {
-        midPriceOpenClose,
-        midPriceHighLow,
-        sessionIndex,
-        sessionIntradayIndex,
-        dayOfTheWeek,
-        dayOfTheMonth,
-        weekOfTheMonth
-    } = studyOptions
-
-    const numberColsKeys = ['open', 'high', 'low', 'close', 'volume']
-    if (midPriceOpenClose) numberColsKeys.push('mid_price_open_close')
-    if (midPriceHighLow)   numberColsKeys.push('mid_price_high_low')
+        validateInputParams(main)
 
-    const numberColsKeysSet = new Set(numberColsKeys)
-    const vert = main.verticalOhlcv
+        const baseKeys = ['open', 'high', 'low', 'close', 'volume'];
+        const baseKeysSet = new Set(baseKeys);
 
-    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)
+        for (let i = 0; i < baseKeys.length; i++) {
+            main.verticalOhlcv[baseKeys[i]] = [...main.nullArray]
         }
 
-        // Extract other keys and initialize their arrays
-        const inputKeys = Object.keys(input[0])
-        const otherKeys = []
+        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)
+            if (!baseKeysSet.has(key)) {
+                main.verticalOhlcv[key] = [...main.nullArray]
                 otherKeys.push(key)
             }
         }
-        main.otherKeys = otherKeys
+        main.otherKeys = otherKeys;
 
-        isValidDate = validateFirstDate(input)
 
-        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
-        }
     } 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.")
+            throw new Error("otherKeys not found in main. Ensure you run with startIndex=0 first to initialize.");
         }
-
-        // 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.")
-        }
-
-        // If we had a valid date initially, we continue with date computations
-        isValidDate = main.prevDateStr !== null
-    }
-
-    // Pre-process indicator params
-    const indicatorCalls = processIndicatorCalls(inputParams)
-
-    // Store references for numeric arrays to avoid repeated dictionary lookups
-    const vo_open = vert.open
-    const vo_high = vert.high
-    const vo_low = vert.low
-    const vo_close = vert.close
-    const vo_volume = vert.volume
-    const vo_mid_oc = midPriceOpenClose ? vert.mid_price_open_close : null
-    const vo_mid_hl = midPriceHighLow ? vert.mid_price_high_low : null
-
-    // References for other keys arrays
-    const otherArrays = {}
-    for (let i = 0; i < main.otherKeys.length; i++) {
-        const k = main.otherKeys[i]
-        otherArrays[k] = vert[k]
     }
 
-    // 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
-
+    const indicatorCalls = processIndicatorCalls(inputParams);
 
 
-
-    // Compute indicators and fill data from startIndex to len
     for (let x = startIndex; x < len; x++) {
-        const current = input[x]
+        const current = input[x];
 
-        // Assign OHLCV
-        vo_open[x] = current.open
-        vo_high[x] = current.high
-        vo_low[x] = current.low
-        vo_close[x] = current.close
-        vo_volume[x] = current.volume
+        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;
 
-        // Mid-price calculations
-        if (vo_mid_oc) {
-            vo_mid_oc[x] = (current.open + current.close) / 2
-        }
-        if (vo_mid_hl) {
-            vo_mid_hl[x] = (current.high + current.low) / 2
-        }
-
-        // Other keys
         for (let i = 0; i < main.otherKeys.length; i++) {
-            const k = main.otherKeys[i]
-            otherArrays[k][x] = current[k]
+            const k = main.otherKeys[i];
+            main.verticalOhlcv[k][x] = current[k];
         }
 
-        // Date processing for session indices and date fields
-        if (isValidDate) {
-            const thisDateStr = current.date.slice(0, 10)
-            if (thisDateStr !== prevDateStr) {
-                prevDateStr = thisDateStr
-                sessionIndexCount++
-                sessionIntradayIndexCount = 0
-                cachedDayInfo = getDateInfo(thisDateStr)
-            }
-
-            if (dayOfTheWeek) {
-                vert.day_of_the_week[x] = cachedDayInfo.day_of_the_week
-            }
-
-            if (dayOfTheMonth) {
-                vert.day_of_the_month[x] = cachedDayInfo.day_of_the_month
-            }
+        for (let i = 0; i < indicatorCalls.length; i++) {
+            const { fn, args, key } = indicatorCalls[i];
+            if (key === 'crossPairs' || key === 'lag') continue;
 
-            if (weekOfTheMonth) {
-                vert.week_of_the_month[x] = cachedDayInfo.week_of_the_month
-            }
-
-            if (sessionIndex) {
-                vert.session_index[x] = sessionIndexCount
-            }
-
-            if (sessionIntradayIndex) {
-                vert.session_intraday_index[x] = sessionIntradayIndexCount
-            }
-
-            sessionIntradayIndexCount++
-
-
-            // Run indicator functions
-            for (let i = 0; i < indicatorCalls.length; i++) {
-                const { fn, args, key } = indicatorCalls[i]
-                if(key === 'crossPairs' || key === 'lag') continue
-                fn(main, x, ...args)
-            }
+            fn(main, x, ...args)
         }
 
-
-        lag(main, x, inputParams.lag)
-        crossPairs(main, x, main.crossPairsList)
-        main.lastComputedIndex++
+        lag(main, x);
+        crossPairs(main, x);
+        main.lastComputedIndex++;
     }
+};
 
-    // 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
-}
 
-const processIndicatorCalls = (inputParams) => {
-    if (!inputParams || typeof inputParams !== 'object') return [];
+const processIndicatorCalls = inputParams => {
+    if (!inputParams || typeof inputParams !== 'object') return []
 
-    const indicatorCalls = [];
-    for (const [key, technical] of Object.entries(inputParams)) {
-        if (Array.isArray(technical)) {
-            for (const params of technical) {
-                if (Array.isArray(params)) {
-                    indicatorCalls.push({
-                        key,
-                        fn: indicatorFunctions[key],
-                        args: params,
-                    });
-                }
-            }
-        }
+    const indicatorCalls = []
+
+    for(let x = 0; x < inputParams.length; x++)
+    {
+        const {key, params} = inputParams[x]
+        indicatorCalls.push({key, fn: indicatorFunctions[key], args: params})
     }
+
     return indicatorCalls;
 };

package/src/utilities/setIndicatorsFromInputParams.js

@@ -1,5 +1,5 @@
-export const setIndicatorsFromInputParams = ({ input, inputParams, OHLCV_INDICATORS, studyOptions }) => {
-    const indicators = new OHLCV_INDICATORS({ input, studyOptions });
+export const setIndicatorsFromInputParams = ({ input, inputParams, OHLCV_INDICATORS }) => {
+    const indicators = new OHLCV_INDICATORS({ input });
 
     for (const [key, technical] of Object.entries(inputParams)) {