@pipsend/charts 2.1.0 → 2.2.1

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

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.1.0
+ * Pipsend Charts v2.2.1
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -15916,6 +15916,85 @@
         return volumes !== undefined && volumes.size > 0;
     }
 
+    const TRANSPARENT = 'rgba(0, 0, 0, 0)';
+    /**
+     * Take a series off the screen without hiding it.
+     *
+     * `visible: false` takes down everything hung off the series as well: its
+     * price lines, primitives and price-axis label stop rendering. A transform
+     * that only wants the bars themselves out of the way — Heikin Ashi drawing
+     * over its source — needs the series to stay visible to the engine, so its
+     * paint is made transparent instead and the last-value label and price line
+     * are switched off. Custom series have no known colours; those fall back to
+     * `visible: false`.
+     *
+     * @param series - Series to blank out.
+     * @returns Puts back the options the series had when it was blanked.
+     */
+    function hideSeriesPaint(series) {
+        switch (series.seriesType()) {
+            case 'Candlestick':
+                return blank(series, {
+                    upColor: TRANSPARENT,
+                    downColor: TRANSPARENT,
+                    borderVisible: false,
+                    wickVisible: false,
+                });
+            case 'Bar':
+                return blank(series, {
+                    upColor: TRANSPARENT,
+                    downColor: TRANSPARENT,
+                });
+            case 'Line':
+                return blank(series, {
+                    color: TRANSPARENT,
+                    crosshairMarkerVisible: false,
+                    pointMarkersVisible: false,
+                });
+            case 'Area':
+                return blank(series, {
+                    lineColor: TRANSPARENT,
+                    topColor: TRANSPARENT,
+                    bottomColor: TRANSPARENT,
+                    crosshairMarkerVisible: false,
+                    pointMarkersVisible: false,
+                });
+            case 'Baseline':
+                return blank(series, {
+                    topLineColor: TRANSPARENT,
+                    topFillColor1: TRANSPARENT,
+                    topFillColor2: TRANSPARENT,
+                    bottomLineColor: TRANSPARENT,
+                    bottomFillColor1: TRANSPARENT,
+                    bottomFillColor2: TRANSPARENT,
+                    crosshairMarkerVisible: false,
+                    pointMarkersVisible: false,
+                });
+            case 'Histogram':
+                return blank(series, {
+                    color: TRANSPARENT,
+                });
+            default:
+                return blank(series, { visible: false });
+        }
+    }
+    function blank(series, paint) {
+        const patch = {
+            ...paint,
+            lastValueVisible: false,
+            priceLineVisible: false,
+        };
+        const before = series.options();
+        const snapshot = {};
+        for (const key of Object.keys(patch)) {
+            snapshot[key] = before[key];
+        }
+        series.applyOptions(patch);
+        return () => {
+            series.applyOptions(snapshot);
+        };
+    }
+
     /**
      * Pins a bounded indicator (RSI, Stochastic…) to a fixed price range.
      *
@@ -17612,9 +17691,9 @@
      * Draw a source series as Heikin Ashi candles.
      *
      * The source series is left in place holding its real prices — it is only
-     * hidden — so indicators bound to it keep computing on the true OHLC, and
-     * `remove()` puts the chart back exactly as it was. That makes this usable as a
-     * chart-type toggle:
+     * painted transparent — so indicators bound to it keep computing on the true
+     * OHLC, its price lines and primitives stay on screen, and `remove()` puts the
+     * chart back exactly as it was. That makes this usable as a chart-type toggle:
      *
      * ```js
      * const ha = applyHeikinAshi(candleSeries, chart);
@@ -17656,10 +17735,16 @@
             priceScaleId: sourceOptions.priceScaleId,
             priceFormat: sourceOptions.priceFormat,
         }, resolved.paneIndex);
-        const sourceWasVisible = sourceOptions.visible;
-        if (resolved.hideSource === true) {
-            series.applyOptions({ visible: false });
-        }
+        let restoreSourcePaint = null;
+        const blankSource = (blank) => {
+            if (blank && restoreSourcePaint === null) {
+                restoreSourcePaint = hideSeriesPaint(series);
+            }
+            else if (!blank && restoreSourcePaint !== null) {
+                restoreSourcePaint();
+                restoreSourcePaint = null;
+            }
+        };
         const runtime = bindIndicator({
             _internal_source: series,
             _internal_chart: chart,
@@ -17683,9 +17768,7 @@
                     wickUpColor: current.wickUpColor,
                     wickDownColor: current.wickDownColor,
                 });
-                series.applyOptions({
-                    visible: current.hideSource === true ? false : sourceWasVisible,
-                });
+                blankSource(current.hideSource === true);
             },
         });
         const handle = {
@@ -17695,10 +17778,10 @@
             recalculate: runtime.recalculate,
             remove: () => {
                 runtime.remove();
-                // The source outlives the indicator, so its visibility is ours to put
+                // The source outlives the indicator, so its paint is ours to put
                 // back — otherwise removing a Heikin Ashi overlay leaves a blank chart.
                 try {
-                    series.applyOptions({ visible: sourceWasVisible });
+                    blankSource(false);
                 }
                 catch (error) {
                     // The series may already be gone if the chart was disposed
@@ -20325,6 +20408,9 @@
         get type() {
             return this._type;
         }
+        isComplete() {
+            return true;
+        }
         /**
          * Lets a tool hand the base its own options object, once, in the constructor.
          *
@@ -20652,6 +20738,7 @@
             this._private__dragStartPoint2 = null;
             // Interactive mode
             this._private__isComplete = false;
+            this._private__interactive = null;
             this._private__previewPoint = null;
             this._private__trendOptions = {
                 lineColor: '#2962ff',
@@ -20699,7 +20786,7 @@
                     this._private__isComplete = true;
                 }
             });
-            // Start the interactive drawing mode
+            this._private__interactive = manager;
             manager._internal_startDrawing();
         }
         _private__createPrimitive() {
@@ -21029,7 +21116,14 @@
         _update() {
             this._private__requestUpdate();
         }
+        isComplete() {
+            return this._private__isComplete;
+        }
         remove() {
+            if (this._private__interactive) {
+                this._private__interactive._internal_destroy();
+                this._private__interactive = null;
+            }
             if (this._private__primitive) {
                 // Detach from series
                 this._series.detachPrimitive(this._private__primitive);
@@ -21936,6 +22030,9 @@
         points() {
             return this._private__points;
         }
+        isComplete() {
+            return this._private__isComplete;
+        }
         remove() {
             this._private__stopDrawing();
             if (this._private__primitive) {
@@ -22406,6 +22503,9 @@
         isHovered() {
             return this._private__isHovered;
         }
+        isComplete() {
+            return this._private__isComplete;
+        }
         remove() {
             this._private__stopDrawing();
             if (this._private__primitive) {
@@ -22870,6 +22970,9 @@
         isHovered() {
             return this._private__isHovered;
         }
+        isComplete() {
+            return this._private__isComplete;
+        }
         remove() {
             this._private__stopDrawing();
             if (this._private__primitive) {
@@ -23800,6 +23903,9 @@
             }
             return false;
         }
+        isComplete() {
+            return this._private__isComplete;
+        }
         remove() {
             if (this._private__primitive) {
                 this._series.detachPrimitive(this._private__primitive);
@@ -24690,6 +24796,9 @@
         _update() {
             this._private__requestUpdate();
         }
+        isComplete() {
+            return !this._private__isDrawing;
+        }
         remove() {
             if (this._private__clickHandler) {
                 this._chart.unsubscribeClick(this._private__clickHandler);
@@ -25233,6 +25342,9 @@
         _update() {
             this._private__requestUpdate();
         }
+        isComplete() {
+            return !this._private__isDrawing;
+        }
         remove() {
             if (this._private__clickHandler) {
                 this._chart.unsubscribeClick(this._private__clickHandler);
@@ -25696,6 +25808,9 @@
         _update() {
             this._private__requestUpdate();
         }
+        isComplete() {
+            return !this._private__isDrawing;
+        }
         remove() {
             if (this._private__clickHandler) {
                 this._chart.unsubscribeClick(this._private__clickHandler);
@@ -26238,6 +26353,9 @@
         _update() {
             this._private__requestUpdate();
         }
+        isComplete() {
+            return !this._private__isDrawing;
+        }
         remove() {
             // Clean up click handler
             if (this._private__clickHandler) {
@@ -26804,7 +26922,7 @@
         }
         _private__setupClickOutsideHandler() {
             // Set up click handler to finish editing when clicking outside
-            this._private__clickOutsideHandler = this._chart.subscribeClick((param) => {
+            const handler = (param) => {
                 if (!this._private__isEditing)
                     return;
                 // Get click coordinates
@@ -26820,7 +26938,9 @@
                         this.remove();
                     }
                 }
-            });
+            };
+            this._private__clickOutsideHandler = handler;
+            this._chart.subscribeClick(handler);
         }
         _private__createPrimitive() {
             this._private__paneView = this._private__createPaneView();
@@ -28969,6 +29089,9 @@
             this._private__selectionChanged = new Delegate();
             this._private__isDragging = false;
             this._private__draggedToolId = null;
+            this._private__pendingToolIds = new Set();
+            this._private__completionCheck = null;
+            this._private__drawingCompleted = new Delegate();
             this._private__chart = chart;
             this._private__series = series;
             this._private__options = {
@@ -29007,9 +29130,63 @@
         addTool(tool, id) {
             const toolId = id ?? tool.id;
             this._private__tools.set(toolId, tool);
+            if (!tool.isComplete()) {
+                this._private__pendingToolIds.add(toolId);
+            }
             this.recordChange();
             return toolId;
         }
+        hasPendingDrawing() {
+            return this._private__pendingToolIds.size > 0;
+        }
+        /** Removes every tool still waiting for points; returns how many were dropped. */
+        cancelPendingDrawings() {
+            if (this._private__pendingToolIds.size === 0) {
+                return 0;
+            }
+            let cancelled = 0;
+            for (const id of Array.from(this._private__pendingToolIds)) {
+                const tool = this._private__tools.get(id);
+                if (tool) {
+                    if (this._private__selectedToolId === id) {
+                        this._private__applySelection(null);
+                    }
+                    tool.remove();
+                    this._private__tools.delete(id);
+                    cancelled++;
+                }
+            }
+            this._private__pendingToolIds.clear();
+            if (cancelled > 0) {
+                this.recordChange();
+            }
+            return cancelled;
+        }
+        subscribeDrawingCompleted(handler) {
+            this._private__drawingCompleted._internal_subscribe(handler);
+        }
+        unsubscribeDrawingCompleted(handler) {
+            this._private__drawingCompleted._internal_unsubscribe(handler);
+        }
+        _private__scheduleCompletionCheck() {
+            if (this._private__pendingToolIds.size === 0 || this._private__completionCheck !== null) {
+                return;
+            }
+            this._private__completionCheck = setTimeout(() => {
+                this._private__completionCheck = null;
+                for (const id of Array.from(this._private__pendingToolIds)) {
+                    const tool = this._private__tools.get(id);
+                    if (!tool) {
+                        this._private__pendingToolIds.delete(id);
+                        continue;
+                    }
+                    if (tool.isComplete()) {
+                        this._private__pendingToolIds.delete(id);
+                        this._private__drawingCompleted._internal_fire(id);
+                    }
+                }
+            }, 0);
+        }
         /**
          * Remove a tool by ID
          */
