@devexperts/dxcharts-lite 1.0.1

package/dist/chart/drawers/data-series.drawer.d.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 { PaneManager } from '../components/pane/pane-manager.component';
+import { Bounds } from '../model/bounds.model';
+import { DataSeriesModel, VisualSeriesPoint } from '../model/data-series.model';
+import { CanvasModel } from '../model/canvas.model';
+import { Drawer } from './drawing-manager';
+export interface ChartDrawerConfig {
+    singleColor?: string;
+    forceBold?: number;
+}
+export interface SeriesDrawer {
+    draw: (ctx: CanvasRenderingContext2D, 
+    /**
+     * You can pass two-dimension array to divide series into multiple parts
+     */
+    points: VisualSeriesPoint[][], model: DataSeriesModel, drawerConfig: ChartDrawerConfig) => void;
+}
+export declare const transformToTwoDimension: (points: VisualSeriesPoint[] | VisualSeriesPoint[][]) => VisualSeriesPoint[][];
+/**
+ * Basic data series drawer.
+ * Have multiple paint tools: linear, histogram, points, text above/below candle and others.
+ *
+ * (may support multiple layers in future)
+ */
+export declare class DataSeriesDrawer implements Drawer {
+    private paneManager;
+    private canvasModel;
+    private readonly seriesDrawers;
+    constructor(paneManager: PaneManager, canvasModel: CanvasModel, seriesDrawers: Record<string, SeriesDrawer>);
+    draw(): void;
+    drawSeries(ctx: CanvasRenderingContext2D, series: DataSeriesModel): void;
+    getCanvasIds(): Array<string>;
+}
+export declare const clipToBounds: (ctx: CanvasRenderingContext2D, bounds: Bounds) => void;
+export declare const setLineWidth: (ctx: CanvasRenderingContext2D, lineWidth: number, dataSeries: DataSeriesModel, drawerConfig: ChartDrawerConfig, seriesSelectedWidth?: number) => void;

package/dist/chart/drawers/data-series.drawer.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{flatMap as i}from"../utils/array.utils";export const transformToTwoDimension=r=>Array.isArray(r[0])?r:[r];export class DataSeriesDrawer{constructor(e,t,a){this.paneManager=e,this.canvasModel=t,this.seriesDrawers=a}draw(){const e=this.canvasModel.ctx;i(Object.values(this.paneManager.paneComponents),t=>t.yExtentComponents).forEach(t=>{e.save(),clipToBounds(e,t.getBounds()),t.dataSeries.forEach(a=>this.drawSeries(e,a)),e.restore()})}drawSeries(e,t){if(t.config.visible){const a=t.config.type,s=this.seriesDrawers[a];if(s){const o=t.getSeriesInViewport(t.scaleModel.xStart-1,t.scaleModel.xEnd+1);o&&o.length>=1&&s.draw(e,o,t,{})}else console.error(`Data series drawer with type ${a} isn't registered!`)}}getCanvasIds(){return[this.canvasModel.canvasId]}}export const clipToBounds=(r,e)=>{r.beginPath(),r.rect(e.x,e.y,e.width,e.height),r.clip(),r.closePath()},setLineWidth=(r,e,t,a,s=e)=>{a.forceBold?r.lineWidth=a.forceBold:t.hovered?r.lineWidth=s:r.lineWidth=e};

package/dist/chart/drawers/drawing-manager.d.ts

@@ -0,0 +1,61 @@
+/*
+ * 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 EventBus from '../events/event-bus';
+import { ChartResizeHandler } from '../inputhandlers/chart-resize.handler';
+export declare const HIT_TEST_PREFIX = "HIT_TEST_";
+declare const drawerTypes: readonly ["MAIN_BACKGROUND", "MAIN_CLEAR", "HIT_TEST_CLEAR", "YAXIS_CLEAR", "SERIES_CLEAR", "OVER_SERIES_CLEAR", "HIT_TEST_DRAWINGS", "GRID", "VOLUMES", "UNDERLAY_VOLUMES_AREA", "X_AXIS", "Y_AXIS", "HIGH_LOW", "DRAWINGS", "DATA_SERIES", "N_MAP_CHART", "PL_CHART", "WATERMARK", "EMPTY_CHART", "OFFLINE_CHART", "LABELS", "EVENTS", "HIT_TEST_EVENTS", "ZERO_LINE", "PL_ZERO_LINE_BACKGROUND", "CROSS_TOOL"];
+export type DrawerType = typeof drawerTypes[number];
+/**
+ * Manages the drawing process.
+ * Can re-order drawers to make one be on top of the other.
+ */
+export declare class DrawingManager {
+    private chartResizeHandler;
+    private drawingOrder;
+    private drawersMap;
+    private readonly drawHitTestCanvas;
+    private canvasIdsList;
+    private animFrameId;
+    constructor(eventBus: EventBus, chartResizeHandler: ChartResizeHandler);
+    /**
+     * Updates canvases' sizes and executes redraw without animation frame.
+     * This is required for multi-chart canvas update synchronization.
+     * If all canvases update in separate animation frames - we see visual lag. Instead we should do all updates and then redraw.
+     * @doc-tags tricky,canvas,resize
+     */
+    redrawCanvasesImmediate(): void;
+    drawLastBar(): void;
+    forceDraw(canvasIds?: Array<string>): void;
+    /**
+     * Indicates whether it is possible to draw chart or not.
+     * @returns {boolean} true if chart is drawable
+     */
+    isDrawable(): boolean;
+    drawHitTestOnly(): void;
+    addDrawer(drawer: Drawer, name?: string): void;
+    addDrawerAfter(drawer: Drawer, newDrawerName: string, drawerToPutAfterName: string): void;
+    addDrawerBefore(drawer: Drawer, newDrawerName: string, drawerToPutBeforeName: string): boolean;
+    getDrawerByName(name: string): Drawer;
+    getNameByDrawer(drawer: Drawer): string | undefined;
+    removeDrawerByName(name: string): void;
+    removeDrawer(drawer: Drawer): void;
+    reorderDrawers(newOrder: string[]): void;
+}
+export interface Drawer {
+    draw(): void;
+    /**
+     * Used for optimization when we have to update only the last candle
+     * Doesn't work for line chart types
+     * TODO rework, method should not be a part of abstract drawer, maybe Candle drawer or something like this
+     * @doc-tags tricky
+     */
+    drawLastBar?: () => void;
+    getCanvasIds(): Array<string>;
+}
+export declare class DynamicDrawerType {
+    static paneResizer(id: string): string;
+}
+export {};

