@pipsend/charts 2.3.18 → 2.3.20

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

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.18-dev+202610170141
+ * Pipsend Charts v2.3.20-dev+202610211649
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -5555,7 +5555,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, (mark, barsPerMark) => this._private__horzScaleBehavior.allowsTickMark?.(mark, barsPerMark) ?? true);
+            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, this._private__points[mark.index - 1]) ?? 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"
@@ -6829,6 +6829,75 @@
         return localDateFromUtc.toLocaleString(locale, formatOptions);
     }
 
+    const DAY = 86400;
+    const QUARTER_HOUR = 900;
+    const zones = new Map();
+    function zoneCache(timeZone) {
+        let cache = zones.get(timeZone);
+        if (cache === undefined) {
+            let format = null;
+            try {
+                format = new Intl.DateTimeFormat('en-US', {
+                    timeZone,
+                    hourCycle: 'h23',
+                    year: 'numeric',
+                    month: 'numeric',
+                    day: 'numeric',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                });
+            }
+            catch (error) {
+                format = null;
+            }
+            cache = { _internal_format: format, _internal_days: new Map(), _internal_quarters: new Map() };
+            zones.set(timeZone, cache);
+        }
+        return cache;
+    }
+    function exactOffset(format, time) {
+        const parts = format.formatToParts(new Date(time * 1000));
+        const part = (type) => Number(parts.find((p) => p.type === type)?.value ?? 0);
+        const wallClock = Date.UTC(part('year'), part('month') - 1, part('day'), part('hour') % 24, part('minute'), part('second'));
+        return Math.round(wallClock / 1000 - time);
+    }
+    /**
+     * Offset of `timeZone` from UTC at `time`, in seconds. Undefined, `'UTC'` and
+     * unknown zones are 0.
+     *
+     * Resolved once per UTC day, and to the quarter hour only on days with a
+     * transition: asking `Intl` for every bar is too slow for a whole series.
+     */
+    function timeZoneOffset(timeZone, time) {
+        if (timeZone === undefined || timeZone === 'UTC') {
+            return 0;
+        }
+        const cache = zoneCache(timeZone);
+        const format = cache._internal_format;
+        if (format === null) {
+            return 0;
+        }
+        const day = Math.floor(time / DAY);
+        let wholeDay = cache._internal_days.get(day);
+        if (wholeDay === undefined) {
+            const start = exactOffset(format, day * DAY);
+            const end = exactOffset(format, (day + 1) * DAY - 1);
+            wholeDay = start === end ? start : null;
+            cache._internal_days.set(day, wholeDay);
+        }
+        if (wholeDay !== null) {
+            return wholeDay;
+        }
+        const quarter = Math.floor(time / QUARTER_HOUR);
+        let offset = cache._internal_quarters.get(quarter);
+        if (offset === undefined) {
+            offset = exactOffset(format, quarter * QUARTER_HOUR);
+            cache._internal_quarters.set(quarter, offset);
+        }
+        return offset;
+    }
+
     function hours(count) {
         return count * 60 * 60 * 1000;
     }
@@ -6868,29 +6937,36 @@
     function cast(t) {
         return t;
     }