@@ -29021,6 +29198,7 @@
                 }
                 tool.remove();
                 this._private__tools.delete(id);
+                this._private__pendingToolIds.delete(id);
                 this.recordChange();
                 return true;
             }
@@ -29220,6 +29398,7 @@
             this._private__applySelection(null);
             this._private__tools.forEach((tool) => tool.remove());
             this._private__tools.clear();
+            this._private__pendingToolIds.clear();
             this.recordChange();
         }
         /**
@@ -29440,6 +29619,11 @@
          * Destroy the manager and cleanup
          */
         destroy() {
+            if (this._private__completionCheck !== null) {
+                clearTimeout(this._private__completionCheck);
+                this._private__completionCheck = null;
+            }
+            this._private__drawingCompleted._internal_destroy();
             this.clearAll();
             this._private__detachEventHandlers();
         }
@@ -29459,8 +29643,8 @@
             const chartElement = this._private__chart.chartElement();
             if (chartElement) {
                 this._private__pointerDownHandler = (event) => this._private__handlePointerDown(event);
-                this._private__pointerUpHandler = (event) => this._private__handlePointerUp();
-                this._private__pointerCancelHandler = (event) => this._private__handlePointerUp();
+                this._private__pointerUpHandler = (event) => this._private__handlePointerUp(event);
+                this._private__pointerCancelHandler = (event) => this._private__handlePointerUp(event);
                 chartElement.addEventListener('pointerdown', this._private__pointerDownHandler);
                 chartElement.addEventListener('pointerup', this._private__pointerUpHandler);
                 chartElement.addEventListener('pointercancel', this._private__pointerCancelHandler);
@@ -29503,6 +29687,7 @@
             }
         }
         _private__handleClick(param) {
+            this._private__scheduleCompletionCheck();
             if (!param.point) {
                 return;
             }
@@ -29582,6 +29767,9 @@
             return null;
         }
         _private__handlePointerDown(event) {
+            if (this._private__isDragging) {
+                return;
+            }
             // Cleared for every press, then raised only if this one grabs a drawing
             setInputClaim(this._private__chart, false);
             const chartElement = this._private__chart.chartElement();
@@ -29624,10 +29812,13 @@
             // mouse events, and those are what drive the crosshair the drag reads.
             this._private__disableChartInteractions();
         }
