@pipsend/charts 2.3.13 → 2.3.15

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

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.13-dev+202609280001
+ * Pipsend Charts v2.3.15
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -14687,6 +14687,9 @@
     function shapeMargin(barSpacing) {
         return Math.max(size(barSpacing, 0.1), 3 /* Constants.MinShapeMargin */);
     }
+    function barGap(barSpacing) {
+        return Math.max(shapeMargin(barSpacing), 10 /* Constants.MinBarGap */);
+    }
     function calculateAdjustedMargin(margin, hasSide, hasInBar) {
         if (hasSide) {
             return margin;
@@ -15313,17 +15316,18 @@
             }
             let prevTimeIndex = NaN;
             const shapeMargin$1 = shapeMargin(timeScale.options().barSpacing);
+            const barGap$1 = barGap(timeScale.options().barSpacing);
             const offsets = {
-                _internal_aboveBar: shapeMargin$1,
-                _internal_belowBar: shapeMargin$1,
+                _internal_aboveBar: barGap$1,
+                _internal_belowBar: barGap$1,
             };
             this._private__data._internal_visibleRange = visibleTimedValues(this._private__data._internal_items, visibleBarsRange, true);
             for (let index = this._private__data._internal_visibleRange.from; index < this._private__data._internal_visibleRange.to; index++) {
                 const marker = seriesMarkers[index];
                 if (marker.time !== prevTimeIndex) {
                     // new bar, reset stack counter
-                    offsets._internal_aboveBar = shapeMargin$1;
-                    offsets._internal_belowBar = shapeMargin$1;
+                    offsets._internal_aboveBar = barGap$1;
+                    offsets._internal_belowBar = barGap$1;
                     prevTimeIndex = marker.time;
                 }
                 const rendererItem = this._private__data._internal_items[index];
@@ -15440,7 +15444,7 @@
                 this._private__cachedBarSpacing = barSpacing;
                 if (this._private__markers.length > 0) {
                     const shapeMargin$1 = shapeMargin(barSpacing);
-                    const marginValue = calculateShapeHeight(barSpacing) * 1.5 + shapeMargin$1 * 2;
+                    const marginValue = calculateShapeHeight(barSpacing) * 1.5 + shapeMargin$1 + barGap(barSpacing);
                     const positions = this._private__getMarkerPositions();
                     this._private__autoScaleMargins = {
                         above: calculateAdjustedMargin(marginValue, positions.aboveBar, positions.inBar),
@@ -17943,10 +17947,13 @@
         const blankSource = (blank) => {
             if (blank && restoreSourcePaint === null) {
                 restoreSourcePaint = hideSeriesPaint(series);
+                // Under the blank source, so what hangs off it draws over the candles.
+                haSeries.setSeriesOrder(series.seriesOrder());
             }
             else if (!blank && restoreSourcePaint !== null) {
                 restoreSourcePaint();
                 restoreSourcePaint = null;
+                haSeries.setSeriesOrder(series.seriesOrder() + 1);
             }
         };
         const runtime = bindIndicator({
@@ -17975,8 +17982,9 @@
                 blankSource(current.hideSource === true);
             },
         });
-        const handle = {
-            _internal_series: haSeries,
+        // Returned as a literal: a local annotation would let the property renamer mangle `series`.
+        return {
+            series: haSeries,
             options: runtime.options,
             applyOptions: runtime.applyOptions,
             recalculate: runtime.recalculate,
@@ -17992,7 +18000,6 @@
                 }
             },
         };
-        return handle;
     }
 
     /**
@@ -21644,6 +21651,13 @@
         series() {
             return this._series;
         }
+        /**
+         * Box the selection toolbar anchors to, in pane pixels. Null falls back to
+         * the serialized points, which cannot place a line across the whole pane.
+         */
+        selectionBox() {
+            return null;
+        }
         getState() {
             return this._state;
         }
@@ -22320,6 +22334,53 @@
         return new TrendLineTool(context, options);
     }
 
