@devexperts/dxcharts-lite 2.7.30 → 2.7.32

package/dist/chart/inputhandlers/hover-producer.component.js

@@ -38,6 +38,7 @@ export class HoverProducerComponent extends ChartBaseElement {
          * When true, mobile long-touch (e.g. 200ms) does not activate crosshair / disable pan.
          */
         this.longTouchCrosshairSuppressed = false;
+        this.hoverOverLastCandle = false;
         this.xFormatter = () => '';
         const candleHoverProducerPart = new CandleHoverProducerPart(this.chartModel);
         const compareSeriesHoverProducerPart = new CompareSeriesHoverProducerPart(this.chartModel);
@@ -68,16 +69,14 @@ export class HoverProducerComponent extends ChartBaseElement {
             lastCandle && this.createAndFireHoverFromCandle(lastCandle);
         }));
         this.addRxSubscription(this.chartModel.candlesUpdatedSubject.subscribe(() => {
-            // update hover if its timestamp is equal or greater than last candle's one
             const lastCandle = this.chartModel.getLastVisualCandle();
-            if (this.hover !== null && lastCandle !== undefined) {
-                if (lastCandle.candle.timestamp <= this.hover.timestamp) {
-                    this.updateHover(lastCandle);
-                }
+            if (this.hover !== null && lastCandle !== undefined && this.hoverOverLastCandle) {
+                this.updateHover(lastCandle);
             }
         }));
         this.addRxSubscription(this.crossEventProducer.crossSubject.subscribe((cross) => {
             if (cross === null) {
+                this.hoverOverLastCandle = false;
                 this.hoverSubject.next(null);
             }
             else {
@@ -243,23 +242,53 @@ export class HoverProducerComponent extends ChartBaseElement {
         this.fireHover(hover);
     }
     /**
-     * Update current hover using a VisualCandle and fires it.
-     * @param {VisualCandle} candle - The VisualCandle object to create the hover from.
+     * Refreshes hover data (candles, studies, etc.) for the current pointer position.
+     * Used when the last candle updates while the legend must stay aligned to crosshair X — not to the last candle center.
      */
     updateHover(candle) {
         var _a, _b;
+        if (!this.hover) {
+            return;
+        }
+        const shouldKeepSetTouchCrosshair = isMobile() &&
+            this.longTouchActivatedSubject.getValue() &&
+            this.crossEventProducer.crossSubject.getValue() !== null;
+        const crossToolHover = this.crossEventProducer.crossToolHover;
+        const hoverX = shouldKeepSetTouchCrosshair ? ((_a = crossToolHover === null || crossToolHover === void 0 ? void 0 : crossToolHover.x) !== null && _a !== void 0 ? _a : this.hover.x) : this.hover.x;
+        const hoverY = shouldKeepSetTouchCrosshair ? ((_b = crossToolHover === null || crossToolHover === void 0 ? void 0 : crossToolHover.y) !== null && _b !== void 0 ? _b : this.hover.y) : this.hover.y;
+        const hoveredCandle = this.chartModel.candleFromX(hoverX, true);
+        const lastIdx = candle.candle.idx;
+        const hoveredIdx = hoveredCandle.idx;
+        if (lastIdx !== undefined &&
+            hoveredIdx !== undefined &&
+            hoveredIdx < lastIdx &&
+            hoverX < candle.xStart(this.scale)) {
+            return;
+        }
         const updatedHover = this.createHoverFromCandle(candle);
-        if (this.hover && updatedHover) {
-            const shouldKeepSetTouchCrosshair = isMobile() &&
-                this.longTouchActivatedSubject.getValue() &&
-                this.crossEventProducer.crossSubject.getValue() !== null;
-            const crossToolHover = this.crossEventProducer.crossToolHover;
-            const hoverX = shouldKeepSetTouchCrosshair ? ((_a = crossToolHover === null || crossToolHover === void 0 ? void 0 : crossToolHover.x) !== null && _a !== void 0 ? _a : this.hover.x) : this.hover.x;
-            const hoverY = shouldKeepSetTouchCrosshair ? ((_b = crossToolHover === null || crossToolHover === void 0 ? void 0 : crossToolHover.y) !== null && _b !== void 0 ? _b : this.hover.y) : this.hover.y;
+        if (updatedHover) {
             const hover = Object.assign(Object.assign({}, updatedHover), { x: hoverX, y: hoverY });
             this.fireHover(hover);
         }
     }
+    updateHoverLastCandle(hover) {
+        const lastCandle = this.chartModel.getLastVisualCandle();
+        if (!lastCandle) {
+            this.hoverOverLastCandle = false;
+            return;
+        }
+        const hoveredCandle = this.chartModel.candleFromX(hover.x, true);
+        const lastIdx = lastCandle.candle.idx;
+        const hoveredIdx = hoveredCandle.idx;
+        const isHistoricalCandleHover = lastIdx !== undefined &&
+            hoveredIdx !== undefined &&
+            hoveredIdx < lastIdx &&
+            hover.x < lastCandle.xStart(this.scale);
+        this.hoverOverLastCandle =
+            !isHistoricalCandleHover &&
+                (lastCandle.candle.timestamp <= hover.timestamp ||
+                    (lastIdx !== undefined && hoveredIdx !== undefined && hoveredIdx === lastIdx));
+    }
     /**
      * Creates a hover element at the specified coordinates and fires it with the option to show the cross tool
      * @param {CrossEvent} [x,y] - The coordinates where the hover element will be created
@@ -292,9 +321,11 @@ export class HoverProducerComponent extends ChartBaseElement {
                     : (_b = hover.candleHover) === null || _b === void 0 ? void 0 : _b.visualCandle.candle;
                 candle && this.chartModel.mainCandleSeries.setActiveCandle(candle);
             }
+            this.updateHoverLastCandle(hover);
             this.hoverSubject.next(hover);
         }
         else {
+            this.hoverOverLastCandle = false;
             this.crossEventProducer.fireCrossClose();
         }
     }

package/dist/chart/utils/candles.utils.d.ts

@@ -3,6 +3,7 @@
  * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
+import { CandleTimestampAnchor } from '../chart.config';
 import { Candle } from '../model/candle.model';
 import { DataSeriesPoint } from '../model/data-series.model';
 import { BinarySearchResult } from './array.utils';
@@ -10,7 +11,10 @@ export declare const getDaysOnlyTimestampFn: (isDaysPeriod: boolean) => (timesta
 export declare const searchCandleIndex: (rawTimestamp: number, options: {
     extrapolate?: boolean;
     isDaysPeriod?: boolean;
+    candleTimestampAnchor?: CandleTimestampAnchor;
 } | undefined, candles: DataSeriesPoint[], periodMs?: number) => BinarySearchResult;
+export declare const getCandleStart: (candles: DataSeriesPoint[], index: number, periodMs: number, anchor: CandleTimestampAnchor) => number;
+export declare const getCandleEnd: (candle: DataSeriesPoint, periodMs: number, anchor: CandleTimestampAnchor) => number;
 /**
  * checks if the first or the last candle or both have implied volatility data provided
  * @param candles

package/dist/chart/utils/candles.utils.js

@@ -11,7 +11,7 @@ export const getDaysOnlyTimestampFn = (isDaysPeriod) => (timestamp) => {
     }
     return timestamp;
 };
-export const searchCandleIndex = (rawTimestamp, options = {}, candles, periodMs = 1000) => {
+const searchOpenTimeCandleIndex = (rawTimestamp, options = {}, candles, periodMs = 1000) => {
     var _a, _b, _c, _d;
     const { extrapolate, isDaysPeriod } = options;
     const shouldExtrapolate = Boolean(extrapolate);
@@ -55,6 +55,85 @@ export const searchCandleIndex = (rawTimestamp, options = {}, candles, periodMs
         return binarySearch(candles, timestamp, candle => getDaysOnlyTimestamp(candle.timestamp));
     }
 };
+const searchCloseTimeCandleIndex = (rawTimestamp, options = {}, candles, periodMs = 1000) => {
+    var _a, _b, _c, _d, _e, _f;
+    const { extrapolate, isDaysPeriod } = options;
+    const shouldExtrapolate = Boolean(extrapolate);
+    const getDaysOnlyTimestamp = getDaysOnlyTimestampFn(Boolean(isDaysPeriod));
+    const timestamp = getDaysOnlyTimestamp(rawTimestamp);
+    if (!candles.length) {
+        return {
+            index: -1,
+            exact: true,
+        };
+    }
+    const firstTimestamp = getDaysOnlyTimestamp((_b = (_a = firstOf(candles)) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : 0);
+    const lastTimestamp = getDaysOnlyTimestamp((_d = (_c = lastOf(candles)) === null || _c === void 0 ? void 0 : _c.timestamp) !== null && _d !== void 0 ? _d : 0);
+    if (timestamp > lastTimestamp) {
+        if (shouldExtrapolate) {
+            return {
+                index: candles.length - 1 + Math.ceil((timestamp - lastTimestamp) / periodMs),
+                exact: true,
+            };
+        }
+        return {
+            index: candles.length - 1,
+            exact: true,
+        };
+    }
+    if (timestamp <= firstTimestamp) {
+        const previousClose = getDaysOnlyTimestamp((_f = (_e = candles[0]) === null || _e === void 0 ? void 0 : _e.timestamp) !== null && _f !== void 0 ? _f : firstTimestamp);
+        const firstCandleStart = previousClose - periodMs;
+        if (timestamp <= firstCandleStart) {
+            if (shouldExtrapolate) {
+                return {
+                    index: floor((timestamp - firstTimestamp) / periodMs),
+                    exact: true,
+                };
+            }
+            return {
+                index: -1,
+                exact: true,
+            };
+        }
+        return {
+            index: 0,
+            exact: timestamp === firstTimestamp,
+        };
+    }
+    let lo = 0;
+    let hi = candles.length;
+    while (lo < hi) {
+        const mid = floor((lo + hi) / 2);
+        if (getDaysOnlyTimestamp(candles[mid].timestamp) < timestamp) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid;
+        }
+    }
+    const index = lo;
+    return {
+        index: index >= candles.length ? candles.length - 1 : index,
+        exact: index < candles.length && getDaysOnlyTimestamp(candles[index].timestamp) === timestamp,
+    };
+};
+export const searchCandleIndex = (rawTimestamp, options = {}, candles, periodMs = 1000) => {
+    var _a;
+    const anchor = (_a = options.candleTimestampAnchor) !== null && _a !== void 0 ? _a : 'open';
+    if (anchor === 'close') {
+        return searchCloseTimeCandleIndex(rawTimestamp, options, candles, periodMs);
+    }
+    return searchOpenTimeCandleIndex(rawTimestamp, options, candles, periodMs);
+};
+export const getCandleStart = (candles, index, periodMs, anchor) => {
+    var _a, _b;
+    if (anchor === 'close') {
+        return (_b = (_a = candles[index - 1]) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : candles[index].timestamp - periodMs;
+    }
+    return candles[index].timestamp;
+};
+export const getCandleEnd = (candle, periodMs, anchor) => anchor === 'close' ? candle.timestamp : candle.timestamp + periodMs;
 /**
  * checks if the first or the last candle or both have implied volatility data provided
  * @param candles