@pipsend/charts 2.3.1 → 2.3.3

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

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.1
+ * Pipsend Charts v2.3.3
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -2485,6 +2485,22 @@
             // Used to avoid binary search if bars are already known
             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.
+         */
+        _internal_barStyleOrNull(barIndex, precomputedBars) {
+            if (precomputedBars === undefined && this._private__series._internal_bars()._internal_valueAt(barIndex) === null) {
+                return null;
+            }
+            return this._internal_barStyle(barIndex, precomputedBars);
+        }
     }
 
     /**
@@ -11428,10 +11444,14 @@
             return this._internal__itemsVisibleRange === null ? null : this._internal__renderer;
         }
         _internal__updateOptions() {
-            this._internal__items = this._internal__items.map((item) => ({
-                ...item,
-                ...this._internal__series._internal_barColorer()._internal_barStyle(item._internal_time),
-            }));
+            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 };
+            });
         }
         _internal__clearVisibleRange() {
             this._internal__itemsVisibleRange = null;
@@ -15860,9 +15880,6 @@
         return wrapper;
     }
 
-    /**
-     * Gestor de marcadores de posiciones de trading
-     */
     class PositionMarkersManager {
         constructor(series, options) {
             this._private__markersPlugin = null;
@@ -15882,30 +15899,20 @@
             };
             this._private__markersPlugin = createSeriesMarkers(series);
         }
-        /**
-         * Agrega una posición al gráfico
-         */
         addPosition(position) {
             this._private__positions.push(position);
             this._private__updateMarkers();
         }
-        /**
-         * Agrega múltiples posiciones al gráfico
-         */
         addPositions(positions) {
             this._private__positions.push(...positions);
             this._private__updateMarkers();
         }
-        /**
-         * Establece las posiciones (reemplaza las existentes)
-         */
+        /** Replaces every position currently on the chart. */
         setPositions(positions) {
             this._private__positions = [...positions];
             this._private__updateMarkers();
         }
-        /**
-         * Cierra una posición abierta agregando el punto de salida
-         */
+        /** Closes an open position by giving it an exit point. */
         closePosition(id, exit, exitText) {
             const position = this._private__positions.find(p => p.id === id);
             if (position) {
@@ -15919,29 +15926,17 @@
                 this._private__updateMarkers();
             }
         }
-        /**
-         * Elimina una posición por ID
-         */
         removePosition(id) {
             this._private__positions = this._private__positions.filter(p => p.id !== id);
             this._private__updateMarkers();
         }
-        /**
-         * Limpia todas las posiciones
-         */
         clearPositions() {
             this._private__positions = [];
             this._private__updateMarkers();
         }
-        /**
-         * Obtiene todas las posiciones actuales
-         */
         getPositions() {
             return this._private__positions;
         }
