ohlcv-indicators 3.5.79 → 3.5.82

package/package.json

@@ -1,28 +1,18 @@
 {
   "name": "ohlcv-indicators",
-  "version": "3.5.79",
+  "version": "3.5.82",
   "description": "A JavaScript library featuring optimized trading indicators for OHLCV arrays [{open, high, low, close, value}]. This library is optimized for backtesting and trading bot development.",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "test": "node test/test.js",
     "build": "npx webpack",
-    "cross": "node src/studies/findCrosses2.js"
+    "test": "node test/test.js"
   },
   "author": "https://jaimelias.com/",
   "license": "ISC",
-  "dependencies": {
-    "ohlcv-indicators": "^3.5.72",
-    "trading-signals": "^5.0.4"
-  },
   "devDependencies": {
-    "@babel/core": "^7.25.2",
-    "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/preset-env": "^7.25.3",
-    "babel-loader": "^9.1.3",
-    "dotenv": "^16.4.5",
-    "terser-webpack-plugin": "^5.3.14",
-    "webpack": "^5.93.0",
-    "webpack-cli": "^5.1.4"
+    "dotenv": "^16.6.1",
+    "webpack": "^5.111.1",
+    "webpack-cli": "^7.2.3"
   }
 }

package/src/core-functions/mainLoop.js

@@ -1,6 +1,7 @@
 import { areKeyValuesValid } from "./pushToMain.js";
 import { validateInputParams } from "../utilities/validators.js";
 import { rsi } from "../oscillators/rsi.js";
+import { mfi } from "../oscillators/mfi.js";
 import { stochastic } from "../oscillators/stochastic.js";
 import { movingAverages } from "../moving-averages/movingAverages.js";
 import { heikenAshi } from "../moving-averages/heikenAshi.js";
@@ -15,12 +16,12 @@ import { crossPairs } from "../studies/findCrosses.js";
 import { dateTime } from "../studies/dateTime.js";
 import { atr } from "../volatility/atr.js";
 import { adx } from "../volatility/adx.js";
-import { mapCols } from "../studies/mapCols.js";
 
 import { buildArray } from "../utilities/assignTypes.js";
 import {  inputNumberFormatter } from "../utilities/numberUtilities.js";
 import { dateFormaters } from "../utilities/dateUtilities.js";
 import { candleFeatures } from "../studies/candleFeatures.js";
+import { getPrecisionDecimals } from "../utilities/precisionMultiplier.js";
 
 
 // Map indicator keys to their respective functions
