@devexperts/dxcharts-lite 2.5.5 → 2.5.6

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

@@ -83,7 +83,7 @@ export class CanvasBoundsContainer {
         this.rightRatio = 0;
         this.boundsChangedSubject = new Subject();
         this.barResizerChangedSubject = new Subject();
-        this._graphsHeightRatio = { chart: 1 };
+        this._graphsHeightRatio = { [CHART_UUID]: 1 };
         this.graphsHeightRatioChangedSubject = new Subject();
         this.boundsChangedSubscriptions = {};
         chartResizeHandler.canvasResized.subscribe(bcr => {

package/dist/chart/components/chart/basic-scale.js

@@ -15,7 +15,6 @@ export const createBasicScaleViewportTransformer = (scale) => (visualCandleSourc
         const endCandle = vCandles[vCandles.length - 1];
         scale.setXScale(startCandle.startUnit, endCandle.startUnit + endCandle.width + scale.offsets.right);
         scale.doAutoScale(true);
-        scale.recalculateZoomXYRatio();
         scale.fireChanged();
     }
 };

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

@@ -7,7 +7,6 @@ import { Subject } from 'rxjs';
 import { ChartConfigComponentsOffsets, ChartScale, FullChartConfig } from '../chart.config';
 import { CanvasAnimation } from '../animation/canvas-animation';
 import { AutoScaleViewportSubModel } from './scaling/auto-scale.model';
-import { ZoomXToZoomYRatio } from './scaling/lock-ratio.model';
 import { Price, Unit, ViewportModel, ViewportModelState, Zoom } from './scaling/viewport.model';
 import { BoundsProvider } from './bounds.model';
 export interface HighLowWithIndex {
@@ -46,7 +45,6 @@ export declare class ScaleModel extends ViewportModel {
     scaleInversedSubject: Subject<boolean>;
     beforeStartAnimationSubject: Subject<void>;
     autoScaleModel: AutoScaleViewportSubModel;
-    zoomXYRatio: ZoomXToZoomYRatio;
     zoomReached: ZoomReached;
     readonly state: ChartScale;
     history: ScaleHistoryItem[];
@@ -101,6 +99,7 @@ export declare class ScaleModel extends ViewportModel {
      */
     setXScale(xStart: Unit, xEnd: Unit, forceNoAnimation?: boolean): void;
     setYScale(yStart: Unit, yEnd: Unit, fire?: boolean): void;
+    private setLockedYScale;
     /**
      * Moves both xStart and xEnd without changing the viewport width (zoom).
      * Works without animation.
@@ -165,10 +164,6 @@ export declare class ScaleModel extends ViewportModel {
      * @param value - If true, the price-to-bar ratio will be locked. If false, it will not be locked.
      */
     setLockPriceToBarRatio(value?: boolean): void;
-    /**
-     * Recalculates the zoom X/Y ratio based on the current zoom levels.
-     */
-    recalculateZoomXYRatio(): void;
 }
 /**
  * The SyncedByXScaleModel class extends the ScaleModel class and adds support for synchronization with other ScaleModel instance, so both instances maintain the same X-axis bounds.

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

@@ -7,7 +7,7 @@ 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 { changeXToKeepRatio, changeYToKeepRatio, ratioFromZoomXY } from './scaling/lock-ratio.model';
+import { changeXToKeepRatio, changeYToKeepRatio } from './scaling/lock-ratio.model';
 import { moveXStart, moveYStart } from './scaling/move-chart.functions';
 import { ViewportModel, calculateZoom, compareStates, } from './scaling/viewport.model';
 import { zoomXToEndViewportCalculator, zoomXToPercentViewportCalculator } from './scaling/x-zooming.functions';
@@ -36,7 +36,6 @@ 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 = [];
@@ -133,7 +132,7 @@ export class ScaleModel extends ViewportModel {
             return;
         }
         if (this.state.lockPriceToBarRatio) {
-            changeYToKeepRatio(constrainedState, this.zoomXYRatio);
+            changeYToKeepRatio(initialStateCopy, constrainedState);
         }
         if (this.state.auto) {
             this.autoScaleModel.doAutoYScale(constrainedState);
@@ -181,7 +180,7 @@ export class ScaleModel extends ViewportModel {
             return;
         }
         if (this.state.lockPriceToBarRatio) {
-            changeYToKeepRatio(constrainedState, this.zoomXYRatio);
+            changeYToKeepRatio(initialState, constrainedState);
         }
         if (this.state.auto) {
             this.autoScaleModel.doAutoYScale(constrainedState);
@@ -199,21 +198,30 @@ export class ScaleModel extends ViewportModel {
         if (initialState.yStart === yStart && initialState.yEnd === yEnd && initialState.zoomY > 0) {
             return;
         }
+        if (this.state.lockPriceToBarRatio) {
+            this.setLockedYScale(yStart, yEnd, fire, initialState);
+            return;
+        }
         super.setYScale(yStart, yEnd, fire);
         const state = this.export();
         const constrainedState = this.scalePostProcessor(initialState, state);
-        if (this.state.lockPriceToBarRatio) {
-            changeXToKeepRatio(constrainedState, this.zoomXYRatio);
-            this.setXScale(constrainedState.xStart, constrainedState.xEnd);
-            // TODO: rewrite logic for applying constraints to consider both axes, now constraints on Y may not work correctly
-            return;
+        if (this.state.auto) {
+            this.autoScaleModel.doAutoYScale(constrainedState);
         }
-        else {
-            if (this.state.auto) {
-                this.autoScaleModel.doAutoYScale(constrainedState);
-            }
-            this.apply(constrainedState);
+        this.apply(constrainedState);
+    }
+    setLockedYScale(yStart, yEnd, fire = false, initialState) {
+        const zoomIn = yEnd < initialState.yEnd;
+        if ((this.zoomReached.min && zoomIn === false) || (this.zoomReached.max && zoomIn === true)) {
+            return;
         }
+        super.setYScale(yStart, yEnd, fire);
+        const state = this.export();
+        const constrainedState = this.scalePostProcessor(initialState, state);
+        changeXToKeepRatio(initialState, constrainedState);
+        this.zoomReached = this.calculateZoomReached(constrainedState.zoomX, zoomIn);
+        this.apply(constrainedState);
+        this.fireChanged();
     }
     /**
      * Moves both xStart and xEnd without changing the viewport width (zoom).
@@ -342,17 +350,8 @@ export class ScaleModel extends ViewportModel {
             this.state.lockPriceToBarRatio = false;
             return;
         }
-        if (value) {
-            this.recalculateZoomXYRatio();
-        }
         this.state.lockPriceToBarRatio = value;
     }
-    /**
-     * Recalculates the zoom X/Y ratio based on the current zoom levels.
-     */
-    recalculateZoomXYRatio() {
-        this.zoomXYRatio = ratioFromZoomXY(this.zoomX, this.zoomY);
-    }
 }
 /**
  * The SyncedByXScaleModel class extends the ScaleModel class and adds support for synchronization with other ScaleModel instance, so both instances maintain the same X-axis bounds.

package/dist/chart/model/scaling/lock-ratio.model.d.ts

@@ -10,13 +10,13 @@ export declare const zoomXToZoomY: (zoomX: Zoom, ratio: ZoomXToZoomYRatio) => Zo
 export declare const zoomYToZoomX: (zoomY: Zoom, ratio: ZoomXToZoomYRatio) => Zoom;
 /**
  * Locks the zoomY with zoomX and zooms y-scale depending on x-scale.
- * @param state
- * @param zoomXYRatio
+ * @param prevState
+ * @param newState
  */
-export declare const changeYToKeepRatio: (state: ViewportModelState, zoomXYRatio: ZoomXToZoomYRatio) => void;
+export declare const changeYToKeepRatio: (prevState: ViewportModelState, newState: ViewportModelState) => void;
 /**
  *  Locks the zoomY with zoomX and zooms x-scale depending on y-scale.
- * @param state
- * @param zoomXYRatio
+ * @param prevState
+ * @param newState
  */
-export declare const changeXToKeepRatio: (state: ViewportModelState, zoomXYRatio: ZoomXToZoomYRatio) => void;
+export declare const changeXToKeepRatio: (prevState: ViewportModelState, newState: ViewportModelState) => void;

package/dist/chart/model/scaling/lock-ratio.model.js

@@ -8,30 +8,36 @@ export const zoomXToZoomY = (zoomX, ratio) => zoomX / ratio;
 export const zoomYToZoomX = (zoomY, ratio) => zoomY * ratio;
 /**
  * Locks the zoomY with zoomX and zooms y-scale depending on x-scale.
- * @param state
- * @param zoomXYRatio
+ * @param prevState
+ * @param newState
  */
-export const changeYToKeepRatio = (state, zoomXYRatio) => {
-    const prevZoomY = state.zoomY;
-    state.zoomY = zoomXToZoomY(state.zoomX, zoomXYRatio);
-    const zoomYMult = state.zoomY / prevZoomY;
-    const lastYHeight = state.yEnd - state.yStart;
-    const newYHeight = lastYHeight * zoomYMult;
-    const delta = newYHeight - lastYHeight;
-    state.yEnd = state.yEnd + delta / 2;
-    state.yStart = state.yStart - delta / 2;
+export const changeYToKeepRatio = (prevState, newState) => {
+    const prevZoomX = prevState.zoomX;
+    const prevZoomY = prevState.zoomY;
+    const prevZoomXY = ratioFromZoomXY(prevZoomX, prevZoomY);
+    const prevYHeight = prevState.yEnd - prevState.yStart;
+    // recalculate zoomY
+    newState.zoomY = zoomXToZoomY(newState.zoomX, prevZoomXY);
+    const zoomYMult = newState.zoomY / prevZoomY;
+    const newYHeight = prevYHeight * zoomYMult;
+    const delta = newYHeight - prevYHeight;
+    newState.yEnd = newState.yEnd + delta / 2;
+    newState.yStart = newState.yStart - delta / 2;
 };
 /**
  *  Locks the zoomY with zoomX and zooms x-scale depending on y-scale.
- * @param state
- * @param zoomXYRatio
+ * @param prevState
+ * @param newState
  */
-export const changeXToKeepRatio = (state, zoomXYRatio) => {
-    const prevZoomX = state.zoomX;
-    state.zoomX = zoomYToZoomX(state.zoomY, zoomXYRatio);
-    const zoomXMult = state.zoomX / prevZoomX;
-    const lastXWidth = state.xEnd - state.xStart;
-    const newXWidth = lastXWidth * zoomXMult;
-    const delta = newXWidth - lastXWidth;
-    state.xStart = state.xStart - delta;
+export const changeXToKeepRatio = (prevState, newState) => {
+    const prevZoomX = prevState.zoomX;
+    const prevZoomY = prevState.zoomY;
+    const prevZoomXY = ratioFromZoomXY(prevZoomX, prevZoomY);
+    const prevXWidth = prevState.xEnd - prevState.xStart;
+    // recalculate zoomX
+    newState.zoomX = zoomYToZoomX(newState.zoomY, prevZoomXY);
+    const zoomXMult = newState.zoomX / prevZoomX;
+    const newXWidth = prevXWidth * zoomXMult;
+    const delta = newXWidth - prevXWidth;
+    newState.xStart = newState.xStart - delta;
 };

package/dist/chart/model/scaling/viewport.model.js

@@ -287,7 +287,12 @@ export class ViewportModel extends ChartBaseElement {
      * @returns {boolean} - Returns true if the viewport is valid, false otherwise.
      */
     isViewportValid() {
-        return this.xStart !== this.xEnd && this.yStart !== this.yEnd && isFinite(this.yStart) && isFinite(this.yEnd) && this.zoomX > 0 && this.zoomY > 0;
+        return (this.xStart !== this.xEnd &&
+            this.yStart !== this.yEnd &&
+            isFinite(this.yStart) &&
+            isFinite(this.yEnd) &&
+            this.zoomX > 0 &&
+            this.zoomY > 0);
     }
 }
 export const compareStates = (a, b) => !keys(a).some(k => a[k] !== b[k]);