@pipsend/charts 2.3.4 → 2.3.11

package/dist/pipsend-charts.standalone.development.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.4
+ * Pipsend Charts v2.3.11
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -2486,14 +2486,8 @@
             return this._private__styleGetter(this._private__findBar, this._private__series._internal_options(), barIndex, precomputedBars);
         }
         /**
-         * Like `barStyle`, but returns null instead of throwing when the bar is
-         * gone.
-         *
-         * Recolouring walks items that were laid out against the data as it was. A
-         * bar that has since disappeared is not an error there: the view is about
-         * to be rebuilt from the new data anyway. Letting it throw took down
-         * whatever asked for the repaint — including `setData`, which left the
-         * series without its data and the pane empty until the page was reloaded.
+         * Like `barStyle`, but null instead of throwing when the bar is gone, which
+         * a recolour of items laid out against older data can hit.
          */
         _internal_barStyleOrNull(barIndex, precomputedBars) {
             if (precomputedBars === undefined && this._private__series._internal_bars()._internal_valueAt(barIndex) === null) {
@@ -2895,7 +2889,10 @@
             commonRendererData._internal_additionalPaddingTop = additionalPadding;
             commonRendererData._internal_additionalPaddingBottom = additionalPadding;
             commonRendererData._internal_coordinate = data._internal_coordinate;
-            commonRendererData._internal_fixedCoordinate = data._internal_fixedCoordinate;
+            // Re-runs at draw time, after the axis has moved the label clear of overlaps.
+            if (data._internal_fixedCoordinate !== undefined) {
+                commonRendererData._internal_fixedCoordinate = data._internal_fixedCoordinate;
+            }
             axisRendererData._internal_text = data._internal_text;
             axisRendererData._internal_visible = data._internal_visible;
             axisRendererData._internal_tickVisible = data._internal_tickVisible;
@@ -3772,7 +3769,6 @@
         }
     }
 
-    const TICK_DENSITY = 2.5;
     class PriceTickMarkBuilder {
         constructor(priceScale, base, coordinateToLogicalFunc, logicalToCoordinateFunc) {
             this._private__marks = [];
@@ -3833,7 +3829,7 @@
             return this._private__priceScale._internal_fontSize();
         }
         _private__tickMarkHeight() {
-            return Math.ceil(this._private__fontHeight() * TICK_DENSITY);
+            return Math.max(1, Math.ceil(this._private__fontHeight() * this._private__priceScale._internal_options().tickMarkSpacing));
         }
         _private__updateMarks(firstValue, span, high, low, minCoord, maxCoord) {
             const marks = this._private__marks;
@@ -3998,6 +3994,9 @@
                 this._private__invalidateInternalHeightCache();
                 this._private__marksCache = null;
             }
+            if (options.tickMarkSpacing !== undefined) {
+                this._private__marksCache = null;
+            }
         }
         _internal_isAutoScale() {
             return this._private__options.autoScale;
@@ -5175,6 +5174,9 @@
             this._private__uniformDistribution = val;
             this._private__cache = null;
         }
+        _internal_invalidate() {
+            this._private__cache = null;
+        }
         _internal_setTimeScalePoints(newPoints, firstChangedPointIndex) {
             this._private__removeMarksSinceIndex(firstChangedPointIndex);
             this._private__cache = null;
@@ -5193,7 +5195,7 @@
                 });
             }
         }
-        _internal_build(spacing, maxWidth, checkIndicesForData, indicesWithDataMap, indicesWithDataId) {
+        _internal_build(spacing, maxWidth, checkIndicesForData, indicesWithDataMap, indicesWithDataId, allows = () => true) {
             const maxIndexesPerMark = Math.ceil(maxWidth / spacing);
             if (this._private__cache === null ||
                 this._private__cache._internal_maxIndexesPerMark !== maxIndexesPerMark ||
@@ -5202,7 +5204,7 @@
                 this._private__cache = {
                     _internal_indicesWithDataId: indicesWithDataId,
                     _internal_checkIndicesForData: checkIndicesForData,
-                    _internal_marks: this._private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap),
+                    _internal_marks: this._private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap, allows),
                     _internal_maxIndexesPerMark: maxIndexesPerMark,
                 };
             }
@@ -5226,7 +5228,7 @@
                 this._private__marksByWeight.delete(weight);
             }
         }
