@mathieuc/tradingview 3.0.0 → 3.3.0

package/examples/ReplayMode.js

@@ -0,0 +1,97 @@
+const TradingView = require('../main');
+
+/*
+  This example tests the real replay
+  mode by fetching indicator data and
+  stores it in a 'periods' variable
+*/
+
+const config = {
+  symbol: 'BINANCE:BTCEUR',
+  timeframe: 'D',
+  startFrom: Math.round(Date.now() / 1000) - 86400 * 7, // Seven days before now
+  // startFrom: 1600000000,
+};
+
+console.log('----- Testing ReplayMode: -----');
+
+const client = new TradingView.Client();
+const chart = new client.Session.Chart();
+
+chart.setMarket(config.symbol, {
+  timeframe: config.timeframe,
+  replay: config.startFrom,
+  range: 1,
+});
+
+// chart.onReplayLoaded(() => {
+//   console.log('STARTING REPLAY MODE');
+//   chart.replayStart(1000);
+
+//   // setTimeout(() => {
+//   //   console.log('STOPPING REPLAY MODE');
+//   //   chart.replayStop();
+//   // }, 7000);
+// });
+
+let loading = 0;
+const indicators = [];
+const periods = {};
+
+let interval = NaN;
+
+async function step() {
+  const period = { ...chart.periods[0] };
+
+  const times = Object.keys(periods);
+  const intrval = times[times.length - 1] - times[times.length - 2];
+  if (Number.isNaN(interval) && times.length >= 2) interval = intrval;
+
+  if (!Number.isNaN(interval) && interval !== intrval) {
+    throw new Error(`Wrong interval: ${intrval} (should be ${interval})`);
+  }
+
+  indicators.forEach(([n, i]) => {
+    const plots = { ...i.periods[0] };
+    delete plots.$time;
+    period[n] = { plots };
+
+    Object.keys(i.graphic).forEach((g) => {
+      if (!i.graphic[g].length) return;
+      if (!period[n].graphics) period[n].graphics = {};
+      period[n].graphics[g] = i.graphic[g];
+    });
+  });
+
+  periods[period.time] = period;
+
+  console.log('Next ->', period.time, times.length);
+
+  await chart.replayStep(1);
+  step();
+}
+
+chart.onReplayEnd(async () => {
+  await client.end();
+  console.log('Done !', Object.keys(periods).length);
+});
+
+async function addIndicator(name, pineId, options = {}) {
+  loading += 1;
+
+  const indic = pineId.includes('@')
+    ? new TradingView.BuiltInIndicator(pineId)
+    : await TradingView.getIndicator(pineId);
+  Object.keys(options).forEach((o) => { indic.setOption(o, options[o]); });
+
+  const std = new chart.Study(indic);
+
+  std.onReady(() => {
+    indicators.push([name, std]);
+    if (loading === indicators.length) step();
+  });
+}
+
+addIndicator('Volume', 'Volume@tv-basicstudies-144');
+addIndicator('EMA_50', 'STD;EMA', { Length: 50 });
+addIndicator('EMA_200', 'STD;EMA', { Length: 200 });

package/examples/UserLogin.js

@@ -0,0 +1,16 @@
+const TradingView = require('../main');
+
+/*
+  This example tests the
+  user login function
+*/
+
+if (!process.argv[2]) throw Error('Please specify your username/email');
+if (!process.argv[3]) throw Error('Please specify your password');
+
+TradingView.loginUser(process.argv[2], process.argv[3], false).then((user) => {
+  console.log('User:', user);
+  console.log('Sessionid:', user.session);
+}).catch((err) => {
+  console.error('Login error:', err.message);
+});

package/main.js

@@ -2,8 +2,10 @@ const miscRequests = require('./src/miscRequests');
 const Client = require('./src/client');
 const BuiltInIndicator = require('./src/classes/BuiltInIndicator');
 const PineIndicator = require('./src/classes/PineIndicator');
