@devexperts/dxcharts-lite 1.0.1

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

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { Observable, Subject } from 'rxjs';
+import { BarType, FullChartColors } from '../chart.config';
+import { ChartInstrument } from '../components/chart/chart.component';
+import { CandleWidthCalculator, VisualCandleCalculator } from '../components/chart/chart.model';
+import { YExtentComponent } from '../components/pane/extent/y-extent-component';
+import EventBus from '../events/event-bus';
+import { DeepPartial } from '../utils/object.utils';
+import { Candle } from './candle.model';
+import { DataSeriesType } from './data-series.config';
+import { DataSeriesModel } from './data-series.model';
+import { HighLowWithIndex, ScaleModel } from './scale.model';
+import { Unit } from './scaling/viewport.model';
+import VisualCandle from './visual-candle';
+export type PriceMovement = 'up' | 'down' | 'none';
+export declare class CandleSeriesModel extends DataSeriesModel<Candle, VisualCandle> {
+    private eventBus;
+    private readonly candlesTransformersByChartType;
+    private readonly candleWidthByChartType;
+    colors: CandleSeriesColors;
+    zippedHighLow: HighLowWithIndex;
+    activeCandle?: Candle;
+    currentPrice: number | undefined;
+    previousPrice: number | undefined;
+    lastPriceMovement: PriceMovement;
+    lastVisualCandleChangedSubject: Subject<void>;
+    get dataPoints(): Candle[];
+    set dataPoints(points: Candle[] | Candle[][]);
+    private _instrument;
+    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);
+    /**
+     * 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.
+     * @returns {void}
+     */
+    recalculateDataViewportIndexes(xStart?: number, xEnd?: number): void;
+    /**
+     * 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}
+     */
+    private applyPriceMovement;
+    /**
+     * Should be called 1 time when candles are set / updated to chart.
+     */
+    recalculateVisualPoints(): void;
+    /**
+     * Used for optimization when we have to update only the last candle
+     * @doc-tags tricky
+     */
+    /**
+     * 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(): HighLowWithIndex;
+    /**
+     * 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: number): void;
+    /**
+     * 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: PartialCandleSeriesColors): void;
+    /**
+     * 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(): Observable<void>;
+    doDeactivate(): void;
+    /**
+     * 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: Array<Candle>, startX?: number): Array<VisualCandle>;
+    /**
+     * 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: VisualCandle[]): void;
+    /**
+     * 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: Candle): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * Clears the visualPoints property of the instance.
+     * Sets the visualPoints property of the instance to an empty array.
+     *
+     * @returns {void}
+     */
+    clearVisualCandles(): void;
+}
+/**
+ * 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 declare function isLinked(chartType: BarType): boolean;
+export type CandleSeriesColors = FullChartColors;
+export type PartialCandleSeriesColors = DeepPartial<CandleSeriesColors>;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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}}

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { Unit } from './scaling/viewport.model';
+import { PriceMovement } from './candle-series.model';
+export declare const BASIC_CANDLE_WIDTH: Unit;
+/**
+ * @doc-tags model
+ * @doc-tags-name Candle
+ */
+export interface Candle {
+    readonly hi: number;
+    readonly lo: number;
+    readonly open: number;
+    readonly close: number;
+    readonly timestamp: number;
+    volume: number;
+    readonly expansion?: boolean;
+    idx?: number;
+    readonly impVolatility?: number;
+    readonly vwap?: number;
+}
+/**
+ * Provides the name of candle difference
+ * @param {Number} open
+ * @param {Number} close
+ * @returns {String}
+ */
+export declare function nameDirection(open: number, close: number): PriceMovement;
+/**
+ * Provides the name of candle difference for hollow chart type
+ * @param {Number} open
+ * @param {Number} close
+ * @returns {String}
+ */
+export declare function hollowDirection(open: number, close: number): PriceMovement;
+/**
+ * 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 declare function copyCandle(base: Candle, idx: number, pricesAsClose?: boolean): Candle;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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}}

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

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { BarType, FullChartConfig } from '../chart.config';
+import EventBus from '../events/event-bus';
+import { PickedDOMRect } from '../inputhandlers/chart-resize.handler';
+import { DrawingManager } from '../drawers/drawing-manager';
+/**
+ * The minimum supported canvas size in chart-core (in pixels).
+ * Any size of <canvas> element below these dimensions will not be rendered (is NOT INTENDED to be rendered).
+ * @doc-tags chart-core,canvas
+ */
+export declare const MIN_SUPPORTED_CANVAS_SIZE: {
+    width: number;
+    height: number;
+};
+export declare class CanvasModel {
+    private eventBus;
+    canvas: HTMLCanvasElement;
+    drawingManager: DrawingManager;
+    private resizer?;
+    private readonly context;
+    parent: HTMLElement;
+    width: number;
+    height: number;
+    prevHeight: number;
+    prevWidth: number;
+    private readonly _canvasId;
+    type: CanvasBarType;
+    constructor(eventBus: EventBus, canvas: HTMLCanvasElement, drawingManager: DrawingManager, canvasModels: CanvasModel[], resizer?: HTMLElement | undefined, options?: CanvasRenderingContext2DSettings);
+    /**
+     * About rendering for non-integer dpi
+     * https://stackoverflow.com/questions/17553557/draw-crisp-lines-on-html5-canvas-with-browser-zoom
+     * @param bcr
+     */
+    updateDPR(bcr: PickedDOMRect | ClientRect): void;
+    get canvasId(): string;
+    get ctx(): CanvasRenderingContext2D;
+    /**
+     * Clears the canvas by using the clearRect method of the canvas context.
+     * @function
+     * @name clear
+     * @memberof Canvas
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Checks if the type is linked.
+     *
+     * @returns {boolean} Returns true if the type is linked, false otherwise.
+     */
+    isLinked(): boolean;
+    /**
+     * Triggers the 'fireDraw' event on the event bus with the canvas ID as the parameter.
+     */
+    fireDraw(): void;
+    /**
+     * Updates the width and height of the canvas element based on the client width and height of the canvas element and the height of the chart resizer element.
+     * @param {HTMLCanvasElement} canvas - The canvas element to update.
+     * @param {ClientRect | DOMRect} [bcr=this.getChartResizerElement().getBoundingClientRect()] - The bounding client rectangle of the chart resizer element.
+     * @returns {void}
+     */
+    private updateCanvasWidthHeight;
+    /**
+     * Returns the chart resizer element. If the resizer is not defined, it returns the parent element.
+     *
+     * @returns {HTMLElement} The chart resizer element.
+     */
+    getChartResizerElement(): HTMLElement;
+    /**
+     * Checks if the canvas is ready to be used by verifying if its width and height are greater than the minimum supported canvas size.
+     *
+     * @returns {boolean} - Returns true if the canvas is ready to be used, false otherwise.
+     */
+    isReady(): boolean;
+}
+export interface CanvasBarType {
+    name: string;
+    linked?: boolean;
+}
+/**
+ * Creates a new canvas model for the main chart canvas.
+ *
+ * @param {EventBus} eventBus - The event bus used to communicate between components.
+ * @param {HTMLCanvasElement} canvas - The canvas element to create the model for.
+ * @param {HTMLElement} resizer - The element used to resize the canvas.
+ * @param {BarType} barType - The type of bar to use for the chart.
+ * @param {FullChartConfig} config - The configuration object for the chart.
+ * @param {DrawingManager} drawingManager - The drawing manager used to draw on the canvas.
+ * @param {CanvasModel[]} canvasModels - An array of canvas models to add the new model to.
+ *
+ * @returns {CanvasModel} The newly created canvas model.
+ 
+export function createMainCanvasModel(
+    eventBus,
+    canvas,
+    resizer,
+    barType,
+    config,
+    drawingManager,
+    canvasModels,
+) {
+    const canvasModel = createCanvasModel(eventBus, canvas, config, drawingManager, canvasModels, resizer);
+    // @ts-ignore
+    canvasModel.type = TYPES[barType] ?? CANDLE_TYPE;
+    return canvasModel;
+}*/
+export declare function createMainCanvasModel(eventBus: EventBus, canvas: HTMLCanvasElement, resizer: HTMLElement, barType: BarType, config: FullChartConfig, drawingManager: DrawingManager, canvasModels: CanvasModel[]): CanvasModel;
+/**
+ * Creates a new CanvasModel instance.
+ *
+ * @param {EventBus} eventBus - The event bus to use.
+ * @param {HTMLCanvasElement} canvas - The canvas element to use.
+ * @param {FullChartConfig} config - The configuration object for the chart.
+ * @param {DrawingManager} drawingManager - The drawing manager to use.
+ * @param {CanvasModel[]} canvasModels - An array of existing canvas models.
+ * @param {HTMLElement} [resizer] - The element to use for resizing the canvas.
+ *
+ * @returns {CanvasModel} A new instance of the CanvasModel class.
+ */
+export declare function createCanvasModel(eventBus: EventBus, canvas: HTMLCanvasElement, config: FullChartConfig, drawingManager: DrawingManager, canvasModels: CanvasModel[], resizer?: HTMLElement, options?: CanvasRenderingContext2DSettings): CanvasModel;
+/**
+ * Initializes a canvas with a given configuration.
+ * @param {CanvasModel} canvasModel - The canvas model to be initialized.
+ * @param {FullChartConfig} config - The configuration object for the canvas.
+ * @returns {void}
+ 
+*/
+export declare function initCanvasWithConfig(canvasModel: CanvasModel, config: FullChartConfig): void;

