@mathieuc/tradingview 3.3.0 → 3.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mathieuc/tradingview",
-  "version": "3.3.0",
+  "version": "3.3.3",
   "description": "Tradingview instant stocks API, indicator alerts, trading bot, and more !",
   "main": "main.js",
   "scripts": {

package/src/chart/study.js

@@ -32,6 +32,27 @@ function getInputs(options) {
   return options.options;
 }
 
+const parseTrades = (trades) => trades.reverse().map((t) => ({
+  entry: {
+    name: t.e.c,
+    type: (t.e.tp[0] === 's' ? 'short' : 'long'),
+    value: t.e.p,
+    time: t.e.tm,
+  },
+  exit: {
+    name: t.x.c,
+    value: t.x.p,
+    time: t.x.tm,
+  },
+  quantity: t.q,
+  profit: t.tp,
+  cumulative: t.cp,
+  runup: t.rn,
+  drawdown: t.dd,
+}));
+
+// const historyParser = (history) => history.reverse().map((h) => ({
+
 /**
  * @typedef {Object} TradeReport Trade report
 
@@ -86,9 +107,19 @@ function getInputs(options) {
  * @prop {number} totalTrades Total trades
 */
 
+/**
+ * @typedef {Object} FromTo
+ * @prop {number} from From timestamp
+ * @prop {number} to To timestamp
+ */
+
 /**
  * @typedef {Object} StrategyReport
  * @prop {'EUR' | 'USD' | 'JPY' | '' | 'CHF'} [currency] Selected currency
+ * @prop {Object} [settings] Backtester settings
+ * @prop {Object} [settings.dateRange] Backtester date range
+ * @prop {FromTo} [settings.dateRange.backtest] Date range for backtest
+ * @prop {FromTo} [settings.dateRange.trade] Date range for trade
  * @prop {TradeReport[]} trades Trade list starting by the last
  * @prop {Object} history History Chart value
  * @prop {number[]} [history.buyHold] Buy hold values
@@ -275,50 +306,45 @@ module.exports = (chartSession) => class ChartStudy {
             changes.push('graphic');
           }
 
-          if (parsed.data && parsed.data.report && parsed.data.report.performance) {
-            this.#strategyReport.performance = parsed.data.report.performance;
-            changes.push('perfReport');
-          }
+          const updateStrategyReport = (report) => {
+            if (report.currency) {
+              this.#strategyReport.currency = report.currency;
+              changes.push('report.currency');
+            }
+
+            if (report.settings) {
+              this.#strategyReport.settings = report.settings;
+              changes.push('report.settings');
+            }
+
+            if (report.performance) {
+              this.#strategyReport.performance = report.performance;
+              changes.push('report.perf');
+            }
+
+            if (report.trades) {
+              this.#strategyReport.trades = parseTrades(report.trades);
+              changes.push('report.trades');
+            }
+
+            if (report.equity) {
+              this.#strategyReport.history = {
+                buyHold: report.buyHold,
+                buyHoldPercent: report.buyHoldPercent,
+                drawDown: report.drawDown,
+                drawDownPercent: report.drawDownPercent,
+                equity: report.equity,
+                equityPercent: report.equityPercent,
+              };
+              changes.push('report.history');
+            }
+          };
 
           if (parsed.dataCompressed) {
-            const parsedC = await parseCompressed(parsed.dataCompressed);
-
-            this.#strategyReport = {
-              currency: parsedC.report.currency,
-
-              trades: parsedC.report.trades.reverse().map((t) => ({
-                entry: {
-                  name: t.e.c,
-                  type: (t.e.tp[0] === 's' ? 'short' : 'long'),
-                  value: t.e.p,
-                  time: t.e.tm,
-                },
-                exit: {
-                  name: t.x.c,
-                  value: t.x.p,
-                  time: t.x.tm,
-                },
-                quantity: t.q,
-                profit: t.tp,
-                cumulative: t.cp,
-                runup: t.rn,
-                drawdown: t.dd,
-              })),
-
-              history: {
-                buyHold: parsedC.report.buyHold,
-                buyHoldPercent: parsedC.report.buyHoldPercent,
-                drawDown: parsedC.report.drawDown,
-                drawDownPercent: parsedC.report.drawDownPercent,
-                equity: parsedC.report.equity,
-                equityPercent: parsedC.report.equityPercent,
-              },
-
-              performance: parsedC.report.performance,
-            };
-
-            changes.push('fullReport');
+            updateStrategyReport((await parseCompressed(parsed.dataCompressed)).report);
           }
+
+          if (parsed.data && parsed.data.report) updateStrategyReport(parsed.data.report);
         }
 
         if (data.ns.indexes && typeof data.ns.indexes === 'object') {
@@ -372,7 +398,12 @@ module.exports = (chartSession) => class ChartStudy {
     this.#callbacks.studyCompleted.push(cb);
   }
 
-  /** @typedef {'plots' | 'perfReport' | 'fullReport'} UpdateChangeType */
+  /**
+   * @typedef {'plots' | 'report.currency'
+   *  | 'report.settings' | 'report.perf'
+   *  | 'report.trades' | 'report.history'
+   * } UpdateChangeType
+   */
 
   /**
    * When an indicator update happens

package/src/client.js

@@ -215,6 +215,7 @@ module.exports = class Client {
    * @typedef {Object} ClientOptions
    * @prop {string} [token] User auth token (in 'sessionid' cookie)
    * @prop {boolean} [DEBUG] Enable debug mode
+   * @prop {'data' | 'prodata' | 'widgetdata'} [server] Server type
    */
 
   /** Client object
@@ -223,7 +224,8 @@ module.exports = class Client {
   constructor(clientOptions = {}) {
     if (clientOptions.DEBUG) global.TW_DEBUG = clientOptions.DEBUG;
 
-    this.#ws = new WebSocket('wss://data.tradingview.com/socket.io/websocket', {
+    const server = clientOptions.server || 'data';
+    this.#ws = new WebSocket(`wss://${server}.tradingview.com/socket.io/websocket`, {
       origin: 'https://s.tradingview.com',
     });
 

package/src/miscRequests.js

@@ -275,10 +275,12 @@ module.exports = {
     data.result.metaInfo.inputs.forEach((input) => {
       if (['text', 'pineId', 'pineVersion'].includes(input.id)) return;
 
+      const inlineName = input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+
       inputs[input.id] = {
         name: input.name,
-        inline: input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, ''),
-        internalID: input.internalID,
+        inline: input.inline || inlineName,
+        internalID: input.internalID || inlineName,
         tooltip: input.tooltip,
 
         type: input.type,