+const PinePermManager = require('./src/classes/PinePermManager');
 
 module.exports = { ...miscRequests };
 module.exports.Client = Client;
 module.exports.BuiltInIndicator = BuiltInIndicator;
 module.exports.PineIndicator = PineIndicator;
+module.exports.PinePermManager = PinePermManager;

package/package.json

@@ -1,20 +1,18 @@
 {
   "name": "@mathieuc/tradingview",
-  "version": "3.0.0",
+  "version": "3.3.0",
   "description": "Tradingview instant stocks API, indicator alerts, trading bot, and more !",
   "main": "main.js",
   "scripts": {
-    "test-prices": "node ./tests/prices.js",
-    "test-analysis": "node ./tests/analysis.js",
-    "test-indicator": "node ./tests/indicator.js",
-    "test-manual-alerts": "node ./tests/alerts/manualAlert.js",
-    "test-strat-alerts": "node ./tests/alerts/strategyAlert.js",
-    "test": "npm run test-prices"
+    "test": "node test"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Mathieu2301/TradingView-API.git"
   },
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "keywords": [
     "tradingwiew",
     "market",
@@ -36,7 +34,6 @@
     "@mathieuc/console": "^1.0.1",
     "eslint": "^7.25.0",
     "eslint-config-airbnb-base": "^14.2.1",
-    "eslint-plugin-import": "^2.22.1",
-    "jsdoc-to-markdown": "^7.1.0"
+    "eslint-plugin-import": "^2.22.1"
   }
 }

package/src/FormData.js

@@ -0,0 +1,36 @@
+/** @class */
+class FormData {
+  #string = '';
+
+  #boundary = '';
+
+  get boundary() {
+    return this.#boundary;
+  }
+
+  constructor() {
+    const random = (Math.random() * 10 ** 20).toString(36);
+    this.#boundary = `${random}`;
+    this.#string = `--${this.boundary}`;
+  }
+
+  /**
+   * Adds a property to the FormData object
+   * @param {string} key Property key
+   * @param {string} value Property value
+   */
+  append(key, value) {
+    this.#string += `\r\nContent-Disposition: form-data; name="${key}"`;
+    this.#string += `\r\n\r\n${value}`;
+    this.#string += `\r\n--${this.boundary}`;
+  }
+
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return `${this.#string}--`;
+  }
+}
+
+module.exports = FormData;

package/src/chart/session.js