-        /**
-         * Actualiza las opciones del gestor
-         */
         applyOptions(options) {
             if (options.longColors) {
                 this._private__options.longColors = {
@@ -15966,9 +15961,6 @@
             }
             this._private__updateMarkers();
         }
-        /**
-         * Convierte las posiciones a marcadores de serie
-         */
         _private__positionsToMarkers() {
             const markers = [];
             for (const position of this._private__positions) {
@@ -16015,18 +16007,12 @@
             }
             return markers;
         }
-        /**
-         * Actualiza los marcadores en el gráfico
-         */
         _private__updateMarkers() {
             if (this._private__markersPlugin) {
                 const markers = this._private__positionsToMarkers();
                 this._private__markersPlugin.setMarkers(markers);
             }
         }
-        /**
-         * Desconecta el plugin y limpia recursos
-         */
         detach() {
             if (this._private__markersPlugin) {
                 this._private__markersPlugin.detach();
@@ -16036,47 +16022,18 @@
         }
     }
     /**
-     * Crea un gestor de marcadores de posiciones de trading
-     *
-     * @param series - Serie a la que se adjuntarán los marcadores
-     * @param positions - Posiciones iniciales (opcional)
-     * @param options - Opciones de configuración (opcional)
-     * @returns Instancia del gestor de posiciones
+     * Marks trades on a series with an arrow at the entry and, once closed, at the
+     * exit.
      *
      * @example
      * ```typescript
-     * // Crear el gestor
-     * const positionMarkers = createPositionMarkers(candleSeries);
-     *
-     * // Agregar una posición long
-     * positionMarkers.addPosition({
-     *   type: 'long',
-     *   entry: { time: '2023-01-01', price: 100.50 },
-     *   exit: { time: '2023-01-05', price: 105.20 },
-     *   id: 'pos-1'
-     * });
-     *
-     * // Agregar una posición short
-     * positionMarkers.addPosition({
-     *   type: 'short',
-     *   entry: { time: '2023-01-10', price: 110.00 },
-     *   exit: { time: '2023-01-15', price: 107.50 },
-     *   id: 'pos-2'
-     * });
-     *
-     * // Agregar múltiples posiciones
-     * positionMarkers.setPositions([
-     *   {
+     * const markers = createPositionMarkers(candleSeries);
+     * markers.addPosition({
      *     type: 'long',
-     *     entry: { time: '2023-02-01', price: 95.00 },
-     *     exit: { time: '2023-02-10', price: 98.50 }
-     *   },
-     *   {
-     *     type: 'short',
-     *     entry: { time: '2023-02-15', price: 102.00 },
-     *     exit: { time: '2023-02-20', price: 99.00 }
-     *   }
-     * ]);
+     *     entry: { time: '2023-01-01', price: 100.50 },
+     *     exit: { time: '2023-01-05', price: 105.20 },
+     *     id: 'pos-1',
+     * });
      * ```
      */
     function createPositionMarkers(series, positions, options) {
@@ -20327,9 +20284,6 @@
         return new DraggablePriceLine(chart, series, lineOptions);
     }
 
-    /**
-     * Interactive Line Manager - Permite crear líneas haciendo clic en el gráfico
-     */
     class InteractiveLineManager {
         constructor(chart, series) {
             this._private__container = null;
@@ -20358,10 +20312,9 @@
             return price === null ? 0 : price;
         }
         /**
-         * Activa el modo de creación de líneas por clic
-         * @param mode - Tipo de línea a crear
-         * @param customOptions - Opciones personalizadas para líneas custom
-         * @returns Promesa que se resuelve cuando el usuario hace clic
+         * Arms the chart so the next click drops a line.
+         *
+         * @returns The line, once the user has clicked.
          */
         enableClickToCreate(mode, customOptions) {
             if (!this._private__container) {
@@ -20382,9 +20335,6 @@
                 this._private__container.addEventListener('click', this._private__clickHandler);
             });
         }
-        /**
-         * Desactiva el modo de creación por clic
-         */
         disableClickToCreate() {
             if (this._private__container && this._private__clickHandler) {
                 this._private__container.removeEventListener('click', this._private__clickHandler);
@@ -20474,31 +20424,21 @@
             }
             return new DraggablePriceLine(this._private__chart, this._private__series, options);
         }
-        /**
-         * Obtiene el modo actual de creación
-         */
         getCreationMode() {
             return this._private__creationMode;
         }
-        /**
-         * Verifica si está en modo de creación
-         */
         isCreating() {
             return this._private__creationMode !== null;
         }
     }
     /**
-     * Crea un manager interactivo para añadir líneas con clics
-     * @param chart - Chart instance
-     * @param series - Series instance
-     * @returns InteractiveLineManager
+     * Lets the user place draggable lines by clicking the chart.
+     *
      * @example
      * ```typescript
      * const manager = createInteractiveLineManager(chart, candleSeries);
-     *
-     * // Activar modo de creación
      * const line = await manager.enableClickToCreate('stop-loss', {
-     *     onDragEnd: (price) => console.log('SL:', price)
+     *     onDragEnd: (price) => console.log('SL:', price),
      * });
      * ```
      */
@@ -24361,9 +24301,6 @@
         return new VerticalLineTool(context, options);
     }
 
-    /**
-     * Fibonacci Calculator - Cálculos de niveles de retroceso de Fibonacci
-     */
     /**
      * Standard Fibonacci retracement ratios
      */
@@ -24509,10 +24446,7 @@
         }
     }
 
