binbot-charts 0.5.1 → 0.5.3

package/dist/src/components/datafeed.js

@@ -0,0 +1,199 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_js_1 = require("./helpers.js");
+const streaming_js_1 = require("./streaming.js");
+const binanceResolutions = [
+    "1s",
+    "1m",
+    "3m",
+    "5m",
+    "15m",
+    "30m",
+    "1h",
+    "2h",
+    "4h",
+    "6h",
+    "8h",
+    "12h",
+    "1d",
+    "3d",
+    "1w",
+    "1M",
+];
+const getConfigurationData = () => __awaiter(void 0, void 0, void 0, function* () {
+    return {
+        supports_marks: true,
+        supports_time: true,
+        supports_timescale_marks: true,
+        supports_time: true,
+        supported_resolutions: [
+            "1S",
+            "1",
+            "3",
+            "5",
+            "15",
+            "30",
+            "60",
+            "120",
+            "240",
+            "360",
+            "480",
+            "720",
+            "1D",
+            "3D",
+            "1W",
+            "12M",
+        ],
+        exchanges: [
+            {
+                value: "Binance",
+                name: "Binance",
+                desc: "Binance",
+            },
+        ],
+        symbols_types: [
+            {
+                name: "crypto",
+                value: "crypto",
+            },
+        ],
+    };
+});
+/**
+ * @param timescale { Array }. timescaleMark objects
+ * @param interval { string }. Klines timescale from the list of Binance Enums
+ */
+class Datafeed {
+    constructor(timescaleMarks = [], interval = "1h") {
+        this.onReady = (callback) => __awaiter(this, void 0, void 0, function* () {
+            this.configurationData = yield getConfigurationData();
+            callback(this.configurationData);
+        });
+        this.searchSymbols = (userInput, exchange, symbolType, onResultReadyCallback) => __awaiter(this, void 0, void 0, function* () {
+            const symbols = yield (0, helpers_js_1.getAllSymbols)(userInput);
+            onResultReadyCallback(symbols);
+        });
+        this.resolveSymbol = (symbolName, onSymbolResolvedCallback, onResolveErrorCallback) => __awaiter(this, void 0, void 0, function* () {
+            if (!symbolName) {
+                yield onResolveErrorCallback("cannot resolve symbol");
+                return;
+            }
+            const symbolInfo = () => {
+                return {
+                    ticker: symbolName,
+                    name: symbolName,
+                    ticker: symbolName,
+                    description: symbolName,
+                    type: "crypto",
+                    session: "24x7",
+                    timezone: "Etc/UTC",
+                    exchange: "Binance",
+                    minmov: 100,
+                    pricescale: 100000000,
+                    has_daily: true,
+                    has_intraday: true,
+                    has_no_volume: false,
+                    has_seconds: true,
+                    seconds_multipliers: [1],
+                    volume: "hundreds",
+                    volume_precision: 9,
+                    data_status: "streaming",
+                    resolution: "1h",
+                };
+            };
+            const symbol = yield symbolInfo();
+            onSymbolResolvedCallback(symbol);
+        });
+        this.getBars = (symbolInfo, resolution, periodParams, onHistoryCallback, onErrorCallback) => __awaiter(this, void 0, void 0, function* () {
+            const { from, to, firstDataRequest } = periodParams;
+            let interval = "60"; // 1 hour
+            // Calculate interval using resolution data
+            if (!/[a-zA-Z]$/.test(resolution)) {
+                if (parseInt(resolution) >= 60) {
+                    interval = parseInt(resolution) / 60 + "h";
+                }
+                else {
+                    interval = resolution + "m";
+                }
+            }
+            else {
+                interval = resolution.toLowerCase().replace(/[a-z]\b/g, c => c.toLowerCase());
+            }
+            let urlParameters = {
+                symbol: symbolInfo.name,
+                interval: interval,
+                startTime: Math.abs(from * 1000),
+                endTime: Math.abs(to * 1000),
+                limit: 600,
+            };
+            const query = Object.keys(urlParameters)
+                .map((name) => `${name}=${encodeURIComponent(urlParameters[name])}`)
+                .join("&");
+            try {
+                const data = yield (0, helpers_js_1.makeApiRequest)(`api/v3/uiKlines?${query}`);
+                if ((data.Response && data.Response === "Error") || data.length === 0) {
+                    // "noData" should be set if there is no data in the requested period.
+                    onHistoryCallback([], {
+                        noData: true,
+                    });
+                    return;
+                }
+                let bars = [];
+                data.forEach((bar) => {
+                    if (bar[0] >= from * 1000 && bar[0] < to * 1000) {
+                        bars = [
+                            ...bars,
+                            {
+                                time: bar[0],
+                                low: bar[3],
+                                high: bar[2],
+                                open: bar[1],
+                                close: bar[4],
+                                volume: bar[5],
+                            },
+                        ];
+                    }
+                });
+                onHistoryCallback(bars, {
+                    noData: false,
+                });
+            }
+            catch (error) {
+                console.log("[getBars]: Get error", error);
+                onErrorCallback(error);
+            }
+        });
+        this.subscribeBars = (symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback) => {
+            (0, streaming_js_1.subscribeOnStream)(symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback, this.interval);
+        };
+        this.unsubscribeBars = (subscriberUID) => {
+            (0, streaming_js_1.unsubscribeFromStream)(subscriberUID);
+        };
+        this.streaming = null;
+        this.timescaleMarks = timescaleMarks;
+        this.interval = interval;
+    }
+    getTimescaleMarks(symbolInfo, from, to, onDataCallback, resolution) {
+        if (this.timescaleMarks.length > 0) {
+            let timescaleMarks = Object.assign([], this.timescaleMarks);
+            onDataCallback(timescaleMarks);
+        }
+    }
+    getServerTime(onServertimeCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield (0, helpers_js_1.makeApiRequest)(`api/v3/time`);
+            const serverTime = (data.serverTime / 1000);
+            onServertimeCallback(serverTime);
+        });
+    }
+}
+exports.default = Datafeed;