-    function fillWeightsForPoints(sortedTimePoints, startIndex = 0) {
+    // Business days are dates, not instants: never shifted
+    function zonedTimestamp(point, timeZone) {
+        const time = cast(point.time);
+        return time._internal_businessDay === undefined ? time._internal_timestamp + timeZoneOffset(timeZone, time._internal_timestamp) : time._internal_timestamp;
+    }
+    function fillWeightsForPoints(sortedTimePoints, startIndex = 0, timeZone) {
         if (sortedTimePoints.length === 0) {
             return;
         }
-        let prevTime = startIndex === 0 ? null : cast(sortedTimePoints[startIndex - 1].time)._internal_timestamp;
+        let prevTime = startIndex === 0 ? null : zonedTimestamp(sortedTimePoints[startIndex - 1], timeZone);
         let prevDate = prevTime !== null ? new Date(prevTime * 1000) : null;
         let totalTimeDiff = 0;
         for (let index = startIndex; index < sortedTimePoints.length; ++index) {
             const currentPoint = sortedTimePoints[index];
-            const currentDate = new Date(cast(currentPoint.time)._internal_timestamp * 1000);
+            const currentTime = zonedTimestamp(currentPoint, timeZone);
+            const currentDate = new Date(currentTime * 1000);
             if (prevDate !== null) {
                 currentPoint.timeWeight = weightByTime(currentDate, prevDate);
             }
-            totalTimeDiff += cast(currentPoint.time)._internal_timestamp - (prevTime || cast(currentPoint.time)._internal_timestamp);
-            prevTime = cast(currentPoint.time)._internal_timestamp;
+            totalTimeDiff += currentTime - (prevTime || currentTime);
+            prevTime = currentTime;
             prevDate = currentDate;
         }
         if (startIndex === 0 && sortedTimePoints.length > 1) {
             // let's guess a weight for the first point
             // let's say the previous point was average time back in the history
             const averageTimeDiff = Math.ceil(totalTimeDiff / (sortedTimePoints.length - 1));
-            const approxPrevDate = new Date((cast(sortedTimePoints[0].time)._internal_timestamp - averageTimeDiff) * 1000);
-            sortedTimePoints[0].timeWeight = weightByTime(new Date(cast(sortedTimePoints[0].time)._internal_timestamp * 1000), approxPrevDate);
+            const firstTime = zonedTimestamp(sortedTimePoints[0], timeZone);
+            const approxPrevDate = new Date((firstTime - averageTimeDiff) * 1000);
+            sortedTimePoints[0].timeWeight = weightByTime(new Date(firstTime * 1000), approxPrevDate);
         }
     }
 
@@ -7045,16 +7121,15 @@
             }
         }
         formatHorzItem(item) {
-            const tp = item;
-            return this._private__dateTimeFormatter._internal_format(new Date(tp._internal_timestamp * 1000));
+            return this._private__dateTimeFormatter._internal_format(new Date(this._private__zonedTimePoint(item)._internal_timestamp * 1000));
         }
-        allowsTickMark(tickMark, barsPerMark) {
+        allowsTickMark(tickMark, barsPerMark, previous) {
             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);
+            return filter(tickMark.originalTime, tickMarkType, barsPerMark, previous === undefined ? null : previous.originalTime);
         }
         formatTickmark(tickMark, localizationOptions) {
             const tickMarkType = weightToTickMarkType(tickMark.weight, this._private__options.timeScale.timeVisible, this._private__options.timeScale.secondsVisible);
@@ -7065,7 +7140,7 @@
                     return tickMarkString;
                 }
             }
-            return defaultTickMarkFormatter(tickMark.time, tickMarkType, localizationOptions.locale);
+            return defaultTickMarkFormatter(this._private__zonedTimePoint(tickMark.time), tickMarkType, localizationOptions.locale);
         }
         maxTickMarkWeight(tickMarks) {
             let maxWeight = tickMarks.reduce(markWithGreaterWeight$2, tickMarks[0]).weight;
@@ -7077,7 +7152,17 @@
             return maxWeight;
         }
         fillWeightsForPoints(sortedTimePoints, startIndex) {
-            fillWeightsForPoints(sortedTimePoints, startIndex);
+            fillWeightsForPoints(sortedTimePoints, startIndex, this._private__timeZone());
+        }
+        _private__timeZone() {
+            return this._private__options?.localization.timeZone;
+        }
+        _private__zonedTimePoint(timePoint) {
+            if (timePoint._internal_businessDay !== undefined) {
+                return timePoint;
+            }
+            const offset = timeZoneOffset(this._private__timeZone(), timePoint._internal_timestamp);
+            return offset === 0 ? timePoint : { _internal_timestamp: (timePoint._internal_timestamp + offset) };
         }
         static _internal_applyDefaults(options) {
             return merge({ localization: { dateFormat: 'dd MMM \'yy' } }, options ?? {});
@@ -11079,6 +11164,10 @@
             this._private__sortedTimePoints = [];
             this._private__horzScaleBehavior = horzScaleBehavior;
         }
