@devexperts/dxcharts-lite 1.0.2 → 2.0.0

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

@@ -3,4 +3,91 @@
  * 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{CanvasBoundsContainer as l,CanvasElement as t,isInVerticalBounds as g}from"../canvas/canvas-bounds-container";import{ChartBaseElement as C}from"./chart-base-element";import{DragNDropYComponent as v}from"../components/dran-n-drop_helper/drag-n-drop-y.component";export const BASELINE_RESIZER_UUID="BASELINE_RESIZER";export class BaselineModel extends C{constructor(s,e,n,i,r,a,h){super(),this.chartModel=s,this.canvasModel=n,this.canvasInputListener=i,this.config=r,this.canvasBoundContainer=a,this.cursorHandler=h,this.resizerBounds={x:0,y:0,pageX:0,pageY:0,height:0,width:0},this.baselineYPercents=50,this.ht=l.hitTestOf(this.resizerBounds,{extensionY:this.config.components.paneResizer.dragZone}),this.dragTickCb=d=>{const{delta:u}=d,B=this.canvasBoundContainer.getBounds(t.CHART),o=this.canvasInputListener.getCurrentPoint().y;u!==0&&g(o,B)&&(this.moveBaseLine(o),this.canvasModel.fireDraw())};const c=new v(this.ht,{onDragTick:this.dragTickCb},i,e);this.addChildEntity(c)}doActivate(){super.doActivate(),this.addRxSubscription(this.canvasBoundContainer.observeBoundsChanged(t.CHART).subscribe(()=>this.recalculateBounds())),this.chartModel.chartTypeChanged.subscribe(s=>{s==="baseline"?this.cursorHandler.setCursorForBounds("BASELINE_RESIZER",this.resizerBounds,this.config.components.baseline.cursor,this.config.components.baseline.dragZone):this.cursorHandler.removeCursorForCanvasEl("BASELINE_RESIZER")})}recalculateBounds(){const s=this.canvasBoundContainer.getBounds(t.CHART),e=this.canvasBoundContainer.getBounds(t.Y_AXIS);this.resizerBounds.x=s.x,this.resizerBounds.width=s.width+e.width,this.resizerBounds.height=this.config.components.baseline.height;const n=s.y+s.height*(this.baselineYPercents/100);this.resizerBounds.y=n,this.canvasBoundContainer.bounds[BASELINE_RESIZER_UUID]=this.resizerBounds}moveBaseLine(s){const e=this.canvasBoundContainer.getBounds(t.CHART);this.baselineYPercents=(s-e.y)*100/e.height,this.resizerBounds.y=s}doDeactivate(){super.doDeactivate()}}