package/dist/src/components/helpers.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrevious = exports.getAllSymbols = exports.makeApiRequest = void 0;
+const react_1 = require("react");
+function makeApiRequest(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield fetch(`https://api.binance.com/${path}`);
+            return response.json();
+        }
+        catch (error) {
+            throw new Error(`Binance request error: ${error.status}`);
+        }
+    });
+}
+exports.makeApiRequest = makeApiRequest;
+function getAllSymbols(symbol) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let newSymbols = [];
+        try {
+            const data = yield makeApiRequest(`api/v3/exchangeInfo?symbol=${symbol.toUpperCase()}`);
+            data.symbols.forEach(item => {
+                if (item.status === "TRADING") {
+                    newSymbols.push({
+                        symbol: item.symbol,
+                        full_name: `${item.baseAsset}/${item.quoteAsset}`,
+                        description: `Precision: ${item.quoteAssetPrecision}`,
+                        exchange: "Binance",
+                        ticker: item.symbol,
+                        type: "crypto",
+                    });
+                }
+            });
+        }
+        catch (e) {
+            return newSymbols;
+        }
+        return newSymbols;
+    });
+}
+exports.getAllSymbols = getAllSymbols;
+function usePrevious(value) {
+    const ref = (0, react_1.useRef)();
+    (0, react_1.useEffect)(() => {
+        ref.current = value;
+    });
+    return ref.current;
+}
+exports.usePrevious = usePrevious;

package/dist/src/components/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TVChartContainer = void 0;
+const TVChartContainer_1 = __importDefault(require("./TVChartContainer"));
+exports.TVChartContainer = TVChartContainer_1.default;