package/dist/chart/drawers/drawing-manager.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{EVENT_DRAW as h}from"../events/events";import{MIN_SUPPORTED_CANVAS_SIZE as t}from"../model/canvas.model";import{arrayIntersect as w,reorderArray as o}from"../utils/array.utils";import{animationFrameThrottled as E}from"../utils/perfomance/request-animation-frame-throttle.utils";import{uuid as d}from"../utils/uuid.utils";export const HIT_TEST_PREFIX="HIT_TEST_";const I=["MAIN_BACKGROUND","MAIN_CLEAR","HIT_TEST_CLEAR","YAXIS_CLEAR","SERIES_CLEAR","OVER_SERIES_CLEAR","HIT_TEST_DRAWINGS","GRID","VOLUMES","UNDERLAY_VOLUMES_AREA","X_AXIS","Y_AXIS","HIGH_LOW","DRAWINGS","DATA_SERIES","N_MAP_CHART","PL_CHART","WATERMARK","EMPTY_CHART","OFFLINE_CHART","LABELS","EVENTS","HIT_TEST_EVENTS","ZERO_LINE","PL_ZERO_LINE_BACKGROUND","CROSS_TOOL"];export class DrawingManager{constructor(i,r){this.chartResizeHandler=r,this.drawingOrder=[],this.drawersMap={},this.canvasIdsList=[],this.animFrameId=`draw_${d()}`,this.drawHitTestCanvas=()=>{this.drawingOrder.forEach(e=>{e.indexOf(HIT_TEST_PREFIX)!==-1&&this.drawersMap[e].draw()})},i.on(h,e=>{r.wasResized()&&(this.canvasIdsList&&(e&&e.length!==0?this.canvasIdsList=this.canvasIdsList.concat(e):this.canvasIdsList=void 0),E(this.animFrameId,()=>{this.forceDraw(this.canvasIdsList),this.canvasIdsList=[],this.drawHitTestCanvas()}))})}redrawCanvasesImmediate(){this.chartResizeHandler.fireUpdates(),this.forceDraw()}drawLastBar(){this.drawingOrder.forEach(i=>{if(i.indexOf(HIT_TEST_PREFIX)===-1){const r=this.drawersMap[i];r.drawLastBar&&r.drawLastBar()}})}forceDraw(i){this.isDrawable()&&this.drawingOrder.forEach(r=>{if(r.indexOf(HIT_TEST_PREFIX)===-1){const e=this.drawersMap[r];if(!i||i.length===0){e.draw();return}w(i,e.getCanvasIds()).length&&e.draw()}})}isDrawable(){var i,r,e,s;return((r=(i=this.chartResizeHandler.previousBCR)===null||i===void 0?void 0:i.height)!==null&&r!==void 0?r:0)>t.width&&((s=(e=this.chartResizeHandler.previousBCR)===null||e===void 0?void 0:e.width)!==null&&s!==void 0?s:0)>t.height}drawHitTestOnly(){this.drawHitTestCanvas()}addDrawer(i,r=d()){this.drawingOrder.indexOf(r)===-1&&this.drawingOrder.push(r),this.drawersMap[r]=i}addDrawerAfter(i,r,e){this.addDrawer(i,r);const s=this.drawingOrder.indexOf(r);this.drawingOrder.splice(s,1);const a=this.drawingOrder.indexOf(e);this.drawingOrder.splice(a+1,0,r),this.reorderDrawers(this.drawingOrder)}addDrawerBefore(i,r,e){this.addDrawer(i,r);const s=this.drawingOrder.indexOf(e);if(s!==-1){const a=this.drawingOrder.indexOf(r);return this.drawingOrder.splice(a,1),this.drawingOrder.splice(s,0,r),this.reorderDrawers(this.drawingOrder),!0}return!1}getDrawerByName(i){return this.drawersMap[i]}getNameByDrawer(i){for(const r in this.drawersMap)if(this.drawersMap[r]===i)return r}removeDrawerByName(i){const r=this.drawersMap[i];this.removeDrawer(r)}removeDrawer(i){Object.keys(this.drawersMap).forEach(r=>{if(this.drawersMap[r]===i){delete this.drawersMap[r];const e=this.drawingOrder.indexOf(r);e!==-1&&this.drawingOrder.splice(e,1)}})}reorderDrawers(i){this.drawingOrder=o(this.drawingOrder,i)}}export class DynamicDrawerType{static paneResizer(i){return`PANE_RESIZER_${i}`}}

