@orderly.network/ui-tradingview 2.8.3 → 2.8.4-alpha.0

package/dist/index.js

@@ -1016,21 +1016,32 @@ function getErrorMessage(error) {
 }
 
 // src/tradingviewAdapter/datafeed/history-provider.ts
-var HistoryProvider = class {
+var HISTORY_PATH = "tv/history";
+var KLINE_HISTORY_PATH = "v1/tv/kline_history";
+var _HistoryProvider = class _HistoryProvider {
   constructor(datafeedUrl, requester, limitedServerResponse) {
+    this._klinePreference = /* @__PURE__ */ new Map();
     this._datafeedUrl = datafeedUrl;
     this._requester = requester;
     this._limitedServerResponse = limitedServerResponse;
   }
-  getBars(symbolInfo, resolution, periodParams) {
+  /**
+   * Build request parameters for history API calls
+   * @param symbolInfo - Symbol information
+   * @param resolution - Resolution string
+   * @param periodParams - Period parameters with optional countback
+   * @returns Request parameters object
+   */
+  _buildRequestParams(symbolInfo, resolution, periodParams) {
     const requestParams = {
       symbol: symbolInfo.ticker || "",
       resolution,
       from: periodParams.from,
       to: periodParams.to
     };
+    const countBack = Math.min(periodParams.countBack ?? 0, 1e3);
     if (periodParams.countBack !== void 0) {
-      requestParams.countback = periodParams.countBack;
+      requestParams.countback = countBack;
     }
     if (symbolInfo.currency_code !== void 0) {
       requestParams.currencyCode = symbolInfo.currency_code;
@@ -1038,28 +1049,127 @@ var HistoryProvider = class {
     if (symbolInfo.unit_id !== void 0) {
       requestParams.unitId = symbolInfo.unit_id;
     }
+    return requestParams;
+  }
+  getBars(symbolInfo, resolution, periodParams) {
+    const requestParams = this._buildRequestParams(
+      symbolInfo,
+      resolution,
+      periodParams
+    );
+    const preferenceKey = this._getPreferenceKey(symbolInfo, resolution);
+    const prefersKline = this._klinePreference.get(preferenceKey) === true;
+    const countBack = Math.min(periodParams.countBack ?? 0, 1e3);
     return new Promise(
       async (resolve, reject) => {
         try {
-          const initialResponse = await this._requester.sendRequest(
-            this._datafeedUrl,
-            "history",
-            requestParams
-          );
-          const result = this._processHistoryResponse(initialResponse);
-          if (this._limitedServerResponse) {
-            await this._processTruncatedResponse(result, requestParams);
+          let result;
+          let usedHistoryResult = false;
+          if (prefersKline) {
+            result = await this._requestKlineHistory(
+              this._buildKlineParams(requestParams, countBack)
+            );
+          } else {
+            const initialResponse = await this._requestHistory(requestParams);
+            result = this._processHistoryResponse(initialResponse);
+            usedHistoryResult = true;
+            const needsFallback = this._shouldFallbackToKline(
+              initialResponse,
+              countBack
+            );
+            if (needsFallback) {
+              const klineResult = await this._tryKlineFallback(
+                requestParams,
+                countBack
+              );
+              if (klineResult !== null) {
+                result = klineResult;
+                usedHistoryResult = false;
+                this._klinePreference.set(preferenceKey, true);
+              } else {
+                this._klinePreference.set(preferenceKey, false);
+              }
+            } else {
+              this._klinePreference.set(preferenceKey, false);
+            }
+          }
+          if (usedHistoryResult && this._limitedServerResponse) {
+            await this._processTruncatedResponse(result, { ...requestParams });
           }
           resolve(result);
         } catch (e) {
-          if (e instanceof Error || typeof e === "string") {
-            const reasonString = getErrorMessage(e);
-            reject(reasonString);
-          }
+          const error = e instanceof Error ? e : typeof e === "string" ? e : void 0;
+          const reasonString = getErrorMessage(error);
+          reject(reasonString || "Error");
         }
       }
     );
   }
+  /**
+   * Request kline history using KLINE_HISTORY_PATH endpoint
+   * Handles rate limiting (429 errors) by waiting and retrying
+   * @param requestParams - Request parameters
+   * @param retryCount - Current retry attempt (internal use)
+   * @returns Processed history response
+   */
+  async _requestKlineHistory(requestParams, retryCount = 0) {
+    const maxRetries = 5;
+    const baseRetryDelay = 2500;
+    const maxRetryDelay = 1e4;
+    const params = {
+      ...requestParams,
+      resolution: this._mapToKlineHistoryResolution(
+        requestParams.resolution
+      )
+    };
+    const urlPath = this._buildUrlWithParams(KLINE_HISTORY_PATH, params);
+    const options = { credentials: "same-origin" };
+    const requesterWithHeaders = this._requester;
+    if (requesterWithHeaders._headers !== void 0) {
+      options.headers = requesterWithHeaders._headers;
+    }
+    let response;
+    try {
+      response = await fetch(`${this._datafeedUrl}/${urlPath}`, options);
+    } catch (error) {
+      throw error;
+    }
+    if (response.status === 429) {
+      if (retryCount >= maxRetries) {
+        throw new Error(
+          `Rate limit exceeded: Maximum retry attempts (${maxRetries}) reached`
+        );
+      }
+      const retryDelay = Math.min(
+        baseRetryDelay * Math.pow(2, retryCount),
+        maxRetryDelay
+      );
+      const retryAfter = response.headers.get("Retry-After");
+      const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : retryDelay;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return this._requestKlineHistory(requestParams, retryCount + 1);
+    }
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({
+        message: response.statusText
+      }));
+      throw new Error(
+        errorData.message || errorData.errmsg || response.statusText
+      );
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new Error("Failed to parse response JSON");
+    }
+    return this._processHistoryResponse(data);
+  }
+  /**
+   * Process truncated response by making follow-up requests if needed
+   * @param result - Current result with bars
+   * @param requestParams - Request parameters
+   */
   async _processTruncatedResponse(result, requestParams) {
     let lastResultLength = result.bars.length;
     try {
@@ -1076,7 +1186,7 @@ var HistoryProvider = class {
         }
         const followupResponse = await this._requester.sendRequest(
           this._datafeedUrl,
-          "history",
+          HISTORY_PATH,
           requestParams
         );
         const followupResult = this._processHistoryResponse(followupResponse);
@@ -1143,7 +1253,106 @@ var HistoryProvider = class {
       meta
     };
   }
+  /**
+   * Maps TradingView resolution format to Kline History API resolution format
+   * @param resolution - TradingView resolution string (e.g., "1", "60", "1D")
+   * @returns Kline History API resolution string (e.g., "1m", "1h", "1d")
+   */
+  _mapToKlineHistoryResolution(resolution) {
+    return _HistoryProvider._RESOLUTION_MAP.get(resolution) ?? resolution;
+  }
+  _buildUrlWithParams(path, params) {
+    if (!params || Object.keys(params).length === 0) {
+      return path;
+    }
+    const searchParams = new URLSearchParams();
+    Object.keys(params).forEach((key) => {
+      const value = params[key];
+      if (Array.isArray(value)) {
+        value.forEach((item) => searchParams.append(key, item));
+      } else {
+        searchParams.append(key, value.toString());
+      }
+    });
+    const queryString = searchParams.toString();
+    return queryString ? `${path}?${queryString}` : path;
+  }
+  _getPreferenceKey(symbolInfo, resolution) {
+    return `${symbolInfo.ticker ?? ""}|${resolution}`;
+  }
+  _requestHistory(requestParams) {
+    return this._requester.sendRequest(
+      this._datafeedUrl,
+      HISTORY_PATH,
+      requestParams
+    );
+  }
+  _buildKlineParams(requestParams, countBack) {
+    const params = {
+      ...requestParams
+    };
+    delete params.countback;
+    if (countBack > 0) {
+      params.limit = countBack;
+    } else {
+      delete params.limit;
+    }
+    return params;
+  }
+  async _tryKlineFallback(requestParams, countBack) {
+    try {
+      const result = await this._requestKlineHistory(
+        this._buildKlineParams(requestParams, countBack)
+      );
+      return result.bars.length > 0 ? result : null;
+    } catch {
+      return null;
+    }
+  }
+  _shouldFallbackToKline(response, expectedCount) {
+    if (response.s !== "ok") {
+      return false;
+    }
+    const barsCount = response.t.length;
+    if (expectedCount > 0 && barsCount < expectedCount) {
+      return true;
+    }
+    if (this._limitedServerResponse && this._limitedServerResponse.maxResponseLength > 0 && barsCount >= this._limitedServerResponse.maxResponseLength) {
+      return true;
+    }
+    return false;
+  }
 };
+/**
+ * Static mapping table for resolution conversion
+ * Maps TradingView resolution format to Kline History API resolution format
+ * Key: TradingView resolution, Value: Kline History API resolution
+ */
+_HistoryProvider._RESOLUTION_MAP = /* @__PURE__ */ new Map([
+  ["1", "1m"],
+  // 1 minute
+  ["3", "3m"],
+  // 3 minutes
+  ["5", "5m"],
+  // 5 minutes
+  ["15", "15m"],
+  // 15 minutes
+  ["30", "30m"],
+  // 30 minutes
+  ["60", "1h"],
+  // 1 hour
+  ["240", "4h"],
+  // 4 hours
+  ["720", "12h"],
+  // 12 hours
+  ["1D", "1d"],
+  // 1 day
+  ["1W", "1w"],
+  // 1 week
+  ["1M", "1mon"]
+  // 1 month (mapped to 1m)
+]);
+var HistoryProvider = _HistoryProvider;
 
 // src/tradingviewAdapter/datafeed/requester.ts
 var Requester = class {
@@ -1168,7 +1377,15 @@ var Requester = class {
     if (this._headers !== void 0) {
       options.headers = this._headers;
     }
-    return fetch(`${datafeedUrl}/${urlPath}`, options).then((response) => response.text()).then((responseTest) => JSON.parse(responseTest));
+    return fetch(`${datafeedUrl}/${urlPath}`, options).then((response) => response.json()).then((data) => {
+      if (typeof data.success === "undefined") {
+        return data;
+      }
+      if (!data.success) {
+        throw new Error(data.message);
+      }
+      return data;
+    });
   }
 };
 
@@ -1267,9 +1484,13 @@ var SymbolsStorage = class {
   _requestExchangeData(exchange) {
     return new Promise(
       (resolve, reject) => {
-        this._requester.sendRequest(this._datafeedUrl, "symbol_info", {
-          group: exchange
-        }).then((response) => {
+        this._requester.sendRequest(
+          this._datafeedUrl,
+          "tv/symbol_info",
+          {
+            group: exchange
+          }
+        ).then((response) => {
           try {
             this._onExchangeDataReceived(exchange, response);
           } catch (error) {
@@ -1362,11 +1583,13 @@ var SymbolsStorage = class {
             extractField(data, "intraday-multipliers", symbolIndex, true),
             ["1", "5", "15", "30", "60"]
           ),
-          has_weekly_and_monthly: extractField(
-            data,
-            "has-weekly-and-monthly",
-            symbolIndex
-          ),
+          // daily_multipliers:["1"],
+          // has_weekly_and_monthly: extractField(
+          //   data,
+          //   "has-weekly-and-monthly",
+          //   symbolIndex,
+          // ),
+          has_weekly_and_monthly: true,
           has_empty_bars: extractField(data, "has-empty-bars", symbolIndex),
           volume_precision: definedValueOrDefault(
             extractField(data, "volume-precision", symbolIndex),
@@ -1400,6 +1623,7 @@ var AbstractDatafeed = class {
   constructor(datafeedURL) {
     this._configuration = defaultConfiguration();
     this._symbolsStorage = null;
+    this._historyCursor = null;
     this._datafeedURL = datafeedURL;
     this._requester = new Requester();
     this._historyProvider = new HistoryProvider(datafeedURL, this._requester);
@@ -1413,9 +1637,52 @@ var AbstractDatafeed = class {
     );
   }
   getBars(symbolInfo, resolution, periodParams, onResult, onError) {
-    this._historyProvider.getBars(symbolInfo, resolution, periodParams).then((result) => {
-      onResult(result.bars, result.meta);
-    }).catch(onError);
+    const { to, firstDataRequest } = periodParams;
+    if (firstDataRequest || this._historyCursor === null) {
+      this._historyCursor = to;
+    }
+    const resolutionInSeconds = this._resolutionToSeconds(resolution);
+    const cursor = this._historyCursor ?? to;
+    const maxBarsPerRequest = 1e3;
+    const shouldUseOriginalRange = resolution.toLowerCase?.() === "1m" && periodParams.from !== void 0;
+    const barsToLoad = shouldUseOriginalRange ? periodParams.countBack ?? maxBarsPerRequest : maxBarsPerRequest;
+    const requestTo = shouldUseOriginalRange ? periodParams.to ?? to : cursor;
+    const requestFrom = shouldUseOriginalRange ? periodParams.from : Math.max(requestTo - resolutionInSeconds * barsToLoad, 0);
+    this._historyProvider.getBars(symbolInfo, resolution, {
+      ...periodParams,
+      countBack: barsToLoad,
+      from: requestFrom,
+      to: requestTo
+    }).then(
+      (result) => {
+        if (result.bars.length > 0) {
+          this._historyCursor = Math.floor(result.bars[0].time / 1e3) - 1;
+        }
+        onResult(result.bars, result.meta);
+      },
+      (error) => {
+        onError(error);
+      }
+    ).catch((error) => {
+      onError(error);
+    });
+  }
+  _resolutionToSeconds(resolution) {
+    switch (resolution) {
+      case "1D":
+        return 86400;
+      case "3D":
+        return 86400 * 3;
+      case "1W":
+        return 86400 * 7;
+      case "1M":
+        return 86400 * 30;
+    }
+    const res = parseInt(resolution);
+    if (!isNaN(res)) {
+      return res * 60;
+    }
+    return 60;
   }
   onReady(callback) {
     this._configurationReadyPromise.then(() => {
@@ -1451,7 +1718,7 @@ var AbstractDatafeed = class {
   getServerTime() {
   }
   _requestConfiguration() {
-    return this._send("config").catch(
+    return this._send("tv/config").catch(
       (reason) => {
         logMessage(
           `Datafeed: Cannot get datafeed configuration - use default, error=${getErrorMessage(
@@ -1734,7 +2001,7 @@ var getAutoIncrementId = /* @__PURE__ */ (() => {
 })();
 var Datafeed = class extends AbstractDatafeed {
   constructor(apiUrl, ws) {
-    const datafeedURL = `${apiUrl}/tv`;
+    const datafeedURL = `${apiUrl}`;
     super(datafeedURL);
     this.bbosMap = /* @__PURE__ */ new Map();
     this.tickersMap = /* @__PURE__ */ new Map();
@@ -3396,6 +3663,11 @@ var Widget = class {
     } catch (e) {
     }
   }
+  setResolution(resolution) {
+    if (this._instance) {
+      this._instance.activeChart().setResolution(resolution);
+    }
+  }
   executeActionById(actionId) {
     try {
       this._instance?.onChartReady(() => {
@@ -3480,7 +3752,7 @@ var Widget = class {
           "30",
           "60",
           "240",
-          "1D",
+          "1d",
           "1W",
           "1M"
         ],
@@ -3690,7 +3962,7 @@ function useTradingviewScript(props) {
     }
     localStorage.setItem(TradingViewSDKLocalstorageKey.interval, newInterval);
     setInterval(newInterval);
-    chart.current?.setSymbol(symbol ?? "", newInterval);
+    chart.current?.setResolution(newInterval);
   };
   const changeLineType = (newLineType) => {
     if (!chart.current) {