-    /**
-     * Fibonacci Retracement Tool - Herramienta para dibujar niveles de Fibonacci
-     * Muestra niveles estándar: 0%, 23.6%, 38.2%, 50%, 61.8%, 78.6%, 100%
-     */
+    /** Draws 0, 23.6, 38.2, 50, 61.8, 78.6 and 100% unless `levels` says otherwise. */
     /** A ratio and the label it is shown with, derived rather than stored. */
     function toRatio(ratio) {
         return { _internal_ratio: ratio, _internal_label: `${(ratio * 100).toFixed(1)}%` };
@@ -27586,7 +27520,7 @@
             if (this._private__isOverAnotherDrawing()) {
                 return;
             }
-            const point = this._private__toPanePoint(event);
+            const point = this._private__toPanePoint(event, false);
             if (point === null) {
                 return;
             }
@@ -27605,7 +27539,7 @@
             if (!this._private__isDrawing) {
                 return;
             }
-            const point = this._private__toPanePoint(event);
+            const point = this._private__toPanePoint(event, true);
             if (point === null) {
                 return;
             }
@@ -27676,13 +27610,51 @@
             }
             this._private__pointerId = null;
         }
-        _private__toPanePoint(event) {
+        /**
+         * Where a press lands relative to the drawing area, or null if it lands
+         * outside it. `clamp` pins the point to the edge instead, for a stroke that
+         * is already under way.
+         */
+        _private__toPanePoint(event, clamp) {
+            const area = this._private__drawArea();
+            if (area === null) {
+                return null;
+            }
+            const x = event.clientX - area._internal_left;
+            const y = event.clientY - area._internal_top;
+            if (clamp) {
+                return {
+                    _internal_x: Math.max(0, Math.min(area._internal_width, x)),
+                    _internal_y: Math.max(0, Math.min(area._internal_height, y)),
+                };
+            }
+            if (x < 0 || x > area._internal_width || y < 0 || y > area._internal_height) {
+                return null;
+            }
+            return { _internal_x: x, _internal_y: y };
+        }
+        /**
+         * The pane's element is the whole row, price axis cells included, so its
+         * bounds are not the drawing area's. Taking them for it is what let a press
+         * on an axis start a stroke — and be swallowed, leaving the chart unable to
+         * be stretched while the brush was armed.
+         */
+        _private__drawArea() {
             const paneElement = this._private__paneElement();
             if (paneElement === null) {
                 return null;
             }
             const rect = paneElement.getBoundingClientRect();
-            return { _internal_x: event.clientX - rect.left, _internal_y: event.clientY - rect.top };
+            let left = 0;
+            let width = rect.width;
+            // The time scale measures the drawing area; the left axis, when shown, is
+            // what stands between it and the row's edge.
+            const paneWidth = this._chart.timeScale().width();
+            if (paneWidth > 0) {
+                left = this._chart.priceScale('left').width();
+                width = paneWidth;
+            }
+            return { _internal_left: rect.left + left, _internal_top: rect.top, _internal_width: width, _internal_height: rect.height };
         }
         _private__paneElement() {
             try {
@@ -28305,9 +28277,6 @@
         return new TextTool(context, options);
     }
 
-    /**
-     * Position Calculator - Cálculos de P&L, pips, R:R para trading
-     */
     class PositionCalculator {
         constructor(pipConfig) {
             this._private__pipConfig = pipConfig;
@@ -28459,9 +28428,6 @@
         };
     }
 
-    /**
-     * Ruler Calculator - Cálculos de distancia, pips, tiempo para mediciones
-     */
     class RulerCalculator {
         constructor(pipConfig) {
             this._private__pipConfig = pipConfig;
@@ -28580,10 +28546,7 @@
         }
     }
 
-    /**
-     * Measurement Ruler Tool - Herramienta para medir distancia entre dos puntos
-     * Muestra pips, porcentaje, tiempo transcurrido y número de barras
-     */
+    /** Measures two points: pips, percent, elapsed time and bar count. */
     class RulerTool extends DrawingToolBase {
         constructor(context, options) {
             super(context, 'ruler-tool', options);
@@ -29143,10 +29106,7 @@
         }
     }
 
-    /**
-     * Position Tool - Herramienta unificada para marcar posiciones long/short
-     * Muestra dos rectángulos ajustables (profit/loss) con línea vertical conectora
-     */
+    /** Two adjustable boxes, profit and loss, joined by a vertical connector. */
     class PositionTool extends DrawingToolBase {
         constructor(context, options) {
             super(context, 'position-tool', options);
@@ -31041,7 +31001,7 @@
      * Returns the current version as a string. For example `'1.0.0'`.
      */
     function version() {
-        return "2.3.1";
+        return "2.3.3";
     }
 
     var PipsendChartsModule = /*#__PURE__*/Object.freeze({