-        _private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap) {
+        _private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap, allows) {
             let marks = [];
             const canBeIncluded = (mark) => !checkIndicesForData || indicesWithDataMap.has(mark.index);
             for (const weight of Array.from(this._private__marksByWeight.keys()).sort((a, b) => b - a)) {
@@ -5244,6 +5246,11 @@
                 let leftIndex = -Infinity;
                 for (let i = 0; i < currentWeightLength; i++) {
                     const mark = currentWeight[i];
+                    // Skipped before the fit check: a rejected mark must not count as one
+                    // that did not fit, which with uniform distribution drops its whole weight.
+                    if (!allows(mark, maxIndexesPerMark)) {
+                        continue;
+                    }
                     const currentIndex = mark.index;
                     // Determine indexes with which current index will be compared
                     // All marks to the right is moved to new array
@@ -5550,7 +5557,7 @@
             const visibleBars = ensureNotNull(this._internal_visibleStrictRange());
             const firstBar = Math.max(visibleBars._internal_left(), visibleBars._internal_left() - indexPerLabel);
             const lastBar = Math.max(visibleBars._internal_right(), visibleBars._internal_right() - indexPerLabel);
-            const items = this._private__tickMarks._internal_build(spacing, maxLabelWidth, this._private__options.ignoreWhitespaceIndices, this._private__indicesWithData, this._private__indicesWithDataUpdateId);
+            const items = this._private__tickMarks._internal_build(spacing, maxLabelWidth, this._private__options.ignoreWhitespaceIndices, this._private__indicesWithData, this._private__indicesWithDataUpdateId, (mark, barsPerMark) => this._private__horzScaleBehavior.allowsTickMark?.(mark, barsPerMark) ?? true);
             // according to indexPerLabel value this value means "earliest index which _might be_ used as the second label on time scale"
             const earliestIndexOfSecondLabel = this._private__firstIndex() + indexPerLabel;
             // according to indexPerLabel value this value means "earliest index which _might be_ used as the second last label on time scale"
@@ -5928,6 +5935,7 @@
         _private__invalidateTickMarks() {
             this._private__resetTimeMarksCache();
             this._private__formattedByWeight.clear();
+            this._private__tickMarks._internal_invalidate();
         }
         _private__updateDateTimeFormatter() {
             this._private__horzScaleBehavior.updateFormatter(this._private__localizationOptions);
@@ -7042,6 +7050,14 @@
             const tp = item;
             return this._private__dateTimeFormatter._internal_format(new Date(tp._internal_timestamp * 1000));
         }
+        allowsTickMark(tickMark, barsPerMark) {
+            const filter = this._private__options.timeScale.tickMarkFilter;
+            if (filter === undefined) {
+                return true;
+            }
+            const tickMarkType = weightToTickMarkType(tickMark.weight, this._private__options.timeScale.timeVisible, this._private__options.timeScale.secondsVisible);
+            return filter(tickMark.originalTime, tickMarkType, barsPerMark);
+        }
         formatTickmark(tickMark, localizationOptions) {
             const tickMarkType = weightToTickMarkType(tickMark.weight, this._private__options.timeScale.timeVisible, this._private__options.timeScale.secondsVisible);
             const options = this._private__options.timeScale;
@@ -11446,9 +11462,6 @@
         _internal__updateOptions() {
             const colorer = this._internal__series._internal_barColorer();
             this._internal__items = this._internal__items.map((item) => {
-                // An item whose bar is gone keeps the colour it had. Throwing here
-                // took down whatever asked for the repaint — `setData` among them,
-                // which left the series without its data and the pane empty.
                 const style = colorer._internal_barStyleOrNull(item._internal_time);
                 return style === null ? item : { ...item, ...style };
             });
@@ -11751,6 +11764,7 @@
         },
         minimumWidth: 0,
         ensureEdgeTickMarksVisible: false,
+        tickMarkSpacing: 2.5,
     };
 
     const timeScaleOptionsDefaults = {
@@ -12846,8 +12860,6 @@
             const colorer = this._internal__series._internal_barColorer();
             this._internal__items = this._internal__series._internal_bars()._internal_rows().map((row) => {
                 const value = row._internal_value[3 /* PlotRowValueIndex.Close */];
-                // The row travels with the point: without it the colorer looks it up
-                // again by index, and that lookup could fail and take the repaint down.
                 return this._internal__createRawItem(row._internal_index, value, colorer, row);
             });
         }
@@ -12870,10 +12882,10 @@
             if (point) {
                 const style = styleGetter(renderingScope, point);
                 if (style !== prevStyle) {
-                    context.beginPath();
                     if (prevStyle !== null) {
                         context.fill();
                     }
+                    context.beginPath();
                     context.fillStyle = style;
                     prevStyle = style;
                 }
@@ -13812,9 +13824,6 @@
         }
         _internal__fillRawPoints() {
             const colorer = this._internal__series._internal_barColorer();
-            // The row goes to the colorer as it is. Asking for the style by index
-            // alone made it look the row up again, and that second lookup could come
-            // back empty and throw, taking the whole repaint down with it.
             this._internal__items = this._internal__series._internal_bars()._internal_rows().map((row) => this._internal__createRawItem(row._internal_index, row, colorer));
         }
     }
@@ -17885,7 +17894,7 @@
             hideSource: options.hideSource ?? true,
         };
         const sourceOptions = series.options();
-        // Same price scale and the same formatting as the source: the candles are a
+        // Same price scale, formatting and axis labels as the source: the candles are a
         // restatement of that series, not a second instrument, so they must not
         // autoscale on their own axis or round to a different precision.
         const haSeries = chart.addSeries(candlestickSeries, {
@@ -17899,6 +17908,8 @@
             wickDownColor: resolved.wickDownColor,
             priceScaleId: sourceOptions.priceScaleId,
             priceFormat: sourceOptions.priceFormat,
+            lastValueVisible: sourceOptions.lastValueVisible,
+            priceLineVisible: sourceOptions.priceLineVisible,
         }, resolved.paneIndex);
         let restoreSourcePaint = null;
         const blankSource = (blank) => {
@@ -18100,12 +18111,14 @@
         const macdSeries = chart.addSeries(lineSeries, {
             color: resolved.colorMACD,
         }, paneIndex);
+        // An index past the last pane opens a new one, so the rest follow MACD to where it landed.
+        const macdPane = paneIndexOf(chart, macdSeries, paneIndex);
         const signalSeries = chart.addSeries(lineSeries, {
             color: resolved.colorSignal,
-        }, paneIndex);
+        }, macdPane);
         const histogramSeries$1 = chart.addSeries(histogramSeries, {
             color: resolved.colorHistogramUp,
-        }, paneIndex);
+        }, macdPane);
         // Calculate EMA
         const calculateEMA = (prices, period) => {
             const ema = [];
@@ -18237,13 +18250,13 @@
             // Stochastic is bounded to 0-100; pinning it keeps the pane readable
             autoscaleInfoProvider: boundedScale,
         }, paneIndex);