@@ -53,17 +53,20 @@ const ChartTypes = {
  * @prop {number} close Period close value
  * @prop {number} max Period max value
  * @prop {number} min Period min value
- * @prop {number} change Period change absolute value
+ * @prop {number} volume Period volume value
  */
 
 /**
  * @typedef {Object} Subsession
  * @prop {string} id Subsession ID (ex: 'regular')
  * @prop {string} description Subsession description (ex: 'Regular')
- * @prop {string} privat If private
+ * @prop {boolean} private If private
  * @prop {string} session Session (ex: '24x7')
+ * @prop {string} session-correction Session correction
  * @prop {string} session-display Session display (ex: '24x7')
- *
+ */
+
+/**
  * @typedef {Object} MarketInfos
  * @prop {string} series_id            Used series (ex: 'ser_1')
  * @prop {string} base_currency        Base currency (ex: 'BTC')
@@ -91,7 +94,7 @@ const ChartTypes = {
  * @prop {number} minmove2             Minimum move value 2
  * @prop {string} timezone             Used timezone
  * @prop {boolean} is_replayable       If the replay mode is available
- * @prop {boolean} has_adjustment      If the adjustment mode is enabled ????
+ * @prop {boolean} has_adjustment      If the adjustment mode is enabled
  * @prop {boolean} has_extended_hours  Has extended hours
  * @prop {string} bar_source           Bar source
  * @prop {string} bar_transform        Bar transform
@@ -112,7 +115,14 @@ const ChartTypes = {
  * @param {import('../client').ClientBridge} client
  */
 module.exports = (client) => class ChartSession {
-  #sessionID = genSessionID('cs');
+  #chartSessionID = genSessionID('cs');
+
+  #replaySessionID = genSessionID('rs');
+
+  #replayMode = false;
+
+  /** @type {Object<string, (): any>} */
+  #replayOKCB = {};
 
   /** Parent client */
   #client = client;
@@ -147,6 +157,11 @@ module.exports = (client) => class ChartSession {
     symbolLoaded: [],
     update: [],
 
+    replayLoaded: [],
+    replayPoint: [],
+    replayResolution: [],
+    replayEnd: [],
+
     event: [],
     error: [],
   };
@@ -166,7 +181,7 @@ module.exports = (client) => class ChartSession {
   }
 
   constructor() {
-    this.#client.sessions[this.#sessionID] = {
+    this.#client.sessions[this.#chartSessionID] = {
       type: 'chart',
       onData: (packet) => {
         if (global.TW_DEBUG) console.log('§90§30§106 CHART SESSION §0 DATA', packet);
@@ -187,7 +202,10 @@ module.exports = (client) => class ChartSession {
         }
 
         if (['timescale_update', 'du'].includes(packet.type)) {
+          const changes = [];
+
           Object.keys(packet.data[1]).forEach((k) => {
+            changes.push(k);
             if (k === '$prices') {
               const periods = packet.data[1].$prices;
               if (!periods || !periods.s) return;
@@ -200,7 +218,7 @@ module.exports = (client) => class ChartSession {
                   close: p.v[4],
                   max: p.v[2],
                   min: p.v[3],
-                  change: Math.round(p.v[5] * 100) / 100,
+                  volume: Math.round(p.v[5] * 100) / 100,
                 };
               });
 
@@ -210,7 +228,7 @@ module.exports = (client) => class ChartSession {
             if (this.#studyListeners[k]) this.#studyListeners[k](packet);
           });
 
-          this.#handleEvent('update');
+          this.#handleEvent('update', changes);
           return;
         }
 
@@ -231,7 +249,47 @@ module.exports = (client) => class ChartSession {
       },
     };
 
-    this.#client.send('chart_create_session', [this.#sessionID]);
+    this.#client.sessions[this.#replaySessionID] = {
+      type: 'replay',
+      onData: (packet) => {
+        if (global.TW_DEBUG) console.log('§90§30§106 REPLAY SESSION §0 DATA', packet);
+
+        if (packet.type === 'replay_ok') {
+          if (this.#replayOKCB[packet.data[1]]) {
+            this.#replayOKCB[packet.data[1]]();
+            delete this.#replayOKCB[packet.data[1]];
+          }
+          return;
+        }
+
+        if (packet.type === 'replay_instance_id') {
+          this.#handleEvent('replayLoaded', packet.data[1]);
+          return;
+        }
+
+        if (packet.type === 'replay_point') {
+          this.#handleEvent('replayPoint', packet.data[1]);
+          return;
+        }
+
+        if (packet.type === 'replay_resolutions') {
+          this.#handleEvent('replayResolution', packet.data[1], packet.data[2]);
+          return;
+        }
+
+        if (packet.type === 'replay_data_end') {
+          this.#handleEvent('replayEnd');
+          return;
+        }
+
+        if (packet.type === 'critical_error') {
+          const [, name, description] = packet.data;
+          this.#handleError('Critical error:', name, description);
+        }
+      },
+    };
+
+    this.#client.send('chart_create_session', [this.#chartSessionID]);
   }
 
   #seriesCreated = false;
@@ -241,22 +299,25 @@ module.exports = (client) => class ChartSession {
   /**
    * @param {import('../types').TimeFrame} timeframe Chart period timeframe
    * @param {number} [range] Number of loaded periods/candles (Default: 100)
+   * @param {number} [reference] Reference candle timestamp (Default is now)
    */
-  setSeries(timeframe = '240', range = 100) {
+  setSeries(timeframe = '240', range = 100, reference = null) {
     if (!this.#currentSeries) {
       this.#handleError('Please set the market before setting series');
       return;
     }
 
+    const calcRange = !reference ? range : ['bar_count', reference, range];
+
     this.#periods = {};
 
     this.#client.send(`${this.#seriesCreated ? 'modify' : 'create'}_series`, [
-      this.#sessionID,
+      this.#chartSessionID,
       '$prices',
       's1',
       `ser_${this.#currentSeries}`,
       timeframe,
-      this.#seriesCreated ? '' : range,
+      this.#seriesCreated ? '' : calcRange,
     ]);
 
     this.#seriesCreated = true;
@@ -268,41 +329,67 @@ module.exports = (client) => class ChartSession {
    * @param {Object} [options] Chart options
    * @param {import('../types').TimeFrame} [options.timeframe] Chart period timeframe
    * @param {number} [options.range] Number of loaded periods/candles (Default: 100)
+   * @param {number} [options.to] Last candle timestamp (Default is now)
    * @param {'splits' | 'dividends'} [options.adjustment] Market adjustment
    * @param {'regular' | 'extended'} [options.session] Chart session
    * @param {'EUR' | 'USD' | string} [options.currency] Chart currency
    * @param {ChartType} [options.type] Chart custom type
    * @param {ChartInputs} [options.inputs] Chart custom inputs
+   * @param {number} [options.replay] Replay mode starting point (Timestamp)
    */
   setMarket(symbol, options = {}) {
     this.#periods = {};
 
+    if (this.#replayMode) {
+      this.#replayMode = false;
+      this.#client.send('replay_delete_session', [this.#replaySessionID]);
+    }
+
     const symbolInit = {
       symbol: symbol || 'BTCEUR',
       adjustment: options.adjustment || 'splits',
     };
 
     if (options.session) symbolInit.session = options.session;
-
     if (options.currency) symbolInit['currency-id'] = options.currency;
 
-    const chartInit = (options.type && ChartTypes[options.type]) ? {} : symbolInit;
+    if (options.replay) {
+      this.#replayMode = true;
+      this.#client.send('replay_create_session', [this.#replaySessionID]);
+
+      this.#client.send('replay_add_series', [
+        this.#replaySessionID,
+        'req_replay_addseries',
+        `=${JSON.stringify(symbolInit)}`,
+        options.timeframe,
+      ]);
+
+      this.#client.send('replay_reset', [
+        this.#replaySessionID,
+        'req_replay_reset',
+        options.replay,
+      ]);
+    }
+
+    const complex = options.type || options.replay;
+    const chartInit = complex ? {} : symbolInit;
 
-    if (options.type && ChartTypes[options.type]) {
+    if (complex) {
+      if (options.replay) chartInit.replay = this.#replaySessionID;
       chartInit.symbol = symbolInit;
       chartInit.type = ChartTypes[options.type];
-      chartInit.inputs = { ...options.inputs };
+      if (options.type) chartInit.inputs = { ...options.inputs };
     }
 
     this.#currentSeries += 1;
 
     this.#client.send('resolve_symbol', [
-      this.#sessionID,
+      this.#chartSessionID,
       `ser_${this.#currentSeries}`,
       `=${JSON.stringify(chartInit)}`,
     ]);
 