package/dist/src/components/streaming.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeFromStream = exports.subscribeOnStream = void 0;
+const channelToSubscription = new Map();
+function setupSockets(subRequest) {
+    const socket = new WebSocket("wss://stream.binance.com:9443/ws");
+    window.socket = socket;
+    socket.onopen = (event) => {
+        console.log("[socket] Connected");
+        socket.send(JSON.stringify(subRequest));
+    };
+    socket.onclose = (reason) => {
+        console.log("[socket] Disconnected:", reason);
+    };
+    socket.onerror = (error) => {
+        console.log("[socket] Error:", error);
+    };
+    socket.onmessage = (e) => {
+        const data = JSON.parse(e.data);
+        if (data.e == undefined) {
+            // skip all non-TRADE events
+            return;
+        }
+        const { s: symbol, t: startTime, T: closeTime, i: interval, o: open, c: close, h: high, l: low, v: volume, n: trades, q: quoteVolume, } = data.k;
+        const channelString = `${symbol.toLowerCase()}@kline_${interval}`;
+        const subscriptionItem = channelToSubscription.get(channelString);
+        if (subscriptionItem === undefined) {
+            return;
+        }
+        const bar = {
+            time: startTime,
+            open: open,
+            high: high,
+            low: low,
+            close: close,
+            volume: volume,
+        };
+        // send data to every subscriber of that symbol
+        subscriptionItem.handlers.forEach((handler) => handler.callback(bar));
+    };
+}
+function subscribeOnStream(symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback, interval) {
+    const channelString = `${symbolInfo.name.toLowerCase()}@kline_${interval}`;
+    const handler = {
+        id: subscribeUID,
+        callback: onRealtimeCallback,
+    };
+    let subscriptionItem = channelToSubscription.get(channelString);
+    if (subscriptionItem) {
+        // already subscribed to the channel, use the existing subscription
+        subscriptionItem.handlers.push(handler);
+        return;
+    }
+    subscriptionItem = {
+        subscribeUID,
+        resolution,
+        handlers: [handler],
+    };
+    const subRequest = {
+        method: "SUBSCRIBE",
+        params: [channelString],
+        id: 1,
+    };
+    channelToSubscription.set(channelString, subscriptionItem);
+    setupSockets(subRequest);
+}
+exports.subscribeOnStream = subscribeOnStream;
+function unsubscribeFromStream(subscriberUID) {
+    // find a subscription with id === subscriberUID
+    for (const channelString of channelToSubscription.keys()) {
+        const subscriptionItem = channelToSubscription.get(channelString);
+        const handlerIndex = subscriptionItem.handlers.findIndex((handler) => handler.id === subscriberUID);
+        if (handlerIndex !== -1) {
+            // remove from handlers
+            subscriptionItem.handlers.splice(handlerIndex, 1);
+            if (subscriptionItem.handlers.length === 0) {
+                // unsubscribe from the channel, if it was the last handler
+                console.log("[unsubscribeBars]: Unsubscribe from streaming. Channel:", channelString);
+                const subRequest = {
+                    method: "UNSUBSCRIBE",
+                    params: [channelString],
+                    id: 1,
+                };
+                window.socket.send(JSON.stringify(subRequest));
+                channelToSubscription.delete(channelString);
+                window.socket = undefined;
+                break;
+            }
+        }
+    }
+}
+exports.unsubscribeFromStream = unsubscribeFromStream;

package/dist/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_dom_1 = __importDefault(require("react-dom"));
+const App_tsx_1 = __importDefault(require("./App.tsx"));
+require("./index.css");
+react_dom_1.default.render(<App_tsx_1.default />, document.getElementById('root'));

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.1",
+  "version": "0.5.3",
   "name": "binbot-charts",
   "dependencies": {
     "react": "^17.0.1",
@@ -20,7 +20,7 @@
   },
   "scripts": {
     "start": "react-scripts start",
-    "build": "rm -rf dist && NODE_ENV=production babel -d dist/components src/components --extensions \".js,.jsx\" && cp -r src/charting_library dist/charting_library",
+    "build": "rm -rf dist && NODE_ENV=production babel -d dist/components src/components --extensions \".js\" && cp -r src/charting_library dist/charting_library && tsc",
     "release": "yarn build && yarn publish"
   },
   "description": "Binbot charts is the default candlestick bars chart used in terminal.binbot.in to render bots graphically.",