+        // An index past the last pane opens a new one, so %D follows %K to where it landed.
+        const scalePane = paneIndexOf(chart, kSeries, paneIndex);
         // Create %D line (slow - signal)
         const dSeries = chart.addSeries(lineSeries, {
             color: resolved.colorD,
             autoscaleInfoProvider: boundedScale,
-        }, paneIndex);
-        // The pane the series landed in, which is not always the one asked for.
-        const scalePane = paneIndexOf(chart, kSeries, paneIndex);
+        }, scalePane);
         chart.priceScale(kSeries.options().priceScaleId ?? 'right', scalePane).applyOptions({
             scaleMargins: {
                 top: 0.1,
@@ -18585,15 +18598,16 @@
             color: resolved.colorADX,
             autoscaleInfoProvider: boundedScale,
         }, paneIndex);
+        // An index past the last pane opens a new one, so the DI lines follow ADX to where it landed.
+        const scalePane = paneIndexOf(chart, adxSeries, paneIndex);
         const plusSeries = chart.addSeries(lineSeries, {
             color: resolved.colorPlusDI,
             autoscaleInfoProvider: boundedScale,
-        }, paneIndex);
+        }, scalePane);
         const minusSeries = chart.addSeries(lineSeries, {
             color: resolved.colorMinusDI,
             autoscaleInfoProvider: boundedScale,
-        }, paneIndex);
-        const scalePane = paneIndexOf(chart, adxSeries, paneIndex);
+        }, scalePane);
         chart.priceScale(adxSeries.options().priceScaleId ?? 'right', scalePane).applyOptions({
             scaleMargins: {
                 top: 0.1,
@@ -19709,6 +19723,8 @@
             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. */
@@ -19773,8 +19789,18 @@
             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 };
@@ -19813,6 +19839,7 @@
         }
         _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();
@@ -19834,12 +19861,24 @@
                         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
@@ -19885,9 +19924,38 @@
             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;
             }
@@ -20004,6 +20072,7 @@
      * 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;
@@ -20056,6 +20125,14 @@
                 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;
@@ -20598,22 +20675,27 @@
         _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' };
                 }
             }
@@ -20850,8 +20932,8 @@
         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);
         }
     }
 
@@ -21002,6 +21084,13 @@
          * 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;
@@ -30072,6 +30161,7 @@
             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;
@@ -30646,10 +30736,12 @@
             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);
             }
@@ -30684,6 +30776,10 @@
                     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;
@@ -30833,6 +30929,36 @@
             // 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;
@@ -31006,7 +31132,7 @@
      * Returns the current version as a string. For example `'1.0.0'`.
      */
     function version() {
-        return "2.3.4";
+        return "2.3.11";
     }
 
     var PipsendChartsModule = /*#__PURE__*/Object.freeze({