-        _private__handlePointerUp() {
+        _private__handlePointerUp(event) {
             if (!this._private__isDragging || this._private__draggedToolId === null) {
                 return;
             }
+            if (event && this._private__pointerId !== null && event.pointerId !== this._private__pointerId) {
+                return;
+            }
             const tool = this._private__tools.get(this._private__draggedToolId);
             if (tool) {
                 tool.stopDrag();
@@ -29685,6 +29876,9 @@
             this._private__pointerId = null;
         }
         _private__disableChartInteractions() {
+            if (this._private__interactionsBeforeDrag !== null) {
+                return;
+            }
             const options = this._private__chart.options();
             this._private__interactionsBeforeDrag = {
                 _internal_handleScroll: options.handleScroll,
@@ -29709,6 +29903,14 @@
             });
         }
         _private__handleKeyboard(event) {
+            const target = event.target;
+            const typing = !!target && (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable);
+            if (typing) {
+                return;
+            }
+            if (event.key === 'Enter') {
+                this._private__scheduleCompletionCheck();
+            }
             // Delete or Backspace to remove selected tool
             if (event.key === 'Delete' || event.key === 'Backspace') {
                 if (this.deleteSelected()) {
@@ -29729,8 +29931,8 @@
                 }
                 return;
             }
-            // Escape to deselect
             if (event.key === 'Escape') {
+                this.cancelPendingDrawings();
                 this._private__handlePointerUp();
                 this._private__deselectAll();
                 this.stopDrawing();
@@ -29766,7 +29968,7 @@
      * Returns the current version as a string. For example `'1.0.0'`.
      */
     function version() {
-        return "2.1.0";
+        return "2.2.1";
     }
 
     var PipsendChartsModule = /*#__PURE__*/Object.freeze({
@@ -29876,6 +30078,7 @@
         customSeriesDefaultOptions: customSeriesDefaultOptions,
         defaultHorzScaleBehavior: defaultHorzScaleBehavior,
         getPipConfig: getPipConfig,
+        hideSeriesPaint: hideSeriesPaint,
         isBusinessDay: isBusinessDay,
         isUTCTimestamp: isUTCTimestamp,
         setSeriesVolumes: setSeriesVolumes,