@devexperts/dxcharts-lite 1.0.1 → 2.0.0

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

@@ -1,6 +1,321 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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{Subject as c}from"rxjs";import{startViewportModelAnimation as l}from"../animation/viewport-model-animation";import{cloneUnsafe as u}from"../utils/object.utils";import{AutoScaleViewportSubModel as d}from"./scaling/auto-scale.model";import{zoomConstraint as m}from"./scaling/constrait.functions";import{lockedYEndViewportCalculator as a,ratioFromZoomXY as p}from"./scaling/lock-ratio.model";import{moveXStart as f,moveYStart as S}from"./scaling/move-chart.functions";import{ViewportModel as g,compareStates as x}from"./scaling/viewport.model";import{zoomXToEndViewportCalculator as A,zoomXToPercentViewportCalculator as y}from"./scaling/x-zooming.functions";export const getDefaultHighLowWithIndex=()=>({high:Number.NEGATIVE_INFINITY,low:Number.POSITIVE_INFINITY,highIdx:0,lowIdx:0});export class ScaleModel extends g{constructor(t,s,e){super(),this.config=t,this.getBounds=s,this.canvasAnimation=e,this.scaleInversedSubject=new c,this.history=[],this.zoomXYRatio=0,this.xConstraints=[],this.scalePostProcessor=(o,i)=>this.xConstraints.reduce((n,h)=>h(o,n),i),this.state=u(t.scale),this.autoScaleModel=new d(this),this.offsets=this.config.components.offsets,this.addXConstraint((o,i)=>m(o,i,this.config.components.chart,this.getBounds))}addXConstraint(t){this.xConstraints=[...this.xConstraints,t]}updateOffsets(t){this.offsets=Object.assign(Object.assign({},this.offsets),t),this.doAutoScale(!0)}getOffsets(){return this.offsets}zoomXToPercent(t,s,e=!1,o=this.config.scale.zoomSensitivity){this.config.components.yAxis.type==="percent"&&this.haltAnimation();const i=this.export();y(this,i,t,o,s),this.zoomXTo(i,e)}zoomXToEnd(t,s=this.config.scale.zoomSensitivity){this.config.components.yAxis.type==="percent"&&this.haltAnimation();const e=this.export();A(this,e,s,t),this.zoomXTo(e)}haltAnimation(){var t;!((t=this.currentAnimation)===null||t===void 0)&&t.animationInProgress&&(this.currentAnimation.finishAnimation(),this.doAutoScale())}zoomXTo(t,s){const e=Object.assign({},t),o=this.scalePostProcessor(e,t);this.state.lockPriceToBarRatio&&a(o,this.zoomXYRatio),this.state.auto&&this.autoScaleModel.setAutoAndRecalculateState(o,!0),s?this.apply(o):l(this.canvasAnimation,this,o)}setXScale(t,s){const e=this.export();super.setXScale(t,s,!1);const o=this.export(),i=this.scalePostProcessor(e,o);this.state.lockPriceToBarRatio&&a(i,this.zoomXYRatio),this.state.auto&&this.autoScaleModel.setAutoAndRecalculateState(i,!0),this.apply(i)}moveXStart(t){const s=this.export(),e=Object.assign({},s);this.haltAnimation(),f(s,t);const o=this.scalePostProcessor(e,s);this.state.auto&&this.autoScaleModel.setAutoAndRecalculateState(o,!0),this.apply(o)}moveYStart(t){if(this.haltAnimation(),!this.state.auto){const s=this.export();S(s,t),this.apply(s)}}doAutoScale(t=!1){if(!this.isViewportAnimationInProgress()&&this.state.auto||t){const s=this.export();this.autoScaleModel.setAutoAndRecalculateState(s,!0),x(s,this.export())||this.apply(s)}}isViewportAnimationInProgress(){const t=this.currentAnimation;return t==null?void 0:t.animationInProgress}pushToHistory(t){this.history.push(t)}popFromHistory(){return this.history.pop()}clearHistory(){this.history=[]}isDefaultXBounds(){return this.xStart===0&&this.xEnd===0}isDefaultYBounds(){return this.yStart===0&&this.yEnd===0}isScaleReady(){return!this.isDefaultXBounds()&&!this.isDefaultYBounds()}autoScale(t=!0){this.config.components.yAxis.type==="percent"?this.state.auto=!0:this.state.auto=t,t&&(this.clearHistory(),this.doAutoScale())}setLockPriceToBarRatio(t=!1){const{type:s}=this.config.components.yAxis;if(s==="percent"||s==="logarithmic"){this.state.lockPriceToBarRatio=!1;return}t&&this.recalculateZoomXYRatio(),this.state.lockPriceToBarRatio=t}recalculateZoomXYRatio(){this.zoomXYRatio=p(this.zoomX,this.zoomY)}}export class SyncedByXScaleModel extends ScaleModel{constructor(t,s,e,o){super(s,e,o),this.delegate=t,this.config=s,this.getBounds=e}doActivate(){this.addRxSubscription(this.delegate.xChanged.subscribe(()=>this.doAutoScale(this.state.auto)))}get xStart(){return this.delegate.xStart}set xStart(t){this.delegate.xStart=t}get xEnd(){return this.delegate.xEnd}set xEnd(t){this.delegate.xEnd=t}get zoomX(){return this.delegate.zoomX}set zoomX(t){this.delegate.zoomX=t}observeXChanged(){return this.delegate.xChanged}fireChanged(){this.delegate.changed.next(),this.changed.next()}}
+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 { lockedYEndViewportCalculator, ratioFromZoomXY } from './scaling/lock-ratio.model';
+import { moveXStart, moveYStart } from './scaling/move-chart.functions';
+import { ViewportModel, compareStates } from './scaling/viewport.model';
+import { zoomXToEndViewportCalculator, zoomXToPercentViewportCalculator } from './scaling/x-zooming.functions';
+export const getDefaultHighLowWithIndex = () => ({
+    high: Number.NEGATIVE_INFINITY,
+    low: Number.POSITIVE_INFINITY,
+    highIdx: 0,
+    lowIdx: 0,
+});
+/**
+ * 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.
+ * Controls current visible CHART viewport.
+ * Has additional logic:
+ * - auto-scale
+ * - locked scale
+ * - zooming functions
+ * - history
+ */
+export class ScaleModel extends ViewportModel {
+    constructor(config, getBounds, canvasAnimation) {
+        super();
+        this.config = config;
+        this.getBounds = getBounds;
+        this.canvasAnimation = canvasAnimation;
+        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();
+        // 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
+            // if we will need more complex order handling -> add some managing
+            return this.xConstraints.reduce((acc, cur) => cur(initialState, acc), state);
+        };
+        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));
+    }
+    /**
+     * The method adds a new "constraint" to the existing list of x-axis constraints for charting.
+     * The "constrait" is expected to be an object containing information about the constraints, such as the minimum and maximum values for the x-axis.
+     * @param constraint
+     */
+    addXConstraint(constraint) {
+        this.xConstraints = [...this.xConstraints, constraint];
+    }
+    /**
+     * The method updates the offsets for the scale model based on the provided "offsets" object.
+     * Note that the method modifies the offsets and triggers an autoscale
+     * @param offsets
+     */
+    updateOffsets(offsets) {
+        this.offsets = Object.assign(Object.assign({}, this.offsets), offsets);
+        this.doAutoScale(true);
+    }
+    /**
+     * @returns current offsets
+     */
+    getOffsets() {
+        return this.offsets;
+    }
+    /**
+     * Zooms the X axis of the chart to a specified percentage of the viewport.
+     * @param viewportPercent The percentage of the viewport width to zoom to.
+     * @param zoomIn Whether to zoom in or out.
+     * @param forceNoAnimation Whether to skip animation.
+     * @param zoomSensitivity The sensitivity of the zoom.
+     */
+    zoomXToPercent(viewportPercent, zoomIn, forceNoAnimation = false, zoomSensitivity = this.config.scale.zoomSensitivity) {
+        this.beforeStartAnimationSubject.next();
+        const state = this.export();
+        zoomXToPercentViewportCalculator(this, state, viewportPercent, zoomSensitivity, zoomIn);
+        this.zoomXTo(state, forceNoAnimation);
+    }
+    /**
+     * Zooms the X axis of the chart relativly to the end of the data range.
+     * @param zoomIn - If true, the chart will be zoomed in. If false, the chart will be zoomed out.
+     * @param zoomSensitivity - The sensitivity of the zoom. Default value is taken from the configuration object.
+     */
+    zoomXToEnd(zoomIn, zoomSensitivity = this.config.scale.zoomSensitivity) {
+        this.beforeStartAnimationSubject.next();
+        const state = this.export();
+        zoomXToEndViewportCalculator(this, state, zoomSensitivity, zoomIn);
+        this.zoomXTo(state);
+    }
+    haltAnimation() {
+        var _a;
+        if ((_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.animationInProgress) {
+            this.currentAnimation.finishAnimation();
+            this.doAutoScale();
+        }
+    }
+    zoomXTo(state, forceNoAnimation) {
+        const initialStateCopy = Object.assign({}, state);
+        const constrainedState = this.scalePostProcessor(initialStateCopy, state);
+        if (this.state.lockPriceToBarRatio) {
+            lockedYEndViewportCalculator(constrainedState, this.zoomXYRatio);
+        }
+        if (this.state.auto) {
+            this.autoScaleModel.setAutoAndRecalculateState(constrainedState, true);
+        }
+        if (forceNoAnimation) {
+            this.apply(constrainedState);
+        }
+        else {
+            startViewportModelAnimation(this.canvasAnimation, this, constrainedState);
+        }
+    }
+    /**
+     * Moves the viewport to exactly xStart..xEnd place.
+     * (you need to fire DRAW event after this)
+     * @param xStart - viewport start in units
+     * @param xEnd - viewport end in units
+     * @param fireChanged
+     * @param forceNoAutoScale - force NOT apply auto-scaling (for lazy loading)
+     */
+    setXScale(xStart, xEnd) {
+        const initialState = this.export();
+        super.setXScale(xStart, xEnd, false);
+        const state = this.export();
+        const constraitedState = this.scalePostProcessor(initialState, state);
+        if (this.state.lockPriceToBarRatio) {
+            lockedYEndViewportCalculator(constraitedState, this.zoomXYRatio);
+        }
+        if (this.state.auto) {
+            this.autoScaleModel.setAutoAndRecalculateState(constraitedState, true);
+        }
+        this.apply(constraitedState);
+    }
+    /**
+     * Moves both xStart and xEnd without changing the viewport width (zoom).
+     * WILL CHANGE the Y axis if scale.auto=true.
+     * @param xStart - starting point in units
+     */
+    moveXStart(xStart) {
+        const state = this.export();
+        const initialStateCopy = Object.assign({}, state);
+        // always stop the animations
+        this.haltAnimation();
+        moveXStart(state, xStart);
+        // there we need only candles constrait
+        const constraitedState = this.scalePostProcessor(initialStateCopy, state);
+        if (this.state.auto) {
+            this.autoScaleModel.setAutoAndRecalculateState(constraitedState, true);
+        }
+        this.apply(constraitedState);
+    }
+    /**
+     * Moves both yStart and yEnd without changing the viewport height (zoom).
+     * Will not move viewport if scale.auto=true
+     * @param yStart - starting point in units
+     */
+    moveYStart(yStart) {
+        this.haltAnimation();
+        if (this.state.auto) {
+            return;
+        }
+        else {
+            const state = this.export();
+            moveYStart(state, yStart);
+            this.apply(state);
+        }
+    }
+    /**
+     * Automatically scales the chart to fit the data range.
+     * @param forceApply - If true, the chart will be forcefully auto-scaled even if animation is in progress.
+     */
+    doAutoScale(forceApply = false) {
+        // dont auto-scale if animation, otherwise - forced or config
+        if ((!this.isViewportAnimationInProgress() && this.state.auto) || forceApply) {
+            const state = this.export();
+            this.autoScaleModel.setAutoAndRecalculateState(state, true);
+            if (!compareStates(state, this.export())) {
+                this.apply(state);
+            }
+        }
+    }
+    /**
+     * Checks if viewport animation is currently in progress.
+     * @returns returns true if viewport animation is in progress, false otherwise.
+     */
+    isViewportAnimationInProgress() {
+        const animation = this.currentAnimation;
+        return animation === null || animation === void 0 ? void 0 : animation.animationInProgress;
+    }
+    /**
+     * Adds an item to the scale history.
+     * @param item - The item to add to the history.
+     */
+    pushToHistory(item) {
+        this.history.push(item);
+    }
+    /**
+     * Removes the most recent item from the scale history and returns it.
+     * @returns - The most recent item from the history, or undefined if the history is empty.
+     */
+    popFromHistory() {
+        return this.history.pop();
+    }
+    /**
+     * Clears the scale history.
+     */
+    clearHistory() {
+        this.history = [];
+    }
+    /**
+     * Checks if the X axis bounds are the default values.
+     * @returns if false - it means there are candles and it's possible to do scaling and add drawings
+     */
+    isDefaultXBounds() {
+        return this.xStart === 0 && this.xEnd === 0;
+    }
+    /**
+     * Checks if the Y axis bounds are the default values.
+     * @returns if false - it means there are candles and it's possible to do scaling and add drawings
+     */
+    isDefaultYBounds() {
+        return this.yStart === 0 && this.yEnd === 0;
+    }
+    /**
+     * Checks if the scale is ready to be used.
+     * @returns - Returns true if the scale is ready, false otherwise.
+     */
+    isScaleReady() {
+        return !this.isDefaultXBounds() && !this.isDefaultYBounds();
+    }
+    /**
+     * Enables or disables auto-scaling of the chart.
+     * @param auto - If true, the chart will be automatically scaled. If false, auto-scaling will be disabled.
+     */
+    autoScale(auto = true) {
+        // TODO rework, make this a separate feature toggle, describe in docs; this should be a business-logic level
+        if (this.config.components.yAxis.type === 'percent') {
+            this.state.auto = true;
+        }
+        else {
+            this.state.auto = auto;
+        }
+        if (auto) {
+            this.clearHistory();
+            this.doAutoScale();
+        }
+    }
+    /**
+     * Sets whether the price-to-bar ratio should be locked or not.
+     * @param value - If true, the price-to-bar ratio will be locked. If false, it will not be locked.
+     */
+    setLockPriceToBarRatio(value = false) {
+        const { type } = this.config.components.yAxis;
+        // TODO rework, why such logic? same as above, if we have business-logic like this one => make it separate code
+        if (type === 'percent' || type === 'logarithmic') {
+            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.
+ * This is useful for scenarios where multiple charts need to display the same X-axis data, but with different Y-axis scales.
+ */
+export class SyncedByXScaleModel extends ScaleModel {
+    constructor(delegate, config, getBounds, canvasAnimation) {
+        super(config, getBounds, canvasAnimation);
+        this.delegate = delegate;
+        this.config = config;
+        this.getBounds = getBounds;
+    }
+    doActivate() {
+        this.addRxSubscription(this.delegate.xChanged.subscribe(() => this.doAutoScale(this.state.auto)));
+    }
+    get xStart() {
+        return this.delegate.xStart;
+    }
+    set xStart(value) {
+        this.delegate.xStart = value;
+    }
+    get xEnd() {
+        return this.delegate.xEnd;
+    }
+    set xEnd(value) {
+        this.delegate.xEnd = value;
+    }
+    get zoomX() {
+        return this.delegate.zoomX;
+    }
+    set zoomX(value) {
+        this.delegate.zoomX = value;
+    }
+    observeXChanged() {
+        return this.delegate.xChanged;
+    }
+    fireChanged() {
+        this.delegate.changed.next();
+        this.changed.next();
+    }
+}

package/dist/chart/model/scaling/auto-scale.model.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */

package/dist/chart/model/scaling/auto-scale.model.js

@@ -1,6 +1,102 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */
-export class AutoScaleViewportSubModel{constructor(o,e){this.delegate=o,this.auto=!0,this.highLowPostPorcessor={},this.highLowProviders=e!=null?e:{}}setHighLowProvider(o,e){this.highLowProviders[o]=e}deleteHighLowProvider(o){delete this.highLowProviders[o]}setHighLowPostProcessor(o,e){this.highLowPostPorcessor[o]=e}setAutoAndRecalculateState(o,e){this.auto=e,e&&autoScaleYViewportTransformer(this.delegate,o,Object.values(this.highLowProviders),Object.values(this.highLowPostPorcessor))}}export const autoScaleYViewportTransformer=(i,o,e,t)=>{const h=e.filter(r=>r.isHighLowActive()).map(r=>r.calculateHighLow(o)),l=mergeHighLow(h),s=t.reduce((r,c)=>c(r),l);o.yStart=s.low,o.yEnd=s.high,o.zoomY=i.calculateZoomY(o.yStart,o.yEnd)};export function mergeHighLow(i){if(i.length===0)return getDefaultHighLow();let o=i[0].high,e=i[0].low;return i.forEach(t=>{isFinite(t.high)&&t.high>=o&&(o=t.high),isFinite(t.low)&&t.low<=e&&(e=t.low)}),{low:e,high:o}}export const getDefaultHighLow=()=>({high:Number.MIN_SAFE_INTEGER,low:Number.MAX_SAFE_INTEGER});
+/**
+ * Auxiliary sub-model to apply X,Y auto-scaling feature.
+ * Transforms the original ViewportModel.
+ * @doc-tags auto-scale,viewport,scaling
+ */
+export class AutoScaleViewportSubModel {
+    constructor(delegate, highLowProviders) {
+        this.delegate = delegate;
+        // local state, used for pane X dragging
+        this.auto = true;
+        // post processors can apply some changes to high low before applying it
+        this.highLowPostPorcessor = {};
+        this.highLowProviders = highLowProviders !== null && highLowProviders !== void 0 ? highLowProviders : {};
+    }
+    /**
+     * Sets a HighLowProvider for a given name.
+     * @param {string} name - The name of the HighLowProvider.
+     * @param {HighLowProvider} provider - The HighLowProvider to be set.
+     */
+    setHighLowProvider(name, provider) {
+        this.highLowProviders[name] = provider;
+    }
+    /**
+     * Deletes a high-low provider from the list of high-low providers.
+     * @param {string} name - The name of the high-low provider to be deleted.
+     */
+    deleteHighLowProvider(name) {
+        delete this.highLowProviders[name];
+    }
+    /**
+     * Sets a HighLowPostProcessor for a given name.
+     *
+     * @param {string} name - The name of the HighLowPostProcessor.
+     * @param {HighLowPostProcessor} processor - The HighLowPostProcessor to be set.
+     * @returns {void}
+     */
+    setHighLowPostProcessor(name, processor) {
+        this.highLowPostPorcessor[name] = processor;
+    }
+    /**
+     * Sets the auto and recalculates the state of the viewport model.
+     * @param {ViewportModelState} state - The state of the viewport model.
+     * @param {boolean} auto - The auto value to set.
+     * @returns {void}
+     */
+    setAutoAndRecalculateState(state, auto) {
+        this.auto = auto;
+        if (auto) {
+            autoScaleYViewportTransformer(this.delegate, state, Object.values(this.highLowProviders), Object.values(this.highLowPostPorcessor));
+        }
+    }
+}
+/**
+ * Y auto-scale viewport transformer. Calculates highLow for all chart visuals and recalculates the Y scale.
+ * @param vm
+ * @param state
+ * @param highLowProviders
+ * @param highLowPostProcessors
+ */
+export const autoScaleYViewportTransformer = (vm, state, highLowProviders, highLowPostProcessors) => {
+    const highLowList = highLowProviders
+        .filter(provider => provider.isHighLowActive())
+        .map(provider => provider.calculateHighLow(state));
+    const highLow = mergeHighLow(highLowList);
+    const postProcessedHighLow = highLowPostProcessors.reduce((prevResult, postProcessor) => postProcessor(prevResult), highLow);
+    state.yStart = postProcessedHighLow.low;
+    state.yEnd = postProcessedHighLow.high;
+    state.zoomY = vm.calculateZoomY(state.yStart, state.yEnd);
+};
+/**
+ * Merges an array of HighLow objects into a single HighLow object.
+ * @param {HighLow[]} input - The array of HighLow objects to be merged.
+ * @returns {HighLow} - The merged HighLow object.
+ 
+*/
+export function mergeHighLow(input) {
+    if (input.length === 0) {
+        return getDefaultHighLow();
+    }
+    let max = input[0].high;
+    let min = input[0].low;
+    input.forEach(highLow => {
+        if (isFinite(highLow.high) && highLow.high >= max) {
+            max = highLow.high;
+        }
+        if (isFinite(highLow.low) && highLow.low <= min) {
+            min = highLow.low;
+        }
+    });
+    return { low: min, high: max };
+}
+export const getDefaultHighLow = () => {
+    return {
+        high: Number.MIN_SAFE_INTEGER,
+        low: Number.MAX_SAFE_INTEGER,
+    };
+};

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */

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

@@ -1,6 +1,66 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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{at as S}from"../../utils/array.utils";import{calculateZoom as E,pixelsToUnits as w}from"./viewport.model";export const candleEdgesConstrait=(d,s,r,l)=>{var t,o,i,a;const n=Object.assign({},d),e=(o=(t=s[r])===null||t===void 0?void 0:t.startUnit)!==null&&o!==void 0?o:0,c=(a=(i=S(-r,s))===null||i===void 0?void 0:i.startUnit)!==null&&a!==void 0?a:0;let m=d.xStart,x=d.xEnd;return n.xStart>=c&&(m=c,x=x-(n.xStart-c)),n.xEnd<e&&(m=e-w(l.width,n.zoomX),x=e),n.xStart=m,n.xEnd=x,n},zoomConstraint=(d,s,r,l)=>{const t=Object.assign({},s),o=l(),i=t.xEnd-t.xStart,a=i<r.minCandles,n=o.width/r.minWidth,e=i>n;if(o.width>0){if(e)return t.xStart=t.xEnd-n,t.zoomX=E(t.xEnd-t.xStart,o.width),t;if(a)return t.xEnd=d.xEnd,t.xStart=t.xEnd-r.minCandles,t.zoomX=E(t.xEnd-t.xStart,o.width),t}return t};
+import { at } from '../../utils/array.utils';
+import { calculateZoom, 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
+ * @param initialState
+ * @param state
+ * @param visualCandlesCoordinates
+ * @param candleLimit
+ * @param bounds
+ * @returns
+ * @doc-tags viewport,zoom,scaling
+ */
+export const candleEdgesConstrait = (state, visualCandlesCoordinates, candleLimit, bounds) => {
+    var _a, _b, _c, _d;
+    const newState = Object.assign({}, state);
+    const leftConstraitCoordinate = (_b = (_a = visualCandlesCoordinates[candleLimit]) === null || _a === void 0 ? void 0 : _a.startUnit) !== null && _b !== void 0 ? _b : 0;
+    const rightConstraintCoordinate = (_d = (_c = at(-candleLimit, visualCandlesCoordinates)) === null || _c === void 0 ? void 0 : _c.startUnit) !== null && _d !== void 0 ? _d : 0;
+    let normalizedXStart = state.xStart;
+    let normalizedXEnd = state.xEnd;
+    if (newState.xStart >= rightConstraintCoordinate) {
+        normalizedXStart = rightConstraintCoordinate;
+        normalizedXEnd = normalizedXEnd - (newState.xStart - rightConstraintCoordinate);
+    }
+    if (newState.xEnd < leftConstraitCoordinate) {
+        normalizedXStart = leftConstraitCoordinate - pixelsToUnits(bounds.width, newState.zoomX);
+        normalizedXEnd = leftConstraitCoordinate;
+    }
+    newState.xStart = normalizedXStart;
+    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 = (initialState, 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.xEnd = initialState.xEnd;
+            newState.xStart = newState.xEnd - chartConfig.minCandles;
+            newState.zoomX = calculateZoom(newState.xEnd - newState.xStart, bounds.width);
+            return newState;
+        }
+    }
+    return newState;
+};

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */

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

@@ -1,6 +1,22 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */
-export const ratioFromZoomXY=(o,n)=>o/n,zoomXToZoomY=(o,n)=>o/n,zoomYToZoomX=(o,n)=>o*n,lockedYEndViewportCalculator=(o,n)=>{const Y=o.zoomY;o.zoomY=zoomXToZoomY(o.zoomX,n);const c=o.zoomY/Y,m=o.yEnd-o.yStart,r=m*c-m;o.yEnd=o.yEnd+r};
+export const ratioFromZoomXY = (zoomX, zoomY) => zoomX / zoomY;
+export const zoomXToZoomY = (zoomX, ratio) => zoomX / ratio;
+export const zoomYToZoomX = (zoomY, ratio) => zoomY * ratio;
+/**
+ * Locks the zoomY with zoomX and moves yEnd according to ratio changes.
+ * @param state
+ * @param zoomXYRatio
+ */
+export const lockedYEndViewportCalculator = (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;
+};

package/dist/chart/model/scaling/move-chart.functions.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */

package/dist/chart/model/scaling/move-chart.functions.js

@@ -1,6 +1,27 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */
-export const moveXStart=(n,o)=>{const r=n.xStart;n.xStart=o,n.xEnd=n.xEnd+(o-r)},moveYStart=(n,o)=>{const r=n.yStart;n.yStart=o,n.yEnd=n.yEnd+(o-r)};
+/**
+ * Moves both xStart and xEnd without changing the viewport width (zoomX).
+ * @param state
+ * @param xStart - left starting point in units
+ * @doc-tags scaling,viewport
+ */
+export const moveXStart = (state, xStart) => {
+    const prev = state.xStart;
+    state.xStart = xStart;
+    state.xEnd = state.xEnd + (xStart - prev);
+};
+/**
+ * Moves both yStart and yEnd without changing the viewport height (zoomY).
+ * @param state
+ * @param yStart - starting point in units
+ * @doc-tags scaling,viewport
+ */
+export const moveYStart = (state, yStart) => {
+    const prev = state.yStart;
+    state.yStart = yStart;
+    state.yEnd = state.yEnd + (yStart - prev);
+};

package/dist/chart/model/scaling/viewport.model.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 - 2023 Devexperts LLC
+ * Copyright (C) 2019 - 2023 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/.
  */
@@ -19,8 +19,8 @@ export type Timestamp = Unit;
 export type Percent = Unit;
 export type LogValue = Unit;
 export type YUnit = Price | Percent | LogValue;
-export declare const unitToPercent: (value: Unit, baseLine: Unit) => Percent;
-export declare const percentToUnit: (percent: Percent, baseLine: Unit) => Unit;
+export declare const unitToPercent: (value: Unit, baseline: Unit) => Percent;
+export declare const percentToUnit: (percent: Percent, baseline: Unit) => Unit;
 export declare const calcLogValue: (value: Price) => LogValue;
 export declare const logValueToUnit: (logValue: LogValue) => number;
 /**