+        _internal_refillTimeWeights() {
+            this._private__horzScaleBehavior.fillWeightsForPoints(this._private__sortedTimePoints, 0);
+            return this._private__sortedTimePoints;
+        }
         _internal_destroy() {
             this._private__pointDataByTimePoint.clear();
             this._private__seriesRowsBySeries.clear();
@@ -12583,7 +12672,13 @@
                     throw new Error(`colorParsers option should not be changed once the chart has been created.`);
                 }
             }
+            const timeZone = this.options().localization.timeZone;
             this._private__chartWidget._internal_applyOptions(toInternalOptions(options));
+            if (this.options().localization.timeZone !== timeZone) {
+                const model = this._private__chartWidget._internal_model();
+                model._internal_timeScale()._internal_update(this._private__dataLayer._internal_refillTimeWeights(), 0);
+                model._internal_fullUpdate();
+            }
         }
         options() {
             return this._private__chartWidget._internal_options();
@@ -19221,8 +19316,9 @@
     const DEFAULT_SESSIONS = [
         {
             name: 'Tokyo',
-            startHour: 0,
-            endHour: 9,
+            startHour: 9,
+            endHour: 18,
+            timeZone: 'Asia/Tokyo',
             color: '#FF6B00',
             opacity: 0.1,
         },
@@ -19230,13 +19326,15 @@
             name: 'London',
             startHour: 8,
             endHour: 17,
+            timeZone: 'Europe/London',
             color: '#2962FF',
             opacity: 0.1,
         },
         {
             name: 'New York',
-            startHour: 13,
-            endHour: 22,
+            startHour: 8,
+            endHour: 17,
+            timeZone: 'America/New_York',
             color: '#089981',
             opacity: 0.1,
         },
@@ -19322,79 +19420,49 @@
             }
         }
         _private__highlightSession(session, data) {
-            let sessionStart = null;
-            let sessionData = [];
-            for (const point of data) {
-                const time = point.time;
-                const hour = this._private__getUTCHour(time);
-                const isInSession = this._private__isTimeInSession(hour, session.startHour, session.endHour);
-                if (isInSession) {
-                    if (!sessionStart) {
-                        sessionStart = time;
-                    }
-                    sessionData.push(point);
-                }
-                else {
-                    if (sessionStart && sessionData.length > 0) {
-                        // End of session, create highlight box
-                        this._private__createSessionBox(sessionStart, sessionData[sessionData.length - 1].time, session);
-                        sessionStart = null;
-                        sessionData = [];
-                    }
-                }
-            }
-            // Handle case where session extends to end of visible range
-            if (sessionStart && sessionData.length > 0) {
-                this._private__createSessionBox(sessionStart, sessionData[sessionData.length - 1].time, session);
-            }
+            this._private__eachRun(data, (time) => this._private__inSession(time, session), (startTime, endTime) => this._private__createSessionBox(startTime, endTime, session));
         }
+        // Per bar, since each session reads the clock of its own zone
         _private__highlightOverlaps(data) {
-            // Find overlapping sessions
             const sessions = this._private__options.sessions;
             for (let i = 0; i < sessions.length; i++) {
                 for (let j = i + 1; j < sessions.length; j++) {
-                    const session1 = sessions[i];
-                    const session2 = sessions[j];
-                    // Check if sessions overlap
-                    const overlap = this._private__getSessionOverlap(session1, session2);
-                    if (overlap) {
-                        this._private__highlightOverlapPeriod(overlap, data);
-                    }
+                    this._private__eachRun(data, (time) => this._private__inSession(time, sessions[i]) && this._private__inSession(time, sessions[j]), (startTime, endTime) => this._private__createOverlapBox(startTime, endTime));
                 }
             }
         }
