binbot-charts 0.5.9 → 0.6.0

package/dist/TVChartContainer.mjs

@@ -0,0 +1,735 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/components/TVChartContainer.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState } from "react";
+
+// src/charting_library/charting_library.js
+!function(e, t) {
+  "object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd ? define(["exports"], t) : t((e = "undefined" != typeof globalThis ? globalThis : e || self).TradingView = {});
+}(void 0, function(e) {
+  "use strict";
+  function t(e2, i2) {
+    const n2 = __spreadValues({}, e2);
+    for (const o2 in i2) "object" != typeof e2[o2] || null === e2[o2] || Array.isArray(e2[o2]) ? void 0 !== i2[o2] && (n2[o2] = i2[o2]) : n2[o2] = t(e2[o2], i2[o2]);
+    return n2;
+  }
+  const i = { mobile: { disabled_features: ["left_toolbar", "header_widget", "timeframes_toolbar", "edit_buttons_in_legend", "context_menus", "control_bar", "border_around_the_chart"], enabled_features: [] } }, n = { width: 800, height: 500, interval: "1D", timezone: "Etc/UTC", container: "", library_path: "", locale: "en", widgetbar: { details: false, watchlist: false, watchlist_settings: { default_symbols: [] } }, overrides: { "mainSeriesProperties.showCountdown": false }, studies_overrides: {}, trading_customization: { position: {}, order: {} }, brokerConfig: { configFlags: {} }, fullscreen: false, autosize: false, disabled_features: [], enabled_features: [], debug: false, logo: {}, time_frames: [{ text: "5y", resolution: "1W" }, { text: "1y", resolution: "1W" }, { text: "6m", resolution: "120" }, { text: "3m", resolution: "60" }, { text: "1m", resolution: "30" }, { text: "5d", resolution: "5" }, { text: "1d", resolution: "1" }], client_id: "0", user_id: "0", charts_storage_api_version: "1.0", favorites: { intervals: [], chartTypes: [] } };
+  let o = false;
+  function s() {
+    return "CL v21.064 (internal id f0bc1e45 @ 2022-03-17T12:19:26.809Z)";
+  }
+  const r = class {
+    constructor(e2) {
+      if (this._id = `tradingview_${(1048576 * (1 + Math.random()) | 0).toString(16).substring(1)}`, this._ready = false, this._readyHandlers = [], this._onWindowResize = this._autoResizeChart.bind(this), !e2.datafeed) throw new Error("Datafeed is not defined");
+      if (this._options = t(n, e2), e2.preset) {
+        const t2 = i[e2.preset];
+        t2 ? (void 0 !== this._options.disabled_features ? this._options.disabled_features = this._options.disabled_features.concat(t2.disabled_features) : this._options.disabled_features = t2.disabled_features, void 0 !== this._options.enabled_features ? this._options.enabled_features = this._options.enabled_features.concat(t2.enabled_features) : this._options.enabled_features = t2.enabled_features) : console.warn("Unknown preset: `" + e2.preset + "`");
+      }
+      "Dark" === this._options.theme && void 0 === this._options.loading_screen && (this._options.loading_screen = { backgroundColor: "#131722" }), this._options.debug && (o || (o = true, console.log("Using CL v21.064 (internal id f0bc1e45 @ 2022-03-17T12:19:26.809Z)"))), this._create();
+    }
+    onChartReady(e2) {
+      this._ready ? e2.call(this) : this._readyHandlers.push(e2);
+    }
+    headerReady() {
+      return this._innerWindowLoaded.then(() => this._innerWindow().headerReady());
+    }
+    onGrayedObjectClicked(e2) {
+      this._doWhenInnerApiLoaded((t2) => {
+        t2.onGrayedObjectClicked(e2);
+      });
+    }
+    onShortcut(e2, t2) {
+      this._doWhenInnerWindowLoaded((i2) => {
+        i2.createShortcutAction(e2, t2);
+      });
+    }
+    subscribe(e2, t2) {
+      this._doWhenInnerApiLoaded((i2) => {
+        i2.subscribe(e2, t2);
+      });
+    }
+    unsubscribe(e2, t2) {
+      this._doWhenInnerApiLoaded((i2) => {
+        i2.unsubscribe(e2, t2);
+      });
+    }
+    chart(e2) {
+      return this._innerAPI().chart(e2);
+    }
+    getLanguage() {
+      return this._options.locale;
+    }
+    setSymbol(e2, t2, i2) {
+      this._innerAPI().changeSymbol(e2, t2, i2);
+    }
+    remove() {
+      window.removeEventListener("resize", this._onWindowResize), this._readyHandlers.splice(0, this._readyHandlers.length), delete window[this._id], this._iFrame.parentNode && this._iFrame.parentNode.removeChild(this._iFrame);
+    }
+    closePopupsAndDialogs() {
+      this._doWhenInnerApiLoaded((e2) => {
+        e2.closePopupsAndDialogs();
+      });
+    }
+    selectLineTool(e2) {
+      this._innerAPI().selectLineTool(e2);
+    }
+    selectedLineTool() {
+      return this._innerAPI().selectedLineTool();
+    }
+    save(e2) {
+      this._innerAPI().saveChart(e2);
+    }
+    load(e2, t2) {
+      this._innerAPI().loadChart({ json: e2, extendedData: t2 });
+    }
+    getSavedCharts(e2) {
+      this._innerAPI().getSavedCharts(e2);
+    }
+    loadChartFromServer(e2) {
+      this._innerAPI().loadChartFromServer(e2);
+    }
+    saveChartToServer(e2, t2, i2) {
+      this._innerAPI().saveChartToServer(e2, t2, i2);
+    }
+    removeChartFromServer(e2, t2) {
+      this._innerAPI().removeChartFromServer(e2, t2);
+    }
+    onContextMenu(e2) {
+      this._doWhenInnerApiLoaded((t2) => {
+        t2.onContextMenu(e2);
+      });
+    }
+    createButton(e2) {
+      return this._innerWindow().createButton(e2);
+    }
+    createDropdown(e2) {
+      return this._innerWindow().createDropdown(e2);
+    }
+    showNoticeDialog(e2) {
+      this._doWhenInnerApiLoaded((t2) => {
+        t2.showNoticeDialog(e2);
+      });
+    }
+    showConfirmDialog(e2) {
+      this._doWhenInnerApiLoaded((t2) => {
+        t2.showConfirmDialog(e2);
+      });
+    }
+    showLoadChartDialog() {
+      this._innerAPI().showLoadChartDialog();
+    }
+    showSaveAsChartDialog() {
+      this._innerAPI().showSaveAsChartDialog();
+    }
+    symbolInterval() {
+      return this._innerAPI().getSymbolInterval();
+    }
+    mainSeriesPriceFormatter() {
+      return this._innerAPI().mainSeriesPriceFormatter();
+    }
+    getIntervals() {
+      return this._innerAPI().getIntervals();
+    }
+    getStudiesList() {
+      return this._innerAPI().getStudiesList();
+    }
+    getStudyInputs(e2) {
+      return this._innerAPI().getStudyInputs(e2);
+    }
+    addCustomCSSFile(e2) {
+      this._innerWindow().addCustomCSSFile(e2);
+    }
+    applyOverrides(e2) {
+      this._options = t(this._options, { overrides: e2 }), this._doWhenInnerWindowLoaded((t2) => {
+        t2.applyOverrides(e2);
+      });
+    }
+    applyStudiesOverrides(e2) {
+      this._doWhenInnerWindowLoaded((t2) => {
+        t2.applyStudiesOverrides(e2);
+      });
+    }
+    watchList() {
+      return this._innerAPI().watchlist();
+    }
+    news() {
+      return this._innerAPI().news();
+    }
+    activeChart() {
+      return this._innerAPI().activeChart();
+    }
+    chartsCount() {
+      return this._innerAPI().chartsCount();
+    }
+    layout() {
+      return this._innerAPI().layout();
+    }
+    setLayout(e2) {
+      this._innerAPI().setLayout(e2);
+    }
+    layoutName() {
+      return this._innerAPI().layoutName();
+    }
+    changeTheme(e2, t2) {
+      return this._innerWindow().changeTheme(e2, t2);
+    }
+    getTheme() {
+      return this._innerWindow().getTheme();
+    }
+    takeScreenshot() {
+      this._doWhenInnerApiLoaded((e2) => {
+        e2.takeScreenshot();
+      });
+    }
+    lockAllDrawingTools() {
+      return this._innerAPI().lockAllDrawingTools();
+    }
+    hideAllDrawingTools() {
+      return this._innerAPI().hideAllDrawingTools();
+    }
+    drawOnAllCharts(e2) {
+      this._innerAPI().drawOnAllCharts(e2);
+    }
+    magnetEnabled() {
+      return this._innerAPI().magnetEnabled();
+    }
+    magnetMode() {
+      return this._innerAPI().magnetMode();
+    }
+    undoRedoState() {
+      return this._innerAPI().undoRedoState();
+    }
+    setIntervalLinkingEnabled(e2) {
+      this._innerAPI().setIntervalLinkingEnabled(e2);
+    }
+    setTimeFrame(e2) {
+      this._innerAPI().setTimeFrame(e2);
+    }
+    symbolSync() {
+      return this._innerAPI().symbolSync();
+    }
+    intervalSync() {
+      return this._innerAPI().intervalSync();
+    }
+    crosshairSync() {
+      return this._innerAPI().crosshairSync();
+    }
+    timeSync() {
+      return this._innerAPI().timeSync();
+    }
+    getAllFeatures() {
+      return this._innerWindow().getAllFeatures();
+    }
+    clearUndoHistory() {
+      return this._innerAPI().clearUndoHistory();
+    }
+    undo() {
+      return this._innerAPI().undo();
+    }
+    redo() {
+      return this._innerAPI().redo();
+    }
+    startFullscreen() {
+      this._innerAPI().startFullscreen();
+    }
+    exitFullscreen() {
+      this._innerAPI().exitFullscreen();
+    }
+    takeClientScreenshot(e2) {
+      return this._innerAPI().takeClientScreenshot(e2);
+    }
+    navigationButtonsVisibility() {
+      return this._innerWindow().getNavigationButtonsVisibility();
+    }
+    paneButtonsVisibility() {
+      return this._innerWindow().getPaneButtonsVisibility();
+    }
+    dateFormat() {
+      return this._innerWindow().getDateFormat();
+    }
+    _innerAPI() {
+      return this._innerWindow().tradingViewApi;
+    }
+    _innerWindow() {
+      return this._iFrame.contentWindow;
+    }
+    _doWhenInnerWindowLoaded(e2) {
+      this._ready ? e2(this._innerWindow()) : this._innerWindowLoaded.then(() => {
+        e2(this._innerWindow());
+      });
+    }
+    _doWhenInnerApiLoaded(e2) {
+      this._doWhenInnerWindowLoaded((t2) => {
+        t2.doWhenApiIsReady(() => e2(this._innerAPI()));
+      });
+    }
+    _autoResizeChart() {
+      this._options.fullscreen && (this._iFrame.style.height = window.innerHeight + "px");
+    }
+    _create() {
+      const e2 = this._render();
+      this._options.container_id && console.warn("`container_id` is now deprecated. Please use `container` instead to either still pass a string or an `HTMLElement`.");
+      const t2 = this._options.container_id || this._options.container, i2 = "string" == typeof t2 ? document.getElementById(t2) : t2;
+      if (null === i2) throw new Error(`There is no such element - #${this._options.container}`);
+      i2.innerHTML = e2, this._iFrame = i2.querySelector(`#${this._id}`);
+      const n2 = this._iFrame;
+      (this._options.autosize || this._options.fullscreen) && (n2.style.width = "100%", this._options.fullscreen || (n2.style.height = "100%")), window.addEventListener("resize", this._onWindowResize), this._onWindowResize(), this._innerWindowLoaded = new Promise((e3) => {
+        const t3 = () => {
+          n2.removeEventListener("load", t3, false), e3();
+        };
+        n2.addEventListener("load", t3, false);
+      }), this._innerWindowLoaded.then(() => {
+        this._innerWindow().widgetReady(() => {
+          this._ready = true;
+          for (const e3 of this._readyHandlers) try {
+            e3.call(this);
+          } catch (e4) {
+            console.error(e4);
+          }
+          this._innerWindow().initializationFinished();
+        });
+      });
+    }
+    _render() {
+      const e2 = window;
+      if (e2[this._id] = { datafeed: this._options.datafeed, customFormatters: this._options.custom_formatters || this._options.customFormatters, brokerFactory: this._options.broker_factory || this._options.brokerFactory, overrides: this._options.overrides, studiesOverrides: this._options.studies_overrides, tradingCustomization: this._options.trading_customization, disabledFeatures: this._options.disabled_features, enabledFeatures: this._options.enabled_features, brokerConfig: this._options.broker_config || this._options.brokerConfig, restConfig: this._options.restConfig, favorites: this._options.favorites, logo: this._options.logo, numeric_formatting: this._options.numeric_formatting, rss_news_feed: this._options.rss_news_feed, newsProvider: this._options.news_provider, loadLastChart: this._options.load_last_chart, saveLoadAdapter: this._options.save_load_adapter, loading_screen: this._options.loading_screen, settingsAdapter: this._options.settings_adapter, getCustomIndicators: this._options.custom_indicators_getter, additionalSymbolInfoFields: this._options.additional_symbol_info_fields, headerWidgetButtonsMode: this._options.header_widget_buttons_mode, symbolSearchComplete: this._options.symbol_search_complete }, this._options.saved_data) e2[this._id].chartContent = { json: this._options.saved_data }, this._options.saved_data_meta_info && (e2[this._id].chartContentExtendedData = this._options.saved_data_meta_info);
+      else if (!this._options.load_last_chart && !this._options.symbol) throw new Error("Symbol is not defined: either 'symbol' or 'load_last_chart' option must be set");
+      const t2 = (this._options.library_path || "") + `${encodeURIComponent(this._options.locale)}-tv-chart.f0bc1e45.html#symbol=` + encodeURIComponent(this._options.symbol || "") + "&interval=" + encodeURIComponent(this._options.interval) + (this._options.timeframe ? "&timeframe=" + encodeURIComponent(this._options.timeframe) : "") + (this._options.toolbar_bg ? "&toolbarbg=" + encodeURIComponent(this._options.toolbar_bg.replace("#", "")) : "") + (this._options.studies_access ? "&studiesAccess=" + encodeURIComponent(JSON.stringify(this._options.studies_access)) : "") + "&widgetbar=" + encodeURIComponent(JSON.stringify(this._options.widgetbar)) + (this._options.drawings_access ? "&drawingsAccess=" + encodeURIComponent(JSON.stringify(this._options.drawings_access)) : "") + "&timeFrames=" + encodeURIComponent(JSON.stringify(this._options.time_frames)) + "&locale=" + encodeURIComponent(this._options.locale) + "&uid=" + encodeURIComponent(this._id) + "&clientId=" + encodeURIComponent(String(this._options.client_id)) + "&userId=" + encodeURIComponent(String(this._options.user_id)) + (this._options.charts_storage_url ? "&chartsStorageUrl=" + encodeURIComponent(this._options.charts_storage_url) : "") + (this._options.charts_storage_api_version ? "&chartsStorageVer=" + encodeURIComponent(this._options.charts_storage_api_version) : "") + (this._options.custom_css_url ? "&customCSS=" + encodeURIComponent(this._options.custom_css_url) : "") + (this._options.auto_save_delay ? "&autoSaveDelay=" + encodeURIComponent(String(this._options.auto_save_delay)) : "") + "&debug=" + encodeURIComponent(String(this._options.debug)) + (this._options.snapshot_url ? "&snapshotUrl=" + encodeURIComponent(this._options.snapshot_url) : "") + (this._options.timezone ? "&timezone=" + encodeURIComponent(this._options.timezone) : "") + (this._options.study_count_limit ? "&studyCountLimit=" + encodeURIComponent(String(this._options.study_count_limit)) : "") + (this._options.symbol_search_request_delay ? "&ssreqdelay=" + encodeURIComponent(String(this._options.symbol_search_request_delay)) : "") + (this._options.compare_symbols ? "&compareSymbols=" + encodeURIComponent(JSON.stringify(this._options.compare_symbols)) : "") + (this._options.theme ? "&theme=" + encodeURIComponent(String(this._options.theme)) : "") + (this._options.header_widget_buttons_mode ? "&header_widget_buttons_mode=" + encodeURIComponent(String(this._options.header_widget_buttons_mode)) : "") + (this._options.time_scale ? "&time_scale=" + encodeURIComponent(JSON.stringify(this._options.time_scale)) : "");
+      return '<iframe id="' + this._id + '" name="' + this._id + '"  src="' + t2 + '"' + (this._options.autosize || this._options.fullscreen ? "" : ' width="' + this._options.width + '" height="' + this._options.height + '"') + ' title="Financial Chart" frameborder="0" allowTransparency="true" scrolling="no" allowfullscreen style="display:block;"></iframe>';
+    }
+  };
+  window.TradingView = window.TradingView || {}, window.TradingView.version = s, e.version = s, e.widget = r, Object.defineProperty(e, "__esModule", { value: true });
+});
+
+// src/components/helpers.js
+import { useEffect, useRef } from "react";
+function makeApiRequest(path) {
+  return __async(this, null, function* () {
+    try {
+      const response = yield fetch(`https://api.binance.com/${path}`);
+      return response.json();
+    } catch (error) {
+      throw new Error(`Binance request error: ${error.status}`);
+    }
+  });
+}
+function getAllSymbols(symbol) {
+  return __async(this, null, 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;
+  });
+}
+
+// src/components/streaming.js
+var channelToSubscription = /* @__PURE__ */ 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 == void 0) {
+      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 === void 0) {
+      return;
+    }
+    const bar = {
+      time: startTime,
+      open,
+      high,
+      low,
+      close,
+      volume
+    };
+    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) {
+    subscriptionItem.handlers.push(handler);
+    return;
+  }
+  subscriptionItem = {
+    subscribeUID,
+    resolution,
+    handlers: [handler]
+  };
+  const subRequest = {
+    method: "SUBSCRIBE",
+    params: [channelString],
+    id: 1
+  };
+  channelToSubscription.set(channelString, subscriptionItem);
+  setupSockets(subRequest);
+}
+function unsubscribeFromStream(subscriberUID) {
+  for (const channelString of channelToSubscription.keys()) {
+    const subscriptionItem = channelToSubscription.get(channelString);
+    const handlerIndex = subscriptionItem.handlers.findIndex(
+      (handler) => handler.id === subscriberUID
+    );
+    if (handlerIndex !== -1) {
+      subscriptionItem.handlers.splice(handlerIndex, 1);
+      if (subscriptionItem.handlers.length === 0) {
+        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 = void 0;
+        break;
+      }
+    }
+  }
+}
+
+// src/components/datafeed.js
+var getConfigurationData = () => __async(void 0, null, 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"
+      }
+    ]
+  };
+});
+var Datafeed = class {
+  constructor(timescaleMarks = [], interval = "1h") {
+    __publicField(this, "onReady", (callback) => __async(this, null, function* () {
+      this.configurationData = yield getConfigurationData();
+      callback(this.configurationData);
+    }));
+    __publicField(this, "searchSymbols", (userInput, exchange, symbolType, onResultReadyCallback) => __async(this, null, function* () {
+      const symbols = yield getAllSymbols(userInput);
+      onResultReadyCallback(symbols);
+    }));
+    __publicField(this, "resolveSymbol", (symbolName, onSymbolResolvedCallback, onResolveErrorCallback) => __async(this, null, 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: 1e5,
+          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);
+    }));
+    __publicField(this, "getBars", (symbolInfo, resolution, periodParams, onHistoryCallback, onErrorCallback) => __async(this, null, function* () {
+      const { from, to, firstDataRequest } = periodParams;
+      let interval = "60";
+      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,
+        startTime: Math.abs(from * 1e3),
+        endTime: Math.abs(to * 1e3),
+        limit: 600
+      };
+      const query = Object.keys(urlParameters).map((name) => `${name}=${encodeURIComponent(urlParameters[name])}`).join("&");
+      try {
+        const data = yield makeApiRequest(`api/v3/uiKlines?${query}`);
+        if (data.Response && data.Response === "Error" || data.length === 0) {
+          onHistoryCallback([], {
+            noData: true
+          });
+          return;
+        }
+        let bars = [];
+        data.forEach((bar) => {
+          if (bar[0] >= from * 1e3 && bar[0] < to * 1e3) {
+            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);
+      }
+    }));
+    __publicField(this, "subscribeBars", (symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback) => {
+      subscribeOnStream(
+        symbolInfo,
+        resolution,
+        onRealtimeCallback,
+        subscribeUID,
+        onResetCacheNeededCallback,
+        this.interval
+      );
+    });
+    __publicField(this, "unsubscribeBars", (subscriberUID) => {
+      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 __async(this, null, function* () {
+      const data = yield makeApiRequest(`api/v3/time`);
+      const serverTime = data.serverTime / 1e3;
+      onServertimeCallback(serverTime);
+    });
+  }
+};
+
+// src/components/TVChartContainer.tsx
+import { useImmer } from "use-immer";
+import { jsx } from "react/jsx-runtime";
+var TVChartContainer = ({
+  symbol = "BTCUSDT",
+  interval = "1h",
+  libraryPath = "/charting_library/",
+  timescaleMarks = [],
+  orderLines = [],
+  height = "calc(100vh - 80px)",
+  onTick,
+  getLatestBar
+}) => {
+  const containerRef = useRef2(null);
+  const [chartOrderLines, setChartOrderLines] = useImmer([]);
+  const [widgetState, setWidgetState] = useImmer(null);
+  const [symbolState] = useState(null);
+  const prevTimescaleMarks = useRef2(timescaleMarks);
+  useEffect2(() => {
+    if (!widgetState) {
+      initializeChart(interval);
+    }
+    if (orderLines && orderLines.length > 0) {
+      updateOrderLines(orderLines);
+    }
+    if (widgetState && symbol !== symbolState) {
+      widgetState.setSymbol(symbol, interval);
+    }
+    if (widgetState && prevTimescaleMarks.current && timescaleMarks !== prevTimescaleMarks.current) {
+      widgetState._options.datafeed.timescaleMarks = timescaleMarks;
+      prevTimescaleMarks.current = timescaleMarks;
+    }
+  }, [orderLines, timescaleMarks]);
+  const initializeChart = (interval2) => {
+    const widgetOptions = {
+      symbol,
+      datafeed: new Datafeed(timescaleMarks, interval2),
+      interval: interval2,
+      container: containerRef.current,
+      library_path: libraryPath,
+      locale: "en",
+      fullscreen: false,
+      autosize: true,
+      studies_overrides: {},
+      symbol_search_request_delay: 1e3,
+      overrides: {
+        volumePaneSize: "small",
+        "mainSeriesProperties.barStyle.dontDrawOpen": false
+      }
+    };
+    const tvWidget = new (void 0)(widgetOptions);
+    tvWidget.onChartReady(() => {
+      tvWidget.subscribe("onTick", (event) => onTick && onTick(event));
+      setWidgetState(tvWidget);
+      const prices = () => __async(void 0, null, function* () {
+        const data = yield tvWidget.activeChart().exportData({
+          includeTime: false,
+          includeSeries: true,
+          includedStudies: []
+        });
+        getLatestBar && getLatestBar(data.data[data.data.length - 1]);
+      });
+      prices();
+    });
+  };
+  const updateOrderLines = (orderLines2) => {
+    if (chartOrderLines && chartOrderLines.length > 0) {
+      chartOrderLines.forEach((item) => {
+        orderLines2.forEach((order) => {
+          if (item.id == order.id) {
+            item.setText(order.text).setTooltip(order.tooltip).setQuantity(order.quantity).setPrice(order.price);
+          }
+        });
+      });
+    } else {
+      if (widgetState && orderLines2 && orderLines2.length > 0) {
+        orderLines2.forEach((order) => {
+          const lineStyle = order.lineStyle || 0;
+          let chartOrderLine = widgetState.chart().createOrderLine().setText(order.text).setTooltip(order.tooltip).setQuantity(order.quantity).setQuantityFont("inherit 14px Arial").setQuantityBackgroundColor(order.color).setQuantityBorderColor(order.color).setLineStyle(lineStyle).setLineLength(25).setLineColor(order.color).setBodyFont("inherit 14px Arial").setBodyBorderColor(order.color).setBodyTextColor(order.color).setPrice(order.price);
+          chartOrderLine.id = order.id;
+          setChartOrderLines((draft) => {
+            draft.push(chartOrderLine);
+            return draft;
+          });
+        });
+      }
+    }
+  };
+  return /* @__PURE__ */ jsx("div", { ref: containerRef, style: { height } });
+};
+var TVChartContainer_default = TVChartContainer;
+export {
+  TVChartContainer_default as default
+};
+//# sourceMappingURL=TVChartContainer.mjs.map