binbot-charts 0.0.4 → 0.0.5

package/dist/TVChartContainer.js

@@ -5,45 +5,49 @@ require("core-js/modules/web.dom-collections.iterator.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TVChartContainer = void 0;
+exports.default = void 0;
 
-var React = _interopRequireWildcard(require("react"));
+var _react = _interopRequireWildcard(require("react"));
 
 var _charting_library = require("../charting_library");
 
+var _datafeed = _interopRequireDefault(require("./datafeed"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-class TVChartContainer extends React.PureComponent {
+class TVChartContainer extends _react.Component {
   constructor(props) {
     super(props);
 
     _defineProperty(this, "tvWidget", null);
 
-    this.ref = /*#__PURE__*/React.createRef();
+    this.ref = /*#__PURE__*/_react.default.createRef();
   }
 
   componentDidMount() {
     const widgetOptions = {
       symbol: "AAPL",
       // BEWARE: no trailing slash is expected in feed URL
-      datafeed: new window.Datafeeds.UDFCompatibleDatafeed(this.props.datafeedUrl),
-      interval: this.props.interval,
+      datafeed: _datafeed.default,
+      // interval: this.props.interval,
       container: this.ref.current,
       library_path: this.props.libraryPath,
       locale: "en",
-      disabled_features: ["use_localstorage_for_settings"],
-      enabled_features: ["study_templates"],
-      charts_storage_url: this.props.chartsStorageUrl,
-      charts_storage_api_version: this.props.chartsStorageApiVersion,
-      client_id: this.props.clientId,
-      user_id: this.props.userId,
-      fullscreen: this.props.fullscreen,
-      autosize: this.props.autosize,
-      studies_overrides: this.props.studiesOverrides
+      // disabled_features: ["use_localstorage_for_settings"],
+      // enabled_features: ["study_templates"],
+      // charts_storage_url: this.props.chartsStorageUrl,
+      // charts_storage_api_version: this.props.chartsStorageApiVersion,
+      // client_id: this.props.clientId,
+      // user_id: this.props.userId,
+      fullscreen: false,
+      autosize: false,
+      studies_overrides: {}
     };
     const tvWidget = new _charting_library.widget(widgetOptions);
     this.tvWidget = tvWidget;
@@ -61,7 +65,7 @@ class TVChartContainer extends React.PureComponent {
   }
 
   render() {
-    return /*#__PURE__*/React.createElement("div", {
+    return /*#__PURE__*/_react.default.createElement("div", {
       ref: this.ref,
       style: {
         height: "calc(100vh - 80px)"
@@ -71,15 +75,4 @@ class TVChartContainer extends React.PureComponent {
 
 }
 
-exports.TVChartContainer = TVChartContainer;
-
-_defineProperty(TVChartContainer, "defaultProps", {
-  symbol: "AAPL",
-  interval: "D",
-  datafeedUrl: "https://demo_feed.tradingview.com",
-  libraryPath: "/charting_library/",
-  chartsStorageApiVersion: "1.1",
-  fullscreen: false,
-  autosize: true,
-  studiesOverrides: {}
-});
+exports.default = TVChartContainer;

package/dist/datafeed.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.symbol.description.js");
+
+var _helpers = require("./helpers.js");
+
+var _streaming = require("./streaming.js");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const lastBarsCache = new Map();
+const exchange = "Binance";
+const configurationData = {
+  supported_resolutions: ["1D", "1W", "1M"],
+  exchanges: [{
+    value: "Binance",
+    name: "Binance",
+    desc: "Binance"
+  }],
+  symbols_types: [{
+    name: "crypto",
+    // `symbolType` argument for the `searchSymbols` method, if a user selects this symbol type
+    value: "crypto"
+  } // ...
+  ]
+};
+
+async function getAllSymbols() {
+  const data = await (0, _helpers.makeApiRequest)("data/v3/all/exchanges");
+  let allSymbols = [];
+  const pairs = data.Data[exchange].pairs;
+
+  for (const leftPairPart of Object.keys(pairs)) {
+    const symbols = pairs[leftPairPart].map(rightPairPart => {
+      const symbol = (0, _helpers.generateSymbol)(exchange, leftPairPart, rightPairPart);
+      return {
+        symbol: symbol.short,
+        full_name: symbol.full,
+        description: symbol.short,
+        exchange: exchange,
+        type: "crypto"
+      };
+    });
+    allSymbols = [...allSymbols, ...symbols];
+  }
+
+  return allSymbols;
+}
+
+class Datafeed {}
+
+exports.default = Datafeed;
+
+_defineProperty(Datafeed, "onReady", callback => {
+  console.log("[onReady]: Method call");
+  setTimeout(() => callback(configurationData));
+});
+
+_defineProperty(Datafeed, "searchSymbols", async (userInput, exchange, symbolType, onResultReadyCallback) => {
+  console.log("[searchSymbols]: Method call");
+  const symbols = await getAllSymbols();
+  const newSymbols = symbols.filter(symbol => {
+    const isExchangeValid = exchange === "" || symbol.exchange === exchange;
+    const isFullSymbolContainsInput = symbol.full_name.toLowerCase().indexOf(userInput.toLowerCase()) !== -1;
+    return isExchangeValid && isFullSymbolContainsInput;
+  });
+  onResultReadyCallback(newSymbols);
+});
+
+_defineProperty(Datafeed, "resolveSymbol", async (symbolName, onSymbolResolvedCallback, onResolveErrorCallback) => {
+  console.log("[resolveSymbol]: Method call", symbolName);
+  const symbols = await getAllSymbols();
+  const symbolItem = symbols.find(_ref => {
+    let {
+      full_name
+    } = _ref;
+    return full_name === symbolName;
+  });
+
+  if (!symbolItem) {
+    console.log("[resolveSymbol]: Cannot resolve symbol", symbolName);
+    onResolveErrorCallback("cannot resolve symbol");
+    return;
+  }
+
+  const symbolInfo = {
+    ticker: symbolItem.full_name,
+    name: symbolItem.symbol,
+    description: symbolItem.description,
+    type: symbolItem.type,
+    session: "24x7",
+    timezone: "Etc/UTC",
+    exchange: symbolItem.exchange,
+    minmov: 1,
+    pricescale: 100,
+    has_intraday: false,
+    has_no_volume: true,
+    has_weekly_and_monthly: false,
+    supported_resolutions: ["1D", "1W", "1M"],
+    volume_precision: 2,
+    data_status: "streaming"
+  };
+  console.log("[resolveSymbol]: Symbol resolved", symbolName);
+  onSymbolResolvedCallback(symbolInfo);
+});
+
+_defineProperty(Datafeed, "getBars", async (symbolInfo, resolution, periodParams, onHistoryCallback, onErrorCallback) => {
+  const {
+    from,
+    to,
+    firstDataRequest
+  } = periodParams;
+  console.log("[getBars]: Method call", symbolInfo, resolution, from, to);
+  const parsedSymbol = (0, _helpers.parseFullSymbol)(symbolInfo.full_name);
+  const urlParameters = {
+    e: parsedSymbol.exchange,
+    fsym: parsedSymbol.fromSymbol,
+    tsym: parsedSymbol.toSymbol,
+    toTs: to,
+    limit: 2000
+  };
+  const query = Object.keys(urlParameters).map(name => "".concat(name, "=").concat(encodeURIComponent(urlParameters[name]))).join("&");
+
+  try {
+    const data = await (0, _helpers.makeApiRequest)("data/histoday?".concat(query));
+
+    if (data.Response && data.Response === "Error" || data.Data.length === 0) {
+      // "noData" should be set if there is no data in the requested period.
+      onHistoryCallback([], {
+        noData: true
+      });
+      return;
+    }
+
+    let bars = [];
+    data.Data.forEach(bar => {
+      if (bar.time >= from && bar.time < to) {
+        bars = [...bars, {
+          time: bar.time * 1000,
+          low: bar.low,
+          high: bar.high,
+          open: bar.open,
+          close: bar.close
+        }];
+      }
+    });
+
+    if (firstDataRequest) {
+      lastBarsCache.set(symbolInfo.full_name, _objectSpread({}, bars[bars.length - 1]));
+    }
+
+    console.log("[getBars]: returned ".concat(bars.length, " bar(s)"));
+    onHistoryCallback(bars, {
+      noData: false
+    });
+  } catch (error) {
+    console.log("[getBars]: Get error", error);
+    onErrorCallback(error);
+  }
+});
+
+_defineProperty(Datafeed, "subscribeBars", (symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback) => {
+  console.log("[subscribeBars]: Method call with subscribeUID:", subscribeUID);
+  (0, _streaming.subscribeOnStream)(symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback, lastBarsCache.get(symbolInfo.full_name));
+});
+
+_defineProperty(Datafeed, "unsubscribeBars", subscriberUID => {
+  console.log("[unsubscribeBars]: Method call with subscriberUID:", subscriberUID);
+  (0, _streaming.unsubscribeFromStream)(subscriberUID);
+});

package/dist/helpers.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateSymbol = generateSymbol;
+exports.makeApiRequest = makeApiRequest;
+exports.parseFullSymbol = parseFullSymbol;
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.match.js");
+
+// Make requests to CryptoCompare API
+async function makeApiRequest(path) {
+  try {
+    const response = await fetch("https://min-api.cryptocompare.com/".concat(path));
+    return response.json();
+  } catch (error) {
+    throw new Error("CryptoCompare request error: ".concat(error.status));
+  }
+} // Generate a symbol ID from a pair of the coins
+
+
+function generateSymbol(exchange, fromSymbol, toSymbol) {
+  const short = "".concat(fromSymbol, "/").concat(toSymbol);
+  return {
+    short,
+    full: "".concat(exchange, ":").concat(short)
+  };
+}
+
+function parseFullSymbol(fullSymbol) {
+  const match = fullSymbol.match(/^(\w+):(\w+)\/(\w+)$/);
+
+  if (!match) {
+    return null;
+  }
+
+  return {
+    exchange: match[1],
+    fromSymbol: match[2],
+    toSymbol: match[3]
+  };
+}

package/dist/streaming.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeOnStream = subscribeOnStream;
+exports.unsubscribeFromStream = unsubscribeFromStream;
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.split.js");
+
+require("core-js/modules/es.parse-int.js");
+
+require("core-js/modules/es.parse-float.js");
+
+var _helpers = require("./helpers.js");
+
+var _socket = _interopRequireDefault(require("socket.io-client"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const socket = (0, _socket.default)("wss://streamer.cryptocompare.com");
+const channelToSubscription = new Map();
+socket.on("connect", () => {
+  console.log("[socket] Connected");
+});
+socket.on("disconnect", reason => {
+  console.log("[socket] Disconnected:", reason);
+});
+socket.on("error", error => {
+  console.log("[socket] Error:", error);
+});
+socket.on("m", data => {
+  console.log("[socket] Message:", data);
+  const [eventTypeStr, exchange, fromSymbol, toSymbol,,, tradeTimeStr,, tradePriceStr] = data.split("~");
+
+  if (parseInt(eventTypeStr) !== 0) {
+    // skip all non-TRADE events
+    return;
+  }
+
+  const tradePrice = parseFloat(tradePriceStr);
+  const tradeTime = parseInt(tradeTimeStr);
+  const channelString = "0~".concat(exchange, "~").concat(fromSymbol, "~").concat(toSymbol);
+  const subscriptionItem = channelToSubscription.get(channelString);
+
+  if (subscriptionItem === undefined) {
+    return;
+  }
+
+  const lastDailyBar = subscriptionItem.lastDailyBar;
+  const nextDailyBarTime = getNextDailyBarTime(lastDailyBar.time);
+  let bar;
+
+  if (tradeTime >= nextDailyBarTime) {
+    bar = {
+      time: nextDailyBarTime,
+      open: tradePrice,
+      high: tradePrice,
+      low: tradePrice,
+      close: tradePrice
+    };
+    console.log("[socket] Generate new bar", bar);
+  } else {
+    bar = _objectSpread(_objectSpread({}, lastDailyBar), {}, {
+      high: Math.max(lastDailyBar.high, tradePrice),
+      low: Math.min(lastDailyBar.low, tradePrice),
+      close: tradePrice
+    });
+    console.log("[socket] Update the latest bar by price", tradePrice);
+  }
+
+  subscriptionItem.lastDailyBar = bar; // send data to every subscriber of that symbol
+
+  subscriptionItem.handlers.forEach(handler => handler.callback(bar));
+});
+
+function getNextDailyBarTime(barTime) {
+  const date = new Date(barTime * 1000);
+  date.setDate(date.getDate() + 1);
+  return date.getTime() / 1000;
+}
+
+function subscribeOnStream(symbolInfo, resolution, onRealtimeCallback, subscribeUID, onResetCacheNeededCallback, lastDailyBar) {
+  const parsedSymbol = (0, _helpers.parseFullSymbol)(symbolInfo.full_name);
+  const channelString = "0~".concat(parsedSymbol.exchange, "~").concat(parsedSymbol.fromSymbol, "~").concat(parsedSymbol.toSymbol);
+  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,
+    lastDailyBar,
+    handlers: [handler]
+  };
+  channelToSubscription.set(channelString, subscriptionItem);
+  console.log("[subscribeBars]: Subscribe to streaming. Channel:", channelString);
+  socket.emit("SubAdd", {
+    subs: [channelString]
+  });
+}
+
+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);
+        socket.emit("SubRemove", {
+          subs: [channelString]
+        });
+        channelToSubscription.delete(channelString);
+        break;
+      }
+    }
+  }
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.4",
+  "version": "0.0.5",
   "name": "binbot-charts",
   "dependencies": {
     "@babel/cli": "^7.18.10",
@@ -12,7 +12,7 @@
   },
   "scripts": {
     "start": "react-scripts start",
-    "build": "rm -rf dist && NODE_ENV=production babel src/components src/charting_library --out-dir dist --copy-files",
+    "build": "rm -rf dist && cp src/charting_library dist/charting_library NODE_ENV=production babel src/components --out-dir dist --copy-files",
     "publish": "yarn build && npm publish"
   },
   "description": "Binbot charts is the default candlestick bars chart used in terminal.binbot.com to render bots graphically.",