package/dist/chart/model/canvas.model.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 MIN_SUPPORTED_CANVAS_SIZE={width:20,height:20};export class CanvasModel{constructor(t,e,i,n,r,a={}){var s;this.eventBus=t,this.canvas=e,this.drawingManager=i,this.resizer=r,this.width=0,this.height=0,this.prevHeight=0,this.prevWidth=0,this.type=l,n.push(this),this.parent=p(e);const d=e.getContext("2d",a);if(d===null)throw new Error("Couldn't get 2d context????");this.context=d,this._canvasId=(s=e.getAttribute("data-element"))!==null&&s!==void 0?s:"",this.updateCanvasWidthHeight(e,this.getChartResizerElement().getBoundingClientRect())}updateDPR(t){const{width:e,height:i}=t,n=window.devicePixelRatio;this.canvas.style.height=i+"px",this.canvas.style.width=e+"px",this.canvas.width=e*n,this.canvas.height=i*n,this.width=e,this.height=i,this.ctx.scale(n,n)}get canvasId(){return this._canvasId}get ctx(){return this.context}clear(){this.context.clearRect(0,0,this.width,this.height)}isLinked(){var t,e;return(e=(t=this.type)===null||t===void 0?void 0:t.linked)!==null&&e!==void 0?e:!1}fireDraw(){this.eventBus.fireDraw([this.canvasId])}updateCanvasWidthHeight(t,e=this.getChartResizerElement().getBoundingClientRect()){t.clientWidth!==this.width&&(t.width=t.clientWidth,this.width=t.clientWidth);const i=e.height;i!==this.height&&(t.style.height=i+"px",this.height=i,t.height=i,this.prevHeight=i)}getChartResizerElement(){var t;return(t=this.resizer)!==null&&t!==void 0?t:this.parent}isReady(){return this.width>MIN_SUPPORTED_CANVAS_SIZE.width&&this.height>MIN_SUPPORTED_CANVAS_SIZE.height}}const l={name:"candle"},o={name:"candle"},c={name:"line",linked:!0},g={name:"area",linked:!0},u={candle:l,bar:o,line:c,area:g};export function createMainCanvasModel(h,t,e,i,n,r,a){var s;const d=createCanvasModel(h,t,n,r,a,e);return d.type=(s=u[i])!==null&&s!==void 0?s:l,d}export function createCanvasModel(h,t,e,i,n,r,a){const s=new CanvasModel(h,t,i,n,r,a);return initCanvasWithConfig(s,e),s}export function initCanvasWithConfig(h,t){const e=h.canvas;t.fixedSize&&(e.width=t.fixedSize.width,e.height=t.fixedSize.height,e.style.width=t.fixedSize.width+"px",e.style.height=t.fixedSize.height+"px",h.width=t.fixedSize.width,h.height=t.fixedSize.height),e.style.position="absolute",e.style.top="0",e.style.left="0",e.style.direction="ltr"}function p(h){let t=h;for(;t;){if(t.nodeType===1&&t.hasAttribute("data-chart-container"))return t;if(t.parentElement!==null)t=t.parentElement;else break}return t}

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

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { Subscription } from 'rxjs/internal/Subscription';
+import { Unsubscriber } from '../utils/function.utils';
+export type ChartEntityState = 'initial' | 'active' | 'deactivated' | 'disabled';
+/**
+ * Chart entity has the following lifecycle: initial -> active <=> deactivated -> disposed.
+ * Methods of chart entity allows to transit entity between its states.
+ */
+export interface ChartEntity {
+    /** Make entity active. Next allowed stated: deactivated,disposed */
+    activate(): void;
+    /** Make entity inactive. Next allowed states: active,disposed. */
+    deactivate(): void;
+    /** Make entity disabled & inactive, cannot activate it */
+    disable(): void;
+    /** Make entity enabled & active */
+    enable(): void;
+    /** Get current state of chart entity */
+    getState(): ChartEntityState;
+}
+/**
+ * Base class for chart elements. Contains lifecycle support, utility methods.
+ *
+ * Chart entity state transition: INITIAL -> ACTIVE <-> DEACTIVATED -> DISPOSED
+ */
+export declare abstract class ChartBaseElement implements ChartEntity {
+    private subscriptions;
+    private _state;
+    private entities;
+    /**
+     * This method is used to activate a protected feature.
+     * It does not take any arguments and does not return anything.
+     */
+    protected doActivate(): void;
+    /**
+     * This method is used to unsubscribe from all events.
+     * It clears the subscriptions array.
+     * @returns {void}
+     */
+    protected doDeactivate(): void;
+    /**
+     * Enables the functionality of an object.
+     * If the object is not currently active, it sets the state to 'deactivated' and activates it.
+     * @returns {void}
+     */
+    enable(): void;
+    /**
+     * Disables the current object if it is not already disabled.
+     * If the object is not disabled, it will be deactivated and its state will be set to 'disabled'.
+     * @returns {void}
+     */
+    disable(): void;
+    /**
+     * Activates the entity and all its child entities.
+     * If the entity is already active, it does nothing.
+     * If the entity is disabled, it does nothing.
+     * @returns {void}
+     */
+    activate(): void;
+    /**
+     * Deactivates the entity and all its child entities.
+     * If the entity is already disabled, it does nothing.
+     * If the entity is not yet deactivated, it calls the doDeactivate method and sets the state to 'deactivated'.
+     * Finally, it deactivates all child entities.
+     * @returns {void}
+     */
+    deactivate(): void;
+    /**
+     * Returns the current state of the ChartEnitity instance.
+     * @returns {ChartEntityState} The current state of the ChartEnitity instance.
+     */
+    getState(): ChartEntityState;
+    /**
+     * Adds default subscription
+     * @param fn - an unsubscriber function
+     * @protected
+     */
+    addSubscription(fn: Unsubscriber): void;
+    /**
+     * Adds rxjs subscription
+     * @param subscription
+     * @protected
+     */
+    protected addRxSubscription(subscription?: Subscription): void;
+    /**
+     * Adds a new entity to the entities array and activates it if the parent entity is active.
+     *
+     * @param {Entity} entity - The entity to be added to the entities array.
+     * @returns {void}
+     */
+    addChildEntity(entity: ChartEntity): void;
+    /**
+     * Removes a entity from the entities array.
+     *
+     * @param {ChartEntity} entity - The entity to be removed.
+     * @returns {void}
+     */
+    removeChildEntity(entity: ChartEntity): void;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export class ChartBaseElement{constructor(){this.subscriptions=[],this._state="initial",this.entities=[]}doActivate(){}doDeactivate(){this.subscriptions.forEach(t=>t()),this.subscriptions=[]}enable(){this._state!=="active"&&(this._state="deactivated",this.activate())}disable(){this._state!=="disabled"&&(this.deactivate(),this._state="disabled")}activate(){this._state!=="disabled"&&(this._state!=="active"&&(this.doActivate(),this._state="active"),this.entities.forEach(t=>t.activate()))}deactivate(){this._state!=="disabled"&&(this._state!=="deactivated"&&(this.doDeactivate(),this._state="deactivated"),this.entities.forEach(t=>t.deactivate()))}getState(){return this._state}addSubscription(t){this.subscriptions.push(t)}addRxSubscription(t){t&&this.subscriptions.push(t.unsubscribe.bind(t))}addChildEntity(t){this.entities.push(t),this._state==="active"&&t.activate()}removeChildEntity(t){this.entities=this.entities.filter(i=>i!==t)}}

package/dist/chart/model/compare-series-hover.d.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { ChartModel } from '../components/chart/chart.model';
+import { BaseHover, HoverProducerPart } from '../inputhandlers/hover-producer.component';
+export interface CompareSeriesHover {
+    instrument: string;
+    price: string;
+    id: number;
+}
+export declare class CompareSeriesHoverProducerPart implements HoverProducerPart<CompareSeriesHover[]> {
+    private chartModel;
+    constructor(chartModel: ChartModel);
+    /**
+     * Returns an array of objects containing information about the series of candles at a specific x-coordinate.
+     * @param {BaseHover} hover - The hover object containing the x-coordinate.
+     * @returns {CompareSeriesHover[]} An array of objects containing the instrument symbol, price and id of each series of candles.
+     */
+    getData(hover: BaseHover): CompareSeriesHover[];
+}

package/dist/chart/model/compare-series-hover.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export class CompareSeriesHoverProducerPart{constructor(e){this.chartModel=e}getData(e){const{x:t}=e,c=this.chartModel.candleFromX(t).idx||0;return this.chartModel.candleSeries.map(r=>{const o=r.dataPoints[c],a=this.chartModel.pane.regularFormatter(o==null?void 0:o.close);return{instrument:r.instrument.symbol,price:a,id:r.id}})}}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { PriceAxisType } from '../components/labels_generator/numeric-axis-labels.generator';
+import { DataSeriesModel } from './data-series.model';
+import { ScaleModel } from './scale.model';
+import { Index, Pixel, Price, Unit, Viewable } from './scaling/viewport.model';
+/**
+ * A class representing a view for a data series chart.
+ * It contains methods to convert between price values and pixel coordinates using the selected scale model,
+ * as well as between price values and units based on the selected price type and axis type.
+ */
+export declare class DataSeriesView implements Viewable {
+    private dataSeries;
+    private scaleModel;
+    private getAxisType;
+    private getBaseLine;
+    private percentAnimationHandler;
+    constructor(dataSeries: DataSeriesModel, scaleModel: ScaleModel, getAxisType: () => PriceAxisType, getBaseLine: (idx?: Index) => Unit);
+    /**
+     * Convert the input value to its corresponding y-pixel coordinate based on the selected price type and scale model.
+     * @param value - The value to be converted to y-pixel coordinate.
+     * @returns - The converted value in y-pixel coordinate.
+     */
+    toY: (value: Price) => Pixel;
+    /**
+     * Convert the input value to the corresponding unit based on the current axis type.
+     * @param value - The value to be converted to unit.
+     * @param getBaseLine - A function that returns the baseline for percent.
+     * @returns - The converted value in the corresponding unit.
+     */
+    toAxisUnits(value: Price, getBaseLine?: (idx?: number | undefined) => number): Unit;
+    /**
+     * Convert the input unit to its corresponding x-pixel coordinate based on the scale model.
+     * @param unit - The unit to be converted to x-pixel coordinate.
+     * @returns - The converted value in x-pixel coordinate.
+     */
+    toX: (unit: Unit) => Pixel;
+    xPixels: (unit: Unit) => Pixel;
+    /**
+     * Pay attention! This method doesn't convert price to pixels, it converts only current axis UNITs!
+     * @param unit
+     */
+    yPixels: (unit: Unit) => Pixel;
+    /**
+     * Converts "y" in pixels to price
+     * @param y - source value in pixels
+     */
+    priceFromY(y: Pixel): Price;
+    /**
+     * Convert the input unit to its corresponding price value based on the selected axis type.
+     * @param {number} unit - The unit to be converted to price value.
+     * @returns {number} - The converted value in price.
+     */
+    fromAxisUnits(unit: Unit): Price;
+}

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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{binarySearch as a}from"../utils/array.utils";import{calcLogValue as o,logValueToUnit as l,percentToUnit as c,unitToPercent as h}from"./scaling/viewport.model";class d{constructor(e,i){this.scaleModel=e,this.dataSeries=i,this.prevAnimationId=""}getBaselineForPercent(e){const i=this.scaleModel.currentAnimation;let s;if(i!=null&&i.animationInProgress){i.id!==this.prevAnimationId&&(this.initialBaseline=void 0,this.targetBaseline=void 0,this.prevAnimationId=i.id);const n=i.easingFn(i.getProgress());this.initialBaseline===void 0&&(this.initialBaseline=e(a(this.dataSeries.visualPoints,i.xStart,t=>t.centerUnit).index)),this.targetBaseline===void 0&&(this.targetBaseline=e(a(this.dataSeries.visualPoints,i.animationConfig.targetXStart,t=>t.centerUnit).index)),s=this.initialBaseline+(this.targetBaseline-this.initialBaseline)*n}else s=e();return s}}export class DataSeriesView{constructor(e,i,s,n){this.dataSeries=e,this.scaleModel=i,this.getAxisType=s,this.getBaseLine=n,this.toY=t=>this.scaleModel.toY(this.toAxisUnits(t)),this.toX=t=>this.scaleModel.toX(t),this.xPixels=t=>this.scaleModel.xPixels(t),this.yPixels=t=>this.scaleModel.yPixels(t),this.percentAnimationHandler=new d(this.scaleModel,this.dataSeries)}toAxisUnits(e,i=this.getBaseLine){switch(this.getAxisType()){case"percent":const s=this.percentAnimationHandler.getBaselineForPercent(i);return h(e,s);case"logarithmic":return o(e);case"regular":return e}}priceFromY(e){const i=this.scaleModel.fromY(e);return this.fromAxisUnits(i)}fromAxisUnits(e){switch(this.getAxisType()){case"percent":return c(e,this.getBaseLine());case"logarithmic":return l(e);case"regular":return e}}}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 { BarTypes, YAxisLabelAppearanceType, YAxisLabelMode } from '../chart.config';
+export type DataSeriesType = 'POINTS' | 'LINEAR' | 'HISTOGRAM' | 'TREND_HISTOGRAM' | 'DIFFERENCE' | 'TEXT' | 'ABOVE_CANDLE_TEXT' | 'BELOW_CANDLE_TEXT' | 'ABOVE_CANDLE_TRIANGLE' | 'TRIANGLE' | 'COLOR_CANDLE' | 'RECTANGULAR' | keyof BarTypes | string;
+export interface DataSeriesConfig {
+    paintConfig: Array<DataSeriesPaintConfig>;
+    visible: boolean;
+    highLowActive: boolean;
+    type: DataSeriesType;
+    /**
+     * 'viewport' data-series label will show last visible on the screen series value.
+     * 'series'  data-series label will show last overall series value (even if not visible).
+     */
+    labelLastValue: 'series' | 'viewport';
+    labelMode: YAxisLabelMode;
+    labelAppearanceType: YAxisLabelAppearanceType;
+    labelPaddingBottom?: number;
+    labelPaddingTop?: number;
+    labelPaddingEnd?: number;
+}
+export interface DataSeriesPaintConfig {
+    color: string;
+    lineWidth: number;
+    hoveredLineWidth: number;
+    aditionalColor?: string;
+}
+export declare const DEFAULT_DATA_SERIES_PAINT_CONFIG: DataSeriesPaintConfig;
+export declare const DEFAULT_DATA_SERIES_CONFIG: DataSeriesConfig;

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

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2002 - 2023 Devexperts LLC
+ * 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 DEFAULT_DATA_SERIES_PAINT_CONFIG={color:"#FF00FF",lineWidth:1,hoveredLineWidth:2},DEFAULT_DATA_SERIES_CONFIG={paintConfig:[DEFAULT_DATA_SERIES_PAINT_CONFIG],type:"LINEAR",highLowActive:!0,visible:!0,labelLastValue:"viewport",labelMode:"label",labelAppearanceType:"badge"};