ccxt-look 1.81.50

package/js/base/functions/generic.js

@@ -0,0 +1,270 @@
+"use strict";
+
+// ----------------------------------------------------------------------------
+
+const { isObject, isNumber, isDictionary, isArray } = require ('./type')
+
+// ----------------------------------------------------------------------------
+
+const keys = Object.keys
+    , values = (x) => ((!isArray (x)) ? Object.values (x) : x) // don't copy arrays if they're already arrays
+    , index = (x) => new Set (values (x))
+    , extend = (...args) => Object.assign ({}, ...args) // NB: side-effect free
+    , clone = (x) => (isArray (x) ? Array.from (x) : extend (x)) // clone arrays or objects
+
+// ----------------------------------------------------------------------------
+
+module.exports = {
+    keys
+    , values
+    , extend
+    , clone
+    , index
+    , ordered: (x) => x // a stub to keep assoc keys in order (in JS it does nothing, it's mostly for Python)
+    , unique: (x) => Array.from (index (x))
+    , arrayConcat: (a, b) => a.concat (b)
+
+    // ------------------------------------------------------------------------
+
+    , inArray (needle, haystack) {
+
+        return haystack.includes (needle)
+    }
+
+    , toArray (object) {
+
+        return Object.values (object)
+    }
+
+    , isEmpty (object) {
+        if (!object) {
+            return true
+        }
+        return (Array.isArray (object) ? object : Object.keys (object)).length < 1;
+    }
+
+    // ------------------------------------------------------------------------
+
+    , keysort (x, out = {}) {
+
+        for (const k of keys (x).sort ()) {
+            out[k] = x[k]
+        }
+
+        return out
+    }
+
+    // ------------------------------------------------------------------------
+
+    /*
+        Accepts a map/array of objects and a key name to be used as an index:
+        array = [
+            { someKey: 'value1', anotherKey: 'anotherValue1' },
+            { someKey: 'value2', anotherKey: 'anotherValue2' },
+            { someKey: 'value3', anotherKey: 'anotherValue3' },
+        ]
+        key = 'someKey'
+
+        Returns a map:
+        {
+            value1: { someKey: 'value1', anotherKey: 'anotherValue1' },
+            value2: { someKey: 'value2', anotherKey: 'anotherValue2' },
+            value3: { someKey: 'value3', anotherKey: 'anotherValue3' },
+        }
+    */
+
+    , indexBy (x, k, out = {}) {
+
+        for (const v of values (x)) {
+            if (k in v) {
+                out[v[k]] = v
+            }
+        }
+
+        return out
+    }
+
+    // ------------------------------------------------------------------------
+
+    /*
+        Accepts a map/array of objects and a key name to be used as a grouping parameter:
+        array = [
+            { someKey: 'value1', anotherKey: 'anotherValue1' },
+            { someKey: 'value1', anotherKey: 'anotherValue2' },
+            { someKey: 'value3', anotherKey: 'anotherValue3' },
+        ]
+        key = 'someKey'
+
+        Returns a map:
+        {
+            value1: [
+                { someKey: 'value1', anotherKey: 'anotherValue1' },
+                { someKey: 'value1', anotherKey: 'anotherValue2' },
+            ]
+            value3: [
+                { someKey: 'value3', anotherKey: 'anotherValue3' }
+            ],
+        }
+    */
+
+    , groupBy (x, k, out = {}) {
+
+        for (const v of values (x)) {
+            if (k in v) {
+                const p = v[k]
+                out[p] = out[p] || []
+                out[p].push (v)
+            }
+        }
+        return out
+    }
+
+    // ------------------------------------------------------------------------
+
+    /*
+        Accepts a map/array of objects, a key name and a key value to be used as a filter:
+        array = [
+            { someKey: 'value1', anotherKey: 'anotherValue1' },
+            { someKey: 'value2', anotherKey: 'anotherValue2' },
+            { someKey: 'value3', anotherKey: 'anotherValue3' },
+        ]
+        key = 'someKey'
+        value = 'value1'
+
+        Returns an array:
+        [
+            value1: { someKey: 'value1', anotherKey: 'anotherValue1' },
+        ]
+    */
+
+    , filterBy (x, k, value = undefined, out = []) {
+
+        for (const v of values (x)) {
+            if (v[k] === value) {
+                out.push (v)
+            }
+        }
+
+        return out
+    }
+
+    // ------------------------------------------------------------------------
+    // NB: MUTATES ARRAY!
+
+    , sortBy: (array, key, descending = false, direction  = descending ? -1 : 1) => array.sort ((a, b) => {
+        if (a[key] < b[key]) {
+            return -direction
+        } else if (a[key] > b[key]) {
+            return direction
+        } else {
+            return 0
+        }
+    })
+
+    , sortBy2: (array, key1, key2, descending = false, direction  = descending ? -1 : 1) => array.sort ((a, b) => {
+        if (a[key1] < b[key1]) {
+            return -direction
+        } else if (a[key1] > b[key1]) {
+            return direction
+        } else {
+            if (a[key2] < b[key2]) {
+                return -direction;
+            } else if (a[key2] > b[key2]) {
+                return direction;
+            } else {
+                return 0
+            }
+        }
+    })
+
+    // ------------------------------------------------------------------------
+
+    , flatten: function flatten (x, out = []) {
+
+        for (const v of x) {
+            if (isArray (v)) {
+                flatten (v, out)
+            } else {
+                out.push (v)
+            }
+        }
+
+        return out
+    }
+
+    // ------------------------------------------------------------------------
+
+    , pluck: (x, k) => values (x).filter ((v) => k in v).map ((v) => v[k])
+
+    // ------------------------------------------------------------------------
+
+    , omit (x, ...args) {
+
+        if (!Array.isArray (x)) {
+
+            const out = clone (x)
+
+            for (const k of args) {
+                if (isArray (k)) { // omit (x, ['a', 'b'])
+                    for (const kk of k) {
+                        delete out[kk]
+                    }
+                } else {
+                    delete out[k] // omit (x, 'a', 'b')
+                }
+            }
+
+            return out
+        }
+
+        return x
+    }
+
+    // ------------------------------------------------------------------------
+
+    , sum (...xs) {
+
+        const ns = xs.filter (isNumber) // leave only numbers
+
+        return (ns.length > 0) ? ns.reduce ((a, b) => a + b, 0) : undefined
+    }
+
+    // ------------------------------------------------------------------------
+
+    , deepExtend: function deepExtend (...xs) {
+        let out = undefined
+        for (const x of xs) {
+            if (isDictionary (x)) {
+                if (!isDictionary (out)) {
+                    out = {}
+                }
+                for (const k in x) {
+                    out[k] = deepExtend (out[k], x[k])
+                }
+            } else {
+                out = x
+            }
+        }
+        return out
+    }
+
+    // ------------------------------------------------------------------------
+
+    , merge (target, ...args) {
+        // doesn't overwrite defined keys with undefined
+        const overwrite = {}
+        const merged = Object.assign ({}, ...args)
+        const keys = Object.keys (merged)
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i]
+            if (target[key] === undefined) {
+                overwrite[key] = merged[key]
+            }
+        }
+        // eslint-disable-next-line
+        return Object.assign ({}, target, overwrite)
+    }
+
+// ----------------------------------------------------------------------------
+
+}