-    this.setSeries(options.timeframe, options.range);
+    this.setSeries(options.timeframe, options.range, options.to);
   }
 
   /**
@@ -311,7 +398,7 @@ module.exports = (client) => class ChartSession {
    */
   setTimezone(timezone) {
     this.#periods = {};
-    this.#client.send('switch_timezone', [this.#sessionID, timezone]);
+    this.#client.send('switch_timezone', [this.#chartSessionID, timezone]);
   }
 
   /**
@@ -319,7 +406,60 @@ module.exports = (client) => class ChartSession {
    * @param {number} number Number of additional periods/candles you want to fetch
    */
   fetchMore(number = 1) {
-    this.#client.send('request_more_data', [this.#sessionID, '$prices', number]);
+    this.#client.send('request_more_data', [this.#chartSessionID, '$prices', number]);
+  }
+
+  /**
+   * Fetch x additional previous periods/candles values
+   * @param {number} number Number of additional periods/candles you want to fetch
+   * @returns {Promise} Raise when the data has been fetched
+   */
+  replayStep(number = 1) {
+    return new Promise((cb) => {
+      if (!this.#replayMode) {
+        this.#handleError('No replay session');
+        return;
+      }
+
+      const reqID = genSessionID('rsq_step');
+      this.#client.send('replay_step', [this.#replaySessionID, reqID, number]);
+      this.#replayOKCB[reqID] = () => { cb(); };
+    });
+  }
+
+  /**
+   * Start fetching a new period/candle every x ms
+   * @param {number} interval Number of additional periods/candles you want to fetch
+   * @returns {Promise} Raise when the replay mode starts
+   */
+  replayStart(interval = 1000) {
+    return new Promise((cb) => {
+      if (!this.#replayMode) {
+        this.#handleError('No replay session');
+        return;
+      }
+
+      const reqID = genSessionID('rsq_start');
+      this.#client.send('replay_start', [this.#replaySessionID, reqID, interval]);
+      this.#replayOKCB[reqID] = () => { cb(); };
+    });
+  }
+
+  /**
+   * Stop fetching a new period/candle every x ms
+   * @returns {Promise} Raise when the replay mode stops
+   */
+  replayStop() {
+    return new Promise((cb) => {
+      if (!this.#replayMode) {
+        this.#handleError('No replay session');
+        return;
+      }
+
+      const reqID = genSessionID('rsq_stop');
+      this.#client.send('replay_stop', [this.#replaySessionID, reqID]);
+      this.#replayOKCB[reqID] = () => { cb(); };
+    });
   }
 
   /**
@@ -333,13 +473,52 @@ module.exports = (client) => class ChartSession {
 
   /**
    * When a chart update happens
-   * @param {() => void} cb
+   * @param {(changes: ('$prices' | string)[]) => void} cb
    * @event
    */
   onUpdate(cb) {
     this.#callbacks.update.push(cb);
   }
 