+import { CanvasBoundsContainer, CanvasElement, isInVerticalBounds, } from '../canvas/canvas-bounds-container';
+import { ChartBaseElement } from './chart-base-element';
+import { DragNDropYComponent } from '../components/dran-n-drop_helper/drag-n-drop-y.component';
+export const BASELINE_RESIZER_UUID = 'BASELINE_RESIZER';
+/**
+ * Baseline separator for baseline chart
+ * Used to resize baseline area on chart.
+ */
+export class BaselineModel extends ChartBaseElement {
+    constructor(chartModel, chartPanComponent, canvasModel, canvasInputListener, config, canvasBoundContainer, cursorHandler) {
+        super();
+        this.chartModel = chartModel;
+        this.canvasModel = canvasModel;
+        this.canvasInputListener = canvasInputListener;
+        this.config = config;
+        this.canvasBoundContainer = canvasBoundContainer;
+        this.cursorHandler = cursorHandler;
+        this.resizerBounds = { x: 0, y: 0, pageX: 0, pageY: 0, height: 0, width: 0 };
+        // the position of a baseline in percents relatively to chart height
+        this.baselineYPercents = 50;
+        this.ht = CanvasBoundsContainer.hitTestOf(this.resizerBounds, {
+            extensionY: this.config.components.paneResizer.dragZone,
+        });
+        this.dragTickCb = (dragInfo) => {
+            const { delta: yDelta } = dragInfo;
+            const chart = this.canvasBoundContainer.getBounds(CanvasElement.CHART);
+            const y = this.canvasInputListener.getCurrentPoint().y;
+            if (yDelta !== 0 && isInVerticalBounds(y, chart)) {
+                this.moveBaseLine(y);
+                this.canvasModel.fireDraw();
+            }
+        };
+        const dndHelper = new DragNDropYComponent(this.ht, {
+            onDragTick: this.dragTickCb,
+        }, canvasInputListener, chartPanComponent);
+        this.addChildEntity(dndHelper);
+    }
+    doActivate() {
+        super.doActivate();
+        this.addRxSubscription(this.canvasBoundContainer
+            .observeBoundsChanged(CanvasElement.CHART)
+            .subscribe(() => this.recalculateBounds()));
+        this.chartModel.chartTypeChanged.subscribe(type => {
+            if (type === 'baseline') {
+                this.cursorHandler.setCursorForBounds('BASELINE_RESIZER', this.resizerBounds, this.config.components.baseline.cursor, this.config.components.baseline.dragZone);
+            }
+            else {
+                this.cursorHandler.removeCursorForCanvasEl('BASELINE_RESIZER');
+            }
+        });
+    }
+    /**
+     * Recalculates the bounds of the baseline resizer based on the current chart and y-axis bounds.
+     * @private
+     * @function
+     * @name recalculateBounds
+     * @memberof ClassName
+     * @returns {void}
+     */
+    recalculateBounds() {
+        const chart = this.canvasBoundContainer.getBounds(CanvasElement.CHART);
+        const yAxis = this.canvasBoundContainer.getBounds(CanvasElement.Y_AXIS);
+        this.resizerBounds.x = chart.x;
+        this.resizerBounds.width = chart.width + yAxis.width;
+        this.resizerBounds.height = this.config.components.baseline.height;
+        const relativeBaselineY = chart.y + chart.height * (this.baselineYPercents / 100);
+        this.resizerBounds.y = relativeBaselineY;
+        this.canvasBoundContainer.bounds[BASELINE_RESIZER_UUID] = this.resizerBounds;
+    }
+    /**
+     * Moves the baseline of the chart to the specified y coordinate.
+     * @param {number} y - The y coordinate to move the baseline to.
+     * @returns {void}
+     */
+    moveBaseLine(y) {
+        const chart = this.canvasBoundContainer.getBounds(CanvasElement.CHART);
+        this.baselineYPercents = ((y - chart.y) * 100) / chart.height;
+        this.resizerBounds.y = y;
+    }
+    /**
+     * This method is called when the component is being deactivated.
+     * It calls the doDeactivate method of the parent class.
+     * @protected
+     */
+    doDeactivate() {
+        super.doDeactivate();
+    }
+}

package/dist/chart/model/bounds.model.js

@@ -3,4 +3,4 @@
  * 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{};
+export {};

package/dist/chart/model/candle-hover.js

@@ -3,4 +3,73 @@
  * 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/.
  */
