@forgecharts/sdk 1.5.68 → 1.5.70

package/dist/internal.js

@@ -100,6 +100,36 @@ function isGLBXDailyBreak(nowMs = Date.now()) {
   return weekday === "Mon" || weekday === "Tue" || weekday === "Wed" || weekday === "Thu";
 }
 
+// src/core/cursorTime.ts
+function cursorBucketTime(bars, transform, interval, x) {
+  const raw = transform.xToTime(x);
+  const tfSec = parseTfSeconds(interval) ?? 0;
+  const floored = tfSec > 0 ? Math.floor(raw / tfSec) * tfSec : raw;
+  if (!bars || bars.length === 0) return floored;
+  let lo = 0, hi = bars.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (bars[mid].time < raw) lo = mid + 1;
+    else hi = mid;
+  }
+  let nearest = lo;
+  let best = Math.abs(transform.timeToX(bars[lo].time) - x);
+  for (const i of [lo - 1, lo + 1]) {
+    if (i < 0 || i >= bars.length) continue;
+    const d = Math.abs(transform.timeToX(bars[i].time) - x);
+    if (d < best) {
+      best = d;
+      nearest = i;
+    }
+  }
+  const first = bars[0].time;
+  const last = bars[bars.length - 1].time;
+  const halfCol = bars.length > 1 ? Math.abs(transform.timeToX(bars[1].time) - transform.timeToX(first)) / 2 : Infinity;
+  const edgeX = raw > last ? transform.timeToX(last) : raw < first ? transform.timeToX(first) : null;
+  if (edgeX !== null && Math.abs(x - edgeX) > halfCol) return floored;
+  return bars[nearest].time;
+}
+
 // src/core/CanvasLayer.ts
 var CanvasLayer = class {
   canvas;
@@ -4792,10 +4822,7 @@ var Chart = class {
         onCrosshairMove: (x, y) => {
           if (!this._crosshairEnabled) return;
           if (this._magnetMode === "off") {
-            const tfSec = _tfToSeconds(this._interval);
-            const rawTime = this._transform.xToTime(x);
-            const flooredTime = Math.floor(rawTime / tfSec) * tfSec;
-            this._crosshair.update(x, y, flooredTime);
+            this._crosshair.update(x, y, this._cursorBucketTime(x));
           } else {
             const snap = this.snapXToBar(x);
             const sy = this._magnetMode === "snap-xy" ? snap.closeY ?? y : y;
@@ -4836,7 +4863,8 @@ var Chart = class {
         },
         onDrawPointerMove: (x, y) => {
           this._drawingCursorPt = {
-            time: this._transform.xToTime(x),
+            // Bucket time, not raw: the label and the stored anchor agree.
+            time: this._cursorBucketTime(x),
             price: this._transform.yToPrice(y)
           };
           this._dirty = true;
@@ -5109,9 +5137,19 @@ var Chart = class {
         closeY: this._transform.priceToY(bar.close)
       };
     }
-    const tfSec = _tfToSeconds(this._interval);
-    const rawTime = this._transform.xToTime(x);
-    return { x, time: Math.floor(rawTime / tfSec) * tfSec };
+    return { x, time: this._cursorBucketTime(x) };
+  }
+  /** Bucket time for a cursor x — see core/cursorTime.ts for the rule. */
+  _cursorBucketTime(x) {
+    let bars = null;
+    for (const s of this._series) {
+      const data = s.data();
+      if (data.length > 0) {
+        bars = data;
+        break;
+      }
+    }
+    return cursorBucketTime(bars, this._transform, this._interval, x);
   }
   _computeViewport() {
     return {
@@ -5588,7 +5626,7 @@ var Chart = class {
     const MAGNET_PX = 15;
     const t = this._transform;
     const price = t.yToPrice(y);
-    const time = t.xToTime(x);
+    const time = this._cursorBucketTime(x);
     if (this._magnetMode === "off") return { time, price };
     let bestBar = null;
     let bestDist = SNAP_PX;
@@ -6297,7 +6335,16 @@ var PixiCrosshairRenderer = class {
   interval = "1h";
   /** IANA timezone for the time label. Falls back to UTC. */
   timezone = "UTC";
-  update(x, y) {
+  /**
+   * The time the chart computed for this cursor position — nearest bar, else
+   * floored to the timeframe grid. This renderer must never derive its own:
+   * it once did (raw xToTime), and every pointer style's time label showed
+   * interpolated minute noise (10:02 on an hourly chart) on any timeframe
+   * wider than the interpolation error.
+   */
+  _snapTime = null;
+  update(x, y, snapTime) {
+    this._snapTime = snapTime ?? null;
     this._x = x;
     this._y = y;
   }
@@ -6339,7 +6386,7 @@ var PixiCrosshairRenderer = class {
     this._priceLabel.text = priceText;
     this._priceLabel.x = pw + 4;
     this._priceLabel.y = y - this._priceLabel.height / 2;
-    const time = transform.xToTime(x);
+    const time = this._snapTime ?? transform.xToTime(x);
     const timeText = this._formatTime(time);
     const tlw = DAILY_INTERVALS.has(this.interval) ? 120 : 170;
     const tlh = tsh - 4;
@@ -8736,11 +8783,11 @@ var PixiChart = class {
         onCrosshairMove: (x, y) => {
           if (!this._crosshairEnabled) return;
           if (this._magnetMode === "off") {
-            this._crosshairRenderer.update(x, y);
+            this._crosshairRenderer.update(x, y, this._cursorBucketTime(x));
           } else {
             const snap = this.snapXToBar(x);
             const sy = this._magnetMode === "snap-xy" ? snap.closeY ?? y : y;
-            this._crosshairRenderer.update(snap.x, sy);
+            this._crosshairRenderer.update(snap.x, sy, snap.time);
           }
           const ah = this._interaction.axisHover;
           if (ah !== this._lastAxisHover) {
@@ -8786,7 +8833,9 @@ var PixiChart = class {
         },
         onDrawPointerMove: (x, y) => {
           this._drawingCursorPt = {
-            time: this._transform.xToTime(x),
+            // Bucket time, not raw: what the crosshair label shows is what a
+            // drawing placed here will store.
+            time: this._cursorBucketTime(x),
             price: this._transform.yToPrice(y)
           };
           this._layers.dirty.mark(3 /* Drawing */);
@@ -9353,6 +9402,18 @@ var PixiChart = class {
   setNativeCursorHidden(hidden) {
     this._interaction.setHideCursor(hidden);
   }
+  /** Bucket time for a cursor x — see core/cursorTime.ts for the rule. */
+  _cursorBucketTime(x) {
+    let bars = null;
+    for (const s of this._series) {
+      const data = s.data();
+      if (data.length > 0) {
+        bars = data;
+        break;
+      }
+    }
+    return cursorBucketTime(bars, this._transform, this._interval, x);
+  }
   snapXToBar(x) {
     const SNAP_PX = 20;
     let bars = null;
@@ -9396,7 +9457,7 @@ var PixiChart = class {
         closeY: t.priceToY(bar.close)
       };
     }
-    return { x, time: t.xToTime(x) };
+    return { x, time: this._cursorBucketTime(x) };
   }
   setIndicatorsVisible(v) {
     this._indicatorsVisible = v;
@@ -10369,14 +10430,13 @@ function toOHLCV(bar) {
 function _historyWindow(tf) {
   return 500 * (parseTfSeconds(tf) ?? 3600);
 }
-var BATCH_SUPPRESSION_MS = 1e4;
+var REFETCH_ON_DOUBT_DELAY_MS = 3e3;
 function tfSeconds(tf) {
   const m = /^(\d+)\s*(s|m|h|D|W|M)$/.exec(tf);
   if (!m) return 0;
   const mult = { s: 1, m: 60, h: 3600, D: 86400, W: 604800, M: 2592e3 }[m[2]];
   return parseInt(m[1], 10) * mult;
 }
-var LIVE_GAP_REPAIR_DELAY_MS = 3e3;
 function _pageSize(tf) {
   return 500 * (parseTfSeconds(tf) ?? 3600);
 }
@@ -10412,9 +10472,11 @@ var DatafeedConnector = class {
    */
   _emptyPageStreak = 0;
   /**
-   * Safety timer: clears `batchPending` if bar_batch never arrives, so live
-   * ticks resume. It no longer gates the chart reveal.
-   * Prevents the chart from staying blank when a provider doesn't fire onHistoricalReady.
+   * Nothing arms this any more — live-tick suppression went with the rest of
+   * the client-side stitching once history became authoritative through the
+   * forming bar. Kept (with its clear helper) because reconnect paths call
+   * the helper and older subclasses may too; clearing a never-set timer is
+   * free. Remove both in the next breaking cleanup.
    */
   _batchSafetyTimer = null;
   constructor(datafeed, series, callbacks) {
@@ -10438,12 +10500,10 @@ var DatafeedConnector = class {
     const to = Math.floor(Date.now() / 1e3);
     const from = to - _historyWindow(timeframe);
     this._clearBatchTimer();
-    let batchPending = false;
     const engine = new CandleEngine({
       // Every live tick mutates the engine's bar array and the chart series.
       onBarUpdated: (bar) => {
         if (this._activeUID !== uid) return;
-        if (batchPending) return;
         const ohlcv = toOHLCV(bar);
         this._series.update(ohlcv);
         this._cb.onUpdate?.(ohlcv);
@@ -10497,54 +10557,33 @@ var DatafeedConnector = class {
       }).catch(() => {
       });
       if (this._activeUID !== uid) return;
-      if (lastBarTime != null) {
-        batchPending = true;
-        this._batchSafetyTimer = setTimeout(() => {
-          batchPending = false;
-          this._batchSafetyTimer = null;
-        }, BATCH_SUPPRESSION_MS);
-      }
       const tfSec = tfSeconds(timeframe);
       let lastSeenBarTime = lastBarTime ?? 0;
-      let repairTimer = null;
-      const REPAIR_RETRY_MS = 6e4;
-      const REPAIR_MAX_ATTEMPTS = 15;
-      let repairAttempts = 0;
-      const repairGap = (fromTime, toTime) => {
-        if (repairTimer) clearTimeout(repairTimer);
-        repairTimer = setTimeout(() => {
-          repairTimer = null;
+      let refetchTimer = null;
+      const refetchOnDoubt = (fromTime, toTime) => {
+        if (refetchTimer) clearTimeout(refetchTimer);
+        refetchTimer = setTimeout(() => {
+          refetchTimer = null;
           if (this._activeUID !== uid || this._destroyed) return;
           void this._datafeed.getHistoricalBars(symbol, timeframe, fromTime, toTime).then(({ bars: filled }) => {
-            if (this._activeUID !== uid) return;
-            if (filled.length > 0) engine.backfillGap(filled);
-            const newest = filled.length > 0 ? filled[filled.length - 1].time : 0;
-            const covered = tfSec > 0 && newest >= toTime - 2 * tfSec;
-            if (!covered && repairAttempts < REPAIR_MAX_ATTEMPTS) {
-              repairAttempts += 1;
-              if (repairTimer) clearTimeout(repairTimer);
-              repairTimer = setTimeout(() => {
-                repairTimer = null;
-                repairGap(fromTime, toTime);
-              }, REPAIR_RETRY_MS);
-            } else if (covered) {
-              repairAttempts = 0;
-            }
+            if (this._activeUID !== uid || filled.length === 0) return;
+            engine.backfillGap(filled);
+            const newest = filled[filled.length - 1].time;
+            if (newest > lastSeenBarTime) lastSeenBarTime = newest;
           }).catch(() => {
           });
-        }, LIVE_GAP_REPAIR_DELAY_MS);
+        }, REFETCH_ON_DOUBT_DELAY_MS);
       };
       this._datafeed.subscribeBars(symbol, timeframe, (bar) => {
         if (this._activeUID !== uid) return;
         const t = bar.time;
         if (tfSec > 0 && lastSeenBarTime > 0 && t > lastSeenBarTime + tfSec) {
-          repairGap(lastSeenBarTime, t);
+          refetchOnDoubt(lastSeenBarTime, t);
         }
         if (t > lastSeenBarTime) lastSeenBarTime = t;
         engine.applyLiveUpdate(bar);
       }, uid, lastBarTime, (bars) => {
         this._clearBatchTimer();
-        batchPending = false;
         if (this._activeUID === uid) {
           engine.backfillGap(bars);
           const newest = bars.length > 0 ? bars[bars.length - 1].time : 0;
@@ -10552,16 +10591,7 @@ var DatafeedConnector = class {
         }
         fireLoaded();
       });
-      if (result.filling) {
-        setTimeout(() => {
-          if (this._activeUID !== uid || this._destroyed) return;
-          void this._datafeed.getHistoricalBars(symbol, timeframe, from, to).then(({ bars: refetchedBars }) => {
-            if (this._activeUID !== uid) return;
-            engine.backfillGap(refetchedBars);
-          }).catch(() => {
-          });
-        }, 8e3);
-      }
+      if (result.filling) refetchOnDoubt(from, to);
     }).catch((err) => {
       if (this._activeUID !== uid) return;
       const message = err instanceof Error ? err.message : String(err);
@@ -25585,7 +25615,7 @@ var demonstrationTool = {
 };
 
 // src/version.ts
-var FORGECHARTS_VERSION = "1.5.68" ;
+var FORGECHARTS_VERSION = "1.5.70" ;
 
 // src/compatibility.ts
 var MIN_KIT_API = 1;