package/dist/chart/drawers/ht-data-series.drawer.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 { PaneManager } from '../components/pane/pane-manager.component';
+import { DataSeriesModel } from '../model/data-series.model';
+import { HitTestCanvasModel } from '../model/hit-test-canvas.model';
+import { SeriesDrawer } from './data-series.drawer';
+import { Drawer } from './drawing-manager';
+/***
+ * HitTest Chart drawer. It's used to draw hit test for chart types on the hit-test canvas.
+ */
+export declare class HTDataSeriesDrawer implements Drawer {
+    private readonly seriesDrawers;
+    private canvasModel;
+    private paneManager;
+    constructor(seriesDrawers: Record<string, SeriesDrawer>, canvasModel: HitTestCanvasModel, paneManager: PaneManager);
+    draw(): void;
+    drawSeries(ctx: CanvasRenderingContext2D, series: DataSeriesModel): void;
+    getCanvasIds(): Array<string>;
+}

package/dist/chart/drawers/ht-data-series.drawer.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{flatMap as s}from"../utils/array.utils";import{clipToBounds as n}from"./data-series.drawer";export class HTDataSeriesDrawer{constructor(o,a,t){this.seriesDrawers=o,this.canvasModel=a,this.paneManager=t}draw(){const o=this.canvasModel.ctx;s(Object.values(this.paneManager.paneComponents),a=>a.yExtentComponents).forEach(a=>{o.save(),n(o,a.getBounds()),a.dataSeries.forEach(t=>this.drawSeries(o,t)),o.restore()})}drawSeries(o,a){if(a.config.visible){const t=a.config.type,e=this.seriesDrawers[t];if(e){const r={singleColor:this.canvasModel.idToColor(a.id),forceBold:7};e.draw(o,a.getSeriesInViewport(a.scaleModel.xStart-1,a.scaleModel.xEnd+1),a,r)}}}getCanvasIds(){return[this.canvasModel.canvasId]}}

package/dist/chart/events/event-bus.d.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 } from 'rxjs';
+import { EVENT_DRAW, EVENT_RESIZED } from './events';
+export interface EventBusFireAsync {
+    (type: typeof EVENT_RESIZED, event?: ClientRect | DOMRect): number | void;
+    (type: string, event?: string): number | void;
+    (type: string, event?: string): number | void;
+}
+export interface EventBusFire {
+    (type: typeof EVENT_RESIZED, event?: ClientRect | DOMRect): number | void;
+    (type: string, ...args: unknown[]): void;
+}
+export interface EventBusOn {
+    (type: typeof EVENT_RESIZED, fn: (bcr?: DOMRect) => void): () => void;
+    (type: typeof EVENT_DRAW, fn: (canvasIds: Array<string>) => void): () => void;
+    (type: string, fn: (...args: unknown[]) => void): () => void;
+}
+/**
+ * Event bus for chart.
+ * @doc-tags core-components
+ */
+export default class EventBus {
+    private UNKNOWN_ARR;
+    /** Registered event handlers. */
+    private handlers;
+    /** State which can enable / disable events processing. */
+    private muted;
+    constructor();
+    /**
+     * Triggers the draw event for the specified canvas IDs.
+     * @param {Array<string>} canvasIds - An optional array of canvas IDs to trigger the draw event for.
+     */
+    fireDraw(canvasIds?: Array<string>): void;
+    unsub: (type: string, fn: (...args: any[]) => void) => void;
+    add: (method: (...args: unknown[]) => void, type: string, fn: (...args: any[]) => void) => () => void;
+    on: EventBusOn;
+    observe: (type: string) => Observable<any>;
+    onPrior: (type: string, fn: (...args: any[]) => void) => () => void;
+    off: (type: string, fn: (...args: any[]) => void) => void;
+    fire: EventBusFire;
+    fireAsync: EventBusFireAsync;
+    setMuted: (val: boolean) => void;
+    clear: () => void;
+}

package/dist/chart/events/event-bus.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 h}from"rxjs";import{arrayRemove as r}from"../utils/array.utils";import{EVENT_DRAW as u}from"./events";export default class d{constructor(){this.UNKNOWN_ARR=[],this.handlers={},this.muted=!1,this.unsub=(t,s)=>{const i=this.handlers[t];i!==void 0&&r.call(i,s)},this.add=(t,s,i)=>(s in this.handlers?t.call(this.handlers[s],i):this.handlers[s]=[i],this.unsub.bind(this,s,i)),this.on=(t,s)=>this.add(this.UNKNOWN_ARR.push,t,s),this.observe=t=>{const s=new h,i=s.next.bind(s),n=s.unsubscribe.bind(s);return this.on(t,i),s.unsubscribe=()=>{this.unsub(t,i),n()},s.asObservable()},this.onPrior=(t,s)=>this.add(this.UNKNOWN_ARR.unshift,t,s),this.off=this.unsub,this.fire=(t,...s)=>{var i;if(!this.muted){const n=(i=this.handlers[t])!==null&&i!==void 0?i:[];let e;for(e=0,n.length;e<n.length;e++)n[e].apply(null,s)}},this.fireAsync=(t,s)=>{if(!this.muted)return window.setTimeout(this.fire.bind(this,t,s),0)},this.setMuted=t=>{this.muted=t},this.clear=()=>{this.handlers={}}}fireDraw(t){this.fire(u,t)}}