-        _private__getSessionOverlap(session1, session2) {
-            const start = Math.max(session1.startHour, session2.startHour);
-            const end = Math.min(session1.endHour, session2.endHour);
-            if (start < end) {
-                return { _internal_start: start, _internal_end: end };
-            }
-            return null;
-        }
-        _private__highlightOverlapPeriod(overlap, data) {
-            let overlapStart = null;
-            let overlapData = [];
+        _private__eachRun(data, inside, emit) {
+            let runStart = null;
+            let runEnd = null;
             for (const point of data) {
-                const time = point.time;
-                const hour = this._private__getUTCHour(time);
-                const isInOverlap = hour >= overlap._internal_start && hour < overlap._internal_end;
-                if (isInOverlap) {
-                    if (!overlapStart) {
-                        overlapStart = time;
-                    }
-                    overlapData.push(point);
+                if (inside(point.time)) {
+                    runStart = runStart ?? point.time;
+                    runEnd = point.time;
                 }
-                else {
-                    if (overlapStart && overlapData.length > 0) {
-                        this._private__createOverlapBox(overlapStart, overlapData[overlapData.length - 1].time);
-                        overlapStart = null;
-                        overlapData = [];
-                    }
+                else if (runStart !== null && runEnd !== null) {
+                    emit(runStart, runEnd);
+                    runStart = null;
+                    runEnd = null;
                 }
             }
-            if (overlapStart && overlapData.length > 0) {
-                this._private__createOverlapBox(overlapStart, overlapData[overlapData.length - 1].time);
+            if (runStart !== null && runEnd !== null) {
+                emit(runStart, runEnd);
+            }
+        }
+        _private__inSession(time, session) {
+            const hour = this._private__hourIn(time, session.timeZone);
+            if (session.startHour < session.endHour) {
+                return hour >= session.startHour && hour < session.endHour;
             }
+            // Crosses midnight
+            return hour >= session.startHour || hour < session.endHour;
+        }
+        _private__hourIn(time, timeZone) {
+            const seconds = typeof time === 'number' ? time : typeof time === 'string' ? Date.parse(time) / 1000 : NaN;
+            if (!Number.isFinite(seconds)) {
+                return 0;
+            }
+            return new Date((seconds + timeZoneOffset(timeZone, seconds)) * 1000).getUTCHours();
         }
         _private__createSessionBox(startTime, endTime, session) {
             // Validate times
@@ -19424,29 +19492,6 @@
             };
             this._private__sessionBoxes.push(box);
         }
-        _private__isTimeInSession(hour, startHour, endHour) {
-            if (startHour < endHour) {
-                return hour >= startHour && hour < endHour;
-            }
-            else {
-                // Session crosses midnight
-                return hour >= startHour || hour < endHour;
-            }
-        }
-        _private__getUTCHour(time) {
-            // Convert time to UTC hour
-            if (typeof time === 'number') {
-                // Unix timestamp in seconds
-                const date = new Date(time * 1000);
-                return date.getUTCHours();
-            }
-            else if (typeof time === 'string') {
-                // ISO string
-                const date = new Date(time);
-                return date.getUTCHours();
-            }
-            return 0;
-        }
         _private__clearSessionBoxes() {
             // Clear all session boxes
             this._private__sessionBoxes = [];
@@ -27953,6 +27998,13 @@
         isDrawingModeActive() {
             return this._private__drawingModeActive;
         }
+        /**
+         * A brush armed for its next stroke is not a drawing yet: it stays out of the
+         * undo history, where restoring it would re-arm a brush the app does not hold.
+         */
+        isComplete() {
+            return (this._private__brushOptions.points ?? []).length > 0;
+        }
         _private__onPointerDown(event) {
             // A press over an existing drawing belongs to that drawing: it is how the
             // user grabs or selects one without putting the brush away first.
@@ -30592,6 +30644,14 @@
 
     /** Undo steps kept, each a full snapshot of every drawing. */
     const UNDO_HISTORY_LIMIT = 100;
+    /**
+     * Points for a restored freehand tool. Built with bracket notation: a plain
+     * `{ time, price }` literal gets its keys renamed by the build, and the tool,
+     * which reads them by their public names, comes back drawing nothing.
+     */
+    function restorePoints(points) {
+        return points.map((point) => makeSerializedPoint(readSerializedNumber(point, 'price') ?? 0, readSerializedTime(point)));
+    }
     /**
      * Central manager for all drawing tools - TradingView style
      * Handles multiple tools, selection, deletion, and keyboard shortcuts
@@ -30826,7 +30886,22 @@
         _private__applySnapshot(snapshot) {
             this._private__restoring = true;
             try {
-                this.restoreAll({ chart: this._private__chart, series: this._private__series }, snapshot, true);
+                // The history only holds placed drawings, so a tool still being drawn
+                // stays: undoing with the brush armed must leave it armed.
+                this._private__applySelection(null);
+                for (const [id, tool] of Array.from(this._private__tools)) {
+                    if (!tool.isComplete()) {
+                        continue;
+                    }
+                    tool.remove();
+                    this._private__tools.delete(id);
+                    this._private__pendingToolIds.delete(id);
+                }
+                // Annotated, or the build renames the keys the tools read
+                const context = { chart: this._private__chart, series: this._private__series };
+                for (const data of snapshot) {
+                    this.restoreTool(context, data);
+                }
                 this._private__committed = snapshot;
             }
             finally {
@@ -31056,16 +31131,8 @@
                         ...style,
                     });
                 case 'polygon':
-                    // Bracket notation on the way out too, not just on the way in: a
-                    // plain `{ time, price }` literal here gets its keys renamed and
-                    // the restored corners come back empty.
                     return createPolygonTool(context, {
-                        points: points.map((_, index) => {
-                            const vertex = {};
-                            vertex['time'] = pt(index)._internal_t;
-                            vertex['price'] = pt(index)._internal_p;
-                            return vertex;
-                        }),
+                        points: restorePoints(points),
                         ...style,
                     });
                 case 'crossLine':
@@ -31131,12 +31198,12 @@
                     });
                 case 'arrow':
                     return createArrowTool(context, {
-                        points: points.map((p) => ({ _internal_time: p['time'], _internal_price: p['price'] })),
+                        points: restorePoints(points),
                         ...style,
                     });
                 case 'brush':
                     return createBrushTool(context, {
-                        points: points.map((p) => ({ _internal_time: p['time'], _internal_price: p['price'] })),
+                        points: restorePoints(points),
                         ...style,
                     });
                 case 'text':
@@ -31434,6 +31501,8 @@
             event.preventDefault();
         }
         _private__handlePointerUp(event) {
+            // A brush stroke ends here, and no click follows it to run the check
+            this._private__scheduleCompletionCheck();
             if (!this._private__isDragging || this._private__draggedToolId === null) {
                 return;
             }
@@ -31606,7 +31675,7 @@
      * Returns the current version as a string. For example `'1.0.0'`.
      */
     function version() {
-        return "2.3.18-dev+202610170141";
+        return "2.3.20-dev+202610211649";
     }
 
     var PipsendChartsModule = /*#__PURE__*/Object.freeze({
@@ -31725,6 +31794,7 @@
         setSeriesVolumes: setSeriesVolumes,
         setVolumeProfileData: setVolumeProfileData,
         timeFromCoordinate: timeFromCoordinate,
+        timeZoneOffset: timeZoneOffset,
         version: version
     });