-class l{constructor(t,e,r,s){this.visualCandle=t,this.price=e,this.priceFormatter=r,this.toY=s}get high(){return this.visualCandle.high}get low(){return this.visualCandle.low}get open(){return this.visualCandle.open}get close(){return this.visualCandle.close}get volume(){return this.visualCandle.candle.volume}get openY(){return this.toY(this.open)}get closeY(){return this.toY(this.close)}get highY(){return this.toY(this.high)}get lowY(){return this.toY(this.low)}get openFormatted(){return this.priceFormatter(this.open)}get closeFormatted(){return this.priceFormatter(this.close)}get highFormatted(){return this.priceFormatter(this.high)}get lowFormatted(){return this.priceFormatter(this.low)}get closestOHLCY(){return this.toY([this.close,this.open,this.high,this.low].sort((t,e)=>Math.abs(t-this.price)-Math.abs(e-this.price))[0])}}export class CandleHoverProducerPart{constructor(t){this.chartModel=t}getData(t){const{x:e,y:r}=t,h=this.chartModel.candleFromX(e).idx||0,i=this.chartModel.getVisualCandle(h),a=this.chartModel.priceFromY(r);return i&&new l(i,a,this.chartModel.pane.regularFormatter,this.chartModel.toY)}}
+class CandleHoverImpl {
+    constructor(visualCandle, price, priceFormatter, toY) {
+        this.visualCandle = visualCandle;
+        this.price = price;
+        this.priceFormatter = priceFormatter;
+        this.toY = toY;
+    }
+    get high() {
+        return this.visualCandle.high;
+    }
+    get low() {
+        return this.visualCandle.low;
+    }
+    get open() {
+        return this.visualCandle.open;
+    }
+    get close() {
+        return this.visualCandle.close;
+    }
+    get volume() {
+        return this.visualCandle.candle.volume;
+    }
+    get openY() {
+        return this.toY(this.open);
+    }
+    get closeY() {
+        return this.toY(this.close);
+    }
+    get highY() {
+        return this.toY(this.high);
+    }
+    get lowY() {
+        return this.toY(this.low);
+    }
+    get openFormatted() {
+        return this.priceFormatter(this.open);
+    }
+    get closeFormatted() {
+        return this.priceFormatter(this.close);
+    }
+    get highFormatted() {
+        return this.priceFormatter(this.high);
+    }
+    get lowFormatted() {
+        return this.priceFormatter(this.low);
+    }
+    get closestOHLCY() {
+        return this.toY([this.close, this.open, this.high, this.low].sort((a, b) => Math.abs(a - this.price) - Math.abs(b - this.price))[0]);
+    }
+}
+export class CandleHoverProducerPart {
+    constructor(chartModel) {
+        this.chartModel = chartModel;
+    }
+    /**
+     * Returns a CandleHover object or undefined based on the provided BaseHover object.
+     * @param {BaseHover} hover - The BaseHover object containing the x and y coordinates.
+     * @returns {CandleHover | undefined} - The CandleHover object or undefined if mainSeriesCandle is falsy.
+     */
+    getData(hover) {
+        const { x, y } = hover;
+        const candle = this.chartModel.candleFromX(x);
+        const idx = candle.idx || 0;
+        const mainSeriesCandle = this.chartModel.getVisualCandle(idx);
+        const price = this.chartModel.priceFromY(y);
+        const candleHover = mainSeriesCandle &&
+            new CandleHoverImpl(mainSeriesCandle, price, this.chartModel.pane.regularFormatter, this.chartModel.toY);
+        return candleHover;
+    }
+}

package/dist/chart/model/candle-series-high-low.provider.js

@@ -3,4 +3,48 @@
  * 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 createCandleSeriesHighLowProvider=i=>({isHighLowActive:()=>!0,calculateHighLow:t=>{const o=t?t.xStart:i.scaleModel.xStart,n=t?t.xEnd:i.scaleModel.xEnd,{dataIdxStart:a,dataIdxEnd:r}=i.calculateDataViewportIndexes(o,n),x=i.visualPoints.slice(a,r+1),h=calculateCandlesHighLow(x),c=()=>{var s,l;return(l=(s=i.visualPoints[a])===null||s===void 0?void 0:s.close)!==null&&l!==void 0?l:1};return Object.assign(Object.assign({},h),{low:i.view.toAxisUnits(h.low,c),high:i.view.toAxisUnits(h.high,c)})}}),calculateCandlesHighLow=i=>{const t={high:Number.MIN_SAFE_INTEGER,low:Number.MAX_SAFE_INTEGER,highIdx:0,lowIdx:0};for(let o=0;o<i.length;o++){const n=i[o];n.high>t.high&&(t.high=n.high,t.highIdx=o),n.low<t.low&&(t.low=n.low,t.lowIdx=o)}return t};
