@mathieuc/tradingview 2.0.91 → 3.2.0

package/{miscRequests.js → src/miscRequests.js}

@@ -1,40 +1,11 @@
 const https = require('https');
+const request = require('./request');
 
-const indicators = ['Recommend.Other', 'Recommend.All', 'Recommend.MA'];
-const indicList = [];
-
-/**
- * @param {https.RequestOptions} options HTTPS Request options
- * @param {boolean} [raw] Get raw or JSON data
- * @param {string} [content] Request body content
- * @returns {Promise<string | object | array>} Result
- */
-function request(options = {}, raw = false, content = '') {
-  return new Promise((cb, err) => {
-    const req = https.request(options, (res) => {
-      let data = '';
-      res.on('data', (c) => { data += c; });
-      res.on('end', () => {
-        if (raw) {
-          cb(data);
-          return;
-        }
-
-        try {
-          data = JSON.parse(data);
-        } catch (error) {
-          err(new Error('Can\'t parse server response'));
-          return;
-        }
-
-        cb(data);
-      });
-    });
+const PinePermManager = require('./classes/PinePermManager');
+const PineIndicator = require('./classes/PineIndicator');
 
-    req.on('error', err);
-    req.end(content);
-  });
-}
+const indicators = ['Recommend.Other', 'Recommend.All', 'Recommend.MA'];
+const builtInIndicList = [];
 
 async function fetchScanData(tickers = [], type = '', columns = []) {
   let data = await request({
@@ -132,7 +103,7 @@ module.exports = {
   },
 
   /**
-   * @typedef {Object} SearchResult
+   * @typedef {Object} SearchMarketResult
    * @property {string} id
    * @property {string} exchange
    * @property {string} fullExchange
@@ -147,9 +118,9 @@ module.exports = {
    * Find a symbol
    * @param {string} search Keywords
    * @param {'stock' | 'futures' | 'forex' | 'cfd' | 'crypto' | 'index' | 'economic'} [filter]
-   * @returns {Promise<SearchResult[]>} Search results
+   * @returns {Promise<SearchMarketResult[]>} Search results
    */
-  async search(search, filter = '') {
+  async searchMarket(search, filter = '') {
     const data = await request({
       host: 'symbol-search.tradingview.com',
       path: `/symbol_search/?text=${search.replace(/ /g, '%20')}&type=${filter}`,
@@ -179,7 +150,7 @@ module.exports = {
   },
 
   /**
-   * @typedef {Object} IndicatorResult
+   * @typedef {Object} SearchIndicatorResult
    * @property {string} id Script ID
    * @property {string} version Script version
    * @property {string} name Script complete name
@@ -187,18 +158,20 @@ module.exports = {
    * @property {string} image Image ID https://tradingview.com/i/${image}
    * @property {string | ''} source Script source (if available)
    * @property {'study' | 'strategy'} type Script type (study / strategy)
-   * @property {'open_source' | 'closed_source' | 'invite_only' | 'other'} access Script access type
+   * @property {'open_source' | 'closed_source' | 'invite_only'
+   *  | 'private' | 'other'} access Script access type
+   * @property {() => Promise<PineIndicator>} get Get the full indicator informations
    */
 
   /**
    * Find an indicator
    * @param {string} search Keywords
-   * @returns {Promise<IndicatorResult[]>} Search results
+   * @returns {Promise<SearchIndicatorResult[]>} Search results
    */
   async searchIndicator(search = '') {
-    if (!indicList.length) {
+    if (!builtInIndicList.length) {
       await Promise.all(['standard', 'candlestick', 'fundamental'].map(async (type) => {
-        indicList.push(...await request({
+        builtInIndicList.push(...await request({
           host: 'pine-facade.tradingview.com',
           path: `/pine-facade/list/?filter=${type}`,
         }));
@@ -215,7 +188,7 @@ module.exports = {
     }
 
     return [
-      ...indicList.filter((i) => (
+      ...builtInIndicList.filter((i) => (
         norm(i.scriptName).includes(norm(search))
         || norm(i.extra.shortDescription).includes(norm(search))
       )).map((ind) => ({
@@ -230,6 +203,9 @@ module.exports = {
         access: 'closed_source',
         source: '',
         type: (ind.extra && ind.extra.kind) ? ind.extra.kind : 'study',
+        get() {
+          return module.exports.getIndicator(ind.scriptIdPart, ind.version);
+        },
       })),
 
       ...data.results.map((ind) => ({
@@ -244,42 +220,20 @@ module.exports = {
         access: ['open_source', 'closed_source', 'invite_only'][ind.access - 1] || 'other',
         source: ind.scriptSource,
         type: (ind.extra && ind.extra.kind) ? ind.extra.kind : 'study',
+        get() {
+          return module.exports.getIndicator(ind.scriptIdPart, ind.version);
+        },
       })),
     ];
   },
 
-  /**
-   * @typedef {Object} indicatorInput
-   * @property {string} name
-   * @property {string} inline Inline name
-   * @property { 'text' | 'source' | 'integer' | 'float' | 'resolution' | 'bool' } type
-   * @property {string | number | boolean} value
-   * @property {string | number | boolean} defVal
-   * @property {boolean} hidden
-   * @property {boolean} isFake
-   * @property {string[]} [options]
-   */
-
-  /**
-   * @typedef {Object} Indicator
-   * @property {string} pineId Indicator ID
-   * @property {string} pineVersion Indicator version
-   * @property {string} description Indicator description
-   * @property {string} shortDescription Indicator short description
-   * @property {string} typeID Indicator script type ID
-   * @property {Object<string, indicatorInput>} inputs Indicator inputs
-   * @property {Object<string, string>} plots Indicator plots
-   * @property {string} script Indicator script
-   */
-
   /**
    * Get an indicator
    * @param {string} id Indicator ID (Like: PUB;XXXXXXXXXXXXXXXXXXXXX)
-   * @param {string} version Wanted version of the indicator
-   * @param {'study' | 'strategy'} [type] Script type
-   * @returns {Promise<Indicator>} Indicator
+   * @param {'last' | string} [version] Wanted version of the indicator
+   * @returns {Promise<PineIndicator>} Indicator
    */
-  async getIndicator(id, version, settings = [], type = 'study') {
+  async getIndicator(id, version = 'last') {
     const indicID = id.replace(/ |%/g, '%25');
 
     let data = await request({
@@ -294,26 +248,24 @@ module.exports = {
     }
 
     if (!data.success || !data.result.metaInfo || !data.result.metaInfo.inputs) {
-      console.error(data);
-      throw new Error('Inexistent or unsupported indicator');
+      throw new Error(`Inexistent or unsupported indicator: "${data.reason}"`);
     }
 
     const inputs = {};
 
     data.result.metaInfo.inputs.forEach((input) => {
       if (['text', 'pineId', 'pineVersion'].includes(input.id)) return;
-      const inline = input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '');
-
-      const i = parseInt(input.id.replace(/[^0-9]/g, ''), 10);
 
       inputs[input.id] = {
         name: input.name,
+        inline: input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, ''),
+        internalID: input.internalID,
+        tooltip: input.tooltip,
+
         type: input.type,
-        value: settings[input.internalID] ?? settings[i] ?? input.defval,
-        defVal: input.defval,
-        hidden: !!input.isHidden,
+        value: input.defval,
+        isHidden: !!input.isHidden,
         isFake: !!input.isFake,
-        inline,
       };
 
       if (input.options) inputs[input.id].options = input.options;
@@ -322,22 +274,37 @@ module.exports = {
     const plots = {};
 
     Object.keys(data.result.metaInfo.styles).forEach((plotId) => {
-      plots[plotId] = data.result.metaInfo.styles[plotId].title.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+      const plotTitle = data
+        .result
+        .metaInfo
+        .styles[plotId]
+        .title
+        .replace(/ /g, '_')
+        .replace(/[^a-zA-Z0-9_]/g, '');
+
+      const titles = Object.values(plots);
+
+      if (titles.includes(plotTitle)) {
+        let i = 2;
+        while (titles.includes(`${plotTitle}_${i}`)) i += 1;
+        plots[plotId] = `${plotTitle}_${i}`;
+      } else plots[plotId] = plotTitle;
     });
 
-    return {
-      pineId: indicID,
-      pineVersion: version,
+    data.result.metaInfo.plots.forEach((plot) => {
+      if (!plot.target) return;
+      plots[plot.id] = `${plots[plot.target] ?? plot.target}_${plot.type}`;
+    });
+
+    return new PineIndicator({
+      pineId: data.result.metaInfo.scriptIdPart || indicID,
+      pineVersion: data.result.metaInfo.pine.version || version,
       description: data.result.metaInfo.description,
       shortDescription: data.result.metaInfo.shortDescription,
-      typeID: {
-        study: 'Script@tv-scripting-101!',
-        strategy: 'StrategyScript@tv-scripting-101!',
-      }[type] || type,
       inputs,
       plots,
       script: data.result.ilTemplate,
-    };
+    });
   },
 
   /**
@@ -404,6 +371,52 @@ module.exports = {
     });
   },
 
+  /**
+   * Get user's private indicators from a 'sessionid' cookie
+   * @param {string} session User 'sessionid' cookie
+   * @returns {Promise<SearchIndicatorResult[]>} Search results
+   */
+  async getPrivateIndicators(session) {
+    return new Promise((cb, err) => {
+      https.get('https://pine-facade.tradingview.com/pine-facade/list?filter=saved', {
+        headers: { cookie: `sessionid=${session}` },
+      }, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', async () => {
+          try {
+            rs = JSON.parse(rs);
+          } catch (error) {
+            err(new Error('Can\'t parse private indicator list'));
+            return;
+          }
+
+          cb(rs.map((ind) => ({
+            id: ind.scriptIdPart,
+            version: ind.version,
+            name: ind.scriptName,
+            author: {
+              id: -1,
+              username: '@ME@',
+            },
+            image: ind.imageUrl,
+            access: 'private',
+            source: ind.scriptSource,
+            type: (ind.extra && ind.extra.kind) ? ind.extra.kind : 'study',
+            get() {
+              return module.exports.getIndicator(ind.scriptIdPart, ind.version);
+            },
+            getManager() {
+              return new PinePermManager(ind.scriptIdPart);
+            },
+          })));
+        });
+
+        res.on('error', err);
+      }).end();
+    });
+  },
+
   /**
    * User credentials
    * @typedef {Object} UserCredentials

package/src/protocol.js

@@ -0,0 +1,54 @@
+const JSZip = require('jszip');
+
+/**
+ * @typedef {Object} TWPacket
+ * @prop {string} [m] Packet type
+ * @prop {[session: string, {}]} [p] Packet data
+ */
+
+module.exports = {
+  /**
+   * Parse websocket packet
+   * @param {string} str Websocket raw data
+   * @returns {TWPacket[]} TradingView packets
+   */
+  parseWSPacket(str) {
+    return str.replace(/~h~/g, '').split(/~m~[0-9]{1,}~m~/g)
+      .map((p) => {
+        if (!p) return false;
+        try {
+          return JSON.parse(p);
+        } catch (error) {
+          console.warn('Cant parse', p);
+          return false;
+        }
+      })
+      .filter((p) => p);
+  },
+
+  /**
+   * Format websocket packet
+   * @param {TWPacket} packet TradingView packet
+   * @returns {string} Websocket raw data
+   */
+  formatWSPacket(packet) {
+    const msg = typeof packet === 'object'
+      ? JSON.stringify(packet)
+      : packet;
+    return `~m~${msg.length}~m~${msg}`;
+  },
+
+  /**
+   * Parse compressed data
+   * @param {string} data Compressed data
+   * @returns {Promise<{}>} Parsed data
+   */
+  async parseCompressed(data) {
+    const zip = new JSZip();
+    return JSON.parse(
+      await (
+        await zip.loadAsync(data, { base64: true })
+      ).file('').async('text'),
+    );
+  },
+};

package/src/quote/market.js

@@ -0,0 +1,123 @@
+/**
+ * @typedef {'loaded' | 'data' | 'error'} MarketEvent
+ */
+
+/**
+ * @param {import('./session').QuoteSessionBridge} quoteSession
+ */
+module.exports = (quoteSession) => class QuoteMarket {
+  #symbolListeners = quoteSession.symbolListeners;
+
+  #symbol;
+
+  #symbolListenerID = 0;
+
+  #lastData = {};
+
+  #callbacks = {
+    loaded: [],
+    data: [],
+
+    event: [],
+    error: [],
+  };
+
+  /**
+   * @param {MarketEvent} ev Client event
+   * @param {...{}} data Packet data
+   */
+  #handleEvent(ev, ...data) {
+    this.#callbacks[ev].forEach((e) => e(...data));
+    this.#callbacks.event.forEach((e) => e(ev, ...data));
+  }
+
+  #handleError(...msgs) {
+    if (this.#callbacks.error.length === 0) console.error(...msgs);
+    else this.#handleEvent('error', ...msgs);
+  }
+
+  /**
+   * @param {string} symbol Market symbol (like: 'BTCEUR' or 'KRAKEN:BTCEUR')
+   */
+  constructor(symbol) {
+    this.#symbol = symbol;
+
+    if (!this.#symbolListeners[symbol]) {
+      this.#symbolListeners[symbol] = [];
+      quoteSession.send('quote_add_symbols', [
+        quoteSession.sessionID,
+        symbol,
+      ]);
+    }
+    this.#symbolListenerID = this.#symbolListeners[symbol].length;
+
+    this.#symbolListeners[symbol][this.#symbolListenerID] = (packet) => {
+      if (global.TW_DEBUG) console.log('§90§30§105 MARKET §0 DATA', packet);
+
+      if (packet.type === 'qsd' && packet.data[1].s === 'ok') {
+        this.#lastData = {
+          ...this.#lastData,
+          ...packet.data[1].v,
+        };
+        this.#handleEvent('data', this.#lastData);
+        return;
+      }
+
+      if (packet.type === 'quote_completed') {
+        this.#handleEvent('loaded');
+        return;
+      }
+
+      if (packet.type === 'qsd' && packet.data[1].s === 'error') {
+        this.#handleError('Market error', packet.data);
+      }
+    };
+  }
+
+  /**
+   * When quote market is loaded
+   * @param {() => void} cb Callback
+   * @event
+   */
+  onLoaded(cb) {
+    this.#callbacks.loaded.push(cb);
+  }
+
+  /**
+   * When quote data is received
+   * @param {(data: {}) => void} cb Callback
+   * @event
+   */
+  onData(cb) {
+    this.#callbacks.data.push(cb);
+  }
+
+  /**
+   * When quote event happens
+   * @param {(...any) => void} cb Callback
+   * @event
+   */
+  onEvent(cb) {
+    this.#callbacks.event.push(cb);
+  }
+
+  /**
+   * When quote error happens
+   * @param {(...any) => void} cb Callback
+   * @event
+   */
+  onError(cb) {
+    this.#callbacks.error.push(cb);
+  }
+
+  /** Close this listener */
+  close() {
+    if (this.#symbolListeners[this.#symbol].length <= 1) {
+      quoteSession.send('quote_remove_symbols', [
+        quoteSession.sessionID,
+        this.#symbol,
+      ]);
+    }
+    delete this.#symbolListeners[this.#symbol][this.#symbolListenerID];
+  }
+};

package/src/quote/session.js

@@ -0,0 +1,125 @@
+const { genSessionID } = require('../utils');
+
+const quoteMarketConstructor = require('./market');
+
+/** @typedef {Object<string, Function[]>} SymbolListeners */
+
+/**
+ * @typedef {Object} QuoteSessionBridge
+ * @prop {string} sessionID
+ * @prop {SymbolListeners} symbolListeners
+ * @prop {import('../client').SendPacket} send
+*/
+
+/**
+ * @typedef {'base-currency-logoid'
+ * | 'ch' | 'chp' | 'currency-logoid' | 'provider_id'
+ * | 'currency_code' | 'current_session' | 'description'
+ * | 'exchange' | 'format' | 'fractional' | 'is_tradable'
+ * | 'language' | 'local_description' | 'logoid' | 'lp'
+ * | 'lp_time' | 'minmov' | 'minmove2' | 'original_name'
+ * | 'pricescale' | 'pro_name' | 'short_name' | 'type'
+ * | 'update_mode' | 'volume' | 'ask' | 'bid' | 'fundamentals'
+ * | 'high_price' | 'low_price' | 'open_price' | 'prev_close_price'
+ * | 'rch' | 'rchp' | 'rtc' | 'rtc_time' | 'status' | 'industry'
+ * | 'basic_eps_net_income' | 'beta_1_year' | 'market_cap_basic'
+ * | 'earnings_per_share_basic_ttm' | 'price_earnings_ttm'
+ * | 'sector' | 'dividends_yield' | 'timezone' | 'country_code'
+ * } quoteField Quote data field
+ */
+
+/** @param {'all' | 'price'} fieldsType */
+function getQuoteFields(fieldsType) {
+  if (fieldsType === 'price') {
+    return ['lp'];
+  }
+
+  return [
+    'base-currency-logoid', 'ch', 'chp', 'currency-logoid',
+    'currency_code', 'current_session', 'description',
+    'exchange', 'format', 'fractional', 'is_tradable',
+    'language', 'local_description', 'logoid', 'lp',
+    'lp_time', 'minmov', 'minmove2', 'original_name',
+    'pricescale', 'pro_name', 'short_name', 'type',
+    'update_mode', 'volume', 'ask', 'bid', 'fundamentals',
+    'high_price', 'low_price', 'open_price', 'prev_close_price',
+    'rch', 'rchp', 'rtc', 'rtc_time', 'status', 'industry',
+    'basic_eps_net_income', 'beta_1_year', 'market_cap_basic',
+    'earnings_per_share_basic_ttm', 'price_earnings_ttm',
+    'sector', 'dividends_yield', 'timezone', 'country_code',
+    'provider_id',
+  ];
+}
+
+/**
+ * @param {import('../client').ClientBridge} client
+ */
+module.exports = (client) => class QuoteSession {
+  #sessionID = genSessionID('qs');
+
+  /** Parent client */
+  #client = client;
+
+  /** @type {SymbolListeners} */
+  #symbolListeners = {};
+
+  /**
+   * @typedef {Object} quoteSessionOptions Quote Session options
+   * @prop {'all' | 'price'} [fields] Asked quote fields
+   * @prop {quoteField[]} [customFields] List of asked quote fields
+   */
+
+  /**
+   * @param {quoteSessionOptions} options Quote settings options
+   */
+  constructor(options = {}) {
+    this.#client.sessions[this.#sessionID] = {
+      type: 'quote',
+      onData: (packet) => {
+        if (global.TW_DEBUG) console.log('§90§30§102 QUOTE SESSION §0 DATA', packet);
+
+        if (packet.type === 'quote_completed') {
+          const symbol = packet.data[1];
+          if (!this.#symbolListeners[symbol]) {
+            this.#client.send('quote_remove_symbols', [this.#sessionID, symbol]);
+            return;
+          }
+          this.#symbolListeners[symbol].forEach((h) => h(packet));
+        }
+
+        if (packet.type === 'qsd') {
+          const symbol = packet.data[1].n;
+          if (!this.#symbolListeners[symbol]) {
+            this.#client.send('quote_remove_symbols', [this.#sessionID, symbol]);
+            return;
+          }
+          this.#symbolListeners[symbol].forEach((h) => h(packet));
+        }
+      },
+    };
+
+    const fields = (options.customFields && options.customFields.length > 0
+      ? options.customFields
+      : getQuoteFields(options.fields)
+    );
+
+    this.#client.send('quote_create_session', [this.#sessionID]);
+    this.#client.send('quote_set_fields', [this.#sessionID, ...fields]);
+  }
+
+  /** @type {QuoteSessionBridge} */
+  #quoteSession = {
+    sessionID: this.#sessionID,
+    symbolListeners: this.#symbolListeners,
+    send: (t, p) => this.#client.send(t, p),
+  };
+
+  /** @constructor */
+  Market = quoteMarketConstructor(this.#quoteSession);
+
+  /** Delete the quote session */
+  delete() {
+    this.#client.send('quote_delete_session', [this.#sessionID]);
+    delete this.#client.sessions[this.#sessionID];
+  }
+};

package/src/request.js

@@ -0,0 +1,37 @@
+const https = require('https');
+
+/**
+ * @param {https.RequestOptions} options HTTPS Request options
+ * @param {boolean} [raw] Get raw or JSON data
+ * @param {string} [content] Request body content
+ * @returns {Promise<string | object | array>} Result
+ */
+function request(options = {}, raw = false, content = '') {
+  return new Promise((cb, err) => {
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', (c) => { data += c; });
+      res.on('end', () => {
+        if (raw) {
+          cb(data);
+          return;
+        }
+
+        try {
+          data = JSON.parse(data);
+        } catch (error) {
+          console.log(data);
+          err(new Error('Can\'t parse server response'));
+          return;
+        }
+
+        cb(data);
+      });
+    });
+
+    req.on('error', err);
+    req.end(content);
+  });
+}
+
+module.exports = request;

package/src/types.js

@@ -0,0 +1,32 @@
+/**
+ * @typedef {string} MarketSymbol Market symbol (like: 'BTCEUR' or 'KRAKEN:BTCEUR')
+ *
+ * @typedef {'Etc/UTC' | 'exchange'
+ * | 'Pacific/Honolulu' | 'America/Juneau' | 'America/Los_Angeles'
+ * | 'America/Phoenix' | 'America/Vancouver' | 'US/Mountain'
+ * | 'America/El_Salvador' | 'America/Bogota' | 'America/Chicago'
+ * | 'America/Lima' | 'America/Mexico_City' | 'America/Caracas'
+ * | 'America/New_York' | 'America/Toronto' | 'America/Argentina/Buenos_Aires'
+ * | 'America/Santiago' | 'America/Sao_Paulo' | 'Atlantic/Reykjavik'
+ * | 'Europe/Dublin' | 'Africa/Lagos' | 'Europe/Lisbon' | 'Europe/London'
+ * | 'Europe/Amsterdam' | 'Europe/Belgrade' | 'Europe/Berlin'
+ * | 'Europe/Brussels' | 'Europe/Copenhagen' | 'Africa/Johannesburg'
+ * | 'Africa/Cairo' | 'Europe/Luxembourg' | 'Europe/Madrid' | 'Europe/Malta'
+ * | 'Europe/Oslo' | 'Europe/Paris' | 'Europe/Rome' | 'Europe/Stockholm'
+ * | 'Europe/Warsaw' | 'Europe/Zurich' | 'Europe/Athens' | 'Asia/Bahrain'
+ * | 'Europe/Helsinki' | 'Europe/Istanbul' | 'Asia/Jerusalem' | 'Asia/Kuwait'
+ * | 'Europe/Moscow' | 'Asia/Qatar' | 'Europe/Riga' | 'Asia/Riyadh'
+ * | 'Europe/Tallinn' | 'Europe/Vilnius' | 'Asia/Tehran' | 'Asia/Dubai'
+ * | 'Asia/Muscat' | 'Asia/Ashkhabad' | 'Asia/Kolkata' | 'Asia/Almaty'
+ * | 'Asia/Bangkok' | 'Asia/Jakarta' | 'Asia/Ho_Chi_Minh' | 'Asia/Chongqing'
+ * | 'Asia/Hong_Kong' | 'Australia/Perth' | 'Asia/Shanghai' | 'Asia/Singapore'
+ * | 'Asia/Taipei' | 'Asia/Seoul' | 'Asia/Tokyo' | 'Australia/Brisbane'
+ * | 'Australia/Adelaide' | 'Australia/Sydney' | 'Pacific/Norfolk'
+ * | 'Pacific/Auckland' | 'Pacific/Fakaofo' | 'Pacific/Chatham'} Timezone (Chart) timezone
+ *
+ * @typedef {'1' | '3' | '5' | '15' | '30'
+ * | '45' | '60' | '120' | '180' | '240'
+ * | '1D' | '1W' | '1M' | 'D' | 'W' | 'M'} TimeFrame
+ */
+
+module.exports = {};

package/src/utils.js

@@ -0,0 +1,8 @@
+module.exports = {
+  genSessionID(type = 'xs') {
+    let r = '';
+    const c = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    for (let i = 0; i < 12; i += 1) r += c.charAt(Math.floor(Math.random() * c.length));
+    return `${type}_${r}`;
+  },
+};