package/dist/chart/events/events.d.ts

@@ -0,0 +1,8 @@
+/*
+ * 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 declare const EVENT_RESIZED: "resized_local";
+export declare const EVENT_DRAW: "draw";
+export declare const EVENT_DRAW_LAST_CANDLE: "draw_last_candle";

package/dist/chart/events/events.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 EVENT_RESIZED="resized_local",EVENT_DRAW="draw",EVENT_DRAW_LAST_CANDLE="draw_last_candle";

package/dist/chart/inputhandlers/candle-tap.handler.d.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 { CanvasInputListenerComponent } from '../inputlisteners/canvas-input-listener.component';
+import { ChartBaseElement } from '../model/chart-base-element';
+import { FullChartConfig } from '../chart.config';
+export declare class CandleTapHandler extends ChartBaseElement {
+    constructor(mainCanvasParent: Element, chartModel: ChartModel, canvasInputListeners: CanvasInputListenerComponent, config: FullChartConfig);
+    /**
+     * Sets the candle as active when a touch event occurs on the chart.
+     * @param {TouchEvent} e - The touch event that occurred on the chart.
+     * @param {Element} mainCanvasParent - The parent element of the main canvas.
+     * @param {ChartModel} chartModel - The chart model object.
+     */
+    private setCandleAsActive;
+    /**
+     * Calculates the X position of a touch event relative to the main canvas parent element.
+     * @param {Touch} touch - The touch event object.
+     * @param {Element} mainCanvasParent - The parent element of the main canvas.
+     * @returns {number} - The X position of the touch event relative to the main canvas parent element.
+     * @todo Check if this body calculations can potentially work incorrectly in the widget.
+     */
+    private getTouchXPosition;
+}

package/dist/chart/inputhandlers/candle-tap.handler.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{ChartBaseElement as i}from"../model/chart-base-element";import{map as l,distinctUntilChanged as r}from"rxjs/operators";export class CandleTapHandler extends i{constructor(t,c,e,n){super(),e.observeTouchStart().pipe(l(o=>n.components.chart.highlightActiveCandle?o:void 0),r()).subscribe(o=>{o&&this.setCandleAsActive(o,t,c)})}setCandleAsActive(t,c,e){if(t.touches.length===1){const n=t.touches.item(0);if(n!==null){const o=this.getTouchXPosition(n,c),s=e.candleFromX(o);s&&e.mainCandleSeries.setActiveCandle(s)}}}getTouchXPosition(t,c){const e=c.getBoundingClientRect(),n=document.body.scrollLeft||document.documentElement.scrollLeft;return t.pageX-e.left-n}}

package/dist/chart/inputhandlers/chart-resize.handler.d.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 } from 'rxjs';
+import { FullChartConfig } from '../chart.config';
+import { CanvasModel } from '../model/canvas.model';
+import EventBus from '../events/event-bus';
+export type PickedDOMRect = Pick<DOMRect, 'x' | 'y' | 'width' | 'height'>;
+/**
+ * Tracks chart element size and emits events whenever it changes.
+ */
+export declare class ChartResizeHandler {
+    private frameElement;
+    private resizerElement;
+    private bus;
+    private canvasModels;
+    private config?;
+    private elementResizeDetector;
+    previousBCR: PickedDOMRect | undefined;
+    private animFrameId;
+    canvasResized: Subject<PickedDOMRect>;
+    constructor(frameElement: HTMLElement, resizerElement: HTMLElement, bus: EventBus, canvasModels: CanvasModel[], config?: FullChartConfig | undefined);
+    /**
+     * Subscribe to resize events
+     * Use it to update chart animations.
+     * TODO activate / deactivate cycle
+     */
+    subscribeResize(): void;
+    /**
+     * Handles the resize event by throttling the animation frame and firing updates.
+     * @private
+     * @function
+     * @returns {void}
+     */
+    private handleResize;
+    /**
+     * Updates the canvas models and fires events if the bounding client rectangle of the resizer element has changed.
+     * @function
+     * @name fireUpdates
+     * @memberof ClassName
+     * @returns {void}
+     */
+    fireUpdates(): void;
+    /**
+     * Checks if the dimensions of two PickedDOMRect objects are different.
+     * @param {PickedDOMRect} previousBCR - The previous bounding client rectangle.
+     * @param {PickedDOMRect} newBCR - The new bounding client rectangle.
+     * @returns {boolean} - Returns true if the dimensions are different, false otherwise.
+     */
+    private isBCRDimensionsDiffer;
+    /**
+     * Unsubscribes from the element resize detector to stop updating the chart animation.
+     * @function
+     * @name unsubscribeAnimationUpdate
+     * @memberof ChartResizeHandler
+     * @instance
+     * @returns {void}
+     */
+    unsubscribeAnimationUpdate(): void;
+    /**
+     * Checks if the canvas has been resized by comparing the previous bounding client rect with the current one.
+     * @returns {boolean} - Returns true if the canvas has been resized, false otherwise.
+     */
+    wasResized(): boolean;
+}

