nodejs-order-book 10.0.1 → 10.2.0

package/dist/esm/orderqueue.js

@@ -1,72 +1,73 @@
 /* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
 import Denque from "denque";
-var OrderQueue = /** @class */ (function () {
-    function OrderQueue(price) {
-        var _this = this;
-        this._ordersMap = {};
-        // returns the number of orders in queue
-        this.len = function () {
-            return _this._orders.length;
-        };
-        this.toArray = function () {
-            return _this._orders.toArray();
-        };
-        // returns price level of the queue
-        this.price = function () {
-            return _this._price;
-        };
-        // returns price level of the queue
-        this.volume = function () {
-            return _this._volume;
-        };
-        // returns top order in queue
-        this.head = function () {
-            return _this._orders.peekFront();
-        };
-        // returns bottom order in queue
-        this.tail = function () {
-            return _this._orders.peekBack();
-        };
-        // adds order to tail of the queue
-        this.append = function (order) {
-            _this._volume += order.size;
-            _this._orders.push(order);
-            _this._ordersMap[order.id] = _this._orders.length - 1;
-            return order;
-        };
-        // sets up new order to list value
-        this.update = function (oldOrder, newOrder) {
-            _this._volume -= oldOrder.size;
-            _this._volume += newOrder.size;
-            // Remove old order from head
-            _this._orders.shift();
-            delete _this._ordersMap[oldOrder.id];
-            // Add new order to head
-            _this._orders.unshift(newOrder);
-            _this._ordersMap[newOrder.id] = 0;
-        };
-        // removes order from the queue
-        this.remove = function (order) {
-            _this._volume -= order.size;
-            var deletedOrderIndex = _this._ordersMap[order.id];
-            _this._orders.removeOne(deletedOrderIndex);
-            delete _this._ordersMap[order.id];
-            // Update all orders indexes where index is greater than the deleted one
-            for (var orderId in _this._ordersMap) {
-                if (_this._ordersMap[orderId] > deletedOrderIndex) {
-                    _this._ordersMap[orderId] -= 1;
-                }
-            }
-        };
-        this.updateOrderSize = function (order, size) {
-            _this._volume += size - order.size; // update volume
-            order.size = size;
-            order.time = Date.now();
-        };
+export class OrderQueue {
+    _price;
+    _volume;
+    // { orderID: index } index in denque
+    _orders;
+    _ordersMap = {};
+    constructor(price) {
         this._price = price;
         this._volume = 0;
         this._orders = new Denque();
     }
-    return OrderQueue;
-}());
-export { OrderQueue };
+    // returns the number of orders in queue
+    len = () => {
+        return this._orders.length;
+    };
+    toArray = () => {
+        return this._orders.toArray();
+    };
+    // returns price level of the queue
+    price = () => {
+        return this._price;
+    };
+    // returns price level of the queue
+    volume = () => {
+        return this._volume;
+    };
+    // returns top order in queue
+    head = () => {
+        return this._orders.peekFront();
+    };
+    // returns bottom order in queue
+    tail = () => {
+        return this._orders.peekBack();
+    };
+    // adds order to tail of the queue
+    append = (order) => {
+        this._volume += order.size;
+        this._orders.push(order);
+        this._ordersMap[order.id] = this._orders.length - 1;
+        return order;
+    };
+    // sets up new order to list value
+    update = (oldOrder, newOrder) => {
+        this._volume -= oldOrder.size;
+        this._volume += newOrder.size;
+        // Remove old order from head
+        this._orders.shift();
+        delete this._ordersMap[oldOrder.id];
+        // Add new order to head
+        this._orders.unshift(newOrder);
+        this._ordersMap[newOrder.id] = 0;
+    };
+    // removes order from the queue
+    remove = (order) => {
+        this._volume -= order.size;
+        const deletedOrderIndex = this._ordersMap[order.id];
+        this._orders.removeOne(deletedOrderIndex);
+        delete this._ordersMap[order.id];
+        // Update all orders indexes where index is greater than the deleted one
+        for (const orderId in this._ordersMap) {
+            if (this._ordersMap[orderId] > deletedOrderIndex) {
+                this._ordersMap[orderId] -= 1;
+            }
+        }
+    };
+    updateOrderSize = (order, size) => {
+        this._volume += size - order.size; // update volume
+        order.size = size;
+        order.time = Date.now();
+    };
+}

package/dist/esm/orderside.js

@@ -1,152 +1,143 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 /* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
 import createRBTree from "functional-red-black-tree";
 import { CustomError, ERROR } from "./errors";
 import { OrderFactory } from "./order";
 import { OrderQueue } from "./orderqueue";
 import { Side } from "./types";
-var OrderSide = /** @class */ (function () {
-    function OrderSide(side) {
-        var _this = this;
-        this._prices = {};
-        this._volume = 0;
-        this._total = 0;
-        this._numOrders = 0;
-        this._depthSide = 0;
-        this._side = Side.SELL;
-        // returns amount of orders
-        this.len = function () {
-            return _this._numOrders;
-        };
-        // returns depth of market
-        this.depth = function () {
-            return _this._depthSide;
-        };
-        // returns total amount of quantity in side
-        this.volume = function () {
-            return _this._volume;
-        };
-        // returns the total (size * price of each price level) in side
-        this.total = function () {
-            return _this._total;
-        };
-        // returns the price tree in side
-        this.priceTree = function () {
-            return _this._priceTree;
-        };
-        // appends order to definite price level
-        this.append = function (order) {
-            var price = order.price;
-            var strPrice = price.toString();
-            if (_this._prices[strPrice] === undefined) {
-                var priceQueue = new OrderQueue(price);
-                _this._prices[strPrice] = priceQueue;
-                _this._priceTree = _this._priceTree.insert(price, priceQueue);
-                _this._depthSide += 1;
-            }
-            _this._numOrders += 1;
-            _this._volume += order.size;
-            _this._total += order.size * order.price;
-            return _this._prices[strPrice].append(order);
-        };
-        // removes order from definite price level
-        this.remove = function (order) {
-            var price = order.price;
-            var strPrice = price.toString();
-            if (_this._prices[strPrice] === undefined) {
-                throw CustomError(ERROR.INVALID_PRICE_LEVEL);
-            }
-            _this._prices[strPrice].remove(order);
-            if (_this._prices[strPrice].len() === 0) {
-                delete _this._prices[strPrice];
-                _this._priceTree = _this._priceTree.remove(price);
-                _this._depthSide -= 1;
-            }
-            _this._numOrders -= 1;
-            _this._volume -= order.size;
-            _this._total -= order.size * order.price;
-            return order;
-        };
-        // Update the price of an order and return the order with the updated price
-        this.updateOrderPrice = function (oldOrder, orderUpdate) {
-            _this.remove(oldOrder);
-            var newOrder = OrderFactory.createOrder(__assign(__assign({}, oldOrder.toObject()), { size: orderUpdate.size !== undefined ? orderUpdate.size : oldOrder.size, price: orderUpdate.price, time: Date.now() }));
-            _this.append(newOrder);
-            return newOrder;
-        };
-        // Update the price of an order and return the order with the updated price
-        this.updateOrderSize = function (oldOrder, orderUpdate) {
-            var _a;
-            var newOrderPrice = (_a = orderUpdate.price) !== null && _a !== void 0 ? _a : oldOrder.price;
-            _this._volume += orderUpdate.size - oldOrder.size;
-            _this._total +=
-                orderUpdate.size * newOrderPrice - oldOrder.size * oldOrder.price;
-            _this._prices[oldOrder.price.toString()].updateOrderSize(oldOrder, orderUpdate.size);
-            return oldOrder;
-        };
-        // returns max level of price
-        this.maxPriceQueue = function () {
-            if (_this._depthSide > 0) {
-                var max = _this._side === Side.SELL ? _this._priceTree.end : _this._priceTree.begin;
-                return max.value;
-            }
-        };
-        // returns min level of price
-        this.minPriceQueue = function () {
-            if (_this._depthSide > 0) {
-                var min = _this._side === Side.SELL ? _this._priceTree.begin : _this._priceTree.end;
-                return min.value;
-            }
-        };
-        // returns nearest OrderQueue with price less than given
-        this.lowerThan = function (price) {
-            var node = _this._side === Side.SELL
-                ? _this._priceTree.lt(price)
-                : _this._priceTree.gt(price);
-            return node.value;
-        };
-        // returns nearest OrderQueue with price greater than given
-        this.greaterThan = function (price) {
-            var node = _this._side === Side.SELL
-                ? _this._priceTree.gt(price)
-                : _this._priceTree.lt(price);
-            return node.value;
-        };
-        // returns all orders
-        this.orders = function () {
-            var orders = [];
-            for (var price in _this._prices) {
-                var allOrders = _this._prices[price].toArray();
-                orders = orders.concat(allOrders);
-            }
-            return orders;
-        };
-        this.toString = function () {
-            var s = "";
-            var level = _this.maxPriceQueue();
-            while (level !== undefined) {
-                var volume = level.volume().toString();
-                s += "\n".concat(level.price(), " -> ").concat(volume);
-                level = _this.lowerThan(level.price());
-            }
-            return s;
-        };
-        var compare = side === Side.SELL
-            ? function (a, b) { return a - b; }
-            : function (a, b) { return b - a; };
+export class OrderSide {
+    _priceTree;
+    _prices = {};
+    _volume = 0;
+    _total = 0;
+    _numOrders = 0;
+    _depthSide = 0;
+    _side = Side.SELL;
+    constructor(side) {
+        const compare = side === Side.SELL
+            ? (a, b) => a - b
+            : (a, b) => b - a;
         this._priceTree = createRBTree(compare);
         this._side = side;
     }
-    return OrderSide;
-}());
-export { OrderSide };
+    // returns amount of orders
+    len = () => {
+        return this._numOrders;
+    };
+    // returns depth of market
+    depth = () => {
+        return this._depthSide;
+    };
+    // returns total amount of quantity in side
+    volume = () => {
+        return this._volume;
+    };
+    // returns the total (size * price of each price level) in side
+    total = () => {
+        return this._total;
+    };
+    // returns the price tree in side
+    priceTree = () => {
+        return this._priceTree;
+    };
+    // appends order to definite price level
+    append = (order) => {
+        const price = order.price;
+        const strPrice = price.toString();
+        if (this._prices[strPrice] === undefined) {
+            const priceQueue = new OrderQueue(price);
+            this._prices[strPrice] = priceQueue;
+            this._priceTree = this._priceTree.insert(price, priceQueue);
+            this._depthSide += 1;
+        }
+        this._numOrders += 1;
+        this._volume += order.size;
+        this._total += order.size * order.price;
+        return this._prices[strPrice].append(order);
+    };
+    // removes order from definite price level
+    remove = (order) => {
+        const price = order.price;
+        const strPrice = price.toString();
+        if (this._prices[strPrice] === undefined) {
+            throw CustomError(ERROR.INVALID_PRICE_LEVEL);
+        }
+        this._prices[strPrice].remove(order);
+        if (this._prices[strPrice].len() === 0) {
+            delete this._prices[strPrice];
+            this._priceTree = this._priceTree.remove(price);
+            this._depthSide -= 1;
+        }
+        this._numOrders -= 1;
+        this._volume -= order.size;
+        this._total -= order.size * order.price;
+        return order;
+    };
+    // Update the price of an order and return the order with the updated price
+    updateOrderPrice = (oldOrder, orderUpdate) => {
+        this.remove(oldOrder);
+        const newOrder = OrderFactory.createOrder({
+            ...oldOrder.toObject(),
+            size: orderUpdate.size !== undefined ? orderUpdate.size : oldOrder.size,
+            price: orderUpdate.price,
+            time: Date.now(),
+        });
+        this.append(newOrder);
+        return newOrder;
+    };
+    // Update the price of an order and return the order with the updated price
+    updateOrderSize = (oldOrder, orderUpdate) => {
+        const newOrderPrice = orderUpdate.price ?? oldOrder.price;
+        this._volume += orderUpdate.size - oldOrder.size;
+        this._total +=
+            orderUpdate.size * newOrderPrice - oldOrder.size * oldOrder.price;
+        this._prices[oldOrder.price.toString()].updateOrderSize(oldOrder, orderUpdate.size);
+        return oldOrder;
+    };
+    // returns max level of price
+    maxPriceQueue = () => {
+        if (this._depthSide > 0) {
+            const max = this._side === Side.SELL ? this._priceTree.end : this._priceTree.begin;
+            return max.value;
+        }
+    };
+    // returns min level of price
+    minPriceQueue = () => {
+        if (this._depthSide > 0) {
+            const min = this._side === Side.SELL ? this._priceTree.begin : this._priceTree.end;
+            return min.value;
+        }
+    };
+    // returns nearest OrderQueue with price less than given
+    lowerThan = (price) => {
+        const node = this._side === Side.SELL
+            ? this._priceTree.lt(price)
+            : this._priceTree.gt(price);
+        return node.value;
+    };
+    // returns nearest OrderQueue with price greater than given
+    greaterThan = (price) => {
+        const node = this._side === Side.SELL
+            ? this._priceTree.gt(price)
+            : this._priceTree.lt(price);
+        return node.value;
+    };
+    // returns all orders
+    orders = () => {
+        let orders = [];
+        for (const price in this._prices) {
+            const allOrders = this._prices[price].toArray();
+            orders = orders.concat(allOrders);
+        }
+        return orders;
+    };
+    toString = () => {
+        let s = "";
+        let level = this.maxPriceQueue();
+        while (level !== undefined) {
+            const volume = level.volume().toString();
+            s += `\n${level.price()} -> ${volume}`;
+            level = this.lowerThan(level.price());
+        }
+        return s;
+    };
+}

package/dist/esm/stopbook.js

@@ -1,73 +1,72 @@
 import { StopSide } from "./stopside";
 import { OrderType, Side } from "./types";
-var StopBook = /** @class */ (function () {
-    function StopBook() {
-        var _this = this;
-        this.add = function (order) {
-            var stopSide = order.side === Side.BUY ? _this.bids : _this.asks;
-            stopSide.append(order);
-        };
-        this.remove = function (side, id, stopPrice) {
-            var stopSide = side === Side.BUY ? _this.bids : _this.asks;
-            return stopSide.remove(id, stopPrice);
-        };
-        this.removePriceLevel = function (side, priceLevel) {
-            var stopSide = side === Side.BUY ? _this.bids : _this.asks;
-            stopSide.removePriceLevel(priceLevel);
-        };
-        this.getConditionalOrders = function (side, priceBefore, marketPrice) {
-            var stopSide = side === Side.BUY ? _this.bids : _this.asks;
-            return stopSide.between(priceBefore, marketPrice);
-        };
-        /**
-         * Stop-Limit Order:
-         *    Buy: marketPrice < stopPrice <= price
-         *    Sell: marketPrice > stopPrice >= price
-         * Stop-Market Order:
-         *    Buy: marketPrice < stopPrice
-         *    Sell: marketPrice > stopPrice
-         */
-        this.validConditionalOrder = function (marketPrice, order) {
-            var response = false;
-            var type = order.type, side = order.side, stopPrice = order.stopPrice;
-            if (type === OrderType.STOP_LIMIT) {
-                // Buy: marketPrice < stopPrice <= price
-                if (side === Side.BUY &&
-                    marketPrice < stopPrice &&
-                    stopPrice <= order.price) {
-                    response = true;
-                }
-                // Sell: marketPrice > stopPrice >= price
-                if (side === Side.SELL &&
-                    marketPrice > stopPrice &&
-                    stopPrice >= order.price) {
-                    response = true;
-                }
-            }
-            else {
-                // Buy: marketPrice < stopPrice
-                if (side === Side.BUY && marketPrice < stopPrice)
-                    response = true;
-                // Sell: marketPrice > stopPrice
-                if (side === Side.SELL && marketPrice > stopPrice)
-                    response = true;
-            }
-            return response;
-        };
-        this.snapshot = function () {
-            var bids = [];
-            var asks = [];
-            _this.bids.priceTree().forEach(function (price, orders) {
-                bids.push({ price: price, orders: orders.toArray().map(function (o) { return o.toObject(); }) });
-            });
-            _this.asks.priceTree().forEach(function (price, orders) {
-                asks.push({ price: price, orders: orders.toArray().map(function (o) { return o.toObject(); }) });
-            });
-            return { bids: bids, asks: asks };
-        };
+export class StopBook {
+    bids;
+    asks;
+    constructor() {
         this.bids = new StopSide(Side.BUY);
         this.asks = new StopSide(Side.SELL);
     }
-    return StopBook;
-}());
-export { StopBook };
+    add = (order) => {
+        const stopSide = order.side === Side.BUY ? this.bids : this.asks;
+        stopSide.append(order);
+    };
+    remove = (side, id, stopPrice) => {
+        const stopSide = side === Side.BUY ? this.bids : this.asks;
+        return stopSide.remove(id, stopPrice);
+    };
+    removePriceLevel = (side, priceLevel) => {
+        const stopSide = side === Side.BUY ? this.bids : this.asks;
+        stopSide.removePriceLevel(priceLevel);
+    };
+    getConditionalOrders = (side, priceBefore, marketPrice) => {
+        const stopSide = side === Side.BUY ? this.bids : this.asks;
+        return stopSide.between(priceBefore, marketPrice);
+    };
+    /**
+     * Stop-Limit Order:
+     *    Buy: marketPrice < stopPrice <= price
+     *    Sell: marketPrice > stopPrice >= price
+     * Stop-Market Order:
+     *    Buy: marketPrice < stopPrice
+     *    Sell: marketPrice > stopPrice
+     */
+    validConditionalOrder = (marketPrice, order) => {
+        let response = false;
+        const { type, side, stopPrice } = order;
+        if (type === OrderType.STOP_LIMIT) {
+            // Buy: marketPrice < stopPrice <= price
+            if (side === Side.BUY &&
+                marketPrice < stopPrice &&
+                stopPrice <= order.price) {
+                response = true;
+            }
+            // Sell: marketPrice > stopPrice >= price
+            if (side === Side.SELL &&
+                marketPrice > stopPrice &&
+                stopPrice >= order.price) {
+                response = true;
+            }
+        }
+        else {
+            // Buy: marketPrice < stopPrice
+            if (side === Side.BUY && marketPrice < stopPrice)
+                response = true;
+            // Sell: marketPrice > stopPrice
+            if (side === Side.SELL && marketPrice > stopPrice)
+                response = true;
+        }
+        return response;
+    };
+    snapshot = () => {
+        const bids = [];
+        const asks = [];
+        this.bids.priceTree().forEach((price, orders) => {
+            bids.push({ price, orders: orders.toArray().map((o) => o.toObject()) });
+        });
+        this.asks.priceTree().forEach((price, orders) => {
+            asks.push({ price, orders: orders.toArray().map((o) => o.toObject()) });
+        });
+        return { bids, asks };
+    };
+}

package/dist/esm/stopqueue.js

@@ -1,56 +1,51 @@
 /* node:coverage ignore next - Don't know why first and last line of each file count as uncovered */
 import Denque from "denque";
-var StopQueue = /** @class */ (function () {
-    function StopQueue(price) {
-        var _this = this;
-        this._ordersMap = {};
-        // returns the number of orders in queue
-        this.len = function () {
-            return _this._orders.length;
-        };
-        // remove order from head of queue
-        this.removeFromHead = function () {
-            // We can't use the shift method here because we need
-            // to update index in the map, so we use the remove(id) function
-            var order = _this._orders.peekFront();
-            if (order === undefined)
-                return;
-            return _this.remove(order.id);
-        };
-        // adds order to tail of the queue
-        this.append = function (order) {
-            _this._orders.push(order);
-            _this._ordersMap[order.id] = _this._orders.length - 1;
-            return order;
-        };
-        // removes order from the queue
-        this.remove = function (id) {
-            var deletedOrderIndex = _this._ordersMap[id];
-            if (deletedOrderIndex === undefined)
-                return;
-            var deletedOrder = _this._orders.removeOne(deletedOrderIndex);
-            delete _this._ordersMap[id];
-            // Update all orders indexes where index is greater than the deleted one
-            for (var orderId in _this._ordersMap) {
-                if (_this._ordersMap[orderId] > deletedOrderIndex) {
-                    _this._ordersMap[orderId] -= 1;
-                }
-            }
-            return deletedOrder;
-        };
-        this.toArray = function () {
-            return _this._orders.toArray();
-        };
+export class StopQueue {
+    _price;
+    _orders;
+    _ordersMap = {};
+    constructor(price) {
         this._price = price;
         this._orders = new Denque();
     }
-    Object.defineProperty(StopQueue.prototype, "price", {
-        get: function () {
-            return this._price;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return StopQueue;
-}());
-export { StopQueue };
+    get price() {
+        return this._price;
+    }
+    // returns the number of orders in queue
+    len = () => {
+        return this._orders.length;
+    };
+    // remove order from head of queue
+    removeFromHead = () => {
+        // We can't use the shift method here because we need
+        // to update index in the map, so we use the remove(id) function
+        const order = this._orders.peekFront();
+        if (order === undefined)
+            return;
+        return this.remove(order.id);
+    };
+    // adds order to tail of the queue
+    append = (order) => {
+        this._orders.push(order);
+        this._ordersMap[order.id] = this._orders.length - 1;
+        return order;
+    };
+    // removes order from the queue
+    remove = (id) => {
+        const deletedOrderIndex = this._ordersMap[id];
+        if (deletedOrderIndex === undefined)
+            return;
+        const deletedOrder = this._orders.removeOne(deletedOrderIndex);
+        delete this._ordersMap[id];
+        // Update all orders indexes where index is greater than the deleted one
+        for (const orderId in this._ordersMap) {
+            if (this._ordersMap[orderId] > deletedOrderIndex) {
+                this._ordersMap[orderId] -= 1;
+            }
+        }
+        return deletedOrder;
+    };
+    toArray = () => {
+        return this._orders.toArray();
+    };
+}