package/js/base/functions/misc.js

@@ -0,0 +1,138 @@
+'use strict';
+
+const { ROUND_UP, ROUND_DOWN } = require ('./number')
+const { NotSupported } = require ('../errors')
+
+//-------------------------------------------------------------------------
+// converts timeframe to seconds
+const parseTimeframe = (timeframe) => {
+
+    const amount = timeframe.slice (0, -1)
+    const unit = timeframe.slice (-1)
+    let scale = undefined;
+
+    if (unit === 'y') {
+        scale = 60 * 60 * 24 * 365
+    } else if (unit === 'M') {
+        scale = 60 * 60 * 24 * 30
+    } else if (unit === 'w') {
+        scale = 60 * 60 * 24 * 7
+    } else if (unit === 'd') {
+        scale = 60 * 60 * 24
+    } else if (unit === 'h') {
+        scale = 60 * 60
+    } else if (unit === 'm') {
+        scale = 60
+    } else if (unit === 's') {
+        scale = 1
+    } else {
+        throw new NotSupported ('timeframe unit ' + unit + ' is not supported')
+    }
+
+    return amount * scale
+}
+
+const roundTimeframe = (timeframe, timestamp, direction = ROUND_DOWN) => {
+    const ms = parseTimeframe (timeframe) * 1000
+    // Get offset based on timeframe in milliseconds
+    const offset = timestamp % ms
+    return timestamp - offset + ((direction === ROUND_UP) ? ms : 0);
+}
+
+// given a sorted arrays of trades (recent last) and a timeframe builds an array of OHLCV candles
+const buildOHLCVC = (trades, timeframe = '1m', since = -Infinity, limit = Infinity) => {
+    const ms = parseTimeframe (timeframe) * 1000;
+    const ohlcvs = [];
+    const [ timestamp, /* open */, high, low, close, volume, count ] = [ 0, 1, 2, 3, 4, 5, 6 ];
+    const oldest = Math.min (trades.length - 1, limit);
+
+    for (let i = 0; i <= oldest; i++) {
+        const trade = trades[i];
+        if (trade.timestamp < since) {
+            continue;
+        }
+        const openingTime = Math.floor (trade.timestamp / ms) * ms; // shift to the edge of m/h/d (but not M)
+        const candle = ohlcvs.length - 1;
+
+        if (candle === -1 || openingTime >= ohlcvs[candle][timestamp] + ms) {
+            // moved to a new timeframe -> create a new candle from opening trade
+            ohlcvs.push ([
+                openingTime,  // timestamp
+                trade.price,  // O
+                trade.price,  // H
+                trade.price,  // L
+                trade.price,  // C
+                trade.amount, // V
+                1,            // count
+            ]);
+        } else {
+            // still processing the same timeframe -> update opening trade
+            ohlcvs[candle][high] = Math.max (ohlcvs[candle][high], trade.price);
+            ohlcvs[candle][low] = Math.min (ohlcvs[candle][low], trade.price);
+            ohlcvs[candle][close] = trade.price;
+            ohlcvs[candle][volume] += trade.amount;
+            ohlcvs[candle][count]++;
+        } // if
+    } // for
+    return ohlcvs;
+}
+
+const extractParams = (string) => {
+    const re = /{([\w-]+)}/g
+    const matches = []
+    let match = re.exec (string)
+    while (match) {
+        matches.push (match[1])
+        match = re.exec (string)
+    }
+    return matches
+}
+
+const implodeParams = (string, params) => {
+    if (!Array.isArray (params)) {
+        const keys = Object.keys (params)
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i]
+            if (!Array.isArray (params[key])) {
+                string = string.replace ('{' + key + '}', params[key])
+            }
+        }
+    }
+    return string
+}
+
+function vwap (baseVolume, quoteVolume) {
+    return ((baseVolume !== undefined) && (quoteVolume !== undefined) && (baseVolume > 0)) ? (quoteVolume / baseVolume) : undefined
+}
+
+/*  ------------------------------------------------------------------------ */
+
+module.exports = {
+
+    aggregate (bidasks) {
+
+        const result = {}
+
+        for (let i = 0; i < bidasks.length; i++) {
+            const [ price, volume ] = bidasks[i];
+            if (volume > 0) {
+                result[price] = (result[price] || 0) + volume
+            }
+        }
+
+        return Object.keys (result).map ((price) => [parseFloat (price), parseFloat (result[price])])
+    },
+
+    parseTimeframe,
+    roundTimeframe,
+    buildOHLCVC,
+    ROUND_UP,
+    ROUND_DOWN,
+
+    implodeParams,
+    extractParams,
+
+    vwap,
+}
+
+/*  ------------------------------------------------------------------------ */