@@ -29,6 +30,7 @@ const mainFunctions = {
   dateTime,
   heikenAshi,
   rsi,
+  mfi,
   stochastic,
   atr,
   adx,
@@ -40,7 +42,6 @@ const mainFunctions = {
   donchianChannels,
   bollingerBands,
   volumeOscillator,
-  mapCols,
   crossPairs,
   lag
 };
@@ -70,16 +71,16 @@ export const mainLoop = (input, main) => {
     verticalOhlcv[key] = buildArray(arrayTypes[key], len)
   }
 
-  // Callbacks can modify inputTypes through main; retain dynamic lookup for them.
-  const inputColumns = executionParams.some(({ key }) => key === 'mapCols')
-    ? null
-    : Object.entries(inputTypes).map(([key, formatterKey]) => {
-        const numeric = inputNumberFormatter.hasOwnProperty(formatterKey)
-        const formatter = numeric
-          ? inputNumberFormatter[formatterKey]
-          : dateFormaters.hasOwnProperty(formatterKey) ? dateFormaters[formatterKey] : null
-        return { key, formatter, numeric }
-      })
+  const inputColumns = Object.entries(inputTypes).map(([key, formatterKey]) => {
+    const numeric = inputNumberFormatter.hasOwnProperty(formatterKey)
+    const formatter = numeric
+      ? inputNumberFormatter[formatterKey]
+      : dateFormaters.hasOwnProperty(formatterKey) ? dateFormaters[formatterKey] : null
+    return { key, formatter, numeric }
+  })
+  const precisionDecimals = typeof precisionMultiplier === 'number'
+    ? getPrecisionDecimals(precisionMultiplier) : undefined
+  let validationColumns = null
 
   // Process each row in the input
   for (let chunkStart = 0; chunkStart < len; chunkStart += chunkProcess) {
@@ -89,37 +90,13 @@ export const mainLoop = (input, main) => {
       for (let index = chunkStart; index < chunkEnd; index++) {
         const curr = input[index]
       
-        if (inputColumns !== null) {
-          for (const { key, formatter, numeric } of inputColumns) {
-            const value = curr[key]
-            if (typeof value === 'undefined') continue
-
-            const formattedValue = formatter === null ? value
-              : numeric ? formatter(value, precisionMultiplier) : formatter(value)
-            main.pushToMain({ index, key, value: formattedValue })
-          }
-        } else {
-          for(const [key, formaterKey] of Object.entries(inputTypes))
-          {
-            let value = curr[key]
-
-            if(typeof value === 'undefined') continue
-
-            if(inputNumberFormatter.hasOwnProperty(formaterKey))
-            {
-              const formatedValue = inputNumberFormatter[formaterKey](value, precisionMultiplier)
-
-              main.pushToMain({index, key, value: formatedValue})
-            }
-            else if(dateFormaters.hasOwnProperty(formaterKey))
-            {
-              main.pushToMain({index, key, value: dateFormaters[formaterKey](value)})
-            }
-            else
-            {
-              main.pushToMain({index, key, value})
-            }
-          }
+        for (const { key, formatter, numeric } of inputColumns) {
+          const value = curr[key]
+          if (typeof value === 'undefined') continue
+
+          const formattedValue = formatter === null ? value
+            : numeric ? formatter(value, precisionMultiplier, precisionDecimals) : formatter(value)
+          main.pushToMain({ index, key, value: formattedValue })
         }
 
         const midPrice = (verticalOhlcv.open[index] + verticalOhlcv.close[index]) / 2
@@ -134,10 +111,13 @@ export const mainLoop = (input, main) => {
       
         input[index] = null //flusing data
 
-        const keyNames = Object.keys(verticalOhlcv)
+        // All built-in outputs (including generated lags) exist after row zero.
+        if (validationColumns === null) {
+          validationColumns = Object.values(verticalOhlcv)
+        }
 
-        // if any value at this index is missing/NaN/null, mark it invalid
-        if (!areKeyValuesValid(main, index, keyNames)) {
+        // Preserve the missing/NaN/null predicate, including Infinity behavior.
+        if (!areKeyValuesValid(validationColumns, index)) {
           main.invalidValueIndex = index
         }
       }

package/src/core-functions/pushToMain.js

@@ -5,29 +5,12 @@ export const pushToMain = ({main, index, key, value}) => {
     verticalOhlcv[key][index] = value
 }
 
-export const areKeyValuesValid = (main, index, keyNames) => {
-    
-    if(keyNames.length === 0) return false
+export const areKeyValuesValid = (columns, index) => {
 
-    const {verticalOhlcv} = main
-
-    let output = true
-
-    for(let x = 0 ; x < keyNames.length; x++)
-    {
-        const key = keyNames[x]
-        if(!verticalOhlcv.hasOwnProperty(key)) {
-            output = false
-            break
-        }
-
-        const val = verticalOhlcv[key][index]
-
-        if (val == null || Number.isNaN(val)) {
-            output = false
-            break
-        }
+    if (columns.length === 0) return false
+    for (let x = 0; x < columns.length; x++) {
+        const val = columns[x][index]
+        if (val == null || Number.isNaN(val)) return false
     }
-
-    return output
-}
+    return true
+}

package/src/core-indicators/README.md

@@ -1,11 +1,9 @@
 # Core indicators
 
-Local numeric replacements for the `Faster*` implementations used from
-`trading-signals@5.0.4`. The existing constructor arguments, `update(value,
+Local numeric `Faster*` indicator implementations. The existing constructor arguments, `update(value,
 replace?)`, `isStable`, and `getResult()` interface remain available. The
 numeric series also retain result/extrema and replacement semantics. These
-are not replacements for the arbitrary-precision `Big` classes or a promise
-of compatibility with other trading-signals versions.
+use ordinary JavaScript numbers, not arbitrary-precision decimal arithmetic.
 
 ```js
 import { FasterEMA } from './index.js'
@@ -41,21 +39,4 @@ provided. This preserves existing JavaScript coercion for custom mapped
 columns without adding object storage for normal numeric input. NaN and
 Infinity remain numeric values and do not trigger this fallback. Candle
 references are retained where the reference implementation observes mutations
-of previously supplied objects. Private buffer layouts intentionally differ.
-
-## Verification
-
-`npm test` compares the core classes directly with the installed
-trading-signals reference, checks bounded retained storage, and exercises all
-public indicators, precision/log modes, lags, callbacks, and config replay.
-The dependency is retained as a regression oracle; production source imports
-only these local classes. Preserve the reference version in the lockfile.
-
-`node test/test.js --baseline /path/to/original/index.js --benchmark` also
-compares the full pipeline with a pre-change checkout. Benchmarks report
-local timings and retained array slots/buffer bytes, not total heap usage or
-performance guarantees. Results must remain exact; changing summation order,
-warm-up, or quirks is a separate behavior change.
-
-Adapted portions retain the upstream MIT notice in `indicator.js`, also
-preserved in the generated distribution's license notice.
+of previously supplied objects. Private buffer layouts intentionally differ.

package/src/core-indicators/indicator.js

@@ -1,27 +1,3 @@
-/*!
- * Portions adapted from trading-signals 5.0.4.
- * MIT License
- * Copyright (c) 2020 Benny Neugebauer
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
 export class NotEnoughDataError extends Error {
     constructor(message = 'Not enough data') {
         super(message)
@@ -30,7 +6,9 @@ export class NotEnoughDataError extends Error {
 }
 
 export class Indicator {
-    result
+    constructor() {
+        this.result = undefined
+    }
 
     get isStable() {
         return this.result !== undefined
@@ -44,11 +22,14 @@ export class Indicator {
 
 // Keep the public result/extrema and replacement semantics without price history.
 export class NumberIndicator extends Indicator {
-    previousResult
-    highest
-    lowest
-    previousHighest
-    previousLowest
+    constructor() {
+        super()
+        this.previousResult = undefined
+        this.highest = undefined
+        this.lowest = undefined
+        this.previousHighest = undefined
+        this.previousLowest = undefined
+    }
 
     setResult(value, replace = false) {
         if (replace) {

package/src/moving-averages/bollingerBands.js

@@ -1,11 +1,13 @@
 import { FasterBollingerBands } from '../core-indicators/index.js'
 import { validateInputValues } from '../utilities/validators.js'
 import { initializeColumns } from '../core-functions/initializeColumns.js'
+import { mathLog } from '../utilities/math.js'
 
-export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
+export const bollingerBands = (main, index, size, stdDev, { lag, retLogs = false } = {}) => {
   const { verticalOhlcv, instances, useFullNames } = main
   const indicatorKey = `${size}_${stdDev}`
-  const prefix = 'bollinger_bands'
+  const instanceKey = `${retLogs ? 'ret_log_' : ''}${indicatorKey}`
+  const prefix = `${retLogs ? 'ret_log_' : ''}bollinger_bands`
   const target = 'close'
 
   // Initialization on the first call.
@@ -31,25 +33,28 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
       }
     }
 
-    instances.bollinger_bands.settings[indicatorKey] = new FasterBollingerBands(size, stdDev)
+    instances.bollinger_bands.settings[instanceKey] = new FasterBollingerBands(size, stdDev)
 
     const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-    const keyNames = [
+    const keyNames = retLogs ? [
+      `${prefix}_width${suffix}`,
+      `${prefix}_position${suffix}`,
+    ] : [
       `${prefix}_upper${suffix}`,
       `${prefix}_middle${suffix}`,
       `${prefix}_lower${suffix}`,
     ]
 
     initializeColumns(main, keyNames.map(key => ({
-      key, priceBased: priceBased.has(target)
+      key, priceBased: !retLogs && priceBased.has(target)
     })), { lag })
   }
 
   const { numberOfIndicators } = instances.bollinger_bands
   const suffix = (numberOfIndicators > 1 || useFullNames) ? `_${indicatorKey}` : ''
 
-  const instance = instances.bollinger_bands.settings[indicatorKey]
+  const instance = instances.bollinger_bands.settings[instanceKey]
   const value = verticalOhlcv[target][index]
   instance.update(value)
 
@@ -59,6 +64,24 @@ export const bollingerBands = (main, index, size, stdDev, { lag } = {}) => {
   const middle = result?.middle ?? NaN
   const lower = result?.lower ?? NaN
 
+  if (retLogs) {
+    let width = NaN
+    let position = NaN
+    const rangeRatio = upper / lower
+    if (lower > 0 && upper >= lower && Number.isFinite(upper) && Number.isFinite(rangeRatio)) {
+      const logRange = mathLog(rangeRatio, 1)
+      width = logRange / 2
+      const locationRatio = value / lower
+      if (logRange > 0 && value > 0 && locationRatio > 0 && Number.isFinite(locationRatio)) {
+        const normalized = 2 * mathLog(locationRatio, 1) / logRange - 1
+        if (Number.isFinite(normalized)) position = normalized
+      }
+    }
+    main.pushToMain({ index, key: `${prefix}_width${suffix}`, value: width })
+    main.pushToMain({ index, key: `${prefix}_position${suffix}`, value: position })
+    return
+  }
+
   main.pushToMain({ index, key: `${prefix}_upper${suffix}`, value: upper })
   main.pushToMain({ index, key: `${prefix}_middle${suffix}`, value: middle })
   main.pushToMain({ index, key: `${prefix}_lower${suffix}`, value: lower })

package/src/moving-averages/donchianChannel.js

@@ -1,36 +1,40 @@
 import { validateInputValues } from '../utilities/validators.js'
 import { initializeColumns } from '../core-functions/initializeColumns.js'
+import { mathLog } from '../utilities/math.js'
 
 export const donchianChannels = (main, index, size, offset, options) => {
   const { verticalOhlcv, instances, len, inputParams, useFullNames } = main
-  const { lag: outputLag = 0 } = options
+  const { lag: outputLag = 0, retLogs = false } = options
   const indicatorKey = `${size}_${offset}`
+  const instanceKey = `${retLogs ? 'ret_log_' : ''}${indicatorKey}`
+  const prefix = `${retLogs ? 'ret_log_' : ''}donchian_channel`
 
   // ---- INIT (only at first bar) ----
   if (index === 0) {
     validateInputValues({ high: true, low: true }, verticalOhlcv, index, 'donchianChannels')
+    if (retLogs) validateInputValues({ close: true }, verticalOhlcv, index, 'donchianChannels')
 
     const numberOfIndicators = inputParams.filter(o => o.key === 'donchianChannels').length
     const useIndexedKeys = numberOfIndicators > 1 || useFullNames
 
     const getKey = name =>
       useIndexedKeys
-        ? `donchian_channel_${name}_${indicatorKey}`
-        : `donchian_channel_${name}`
+        ? `${prefix}_${name}_${indicatorKey}`
+        : `${prefix}_${name}`
 
-    const keys = ['upper', 'basis', 'lower'].map(getKey)
+    const keys = (retLogs ? ['width', 'position'] : ['upper', 'basis', 'lower']).map(getKey)
 
     if (!instances.donchian_channel) {
       instances.donchian_channel = { numberOfIndicators, settings: {} }
     }
 
     instances.donchian_channel.numberOfIndicators = numberOfIndicators
-    instances.donchian_channel.settings[indicatorKey] = {
+    instances.donchian_channel.settings[instanceKey] = {
       maxDeque: { indices: [], head: 0, length: 0 },
       minDeque: { indices: [], head: 0, length: 0 }
     }
 
-    initializeColumns(main, keys.map(key => ({ key, priceBased: true })), { lag: outputLag })
+    initializeColumns(main, keys.map(key => ({ key, priceBased: !retLogs })), { lag: outputLag })
   }
 
   // ---- PER-BAR COMPUTATION ----
@@ -39,10 +43,10 @@ export const donchianChannels = (main, index, size, offset, options) => {
 
   const getKey = name =>
     useIndexedKeys
-      ? `donchian_channel_${name}_${indicatorKey}`
-      : `donchian_channel_${name}`
+      ? `${prefix}_${name}_${indicatorKey}`
+      : `${prefix}_${name}`
 
-  const { maxDeque, minDeque } = settings[indicatorKey]
+  const { maxDeque, minDeque } = settings[instanceKey]
   const current = index - offset
   const start = current - size + 1
 
@@ -74,6 +78,27 @@ export const donchianChannels = (main, index, size, offset, options) => {
   const hasBounds = maxDeque.length && minDeque.length
   const upper = hasBounds ? highs[maxDeque.indices[maxDeque.head]] : NaN
   const lower = hasBounds ? lows[minDeque.indices[minDeque.head]] : NaN
+
+  if (retLogs) {
+    let width = NaN
+    let position = NaN
+    const rangeRatio = upper / lower
+    if (lower > 0 && upper >= lower && Number.isFinite(upper) && Number.isFinite(rangeRatio)) {
+      const logRange = mathLog(rangeRatio, 1)
+      width = logRange / 2
+      // Offset applies to the channel window, not to the current close.
+      const close = verticalOhlcv.close[index]
+      const locationRatio = close / lower
+      if (logRange > 0 && close > 0 && locationRatio > 0 && Number.isFinite(locationRatio)) {
+        const normalized = 2 * mathLog(locationRatio, 1) / logRange - 1
+        if (Number.isFinite(normalized)) position = normalized
+      }
+    }
+    main.pushToMain({ index, key: getKey('width'), value: width })
+    main.pushToMain({ index, key: getKey('position'), value: position })
+    return
+  }
+
   const basis = hasBounds ? (upper + lower) / 2 : NaN
 
   main.pushToMain({ index, key: getKey('upper'), value: upper })