+  /**
+   * When the replay session is ready
+   * @param {() => void} cb
+   * @event
+   */
+  onReplayLoaded(cb) {
+    this.#callbacks.replayLoaded.push(cb);
+  }
+
+  /**
+   * When the replay session has new resolution
+   * @param {(
+   *   timeframe: import('../types').TimeFrame,
+   *   index: number,
+   * ) => void} cb
+   * @event
+   */
+  onReplayResolution(cb) {
+    this.#callbacks.replayResolution.push(cb);
+  }
+
+  /**
+   * When the replay session ends
+   * @param {() => void} cb
+   * @event
+   */
+  onReplayEnd(cb) {
+    this.#callbacks.replayEnd.push(cb);
+  }
+
+  /**
+   * When the replay session cursor has moved
+   * @param {(index: number) => void} cb
+   * @event
+   */
+  onReplayPoint(cb) {
+    this.#callbacks.replayPoint.push(cb);
+  }
+
   /**
    * When chart error happens
    * @param {(...any) => void} cb Callback
@@ -351,7 +530,7 @@ module.exports = (client) => class ChartSession {
 
   /** @type {ChartSessionBridge} */
   #chartSession = {
-    sessionID: this.#sessionID,
+    sessionID: this.#chartSessionID,
     studyListeners: this.#studyListeners,
     indexes: {},
     send: (t, p) => this.#client.send(t, p),
@@ -361,7 +540,9 @@ module.exports = (client) => class ChartSession {
 
   /** Delete the chart session */
   delete() {
-    this.#client.send('quote_delete_session', [this.#sessionID]);
-    delete this.#client.sessions[this.#sessionID];
+    if (this.#replayMode) this.#client.send('replay_delete_session', [this.#replaySessionID]);
+    this.#client.send('chart_delete_session', [this.#chartSessionID]);
+    delete this.#client.sessions[this.#chartSessionID];
+    this.#replayMode = false;
   }
 };