@devexperts/dxcharts-lite 2.7.10 → 2.7.12

package/dist/chart/__tests__/env.js

@@ -11,8 +11,8 @@ Object.defineProperty(window, 'matchMedia', {
         matches: false,
         media: query,
         onchange: null,
-        addListener: jest.fn(),
-        removeListener: jest.fn(),
+        addListener: jest.fn(), // deprecated
+        removeListener: jest.fn(), // deprecated
         addEventListener: jest.fn(),
         removeEventListener: jest.fn(),
         dispatchEvent: jest.fn(),

package/dist/chart/canvas/canvas-bounds-container.js

@@ -11,7 +11,7 @@ import { calcTimeLabelBounds } from '../components/navigation_map/navigation-map
 import { calculateSymbolHeight } from '../utils/canvas/canvas-font-measure-tool.utils';
 import { YAxisBoundsContainer } from './y-axis-bounds.container';
 export const CHART_UUID = 'CHART';
-class CanvasElement {
+export class CanvasElement {
 }
 CanvasElement.CANVAS = 'CANVAS';
 CanvasElement.N_MAP = 'N_MAP';
@@ -38,7 +38,6 @@ CanvasElement.CHART = CanvasElement.PANE_UUID(CHART_UUID);
  * @returns y-axis bounds for the main chart
  */
 CanvasElement.Y_AXIS = CanvasElement.PANE_UUID_Y_AXIS(CHART_UUID);
-export { CanvasElement };
 export const DEFAULT_BOUNDS = { x: 0, y: 0, pageX: 0, pageY: 0, width: 0, height: 0 };
 export const DEFAULT_MIN_PANE_HEIGHT = 20;
 const N_MAP_H = 35;

package/dist/chart/canvas/chart-elements.d.ts

@@ -17,4 +17,4 @@ export interface ChartElements {
     chartContainer?: HTMLElement;
 }
 export type ValidatedChartElements = Required<ChartElements>;
-export declare const validateChartElements: (els: ChartElements) => els is Required<ChartElements>;
+export declare const validateChartElements: (els: ChartElements) => els is ValidatedChartElements;

package/dist/chart/chart.config.js

@@ -52,7 +52,7 @@ export const getDefaultConfig = () => ({
         defaultViewportItems: 100,
         disableAnimations: false,
     },
-    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone, // local timezone
     components: {
         chart: {
             type: 'candle',
@@ -63,7 +63,7 @@ export const getDefaultConfig = () => ({
             lineWidth: 1,
             areaLineWidth: 1,
             barLineWidth: 1,
-            minWidth: 0.5,
+            minWidth: 0.5, // minimum candle width in canvas units - not real pixels! for mac with DPR=2 it will be equal 1 pixel
             minCandles: 10,
             candlePaddingPercent: 0.25,
             highlightActiveCandle: true,

package/dist/chart/chart.js

@@ -109,7 +109,8 @@ export class Chart extends ChartBootstrap {
     setTreasuryFormat(treasuryFormat) {
         this.config.components.yAxis.treasuryFormat = treasuryFormat;
         this.paneManager.yExtents.forEach(ext => {
-            ext.yAxis.updateOrderedLabels(true);
+            ext.yAxis.model.labelsGenerator.updateTreasuryFormat(treasuryFormat);
+            ext.yAxis.model.labelsGenerator.doGenerateLabels();
             ext.yAxis.model.fancyLabelsModel.updateLabels(true);
             ext.yAxis.model.baseLabelsModel.updateLabels();
         });

package/dist/chart/components/chart/chart.component.js

@@ -33,6 +33,7 @@ import { defaultCandleTransformer, hollowCandleTransformer, lineCandleTransforme
 import { deleteCandlesIndex } from './candle.functions';
 import { TrendHistogramDrawer } from '../../drawers/data-series-drawers/trend-histogram.drawer';
 import { debounce } from '../../utils/performance/debounce.utils';
+import { LinearTrendDrawer } from '../../drawers/data-series-drawers/linear-trend.drawer';
 /**
  * Represents a financial instrument to be displayed on a chart
  * @class
@@ -182,6 +183,7 @@ export class ChartComponent extends ChartBaseElement {
         const chartPaneId = CanvasElement.PANE_UUID(CHART_UUID);
         const mainChartBoundsProvider = () => this.canvasBoundsContainer.getBounds(chartPaneId);
         this.registerDataSeriesTypeDrawer('LINEAR', new LinearDrawer());
+        this.registerDataSeriesTypeDrawer('LINEAR_TREND', new LinearTrendDrawer());
         this.registerDataSeriesTypeDrawer('HISTOGRAM', new HistogramDrawer());
         this.registerDataSeriesTypeDrawer('TREND_HISTOGRAM', new TrendHistogramDrawer());
         this.registerDataSeriesTypeDrawer('POINTS', new PointsDrawer());

package/dist/chart/components/chart/chart.model.d.ts

@@ -55,7 +55,7 @@ export declare class ChartModel extends ChartBaseElement {
     secondaryChartColors: SecondaryChartColorsPool;
     lastTimeFrame: TimeFrameRange;
     basicScaleViewportTransformer: (visualCandleSource: VisualCandle[], scaleOptions?: import("./basic-scale").BasicScaleOptions) => void;
-    timeFrameViewportTransformer: (timeframe: [number, number], zoomIn?: boolean | null) => void;
+    timeFrameViewportTransformer: (timeframe: [Timestamp, Timestamp], zoomIn?: boolean | null) => void;
     private FAKE_CANDLES_DEFAULT;
     readonly pane: PaneComponent;
     constructor(chartBaseModel: ChartBaseModel<'candle'>, paneManager: PaneManager, bus: EventBus, canvasModel: CanvasModel, config: FullChartConfig, scale: ScaleModel, formatterFactory: (format: string) => (timestamp: number) => string, mainCanvasParent: Element, canvasBoundsContainer: CanvasBoundsContainer, chartResizeHandler: ChartResizeHandler);

package/dist/chart/components/chart/price-formatters/treasury-price.formatter.d.ts

@@ -14,3 +14,4 @@
  */
 export declare const TREASURY_32ND: number;
 export declare const treasuryPriceFormatter: (value: number) => string;
+export declare const isTreasuryPriceFormat: (value: string) => boolean;

package/dist/chart/components/chart/price-formatters/treasury-price.formatter.js

@@ -24,3 +24,4 @@ export const treasuryPriceFormatter = (value) => {
     const thirtySecondsFormatted = thirtySeconds.toString().padStart(2, '0');
     return `${integerValue}'${thirtySecondsFormatted}`;
 };
+export const isTreasuryPriceFormat = (value) => Boolean(value.match(/^\-?0*(\d+)'(\d{2})$/));

package/dist/chart/components/labels_generator/numeric-axis-labels.generator.d.ts

@@ -6,7 +6,7 @@
 import { Observable, Subject } from 'rxjs';
 import { Unit } from '../../model/scaling/viewport.model';
 import { AnimationFrameCache } from '../../utils/performance/animation-frame-cache.utils';
-import { YAxisConfig } from '../../chart.config';
+import { YAxisConfig, YAxisConfigTreasuryFormat } from '../../chart.config';
 export type PriceAxisType = 'regular' | 'percent' | 'logarithmic';
 export interface LabelsGenerator {
     readonly observeLabelsChanged: () => Observable<NumericAxisLabel[]>;
@@ -36,8 +36,8 @@ export declare class NumericAxisLabelsGenerator implements LabelsGenerator {
     newGeneratedLabelsSubject: Subject<NumericAxisLabel[]>;
     private lastStart;
     private lastEnd;
-    private treasuryFormat;
-    constructor(increment: number | null, startEndProvider: () => [Unit, Unit], lengthProvider: () => Unit, valueFormatter: (value: number) => string, withZero: boolean, axisTypeProvider: () => PriceAxisType, baseLineProvider: () => number, labelFilter?: (labels: NumericAxisLabel[]) => NumericAxisLabel[], singleLabelHeightPixels?: number, yAxisConfig?: YAxisConfig | undefined);
+    protected treasuryFormat: YAxisConfigTreasuryFormat | undefined;
+    constructor(increment: number | null, startEndProvider: () => [Unit, Unit], lengthProvider: () => Unit, valueFormatter: (value: number) => string, withZero: boolean | undefined, axisTypeProvider: () => PriceAxisType, baseLineProvider: () => number, labelFilter?: (labels: NumericAxisLabel[]) => NumericAxisLabel[], singleLabelHeightPixels?: number, yAxisConfig?: YAxisConfig | undefined);
     private generateRegularLabels;
     private generatePercentLabels;
     private generateLogarithmLabels;

package/dist/chart/components/labels_generator/numeric-axis-labels.generator.js

@@ -154,19 +154,17 @@ export class NumericAxisLabelsGenerator {
         return this.adjustIncrementOnAxisType(DEFAULT_REGULAR_INCREMENT);
     }
     adjustIncrementOnAxisType(increment) {
-        var _a;
-        const calculatedIncrement = ((_a = this.treasuryFormat) === null || _a === void 0 ? void 0 : _a.enabled) ? TREASURY_32ND : increment;
         switch (this.axisTypeProvider()) {
             case 'percent':
                 return increment;
             case 'logarithmic':
                 const [logMin] = this.calculateMinMax();
                 const regularMin = logValueToUnit(logMin);
-                const regularIncrementedValue = regularMin + calculatedIncrement;
+                const regularIncrementedValue = regularMin + increment;
                 const incrementedLogValue = calcLogValue(regularIncrementedValue);
                 return incrementedLogValue - logMin;
             case 'regular':
-                return calculatedIncrement;
+                return increment;
         }
     }
     // TODO rework, generator should act as model and update itself on scaleChanged

package/dist/chart/components/pane/extent/y-extent-component.d.ts

@@ -74,7 +74,7 @@ export declare class YExtentComponent extends ChartBaseElement {
      */
     removeDataSeries(series: DataSeriesModel): void;
     valueFormatter: (value: Unit, dataSeries?: DataSeriesModel) => string;
-    get regularFormatter(): (value: number, precision?: number | undefined) => string;
+    get regularFormatter(): (value: number, precision?: number) => string;
     /**
      * Sets the pane value formatters for the current instance.
      * @param {YExtentFormatters} formatters - The pane value formatters to be set.

package/dist/chart/components/pane/extent/y-extent-component.js

@@ -3,7 +3,12 @@
  * 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 { CanvasElement } from '../../../canvas/canvas-bounds-container';
+/*
+ * Copyright (C) 2019 - 2025 Devexperts Solutions IE Limited
+ * 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 { CanvasElement, CHART_UUID } from '../../../canvas/canvas-bounds-container';
 import { ChartBaseElement } from '../../../model/chart-base-element';
 import { DataSeriesModel, VisualSeriesPoint, defaultValueFormatter, } from '../../../model/data-series.model';
 import { mergeHighLow } from '../../../model/scaling/auto-scale.model';
@@ -93,6 +98,11 @@ export class YExtentComponent extends ChartBaseElement {
         if (this.dataSeries.size === 1) {
             this.mainDataSeries = series;
         }
+        else if (this.paneComponent.yExtentComponents.length > 1 && this.paneUUID !== CHART_UUID) {
+            this.mainDataSeries = series;
+            const ds = Array.from(this.paneComponent.mainExtent.dataSeries);
+            this.paneComponent.mainExtent.mainDataSeries = ds[ds.length - 1];
+        }
         this.paneComponent.updateView();
         this.paneComponent.seriesAddedSubject.next(series);
     }

package/dist/chart/components/pane/pane.component.d.ts

@@ -54,7 +54,7 @@ export declare class PaneComponent extends ChartBaseElement {
     yExtentComponentsChangedSubject: Subject<void>;
     get scale(): ScaleModel;
     get yAxis(): YAxisComponent;
-    get dataSeries(): DataSeriesModel<import("../../model/data-series.model").DataSeriesPoint, import("../../model/data-series.model").VisualSeriesPoint>[];
+    get dataSeries(): DataSeriesModel<import("../../model/data-series.model").DataSeriesPoint, import("../../model/data-series.model").VisualSeriesPoint, import("../../model/data-series.config").DataSeriesConfig>[];
     get visible(): boolean;
     mainExtent: YExtentComponent;
     constructor(chartBaseModel: ChartBaseModel<'candle'>, mainCanvasModel: CanvasModel, yAxisLabelsCanvasModel: CanvasModel, dynamicObjectsCanvasModel: CanvasModel, hitTestController: PaneHitTestController, config: FullChartConfig, mainScale: ScaleModel, drawingManager: DrawingManager, chartPanComponent: ChartPanComponent, canvasInputListener: CanvasInputListenerComponent, canvasAnimation: CanvasAnimation, cursorHandler: CursorHandler, eventBus: EventBus, canvasBoundsContainer: CanvasBoundsContainer, uuid: string, seriesAddedSubject: Subject<DataSeriesModel>, seriesRemovedSubject: Subject<DataSeriesModel>, hitTestCanvasModel: HitTestCanvasModel, chartResizeHandler: ChartResizeHandler, options?: AtLeastOne<YExtentCreationOptions>);
@@ -160,7 +160,7 @@ export declare class PaneComponent extends ChartBaseElement {
      */
     canMoveDown(): boolean;
     valueFormatter: (value: Unit, dataSeries?: DataSeriesModel) => string;
-    get regularFormatter(): (value: number, precision?: number | undefined) => string;
+    get regularFormatter(): (value: number, precision?: number) => string;
     /**
      * Sets the pane value formatters for the current instance.
      * @param {YExtentFormatters} formatters - The pane value formatters to be set.

package/dist/chart/components/volumes/separate-volumes.component.js

@@ -6,7 +6,7 @@
 import { ChartBaseElement } from '../../model/chart-base-element';
 import { createCandlesOffsetProvider } from '../chart/data-series.high-low-provider';
 import { volumeFormatter } from './volumes.formatter';
-class SeparateVolumesComponent extends ChartBaseElement {
+export class SeparateVolumesComponent extends ChartBaseElement {
     constructor(chartComponent, config, volumesModel, paneManager) {
         super();
         this.chartComponent = chartComponent;
@@ -64,4 +64,3 @@ class SeparateVolumesComponent extends ChartBaseElement {
     }
 }
 SeparateVolumesComponent.UUID = 'volumes';
-export { SeparateVolumesComponent };

package/dist/chart/components/x_axis/time/parser/time-formats.model.d.ts

@@ -27,7 +27,7 @@ export interface ParsedNCTimeFormat {
 }
 export type ParsedTimeFormat = ParsedCTimeFormat | ParsedWeekFormat | ParsedNCTimeFormat;
 export type SpecialSymbol = '!' | '$';
-export declare const timeFormatConfirugableGuard: (key: string) => key is "year" | "month" | "day" | "hour" | "minute" | "second";
-export declare const weekWeekdayGuard: (key: string) => key is "week-weekday";
-export declare const timeFormatNoNConfirugableGuard: (key: string) => key is "lessThanSecond";
+export declare const timeFormatConfirugableGuard: (key: string) => key is TimeFormatConfirugableType;
+export declare const weekWeekdayGuard: (key: string) => key is TimeFormatWeekWeekdayType;
+export declare const timeFormatNoNConfirugableGuard: (key: string) => key is TimeFormatNonConfirugableType;
 export {};

package/dist/chart/components/x_axis/x-axis-labels.generator.d.ts

@@ -18,7 +18,7 @@ export interface XAxisLabelsGenerator {
     /**
      * Generates x-axis labels from scratch. Heavy operation.
      */
-    generateLabels(prependedCandles?: VisualCandle[]): void;
+    generateLabels(prependedCandles?: VisualCandle[], generateFromCache?: boolean): void;
     /**
      * Updates current labels state (x-position). Lightweight operation.
      */
@@ -53,6 +53,7 @@ export declare class XAxisTimeLabelsGenerator implements XAxisLabelsGenerator {
     private labelsGroupedByWeight;
     private weightedCache?;
     private levelsCache;
+    private labelCache;
     get labels(): XAxisLabelWeighted[];
     private formatsByWeightMap;
     private weightToTimeFormatMatcherArray;
@@ -61,9 +62,9 @@ export declare class XAxisTimeLabelsGenerator implements XAxisLabelsGenerator {
     constructor(eventBus: EventBus, config: FullChartConfig, chartModel: ChartModel, scale: ScaleModel, timeZoneModel: TimeZoneModel, canvasModel: CanvasModel, canvasBoundsContainer: CanvasBoundsContainer);
     private filterLabelsInViewport;
     private getLabelsFromChartType;
-    /**
-     * Make a prediction(750) about how many candles we need to fake to fill all X axis by labels
-     */
+    private getVisualCandleAtIndex;
+    private getVisualCandlesWithFake;
+    private getViewportCandlesWithFake;
     private getAllCandlesWithFake;
     /**
      * Maps an array of weighted points to an array of XAxisLabelWeighted objects.
@@ -78,13 +79,6 @@ export declare class XAxisTimeLabelsGenerator implements XAxisLabelsGenerator {
      * @returns {void}
      */
     setFormatsForLabelsConfig(newFormatsByWeightMap: Record<TimeFormatWithDuration, string>): void;
-    /**
-     * Generates weighted labels based on allCandlesWithFake, weightToTimeFormatMatcherDict and timeZoneModel.
-     * @private
-     * @function
-     * @returns {void}
-     */
-    private generateWeightedLabels;
     /**
      * Retrieves the labels from the cache for a given coverUpLevel.
      * @param {number} coverUpLevel - The coverUpLevel to retrieve the labels from the cache.
@@ -104,10 +98,10 @@ export declare class XAxisTimeLabelsGenerator implements XAxisLabelsGenerator {
      */
     updateHistoryLabels(candles: VisualCandle[]): void;
     /**
-     * Calls the method generateWeightedLabels to generate labels.
+     * Generates labels based on allCandlesWithFake, weightToTimeFormatMatcherDict and timeZoneModel.
      * @returns {void}
      */
-    generateLabels(prependedCandles?: VisualCandle[]): void;
+    generateLabels(prependedCandles?: VisualCandle[], generateFromCache?: boolean): void;
     /**
      * Recalculates the labels by calling the method recalculateCachedLabels.
      * @returns {void}
@@ -146,4 +140,5 @@ export declare class XAxisTimeLabelsGenerator implements XAxisLabelsGenerator {
      * @returns {Record<number, XAxisLabelWeighted[]>} - Object containing the filtered labels grouped by weight.
      */
     private filterLabelsByExtendedRules;
+    private clearLabelCache;
 }

package/dist/chart/components/x_axis/x-axis-labels.generator.js

@@ -24,6 +24,7 @@ export class XAxisTimeLabelsGenerator {
         this.canvasBoundsContainer = canvasBoundsContainer;
         this.labelsGroupedByWeight = {};
         this.levelsCache = {};
+        this.labelCache = new Map();
         this.weightToTimeFormatMatcherArray = [];
         this.weightToTimeFormatsDict = {};
         this.extendedLabelsFilterConfig = {
@@ -83,10 +84,14 @@ export class XAxisTimeLabelsGenerator {
             return labels;
         }
     }
-    /**
-     * Make a prediction(750) about how many candles we need to fake to fill all X axis by labels
-     */
-    getAllCandlesWithFake(prependedCandles = []) {
+    getVisualCandleAtIndex(idx, dataPoints, visualPoints, meanCandleWidth, period) {
+        if (idx >= 0 && idx < visualPoints.length) {
+            return visualPoints[idx];
+        }
+        // generate fake candle for out-of-range index
+        return fakeVisualCandle(dataPoints, visualPoints, meanCandleWidth, idx, period);
+    }
+    getVisualCandlesWithFake(prependedCandles = []) {
         const visualCandles = this.chartModel.mainCandleSeries.visualPoints;
         if (visualCandles.length === 0) {
             return [];
@@ -95,6 +100,53 @@ export class XAxisTimeLabelsGenerator {
         const appendFakeCandle = fakeCandlesForSides.map((_, idx) => fakeVisualCandle(this.chartModel.mainCandleSeries.dataPoints, this.chartModel.mainCandleSeries.visualPoints, this.chartModel.mainCandleSeries.meanCandleWidth, visualCandles.length + idx, this.chartModel.getPeriod()));
         return [...prependedCandles, ...visualCandles, ...appendFakeCandle];
     }
+    getViewportCandlesWithFake() {
+        var _a;
+        const visualCandles = this.chartModel.mainCandleSeries.visualPoints;
+        if (visualCandles.length === 0 || this.scale.xEnd - this.scale.xStart <= 1) {
+            return [];
+        }
+        const meanCandleWidth = this.chartModel.mainCandleSeries.meanCandleWidth;
+        const period = this.chartModel.getPeriod();
+        const dataPoints = this.chartModel.mainCandleSeries.dataPoints;
+        // calculate visible pixel range for the chart area
+        const bounds = this.canvasBoundsContainer.getBounds(CanvasElement.CHART);
+        const leftPx = 0;
+        const rightPx = bounds.width;
+        // convert to units
+        const leftUnit = this.scale.fromX(leftPx);
+        const rightUnit = this.scale.fromX(rightPx);
+        // anchor everything to index 0 (absolute index)
+        // find the X position of index 0 (anchor)
+        let anchorX = 0;
+        if (visualCandles.length > 0) {
+            // if we have visible candles, use the X of the first visible candle at its idx
+            const firstVisible = visualCandles[0];
+            anchorX = firstVisible.centerUnit - ((_a = firstVisible.candle.idx) !== null && _a !== void 0 ? _a : 0) * meanCandleWidth;
+        }
+        // buffer is needed to to avoid empty space when moving viewport
+        const buffer = 500;
+        // allows to round labels better
+        const modulus = 500;
+        // use anchorX and meanCandleWidth to map units to indices
+        const rawFirstIdx = Math.floor((leftUnit - anchorX) / meanCandleWidth) - buffer;
+        const rawLastIdx = Math.ceil((rightUnit - anchorX) / meanCandleWidth) + buffer;
+        const firstIdx = Math.floor(rawFirstIdx / modulus) * modulus;
+        const lastIdx = Math.ceil(rawLastIdx / modulus) * modulus;
+        const allCandles = [];
+        for (let idx = firstIdx; idx <= lastIdx; idx++) {
+            allCandles.push(this.getVisualCandleAtIndex(idx, dataPoints, visualCandles, meanCandleWidth, period));
+        }
+        return [...allCandles];
+    }
+    getAllCandlesWithFake(prependedCandles = []) {
+        if (this.config.components.chart.minCandlesOffset) {
+            return this.getVisualCandlesWithFake(prependedCandles);
+        }
+        else {
+            return this.getViewportCandlesWithFake();
+        }
+    }
     /**
      * Maps an array of weighted points to an array of XAxisLabelWeighted objects.
      * @param {WeightedPoint[]} weightedPoints - An array of weighted points to be mapped.
@@ -125,28 +177,14 @@ export class XAxisTimeLabelsGenerator {
      * @returns {void}
      */
     setFormatsForLabelsConfig(newFormatsByWeightMap) {
+        this.clearLabelCache();
         const { weightToTimeFormatsDict, weightToTimeFormatMatcherDict } = generateWeightsMapForConfig(newFormatsByWeightMap);
         this.formatsByWeightMap = newFormatsByWeightMap;
         this.weightToTimeFormatMatcherArray = Object.entries(weightToTimeFormatMatcherDict)
             .map(([k, v]) => [parseInt(k, 10), v])
             .sort(([a], [b]) => b - a);
         this.weightToTimeFormatsDict = weightToTimeFormatsDict;
-        this.generateWeightedLabels();
-    }
-    /**
-     * Generates weighted labels based on allCandlesWithFake, weightToTimeFormatMatcherDict and timeZoneModel.
-     * @private
-     * @function
-     * @returns {void}
-     */
-    generateWeightedLabels(prependedCandles = []) {
-        const allCandlesWithFake = this.getAllCandlesWithFake(prependedCandles);
-        const weightedPoints = mapCandlesToWeightedPoints(allCandlesWithFake, this.weightToTimeFormatMatcherArray, this.timeZoneModel.tzOffset(this.config.timezone));
-        const weightedLabels = this.mapWeightedPointsToLabels(weightedPoints, allCandlesWithFake);
-        this.labelsGroupedByWeight = groupLabelsByWeight(weightedLabels);
-        this.weightedCache = undefined;
-        this.levelsCache = {};
-        this.recalculateCachedLabels();
+        this.generateLabels();
     }
     /**
      * Retrieves the labels from the cache for a given coverUpLevel.
@@ -250,11 +288,34 @@ export class XAxisTimeLabelsGenerator {
         this.recalculateCachedLabels();
     }
     /**
-     * Calls the method generateWeightedLabels to generate labels.
+     * Generates labels based on allCandlesWithFake, weightToTimeFormatMatcherDict and timeZoneModel.
      * @returns {void}
      */
-    generateLabels(prependedCandles) {
-        this.generateWeightedLabels(prependedCandles);
+    generateLabels(prependedCandles, generateFromCache = false) {
+        var _a;
+        const allCandlesWithFake = this.getAllCandlesWithFake(prependedCandles);
+        const weightedPoints = mapCandlesToWeightedPoints(allCandlesWithFake, this.weightToTimeFormatMatcherArray, this.timeZoneModel.tzOffset(this.config.timezone));
+        let weightedLabels = [];
+        if (generateFromCache) {
+            for (let i = 0; i < allCandlesWithFake.length; i++) {
+                const idx = (_a = allCandlesWithFake[i].candle.idx) !== null && _a !== void 0 ? _a : i;
+                const ts = allCandlesWithFake[i].candle.timestamp;
+                const cacheKey = `${idx}_${ts}`;
+                let label = this.labelCache.get(cacheKey);
+                if (!label) {
+                    label = this.mapWeightedPointsToLabels([weightedPoints[i]], [allCandlesWithFake[i]])[0];
+                    this.labelCache.set(cacheKey, label);
+                }
+                weightedLabels.push(label);
+            }
+        }
+        else {
+            weightedLabels = this.mapWeightedPointsToLabels(weightedPoints, allCandlesWithFake);
+        }
+        this.labelsGroupedByWeight = groupLabelsByWeight(weightedLabels);
+        this.weightedCache = undefined;
+        this.levelsCache = {};
+        this.recalculateCachedLabels();
     }
     /**
      * Recalculates the labels by calling the method recalculateCachedLabels.
@@ -362,4 +423,7 @@ export class XAxisTimeLabelsGenerator {
             return acc;
         }, {});
     }
+    clearLabelCache() {
+        this.labelCache.clear();
+    }
 }

package/dist/chart/components/x_axis/x-axis.component.js

@@ -76,11 +76,18 @@ export class XAxisComponent extends ChartBaseElement {
                 (_b = (_a = this.xAxisLabelsGenerator).updateHistoryLabels) === null || _b === void 0 ? void 0 : _b.call(_a, newCandles);
             }
         }));
-        this.addRxSubscription(merge(this.scale.xChanged, this.chartResizeHandler.canvasResized)
-            .pipe(throttleTime(50, animationFrameScheduler, { trailing: true, leading: true }))
-            .subscribe(() => {
-            this.xAxisLabelsGenerator.recalculateLabels();
-        }));
+        // recalculate existing ones, the number of labels is static
+        if (this.config.components.chart.minCandlesOffset) {
+            this.addRxSubscription(merge(this.scale.xChanged, this.chartResizeHandler.canvasResized)
+                .pipe(throttleTime(50, animationFrameScheduler, { trailing: true, leading: true }))
+                .subscribe(() => this.xAxisLabelsGenerator.recalculateLabels()));
+            // generate visible viewport range labels (real and fake candles), the number of labels is dynamic
+        }
+        else {
+            this.addRxSubscription(merge(this.scale.xChanged, this.chartResizeHandler.canvasResized)
+                .pipe(throttleTime(150, animationFrameScheduler, { trailing: true, leading: true }))
+                .subscribe(() => this.xAxisLabelsGenerator.generateLabels(undefined, true)));
+        }
         this.addRxSubscription(this.chartComponent.chartModel.candlesUpdatedSubject
             .pipe(map(() => lastOf(this.chartComponent.chartModel.mainCandleSeries.visualPoints)), distinctUntilChanged((a, b) => { var _a, _b; return ((_a = a === null || a === void 0 ? void 0 : a.candle) === null || _a === void 0 ? void 0 : _a.id) === ((_b = b === null || b === void 0 ? void 0 : b.candle) === null || _b === void 0 ? void 0 : _b.id); }), filter(notEmpty))
             .subscribe(x => { var _a, _b; return (_b = (_a = this.xAxisLabelsGenerator) === null || _a === void 0 ? void 0 : _a.updateLastLabel) === null || _b === void 0 ? void 0 : _b.call(_a, x); }));

package/dist/chart/components/y_axis/numeric-y-axis-labels.generator.d.ts

@@ -3,7 +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 { YAxisConfig } from '../../chart.config';
+import { YAxisConfig, YAxisConfigTreasuryFormat } from '../../chart.config';
 import { DataSeriesModel } from '../../model/data-series.model';
 import { ViewportModel } from '../../model/scaling/viewport.model';
 import { NumericAxisLabelsGenerator, PriceAxisType } from '../labels_generator/numeric-axis-labels.generator';
@@ -14,6 +14,7 @@ export declare class NumericYAxisLabelsGenerator extends NumericAxisLabelsGenera
     private dataSeriesProvider;
     constructor(increment: number | null, dataSeriesProvider: () => DataSeriesModel | undefined, viewportModel: ViewportModel, valueFormatter: (value: number) => string, axisTypeProvider: (() => PriceAxisType) | undefined, singleLabelHeightPixels: number | undefined, config: YAxisConfig);
     getLargestLabel(): string;
+    updateTreasuryFormat(treasuryFormat: YAxisConfigTreasuryFormat): void;
     /**
      * Calculates the increment to be used on the chart axis based on the length of the value and the instrument's price increments.
      * @param {number} valueLength - The length of the value.

package/dist/chart/components/y_axis/numeric-y-axis-labels.generator.js

@@ -5,6 +5,7 @@
  */
 import { lastOf } from '../../utils/array.utils';
 import { precisionsToIncrement } from '../../utils/price-increments.utils';
+import { TREASURY_32ND } from '../chart/price-formatters/treasury-price.formatter';
 import { NumericAxisLabelsGenerator } from '../labels_generator/numeric-axis-labels.generator';
 /**
  * Y axis labels generator for prices. Respects price increment from instrument.
@@ -18,19 +19,23 @@ export class NumericYAxisLabelsGenerator extends NumericAxisLabelsGenerator {
         var _a;
         return ((_a = this.labelsCache.getLastCachedValue()) !== null && _a !== void 0 ? _a : []).reduce((maxLengthText, label) => (label.text.length > maxLengthText.length ? label.text : maxLengthText), '');
     }
+    updateTreasuryFormat(treasuryFormat) {
+        this.treasuryFormat = treasuryFormat;
+    }
     /**
      * Calculates the increment to be used on the chart axis based on the length of the value and the instrument's price increments.
      * @param {number} valueLength - The length of the value.
      * @returns {number} - The calculated increment.
      */
     calculateIncrement(valueLength) {
-        var _a;
+        var _a, _b;
         const dataSeries = this.dataSeriesProvider();
         if (dataSeries) {
             const lastCandle = lastOf(dataSeries.dataPoints);
             const priceIncrementBasis = (_a = lastCandle === null || lastCandle === void 0 ? void 0 : lastCandle.close) !== null && _a !== void 0 ? _a : 0;
             const increment = precisionsToIncrement(priceIncrementBasis, dataSeries.pricePrecisions);
-            return this.adjustIncrementOnAxisType(increment);
+            const calculatedIncrement = ((_b = this.treasuryFormat) === null || _b === void 0 ? void 0 : _b.enabled) ? TREASURY_32ND : increment;
+            return this.adjustIncrementOnAxisType(calculatedIncrement);
         }
         // auto-generated increment
         return super.calculateIncrement(valueLength);

package/dist/chart/drawers/data-series-drawers/difference-cloud.drawer.d.ts

@@ -21,4 +21,4 @@ export declare class DifferenceCloudDrawer implements SeriesDrawer {
     protected fillCloud(ctx: CanvasRenderingContext2D, color: string, linePoints: Point[], nextLinePoints: Point[], hitTestDrawerConfig: HTSeriesDrawerConfig): void;
     protected mapDataSeriesDiffPointsIntoPoints(points: VisualSeriesPoint[], view: Viewable): Point[];
 }
-export declare const isDifferenceTool: (type: string) => boolean;
+export declare const isDifferenceTool: (type: string) => type is "DIFFERENCE";

package/dist/chart/drawers/data-series-drawers/linear-trend.drawer.d.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2019 - 2025 Devexperts Solutions IE Limited
+ * 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 { DataSeriesModel, VisualSeriesPoint } from '../../model/data-series.model';
+import { HTSeriesDrawerConfig, SeriesDrawer } from '../data-series.drawer';
+export declare class LinearTrendDrawer implements SeriesDrawer {
+    constructor();
+    draw(ctx: CanvasRenderingContext2D, allPoints: VisualSeriesPoint[][], model: DataSeriesModel, hitTestDrawerConfig: HTSeriesDrawerConfig): void;
+}
+export declare const getPreviousValue: (arr: VisualSeriesPoint[], idx: number) => VisualSeriesPoint | undefined;

package/dist/chart/drawers/data-series-drawers/linear-trend.drawer.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 - 2025 Devexperts Solutions IE Limited
+ * 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 { flat } from '../../utils/array.utils';
+import { setLineWidth } from '../data-series.drawer';
+export class LinearTrendDrawer {
+    constructor() { }
+    draw(ctx, allPoints, model, hitTestDrawerConfig) {
+        const allPointsFlat = flat(allPoints);
+        const config = model.getPaintConfig(0);
+        setLineWidth(ctx, config.lineWidth, model, hitTestDrawerConfig, config.hoveredLineWidth);
+        ctx.lineCap = 'round';
+        allPointsFlat.forEach((point, idx) => {
+            var _a, _b;
+            const previousValue = getPreviousValue(allPointsFlat, idx) || allPointsFlat[0];
+            const isNegativeTrend = previousValue && point.close < previousValue.close;
+            if (((_a = config.multiplyColors) === null || _a === void 0 ? void 0 : _a.length) === 2) {
+                ctx.strokeStyle =
+                    (_b = hitTestDrawerConfig.color) !== null && _b !== void 0 ? _b : ((isNegativeTrend ? config.multiplyColors[1] : config.multiplyColors[0]) ||
+                        config.color ||
+                        '#FF00FF');
+                const x = model.view.toX(point.centerUnit);
+                const y = model.view.toY(point.close);
+                const prevX = model.view.toX(previousValue.centerUnit);
+                const prevY = model.view.toY(previousValue.close);
+                ctx.beginPath();
+                ctx.moveTo(prevX, prevY);
+                ctx.lineTo(x, y);
+                ctx.stroke();
+                return;
+            }
+        });
+    }
+}
+export const getPreviousValue = (arr, idx) => {
+    do {
+        idx--;
+    } while (idx >= 0 && !isFinite(arr[idx] && arr[idx].close));
+    return arr[idx] ? arr[idx] : undefined;
+};

package/dist/chart/inputhandlers/hover-producer.component.d.ts

@@ -27,7 +27,7 @@ export interface BaseHover {
 }
 export interface HoverParts {
     readonly candleHover: CandleHover | undefined;
-    readonly compareSeriesHover: CompareSeriesHover[];
+    readonly compareSeriesHover: CompareSeriesHover[] | undefined;
     [key: string]: unknown;
 }
 export interface Hover extends BaseHover, HoverParts {

package/dist/chart/inputlisteners/canvas-input-listener.component.js

@@ -19,7 +19,7 @@ import { deviceDetector } from '../utils/device/device-detector.utils';
  * - zooming (wheel event)
  * - touch start and move
  */
-class CanvasInputListenerComponent extends ChartBaseElement {
+export class CanvasInputListenerComponent extends ChartBaseElement {
     constructor(eventBus, element) {
         super();
         this.eventBus = eventBus;
@@ -652,4 +652,3 @@ class CanvasInputListenerComponent extends ChartBaseElement {
 CanvasInputListenerComponent.DRAG_START_EVENTS = ['mousedown', 'touchstart'];
 CanvasInputListenerComponent.DRAG_EVENTS = ['mousemove', 'touchmove'];
 CanvasInputListenerComponent.DRAG_END_EVENTS = ['mouseup', 'touchend', 'touchcancel'];
-export { CanvasInputListenerComponent };

package/dist/chart/model/data-series-view.d.ts

@@ -31,7 +31,7 @@ export declare class DataSeriesView implements Viewable {
      * @param getBaseline - A function that returns the baseline for percent.
      * @returns - The converted value in the corresponding unit.
      */
-    toAxisUnits(value: Price, getBaseline?: (idx?: number | undefined) => number): Unit;
+    toAxisUnits(value: Price, getBaseline?: (idx?: Index) => Unit): Unit;
     /**
      * Convert the input unit to its corresponding x-pixel coordinate based on the scale model.
      * @param unit - The unit to be converted to x-pixel coordinate.