package/dist/chart/inputhandlers/chart-resize.handler.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 n}from"rxjs";import{EVENT_DRAW as h,EVENT_RESIZED as o}from"../events/events";import{uuid as a}from"../utils/uuid.utils";import{animationFrameThrottledPrior as m}from"../utils/perfomance/request-animation-frame-throttle.utils";export class ChartResizeHandler{constructor(e,i,s,t,r){this.frameElement=e,this.resizerElement=i,this.bus=s,this.canvasModels=t,this.config=r,this.previousBCR=void 0,this.animFrameId=`resize_${a()}`,this.canvasResized=new n,this.elementResizeDetector=new ResizeObserver(()=>this.handleResize())}subscribeResize(){this.elementResizeDetector.observe(this.resizerElement)}handleResize(){m(this.animFrameId,()=>this.fireUpdates())}fireUpdates(){const e=this.resizerElement.getBoundingClientRect(),i={x:e.x,y:e.y,width:e.width,height:e.height};this.config||(this.frameElement.style.height=this.resizerElement.clientHeight+"px"),(this.previousBCR===void 0||this.isBCRDimensionsDiffer(this.previousBCR,i))&&(this.previousBCR=i,this.canvasModels.forEach(s=>this.previousBCR&&s.updateDPR(this.previousBCR)),this.canvasResized.next(i),this.bus.fire(o,i),this.bus.fire(h))}isBCRDimensionsDiffer(e,i){return e.height!==i.height||e.width!==i.width}unsubscribeAnimationUpdate(){if(this.resizerElement)try{this.elementResizeDetector.unobserve(this.resizerElement)}catch(e){console.warn("ChartResizeHandler.ts, unsubscribeAnimationUpdate failed")}}wasResized(){return this.previousBCR!==void 0}}

package/dist/chart/inputhandlers/cross-event-producer.component.d.ts

@@ -0,0 +1,44 @@
+/*
+ * 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 { BehaviorSubject, Subscription } from 'rxjs';
+import { CanvasBoundsContainer, HitBoundsTest, HitBoundsTestOptionsPartial } from '../canvas/canvas-bounds-container';
+import { CanvasInputListenerComponent } from '../inputlisteners/canvas-input-listener.component';
+import { ChartBaseElement } from '../model/chart-base-element';
+import { Unsubscriber } from '../utils/function.utils';
+export type CrossEvent = [number, number, string];
+export declare class CrossEventProducerComponent extends ChartBaseElement {
+    private canvasInputListener;
+    private canvasBoundsContainer;
+    panesSubscriptions: Partial<Record<string, Subscription>>;
+    crossSubject: BehaviorSubject<CrossEvent | null>;
+    constructor(canvasInputListener: CanvasInputListenerComponent, canvasBoundsContainer: CanvasBoundsContainer);
+    protected doActivate(): void;
+    /**
+     * Emits a null value to the `cross` subject, effectively closing the current cross.
+     */
+    fireCrossClose(): void;
+    /**
+     * Unsubscribes from the mouse over event for a specific pane.
+     * @param {string} uuid - The unique identifier of the pane.
+     * @returns {void}
+     */
+    unsubscribeMouseOver(uuid: string): void;
+    /**
+     * Subscribes to mouse over event on canvas elements.
+     * @param {string} uuid - Unique identifier for the subscription.
+     * @param {string[]} canvasElementNames - Array of canvas element names to subscribe to.
+     * @param {HitBoundsTestOptionsPartial} [options] - Optional hit bounds test options.
+     * @returns {Subscription} - Returns a subscription object.
+     */
+    subscribeMouseOver(uuid: string, canvasElementNames: string[], options?: HitBoundsTestOptionsPartial): Unsubscriber;
+    /**
+     * Subscribes to mouse over event on a hit test area identified by uuid.
+     * @param {string} uuid - The unique identifier of the hit test area.
+     * @param {HitBoundsTest} hitTest - The hit test area.
+     * @returns {Subscription} - The subscription object.
+     */
+    subscribeMouseOverHT(uuid: string, hitTest: HitBoundsTest): Unsubscriber;
+}

package/dist/chart/inputhandlers/cross-event-producer.component.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{BehaviorSubject as a,combineLatest as b,filter as v}from"rxjs";import{ChartBaseElement as p}from"../model/chart-base-element";export class CrossEventProducerComponent extends p{constructor(e,s){super(),this.canvasInputListener=e,this.canvasBoundsContainer=s,this.panesSubscriptions={},this.crossSubject=new a(null)}doActivate(){super.doActivate()}fireCrossClose(){this.crossSubject.next(null)}unsubscribeMouseOver(e){var s;(s=this.panesSubscriptions[e])===null||s===void 0||s.unsubscribe()}subscribeMouseOver(e,s,o){const i=s.map(r=>this.canvasBoundsContainer.getBoundsHitTest(r,o)),t=(r,n)=>i.some(u=>u(r,n));return this.subscribeMouseOverHT(e,t)}subscribeMouseOverHT(e,s){const o=this.canvasInputListener.observeMouseMoveDocument(),i=this.canvasInputListener.observeMouseEnter(s);let t=!1;const r=b([o,i]).pipe(v(([,n])=>!t||t&&n)).subscribe(([n,u])=>{if(u){const c=[n.x,n.y,e];this.crossSubject.next(c),t=!1}else this.crossSubject.next(null),t=!0});return this.panesSubscriptions[e]=r,()=>r.unsubscribe()}}