+/**
+ * Candles high low provider.
+ * @param candleSeriesModel
+ * @doc-tags viewport,scaling
+ */
+export const createCandleSeriesHighLowProvider = (candleSeriesModel) => {
+    return {
+        isHighLowActive: () => true,
+        calculateHighLow: (state) => {
+            const xStart = state ? state.xStart : candleSeriesModel.scale.xStart;
+            const xEnd = state ? state.xEnd : candleSeriesModel.scale.xEnd;
+            const { dataIdxStart, dataIdxEnd } = candleSeriesModel.calculateDataViewportIndexes(xStart, xEnd);
+            // +1 because dataIdxEnd candle should be included in the result
+            const visualCandles = candleSeriesModel.visualPoints.slice(dataIdxStart, dataIdxEnd + 1);
+            const highLowWithIndex = calculateCandlesHighLow(visualCandles);
+            // to calculate correct high low for percent scale
+            const baseLine = () => { var _a, _b; return (_b = (_a = candleSeriesModel.visualPoints[dataIdxStart]) === null || _a === void 0 ? void 0 : _a.close) !== null && _b !== void 0 ? _b : 1; };
+            return Object.assign(Object.assign({}, highLowWithIndex), { low: candleSeriesModel.view.toAxisUnits(highLowWithIndex.low, baseLine), high: candleSeriesModel.view.toAxisUnits(highLowWithIndex.high, baseLine) });
+        },
+    };
+};
+/**
+ * Calculates the high and low values for given candles array.
+ * @param visualCandles
+ */
+export const calculateCandlesHighLow = (visualCandles) => {
+    const result = {
+        high: Number.MIN_SAFE_INTEGER,
+        low: Number.MAX_SAFE_INTEGER,
+        highIdx: 0,
+        lowIdx: 0,
+    };
+    for (let i = 0; i < visualCandles.length; i++) {
+        const candle = visualCandles[i];
+        if (candle.high > result.high) {
+            result.high = candle.high;
+            result.highIdx = i;
+        }
+        if (candle.low < result.low) {
+            result.low = candle.low;
+            result.lowIdx = i;
+        }
+    }
+    return result;
+};

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

@@ -34,13 +34,13 @@ export declare class CandleSeriesModel extends DataSeriesModel<Candle, VisualCan
     get instrument(): ChartInstrument;
     set instrument(instrument: ChartInstrument);
     meanCandleWidth: Unit;
-    constructor(extentComponent: YExtentComponent, id: number, eventBus: EventBus, scaleModel: ScaleModel, instrument: ChartInstrument, candlesTransformersByChartType: Partial<Record<DataSeriesType, VisualCandleCalculator>>, candleWidthByChartType: Partial<Record<DataSeriesType, CandleWidthCalculator>>, colors?: CandleSeriesColors);
+    constructor(extentComponent: YExtentComponent, id: number, eventBus: EventBus, scale: ScaleModel, instrument: ChartInstrument, candlesTransformersByChartType: Partial<Record<DataSeriesType, VisualCandleCalculator>>, candleWidthByChartType: Partial<Record<DataSeriesType, CandleWidthCalculator>>, colors?: CandleSeriesColors);
     /**
      * Recalculates data viewport indexes based on xStart and xEnd parameters or values from scaleModel.
      * Calls superclass method for calculation, recalculates zipped high/low data points, and fires draw event.
      *
-     * @param {number} [xStart=this.scaleModel.xStart] - Start index of visible data range.
-     * @param {number} [xEnd=this.scaleModel.xEnd] - End index of visible data range.
+     * @param {number} [xStart=this.scale.xStart] - Start index of visible data range.
+     * @param {number} [xEnd=this.scale.xEnd] - End index of visible data range.
      * @returns {void}
      */
     recalculateDataViewportIndexes(xStart?: number, xEnd?: number): void;

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

