@pipsend/charts 2.3.10 → 2.3.12

package/dist/pipsend-charts.development.mjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.10
+ * Pipsend Charts v2.3.12
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -19309,6 +19309,12 @@ function setVolumeProfileData(indicator, data) {
 }
 
 const CLICK_TOLERANCE_PX = 4;
+/**
+ * A fingertip never holds still: every tap travels further than a pointer
+ * does, and judging it by the mouse's few pixels turned each one into a tiny
+ * drag, so the tap never arrived.
+ */
+const TOUCH_CLICK_TOLERANCE_PX = 12;
 /**
  * Single input owner for every trading line on a chart.
  *
@@ -19327,6 +19333,8 @@ class TradingLineController {
         this._private__pointerId = null;
         this._private__pressOrigin = null;
         this._private__pressedLine = null;
+        /** Whether the gesture in flight came from a finger rather than a mouse. */
+        this._private__pressWasTouch = false;
         /** Distance from the pointer to the dragged line when the press landed. */
         this._private__grabOffset = 0;
         /** Latest pointer position in pane coordinates, or null when off the panes. */
@@ -19391,8 +19399,18 @@ class TradingLineController {
         this._private__applyCursor();
     }
     _private__onPointerDown(event) {
-        const line = this._private__hoveredId === null ? null : this._private__lines.get(this._private__hoveredId) ?? null;
+        // Hover belongs to the mouse. Touch leaves whatever the last press marked
+        // still marked, so trusting it here grabbed that line again wherever the
+        // next tap landed: every press resolves itself instead.
+        this._private__pressWasTouch = event.pointerType !== 'mouse';
+        let line = this._private__pressWasTouch || this._private__hoveredId === null
+            ? null
+            : this._private__lines.get(this._private__hoveredId) ?? null;
+        if (line === null) {
+            line = this._private__resolveHitAt(event);
+        }
         if (!line) {
+            this._private__clearTouchHover();
             return;
         }
         this._private__pressOrigin = { _internal_x: event.clientX, _internal_y: event.clientY };
@@ -19431,14 +19449,16 @@ class TradingLineController {
     }
     _private__onPointerUp(event) {
         const dragged = this._private__dragging;
+        const wasTouch = this._private__pressWasTouch;
         const pressed = this._private__pressedLine;
         const origin = this._private__pressOrigin;
         this._private__releasePointer();
         this._private__pressedLine = null;
         this._private__pressOrigin = null;
+        const tolerance = wasTouch ? TOUCH_CLICK_TOLERANCE_PX : CLICK_TOLERANCE_PX;
         const moved = origin !== null &&
-            (Math.abs(event.clientX - origin._internal_x) > CLICK_TOLERANCE_PX ||
-                Math.abs(event.clientY - origin._internal_y) > CLICK_TOLERANCE_PX);
+            (Math.abs(event.clientX - origin._internal_x) > tolerance ||
+                Math.abs(event.clientY - origin._internal_y) > tolerance);
         if (dragged !== null) {
             this._private__dragging = null;
             this._private__grabOffset = 0;
@@ -19452,12 +19472,24 @@ class TradingLineController {
                     dragged.click();
                 }
             }
+            this._private__clearTouchHover(wasTouch);
             this._private__applyCursor();
             return;
         }
         if (pressed !== null && !moved && pressed.isClickable()) {
             pressed.click();
         }
+        this._private__clearTouchHover(wasTouch);
+    }
+    /** A finger leaves nothing hovered behind it, the way lifting a mouse does. */
+    _private__clearTouchHover(wasTouch = this._private__pressWasTouch) {
+        if (!wasTouch || this._private__hoveredId === null) {
+            return;
+        }
+        const line = this._private__lines.get(this._private__hoveredId) ?? null;
+        this._private__setHovered(null);
+        this._private__setHoveredPart(line, null);
+        this._private__applyCursor();
     }
     /**
      * Abort an in-flight gesture: the line goes back to where it was and no
@@ -19503,9 +19535,38 @@ class TradingLineController {
         return paneY === null ? null : line.priceAt(paneY - this._private__grabOffset);
     }
     /** The pointer's position inside the line's pane, in pane coordinates. */