package/dist/chart/inputhandlers/hover-producer.component.d.ts

@@ -0,0 +1,140 @@
+/*
+ * 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 { BehaviorSubject } from 'rxjs';
+import { CanvasBoundsContainer } from '../canvas/canvas-bounds-container';
+import { FullChartConfig } from '../chart.config';
+import { ChartModel } from '../components/chart/chart.model';
+import { PaneManager } from '../components/pane/pane-manager.component';
+import { CanvasInputListenerComponent } from '../inputlisteners/canvas-input-listener.component';
+import { CandleHover, CandleHoverProducerPart } from '../model/candle-hover';
+import { ChartBaseElement } from '../model/chart-base-element';
+import { CompareSeriesHover, CompareSeriesHoverProducerPart } from '../model/compare-series-hover';
+import { DateTimeFormatter } from '../model/date-time.formatter';
+import { ScaleModel } from '../model/scale.model';
+import VisualCandle from '../model/visual-candle';
+import { CrossEvent, CrossEventProducerComponent } from './cross-event-producer.component';
+import { TimeZoneModel } from '../model/time-zone.model';
+export interface BaseHover {
+    readonly x: number;
+    readonly y: number;
+    readonly timestamp: number;
+    readonly timeFormatted: string;
+    readonly paneId: string;
+}
+export interface HoverParts {
+    readonly candleHover: CandleHover | undefined;
+    readonly compareSeriesHover: CompareSeriesHover[];
+    [key: string]: unknown;
+}
+export interface Hover extends BaseHover, HoverParts {
+}
+export interface HoverProducerPart<T = unknown> {
+    getData(hover: BaseHover): T;
+}
+export interface HoverProducerParts {
+    candleHover: CandleHoverProducerPart;
+    compareSeriesHover: CompareSeriesHoverProducerPart;
+    [key: string]: HoverProducerPart;
+}
+/**
+ * Produces the Hover event.
+ * Hover is used for displaying values in legend and NOT related to displaying cross tool.
+ */
+export declare class HoverProducerComponent extends ChartBaseElement {
+    private crossEventProducer;
+    private scaleModel;
+    private config;
+    private chartModel;
+    private canvasInputListener;
+    private canvasBoundsContainer;
+    private paneManager;
+    private timeZoneModel;
+    private formatterFactory;
+    hoverSubject: BehaviorSubject<Hover | null>;
+    get hover(): Hover | null;
+    private longTouchActivated;
+    private hoverProducerParts;
+    xFormatter: DateTimeFormatter;
+    constructor(crossEventProducer: CrossEventProducerComponent, scaleModel: ScaleModel, config: FullChartConfig, chartModel: ChartModel, canvasInputListener: CanvasInputListenerComponent, canvasBoundsContainer: CanvasBoundsContainer, paneManager: PaneManager, timeZoneModel: TimeZoneModel, formatterFactory: (format: string) => (timestamp: number | Date) => string);
+    /**
+     * This method is responsible for activating the chart hover functionality. It subscribes to several observables to
+     * update the hover when the chart is updated or when the user interacts with it. It also handles special behavior
+     * for mobile devices, such as disabling panning and showing the cross tool on long touch.
+     *
+     * @protected
+     * @memberof ChartHover
+     * @returns {void}
+     */
+    protected doActivate(): void;
+    /**
+     * Recalculates the cross tool X formatter.
+     * @function
+     * @private
+     * @returns {void}
+     */
+    private recalculateCrossToolXFormatter;
+    /**
+     * Creates a hover object from a VisualCandle object.
+     * @param {VisualCandle} candle - The VisualCandle object to create the hover from.
+     * @returns {Hover | undefined} - The created hover object or undefined if the input is invalid.
+     */
+    private createHoverFromCandle;
+    /**
+     * Creates a hover object based on the provided x and y coordinates.
+     * @param {number} x - The x coordinate of the hover.
+     * @param {number} y - The y coordinate of the hover.
+     * @returns {Hover | undefined} - The hover object or undefined if there are no candles in the chart model.
+     * @todo Check if uuid is still useful here.
+     */
+    private createHover;
+    /**
+     * Creates a hover from a VisualCandle object and fires it.
+     * @param {VisualCandle} candle - The VisualCandle object to create the hover from.
+     */
+    createAndFireHoverFromCandle(candle: VisualCandle): void;
+    /**
+     * Update current hover using a VisualCandle and fires it.
+     * @param {VisualCandle} candle - The VisualCandle object to create the hover from.
+     */
+    updateHover(candle: VisualCandle): void;
+    /**
+     * Creates a hover element at the specified coordinates and fires it with the option to show the cross tool
+     * @param {CrossEvent} [x,y] - The coordinates where the hover element will be created
+     * @param {boolean} [showCrossTool=true] - Whether to show the cross tool or not
+     * @returns {void}
+     */
+    createAndFireHover([x, y, uuid]: CrossEvent): void;
+    /**
+     * Private method that handles the hover event. If a hover event is provided, it sets the last hover to the provided hover.
+     * If the device is mobile and the cross tool type is not 'none', it sets the active candle to the hovered candle only when a long tap is detected.
+     * The showCrossToolOverride is set to true only when a long tap is detected on mobile devices, otherwise it is set to the value of showCrossTool parameter.
+     * Finally, it fires the EVENT_HOVER event with the provided hover and showCrossToolOverride.
+     * If no hover event is provided, it fires the EVENT_CLOSE_HOVER event.
+     *
+     * @param {Hover} [hover] - The hover event to handle.
+     * @param {boolean} [showCrossTool=true] - A boolean value indicating whether to show the cross tool or not.
+     * @returns {void}
+     */
+    private fireHover;
+    /**
+     * Fires the last hover update if there is a last cross.
+     */
+    fireLastCross(): void;
+    /**
+     * Registers a hover producer part with the given id.
+     *
+     * @param {string} id - The id of the hover producer part.
+     * @param {HoverProducerPart} hoverProducerPart - The hover producer part to register.
+     * @returns {void}
+     */
+    registerHoverProducerPart(id: string, hoverProducerPart: HoverProducerPart): void;
+    /**
+     * Removes a hover producer part from the hoverProducerParts object.
+     * @param {string} id - The id of the hover producer part to be removed.
+     * @returns {void}
+     */
+    unregisterHoverProducerPart(id: string): void;
+}