@@ -3,4 +3,248 @@
  * 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{getDefaultConfig as f}from"../chart.config";import{defaultCandleTransformer as v}from"../components/chart/candle-transformer.functions";import{calculateCandleWidth as g}from"../components/chart/candle-width-calculator.functions";import{lastOf as w}from"../utils/array.utils";import{merge as D}from"../utils/merge.utils";import{PriceIncrementsUtils as y}from"../utils/price-increments.utils";import{calculateCandlesHighLow as L,createCandleSeriesHighLowProvider as M}from"./candle-series-high-low.provider";import{BASIC_CANDLE_WIDTH as u,nameDirection as S}from"./candle.model";import{DataSeriesModel as V}from"./data-series.model";import{getDefaultHighLowWithIndex as x}from"./scale.model";const I=f().colors;export class CandleSeriesModel extends V{get dataPoints(){return super.dataPoints}set dataPoints(e){super.dataPoints=e,this.applyPriceMovement()}get instrument(){return this._instrument}set instrument(e){var t;this._instrument=e,this.pricePrecisions=y.computePrecisions((t=e.priceIncrements)!==null&&t!==void 0?t:[.01])}constructor(e,t,i,a,s,r,n,o=I){super(e,t),this.eventBus=i,this.candlesTransformersByChartType=r,this.candleWidthByChartType=n,this.colors=o,this.zippedHighLow=x(),this.lastPriceMovement="none",this.lastVisualCandleChangedSubject=new C,this.meanCandleWidth=u,this._instrument=s,this.instrument=s,this.highLowProvider=M(this),this.scaleModel=a,this.name=s.symbol}recalculateDataViewportIndexes(e=this.scaleModel.xStart,t=this.scaleModel.xEnd){super.recalculateDataViewportIndexes(e,t),this.recalculateZippedHighLow(),this.eventBus.fireDraw()}applyPriceMovement(){const e=w(this.dataPoints);e&&(this.lastPriceMovement=S(e.open,e.close))}recalculateVisualPoints(){super.recalculateVisualPoints(),this.recalculateMeanCandleWidth(this.visualPoints)}recalculateZippedHighLow(){return this.zippedHighLow=L(this.visualPoints.slice(this.dataIdxStart,this.dataIdxEnd))}updateCurrentPrice(e){this.previousPrice=this.currentPrice||e,this.currentPrice=e,this.currentPrice!==this.previousPrice&&(this.lastPriceMovement=this.currentPrice>this.previousPrice?"up":"down")}updateCandleSeriesColors(e){this.colors=D(e,this.colors),this.recalculateVisualPoints()}observeLastVisualCandleChanged(){return this.lastVisualCandleChangedSubject.asObservable()}doDeactivate(){super.doDeactivate()}toVisualPoints(e,t=0){var i,a;if(e.length===0)return[];const s=this.config.type,r=[];let n=t;const o=(i=this.candleWidthByChartType[s])!==null&&i!==void 0?i:g;for(let l=0;l<e.length;l++){const d=e[l],p=e[l-1],c=o(d),m=n+c/2,P=(a=this.candlesTransformersByChartType[s])!==null&&a!==void 0?a:v;r.push(P(d,{x:m,width:c,prevCandle:p,activeCandle:this.activeCandle})),n+=c}return r}recalculateMeanCandleWidth(e){e.length!==0?this.meanCandleWidth=e.reduce((t,i)=>t+i.width,0)/e.length:this.meanCandleWidth=u}setActiveCandle(e){this.activeCandle=e,this.recalculateVisualPoints()}clearData(){this.dataPoints=[],this.clearVisualCandles(),this.clearPrices()}clearPrices(){this.previousPrice=void 0,this.currentPrice=void 0,this.lastPriceMovement="none"}clearVisualCandles(){this.visualPoints=[]}}export function isLinked(h){switch(h){case"line":case"area":return!0;default:return!1}}