+    const END_HANDLE_MARGIN = 10;
+    /**
+     * Hands the next `clicks` clicks on the chart to `onClick`, past the last bar
+     * too. A press that grabbed another drawing does not count.
+     */
+    function placeByClicks(chart, series, clicks, onClick) {
+        let placed = 0;
+        let handler = null;
+        const stop = () => {
+            if (handler !== null) {
+                chart.unsubscribeClick(handler);
+                handler = null;
+            }
+        };
+        handler = (param) => {
+            if (!param.point || consumeInputClaim(chart)) {
+                return;
+            }
+            const price = series.coordinateToPrice(param.point.y);
+            const time = timeFromCoordinate(chart, series, param.point.x);
+            if (price === null || time === null) {
+                return;
+            }
+            placed++;
+            if (placed >= clicks) {
+                stop();
+            }
+            onClick({ _internal_time: time, _internal_price: price, _internal_x: param.point.x, _internal_y: param.point.y }, placed - 1);
+        };
+        chart.subscribeClick(handler);
+        return {
+            _internal_pending: () => handler !== null,
+            _internal_stop: stop,
+        };
+    }
+    /** A fifth of the pane, and never less than a bar. */
+    function defaultWidth(chart) {
+        const timeScale = chart.timeScale();
+        return Math.max(timeScale.width() / 5, timeScale.options().barSpacing);
+    }
+    /** Kept inside the pane: past it, the handles on the end hide under the price axis. */
+    function placedEndX(chart, x) {
+        const timeScale = chart.timeScale();
+        const onScreen = Math.min(x + defaultWidth(chart), timeScale.width() - END_HANDLE_MARGIN);
+        return Math.max(onScreen, x + timeScale.options().barSpacing);
+    }
+
     class HorizontalLinePaneRenderer {
         constructor(tool) {
             this._private__tool = tool;
@@ -22360,6 +22421,7 @@
             this._private__isDragging = false;
             this._private__grab = null;
             this._private__moveStartPrice = 0;
+            this._private__placement = null;
             this._private__hLineOptions = {
                 lineColor: '#2962ff',
                 lineWidth: 2,
@@ -22372,6 +22434,26 @@
             };
             this._registerOptions(this._private__hLineOptions);
             this._private__createPrimitive();
+            if (this._private__hLineOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 1, (point) => this._private__placeAt(point));
+            }
+        }
+        _private__placeAt(point) {
+            this._private__hLineOptions.price = point._internal_price;
+            if (this._private__hLineOptions.startTime !== undefined) {
+                this._private__hLineOptions.startTime = point._internal_time;
+            }
+            this._private__requestUpdate();
+        }
+        isComplete() {
+            return !this._private__placement?._internal_pending();
+        }
+        selectionBox() {
+            const y = this._private__hLineOptions.price === undefined ? null : this._series.priceToCoordinate(this._private__hLineOptions.price);
+            if (y === null) {
+                return null;
+            }
+            return { left: this._private__startX(), right: this._chart.timeScale().width(), top: y, bottom: y };
         }
         _private__createPrimitive() {
             this._private__paneView = this._private__createPaneView();
@@ -22409,7 +22491,7 @@
             return coordinateFromTime(this._chart, this._series, this._private__hLineOptions.startTime) ?? 0;
         }
         drawToCanvas(ctx, horizontalPixelRatio, verticalPixelRatio) {
-            if (this._private__hLineOptions.price === undefined)
+            if (!this.isComplete() || this._private__hLineOptions.price === undefined)
                 return;
             const y = (this._series.priceToCoordinate(this._private__hLineOptions.price) ?? 0) * verticalPixelRatio;
             const chartWidth = this._chart.chartElement().clientWidth * horizontalPixelRatio;
@@ -22503,7 +22585,7 @@
             return this.hitTest(x, y) ? toolHoveredItem(this.id, 'body', false) : null;
         }
         hitTest(x, y) {
-            if (this._private__hLineOptions.price === undefined) {
+            if (!this.isComplete() || this._private__hLineOptions.price === undefined) {
                 return false;
             }
             const lineY = this._series.priceToCoordinate(this._private__hLineOptions.price) ?? 0;
@@ -22578,6 +22660,7 @@
             this._private__requestUpdate();
         }
         remove() {
+            this._private__placement?._internal_stop();
             if (this._private__primitive) {
                 this._series.detachPrimitive(this._private__primitive);
                 this._private__primitive = null;
@@ -22637,6 +22720,7 @@
             this._private__grab = null;
             this._private__moveStartTime = 0;
             this._private__moveStartPrice = 0;
+            this._private__placement = null;
             this._private__crossOptions = {
                 lineColor: '#787b86',
                 lineWidth: 1,
@@ -22646,6 +22730,16 @@
             };
             this._registerOptions(this._private__crossOptions);
             this._private__createPrimitive();
+            if (this._private__crossOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 1, (point) => {
+                    this._private__crossOptions.time = point._internal_time;
+                    this._private__crossOptions.price = point._internal_price;
+                    this._private__requestUpdate();
+                });
+            }
+        }
+        isComplete() {
+            return !this._private__placement?._internal_pending();
         }
         _private__createPrimitive() {
             this._private__paneView = new CrossLinePaneView(this);
@@ -22673,7 +22767,7 @@
             this._private__requestUpdate();
         }
         _private__coordinates() {
-            if (this._private__crossOptions.time === undefined || this._private__crossOptions.price === undefined) {
+            if (!this.isComplete() || this._private__crossOptions.time === undefined || this._private__crossOptions.price === undefined) {
                 return null;
             }
             const x = coordinateFromTime(this._chart, this._series, this._private__crossOptions.time);
@@ -22796,6 +22890,7 @@
             return this._private__isHovered;
         }
         remove() {
+            this._private__placement?._internal_stop();
             if (this._private__primitive) {
                 try {
                     this._series.detachPrimitive(this._private__primitive);
@@ -24218,6 +24313,7 @@
             this._private__isDragging = false;
             this._private__grab = null;
             this._private__moveStartTime = 0;
+            this._private__placement = null;
             this._private__vLineOptions = {
                 lineColor: '#787b86',
                 lineWidth: 1,
@@ -24229,6 +24325,29 @@
             };
             this._registerOptions(this._private__vLineOptions);
             this._private__createPrimitive();
+            if (this._private__vLineOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 1, (point) => {
+                    this._private__vLineOptions.time = point._internal_time;
+                    this._private__requestUpdate();
+                });
+            }
+        }
+        isComplete() {
+            return !this._private__placement?._internal_pending();
+        }
+        selectionBox() {
+            const x = coordinateFromTime(this._chart, this._series, this._private__vLineOptions.time);
+            if (x === null) {
+                return null;
+            }
+            let middle;
+            try {
+                middle = this._series.getPane().getHeight() / 2;
+            }
+            catch (error) {
+                return null;
+            }
+            return { left: x, right: x, top: middle, bottom: middle };
         }
         _private__createPrimitive() {
             this._private__paneView = this._private__createPaneView();
@@ -24259,7 +24378,7 @@
             return new VerticalLinePaneView(this);
         }
         drawToCanvas(ctx, horizontalPixelRatio, verticalPixelRatio) {
-            if (this._private__vLineOptions.time === undefined)
+            if (!this.isComplete() || this._private__vLineOptions.time === undefined)
                 return;
             const x = (coordinateFromTime(this._chart, this._series, this._private__vLineOptions.time) ?? 0) * horizontalPixelRatio;
             const chartHeight = this._chart.chartElement().clientHeight * verticalPixelRatio;
@@ -24346,7 +24465,7 @@
             return this.hitTest(x, y) ? toolHoveredItem(this.id, 'body', false) : null;
         }
         hitTest(x, y) {
-            if (this._private__vLineOptions.time === undefined) {
+            if (!this.isComplete() || this._private__vLineOptions.time === undefined) {
                 return false;
             }
             const lineX = coordinateFromTime(this._chart, this._series, this._private__vLineOptions.time) ?? 0;
@@ -24416,6 +24535,7 @@
             this._private__requestUpdate();
         }
         remove() {
+            this._private__placement?._internal_stop();
             if (this._private__primitive) {
                 this._series.detachPrimitive(this._private__primitive);
                 this._private__primitive = null;
@@ -25137,6 +25257,7 @@
             this._private__isHovered = false;
             this._private__isDragging = false;
             this._private__dragTarget = null;
+            this._private__placement = null;
             this._private__fibOptions = {
                 levels: [
                     { level: 0, color: '#787B86', label: '0%' },
@@ -25152,6 +25273,20 @@
                 ...options,
             };
             this._private__createPrimitive();
+            if (this._private__fibOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 3, (point, index) => {
+                    const placed = { time: point._internal_time, price: point._internal_price };
+                    if (index === 0) {
+                        this.setPoint1(placed);
+                    }
+                    else if (index === 1) {
+                        this.setPoint2(placed);
+                    }
+                    else {
+                        this.setPoint3(placed);
+                    }
+                });
+            }
         }
         _private__createPrimitive() {
             this._private__paneView = this._private__createPaneView();
@@ -25209,7 +25344,7 @@
             this._private__requestUpdate();
         }
         isComplete() {
-            return !!(this._private__fibOptions.point1 && this._private__fibOptions.point2 && this._private__fibOptions.point3);
+            return !this._private__placement?._internal_pending() && !!(this._private__fibOptions.point1 && this._private__fibOptions.point2 && this._private__fibOptions.point3);
         }
         setColor(color) {
             this._private__fibOptions.lineColor = color;
@@ -25504,6 +25639,7 @@
             this._private__requestUpdate();
         }
         remove() {
+            this._private__placement?._internal_stop();
             if (this._private__primitive) {
                 this._series.detachPrimitive(this._private__primitive);
                 this._private__primitive = null;
@@ -28069,6 +28205,7 @@
             this._private__moveStart = null;
             this._private__isEditing = false;
             this._private__clickOutsideHandler = null;
+            this._private__placement = null;
             this._private__textOptions = {
                 text: 'Double-click to edit',
                 fontSize: 14,
@@ -28089,6 +28226,14 @@
             this._registerOptions(this._private__textOptions);
             this._private__createPrimitive();
             this._private__setupClickOutsideHandler();
+            if (this._private__textOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 1, (point) => {
+                    this.setPosition(point._internal_time, point._internal_price);
+                    if (this._private__textOptions.onComplete) {
+                        this._private__textOptions.onComplete();
+                    }
+                });
+            }
         }
         _private__setupClickOutsideHandler() {
             // Set up click handler to finish editing when clicking outside
@@ -28174,7 +28319,7 @@
             this._private__requestUpdate();
         }
         isComplete() {
-            return !!(this._private__textOptions.time && this._private__textOptions.price !== undefined);
+            return !this._private__placement?._internal_pending() && !!(this._private__textOptions.time && this._private__textOptions.price !== undefined);
         }
         setColor(color) {
             this._private__textOptions.textColor = color;
@@ -28457,6 +28602,7 @@
             };
         }
         remove() {
+            this._private__placement?._internal_stop();
             // Clean up click handler
             if (this._private__clickOutsideHandler) {
                 this._chart.unsubscribeClick(this._private__clickOutsideHandler);
@@ -29315,6 +29461,7 @@
             this._private__paneView = null;
             this._private__isSelected = false;
             this._private__isHovered = false;
+            this._private__placement = null;
             this._private__isDragging = false;
             this._private__dragTarget = null;
             this._private__grab = null;
@@ -29337,6 +29484,32 @@
             // Create primitive and setup
             this._private__createPrimitive();
             this._private__updateMetrics();
+            if (this._private__positionOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 1, (point) => this._private__placeAt(point));
+            }
+        }
+        _private__placeAt(point) {
+            const options = this._private__positionOptions;
+            const shift = point._internal_price - options.entryPrice;
+            options.entryPrice = point._internal_price;
+            options.entryTime = point._internal_time;
+            if (options.stopLoss !== undefined) {
+                options.stopLoss += shift;
+            }
+            if (options.takeProfit !== undefined) {
+                options.takeProfit += shift;
+            }
+            options.endTime = timeFromCoordinate(this._chart, this._series, placedEndX(this._chart, point._internal_x)) ?? undefined;
+            this._private__updateMetrics();
+            this._private__requestUpdate();
+        }
+        isComplete() {
+            return !this._private__placement?._internal_pending();
+        }
+        _private__span() {
+            const entryX = coordinateFromTime(this._chart, this._series, this._private__positionOptions.entryTime) ?? 0;
+            const endX = coordinateFromTime(this._chart, this._series, this._private__positionOptions.endTime) ?? entryX + defaultWidth(this._chart);
+            return { _internal_entryX: entryX, _internal_endX: endX };
         }
         _private__createPrimitive() {
             // Create and cache the paneView once
@@ -29368,6 +29541,9 @@
             return new PositionPaneView(this);
         }
         drawToCanvas(ctx, horizontalPixelRatio, verticalPixelRatio) {
+            if (!this.isComplete()) {
+                return;
+            }
             // Draw profit rectangle (green)
             if (this._private__profitRect && this._private__positionOptions.takeProfit) {
                 const timeScale = this._chart.timeScale();
@@ -29401,16 +29577,9 @@
             }
         }
         _private__drawRectangle(ctx, rect, horizontalPixelRatio, verticalPixelRatio, timeScale) {
-            const entryX = (coordinateFromTime(this._chart, this._series, this._private__positionOptions.entryTime) ?? 0) * horizontalPixelRatio;
-            // Use endTime if specified, otherwise extend to chart edge
-            let endX;
-            if (this._private__positionOptions.endTime) {
-                endX = (coordinateFromTime(this._chart, this._series, this._private__positionOptions.endTime) ?? 0) * horizontalPixelRatio;
-            }
-            else {
-                const chartWidth = this._chart.chartElement().clientWidth * horizontalPixelRatio;
-                endX = chartWidth;
-            }
+            const span = this._private__span();
+            const entryX = span._internal_entryX * horizontalPixelRatio;
+            const endX = span._internal_endX * horizontalPixelRatio;
             const y1 = (this._series.priceToCoordinate(rect._internal_price1) ?? 0) * verticalPixelRatio;
             const y2 = (this._series.priceToCoordinate(rect._internal_price2) ?? 0) * verticalPixelRatio;
             // Draw filled rectangle with semi-transparent fill
@@ -29425,16 +29594,10 @@
             ctx.stroke();
         }
         _private__drawEntryLine(ctx, horizontalPixelRatio, verticalPixelRatio, timeScale) {
-            const entryX = (coordinateFromTime(this._chart, this._series, this._private__positionOptions.entryTime) ?? 0) * horizontalPixelRatio;
+            const span = this._private__span();
+            const entryX = span._internal_entryX * horizontalPixelRatio;
+            const endX = span._internal_endX * horizontalPixelRatio;
             const entryY = (this._series.priceToCoordinate(this._private__positionOptions.entryPrice) ?? 0) * verticalPixelRatio;
-            let endX;
-            if (this._private__positionOptions.endTime) {
-                endX = (coordinateFromTime(this._chart, this._series, this._private__positionOptions.endTime) ?? 0) * horizontalPixelRatio;
-            }
-            else {
-                const chartWidth = this._chart.chartElement().clientWidth * horizontalPixelRatio;
-                endX = chartWidth;
-            }
             // Draw horizontal entry line (divider)
             const lineColor = this._private__positionOptions.entryLineColor;
             ctx.strokeStyle = lineColor;
@@ -29548,9 +29711,11 @@
             const padding = 6 * horizontalPixelRatio;
             const labelWidth = textMetrics.width + padding * 2;
             const labelHeight = 20 * horizontalPixelRatio;
-            // Position label at the start of the line
+            // Outside the box, so a label wider than it does not cover the handles on its edge
+            const entryY = (this._series.priceToCoordinate(this._private__positionOptions.entryPrice) ?? 0) * verticalPixelRatio;
+            const gap = 3 * verticalPixelRatio;
             const labelX = entryX + 8 * horizontalPixelRatio;
-            const labelY = y - labelHeight / 2;
+            const labelY = y <= entryY ? y - labelHeight - gap : y + gap;
             // Draw label background
             ctx.fillStyle = rect._internal_color;
             ctx.fillRect(labelX, labelY, labelWidth, labelHeight);
@@ -29558,10 +29723,12 @@
             ctx.fillStyle = '#ffffff';
             ctx.textAlign = 'left';
             ctx.textBaseline = 'middle';
-            ctx.fillText(labelText, labelX + padding, y);
+            ctx.fillText(labelText, labelX + padding, labelY + labelHeight / 2);
         }
         _private__drawEndpoint(ctx, price, color, horizontalPixelRatio, verticalPixelRatio, timeScale) {
-            const entryX = (coordinateFromTime(this._chart, this._series, this._private__positionOptions.entryTime) ?? 0) * horizontalPixelRatio;
+            const span = this._private__span();
+            const entryX = span._internal_entryX * horizontalPixelRatio;
+            const endX = span._internal_endX * horizontalPixelRatio;
             const y = (this._series.priceToCoordinate(price) ?? 0) * verticalPixelRatio;
             // Draw circle endpoint at entry
             const circleColor = color;
@@ -29573,14 +29740,6 @@
             ctx.fill();
             ctx.stroke();
             // Draw square endpoint at the right edge
-            let endX;
-            if (this._private__positionOptions.endTime) {
-                endX = (coordinateFromTime(this._chart, this._series, this._private__positionOptions.endTime) ?? 0) * horizontalPixelRatio;
-            }
-            else {
-                const chartWidth = this._chart.chartElement().clientWidth * horizontalPixelRatio;
-                endX = chartWidth - 10 * horizontalPixelRatio;
-            }
             const size = 8 * horizontalPixelRatio;
             const squareColor = color;
             ctx.fillStyle = squareColor;
@@ -29701,18 +29860,12 @@
             return this.hitTest(x, y) ? toolHoveredItem(this.id, 'body', false) : null;
         }
         hitTest(x, y) {
-            if (!this._private__positionOptions.stopLoss && !this._private__positionOptions.takeProfit) {
+            if (!this.isComplete() || (!this._private__positionOptions.stopLoss && !this._private__positionOptions.takeProfit)) {
                 return false;
             }
-            const entryX = coordinateFromTime(this._chart, this._series, this._private__positionOptions.entryTime) ?? 0;
-            let endX;
-            if (this._private__positionOptions.endTime) {
-                endX = coordinateFromTime(this._chart, this._series, this._private__positionOptions.endTime) ?? 0;
-            }
-            else {
-                const chartWidth = this._chart.chartElement().clientWidth;
-                endX = chartWidth;
-            }
+            const { _internal_entryX: entryX, _internal_endX: endX } = this._private__span();
+            const left = Math.min(entryX, endX);
+            const right = Math.max(entryX, endX);
             // Check if inside the entire Position Tool area (rectangles)
             if (this._private__positionOptions.takeProfit && this._private__positionOptions.stopLoss) {
                 const tpY = this._series.priceToCoordinate(this._private__positionOptions.takeProfit) ?? 0;
@@ -29720,7 +29873,7 @@
                 const minY = Math.min(tpY, slY);
                 const maxY = Math.max(tpY, slY);
                 // Check if inside the rectangle bounds (entire tool area)
-                if (x >= entryX && x <= endX && y >= minY && y <= maxY) {
+                if (x >= left && x <= right && y >= minY && y <= maxY) {
                     return true;
                 }
                 // Also check entry line area
@@ -29732,15 +29885,12 @@
             return false;
         }
         hitTestEndpoint(x, y) {
-            const entryX = coordinateFromTime(this._chart, this._series, this._private__positionOptions.entryTime) ?? 0;
-            let endX;
-            if (this._private__positionOptions.endTime) {
-                endX = coordinateFromTime(this._chart, this._series, this._private__positionOptions.endTime) ?? 0;
-            }
-            else {
-                const chartWidth = this._chart.chartElement().clientWidth;
-                endX = chartWidth;
+            if (!this.isComplete()) {
+                return null;
             }
+            const { _internal_entryX: entryX, _internal_endX: endX } = this._private__span();
+            const left = Math.min(entryX, endX);
+            const right = Math.max(entryX, endX);
             const tolerance = 10;
             // Check TP left endpoint (circle)
             if (this._private__positionOptions.takeProfit) {
@@ -29777,7 +29927,7 @@
             // Check entry line (middle divider line) - higher priority than 'move'
             const entryY = this._series.priceToCoordinate(this._private__positionOptions.entryPrice) ?? 0;
             const lineTolerance = 8;
-            if (x >= entryX && x <= endX && Math.abs(y - entryY) <= lineTolerance) {
+            if (x >= left && x <= right && Math.abs(y - entryY) <= lineTolerance) {
                 return 'entry';
             }
             // Check if clicking on the body (rectangles) for moving entire tool
@@ -29787,7 +29937,7 @@
                 const minY = Math.min(tpY, slY);
                 const maxY = Math.max(tpY, slY);
                 // Check if inside the rectangle bounds
-                if (x >= entryX && x <= endX && y >= minY && y <= maxY) {
+                if (x >= left && x <= right && y >= minY && y <= maxY) {
                     return 'move';
                 }
             }
@@ -29887,6 +30037,7 @@
             this._private__requestUpdate();
         }
         remove() {
+            this._private__placement?._internal_stop();
             if (this._private__primitive) {
                 this._series.detachPrimitive(this._private__primitive);
                 this._private__primitive = null;
@@ -29933,6 +30084,7 @@
         }
     }
 
+    const TOP_PADDING = 50;
     class GanttTool extends DrawingToolBase {
         constructor(context, options) {
             super(context, 'gantt', options);
@@ -29946,6 +30098,7 @@
             this._private__grab = null;
             this._private__moveStart = null;
             this._private__hoveredSegmentIndex = -1;
+            this._private__placement = null;
             this._private__ganttOptions = {
                 segments: [],
                 rowHeight: 40,
@@ -29958,6 +30111,43 @@
             };
             this._registerOptions(this._private__ganttOptions);
             this._private__createPrimitive();
+            if (this._private__ganttOptions.interactive) {
+                this._private__placement = placeByClicks(this._chart, this._series, 1, (point) => this._private__placeAt(point));
+            }
+        }
+        _private__placeAt(point) {
+            const segments = this._private__ganttOptions.segments ?? [];
+            const endTime = timeFromCoordinate(this._chart, this._series, placedEndX(this._chart, point._internal_x)) ?? point._internal_time;
+            const rowPitch = this._private__ganttOptions.rowHeight + this._private__ganttOptions.rowSpacing;
+            const row = Math.max(0, Math.floor((point._internal_y - TOP_PADDING) / rowPitch));
+            const shift = segments.length > 0 ? row - segments[0].level : 0;
+            for (const segment of segments) {
+                segment.startTime = point._internal_time;
+                segment.endTime = endTime;
+                segment.level = Math.max(0, segment.level + shift);
+            }
+            this._private__requestUpdate();
+        }
+        isComplete() {
+            return !this._private__placement?._internal_pending();
+        }
+        selectionBox() {
+            const segments = this._private__ganttOptions.segments ?? [];
+            if (segments.length === 0) {
+                return null;
+            }
+            const rowHeight = this._private__ganttOptions.rowHeight;
+            const pitch = rowHeight + this._private__ganttOptions.rowSpacing;
+            // Typed as the public shape: an inferred one gets its keys renamed by the build
+            const box = { left: Infinity, top: Infinity, right: -Infinity, bottom: -Infinity };
+            for (const segment of segments) {
+                const top = TOP_PADDING + segment.level * pitch;
+                box.left = Math.min(box.left, coordinateFromTime(this._chart, this._series, segment.startTime) ?? 0);
+                box.right = Math.max(box.right, coordinateFromTime(this._chart, this._series, segment.endTime) ?? 0);
+                box.top = Math.min(box.top, top);
+                box.bottom = Math.max(box.bottom, top + rowHeight);
+            }
+            return box;
         }
         _private__createPrimitive() {
             this._private__paneView = this._private__createPaneView();
@@ -29988,11 +30178,10 @@
             return new GanttPaneView(this);
         }
         drawToCanvas(ctx, horizontalPixelRatio, verticalPixelRatio) {
-            if (!this._private__ganttOptions.segments || this._private__ganttOptions.segments.length === 0)
+            if (!this.isComplete() || !this._private__ganttOptions.segments || this._private__ganttOptions.segments.length === 0)
                 return;
             // Position gantt at top of chart with padding
-            const topPadding = 50; // pixels from top
-            const baseY = topPadding * verticalPixelRatio;
+            const baseY = TOP_PADDING * verticalPixelRatio;
             const rowHeight = this._private__ganttOptions.rowHeight * verticalPixelRatio;
             const rowSpacing = this._private__ganttOptions.rowSpacing * verticalPixelRatio;
             // Draw grid lines if enabled
@@ -30171,11 +30360,10 @@
             this._private__moveStart = null;
         }
         hitTest(x, y) {
-            if (!this._private__ganttOptions.segments || this._private__ganttOptions.segments.length === 0) {
+            if (!this.isComplete() || !this._private__ganttOptions.segments || this._private__ganttOptions.segments.length === 0) {
                 return false;
             }
-            const topPadding = 50;
-            const baseY = topPadding;
+            const baseY = TOP_PADDING;
             const rowHeight = this._private__ganttOptions.rowHeight;
             const rowSpacing = this._private__ganttOptions.rowSpacing;
             // Check each segment
@@ -30229,6 +30417,7 @@
             this._private__requestUpdate();
         }
         remove() {
+            this._private__placement?._internal_stop();
             if (this._private__primitive) {
                 this._series.detachPrimitive(this._private__primitive);
                 this._private__primitive = null;
@@ -30364,6 +30553,7 @@
             }
             this._private__completionCheck = setTimeout(() => {
                 this._private__completionCheck = null;
+                const completed = [];
                 for (const id of Array.from(this._private__pendingToolIds)) {
                     const tool = this._private__tools.get(id);
                     if (!tool) {
@@ -30372,9 +30562,15 @@
                     }
                     if (tool.isComplete()) {
                         this._private__pendingToolIds.delete(id);
-                        this._private__drawingCompleted._internal_fire(id);
+                        completed.push(id);
                     }
                 }
+                if (completed.length > 0) {
+                    this.recordChange();
+                }
+                for (const id of completed) {
+                    this._private__drawingCompleted._internal_fire(id);
+                }
             }, 0);
         }
         /**
@@ -30434,12 +30630,16 @@
             if (this._private__restoring) {
                 return;
             }
+            const next = this.serializeAll();
+            if (JSON.stringify(next) === JSON.stringify(this._private__committed)) {
+                return;
+            }
             this._private__past.push(this._private__committed);
             if (this._private__past.length > UNDO_HISTORY_LIMIT) {
                 this._private__past.shift();
             }
             this._private__future = [];
-            this._private__committed = this.serializeAll();
+            this._private__committed = next;
         }
         canUndo() {
             return this._private__past.length > 0;
@@ -30495,11 +30695,25 @@
             const tool = this._private__tools.get(this._private__selectedToolId);
             return tool ? this._private__boundsOf(tool) : null;
         }
+        /** Relative to the chart element; the tool's box is relative to its pane. */
+        _private__boundsOf(tool) {
+            const box = tool.selectionBox() ?? this._private__boxFromPoints(tool);
+            if (box === null) {
+                return null;
+            }
+            const offset = this._private__paneOffsetOf(tool);
+            return {
+                left: box.left + offset._internal_x,
+                right: box.right + offset._internal_x,
+                top: box.top + offset._internal_y,
+                bottom: box.bottom + offset._internal_y,
+            };
+        }
         /**
          * Bounds come from the tool's own serialized points, so this works for every
          * tool without each one having to report a box.
          */
-        _private__boundsOf(tool) {
+        _private__boxFromPoints(tool) {
             const series = tool.series();
             const points = tool.serialize().points;
             let left = Number.POSITIVE_INFINITY;
@@ -30522,13 +30736,7 @@
             if (!found) {
                 return null;
             }
-            const offset = this._private__paneOffsetOf(tool);
-            return {
-                left: left + offset._internal_x,
-                right: right + offset._internal_x,
-                top: top + offset._internal_y,
-                bottom: bottom + offset._internal_y,
-            };
+            return { left, top, right, bottom };
         }
         /** Panes below the first one are offset inside the chart element. */
         _private__paneOffsetOf(tool) {
@@ -30612,7 +30820,10 @@
         serializeAll() {
             const result = [];
             for (const tool of this._private__tools.values()) {
-                result.push(tool.serialize());
+                // Not drawn yet: undo would bring it back as a finished drawing
+                if (tool.isComplete()) {
+                    result.push(tool.serialize());
+                }
             }
             return result;
         }
@@ -31237,7 +31448,7 @@
      * Returns the current version as a string. For example `'1.0.0'`.
      */
     function version() {
-        return "2.3.13-dev+202609280001";
+        return "2.3.15";
     }
 
     var PipsendChartsModule = /*#__PURE__*/Object.freeze({