-    _private__paneY(line, event) {
+    /**
+     * The hovered id comes from the crosshair, which touch never moves before it
+     * presses, so the press resolves the target itself.
+     */
+    _private__resolveHitAt(event) {
+        for (const line of this._private__lines.values()) {
+            if (!line.hitTestAt) {
+                continue;
+            }
+            const paneElement = this._private__paneElementOf(line);
+            if (paneElement === null) {
+                continue;
+            }
+            const rect = paneElement.getBoundingClientRect();
+            // A fingertip is far coarser than a pointer, so its targets are widened.
+            const slop = event.pointerType === 'mouse' ? 0 : 12 /* Constants.TouchSlopPx */;
+            const hit = this._private__splitHit(line.hitTestAt(event.clientX - rect.left, event.clientY - rect.top, slop));
+            if (hit === null) {
+                continue;
+            }
+            this._private__setHovered(line.id());
+            this._private__setHoveredPart(line, hit._internal_part);
+            return line;
+        }
+        return null;
+    }
+    _private__paneElementOf(line) {
         const pane = this._private__chart.panes()[line.paneIndex()];
-        const paneElement = pane ? pane.getHTMLElement() : null;
+        return pane ? pane.getHTMLElement() : null;
+    }
+    _private__paneY(line, event) {
+        const paneElement = this._private__paneElementOf(line);
         if (paneElement) {
             return event.clientY - paneElement.getBoundingClientRect().top;
         }
@@ -19622,6 +19683,7 @@ let nextLineId = 0;
  * line. Hit testing comes from the engine — the line's id travels as the price
  * line's `externalId` — so the hit area matches what is drawn.
  */
+const HIT_TOLERANCE_PX$1 = 8;
 class DraggablePriceLine {
     constructor(chart, series, options) {
         this._private__priceLine = null;
@@ -19674,6 +19736,14 @@ class DraggablePriceLine {
             color: hovered ? this._private__options.hoverColor : this._private__originalColor,
         });
     }
+    /**
+     * The engine draws this one, so there is no pane view to ask: a press within
+     * the line's own grab strip counts as a hit.
+     */
+    hitTestAt(x, y, slop = 0) {
+        const coord = this._private__series.priceToCoordinate(this._private__options.price);
+        return coord !== null && Math.abs(y - coord) <= HIT_TOLERANCE_PX$1 + slop ? this._private__id : null;
+    }
     priceAt(paneY) {
         const price = this._private__series.coordinateToPrice(paneY);
         return price === null ? null : price;
@@ -20216,22 +20286,27 @@ class PositionLineRenderer {
     _internal_setData(data) {
         this._private__data = data;
     }
-    _internal_hitTest(x, y) {
+    /**
+     * `slop` widens every target by the same amount, for input coarser than a
+     * mouse pointer.
+     */
+    _internal_hitTest(x, y, slop = 0) {
         // The close button sits on top of the label, which sits on top of the
         // line, so the narrowest target is tested first.
         for (const layout of this._private__layouts) {
-            if (layout._internal_closable && x >= layout._internal_closeLeft && x <= layout._internal_closeRight &&
-                Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2) {
+            if (layout._internal_closable && x >= layout._internal_closeLeft - slop && x <= layout._internal_closeRight + slop &&
+                Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2 + slop) {
                 return { _internal_level: layout._internal_level, _internal_part: 'close' };
             }
         }
         for (const layout of this._private__layouts) {
-            if (x >= layout._internal_pillLeft && x <= layout._internal_pillRight && Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2) {
+            if (x >= layout._internal_pillLeft - slop && x <= layout._internal_pillRight + slop &&
+                Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2 + slop) {
                 return { _internal_level: layout._internal_level, _internal_part: 'body' };
             }
         }
         for (const layout of this._private__layouts) {
-            if (Math.abs(y - layout._internal_y) <= 8 /* Constants.LineHitTolerance */) {
+            if (Math.abs(y - layout._internal_y) <= 8 /* Constants.LineHitTolerance */ + slop) {
                 return { _internal_level: layout._internal_level, _internal_part: 'line' };
             }
         }
@@ -20468,8 +20543,8 @@ class PositionLinePaneView {
     zOrder() {
         return 'top';
     }
-    _internal_hitTest(x, y) {
-        return this._private__data === null ? null : this._private__renderer._internal_hitTest(x, y);
+    _internal_hitTest(x, y, slop = 0) {
+        return this._private__data === null ? null : this._private__renderer._internal_hitTest(x, y, slop);
     }
 }
 
@@ -20620,6 +20695,13 @@ class PositionLine {
      * of jumping to sit under it — which matters most when the label has been
      * fanned away from its own line.
      */
+    hitTestAt(x, y, slop = 0) {
+        const hit = this._private__paneView._internal_hitTest(x, y, slop);
+        if (hit === null) {
+            return null;
+        }
+        return this._private__levelOptions(hit._internal_level) === null ? null : `${this._private__id}#${hit._internal_level}:${hit._internal_part}`;
+    }
     dragAnchorY() {
         if (this._private__dragLevel === null) {
             return null;
@@ -29690,6 +29772,7 @@ class DrawingToolsManager {
         this._private__mouseMoveHandler = null;
         this._private__pointerDownHandler = null;
         this._private__pointerUpHandler = null;
+        this._private__pointerMoveHandler = null;
         this._private__pointerCancelHandler = null;
         this._private__lostCaptureHandler = null;
         this._private__windowPointerUpHandler = null;
@@ -30264,10 +30347,12 @@ class DrawingToolsManager {
         if (chartElement) {
             this._private__pointerDownHandler = (event) => this._private__handlePointerDown(event);
             this._private__pointerUpHandler = (event) => this._private__handlePointerUp(event);
+            this._private__pointerMoveHandler = (event) => this._private__handlePointerMove(event);
             this._private__pointerCancelHandler = (event) => this._private__handlePointerUp(event);
             this._private__lostCaptureHandler = (event) => this._private__handleLostPointerCapture(event);
             chartElement.addEventListener('pointerdown', this._private__pointerDownHandler);
             chartElement.addEventListener('pointerup', this._private__pointerUpHandler);
+            chartElement.addEventListener('pointermove', this._private__pointerMoveHandler);
             chartElement.addEventListener('pointercancel', this._private__pointerCancelHandler);
             chartElement.addEventListener('lostpointercapture', this._private__lostCaptureHandler);
         }
@@ -30302,6 +30387,10 @@ class DrawingToolsManager {
                 chartElement.removeEventListener('pointerup', this._private__pointerUpHandler);
                 this._private__pointerUpHandler = null;
             }
+            if (this._private__pointerMoveHandler) {
+                chartElement.removeEventListener('pointermove', this._private__pointerMoveHandler);
+                this._private__pointerMoveHandler = null;
+            }
             if (this._private__pointerCancelHandler) {
                 chartElement.removeEventListener('pointercancel', this._private__pointerCancelHandler);
                 this._private__pointerCancelHandler = null;
@@ -30451,6 +30540,36 @@ class DrawingToolsManager {
         // mouse events, and those are what drive the crosshair the drag reads.
         this._private__disableChartInteractions();
     }
+    /**
+     * The drag reads the crosshair, which touch never moves: its move handler
+     * only tries to pan, and the drag has just turned panning off. So touch is
+     * driven straight from the pointer instead.
+     */
+    _private__handlePointerMove(event) {
+        if (!this._private__isDragging || this._private__draggedToolId === null || event.pointerType === 'mouse') {
+            return;
+        }
+        if (this._private__pointerId !== null && event.pointerId !== this._private__pointerId) {
+            return;
+        }
+        const tool = this._private__tools.get(this._private__draggedToolId);
+        if (!tool) {
+            return;
+        }
+        const paneElement = this._private__paneElementOf(tool);
+        if (paneElement === null) {
+            return;
+        }
+        const rect = paneElement.getBoundingClientRect();
+        const series = tool.series();
+        const price = series.coordinateToPrice((event.clientY - rect.top));
+        const time = timeFromCoordinate(this._private__chart, series, event.clientX - rect.left);
+        if (price === null || time === null) {
+            return;
+        }
+        tool.updateDrag(time, price);
+        event.preventDefault();
+    }
     _private__handlePointerUp(event) {
         if (!this._private__isDragging || this._private__draggedToolId === null) {
             return;
@@ -30624,7 +30743,7 @@ const customSeriesDefaultOptions = {
  * Returns the current version as a string. For example `'1.0.0'`.
  */
 function version() {
-    return "2.3.10";
+    return "2.3.12";
 }
 
 export { areaSeries as AreaSeries, ArrowTool, barSeries as BarSeries, baselineSeries as BaselineSeries, BrushTool, candlestickSeries as CandlestickSeries, CircleTool, ColorType, CrossLineTool, CrosshairMode, DEFAULT_SESSIONS, DraggablePriceLine, DrawingToolsManager, EXTENDED_FIBONACCI_RATIOS, FibonacciCalculator, FibonacciExtensionTool, FibonacciFanTool, FibonacciTool, GanttTool, histogramSeries as HistogramSeries, HorizontalLineTool, InteractiveLineManager, LastPriceAnimationMode, lineSeries as LineSeries, LineStyle, LineType, MismatchDirection, ParallelChannelTool, PitchforkTool, PolygonTool, PositionCalculator, PositionLine, PositionMarkersManager, PositionTool, PriceLineSource, PriceScaleMode, RectangleTool, RulerCalculator, RulerTool, STANDARD_FIBONACCI_RATIOS, TextTool, TickMarkType, TrackingModeExitMode, TradingSessionsIndicator, TrendLineTool, VerticalLineTool, VolumeProfileIndicator, applyADX, applyATR, applyBollingerBands, applyCCI, applyDonchianChannels, applyEMA, applyHeikinAshi, applyIchimoku, applyKeltnerChannels, applyMACD, applyMFI, applyOBV, applyParabolicSAR, applyPivotPoints, applyRSI, applySMA, applyStochastic, applySuperTrend, applyVWAP, applyVolume, applyWMA, applyWilliamsR, calculateHeikinAshi, calculatePipConfig, coordinateFromTime, createArrowTool, createBrushTool, createChart, createChartEx, createCircleTool, createCrossLineTool, createFibonacciExtensionTool, createFibonacciFanTool, createFibonacciTool, createGanttTool, createHorizontalLineTool, createImageWatermark, createInteractiveLineManager, createOptionsChart, createParallelChannelTool, createPitchforkTool, createPolygonTool, createPositionLine, createPositionMarkers, createPositionTool, createRectangleTool, createRulerTool, createSeriesMarkers, createTextTool, createTextWatermark, createTradingLine, createTradingSessionsIndicator, createTrendLineTool, createUpDownMarkers, createVerticalLineTool, createVolumeProfileIndicator, createYieldCurveChart, customSeriesDefaultOptions, defaultHorzScaleBehavior, getPipConfig, hideSeriesPaint, isBusinessDay, isUTCTimestamp, setSeriesVolumes, setVolumeProfileData, timeFromCoordinate, version };