+import { Subject } from 'rxjs';
+import { getDefaultConfig } from '../chart.config';
+import { defaultCandleTransformer } from '../components/chart/candle-transformer.functions';
+import { calculateCandleWidth } from '../components/chart/candle-width-calculator.functions';
+import { lastOf } from '../utils/array.utils';
+import { merge } from '../utils/merge.utils';
+import { PriceIncrementsUtils } from '../utils/price-increments.utils';
+import { calculateCandlesHighLow, createCandleSeriesHighLowProvider } from './candle-series-high-low.provider';
+import { BASIC_CANDLE_WIDTH, nameDirection } from './candle.model';
+import { DataSeriesModel } from './data-series.model';
+import { getDefaultHighLowWithIndex } from './scale.model';
+const DEFAULT_CANDLE_SERIES_CONFIG = getDefaultConfig().colors;
+export class CandleSeriesModel extends DataSeriesModel {
+    get dataPoints() {
+        return super.dataPoints;
+    }
+    set dataPoints(points) {
+        super.dataPoints = points;
+        this.applyPriceMovement();
+    }
+    get instrument() {
+        return this._instrument;
+    }
+    set instrument(instrument) {
+        var _a;
+        this._instrument = instrument;
+        this.pricePrecisions = PriceIncrementsUtils.computePrecisions((_a = instrument.priceIncrements) !== null && _a !== void 0 ? _a : [0.01]);
+    }
+    constructor(extentComponent, id, eventBus, scale, instrument, candlesTransformersByChartType, candleWidthByChartType, colors = DEFAULT_CANDLE_SERIES_CONFIG) {
+        super(extentComponent, id);
+        this.eventBus = eventBus;
+        this.candlesTransformersByChartType = candlesTransformersByChartType;
+        this.candleWidthByChartType = candleWidthByChartType;
+        this.colors = colors;
+        // high low in absolute price values
+        this.zippedHighLow = getDefaultHighLowWithIndex();
+        this.lastPriceMovement = 'none';
+        this.lastVisualCandleChangedSubject = new Subject();
+        // start/end candle index in viewport
+        this.meanCandleWidth = BASIC_CANDLE_WIDTH;
+        this._instrument = instrument;
+        this.instrument = instrument;
+        this.highLowProvider = createCandleSeriesHighLowProvider(this);
+        this.scale = scale;
+        this.name = instrument.symbol;
+    }
+    /**
+     * Recalculates data viewport indexes based on xStart and xEnd parameters or values from scaleModel.
+     * Calls superclass method for calculation, recalculates zipped high/low data points, and fires draw event.
+     *
+     * @param {number} [xStart=this.scale.xStart] - Start index of visible data range.
+     * @param {number} [xEnd=this.scale.xEnd] - End index of visible data range.
+     * @returns {void}
+     */
+    recalculateDataViewportIndexes(xStart = this.scale.xStart, xEnd = this.scale.xEnd) {
+        super.recalculateDataViewportIndexes(xStart, xEnd);
+        this.recalculateZippedHighLow();
+        this.eventBus.fireDraw();
+    }
+    /**
+     * Calculates the price movement of the last candle by comparing the open and close prices.
+     * Sets the lastPriceMovement property of the instance with the name of the direction of the price movement.
+     *
+     * @returns {void}
+     */
+    applyPriceMovement() {
+        const lastCandle = lastOf(this.dataPoints);
+        if (lastCandle) {
+            this.lastPriceMovement = nameDirection(lastCandle.open, lastCandle.close);
+        }
+    }
+    /**
+     * Should be called 1 time when candles are set / updated to chart.
+     */
+    recalculateVisualPoints() {
+        super.recalculateVisualPoints();
+        this.recalculateMeanCandleWidth(this.visualPoints);
+    }
+    /**
+     * Used for optimization when we have to update only the last candle
+     * @doc-tags tricky
+     */
+    // recalculateOnlyLastVisualCandle() {
+    // 	const prev = this.visualPointsFlat[this.visualPointsFlat.length - 2];
+    // 	const last = this.visualPointsFlat[this.visualPointsFlat.length - 1];
+    // 	if (last && prev) {
+    // 		const startX = this.visualPointsFlat[prev.idx ?? 0].startUnit;
+    // 		const updatedCandle = lastOf(this.toVisualCandles([prev, last], startX));
+    // 		if (updatedCandle) {
+    // 			this.visualCandleSource[this.visualCandleSource.length - 1] = updatedCandle;
+    // 			this.lastVisualCandleChangedSubject.next();
+    // 			this.eventBus.fire(EVENT_DRAW_LAST_CANDLE);
+    // 		}
+    // 	}
+    // }
+    /**
+     * Recalculates and returns the zipped high-low values for the visible data range.
+     * Uses the visualPoints, dataIdxStart, and dataIdxEnd properties of the instance to calculate high-low values.
+     *
+     * @returns {HighLowWithIndex} - An object containing the high-low values along with their corresponding indexes.
+     */
+    recalculateZippedHighLow() {
+        return (this.zippedHighLow = calculateCandlesHighLow(this.visualPoints.slice(this.dataIdxStart, this.dataIdxEnd)));
+    }
+    /**
+     * Updates the current price and the last price movement.
+     * Compares the current price with the previous price, and sets the lastPriceMovement property accordingly.
+     *
+     * @param {number} currentPrice - The current price of the asset.
+     * @returns {void}
+     */
+    updateCurrentPrice(currentPrice) {
+        this.previousPrice = this.currentPrice || currentPrice;
+        this.currentPrice = currentPrice;
+        if (this.currentPrice !== this.previousPrice) {
+            this.lastPriceMovement = this.currentPrice > this.previousPrice ? 'up' : 'down';
+        }
+    }
+    /**
+     * Updates the colors used to render the candlestick series and recalculates the visual points.
+     * Merges the newConfig object with the existing colors object of the instance.
+     * Calls the recalculateVisualPoints method of the instance to update the visual points using the new color configuration.
+     *
+     * @param {PartialCandleSeriesColors} newConfig - The new color configuration to be merged with the existing colors object.
+     * @returns {void}
+     */
+    updateCandleSeriesColors(newConfig) {
+        this.colors = merge(newConfig, this.colors);
+        this.recalculateVisualPoints();
+    }
+    /**
+     * Returns an observable that emits an event when the last visual candle changes.
+     * Returns the observable associated with the lastVisualCandleChangedSubject of the instance.
+     *
+     * @returns {Observable<void>} - An observable that emits an event when the last visual candle changes.
+     */
+    observeLastVisualCandleChanged() {
+        return this.lastVisualCandleChangedSubject.asObservable();
+    }
+    doDeactivate() {
+        super.doDeactivate();
+    }
+    /**
+     * Transforms candles list into visual candles.
+     * NOTE: should be used only on FULL candles array, no single transformations, since candle coordinates depend on each other.
+     * OR provide startX :)
+     * @param candles
+     * @param startX
+     */
+    toVisualPoints(candles, startX = 0) {
+        var _a, _b;
+        if (candles.length === 0) {
+            return [];
+        }
+        const type = this.config.type;
+        const visualCandles = [];
+        let accumulatedWidth = startX;
+        const calculator = (_a = this.candleWidthByChartType[type]) !== null && _a !== void 0 ? _a : calculateCandleWidth;
+        for (let i = 0; i < candles.length; i++) {
+            const candle = candles[i];
+            const prevCandle = candles[i - 1];
+            const width = calculator(candle);
+            // x - middle of candle
+            const x = accumulatedWidth + width / 2;
+            const transformer = (_b = this.candlesTransformersByChartType[type]) !== null && _b !== void 0 ? _b : defaultCandleTransformer;
+            visualCandles.push(transformer(candle, { x, width, prevCandle, activeCandle: this.activeCandle }));
+            accumulatedWidth += width;
+        }
+        return visualCandles;
+    }
+    /**
+     * Recalculates the mean candle width using the given array of visual candles.
+     * Calculates the sum of widths of all visual candles and divides it by the total number of candles to get the mean candle width.
+     * Sets the meanCandleWidth property of the instance with the calculated value.
+     *
+     * @param {VisualCandle[]} visualCandles - An array of visual candles to be used for mean candle width calculation.
+     * @returns {void}
+     */
+    recalculateMeanCandleWidth(visualCandles) {
+        if (visualCandles.length !== 0) {
+            this.meanCandleWidth = visualCandles.reduce((acc, cur) => acc + cur.width, 0) / visualCandles.length;
+        }
+        else {
+            this.meanCandleWidth = BASIC_CANDLE_WIDTH;
+        }
+    }
+    /**
+     * Sets the active candle for the chart and recalculates the visual points.
+     * Sets the activeCandle property of the instance with the provided candle parameter.
+     * Calls the recalculateVisualPoints method of the instance to recalculate the visual points using the new active candle.
+     *
+     * @param {Candle} candle - The candle to be set as active candle.
+     * @returns {void}
+     */
+    setActiveCandle(candle) {
+        this.activeCandle = candle;
+        this.recalculateVisualPoints();
+    }
+    /**
+     * Clears all the data and visual elements from the chart.
+     * Sets the dataPoints property of the instance to an empty array.
+     * Calls the clearVisualCandles and clearPrices methods of the instance to clear the visual elements from the chart.
+     *
+     * @returns {void}
+     */
+    clearData() {
+        this.dataPoints = [];
+        this.clearVisualCandles();
+        this.clearPrices();
+    }
+    /**
+     * Clears the price-related properties of the instance.
+     * Sets the previousPrice, currentPrice and lastPriceMovement properties of the instance to undefined, undefined, and 'none' respectively.
+     *
+     * @returns {void}
+     */
+    clearPrices() {
+        this.previousPrice = undefined;
+        this.currentPrice = undefined;
+        this.lastPriceMovement = 'none';
+    }
+    /**
+     * Clears the visualPoints property of the instance.
+     * Sets the visualPoints property of the instance to an empty array.
+     *
+     * @returns {void}
+     */
+    clearVisualCandles() {
+        this.visualPoints = [];
+    }
+}
+/**
+ * Checks if the provided chart type is linked.
+ * @param {BarType} chartType - The type of chart to check.
+ * @returns {boolean} - Returns true if the chart type is linked, false otherwise.
+ */
+export function isLinked(chartType) {
+    switch (chartType) {
+        case 'line':
+        case 'area':
+            return true;
+        default:
+            return false;
+    }
+}

