upstox-js-sdk
Version:
The official Node Js client for communicating with the Upstox API
143 lines (139 loc) • 7.78 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _events = require("events");
function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } /**
* Interface for classes that manage a WebSocket connection.
*/
var _enableAutoReconnect = /*#__PURE__*/new WeakMap();
var _interval = /*#__PURE__*/new WeakMap();
var _retryCount = /*#__PURE__*/new WeakMap();
var _reconnectInterval = /*#__PURE__*/new WeakMap();
var _reconnectOpenListener = /*#__PURE__*/new WeakMap();
var _reconnectCloseListener = /*#__PURE__*/new WeakMap();
var _prepareAutoReconnect = /*#__PURE__*/new WeakSet();
class Streamer extends _events.EventEmitter {
constructor() {
super();
_classPrivateMethodInitSpec(this, _prepareAutoReconnect);
_defineProperty(this, "Event", Object.freeze({
OPEN: "open",
CLOSE: "close",
MESSAGE: "message",
ERROR: "error",
RECONNECTING: "reconnecting",
AUTO_RECONNECT_STOPPED: "autoReconnectStopped"
}));
_classPrivateFieldInitSpec(this, _enableAutoReconnect, {
writable: true,
value: void 0
});
_classPrivateFieldInitSpec(this, _interval, {
writable: true,
value: void 0
});
_classPrivateFieldInitSpec(this, _retryCount, {
writable: true,
value: void 0
});
_classPrivateFieldInitSpec(this, _reconnectInterval, {
writable: true,
value: void 0
});
_classPrivateFieldInitSpec(this, _reconnectOpenListener, {
writable: true,
value: void 0
});
_classPrivateFieldInitSpec(this, _reconnectCloseListener, {
writable: true,
value: void 0
});
_classPrivateFieldSet(this, _enableAutoReconnect, true);
_classPrivateFieldSet(this, _interval, 1);
_classPrivateFieldSet(this, _retryCount, 5);
_classPrivateFieldSet(this, _reconnectInterval, null);
_classPrivateFieldSet(this, _reconnectOpenListener, null);
_classPrivateFieldSet(this, _reconnectCloseListener, null);
_classPrivateMethodGet(this, _prepareAutoReconnect, _prepareAutoReconnect2).call(this);
if (new.target === Streamer) {
throw new TypeError("Cannot construct Streamer instances directly");
}
}
async connect() {
throw new Error("Method 'connect()' must be implemented.");
}
addEventsListeners() {
throw new Error("Method 'addEventsListeners()' must be implemented.");
}
setupEventListeners() {
this.streamer.on("open", () => this.emit(this.Event.OPEN));
this.streamer.on("data", data => {
this.emit(this.Event.MESSAGE, data);
});
this.streamer.on("error", error => this.emit(this.Event.ERROR, error));
this.streamer.on("close", () => this.emit(this.Event.CLOSE));
}
autoReconnect(enable, interval = 1, retryCount = 5) {
_classPrivateFieldSet(this, _enableAutoReconnect, enable);
_classPrivateFieldSet(this, _interval, interval);
_classPrivateFieldSet(this, _retryCount, retryCount);
if (!enable) {
this.emit(this.Event.AUTO_RECONNECT_STOPPED, "Stopped by client.");
return;
}
_classPrivateMethodGet(this, _prepareAutoReconnect, _prepareAutoReconnect2).call(this);
}
}
function _prepareAutoReconnect2() {
let counter = 0;
const attemptReconnect = async () => {
if (!_classPrivateFieldGet(this, _enableAutoReconnect)) {
clearInterval(_classPrivateFieldGet(this, _reconnectInterval));
return;
}
if (this.streamer.shouldReconnect()) {
this.emit(this.Event.RECONNECTING, `Auto reconnect attempt ${counter + 1}/${_classPrivateFieldGet(this, _retryCount)}`);
await this.connect();
counter++;
}
if (counter >= _classPrivateFieldGet(this, _retryCount)) {
clearInterval(_classPrivateFieldGet(this, _reconnectInterval));
this.streamer.clearSubscriptions();
this.emit(this.Event.AUTO_RECONNECT_STOPPED, `retryCount of ${_classPrivateFieldGet(this, _retryCount)} exhausted.`);
return;
}
};
// Remove existing listeners if they exist
if (_classPrivateFieldGet(this, _reconnectOpenListener)) {
this.removeListener("open", _classPrivateFieldGet(this, _reconnectOpenListener));
}
if (_classPrivateFieldGet(this, _reconnectCloseListener)) {
this.removeListener("close", _classPrivateFieldGet(this, _reconnectCloseListener));
}
// Define new listeners
_classPrivateFieldSet(this, _reconnectOpenListener, () => {
clearInterval(_classPrivateFieldGet(this, _reconnectInterval));
counter = 0;
});
_classPrivateFieldSet(this, _reconnectCloseListener, () => {
_classPrivateFieldSet(this, _reconnectInterval, setInterval(attemptReconnect, _classPrivateFieldGet(this, _interval) * 1000));
});
// Attach the new listeners
this.on("open", _classPrivateFieldGet(this, _reconnectOpenListener));
this.on("close", _classPrivateFieldGet(this, _reconnectCloseListener));
}
var _default = Streamer;
exports.default = _default;