package/dist/chart/inputhandlers/hover-producer.component.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{BehaviorSubject as l,merge as u}from"rxjs";import{CHART_UUID as v,CanvasElement as m}from"../canvas/canvas-bounds-container";import{CandleHoverProducerPart as b}from"../model/candle-hover";import{ChartBaseElement as p}from"../model/chart-base-element";import{CompareSeriesHoverProducerPart as C}from"../model/compare-series-hover";import{recalculateXFormatter as P}from"../model/date-time.formatter";import{isMobile as g}from"../utils/device/browser.utils";export class HoverProducerComponent extends p{get hover(){return this.hoverSubject.getValue()}constructor(t,e,r,s,o,i,c,n,a){super(),this.crossEventProducer=t,this.scaleModel=e,this.config=r,this.chartModel=s,this.canvasInputListener=o,this.canvasBoundsContainer=i,this.paneManager=c,this.timeZoneModel=n,this.formatterFactory=a,this.hoverSubject=new l(null),this.longTouchActivated=!1,this.xFormatter=()=>"";const h=new b(this.chartModel),d=new C(this.chartModel);this.hoverProducerParts={candleHover:h,compareSeriesHover:d}}doActivate(){super.doActivate(),this.addRxSubscription(this.chartModel.candlesSetSubject.subscribe(()=>{const e=this.chartModel.getLastVisualCandle();e&&this.createAndFireHoverFromCandle(e)})),this.addRxSubscription(this.chartModel.candlesUpdatedSubject.subscribe(()=>{const e=this.chartModel.getLastVisualCandle();this.hover!==null&&e!==void 0&&e.candle.timestamp===this.hover.timestamp&&this.updateHover(e)})),this.addRxSubscription(this.crossEventProducer.crossSubject.subscribe(e=>{e===null?this.hoverSubject.next(null):this.createAndFireHover(e)})),this.addRxSubscription(this.scaleModel.xChanged.subscribe(()=>this.fireLastCross())),this.addRxSubscription(this.canvasInputListener.observeTouchStart().subscribe(e=>{const r=e.touches[0].clientX,s=e.touches[0].clientY-this.canvasBoundsContainer.canvasOnPageLocation.y;this.chartModel.candleFromX(r,!0)&&this.createAndFireHover([r,s,""])}));const t=this.canvasBoundsContainer.getBoundsHitTest(m.ALL_PANES);this.addRxSubscription(this.canvasInputListener.observeLongTouch(t).subscribe(e=>{this.paneManager.chartPanComponent.deactivatePanHandlers(),this.longTouchActivated=!0;const r=e.touches[0].clientX,s=e.touches[0].clientY-this.canvasBoundsContainer.canvasOnPageLocation.y;this.createAndFireHover([r,s,""])})),this.addRxSubscription(this.canvasInputListener.observeTouchEndDocument().subscribe(()=>{this.paneManager.chartPanComponent.activateChartPanHandlers(),this.longTouchActivated&&(this.longTouchActivated=!1,this.crossEventProducer.fireCrossClose())})),this.addRxSubscription(u(this.chartModel.candlesSetSubject,this.timeZoneModel.observeTimeZoneChanged()).subscribe(()=>this.recalculateCrossToolXFormatter()))}recalculateCrossToolXFormatter(){const t=this.config.components.crossTool.xAxisLabelFormat;this.xFormatter=P(t,this.chartModel.getPeriod(),this.formatterFactory)}createHoverFromCandle(t){const e=t.xCenter(this.chartModel.scaleModel),r=this.chartModel.scaleModel.toY(t.close);return this.createHover(e,r,v)}createHover(t,e,r){if(this.chartModel.getCandles().length===0)return;const o=this.chartModel.candleFromX(t,!0).timestamp,i={x:t,y:e,timestamp:o,timeFormatted:this.xFormatter(o),paneId:r},c=Object.entries(this.hoverProducerParts).reduce((n,a)=>Object.assign(Object.assign({},n),{[a[0]]:a[1].getData(i)}),{});return Object.assign(Object.assign({},i),c)}createAndFireHoverFromCandle(t){const e=this.createHoverFromCandle(t);this.fireHover(e)}updateHover(t){const e=this.createHoverFromCandle(t);if(this.hover&&e){const r=Object.assign(Object.assign({},e),{x:this.hover.x,y:this.hover.y});this.fireHover(r)}}createAndFireHover([t,e,r]){const s=this.createHover(t,e,r);this.fireHover(s)}fireHover(t){var e;if(t){if(g()&&this.config.components.crossTool.type!=="none"){const r=(e=t.candleHover)===null||e===void 0?void 0:e.visualCandle.candle;r&&this.chartModel.mainCandleSeries.setActiveCandle(r)}this.hoverSubject.next(t)}else this.crossEventProducer.fireCrossClose()}fireLastCross(){const t=this.crossEventProducer.crossSubject.getValue();t&&this.createAndFireHover(t)}registerHoverProducerPart(t,e){this.hoverProducerParts=Object.assign(Object.assign({},this.hoverProducerParts),{[t]:e})}unregisterHoverProducerPart(t){delete this.hoverProducerParts[t]}}

