@devexperts/dxcharts-lite 2.4.6 → 2.5.1

package/dist/chart/inputhandlers/main-canvas-touch.handler.d.ts

@@ -6,15 +6,17 @@
 import { ChartBaseElement } from '../model/chart-base-element';
 import { CanvasInputListenerComponent } from '../inputlisteners/canvas-input-listener.component';
 import { ScaleModel } from '../model/scale.model';
+import { ChartAreaPanHandler } from '../components/chart/chart-area-pan.handler';
 /**
  * Handles chart touch events.
  */
 export declare class MainCanvasTouchHandler extends ChartBaseElement {
+    private chartAreaPanHandler;
     private scale;
     private canvasInputListeners;
     private mainCanvasParent;
     private touchedCandleIndexes;
-    constructor(scale: ScaleModel, canvasInputListeners: CanvasInputListenerComponent, mainCanvasParent: Element);
+    constructor(chartAreaPanHandler: ChartAreaPanHandler, scale: ScaleModel, canvasInputListeners: CanvasInputListenerComponent, mainCanvasParent: Element);
     /**
      * Activates canvas input listeners for touch start and touch move events.
      * @protected
@@ -31,8 +33,13 @@ export declare class MainCanvasTouchHandler extends ChartBaseElement {
      * Handles touch move event
      * @param {TouchEvent} e - The touch event object
      * @returns {void}
-    */
+     */
     private handleTouchMoveEvent;
+    /**
+     * Handles touch end event
+     * @returns {void}
+     */
+    private handleTouchEndEvent;
     /**
      * Gets candle positions touched by user in pixels.
      * @param e - touch event with "touches" array

package/dist/chart/inputhandlers/main-canvas-touch.handler.js

@@ -8,8 +8,9 @@ import { ChartBaseElement } from '../model/chart-base-element';
  * Handles chart touch events.
  */
 export class MainCanvasTouchHandler extends ChartBaseElement {
-    constructor(scale, canvasInputListeners, mainCanvasParent) {
+    constructor(chartAreaPanHandler, scale, canvasInputListeners, mainCanvasParent) {
         super();
+        this.chartAreaPanHandler = chartAreaPanHandler;
         this.scale = scale;
         this.canvasInputListeners = canvasInputListeners;
         this.mainCanvasParent = mainCanvasParent;
@@ -24,6 +25,7 @@ export class MainCanvasTouchHandler extends ChartBaseElement {
     doActivate() {
         this.addRxSubscription(this.canvasInputListeners.observeTouchStart().subscribe(e => this.handleTouchStartEvent(e)));
         this.addRxSubscription(this.canvasInputListeners.observeTouchMove().subscribe(e => this.handleTouchMoveEvent(e)));
+        this.addRxSubscription(this.canvasInputListeners.observeTouchEndDocument().subscribe(e => this.handleTouchEndEvent(e)));
     }
     /**
      * Handles the touch start event.
@@ -32,6 +34,7 @@ export class MainCanvasTouchHandler extends ChartBaseElement {
      */
     handleTouchStartEvent(e) {
         if (e.touches.length === 2) {
+            this.chartAreaPanHandler.deactivate();
             // @ts-ignore
             // TODO rework this
             this.touchedCandleIndexes = this.getXPositions(e).map(x => this.scale.fromX(x));
@@ -41,12 +44,22 @@ export class MainCanvasTouchHandler extends ChartBaseElement {
      * Handles touch move event
      * @param {TouchEvent} e - The touch event object
      * @returns {void}
-    */
+     */
     handleTouchMoveEvent(e) {
         if (e.touches.length === 2) {
             this.pinchHandler(this.touchedCandleIndexes, this.getXPositions(e));
         }
     }
+    /**
+     * Handles touch end event
+     * @returns {void}
+     */
+    handleTouchEndEvent(e) {
+        // zero touches means the user stopped resizing completely (both fingers are up)
+        if (e.touches.length === 0) {
+            this.chartAreaPanHandler.activate();
+        }
+    }
     /**
      * Gets candle positions touched by user in pixels.
      * @param e - touch event with "touches" array
@@ -75,6 +88,9 @@ export class MainCanvasTouchHandler extends ChartBaseElement {
         const last = first +
             ((candleIndexes[0] - candleIndexes[1]) / (touchPositions[0] - touchPositions[1])) *
                 this.scale.getBounds().width;
+        if (first >= last) {
+            return;
+        }
         this.scale.setXScale(first, last);
     }
 }

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

@@ -19,6 +19,7 @@ export declare const BASELINE_RESIZER_UUID = "BASELINE_RESIZER";
  */
 export declare class BaselineModel extends ChartBaseElement {
     private chartModel;
+    private chartPanComponent;
     private canvasModel;
     private canvasInputListener;
     private config;
@@ -29,6 +30,8 @@ export declare class BaselineModel extends ChartBaseElement {
     ht: HitBoundsTest;
     constructor(chartModel: ChartModel, chartPanComponent: ChartPanComponent, canvasModel: CanvasModel, canvasInputListener: CanvasInputListenerComponent, config: FullChartConfig, canvasBoundContainer: CanvasBoundsContainer, cursorHandler: CursorHandler);
     protected doActivate(): void;
+    private dragStartCb;
+    private dragEndCb;
     private dragTickCb;
     /**
      * Recalculates the bounds of the baseline resizer based on the current chart and y-axis bounds.

package/dist/chart/model/baseline.model.js

@@ -15,6 +15,7 @@ export class BaselineModel extends ChartBaseElement {
     constructor(chartModel, chartPanComponent, canvasModel, canvasInputListener, config, canvasBoundContainer, cursorHandler) {
         super();
         this.chartModel = chartModel;
+        this.chartPanComponent = chartPanComponent;
         this.canvasModel = canvasModel;
         this.canvasInputListener = canvasInputListener;
         this.config = config;
@@ -26,6 +27,8 @@ export class BaselineModel extends ChartBaseElement {
         this.ht = CanvasBoundsContainer.hitTestOf(this.resizerBounds, {
             extensionY: this.config.components.paneResizer.dragZone,
         });
+        this.dragStartCb = () => this.chartPanComponent.deactivatePanHandlers();
+        this.dragEndCb = () => this.chartPanComponent.activateChartPanHandlers();
         this.dragTickCb = (dragInfo) => {
             const { delta: yDelta } = dragInfo;
             const chart = this.canvasBoundContainer.getBounds(CanvasElement.CHART);
@@ -37,6 +40,8 @@ export class BaselineModel extends ChartBaseElement {
         };
         const dndHelper = new DragNDropYComponent(this.ht, {
             onDragTick: this.dragTickCb,
+            onDragStart: this.dragStartCb,
+            onDragEnd: this.dragEndCb,
         }, canvasInputListener, chartPanComponent);
         this.addChildEntity(dndHelper);
     }

package/dist/chart/model/chart-base-element.d.ts

@@ -46,12 +46,14 @@ export declare abstract class ChartBaseElement implements ChartEntity {
      * Enables the functionality of an object.
      * If the object is not currently active, it sets the state to 'deactivated' and activates it.
      * @returns {void}
+     * @deprecated use `ChartBaseElement.activate()` instead
      */
     enable(): void;
     /**
      * Disables the current object if it is not already disabled.
      * If the object is not disabled, it will be deactivated and its state will be set to 'disabled'.
      * @returns {void}
+     * @deprecated use `ChartBaseElement.deactivate()` instead
      */
     disable(): void;
     /**

package/dist/chart/model/chart-base-element.js

@@ -34,6 +34,7 @@ export class ChartBaseElement {
      * Enables the functionality of an object.
      * If the object is not currently active, it sets the state to 'deactivated' and activates it.
      * @returns {void}
+     * @deprecated use `ChartBaseElement.activate()` instead
      */
     enable() {
         if (this._state !== 'active') {
@@ -45,6 +46,7 @@ export class ChartBaseElement {
      * Disables the current object if it is not already disabled.
      * If the object is not disabled, it will be deactivated and its state will be set to 'disabled'.
      * @returns {void}
+     * @deprecated use `ChartBaseElement.deactivate()` instead
      */
     disable() {
         if (this._state !== 'disabled') {

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

@@ -48,7 +48,7 @@ export declare class DataSeriesModel<D extends DataSeriesPoint = DataSeriesPoint
     id: string;
     htId: number;
     name: string;
-    hovered: boolean;
+    highlighted: boolean;
     yAxisLabelProvider: DataSeriesYAxisLabelsProvider;
     readonly config: DataSeriesConfig;
     scale: ScaleModel;

package/dist/chart/model/data-series.model.js

@@ -72,7 +72,7 @@ export class DataSeriesModel extends ChartBaseElement {
         this.id = id;
         this.htId = htId;
         this.name = '';
-        this.hovered = false;
+        this.highlighted = false;
         this._dataPoints = [];
         this.pricePrecisions = [2];
         /**

package/dist/chart/model/date-time.formatter.d.ts

@@ -9,10 +9,10 @@ export interface TimeFormatterConfig {
     shortMonths?: string[];
 }
 export interface DateTimeFormatter {
-    (date: Date | number): string;
+    (date: number): string;
 }
 export type DateTimeFormatterFactory = (format: string) => DateTimeFormatter;
-export declare const defaultDateTimeFormatter: () => (date: Date | number) => string;
+export declare const defaultDateTimeFormatter: () => (date: number) => string;
 /**
  * Default chart-core time formatter.
  * @param config
@@ -20,4 +20,21 @@ export declare const defaultDateTimeFormatter: () => (date: Date | number) => st
  * @doc-tags chart-core,default-config,date-formatter
  */
 export declare const dateTimeFormatterFactory: (config: FullChartConfig, offsetFunction: (timezone: string) => (time: number) => Date) => DateTimeFormatterFactory;
-export declare const recalculateXFormatter: (xAxisLabelFormat: string | Array<DateTimeFormatConfig>, period: number, formatterFactory: (format: string) => (timestamp: number | Date) => string) => DateTimeFormatter;
+/**
+ * Returns an array of short day names based on the provided configuration object.
+ * If the configuration object does not contain shortDays property, it returns an array of default short day names.
+ *
+ * @param {TimeFormatterConfig} config - The configuration object containing shortDays property.
+ * @returns {string[]} - An array of short day names.
+ */
+export declare function getShortDays(config: TimeFormatterConfig): string[];
+/**
+ * Returns an array of short month names based on the provided configuration object.
+ * If the configuration object does not have a 'shortMonths' property, it returns the default array of short month names.
+ *
+ * @param {TimeFormatterConfig} config - The configuration object that contains the shortMonths property.
+ * @returns {string[]} - An array of short month names.
+ */
+export declare function getShortMonths(config: TimeFormatterConfig): string[];
+export declare const recalculateXFormatter: (xAxisLabelFormat: string | Array<DateTimeFormatConfig>, period: number, formatterFactory: (format: string) => (timestamp: number) => string) => DateTimeFormatter;
+export declare const formatDate: (date: Date, patternStr: string, daysOfWeek: string[], months: string[]) => string;

package/dist/chart/model/date-time.formatter.js

@@ -31,7 +31,6 @@ export const dateTimeFormatterFactory = (config, offsetFunction) => {
     ['s', 'm', 'H', 'd', 'M'].forEach(function (k) {
         patterns[k + k] = 'this.' + 'addZero' + '(' + patterns[k] + ')';
     });
-    const re = new RegExp(Object.keys(patterns).sort().reverse().join('|'), 'g');
     /**
      * Returns a string that concatenates the result of the function getPrefix with the input string fn and the string '()'.
      * @param {string} fn - The input string to concatenate.
@@ -58,14 +57,6 @@ export const dateTimeFormatterFactory = (config, offsetFunction) => {
     function upperCase(fn) {
         return fn + '.toUpperCase()';
     }
-    /**
-     * Returns a string that concatenates a pattern from an object with a string
-     * @param {string} pattern - The key of the pattern to be concatenated
-     * @returns {string} - A string that concatenates a pattern from an object with a string
-     */
-    function applyPattern(pattern) {
-        return "' + (" + patterns[pattern] + ") + '";
-    }
     return function (pattern) {
         var _a;
         const context = {
@@ -89,11 +80,10 @@ export const dateTimeFormatterFactory = (config, offsetFunction) => {
             },
             tzDate: offsetFunction((_a = config.timezone) !== null && _a !== void 0 ? _a : '') ||
                 function (date) {
-                    return date instanceof Date ? date : new Date(+date);
+                    return new Date(+date);
                 },
         };
-        // eslint-disable-next-line no-new-func
-        return new Function('date', 'date=this.' + 'tzDate' + "(date); return '" + pattern.replace(re, applyPattern) + "'").bind(context);
+        return (date) => formatDate(context.tzDate(date), pattern, context.shortDays, context.shortMonths);
     };
 };
 /**
@@ -103,7 +93,7 @@ export const dateTimeFormatterFactory = (config, offsetFunction) => {
  * @param {TimeFormatterConfig} config - The configuration object containing shortDays property.
  * @returns {string[]} - An array of short day names.
  */
-function getShortDays(config) {
+export function getShortDays(config) {
     var _a;
     return (_a = config.shortDays) !== null && _a !== void 0 ? _a : ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 }
@@ -114,7 +104,7 @@ function getShortDays(config) {
  * @param {TimeFormatterConfig} config - The configuration object that contains the shortMonths property.
  * @returns {string[]} - An array of short month names.
  */
-function getShortMonths(config) {
+export function getShortMonths(config) {
     var _a;
     return (_a = config.shortMonths) !== null && _a !== void 0 ? _a : ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 }
@@ -154,3 +144,61 @@ export const recalculateXFormatter = (xAxisLabelFormat, period, formatterFactory
     }
     return defaultDateTimeFormatter();
 };
+//#region Custom date pattern parser, transforms Date object to string by given pattern
+// examples: dd.MM => 15.12, YYYY => 2024, HH:mm => 15:56
+export const formatDate = (date, patternStr, daysOfWeek, months) => {
+    if (!patternStr) {
+        patternStr = 'M/d/yyyy';
+    }
+    const day = date.getDate();
+    const month = date.getMonth();
+    const year = date.getFullYear();
+    const hour = date.getHours();
+    const minute = date.getMinutes();
+    const second = date.getSeconds();
+    const miliseconds = date.getMilliseconds();
+    const h = hour % 12;
+    const hh = twoDigitPad(h);
+    const HH = twoDigitPad(hour);
+    const mm = twoDigitPad(minute);
+    const ss = twoDigitPad(second);
+    const aaa = hour < 12 ? 'AM' : 'PM';
+    const EEEE = daysOfWeek[date.getDay()];
+    const EEE = EEEE.substring(0, 3);
+    const dd = twoDigitPad(day);
+    const M = month + 1;
+    const MM = twoDigitPad(M);
+    const MMMM = months[month];
+    const MMM = MMMM.substring(0, 3);
+    const yyyy = year + '';
+    const yy = yyyy.substring(2, 4);
+    // checks to see if month name will be used
+    patternStr = patternStr
+        .replace('hh', hh + '')
+        .replace('h', h + '')
+        .replace('HH', HH + '')
+        .replace('H', hour + '')
+        .replace('mm', mm + '')
+        .replace('m', minute + '')
+        .replace('ss', ss + '')
+        .replace('s', second + '')
+        .replace('S', miliseconds + '')
+        .replace('dd', dd + '')
+        .replace('d', day + '')
+        .replace('EEEE', EEEE)
+        .replace('EEE', EEE)
+        .replace('YYYY', yyyy)
+        .replace('yyyy', yyyy)
+        .replace('YY', yy)
+        .replace('yy', yy)
+        .replace('aaa', aaa);
+    if (patternStr.indexOf('MMM') > -1) {
+        patternStr = patternStr.replace('MMMM', MMMM).replace('MMM', MMM);
+    }
+    else {
+        patternStr = patternStr.replace('MM', MM + '').replace('M', M + '');
+    }
+    return patternStr;
+};
+const twoDigitPad = (num) => (typeof num === 'number' && num < 10 ? '0' + num : num);
+//#endregion

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

@@ -25,6 +25,10 @@ export interface ScaleHistoryItem {
 export declare const getDefaultHighLowWithIndex: () => HighLowWithIndex;
 export type ViewportPercent = number;
 type Constraints = (initialState: ViewportModelState, state: ViewportModelState) => ViewportModelState;
+export interface ZoomReached {
+    max: boolean;
+    min: boolean;
+}
 /**
  * The ScaleModel class represents the state of a chart's scale, including the current viewport, zoom level, and auto-scaling settings.
  * It extends the ViewportModel class, which provides the underlying implementation for handling viewports and zoom levels.
@@ -41,12 +45,13 @@ export declare class ScaleModel extends ViewportModel {
     private canvasAnimation;
     scaleInversedSubject: Subject<boolean>;
     beforeStartAnimationSubject: Subject<void>;
-    history: ScaleHistoryItem[];
     autoScaleModel: AutoScaleViewportSubModel;
     zoomXYRatio: ZoomXToZoomYRatio;
-    offsets: ChartConfigComponentsOffsets;
-    xConstraints: Constraints[];
+    zoomReached: ZoomReached;
     readonly state: ChartScale;
+    history: ScaleHistoryItem[];
+    offsets: ChartConfigComponentsOffsets;
+    private xConstraints;
     constructor(config: FullChartConfig, getBounds: BoundsProvider, canvasAnimation: CanvasAnimation);
     protected doActivate(): void;
     protected doDeactivate(): void;
@@ -82,6 +87,10 @@ export declare class ScaleModel extends ViewportModel {
     zoomXToEnd(zoomIn: boolean, zoomSensitivity: number): void;
     haltAnimation(): void;
     private zoomXTo;
+    calculateZoomReached(zoomX: Unit, zoomIn?: boolean): {
+        max: boolean;
+        min: boolean;
+    };
     /**
      * Moves the viewport to exactly xStart..xEnd place.
      * (you need to fire DRAW event after this)

package/dist/chart/model/scale.model.js

@@ -7,10 +7,9 @@ import { Subject } from 'rxjs';
 import { startViewportModelAnimation } from '../animation/viewport-model-animation';
 import { cloneUnsafe } from '../utils/object.utils';
 import { AutoScaleViewportSubModel } from './scaling/auto-scale.model';
-import { zoomConstraint } from './scaling/constrait.functions';
 import { changeXToKeepRatio, changeYToKeepRatio, ratioFromZoomXY } from './scaling/lock-ratio.model';
 import { moveXStart, moveYStart } from './scaling/move-chart.functions';
-import { ViewportModel, compareStates } from './scaling/viewport.model';
+import { ViewportModel, calculateZoom, compareStates, } from './scaling/viewport.model';
 import { zoomXToEndViewportCalculator, zoomXToPercentViewportCalculator } from './scaling/x-zooming.functions';
 export const getDefaultHighLowWithIndex = () => ({
     high: Number.NEGATIVE_INFINITY,
@@ -37,9 +36,10 @@ export class ScaleModel extends ViewportModel {
         this.scaleInversedSubject = new Subject();
         // y-axis component needs this subject in order to halt prev animation if axis type is percent
         this.beforeStartAnimationSubject = new Subject();
+        this.zoomXYRatio = 0;
+        this.zoomReached = { min: false, max: false };
         // TODO rework, make a new history based on units
         this.history = [];
-        this.zoomXYRatio = 0;
         this.xConstraints = [];
         this.scalePostProcessor = (initialState, state) => {
             // for now <s>reduceRight<s/> reduce bcs ChartModel#getZoomConstrait should be invoked first
@@ -49,12 +49,12 @@ export class ScaleModel extends ViewportModel {
         this.state = cloneUnsafe(config.scale);
         this.autoScaleModel = new AutoScaleViewportSubModel(this);
         this.offsets = this.config.components.offsets;
-        this.addXConstraint((initialState, state) => zoomConstraint(initialState, state, this.config.components.chart, this.getBounds));
     }
     doActivate() {
         super.doActivate();
         this.scaleInversedSubject = new Subject();
         this.beforeStartAnimationSubject = new Subject();
+        this.zoomReached = this.calculateZoomReached(this.export().zoomX);
         this.addRxSubscription(this.scaleInversedSubject.subscribe(() => {
             this.fireChanged();
         }));
@@ -102,7 +102,7 @@ export class ScaleModel extends ViewportModel {
         this.beforeStartAnimationSubject.next();
         const state = this.export();
         zoomXToPercentViewportCalculator(this, state, viewportPercent, zoomSensitivity, zoomIn);
-        this.zoomXTo(state, disabledAnimations);
+        this.zoomXTo(state, zoomIn, disabledAnimations);
     }
     /**
      * Zooms the X axis of the chart relativly to the end of the data range.
@@ -116,7 +116,7 @@ export class ScaleModel extends ViewportModel {
         this.beforeStartAnimationSubject.next();
         const state = this.export();
         zoomXToEndViewportCalculator(this, state, zoomSensitivity, zoomIn);
-        this.zoomXTo(state, this.config.scale.disableAnimations);
+        this.zoomXTo(state, zoomIn, this.config.scale.disableAnimations);
     }
     haltAnimation() {
         var _a;
@@ -125,9 +125,13 @@ export class ScaleModel extends ViewportModel {
             this.doAutoScale();
         }
     }
-    zoomXTo(state, forceNoAnimation) {
+    zoomXTo(state, zoomIn, forceNoAnimation) {
         const initialStateCopy = Object.assign({}, state);
         const constrainedState = this.scalePostProcessor(initialStateCopy, state);
+        this.zoomReached = this.calculateZoomReached(constrainedState.zoomX, zoomIn);
+        if (this.zoomReached.max || this.zoomReached.min) {
+            return;
+        }
         if (this.state.lockPriceToBarRatio) {
             changeYToKeepRatio(constrainedState, this.zoomXYRatio);
         }
@@ -141,6 +145,20 @@ export class ScaleModel extends ViewportModel {
             startViewportModelAnimation(this.canvasAnimation, this, constrainedState);
         }
     }
+    calculateZoomReached(zoomX, zoomIn = true) {
+        const chartWidth = this.getBounds().width;
+        const delta = 0.001; // zoom values are very precise and should be compared with some precision delta
+        if (chartWidth > 0) {
+            const maxZoomReached = zoomX - calculateZoom(this.config.components.chart.minCandles, chartWidth) <= delta;
+            // max zoom reached and trying to zoom in further
+            const maxZoomDisabled = maxZoomReached && zoomIn;
+            const minZoomReached = zoomX - calculateZoom(chartWidth / this.config.components.chart.minWidth, chartWidth) >= delta;
+            // min zoom reached and trying to zoom out further
+            const minZoomDisabled = minZoomReached && !zoomIn;
+            return { max: maxZoomDisabled, min: minZoomDisabled };
+        }
+        return { max: false, min: false };
+    }
     /**
      * Moves the viewport to exactly xStart..xEnd place.
      * (you need to fire DRAW event after this)
@@ -152,8 +170,16 @@ export class ScaleModel extends ViewportModel {
     setXScale(xStart, xEnd, forceNoAnimation = true) {
         const initialState = this.export();
         const zoomX = this.calculateZoomX(xStart, xEnd);
+        if (initialState.xStart === xStart && initialState.xEnd === xEnd) {
+            return;
+        }
         const state = Object.assign(Object.assign({}, initialState), { zoomX, xStart, xEnd });
         const constrainedState = this.scalePostProcessor(initialState, state);
+        const zoomIn = constrainedState.xEnd - constrainedState.xStart < initialState.xEnd - initialState.xStart;
+        this.zoomReached = this.calculateZoomReached(zoomX, zoomIn);
+        if (this.zoomReached.max || this.zoomReached.min) {
+            return;
+        }
         if (this.state.lockPriceToBarRatio) {
             changeYToKeepRatio(constrainedState, this.zoomXYRatio);
         }
@@ -170,6 +196,9 @@ export class ScaleModel extends ViewportModel {
     }
     setYScale(yStart, yEnd, fire = false) {
         const initialState = this.export();
+        if (initialState.yStart === yStart && initialState.yEnd === yEnd) {
+            return;
+        }
         super.setYScale(yStart, yEnd, fire);
         const state = this.export();
         const constrainedState = this.scalePostProcessor(initialState, state);

package/dist/chart/model/scaling/constrait.functions.d.ts

@@ -3,8 +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 { ChartConfigComponentsChart } from '../../chart.config';
-import { Bounds, BoundsProvider } from '../bounds.model';
+import { Bounds } from '../bounds.model';
 import VisualCandle from '../visual-candle';
 import { ViewportModelState } from './viewport.model';
 /**
@@ -27,17 +26,3 @@ export declare const candleEdgesConstrait: (state: ViewportModelState, visualCan
     zoomY: number;
     inverseY: boolean;
 };
-/**
- * This function limits minimum and maximum chart viewport dependening on visible x-units
- * @returns
- * @doc-tags viewport,zoom,scaling
- */
-export declare const zoomConstraint: (_: ViewportModelState, state: ViewportModelState, chartConfig: ChartConfigComponentsChart, boundsProvider: BoundsProvider) => {
-    xStart: number;
-    xEnd: number;
-    yStart: number;
-    yEnd: number;
-    zoomX: number;
-    zoomY: number;
-    inverseY: boolean;
-};

package/dist/chart/model/scaling/constrait.functions.js

@@ -4,7 +4,7 @@
  * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 import { at } from '../../utils/array.utils';
-import { calculateZoom, pixelsToUnits } from './viewport.model';
+import { pixelsToUnits } from './viewport.model';
 /**
  * Return constraited state that handled zooming and moving chart near first/last candles
  * this and other constraits that works with state should mutate and return state
@@ -35,31 +35,3 @@ export const candleEdgesConstrait = (state, visualCandlesCoordinates, candleLimi
     newState.xEnd = normalizedXEnd;
     return newState;
 };
-/**
- * This function limits minimum and maximum chart viewport dependening on visible x-units
- * @returns
- * @doc-tags viewport,zoom,scaling
- */
-export const zoomConstraint = (_, state, chartConfig, boundsProvider) => {
-    const newState = Object.assign({}, state);
-    const bounds = boundsProvider();
-    // 1 - is an average candle width: newXEnd - newXStart = avg candles amount in the viewport
-    const avgCandlesInViewport = newState.xEnd - newState.xStart;
-    const minViewportReached = avgCandlesInViewport < chartConfig.minCandles;
-    const maxCandlesInViewport = bounds.width / chartConfig.minWidth;
-    const maxViewportReached = avgCandlesInViewport > maxCandlesInViewport;
-    // rules work only if chart is shown
-    if (bounds.width > 0) {
-        if (maxViewportReached) {
-            newState.xStart = newState.xEnd - maxCandlesInViewport;
-            newState.zoomX = calculateZoom(newState.xEnd - newState.xStart, bounds.width);
-            return newState;
-        }
-        if (minViewportReached) {
-            newState.xStart = newState.xEnd - chartConfig.minCandles;
-            newState.zoomX = calculateZoom(newState.xEnd - newState.xStart, bounds.width);
-            return newState;
-        }
-    }
-    return newState;
-};

package/dist/chart/model/time-zone.model.js

@@ -87,7 +87,9 @@ export class TimeZoneModel {
             // In JS Date object is created with local tz offset,
             // so we have to subtract localOffset from current time
             return time => {
-                return new Date(time + getTimezoneOffset(timezone, time) + new Date(time).getTimezoneOffset() * timeMultiplier);
+                return new Date(time +
+                    getTimezoneOffset(timezone, time) +
+                    new Date(time).getTimezoneOffset() * timeMultiplier);
             };
         }
     }