ohlcv-indicators 3.5.77 → 3.5.79

package/src/oscillators/volumeOscillator.js

@@ -1,59 +1,57 @@
-import { FasterEMA } from 'trading-signals';
+import { FasterEMA } from '../core-indicators/index.js';
+import { mathLog } from '../utilities/math.js';
+import { isPositiveInteger } from '../utilities/numberUtilities.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
-export const volumeOscillator = (main, index, fast, slow, {lag}) => {
-
-    
+export const volumeOscillator = (main, index, fast, slow, {lag, retLogs}) => {
 
     const {verticalOhlcv, instances} = main
-    const value = verticalOhlcv.volume[index]
     const key = `volume_oscillator_${fast}_${slow}`
 
     if (index === 0) {
+        validateInputValues({ volume: true }, verticalOhlcv, index, 'volumeOscillator');
 
-        const {len} = main
         Object.assign(instances, {
             [key]: {
                 fastEMA: new FasterEMA(fast),
-                slowEMA: new FasterEMA(slow)
+                slowEMA: new FasterEMA(slow),
             }
         })
 
-        verticalOhlcv[key] = new Float64Array(len).fill(NaN)
-
-        if(lag > 0)
-        {
-            main.lag([key], lag)
-        }
+        initializeColumns(main, [
+            { key },
+            { key: `ret_log_${key}`, enabled: retLogs }
+        ], { lag });
     }
 
     const { fastEMA, slowEMA } = instances[key];
 
-    fastEMA.update(value);
-    slowEMA.update(value);
+    const volume = verticalOhlcv.volume[index];
 
-    let fastValue = NaN;
-    let slowValue = NaN;
-
-    try {
-        fastValue = fastEMA.getResult();
-    } catch (err) {
-        
+    if(volume === 0) {
+        return;
     }
 
-    try {
-        slowValue = slowEMA.getResult();
-    } catch (err) {
+    fastEMA.update(volume);
+    slowEMA.update(volume);
 
-    }
+    const fastValue = fastEMA.isStable ? fastEMA.getResult() : NaN;
+    const slowValue = slowEMA.isStable ? slowEMA.getResult() : NaN;
 
     let volumeOscValue = NaN
+    let volumeOscRetLog = NaN
 
-    if(!Number.isNaN(fastValue) && !Number.isNaN(slowValue))
-    {
-        volumeOscValue = 100 * (fastValue - slowValue) / slowValue
+    if(Number.isNaN(fastValue) || Number.isNaN(slowValue)) {
+        return;
     }
 
-    main.pushToMain({index, key, value:  volumeOscValue})
+    volumeOscValue = 100 * (fastValue - slowValue) / slowValue
+
+    if(retLogs) {
+        volumeOscRetLog = mathLog(fastValue, slowValue)
+        main.pushToMain({index, key: `ret_log_${key}`, value:  volumeOscRetLog})
+    }
 
-    return true;
+    main.pushToMain({index, key, value:  volumeOscValue})
 };

package/src/studies/{priceFeatures.js → candleFeatures.js}

@@ -1,49 +1,41 @@
-
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 const isBadNumber = (v) => v == null || !Number.isFinite(v)
 
-export const priceFeatures  = (main, index, {lag, colKeys, retLogs}) => {
+export const candleFeatures  = (main, index, {lag, colKeys, retLogs}) => {
     const { verticalOhlcv, priceBased, scaledGroups } = main
 
     const getRet = (next, prev) => (retLogs) ? Math.log(next / prev) : (next - prev) / prev
     const prefix = (retLogs) ? 'ret_log_' : 'ret_'
 
     if(index === 0) {
-        const {len} = main
-        
-        const newCols = {
-            [`${prefix}change`]: new Float64Array(len).fill(NaN),
-            [`${prefix}mid_price_change`]: new Float64Array(len).fill(NaN),
-            [`${prefix}upper_wick`]: new Float64Array(len).fill(NaN),
-            [`${prefix}lower_wick`]: new Float64Array(len).fill(NaN),
-            [`${prefix}gap`]: new Float64Array(len).fill(NaN),
-            [`${prefix}body`]: new Float64Array(len).fill(NaN),
-            [`${prefix}range`]: new Float64Array(len).fill(NaN)
-        }
+        validateInputValues({ open: true, high: true, low: true, close: true }, verticalOhlcv, index, 'candleFeatures')
+
+        const columns = [
+            'change', 'mid_price_change', 'upper_wick', 'lower_wick',
+            'gap', 'body', 'range'
+        ].map(name => ({ key: `${prefix}${name}` }))
 
         for(const target of colKeys) {
+            validateInputValues({ [target]: true }, verticalOhlcv, index, 'candleFeatures')
+
             if(!verticalOhlcv.hasOwnProperty(target)) {
                 throw new Error(
-                    `Target property in "options.colKey" array "${target}" not found in verticalOhlcv for "priceFeatures".`
+                    `Target property in "options.colKey" array "${target}" not found in verticalOhlcv for "candleFeatures".`
                 );
             }
 
             else if(!priceBased.has(target)) {
                  throw new Error(
-                     `Target property in "options.colKey" array "${target}" not found in priceBased for "priceFeatures".`
+                     `Target property in "options.colKey" array "${target}" not found in priceBased for "candleFeatures".`
                 );               
             }
 
-            newCols[`${prefix}${target}`] = new Float64Array(len).fill(NaN)
+            columns.push({ key: `${prefix}${target}` })
         }
 
-        Object.assign(verticalOhlcv, newCols)
-
-        scaledGroups.priceFeatures = Object.keys(newCols)
-
-        if(lag) {
-            main.lag(Object.keys(newCols), lag)
-        }
+        scaledGroups.candleFeatures = initializeColumns(main, columns, { lag })
     }
 
     const prevClose = verticalOhlcv.close[index - 1]

package/src/studies/dateTime.js

@@ -1,4 +1,5 @@
 import {oneHotEncode} from '../machine-learning/ml-utilities.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
 export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
@@ -9,11 +10,16 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
     if(index === 0)
     {
-        const {len, dateType} = main
+        const {dateType} = main
         if(!dateType) throw Error('dateTime method found and invalid "date" in input ohlcv')
 
         Object.assign(instances, {
             dateTime: {
+                formatter: new Intl.DateTimeFormat('en-US-u-ca-gregory-nu-latn', {
+                    timeZone: main.timeZone,
+                    year: 'numeric', month: 'numeric', day: 'numeric', weekday: 'short',
+                    hour: 'numeric', minute: 'numeric', hourCycle: 'h23'
+                }),
                 colKeys: [...precompute.colKeys, `${prefix}year`].filter(v => v !== 'one_hot_year'),
                 colKeySizes: {
                     ...precompute.colKeySizes
@@ -23,28 +29,18 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
         const { colKeys } = instances.dateTime
 
-        // choose your ctor, fill-value and type-name once
-        const ctor     = oneHot ? Array     : Int16Array
-        const fillVal  = oneHot ? null      : NaN
-
-        // single loop instead of three
-        for (const key of colKeys) {
-
-            verticalOhlcv[key] = new ctor(len).fill(fillVal)
-
-        }
-
-        // finally, apply lag once
-        if (lag > 0) {
-        main.lag(colKeys, lag)
-        }
+        initializeColumns(main, colKeys.map(key => ({
+            key,
+            type: oneHot ? 'Array' : 'Int16Array',
+            fill: oneHot ? null : 0
+        })), { lag })
     }
 
-    const {colKeySizes} = instances.dateTime
+    const {colKeySizes, formatter} = instances.dateTime
 
     const currDate = verticalOhlcv.date[index]
 
-    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes)
+    const dateInfo = getDateInfo(currDate, oneHot, colKeySizes, formatter)
 
     for(const [key, value] of Object.entries(dateInfo))
     {
@@ -54,17 +50,16 @@ export const dateTime = (main, index, {lag, oneHot, precompute}) => {
 
 
 
-const getDateInfo = (date, oneHot, colKeySizes) => {
-
+const getDateInfo = (date, oneHot, colKeySizes, formatter) => {
 
-  const year = date.getFullYear();
 
-  //start with 0 values
-  const month = date.getMonth();
-  const hour = date.getHours();
-  const minute = date.getMinutes();
-  const dayOfWeek = date.getDay();
-  const dayOfMonth = date.getDate() - 1; // keep same offset
+  const parts = Object.fromEntries(formatter.formatToParts(date).map(({ type, value }) => [type, value]));
+  const year = Number(parts.year);
+  const month = Number(parts.month) - 1;
+  const hour = Number(parts.hour);
+  const minute = Number(parts.minute);
+  const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(parts.weekday);
+  const dayOfMonth = Number(parts.day) - 1;
 
   if (!oneHot) {
     return {

package/src/studies/findCrosses.js

@@ -1,6 +1,8 @@
 import { oneHotEncode } from "../machine-learning/ml-utilities.js"
 import { buildArray } from "../utilities/assignTypes.js"
 import { addPrecisionAsNumber } from "../utilities/precisionMultiplier.js"
+import { validateInputValues } from "../utilities/validators.js"
+import { initializeColumns } from "../core-functions/initializeColumns.js"
 const eq = (fast, slow) => fast === slow
 const gt = (fast, slow) => fast > slow
 const lt = (fast, slow) => fast < slow
@@ -143,6 +145,16 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
     if(index === 0)
     {
+        validateInputValues(
+            {
+                ...(fast === 'price' ? { high: true, low: true, close: true } : { [fast]: true }),
+                ...(typeof slow === 'number' ? {} : { [slow]: true })
+            },
+            verticalOhlcv,
+            index,
+            'crossPairs'
+        )
+
         // allow numeric 'slow' as a constant column
         if (typeof slow === 'number') {
 
@@ -173,12 +185,10 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
         const crossArrType = (limit !== null && limit <= 125) ? 'Int8Array' : 'Float64Array'
 
-        verticalOhlcv[crossName] = buildArray(crossArrType, len, 0)
-
-        if(oneHot)
-        {
-            verticalOhlcv[`one_hot_${crossName}`] = buildArray('Array', len, null)
-        }
+        initializeColumns(main, [
+            { key: crossName, type: crossArrType, fill: 0 },
+            { key: `one_hot_${crossName}`, type: 'Array', enabled: oneHot }
+        ])
 
     }  else if(index + 1 === len) {
         // sanity checks
@@ -228,5 +238,4 @@ export const crossPairs = (main, index, crossPairsList, {oneHot, limit}) => {
 
   }
 
-  return true
 }

package/src/studies/lag.js

@@ -1,13 +1,15 @@
-import { buildArray, getArrayType } from "../utilities/assignTypes.js"
+import { initializeColumns } from "../core-functions/initializeColumns.js"
+
+const lagColumnsKey = Symbol('lagColumns')
 
 export const lag = (main, index, colKeys, lookback) => {
 
-  
-  
-  const { verticalOhlcv, len, priceBased } = main
+  const { verticalOhlcv, priceBased, instances } = main
 
   if(index === 0)
   {
+    const lagColumns = new Map()
+
     for (const targetKey of colKeys) {
       if (!verticalOhlcv.hasOwnProperty(targetKey)) {
         throw new Error(
@@ -16,29 +18,41 @@ export const lag = (main, index, colKeys, lookback) => {
       }
 
       const addToPriceBased = priceBased.has(targetKey)
+      const type = Array.isArray(verticalOhlcv[targetKey]) ? 'Array' : 'Float64Array'
+      const columns = []
+      const keyNames = []
 
       for (let step = 1; step <= lookback; step++) {
         const key = `${targetKey}_lag_${step}`
 
-        if(addToPriceBased) priceBased.add(key)
-
-        const thisArrType = getArrayType(targetKey, verticalOhlcv[targetKey])
-
-        verticalOhlcv[key] = buildArray(thisArrType, len)
+        columns.push({ key, type, priceBased: addToPriceBased, includeInLag: false })
+        keyNames.push(key)
       }   
+
+      initializeColumns(main, columns)
+      lagColumns.set(targetKey, keyNames)
     }
+
+    // colKeys belongs to the runtime queue; keep cached names out of exported params.
+    if (!instances[lagColumnsKey]) instances[lagColumnsKey] = new WeakMap()
+    instances[lagColumnsKey].set(colKeys, lagColumns)
   }
 
+  const lagColumns = instances[lagColumnsKey]?.get(colKeys)
+
   for (const targetKey of colKeys) {
+    const keyNames = lagColumns?.get(targetKey)
     const currentColumn = verticalOhlcv[targetKey]
+    const missingValue = Array.isArray(currentColumn) ? null : NaN
 
     // Populate the lagged values each tick:
     for (let step = 1; step <= lookback; step++) {
-      const key = `${targetKey}_lag_${step}`
+      // Runtime callbacks may change the target list or lookback after initialization.
+      const key = keyNames?.[step - 1] ?? `${targetKey}_lag_${step}`
       const laggedIndex = index - step
       const value =
-        laggedIndex < 0 || currentColumn[laggedIndex] === undefined
-          ? null
+        laggedIndex < 0 || currentColumn[laggedIndex] == null
+          ? missingValue
           : currentColumn[laggedIndex]
 
       main.pushToMain({ index, key, value })
@@ -46,5 +60,4 @@ export const lag = (main, index, colKeys, lookback) => {
     }
   }
 
-  return true
 }

package/src/studies/mapCols.js

@@ -1,32 +1,31 @@
-export const mapCols = (main, index, newCols, callback, {lag, isPriceBased}) => {
+import { validateInputValues } from '../utilities/validators.js'
+import { initializeColumns } from '../core-functions/initializeColumns.js'
 
-    const {verticalOhlcv, len, priceBased, precision} = main
+export const mapCols = (main, index, newCols, callback, {lag, isPriceBased, callbackParams = {}}) => {
+
+    const {verticalOhlcv, precision} = main
 
     if(index === 0)
     {
+        if (callback === defaultMapColsCallback) {
+            validateInputValues({ open: true, close: true }, verticalOhlcv, index, 'mapCols')
+        }
+
         for(const key of newCols)
         {
             if(verticalOhlcv.hasOwnProperty(key)) {
                 throw new Error(`New property "${key}" already exist in "verticalOhlcv" and can not be modified using mapCols.`)
             }
-
-            verticalOhlcv[key] = new Array(len).fill(0)
-
-            if(precision && isPriceBased)
-            {
-                priceBased.add(key)
-            }
         }
 
-        if(lag > 0)
-        {
-            main.lag(newCols, lag)
-        }
+        initializeColumns(main, newCols.map(key => ({
+            key, type: 'Array', priceBased: precision && isPriceBased
+        })), { lag })
     }
 
-    const cols = callback({index, main})
+    const cols = callback({index, main, params: callbackParams})
 
-    if(cols == null) return true
+    if(cols == null) return;
 
     for(const [key, value] of Object.entries(cols))
     {

package/src/utilities/assignTypes.js

@@ -29,7 +29,7 @@ export const buildArray = (arrayType, len, fallbackValue) => {
 
   
   // Ctor.from({ length }, mapFn) works for Array *and* all TypedArrays
-  return Ctor.from({ length: len }, () => fillValue)
+  return new Ctor(len).fill(fillValue)
 }
 
 export const assignTypes = main => {

package/src/utilities/config.js

@@ -0,0 +1,64 @@
+import { defaultMapColsCallback } from '../studies/mapCols.js';
+
+export const CONFIG_VERSION = 1;
+const mapCallbacks = new Map([['default', defaultMapColsCallback]]);
+
+// Copy configuration without JSON's silent conversion of functions/NaN to null.
+export const copyConfig = (value, allowFunctions = false, ancestors = new Set()) => {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'function' && allowFunctions) return value;
+  if (typeof value !== 'object' || value === null) {
+    throw new TypeError('Configuration values must be JSON-safe: no undefined, non-finite numbers, or unregistered functions.');
+  }
+  if (ancestors.has(value)) throw new TypeError('Configuration must not contain circular references.');
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError('Configuration must contain only plain objects and arrays.');
+  }
+  if (Object.getOwnPropertySymbols(value).length) throw new TypeError('Configuration must not contain symbol keys.');
+
+  ancestors.add(value);
+  const result = Array.isArray(value)
+    ? Array.from(value, item => copyConfig(item, allowFunctions, ancestors))
+    : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyConfig(item, allowFunctions, ancestors)]));
+  ancestors.delete(value);
+  return result;
+};
+
+export const freezeConfig = value => {
+  if (value !== null && typeof value === 'object') {
+    for (const item of Object.values(value)) freezeConfig(item);
+    Object.freeze(value);
+  }
+  return value;
+};
+
+export const registerMapCallback = (name, callback) => {
+  if (typeof name !== 'string' || !name || typeof callback !== 'function') {
+    throw new TypeError('registerMapCallback requires a nonempty name and a function.');
+  }
+  if (mapCallbacks.has(name) && mapCallbacks.get(name) !== callback) {
+    throw new Error(`mapCols callback "${name}" is already registered. Use a new versioned name.`);
+  }
+  mapCallbacks.set(name, callback);
+};
+
+export const resolveMapCallback = callback => {
+  if (typeof callback === 'function') return callback;
+  if (typeof callback === 'string' && mapCallbacks.has(callback)) return mapCallbacks.get(callback);
+  throw new Error(`Unknown mapCols callback "${callback}". Register it before loading the configuration.`);
+};
+
+export const exportInputParams = inputParams => {
+  const result = copyConfig(inputParams, true);
+  for (const job of result) {
+    if (job.key !== 'mapCols' || typeof job.params[1] !== 'function') continue;
+    const entry = [...mapCallbacks].find(([, callback]) => callback === job.params[1]);
+    if (!entry) {
+      throw new Error('Cannot export an unregistered mapCols callback. Register it with OHLCV_INDICATORS.registerMapCallback(name, callback).');
+    }
+    job.params[1] = entry[0];
+  }
+  return copyConfig(result);
+};

package/src/utilities/numberUtilities.js

@@ -1,5 +1,7 @@
 import { addPrecisionAsNumber, revertPrecisionAsNumber } from "./precisionMultiplier.js";
 
+export const isPositiveInteger = n => Number.isInteger(n) && n >= 0;
+
 export const inputNumberFormatter = {
   number: n => n,
   numberCleanString: n => Number(n),

package/src/utilities/validators.js

@@ -5,7 +5,14 @@ export const validateInputParams = (inputParams, len) => {
         throw new Error('Property "inputParams" must be an "Array" or "Set".')
     }
 
-    for (const { params } of inputParams) {
+    for (const job of inputParams) {
+        if (!job || typeof job.key !== 'string' || !Array.isArray(job.params)) {
+            throw new TypeError('Each inputParams entry must have an indicator key and a params array.')
+        }
+        if (job.order !== undefined && !Number.isFinite(job.order)) {
+            throw new TypeError('Indicator order must be a finite number when provided.')
+        }
+        const { params } = job
         for (const v of params) {
             if (typeof v === 'number' && v > len) {
                 console.log(v, len);
@@ -16,6 +23,7 @@ export const validateInputParams = (inputParams, len) => {
 }
 
 export const isAlreadyComputed = main => {
+    if(main.isComputing === true) throw Error('You cannot add indicators while computation is in progress.')
     if(main.isComputed === true) throw Error('ohlcv is already computed, you can not add new indicators after "compute", "getLastValues" or "getData" methods are called.')
 }
 
@@ -111,32 +119,40 @@ export const validateNumber = (value, options, paramName, callerName) => {
 };
 
 
-export const validateArrayOfRanges = (range, paramName, callerName) => {
+export const validateString = (txt, paramName, callerName) => {
 
-    validateArray(range, paramName, callerName)
+  if(typeof txt !== 'string' || !txt.length) throw new Error(`Invalid "${paramName}" property in "${callerName}". Only strings are accepted.`)
 
-    if (range.length !== 2) {
-        throw new Error(
-          `Invalid "${paramName}" array length: expected 2 items, but got ${range.length} in "${callerName}.${paramName}".`
-        );
-    }
+  return true
+}
 
-    const [min, max] = range
 
-    validateNumber(min, {min: -100, max, allowDecimals: false}, `${paramName}[0] (min)`, callerName)
-    validateNumber(max, {min: min, max: 100, allowDecimals: false}, `${paramName}[1] (max)`, callerName)
+export const validateInputValues = (
+  requiredParams,
+  verticalOhlcv,
+  index,
+  callbackName
+) => {
+  if (index !== 0) return true;
 
-    if(min === max)
-    {
-        throw new Error(`Invalid "min" can not be equal to "max" property in "${callerName}.${paramName}".`)
-    }
+  const invalidParams = [];
 
-    return true
-}
+  for (const key of Object.keys(requiredParams)) {
+    const value = verticalOhlcv[key]?.[index];
 
-export const validateString = (txt, paramName, callerName) => {
+    const isValid = key === "volume"
+      ? Number.isInteger(value) && value >= 0
+      : Number.isFinite(value) && value > 0;
 
-  if(typeof txt !== 'string' || !txt.length) throw new Error(`Invalid "${paramName}" property in "${callerName}". Only strings are accepted.`)
+    if (!isValid) invalidParams.push(key);
+  }
 
-  return true
-}
+  if (invalidParams.length > 0) {
+    throw new TypeError(
+      `Invalid or missing input value(s) [${invalidParams.join(", ")}] ` +
+      `at index ${index} in "${callbackName}".`
+    );
+  }
+
+  return true;
+};

package/src/utilities/verticalToHorizontal.js

@@ -13,29 +13,34 @@ export const verticalToHorizontal = ({main, skipNull = false, startIndex = 0, da
   const maxStartIndex = Math.max(skipNullIndex, startIndex)
   const diffLen = len - maxStartIndex
   const result = Array.from({ length: diffLen }, () => ({}))
-  const formatter = {}
-  
-  for(const key of verticalOhlcvKeyNames) {
-      if(precision && priceBased.has(key)) {
-          formatter[key] = (num, mul) => outputNumberFormatter.precisionNumberCleanString(num, mul)
-      }
-      else {
-          formatter[key] = v => v
-      }
-  }
 
   for(const [key, arr] of Object.entries(verticalOhlcv)){
     if(verticalOhlcvTempCols.has(key)) continue
 
-    for (let i = maxStartIndex; i < len; i++)
+    if(key === 'date')
     {
-      if(key === 'date')
+      const formatter = dateOutputFormaters[dateFormat]
+      for (let i = maxStartIndex; i < len; i++)
       {
-        result[i - maxStartIndex][key] = dateOutputFormaters[dateFormat](arr[i])
-      } 
-      else
+        result[i - maxStartIndex][key] = formatter(arr[i])
+      }
+    }
+    else if(precision && priceBased.has(key))
+    {
+      const formatter = outputNumberFormatter.precisionNumberCleanString
+      for (let i = maxStartIndex; i < len; i++)
+      {
+        const value = arr[i]
+        result[i - maxStartIndex][key] = value == null || Number.isNaN(value)
+          ? value
+          : formatter(value, precisionMultiplier)
+      }
+    }
+    else
+    {
+      for (let i = maxStartIndex; i < len; i++)
       {
-        result[i - maxStartIndex][key] = formatter[key](arr[i], precisionMultiplier)
+        result[i - maxStartIndex][key] = arr[i]
       }
     }
   }