package/dist/chart/inputhandlers/main-canvas-touch.handler.d.ts

@@ -0,0 +1,54 @@
+/*
+ * 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 { ChartBaseElement } from '../model/chart-base-element';
+import { CanvasInputListenerComponent } from '../inputlisteners/canvas-input-listener.component';
+import { ScaleModel } from '../model/scale.model';
+/**
+ * Handles chart touch events.
+ */
+export declare class MainCanvasTouchHandler extends ChartBaseElement {
+    private scaleModel;
+    private canvasInputListeners;
+    private mainCanvasParent;
+    private touchedCandleIndexes;
+    constructor(scaleModel: ScaleModel, canvasInputListeners: CanvasInputListenerComponent, mainCanvasParent: Element);
+    /**
+     * Activates canvas input listeners for touch start and touch move events.
+     * @protected
+     * @returns {void}
+     */
+    protected doActivate(): void;
+    /**
+     * Handles the touch start event.
+     * @param {TouchEvent} e - The touch event.
+     * @returns {void}
+     */
+    private handleTouchStartEvent;
+    /**
+     * Handles touch move event
+     * @param {TouchEvent} e - The touch event object
+     * @returns {void}
+     
+    private handleTouchMoveEvent(e: TouchEvent): void {
+        if (e.touches.length === 2) {
+            this.pinchHandler(this.touchedCandleIndexes, this.getXPositions(e));
+        }
+    }*/
+    private handleTouchMoveEvent;
+    /**
+     * Gets candle positions touched by user in pixels.
+     * @param e - touch event with "touches" array
+     * @return Array<number> - X coordinates of touches on the canvas
+     */
+    private getXPositions;
+    /**
+     * Handles the pinch gesture on the chart.
+     * @param {Array<number>} candleIndexes - An array of two numbers representing the indexes of the first and last visible candles on the chart.
+     * @param {number[]} touchPositions - An array of two numbers representing the touch positions on the screen.
+     * @returns {void}
+     */
+    pinchHandler(candleIndexes: Array<number>, touchPositions: number[]): void;
+}

package/dist/chart/inputhandlers/main-canvas-touch.handler.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{ChartBaseElement as c}from"../model/chart-base-element";export class MainCanvasTouchHandler extends c{constructor(t,e,s){super(),this.scaleModel=t,this.canvasInputListeners=e,this.mainCanvasParent=s,this.touchedCandleIndexes=[0,0]}doActivate(){this.addRxSubscription(this.canvasInputListeners.observeTouchStart().subscribe(t=>this.handleTouchStartEvent(t))),this.addRxSubscription(this.canvasInputListeners.observeTouchMove().subscribe(t=>this.handleTouchMoveEvent(t)))}handleTouchStartEvent(t){t.touches.length===2&&(this.touchedCandleIndexes=this.getXPositions(t).map(e=>this.scaleModel.fromX(e)))}handleTouchMoveEvent(t){t.touches.length===2&&this.pinchHandler(this.touchedCandleIndexes,this.getXPositions(t))}getXPositions(t){const e=this.mainCanvasParent.getBoundingClientRect(),s=[0,0],a=document.body.scrollLeft||document.documentElement.scrollLeft;for(let n=0,h=t.touches.length;n<h;n++){const o=t.touches[n];s[n]=o.pageX-e.left-a}return s}pinchHandler(t,e){const s=(e[0]*t[1]-e[1]*t[0])/(e[0]-e[1]),a=s+(t[0]-t[1])/(e[0]-e[1])*this.scaleModel.getBounds().width;this.scaleModel.setXScale(s,a)}}