@devexperts/dxcharts-lite 1.0.1 → 2.0.0

package/dist/chart/components/chart/chart.model.js

@@ -1,6 +1,959 @@
 /*
- * 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 p,merge as U}from"rxjs";import{distinctUntilChanged as A}from"rxjs/operators";import{ChartBaseElement as D}from"../../model/chart-base-element";import{CHART_UUID as C,CanvasElement as f,areBoundsChanged as W}from"../../canvas/canvas-bounds-container";import{getDefaultConfig as j}from"../../chart.config";import{MIN_SUPPORTED_CANVAS_SIZE as M}from"../../model/canvas.model";import{CandleSeriesModel as _}from"../../model/candle-series.model";import{copyCandle as O}from"../../model/candle.model";import{MainCandleSeriesModel as V}from"../../model/main-candle-series.model";import{candleEdgesConstrait as L}from"../../model/scaling/constrait.functions";import{pixelsToUnits as b}from"../../model/scaling/viewport.model";import{merge as X}from"../../utils/merge.utils";import{createBasicScaleViewportTransformer as Y,createTimeFrameViewportTransformer as R}from"./basic-scale";import{calculateCandleWidth as N}from"./candle-width-calculator.functions";import{deleteCandlesIndex as H,prepareCandle as S,reindexCandles as P}from"./candle.functions";import{ChartInstrument as k}from"./chart.component";import{fakeCandle as g}from"./fake-candles";import{SecondaryChartColorsPool as z}from"./secondary-chart-colors-pool";import{binarySearch as T,lastOf as w}from"../../utils/array.utils";import{searchCandleIndex as v}from"../../utils/candles.utils";import{floor as Z,round as K}from"../../utils/math.utils";export class ChartModel extends D{get mainCandleSeries(){return this.candleSeries[0]}get secondaryCandleSeries(){return this.candleSeries.filter(e=>e!==this.mainCandleSeries)}constructor(e,t,s,i,a,n,d,l,r,o){super(),this.chartBaseModel=e,this.paneManager=t,this.bus=s,this.canvasModel=i,this.config=a,this.scaleModel=n,this.formatterFactory=d,this.mainCanvasParent=l,this.canvasBoundsContainer=r,this.chartResizeHandler=o,this.prevChartWidth=0,this.prevYWidth=0,this.candleSeries=[],this.nextCandleTimeStampSubject=new p,this.axisTypeSetSubject=new p,this.chartTypeChanged=new p,this.mainInstrumentChangedSubject=new p,this.scaleInversedSubject=new p,this.offsetsChanged=new p,this.candlesTransformersByChartType={},this.lastCandleLabelsByChartType={},this.candleWidthByChartType={},this.lastTimeFrame=[0,0],this.FAKE_CANDLES_DEFAULT=100,this.toY=u=>this.mainCandleSeries.view.toY(u),this.chartTypeChanged.next(this.config.components.chart.type),this.secondaryChartColors=new z(this.config);const c=new V(this.chartBaseModel,this.paneManager.paneComponents[C].mainYExtentComponent,this.paneManager.hitTestController.getNewDataSeriesHitTestId(),this.bus,this.scaleModel,new k,this.candlesTransformersByChartType,this.candleWidthByChartType,Object.assign({},this.config.colors));c.config.type=this.config.components.chart.type,this.candleSeries.push(c),n.addXConstraint((u,m)=>L(m,this.mainCandleSeries.visualPoints,this.config.components.chart.minCandlesOffset,n.getBounds())),this.basicScaleViewportTransformer=Y(n),this.timeFrameViewportTransformer=R(n,this),this.pane=this.paneManager.paneComponents[C]}get candlesUpdatedSubject(){return this.chartBaseModel.dataUpdatedSubject}get candlesSetSubject(){return this.chartBaseModel.dataSetSubject}get candlesRemovedSubject(){return this.chartBaseModel.dataRemovedSubject}get candlesPrependSubject(){return this.chartBaseModel.dataPrependSubject}doActivate(){super.doActivate(),this.addRxSubscription(this.canvasBoundsContainer.observeBoundsChanged(f.PANE_UUID(C)).pipe(A(W)).subscribe(e=>{this.handleChartResize(e)}))}handleChartResize(e){if(e.width>M.width&&e.height>M.height){const t=this.getEffectiveChartWidth(),s=this.getEffectiveYAxisWidth();if(this.prevChartWidth===0){this.scaleModel.isViewportValid()?this.scaleModel.recalculateZoom():this.doBasicScale(),this.prevChartWidth=t,this.prevYWidth=s;return}if(s!==this.prevYWidth){if(this.config.scale.keepZoomXOnYAxisChange){const a=b(s-this.prevYWidth,this.scaleModel.zoomX);this.scaleModel.setXScale(this.scaleModel.xStart,this.scaleModel.xEnd-a)}else this.scaleModel.recalculateZoomX();this.prevYWidth=s,this.prevChartWidth=t;return}const i=b(t-this.prevChartWidth,this.scaleModel.zoomX);this.scaleModel.setXScale(this.scaleModel.xStart-i,this.scaleModel.xEnd),this.scaleModel.recalculateZoomY(),this.prevYWidth=s,this.prevChartWidth=t}}setMainCandleSeries(e,t){this.mainCandleSeries.instrument=t,this.setAllSeries({candles:e,instrument:t},this.getSecondarySeries().map(s=>{const i=s.dataPoints;return H(i),{candles:i,instrument:s.instrument}}))}setSecondaryCandleSeries(e,t=this.mainCandleSeries.instrument,s=!0){const i=y(e.map(S)),a=this.reindexCandlesBasedOnSeries(this.mainCandleSeries.dataPoints,i),n=this.secondarySeriesAdjustments(this.mainCandleSeries.dataPoints,a),l=this.secondaryCandleSeries.some(r=>r.instrument.symbol===t.symbol)?this.secondaryCandleSeries.find(r=>r.instrument.symbol===t.symbol):this.createSecondaryCandleSeriesModel(t);if(l)return l.dataPoints=n,s&&(this.scaleModel.doAutoScale(),l.recalculateVisualPoints(),this.candlesSetSubject.next(),this.bus.fireDraw([this.canvasModel.canvasId])),l}setAllSeries(e,t=[]){var s;this.mainCandleSeries.instrument=(s=e.instrument)!==null&&s!==void 0?s:this.mainCandleSeries.instrument,e.instrument&&this.mainInstrumentChangedSubject.next(e.instrument),this.rememberCurrentTimeframe();const i=y(e.candles.map(S));this.mainCandleSeries.clearData(),P(i),this.mainCandleSeries.dataPoints=i,this.secondaryCandleSeries.filter(a=>t.filter(n=>{var d;return((d=n.instrument)===null||d===void 0?void 0:d.symbol)===a.instrument.symbol}).length===0).forEach(a=>this.removeSecondaryCandleSeries(a)),t.map(a=>this.setSecondaryCandleSeries(a.candles,a.instrument,!1)),this.candleSeries.forEach(a=>{a.recalculateDataViewportIndexes(),a.recalculateVisualPoints()}),this.chartBaseModel.recalculatePeriod(),this.autoScaleOnCandles(),this.scaleModel.doAutoScale(),this.candlesSetSubject.next(),this.bus.fireDraw([this.canvasModel.canvasId])}autoScaleOnCandles(){this.scaleModel.state.autoScaleOnCandles&&(this.doBasicScale(),this.scaleModel.autoScale(!0))}doBasicScale(){this.basicScaleViewportTransformer(this.mainCandleSeries.visualPoints),this.bus.fireDraw()}doPreviousTimeFrameScale(e=null){this.timeFrameViewportTransformer(this.lastTimeFrame,e),this.scaleModel.state.autoScaleOnCandles&&this.scaleModel.doAutoScale(!0),this.bus.fireDraw()}rememberCurrentTimeframe(){this.mainCandleSeries.visualPoints.length!==0&&(this.lastTimeFrame=[this.candleFromX(this.scaleModel.toX(this.scaleModel.xStart),!0).timestamp,this.candleFromX(this.scaleModel.toX(this.scaleModel.xEnd),!0).timestamp])}updateAllSeries(e,t=[]){e=Object.assign({},e),e.instrument||(e.instrument=this.mainCandleSeries.instrument);const s=[e,...t];if(!this.candleSeries.every(l=>s.find(r=>{var o;return((o=r.instrument)===null||o===void 0?void 0:o.symbol)===l.instrument.symbol}))||t.length!==this.secondaryCandleSeries.length){console.error("All series update failed. Instruments for series are different.");return}const i=y(e.candles.map(S)),a=I(this.mainCandleSeries.dataPoints,i),n=a.candles;P(n),this.mainCandleSeries.dataPoints=n,t.map(l=>{var r,o,c,u;const m=y(l.candles.map(S)),x=I((u=(c=this.findSecondarySeriesBySymbol((o=(r=l.instrument)===null||r===void 0?void 0:r.symbol)!==null&&o!==void 0?o:""))===null||c===void 0?void 0:c.dataPoints)!==null&&u!==void 0?u:[],m).candles;return this.setSecondaryCandleSeries(x,l.instrument,!1)}),this.candleSeries.forEach(l=>{l.recalculateVisualPoints(),l.recalculateDataViewportIndexes()});const d=this.chartBaseModel.mainVisualPoints.slice(0,a.prepended).reduce((l,r)=>l+r.width,0);this.scaleModel.moveXStart(this.scaleModel.xStart+d),this.candlesPrependSubject.next({prependedCandlesWidth:d,preparedCandles:i}),this.chartBaseModel.recalculatePeriod(),this.candlesUpdatedSubject.next(),this.bus.fireDraw()}removeDataFrom(e){Object.values(this.paneManager.paneComponents).forEach(t=>{t.dataSeries.forEach(s=>{const i=T(s.dataPoints,e,n=>n.timestamp),a=i.exact?i.index:i.index+1;s.dataPoints=s.dataPoints.slice(0,a)})}),this.candlesRemovedSubject.next(),this.candlesUpdatedSubject.next(),this.canvasModel.fireDraw()}createSecondaryCandleSeriesModel(e){const t=Object.assign(Object.assign({},this.config.colors),this.secondaryChartColors.takeColorFromPool(e.symbol));return this.createCandleSeriesModel(e,t)}createCandleSeriesModel(e,t){const s=new _(this.paneManager.paneComponents[C].mainYExtentComponent,this.paneManager.hitTestController.getNewDataSeriesHitTestId(),this.bus,this.scaleModel,e,this.candlesTransformersByChartType,this.candleWidthByChartType,t);return s.config.type="line",this.candleSeries.push(s),s}removeSecondaryCandleSeries(e){return this.secondaryChartColors.addColorToPool(e.instrument.symbol),this.candleSeries=this.candleSeries.filter(t=>t!==e),e.deactivate(),this.paneManager.paneComponents[C].removeDataSeries(e),this.scaleModel.doAutoScale(),e.colors}secondarySeriesAdjustments(e,t){const s=[];return e.forEach(i=>{var a;const n=(a=i.idx)!==null&&a!==void 0?a:0,d=t[n];if(d)s.push(d);else{let l=B(t,n,-1);if(l||(l=B(t,n,1)),l){const r=O(l,n,!0);s.push(r)}}}),s}updateSecondaryCandleSeriesConfig(e,t,s){const i=X(e,j().colors);this.secondaryChartColors.updateColorConfig(t,i);const a=this.findSecondarySeriesBySymbol(t);a&&(a.config.type=s,a.updateCandleSeriesColors(i),this.bus.fireDraw([this.canvasModel.canvasId])),this.bus.fireDraw([this.canvasModel.canvasId])}setAutoScale(e){this.scaleModel.autoScale(e)}getEffectiveYAxisWidth(){return this.canvasBoundsContainer.getBounds(f.PANE_UUID_Y_AXIS(C)).width}getEffectiveChartWidth(){return this.canvasBoundsContainer.getBounds(f.PANE_UUID(C)).width}getEffectiveChartHeight(){return this.canvasBoundsContainer.getBounds(f.PANE_UUID(C)).height}setOffsets(e){this.scaleModel.updateOffsets(e);const t=this.getCandlesCountWithRightOffset(),s=this.mainCandleSeries.visualPoints;this.hasCandles()&&t>=s.length&&this.scaleModel.setXScale(this.scaleModel.xStart,this.candleFromIdx(t).startUnit),this.offsetsChanged.next(),this.bus.fireDraw()}getOffsets(){return this.scaleModel.getOffsets()}fromY(e){return this.scaleModel.fromY(e)}priceFromY(e,t){return(t!=null?t:this.mainCandleSeries).view.priceFromY(e)}fromX(e){return this.scaleModel.fromX(e)}toX(e){const t=this.candleFromIdx(e);return this.scaleModel.toX(t.centerUnit)}getBaseLine(){return this.mainCandleSeries.getBaseLine()}candleFromX(e,t=!1,s=this.mainCandleSeries){const i=this.scaleModel.fromX(e);return this.candleFromUnit(i,t,s)}candleFromUnit(e,t=!1,s=this.mainCandleSeries){var i,a;const n=T(s.visualPoints,e,c=>c.startUnit),d=s.visualPoints,l=this.getLastVisualCandle();d[n.index]!==void 0&&(e<0||l&&e>l.startUnit+l.width)&&(n.index+=K((e-d[n.index].centerUnit)/this.mainCandleSeries.meanCandleWidth));const r=n.index,o=Math.max(Math.min(d.length-1,r),0);return(r<0||r>=d.length)&&t?g(this.mainCandleSeries.dataPoints,r,this.chartBaseModel.period):(a=(i=d[o])===null||i===void 0?void 0:i.candle)!==null&&a!==void 0?a:g(this.mainCandleSeries.dataPoints,o,this.chartBaseModel.period)}candleFromTimestamp(e,t=!0){return this.chartBaseModel.dataFromTimestamp(e,t)}candleFromIdx(e){return this.chartBaseModel.dataFromIdx(e)}isReady(){return this.canvasModel.isReady()&&this.hasCandles()}registerCandlesTransformer(e,t){this.candlesTransformersByChartType[e]=t}registerCandlesWidthCalculator(e,t){this.candleWidthByChartType[e]=t}registerLastCandleLabelHandler(e,t){this.lastCandleLabelsByChartType[e]=t}hasCandles(){return this.mainCandleSeries.visualPoints.length!==0}getVisualCandle(e){var t,s,i;const a=e-((i=(s=(t=this.mainCandleSeries.visualPoints[0])===null||t===void 0?void 0:t.candle)===null||s===void 0?void 0:s.idx)!==null&&i!==void 0?i:0);return this.mainCandleSeries.visualPoints[a]}getFirstIdx(){return this.mainCandleSeries.dataIdxStart}getLastIdx(){return this.mainCandleSeries.dataIdxEnd}getFirstTimestamp(e=!0){return e?this.candleFromIdx(this.getFirstIdx()).candle.timestamp:this.candleFromUnit(this.scaleModel.xStart,!0).timestamp}getLastTimestamp(e=!0){return e?this.candleFromIdx(this.getLastIdx()).candle.timestamp:this.candleFromUnit(this.scaleModel.xEnd,!0).timestamp}setTimestampRange(e,t){const s=this.candleFromTimestamp(e).startUnit,i=this.candleFromTimestamp(t),a=i.startUnit+i.width;return this.scaleModel.setXScale(s,a)}getLastCandle(){const e=this.mainCandleSeries.dataPoints;return w(e)}getLastVisualCandle(){const e=this.mainCandleSeries.visualPoints;return w(e)}getMaxCandlesFitLength(){return Z(this.getEffectiveChartWidth()/this.config.components.chart.minWidth)}getSecondarySeries(){return this.secondaryCandleSeries}isSeriesInstrument(e,t){return e.instrument.symbol===t}findSeriesBySymbol(e){return this.candleSeries.filter(t=>this.isSeriesInstrument(t,e))}findSecondarySeriesBySymbol(e){return this.secondaryCandleSeries.find(t=>this.isSeriesInstrument(t,e))}reindexCandlesBasedOnSeries(e,t){return t.reduce((s,i)=>{const a=i.timestamp,n=v(a,!1,e,this.chartBaseModel.period);return n.index>=0&&n.index<e.length&&(i.idx=n.index,s[n.index]=i),s},[])}getPeriod(){return this.chartBaseModel.period}isCandleInViewport(e){return this.getFirstIdx()<=e&&e<=this.getLastIdx()}updateCandles(e,t=this.mainCandleSeries.instrument.symbol){const s=this.mainCandleSeries.instrument.symbol===t,i=this.findSeriesBySymbol(t);if(i.length===0){console.warn("updateCandles failed. Can't find series",t);return}i.forEach(a=>{const n=a.dataPoints;let d=!1,l=!1,r;e.forEach(o=>{var c;if(!o)return;const u=v(o.timestamp,!0,n,this.getPeriod()),m=Math.min(u.index,n.length);d=d||m===n.length,n[m]=o,o.idx=m,a.dataPoints=n,a.recalculateDataViewportIndexes(),l=l||this.isCandleInViewport(m);const x=m>=n.length-1,E=r&&o.timestamp<r.timestamp;if(x&&!E&&(r=o),d&&r&&s&&l){const F=(c=this.candleWidthByChartType[this.config.components.chart.type])!==null&&c!==void 0?c:N;this.scaleModel.moveXStart(this.scaleModel.xStart+F(r))}}),r&&a.updateCurrentPrice(r.close),l&&r&&e.length===1?this.bus.fireDraw([this.canvasModel.canvasId]):a.recalculateVisualPoints()}),this.scaleModel.doAutoScale(),this.candlesUpdatedSubject.next()}observeCandlesChanged(){return U(this.candlesSetSubject,this.candlesUpdatedSubject)}getCandles(){return this.mainCandleSeries.dataPoints}getCandlesWithFake(e=0,t){let s=this.getCandles().slice();const i=this.getCandlesCount(),a=t!=null?t:i+this.FAKE_CANDLES_DEFAULT;s=s.slice(Math.max(0,e),Math.min(i,a));const n=[],d=[];for(let r=i;r<a;r++)n.push(g(this.mainCandleSeries.dataPoints,r,this.getPeriod()));const l=Math.min(0,a);for(let r=e;r<l;r++)d.push(g(this.mainCandleSeries.dataPoints,r,this.getPeriod()));return[...d,...s,...n]}getCandlesCount(){return this.mainCandleSeries.dataPoints.length}getCandlesCountWithRightOffset(){return this.getCandlesCount()+this.getOffsets().right}clearData(){this.candleSeries.forEach(e=>e.clearData())}prependCandles(e,t){const s=e.slice(),i=[];return t.forEach(a=>{const d=v(a.timestamp,!1,e).index;d<0?i.push(a):e[d].timestamp===a.timestamp?s[d]=a:console.warn(`Couldn't update candle with timestamp ${a.timestamp}`)}),{prepended:i.length,candles:[...i,...s]}}addLastCandle(e,t=this.mainCandleSeries.instrument.symbol){this.updateCandles([e],t)}updateLastCandle(e,t=this.mainCandleSeries.instrument.symbol){this.updateCandles([e],t)}}const y=h=>h.slice().sort((e,t)=>e.timestamp===t.timestamp?0:e.timestamp>t.timestamp?1:-1),B=(h,e,t)=>{if(e>=h.length)return h[h.length-1];for(let s=e;s<h.length&&s>=0;s+=t){const i=h[s];if(i)return i}},I=(h,e)=>{const t=h.slice(),s=[],i=[];return e.forEach(a=>{const d=v(a.timestamp,!0,h).index;d<0?s.push(a):d>=h.length?i.push(a):h[d].timestamp===a.timestamp?t[d]=a:console.warn(`Couldn't update candle with timestamp ${a.timestamp}`)}),{prepended:s.length,appended:i.length,candles:[...s,...t,...i]}};
+import { Subject, merge } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import { CHART_UUID, CanvasElement, areBoundsChanged, } from '../../canvas/canvas-bounds-container';
+import { getDefaultConfig } from '../../chart.config';
+import { CandleSeriesModel } from '../../model/candle-series.model';
+import { copyCandle } from '../../model/candle.model';
+import { MIN_SUPPORTED_CANVAS_SIZE } from '../../model/canvas.model';
+import { ChartBaseElement } from '../../model/chart-base-element';
+import { MainCandleSeriesModel } from '../../model/main-candle-series.model';
+import { candleEdgesConstrait } from '../../model/scaling/constrait.functions';
+import { pixelsToUnits } from '../../model/scaling/viewport.model';
+import { binarySearch, lastOf } from '../../utils/array.utils';
+import { searchCandleIndex } from '../../utils/candles.utils';
+import { floor, round } from '../../utils/math.utils';
+import { merge as mergeObj } from '../../utils/merge.utils';
+import { createBasicScaleViewportTransformer, createTimeFrameViewportTransformer } from './basic-scale';
+import { calculateCandleWidth } from './candle-width-calculator.functions';
+import { deleteCandlesIndex, prepareCandle, reindexCandles } from './candle.functions';
+import { ChartInstrument } from './chart.component';
+import { fakeCandle } from './fake-candles';
+import { SecondaryChartColorsPool } from './secondary-chart-colors-pool';
+export class ChartModel extends ChartBaseElement {
+    get mainCandleSeries() {
+        return this.candleSeries[0];
+    }
+    get secondaryCandleSeries() {
+        return this.candleSeries.filter(s => s !== this.mainCandleSeries);
+    }
+    constructor(chartBaseModel, paneManager, bus, canvasModel, config, scale, formatterFactory, mainCanvasParent, canvasBoundsContainer, chartResizeHandler) {
+        super();
+        this.chartBaseModel = chartBaseModel;
+        this.paneManager = paneManager;
+        this.bus = bus;
+        this.canvasModel = canvasModel;
+        this.config = config;
+        this.scale = scale;
+        this.formatterFactory = formatterFactory;
+        this.mainCanvasParent = mainCanvasParent;
+        this.canvasBoundsContainer = canvasBoundsContainer;
+        this.chartResizeHandler = chartResizeHandler;
+        this.prevChartWidth = 0;
+        this.prevYWidth = 0;
+        this.candleSeries = [];
+        this.nextCandleTimeStampSubject = new Subject();
+        this.chartTypeChanged = new Subject();
+        this.mainInstrumentChangedSubject = new Subject();
+        this.scaleInversedSubject = new Subject();
+        this.offsetsChanged = new Subject();
+        this.candlesTransformersByChartType = {};
+        this.lastCandleLabelsByChartType = {};
+        this.candleWidthByChartType = {};
+        // TODO try to remove this state
+        this.lastTimeFrame = [0, 0];
+        this.FAKE_CANDLES_DEFAULT = 100;
+        this.toY = (value) => {
+            return this.mainCandleSeries.view.toY(value);
+        };
+        this.chartTypeChanged.next(this.config.components.chart.type);
+        this.secondaryChartColors = new SecondaryChartColorsPool(this.config);
+        const candleSeries = new MainCandleSeriesModel(this.chartBaseModel, this.paneManager.panes[CHART_UUID].mainExtent, this.paneManager.hitTestController.getNewDataSeriesHitTestId(), this.bus, this.scale, new ChartInstrument(), this.candlesTransformersByChartType, this.candleWidthByChartType, Object.assign({}, this.config.colors));
+        candleSeries.config.type = this.config.components.chart.type;
+        this.candleSeries.push(candleSeries);
+        scale.addXConstraint((_, state) => candleEdgesConstrait(state, this.mainCandleSeries.visualPoints, this.config.components.chart.minCandlesOffset, scale.getBounds()));
+        this.basicScaleViewportTransformer = createBasicScaleViewportTransformer(scale);
+        this.timeFrameViewportTransformer = createTimeFrameViewportTransformer(scale, this);
+        this.pane = this.paneManager.panes[CHART_UUID];
+    }
+    get candlesUpdatedSubject() {
+        return this.chartBaseModel.dataUpdatedSubject;
+    }
+    get candlesSetSubject() {
+        return this.chartBaseModel.dataSetSubject;
+    }
+    get candlesRemovedSubject() {
+        return this.chartBaseModel.dataRemovedSubject;
+    }
+    get candlesPrependSubject() {
+        return this.chartBaseModel.dataPrependSubject;
+    }
+    /**
+     * Method that activates the canvas bounds container and subscribes to its bounds changes and bar resizer changes.
+     * @protected
+     * @returns {void}
+     */
+    doActivate() {
+        super.doActivate();
+        this.addRxSubscription(this.canvasBoundsContainer
+            .observeBoundsChanged(CanvasElement.PANE_UUID(CHART_UUID))
+            .pipe(distinctUntilChanged(areBoundsChanged))
+            .subscribe(bounds => {
+            this.handleChartResize(bounds);
+        }));
+    }
+    /**
+     * This method keeps the same candle width on chart canvas resize, so chart candles aren't squeezed when canvas becomes smaller
+     * If chart width was changed after Yaxis width changed, scale will be adjusted to right/left, and visually nothing will be changed
+     * @private
+     * @param nextCB - Next chart bounds
+     */
+    handleChartResize(nextCB) {
+        if (nextCB.width > MIN_SUPPORTED_CANVAS_SIZE.width && nextCB.height > MIN_SUPPORTED_CANVAS_SIZE.height) {
+            const nextChartWidth = this.getEffectiveChartWidth();
+            const nextYAxisWidth = this.getEffectiveYAxisWidth();
+            if (this.prevChartWidth === 0) {
+                this.scale.isViewportValid() ? this.scale.recalculateZoom() : this.doBasicScale();
+                this.prevChartWidth = nextChartWidth;
+                this.prevYWidth = nextYAxisWidth;
+                return;
+            }
+            // YAxis width changed, so chart width will be changed too, but we need adjust scale to right/left
+            if (nextYAxisWidth !== this.prevYWidth) {
+                if (this.config.scale.keepZoomXOnYAxisChange) {
+                    const unitDiff = pixelsToUnits(nextYAxisWidth - this.prevYWidth, this.scale.zoomX);
+                    this.scale.setXScale(this.scale.xStart, this.scale.xEnd - unitDiff);
+                }
+                else {
+                    this.scale.recalculateZoomX();
+                }
+                this.prevYWidth = nextYAxisWidth;
+                this.prevChartWidth = nextChartWidth;
+                return;
+            }
+            // YAxis has the same width, so keep the same candle width on chart resize
+            const unitDiff = pixelsToUnits(nextChartWidth - this.prevChartWidth, this.scale.zoomX);
+            this.scale.setXScale(this.scale.xStart - unitDiff, this.scale.xEnd);
+            // height also could be changed - we need correct zoomY
+            this.scale.recalculateZoomY();
+            this.prevYWidth = nextYAxisWidth;
+            this.prevChartWidth = nextChartWidth;
+        }
+    }
+    /**
+     * Sets the main candle series with the provided candles and instrument.
+     * @param {Array<Candle>} candles - The array of candles to set as the main candle series.
+     * @param {ChartInstrument} instrument - The instrument to set for the main candle series.
+     * @returns {void}
+     */
+    setMainCandleSeries(candles, instrument) {
+        this.mainCandleSeries.instrument = instrument;
+        this.setAllSeries({
+            candles,
+            instrument,
+        }, this.getSecondarySeries().map(series => {
+            const originalCandles = series.dataPoints;
+            // reset the idx of candles to calculate them again
+            deleteCandlesIndex(originalCandles);
+            return {
+                candles: originalCandles,
+                instrument: series.instrument,
+            };
+        }));
+    }
+    /**
+     * Sets a secondary candle series based on the provided candles array and instrument.
+     * @param {Array<Candle>} candles - An array of candles to set as the secondary candle series.
+     * @param {ChartInstrument} instrument - The instrument to set as the secondary candle series. Defaults to the main candle series instrument.
+     * @param {boolean} recalculateAndUpdate - A boolean indicating whether to recalculate and update the candle series. Defaults to true.
+     * @returns {CandleSeriesModel | undefined} - The newly created secondary candle series model or undefined if it could not be created.
+     */
+    setSecondaryCandleSeries(candles, instrument = this.mainCandleSeries.instrument, recalculateAndUpdate = true) {
+        const prepareCandleCandles = sortCandles(candles.map(prepareCandle));
+        // set correct indexes based on main candles timestamp
+        const reindexCandles = this.reindexCandlesBasedOnSeries(this.mainCandleSeries.dataPoints, prepareCandleCandles);
+        // ensure there are no gaps in new candles
+        const secondaryCandles = this.secondarySeriesAdjustments(this.mainCandleSeries.dataPoints, reindexCandles);
+        // create a new secondary series model if it doesn't already exist
+        const isSymbolExist = this.secondaryCandleSeries.some(candleSeries => candleSeries.instrument.symbol === instrument.symbol);
+        const candleSeriesModel = isSymbolExist
+            ? this.secondaryCandleSeries.find(candleSeries => candleSeries.instrument.symbol === instrument.symbol)
+            : this.createSecondaryCandleSeriesModel(instrument);
+        if (!candleSeriesModel) {
+            return;
+        }
+        candleSeriesModel.dataPoints = secondaryCandles;
+        if (recalculateAndUpdate) {
+            // calculate X and Y bounds
+            this.scale.doAutoScale();
+            // now the visual candles
+            candleSeriesModel.recalculateVisualPoints();
+            this.candlesSetSubject.next();
+            this.bus.fireDraw([this.canvasModel.canvasId]);
+        }
+        return candleSeriesModel;
+    }
+    /**
+     * Shouldn't be called outside chart-core, use ChartComponent#setAllSeries instead
+     * @param mainSeries
+     * @param secondarySeries
+     */
+    setAllSeries(mainSeries, secondarySeries = []) {
+        var _a;
+        this.mainCandleSeries.instrument = (_a = mainSeries.instrument) !== null && _a !== void 0 ? _a : this.mainCandleSeries.instrument;
+        if (mainSeries.instrument) {
+            this.mainInstrumentChangedSubject.next(mainSeries.instrument);
+        }
+        this.rememberCurrentTimeframe();
+        const prepareCandleCandles = sortCandles(mainSeries.candles.map(prepareCandle));
+        this.mainCandleSeries.clearData();
+        reindexCandles(prepareCandleCandles);
+        this.mainCandleSeries.dataPoints = prepareCandleCandles;
+        // deactivate deleted series
+        this.secondaryCandleSeries
+            .filter(series => {
+            return secondarySeries.filter(s => { var _a; return ((_a = s.instrument) === null || _a === void 0 ? void 0 : _a.symbol) === series.instrument.symbol; }).length === 0;
+        })
+            .forEach(series => this.removeSecondaryCandleSeries(series));
+        // re-create series
+        secondarySeries.map(series => this.setSecondaryCandleSeries(series.candles, series.instrument, false));
+        // do visual recalculations
+        this.candleSeries.forEach(series => {
+            series.recalculateDataViewportIndexes();
+            series.recalculateVisualPoints();
+        });
+        this.chartBaseModel.recalculatePeriod();
+        this.autoScaleOnCandles();
+        this.scale.doAutoScale();
+        this.candlesSetSubject.next();
+        this.bus.fireDraw([this.canvasModel.canvasId]);
+    }
+    /**
+     * This function checks if the autoScaleOnCandles state is true. If it is, it calls the doBasicScale() function and then calls the autoScale() function with a true parameter.
+     * @function
+     * @name autoScaleOnCandles
+     * @memberof ClassName
+     * @returns {void}
+     */
+    autoScaleOnCandles() {
+        if (this.scale.state.autoScaleOnCandles) {
+            this.doBasicScale();
+            this.scale.autoScale(true);
+        }
+    }
+    /**
+     * Applies the basic scale viewport transformer to the visual points of the main candle series and fires a draw event.
+     */
+    doBasicScale() {
+        this.basicScaleViewportTransformer(this.mainCandleSeries.visualPoints);
+        this.bus.fireDraw();
+    }
+    /**
+     * Changes the time frame scale to the previous one and redraws the chart.
+     * @param {boolean | null} zoomIn - If true, zooms in the chart, if false, zooms out the chart, if null, does not zoom.
+     * @returns {void}
+     */
+    doPreviousTimeFrameScale(zoomIn = null) {
+        this.timeFrameViewportTransformer(this.lastTimeFrame, zoomIn);
+        if (this.scale.state.autoScaleOnCandles) {
+            this.scale.doAutoScale(true);
+        }
+        this.bus.fireDraw();
+    }
+    /**
+     * Saves the current timeframe by getting the start and end timestamps of the visual candles in the main candle series.
+     * If there are no visual candles, the last timeframe is not updated.
+     */
+    rememberCurrentTimeframe() {
+        const visualCandles = this.mainCandleSeries.visualPoints;
+        if (visualCandles.length !== 0) {
+            this.lastTimeFrame = [
+                this.candleFromX(this.scale.toX(this.scale.xStart), true).timestamp,
+                this.candleFromX(this.scale.toX(this.scale.xEnd), true).timestamp,
+            ];
+        }
+    }
+    /**
+     * Shouldn't be called outside chart-core, use ChartComponent#updateAllSeries instead
+     * @param mainSeries
+     * @param secondarySeries
+     */
+    updateAllSeries(mainSeries, secondarySeries = []) {
+        mainSeries = Object.assign({}, mainSeries);
+        if (!mainSeries.instrument) {
+            mainSeries.instrument = this.mainCandleSeries.instrument;
+        }
+        const allSeries = [mainSeries, ...secondarySeries];
+        if (!this.candleSeries.every(s => allSeries.find(ss => { var _a; return ((_a = ss.instrument) === null || _a === void 0 ? void 0 : _a.symbol) === s.instrument.symbol; })) ||
+            secondarySeries.length !== this.secondaryCandleSeries.length) {
+            console.error('All series update failed. Instruments for series are different.');
+            return;
+        }
+        const preparedCandles = sortCandles(mainSeries.candles.map(prepareCandle));
+        const updateResult = updateCandles(this.mainCandleSeries.dataPoints, preparedCandles);
+        const updatedCandles = updateResult.candles;
+        reindexCandles(updatedCandles);
+        this.mainCandleSeries.dataPoints = updatedCandles;
+        // re-create series
+        secondarySeries.map(series => {
+            var _a, _b, _c, _d;
+            const preparedCandles = sortCandles(series.candles.map(prepareCandle));
+            const updatedCandles = updateCandles((_d = (_c = this.findSecondarySeriesBySymbol((_b = (_a = series.instrument) === null || _a === void 0 ? void 0 : _a.symbol) !== null && _b !== void 0 ? _b : '')) === null || _c === void 0 ? void 0 : _c.dataPoints) !== null && _d !== void 0 ? _d : [], preparedCandles).candles;
+            return this.setSecondaryCandleSeries(updatedCandles, series.instrument, false);
+        });
+        // do visual recalculations
+        this.candleSeries.forEach(series => {
+            series.recalculateVisualPoints();
+            series.recalculateDataViewportIndexes();
+        });
+        // caclulate offset width for prepanded candles
+        const prependedCandlesWidth = this.chartBaseModel.mainVisualPoints
+            .slice(0, updateResult.prepended)
+            .reduce((acc, cur) => acc + cur.width, 0);
+        this.scale.moveXStart(this.scale.xStart + prependedCandlesWidth);
+        this.candlesPrependSubject.next({
+            prependedCandlesWidth,
+            preparedCandles,
+        });
+        this.chartBaseModel.recalculatePeriod();
+        this.candlesUpdatedSubject.next();
+        this.bus.fireDraw();
+    }
+    /**
+     * Removes all data points from the main candle series that are newer than the given timestamp.
+     * Can be useful for data replay.
+     * @param startTimestamp
+     */
+    removeDataFrom(startTimestamp) {
+        Object.values(this.paneManager.panes).forEach(pane => {
+            pane.dataSeries.forEach(series => {
+                const searchResult = binarySearch(series.dataPoints, startTimestamp, p => p.timestamp);
+                const index = searchResult.exact ? searchResult.index : searchResult.index + 1;
+                series.dataPoints = series.dataPoints.slice(0, index);
+            });
+        });
+        this.candlesRemovedSubject.next();
+        this.candlesUpdatedSubject.next();
+        this.canvasModel.fireDraw();
+    }
+    /**
+     * Creates a secondary candle series model for a given instrument.
+     * @param {ChartInstrument} instrument - The instrument for which the secondary candle series model is created.
+     * @returns {CandleSeriesModel | undefined} - The created secondary candle series model or undefined if it cannot be created.
+     */
+    createSecondaryCandleSeriesModel(instrument) {
+        const candleSeriesConfig = Object.assign(Object.assign({}, this.config.colors), this.secondaryChartColors.takeColorFromPool(instrument.symbol));
+        return this.createCandleSeriesModel(instrument, candleSeriesConfig);
+    }
+    /**
+     * Creates a new CandleSeriesModel object and adds it to the chart.
+     * @param {ChartInstrument} instrument - The instrument to be displayed in the chart.
+     * @param {CandleSeriesColors} [colors] - Optional colors for the candle series.
+     * @returns {CandleSeriesModel} - The newly created CandleSeriesModel object.
+     */
+    createCandleSeriesModel(instrument, colors) {
+        const candleSeries = new CandleSeriesModel(this.paneManager.panes[CHART_UUID].mainExtent, this.paneManager.hitTestController.getNewDataSeriesHitTestId(), this.bus, this.scale, instrument, this.candlesTransformersByChartType, this.candleWidthByChartType, colors);
+        candleSeries.config.type = 'line';
+        this.candleSeries.push(candleSeries);
+        return candleSeries;
+    }
+    /**
+     * Removes a secondary candle series from the chart and returns its colors.
+     * @param {CandleSeriesModel} series - The candle series to be removed.
+     * @returns {CandleSeriesColors | undefined} - The colors of the removed series or undefined if the series was not found.
+     */
+    removeSecondaryCandleSeries(series) {
+        this.secondaryChartColors.addColorToPool(series.instrument.symbol);
+        this.candleSeries = this.candleSeries.filter(s => s !== series);
+        series.deactivate();
+        this.paneManager.panes[CHART_UUID].removeDataSeries(series);
+        this.scale.doAutoScale();
+        return series.colors;
+    }
+    /**
+     * Adjusts secondary series to present them nicely with main series:
+     * - fill gaps in secondarySeries with fake candles OHLC of same price (=close price)
+     * - do not add any candles which are not in main series
+     * @param mainSeries - main series
+     * @param secondarySeries - secondarySeries to adjust
+     */
+    secondarySeriesAdjustments(mainSeries, secondarySeries) {
+        const result = [];
+        mainSeries.forEach(mainCandle => {
+            var _a;
+            const idx = (_a = mainCandle.idx) !== null && _a !== void 0 ? _a : 0;
+            const compareCandle = secondarySeries[idx];
+            if (!compareCandle) {
+                // take first candle to left or right
+                // check left direction first
+                let candle = findFirstNotEmptyCandle(secondarySeries, idx, -1);
+                if (!candle) {
+                    candle = findFirstNotEmptyCandle(secondarySeries, idx, 1);
+                }
+                if (candle) {
+                    // copy the candle and simplify it's OHLC
+                    const fakeCandle = copyCandle(candle, idx, true);
+                    result.push(fakeCandle);
+                }
+            }
+            else {
+                result.push(compareCandle);
+            }
+        });
+        return result;
+    }
+    /**
+     * Updates the configuration of the secondary candle series with the provided colors and instrument symbol.
+     * @param {PartialCandleSeriesColors} config - The partial configuration object containing the colors to update.
+     * @param {string} instrumentSymbol - The symbol of the instrument to update the colors for.
+     * @param {DataSeriesType} chartType - The type of chart to update the series to.
+     * @returns {void}
+     */
+    updateSecondaryCandleSeriesConfig(config, instrumentSymbol, chartType) {
+        const candleSeriesConfig = mergeObj(config, getDefaultConfig().colors);
+        this.secondaryChartColors.updateColorConfig(instrumentSymbol, candleSeriesConfig);
+        const seriesToUpdate = this.findSecondarySeriesBySymbol(instrumentSymbol);
+        if (seriesToUpdate) {
+            seriesToUpdate.config.type = chartType;
+            seriesToUpdate.updateCandleSeriesColors(candleSeriesConfig);
+            this.bus.fireDraw([this.canvasModel.canvasId]);
+        }
+        this.bus.fireDraw([this.canvasModel.canvasId]);
+    }
+    /**
+     * Sets the autoScale property of the scaleModel object.
+     * @param {boolean} auto - The value to be set for the autoScale property.
+     * @returns {void}
+     */
+    setAutoScale(auto) {
+        this.scale.autoScale(auto);
+    }
+    /**
+     * Returns the effective width of the Y axis.
+     *
+     * @function
+     * @name getEffectiveYAxisWidth
+     * @returns {number} The effective width of the Y axis.
+     */
+    getEffectiveYAxisWidth() {
+        const yAxis = this.canvasBoundsContainer.getBounds(CanvasElement.PANE_UUID_Y_AXIS(CHART_UUID));
+        return yAxis.width;
+    }
+    /**
+     * Returns the effective width of the chart.
+     *
+     * @function
+     * @returns {number} The effective width of the chart.
+     */
+    getEffectiveChartWidth() {
+        const chart = this.canvasBoundsContainer.getBounds(CanvasElement.PANE_UUID(CHART_UUID));
+        return chart.width;
+    }
+    /**
+     * Returns the effective height of the chart.
+     *
+     * @returns {number} The effective height of the chart.
+     */
+    getEffectiveChartHeight() {
+        const chart = this.canvasBoundsContainer.getBounds(CanvasElement.PANE_UUID(CHART_UUID));
+        return chart.height;
+    }
+    /**
+     * Updates the offsets of the chart components and redraws the chart.
+     * @param {Partial<ChartConfigComponentsOffsets>} offsets - The new offsets to be applied to the chart components.
+     * @returns {void}
+     */
+    setOffsets(offsets) {
+        this.scale.updateOffsets(offsets);
+        const lastIdx = this.getCandlesCountWithRightOffset();
+        const visualCandles = this.mainCandleSeries.visualPoints;
+        if (this.hasCandles() && lastIdx >= visualCandles.length) {
+            this.scale.setXScale(this.scale.xStart, this.candleFromIdx(lastIdx).startUnit);
+        }
+        this.offsetsChanged.next();
+        this.bus.fireDraw();
+    }
+    /**
+     * Returns the offsets of the chart components.
+     * @returns {ChartConfigComponentsOffsets} The offsets of the chart components.
+     */
+    getOffsets() {
+        return this.scale.getOffsets();
+    }
+    /**
+     * Converts "y" in pixels to: price / percent / other value.
+     * @param y - source value in pixels
+     */
+    fromY(y) {
+        return this.scale.fromY(y);
+    }
+    /**
+     * Converts "y" in pixels to price
+     * @param y - source value in pixels
+     * @param candleSeriesModel - (optional) candle series
+     */
+    priceFromY(y, candleSeriesModel) {
+        const series = candleSeriesModel !== null && candleSeriesModel !== void 0 ? candleSeriesModel : this.mainCandleSeries;
+        return series.view.priceFromY(y);
+    }
+    /**
+     * Converts "x" in pixels to timestamp
+     * @param x - source value in pixels
+     */
+    fromX(x) {
+        return this.scale.fromX(x);
+    }
+    /**
+     * Converts index to pixel.
+     * @param idx - index of candle
+     */
+    toX(idx) {
+        const visualCandle = this.candleFromIdx(idx);
+        // lineX is the middle of candle - it's correct
+        return this.scale.toX(visualCandle.centerUnit);
+    }
+    /**
+     * Transforms X coordinate (relative to canvas element) to Candle object.
+     * If extrapolate = false, then it takes leftmost/rightmost existing candle
+     */
+    candleFromX(x, extrapolate = false, selectedCandleSeries = this.mainCandleSeries) {
+        const unit = this.scale.fromX(x);
+        return this.candleFromUnit(unit, extrapolate, selectedCandleSeries);
+    }
+    /**
+     * Returns a candle object based on the provided unit, which is searched for in the visualPoints array of the selectedCandleSeries.
+     * If extrapolate is true and the unit is outside the visualPoints array, a fake candle is returned.
+     * If extrapolate is false and the unit is outside the visualPoints array, null is returned.
+     * If the unit is within the visualPoints array, the corresponding candle object is returned.
+     *
+     * @param {Unit} unit - The unit to search for in the visualPoints array.
+     * @param {boolean} extrapolate - Whether to extrapolate a fake candle if the unit is outside the visualPoints array.
+     * @param {CandleSeriesModel} selectedCandleSeries - The candle series to search in. Defaults to the mainCandleSeries.
+     * @returns {Candle} - The corresponding candle object, or null if extrapolate is false and the unit is outside the visualPoints array.
+     */
+    candleFromUnit(unit, extrapolate = false, selectedCandleSeries = this.mainCandleSeries) {
+        var _a, _b;
+        const result = binarySearch(selectedCandleSeries.visualPoints, unit, i => i.startUnit);
+        const visualCandleSource = selectedCandleSeries.visualPoints;
+        const lastVisualCandle = this.getLastVisualCandle();
+        if (visualCandleSource[result.index] !== undefined &&
+            (unit < 0 || (lastVisualCandle && unit > lastVisualCandle.startUnit + lastVisualCandle.width))) {
+            result.index += round((unit - visualCandleSource[result.index].centerUnit) / this.mainCandleSeries.meanCandleWidth);
+        }
+        const candleIdx = result.index;
+        const safeIdx = Math.max(Math.min(visualCandleSource.length - 1, candleIdx), 0);
+        if ((candleIdx < 0 || candleIdx >= visualCandleSource.length) && extrapolate) {
+            // fake candle
+            return fakeCandle(this.mainCandleSeries.dataPoints, candleIdx, this.chartBaseModel.period);
+        }
+        else {
+            // real candle
+            return ((_b = (_a = visualCandleSource[safeIdx]) === null || _a === void 0 ? void 0 : _a.candle) !== null && _b !== void 0 ? _b : fakeCandle(this.mainCandleSeries.dataPoints, safeIdx, this.chartBaseModel.period));
+        }
+    }
+    /**
+     * For given timestamp finds the closest candle in dataset.
+     * @param timestamp
+     */
+    candleFromTimestamp(timestamp, shouldExtrapolate = true) {
+        return this.chartBaseModel.dataFromTimestamp(timestamp, shouldExtrapolate);
+    }
+    /**
+     * For given index returns the closest visual candle, or fake candle with correct X coordinate.
+     * @param idx - index of candle
+     */
+    candleFromIdx(idx) {
+        return this.chartBaseModel.dataFromIdx(idx);
+    }
+    /**
+     * Check whether model is ready for drawing.
+     */
+    isReady() {
+        // Do not check canvas size: we should check width only when resize event has occurred
+        return this.canvasModel.isReady() && this.hasCandles();
+    }
+    /**
+     * You can use this method to determine logic of visual candle transformation for specified chart type.
+     * @param chartType
+     * @param calculator
+     */
+    registerCandlesTransformer(chartType, calculator) {
+        this.candlesTransformersByChartType[chartType] = calculator;
+    }
+    /**
+     * You can use this method to determine chart width calculation for specified chart type.
+     * @param chartType
+     * @param calculator
+     */
+    registerCandlesWidthCalculator(chartType, calculator) {
+        this.candleWidthByChartType[chartType] = calculator;
+    }
+    /**
+     * You can use this method to modify labels for last candle.
+     * @param chartType
+     * @param handler
+     */
+    registerLastCandleLabelHandler(chartType, handler) {
+        this.lastCandleLabelsByChartType[chartType] = handler;
+    }
+    /**
+     * Checks if the main candle series has visual points.
+     * @returns {boolean} Returns true if the main candle series has visual points, otherwise false.
+     */
+    hasCandles() {
+        return this.mainCandleSeries.visualPoints.length !== 0;
+    }
+    /**
+     * Returns a visual candle object from the main candle series based on the provided index.
+     * @param {Index} idx - The index of the visual candle to retrieve.
+     * @returns {VisualCandle|undefined} - The visual candle object or undefined if it doesn't exist.
+     */
+    getVisualCandle(idx) {
+        var _a, _b, _c;
+        const indexToGrab = idx - ((_c = (_b = (_a = this.mainCandleSeries.visualPoints[0]) === null || _a === void 0 ? void 0 : _a.candle) === null || _b === void 0 ? void 0 : _b.idx) !== null && _c !== void 0 ? _c : 0);
+        return this.mainCandleSeries.visualPoints[indexToGrab];
+    }
+    /**
+     * Returns the index of the first data point in the main candle series.
+     *
+     * @returns {number} The index of the first data point in the main candle series.
+     */
+    getFirstIdx() {
+        return this.mainCandleSeries.dataIdxStart;
+    }
+    /**
+     * Returns the last index of the data in the mainCandleSeries.
+     *
+     * @returns {number} - The last index of the data in the mainCandleSeries.
+     */
+    getLastIdx() {
+        return this.mainCandleSeries.dataIdxEnd;
+    }
+    /**
+     * Returns the timestamp of the first candle in the viewport dataset
+     * @param dataBased - if false will return timestamp which matches first viewport point even if candle is not available
+     * @returns {Timestamp} The timestamp of the first candle
+     */
+    getFirstTimestamp(dataBased = true) {
+        if (dataBased) {
+            return this.candleFromIdx(this.getFirstIdx()).candle.timestamp;
+        }
+        else {
+            return this.candleFromUnit(this.scale.xStart, true).timestamp;
+        }
+    }
+    /**
+     * Returns the timestamp of the last candle in the viewport candle array
+     * @param dataBased - if false will return timestamp which matches first viewport point even if candle is not available
+     * @returns {Timestamp} The timestamp of the last candle
+     */
+    getLastTimestamp(dataBased = true) {
+        if (dataBased) {
+            return this.candleFromIdx(this.getLastIdx()).candle.timestamp;
+        }
+        else {
+            return this.candleFromUnit(this.scale.xEnd, true).timestamp;
+        }
+    }
+    /**
+     * Sets the timestamp range of the chart by setting the x-axis scale.
+     * @param {Timestamp} start - The start timestamp of the range.
+     * @param {Timestamp} end - The end timestamp of the range.
+     * @returns {void}
+     */
+    setTimestampRange(start, end) {
+        const startUnit = this.candleFromTimestamp(start).startUnit;
+        const endCandle = this.candleFromTimestamp(end);
+        const endUnit = endCandle.startUnit + endCandle.width;
+        return this.scale.setXScale(startUnit, endUnit);
+    }
+    /**
+     * Returns the last candle of the main candle series.
+     * @returns {Candle | undefined} The last candle of the main candle series or undefined if the series is empty.
+     */
+    getLastCandle() {
+        const candles = this.mainCandleSeries.dataPoints;
+        return lastOf(candles);
+    }
+    /**
+     * Returns the last visual candle of the main candle series.
+     * @returns {VisualCandle | undefined} The last visual candle of the main candle series or undefined if the series is empty.
+      
+    */
+    getLastVisualCandle() {
+        const candles = this.mainCandleSeries.visualPoints;
+        return lastOf(candles);
+    }
+    /**
+     * Calculates the maximum number of candles that can fit in the chart width based on the minimum candle width
+     * @returns {number} - The maximum number of candles that can fit in the chart width
+     */
+    getMaxCandlesFitLength() {
+        return floor(this.getEffectiveChartWidth() / this.config.components.chart.minWidth);
+    }
+    /**
+     * Returns an array of CandleSeriesModel objects representing the secondary candle series.
+     * @returns {Array<CandleSeriesModel>} An array of CandleSeriesModel objects representing the secondary candle series.
+     */
+    getSecondarySeries() {
+        return this.secondaryCandleSeries;
+    }
+    /**
+     * Checks if a given symbol matches the symbol of a given CandleSeriesModel's instrument.
+     * @param {CandleSeriesModel} series - The CandleSeriesModel to check.
+     * @param {ChartInstrument['symbol']} symbol - The symbol to compare with the instrument's symbol.
+     * @returns {boolean} - Returns true if the symbol matches the instrument's symbol, false otherwise.
+     */
+    isSeriesInstrument(series, symbol) {
+        return series.instrument.symbol === symbol;
+    }
+    /**
+     * Returns an array of CandleSeriesModel objects that match the provided symbol.
+     *
+     * @param {string} symbol - The symbol to search for.
+     * @returns {CandleSeriesModel[]} - An array of CandleSeriesModel objects that match the provided symbol.
+     */
+    findSeriesBySymbol(symbol) {
+        return this.candleSeries.filter(series => this.isSeriesInstrument(series, symbol));
+    }
+    /**
+     * Finds a secondary candle series by symbol
+     *
+     * @param {string} symbol - The symbol of the chart instrument
+     * @returns {CandleSeriesModel | undefined} - The secondary candle series or undefined if not found
+     */
+    findSecondarySeriesBySymbol(symbol) {
+        return this.secondaryCandleSeries.find(series => this.isSeriesInstrument(series, symbol));
+    }
+    /**
+     * Reindexes candles based on a given series.
+     * @private
+     * @param {Array<Candle>} baseSeries - The base series to search for candles.
+     * @param {Array<Candle>} series - The series to reindex.
+     * @returns {Array<Candle>} - The reindexed series.
+     */
+    reindexCandlesBasedOnSeries(baseSeries, series) {
+        return series.reduce((candles, candle) => {
+            const timestamp = candle.timestamp;
+            // find index of candle in baseSeries
+            const result = searchCandleIndex(timestamp, false, baseSeries, this.chartBaseModel.period);
+            if (result.index >= 0 && result.index < baseSeries.length) {
+                candle.idx = result.index;
+                candles[result.index] = candle;
+            }
+            return candles;
+        }, []);
+    }
+    getPeriod() {
+        return this.chartBaseModel.period;
+    }
+    /**
+     * Checks if a given candle is within the viewport.
+     * @param {number} idx - The index of the candle to check.
+     * @returns {boolean} - True if the candle is within the viewport, false otherwise.
+     */
+    isCandleInViewport(idx) {
+        return this.getFirstIdx() <= idx && idx <= this.getLastIdx();
+    }
+    /**
+     * Updates candles in series. Default is main series.
+     * Any number of candles may be provided - they would be matched by their index and updated.
+     * @param candles - any list of new (updated) candles
+     * @param instrument - name of instrument to update
+     */
+    // I'd like to keep this method, for me one generic method is more convenient than 3 (updateLastCandle, addLastCandle, prepend...)
+    updateCandles(candles, instrumentSymbol = this.mainCandleSeries.instrument.symbol) {
+        const isMainSymbol = this.mainCandleSeries.instrument.symbol === instrumentSymbol;
+        const seriesList = this.findSeriesBySymbol(instrumentSymbol);
+        if (seriesList.length === 0) {
+            console.warn("updateCandles failed. Can't find series", instrumentSymbol);
+            return;
+        }
+        seriesList.forEach(series => {
+            const curCandles = series.dataPoints;
+            let isNewCandle = false;
+            let isInView = false;
+            let lastCandle;
+            candles.forEach(candle => {
+                var _a;
+                if (!candle) {
+                    return;
+                }
+                // detect index of updating candle
+                const result = searchCandleIndex(candle.timestamp, true, curCandles, this.getPeriod());
+                const idx = Math.min(result.index, curCandles.length);
+                isNewCandle = isNewCandle || idx === curCandles.length;
+                // update the candle and index
+                curCandles[idx] = candle;
+                candle.idx = idx;
+                // set serie with new candle
+                series.dataPoints = curCandles;
+                series.recalculateDataViewportIndexes();
+                isInView = isInView || this.isCandleInViewport(idx);
+                const isOutRangeCurrentCandles = idx >= curCandles.length - 1;
+                const isBeforeCurrentLastCandle = lastCandle && candle.timestamp < lastCandle.timestamp;
+                if (isOutRangeCurrentCandles && !isBeforeCurrentLastCandle) {
+                    lastCandle = candle;
+                }
+                // we can move chart only when update is for main symbol
+                // TODO we can have two series with the same instruments - this logic doesn't cover this case
+                if (isNewCandle && lastCandle && isMainSymbol && isInView) {
+                    const widthCalculator = (_a = this.candleWidthByChartType[this.config.components.chart.type]) !== null && _a !== void 0 ? _a : calculateCandleWidth;
+                    this.scale.moveXStart(this.scale.xStart + widthCalculator(lastCandle));
+                }
+            });
+            if (lastCandle) {
+                series.updateCurrentPrice(lastCandle.close);
+            }
+            if (isInView && lastCandle && candles.length === 1) {
+                // can apply some optimization
+                // series.recalculateOnlyLastVisualCandle();
+                // TODO apply optimization
+                this.bus.fireDraw([this.canvasModel.canvasId]);
+            }
+            else {
+                series.recalculateVisualPoints();
+            }
+        });
+        this.scale.doAutoScale();
+        this.candlesUpdatedSubject.next();
+    }
+    /**
+     * Triggers when candles set or updated
+     */
+    observeCandlesChanged() {
+        return merge(this.candlesSetSubject, this.candlesUpdatedSubject);
+    }
+    /**
+     * Returns an array of Candle objects representing the data points of the main candle series.
+     * @returns {Array<Candle>} An array of Candle objects.
+     */
+    getCandles() {
+        return this.mainCandleSeries.dataPoints;
+    }
+    /***
+     * Returns candles array which consists of real candles and fake candles if from and to can't be satisfied with real ones.
+     * @param from - if not specified set to first candle timestamp
+     * @param to - if not specified set to last candle timestamp + right offset
+     */
+    getCandlesWithFake(from = 0, to) {
+        let candles = this.getCandles().slice();
+        const candlesCount = this.getCandlesCount();
+        const _to = to !== null && to !== void 0 ? to : candlesCount + this.FAKE_CANDLES_DEFAULT;
+        candles = candles.slice(Math.max(0, from), Math.min(candlesCount, _to));
+        // add fake candles if needed
+        const append = [];
+        const prepend = [];
+        for (let i = candlesCount; i < _to; i++) {
+            append.push(fakeCandle(this.mainCandleSeries.dataPoints, i, this.getPeriod()));
+        }
+        const toPrepend = Math.min(0, _to);
+        for (let i = from; i < toPrepend; i++) {
+            prepend.push(fakeCandle(this.mainCandleSeries.dataPoints, i, this.getPeriod()));
+        }
+        return [...prepend, ...candles, ...append];
+    }
+    /**
+     * Returns the number of candles in the main candle series.
+     *
+     * @returns {number} The number of candles in the main candle series.
+     */
+    getCandlesCount() {
+        return this.mainCandleSeries.dataPoints.length;
+    }
+    /**
+     * Returns the number of candles with the right offset.
+     * @returns {number} - The number of candles with the right offset.
+     */
+    getCandlesCountWithRightOffset() {
+        return this.getCandlesCount() + this.getOffsets().right;
+    }
+    /**
+     * Clears the data of all candle series in the chart.
+     */
+    clearData() {
+        this.candleSeries.forEach(candleSeries => candleSeries.clearData());
+    }
+    /**
+     * Adds new candles array to the existing one at the start, mostly used in lazy loading
+     * @param target - initial candles array
+     * @param prependUpdate - additional candles array, which will be added to the target array
+     */
+    prependCandles(target, prependUpdate) {
+        const targetCopy = target.slice();
+        const prepend = [];
+        prependUpdate.forEach(c => {
+            const result = searchCandleIndex(c.timestamp, false, target);
+            const idx = result.index;
+            if (idx < 0) {
+                prepend.push(c);
+            }
+            else if (target[idx].timestamp === c.timestamp) {
+                targetCopy[idx] = c;
+            }
+            else {
+                console.warn(`Couldn't update candle with timestamp ${c.timestamp}`);
+            }
+        });
+        return {
+            prepended: prepend.length,
+            candles: [...prepend, ...targetCopy],
+        };
+    }
+    /**
+     * Adds new candle to the chart
+     * @param candle - new candle
+     * @param instrument - name of the instrument to update
+     */
+    addLastCandle(candle, instrumentSymbol = this.mainCandleSeries.instrument.symbol) {
+        this.updateCandles([candle], instrumentSymbol);
+    }
+    /**
+     * Updates last candle value
+     * @param candle - updated candle
+     * @param instrument - name of the instrument to update
+     */
+    updateLastCandle(candle, instrumentSymbol = this.mainCandleSeries.instrument.symbol) {
+        this.updateCandles([candle], instrumentSymbol);
+    }
+}
+const sortCandles = (candles) => candles.slice().sort((a, b) => (a.timestamp === b.timestamp ? 0 : a.timestamp > b.timestamp ? 1 : -1));
+const findFirstNotEmptyCandle = (candles, startIdx, iterateStep) => {
+    if (startIdx >= candles.length) {
+        return candles[candles.length - 1];
+    }
+    for (let i = startIdx; i < candles.length && i >= 0; i += iterateStep) {
+        const candle = candles[i];
+        if (candle) {
+            return candle;
+        }
+    }
+};
+/**
+ * Updates target array using update array.
+ * If there is a candle with the same timestamp as in target array then it will be replaced
+ * If the candle timestamp from update is somewhere between target candles then it will be ignored
+ * If the update candle timestamp is beyond target, then it will be prepended/appended to target
+ * @param target {Candle[]} - sorted candles
+ * @param update {Candle[]} - sorted candles
+ */
+const updateCandles = (target, update) => {
+    const targetCopy = target.slice();
+    const prepend = [];
+    const append = [];
+    update.forEach(c => {
+        const result = searchCandleIndex(c.timestamp, true, target);
+        const idx = result.index;
+        if (idx < 0) {
+            prepend.push(c);
+        }
+        else if (idx >= target.length) {
+            append.push(c);
+        }
+        else if (target[idx].timestamp === c.timestamp) {
+            targetCopy[idx] = c;
+        }
+        else {
+            console.warn(`Couldn't update candle with timestamp ${c.timestamp}`);
+        }
+    });
+    return {
+        prepended: prepend.length,
+        appended: append.length,
+        candles: [...prepend, ...targetCopy, ...append],
+    };
+};