ohlcv-indicators 3.5.78 → 3.5.79

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.')
 }
 
@@ -117,3 +125,34 @@ export const validateString = (txt, paramName, callerName) => {
 
   return true
 }
+
+
+export const validateInputValues = (
+  requiredParams,
+  verticalOhlcv,
+  index,
+  callbackName
+) => {
+  if (index !== 0) return true;
+
+  const invalidParams = [];
+
+  for (const key of Object.keys(requiredParams)) {
+    const value = verticalOhlcv[key]?.[index];
+
+    const isValid = key === "volume"
+      ? Number.isInteger(value) && value >= 0
+      : Number.isFinite(value) && value > 0;
+
+    if (!isValid) invalidParams.push(key);
+  }
+
+  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]
       }
     }
   }

package/src/volatility/adx.js

@@ -1,5 +1,7 @@
-import { FasterADX } from 'trading-signals';
+import { FasterADX } from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 export const adx = (main, index, size, { lag, retLogs }) => {
   const { verticalOhlcv, instances, useFullNames } = main;
@@ -10,7 +12,7 @@ export const adx = (main, index, size, { lag, retLogs }) => {
 
   // Initialization on the first index.
   if (index === 0) {
-    const { len } = main;
+    validateInputValues({ high: true, low: true, close: true }, verticalOhlcv, index, 'adx');
 
     if (!verticalOhlcv.hasOwnProperty('high')) {
       throw new Error('Property high not found in verticalOhlcv for adx.');
@@ -28,32 +30,17 @@ export const adx = (main, index, size, { lag, retLogs }) => {
       [instanceKey]: new FasterADX(size)
     });
 
-    Object.assign(verticalOhlcv, {
-      [adxKey]: new Float64Array(len).fill(NaN)
-    })
-
-
-    if (lag > 0) {
-      main.lag([adxKey], lag);
-    }
+    initializeColumns(main, [{ key: adxKey }], { lag });
   }
 
   const high = verticalOhlcv.high[index];
   const low = verticalOhlcv.low[index];
   const close = verticalOhlcv.close[index];
 
-  let currentAdx = NaN;
-
   // Update the ADX indicator.
   instances[instanceKey].update({ high, low, close });
 
-  try {
-    currentAdx = instances[instanceKey].getResult();
-
-    instances[instanceKey].get
-  } catch (err) {
-    currentAdx = NaN;
-  }
+  const currentAdx = instances[instanceKey].isStable ? instances[instanceKey].getResult() : NaN;
 
 
   const adxVal = Number.isNaN(currentAdx)
@@ -62,4 +49,4 @@ export const adx = (main, index, size, { lag, retLogs }) => {
 
 
   main.pushToMain({ index, key: adxKey, value: adxVal });
-};
+};

package/src/volatility/atr.js

@@ -1,29 +1,22 @@
 
-import {FasterATR, FasterWSMA} from 'trading-signals';
+import {FasterATR, FasterWSMA} from '../core-indicators/index.js';
 import { mathLog } from '../utilities/math.js';
+import { validateInputValues } from '../utilities/validators.js';
+import { initializeColumns } from '../core-functions/initializeColumns.js';
 
 export const atr = (main, index, size, {lag, retLogs}) => {
-  const { verticalOhlcv, instances, priceBased } = main
+  const { verticalOhlcv, instances } = main
   const baseKeyName = retLogs ? `ret_log_atr_${size}` : `atr_${size}`
 
   if (index === 0) {
 
-    const {instances, verticalOhlcv, len} = main
+    const {instances, verticalOhlcv} = main
 
-    instances[baseKeyName] = new FasterATR(size, FasterWSMA)
-
-    const keyNames = [baseKeyName]
+    validateInputValues({ high: true, low: true, close: true }, verticalOhlcv, index, 'atr')
 
-    for(const k of keyNames)
-    { 
-      verticalOhlcv[k] = new Float64Array(len).fill(NaN)
-      priceBased.add(k)
-    }
+    instances[baseKeyName] = new FasterATR(size, FasterWSMA)
 
-    if(lag > 0)
-    {
-      main.lag(keyNames, lag)
-    }
+    initializeColumns(main, [{ key: baseKeyName, priceBased: true }], { lag })
   }
 
   // Retrieve the current price value.
@@ -36,15 +29,9 @@ export const atr = (main, index, size, {lag, retLogs}) => {
 
   // Update the moving average instance.
   instance.update(curr);
-  let currAtr = NaN;
-  try {
-    currAtr = instance.getResult();
-  } catch (err) {
-
-  }
+  const currAtr = instance.isStable ? instance.getResult() : NaN;
 
   // Always push the MA value (even if NaN).
   main.pushToMain({ index, key: baseKeyName, value: Number.isNaN(currAtr) ? NaN : (retLogs ? mathLog(currAtr, curr.close) : currAtr) });
 
-  return true;
-}
+}