package/dist/chart/model/candle.model.js

@@ -3,4 +3,72 @@
  * 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 BASIC_CANDLE_WIDTH=1;export function nameDirection(e,n){return n===e?"none":n>e?"up":"down"}export function hollowDirection(e,n){return n>e?"up":"down"}export function copyCandle(e,n,u=!1){const{expansion:p,impVolatility:c,vwap:f,volume:d,timestamp:x}=e;let o=e.hi,i=e.lo,r=e.open;const t=e.close;u&&(o=t,i=t,r=t);let l=e.idx;return n!==void 0&&(l=n),{hi:o,lo:i,open:r,close:t,timestamp:x,volume:d,expansion:p,idx:l,impVolatility:c,vwap:f}}
+// Has no specific rule, just any number to use in units calculation.
+// 1 - because why not? Easy to debug.
+export const BASIC_CANDLE_WIDTH = 1;
+/**
+ * Provides the name of candle difference
+ * @param {Number} open
+ * @param {Number} close
+ * @returns {String}
+ */
+export function nameDirection(open, close) {
+    if (close === open) {
+        return 'none';
+    }
+    else if (close > open) {
+        return 'up';
+    }
+    else {
+        return 'down';
+    }
+}
+/**
+ * Provides the name of candle difference for hollow chart type
+ * @param {Number} open
+ * @param {Number} close
+ * @returns {String}
+ */
+export function hollowDirection(open, close) {
+    if (close > open) {
+        return 'up';
+    }
+    else {
+        return 'down';
+    }
+}
+/**
+ * Creates a new Candle object based on the provided base object, with the option to modify the prices.
+ * @param {Candle} base - The base object to copy.
+ * @param {number} idx - The index of the new Candle object.
+ * @param {boolean} pricesAsClose - If true, the high, low, and open prices will be set to the close price.
+ * @returns {Candle} A new Candle object with the same properties as the base object, with the option to modify the prices.
+ */
+export function copyCandle(base, idx, pricesAsClose = false) {
+    const { expansion, impVolatility, vwap, volume, timestamp } = base;
+    let hi = base.hi;
+    let lo = base.lo;
+    let open = base.open;
+    const close = base.close;
+    if (pricesAsClose) {
+        hi = close;
+        lo = close;
+        open = close;
+    }
+    let _idx = base.idx;
+    if (idx !== undefined) {
+        _idx = idx;
+    }
+    return {
+        hi,
+        lo,
+        open,
+        close,
+        timestamp,
+        volume,
+        expansion,
+        idx: _idx,
+        impVolatility,
+        vwap,
+    };
+}