@devexperts/dxcharts-lite 1.0.2 → 2.0.0

package/dist/chart/components/dran-n-drop_helper/drag-n-drop-x.component.js

@@ -3,4 +3,31 @@
  * 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{defaultDragComponentOptions as a,DragNDropComponent as o}from"./drag-n-drop.component";export class DragNDropXComponent extends o{constructor(t,s,r,e,i=a){super(t,s,r,e,i)}doActivate(){super.doActivate(),this.addRxSubscription(this.canvasInputListener.observeXDragStart(this.hitTest).subscribe(this.onDragStart)),this.addRxSubscription(this.canvasInputListener.observeXDrag().subscribe(this.onDragTick)),this.addRxSubscription(this.canvasInputListener.observeXDragEnd().subscribe(this.onDragEnd))}doDeactivate(){super.doDeactivate()}}
+import { defaultDragComponentOptions, DragNDropComponent, } from './drag-n-drop.component';
+export class DragNDropXComponent extends DragNDropComponent {
+    constructor(hitTest, dragCallbacks, canvasInputListener, chartPanComponent, dragComponentOptions = defaultDragComponentOptions) {
+        super(hitTest, dragCallbacks, canvasInputListener, chartPanComponent, dragComponentOptions);
+    }
+    /**
+     * This method is used to activate the component and add the necessary subscriptions to the canvasInputListener.
+     * It calls the super method doActivate() and then adds the following subscriptions:
+     * - observeXDragStart() subscription with hitTest() as parameter and onDragStart() as callback function
+     * - observeXDrag() subscription with onDragTick() as callback function
+     * - observeXDragEnd() subscription with onDragEnd() as callback function
+     * @returns {void}
+     */
+    doActivate() {
+        super.doActivate();
+        this.addRxSubscription(this.canvasInputListener.observeXDragStart(this.hitTest).subscribe(this.onDragStart));
+        this.addRxSubscription(this.canvasInputListener.observeXDrag().subscribe(this.onDragTick));
+        this.addRxSubscription(this.canvasInputListener.observeXDragEnd().subscribe(this.onDragEnd));
+    }
+    /**
+     * This method overrides the doDeactivate method of the parent class and calls it using the super keyword.
+     * It is used to deactivate the current object and perform any necessary cleanup operations.
+     * @protected
+     */
+    doDeactivate() {
+        super.doDeactivate();
+    }
+}

package/dist/chart/components/dran-n-drop_helper/drag-n-drop-y.component.js

@@ -3,4 +3,27 @@
  * 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{defaultDragComponentOptions as a,DragNDropComponent as o}from"./drag-n-drop.component";export class DragNDropYComponent extends o{constructor(t,s,r,e,i=a){super(t,s,r,e,i)}doActivate(){super.doActivate(),this.addRxSubscription(this.canvasInputListener.observeYDragStart(this.hitTest).subscribe(this.onDragStart)),this.addRxSubscription(this.canvasInputListener.observeYDrag().subscribe(this.onDragTick)),this.addRxSubscription(this.canvasInputListener.observeYDragEnd().subscribe(this.onDragEnd))}doDeactivate(){super.doDeactivate()}}
+import { defaultDragComponentOptions, DragNDropComponent, } from './drag-n-drop.component';
+export class DragNDropYComponent extends DragNDropComponent {
+    constructor(hitTest, dragCallbacks, canvasInputListener, chartPanComponent, dragComponentOptions = defaultDragComponentOptions) {
+        super(hitTest, dragCallbacks, canvasInputListener, chartPanComponent, dragComponentOptions);
+    }
+    /**
+     * This method activates the component and adds subscriptions to the canvasInputListener.
+     * @protected
+     * @returns {void}
+     */
+    doActivate() {
+        super.doActivate();
+        this.addRxSubscription(this.canvasInputListener.observeYDragStart(this.hitTest).subscribe(this.onDragStart));
+        this.addRxSubscription(this.canvasInputListener.observeYDrag().subscribe(this.onDragTick));
+        this.addRxSubscription(this.canvasInputListener.observeYDragEnd().subscribe(this.onDragEnd));
+    }
+    /**
+     * This method overrides the doDeactivate method of the parent class and calls the parent method before executing its own code.
+     * It is a protected method, which means it can only be accessed within the class and its subclasses.
+     */
+    doDeactivate() {
+        super.doDeactivate();
+    }
+}

package/dist/chart/components/dran-n-drop_helper/drag-n-drop.component.js

@@ -3,4 +3,56 @@
  * 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 e}from"../../model/chart-base-element";export const defaultDragComponentOptions={disableChartPanning:!0};export class DragNDropComponent extends e{constructor(t,s,i,n,r){super(),this.hitTest=t,this.dragCallbacks=s,this.canvasInputListener=i,this.chartPanComponent=n,this.dragComponentOptions=r,this.dragging=!1,this.draggedPixels=0,this.onDragStart=a=>{this.dragging=!0,this.draggedPixels=0,this.dragCallbacks.onDragStart&&this.dragCallbacks.onDragStart(a),this.dragComponentOptions.disableChartPanning&&this.chartPanComponent.deactivatePanHandlers()},this.onDragTick=a=>{this.dragging&&(this.draggedPixels+=a,this.dragCallbacks.onDragTick({delta:a,draggedPixels:this.draggedPixels}))},this.onDragEnd=()=>{this.dragging&&(this.dragging=!1,this.dragCallbacks.onDragEnd&&this.dragCallbacks.onDragEnd(this.draggedPixels),this.dragComponentOptions.disableChartPanning&&this.chartPanComponent.activateChartPanHandlers())}}doActivate(){super.doActivate()}doDeactivate(){super.doDeactivate()}}
+import { ChartBaseElement } from '../../model/chart-base-element';
+export const defaultDragComponentOptions = {
+    disableChartPanning: true,
+};
+export class DragNDropComponent extends ChartBaseElement {
+    constructor(hitTest, dragCallbacks, canvasInputListener, chartPanComponent, dragComponentOptions) {
+        super();
+        this.hitTest = hitTest;
+        this.dragCallbacks = dragCallbacks;
+        this.canvasInputListener = canvasInputListener;
+        this.chartPanComponent = chartPanComponent;
+        this.dragComponentOptions = dragComponentOptions;
+        this.dragging = false;
+        this.draggedPixels = 0;
+        this.onDragStart = (point) => {
+            this.dragging = true;
+            this.draggedPixels = 0;
+            this.dragCallbacks.onDragStart && this.dragCallbacks.onDragStart(point);
+            this.dragComponentOptions.disableChartPanning && this.chartPanComponent.deactivatePanHandlers();
+        };
+        this.onDragTick = (yDelta) => {
+            if (this.dragging) {
+                this.draggedPixels += yDelta;
+                this.dragCallbacks.onDragTick({
+                    delta: yDelta,
+                    draggedPixels: this.draggedPixels,
+                });
+            }
+        };
+        this.onDragEnd = () => {
+            if (this.dragging) {
+                this.dragging = false;
+                this.dragCallbacks.onDragEnd && this.dragCallbacks.onDragEnd(this.draggedPixels);
+                this.dragComponentOptions.disableChartPanning && this.chartPanComponent.activateChartPanHandlers();
+            }
+        };
+    }
+    /**
+     * Calls the parent class's doActivate method and performs any additional activation logic.
+     * This method is protected and can only be accessed by the class itself and its subclasses.
+     */
+    doActivate() {
+        super.doActivate();
+    }
+    /**
+     * This method overrides the doDeactivate method of the parent class and calls it using the super keyword.
+     * It is a protected method that can only be accessed within the class and its subclasses.
+     * This method is responsible for deactivating the current object.
+     */
+    doDeactivate() {
+        super.doDeactivate();
+    }
+}

package/dist/chart/components/dynamic-objects/dynamic-objects.component.d.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { DrawingManager } from '../../drawers/drawing-manager';
+import { CanvasModel } from '../../model/canvas.model';
+import { ChartBaseElement } from '../../model/chart-base-element';
+import { DynamicObjectsModel } from './dynamic-objects.model';
+export declare class DynamicObjectsComponent extends ChartBaseElement {
+    model: DynamicObjectsModel;
+    constructor(canvasModel: CanvasModel, drawingManager: DrawingManager);
+}

package/dist/chart/components/dynamic-objects/dynamic-objects.component.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { ChartBaseElement } from '../../model/chart-base-element';
+import { DynamicObjectsDrawer } from './dynamic-objects.drawer';
+import { DynamicObjectsModel } from './dynamic-objects.model';
+export class DynamicObjectsComponent extends ChartBaseElement {
+    constructor(canvasModel, drawingManager) {
+        super();
+        // model
+        const dynamicObjectsModel = new DynamicObjectsModel();
+        this.model = dynamicObjectsModel;
+        this.addChildEntity(dynamicObjectsModel);
+        // drawer
+        const dynamicObjectsDrawer = new DynamicObjectsDrawer(dynamicObjectsModel, canvasModel);
+        drawingManager.addDrawer(dynamicObjectsDrawer, 'DYNAMIC_OBJECTS');
+    }
+}

package/dist/chart/components/dynamic-objects/dynamic-objects.drawer.d.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { Drawer } from '../../drawers/drawing-manager';
+import { CanvasModel } from '../../model/canvas.model';
+import { DynamicObjectsModel } from './dynamic-objects.model';
+export interface DynamicModelDrawer<T> {
+    draw(canvasModel: CanvasModel, model: T, paneUUID?: string): void;
+}
+export declare class DynamicObjectsDrawer implements Drawer {
+    private dynamicObjectsModel;
+    private canvasModel;
+    constructor(dynamicObjectsModel: DynamicObjectsModel, canvasModel: CanvasModel);
+    draw(): void;
+    getCanvasIds(): string[];
+}

package/dist/chart/components/dynamic-objects/dynamic-objects.drawer.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export class DynamicObjectsDrawer {
+    constructor(dynamicObjectsModel, canvasModel) {
+        this.dynamicObjectsModel = dynamicObjectsModel;
+        this.canvasModel = canvasModel;
+    }
+    draw() {
+        const objects = this.dynamicObjectsModel.objects;
+        Object.entries(objects).forEach(([paneUUID, list]) => {
+            for (const obj of list) {
+                const { model, drawer } = obj;
+                drawer.draw(this.canvasModel, model, paneUUID);
+            }
+        });
+    }
+    getCanvasIds() {
+        return [this.canvasModel.canvasId];
+    }
+}

package/dist/chart/components/dynamic-objects/dynamic-objects.model.d.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { ChartBaseElement } from '../../model/chart-base-element';
+import { LinkedList, ListNode } from '../../utils/linkedList.utils';
+import { DynamicModelDrawer } from './dynamic-objects.drawer';
+export type PaneId = string;
+export interface DynamicObject<T = unknown> {
+    readonly drawer: DynamicModelDrawer<T>;
+    readonly model: T;
+}
+export declare class DynamicObjectsModel extends ChartBaseElement {
+    private _objects;
+    private modelToObjectMap;
+    constructor();
+    /**
+     * Adds an object from outside chart-core into model
+     * @param obj
+     * @param paneId
+     */
+    addObject(obj: DynamicObject, paneId: PaneId): void;
+    /**
+     * Removes an object from model
+     * @param model
+     * @param paneId
+     */
+    removeObject(model: unknown, paneId: PaneId): void;
+    /**
+     * Moves the object inside the drawing order so it's being drawn before the other elements
+     * @param paneId
+     * @param listNode
+     */
+    bringToFront(paneId: PaneId, listNode: ListNode<DynamicObject>): void;
+    /**
+     * Moves the object inside the drawing order so it's being drawn after the other elements
+     * @param paneId
+     * @param listNode
+     */
+    bringToBack(paneId: PaneId, listNode: ListNode<DynamicObject>): void;
+    /**
+     * Moves the object inside the drawing order so it's being drawn one layer ahead
+     * @param obj
+     * @param paneId
+     */
+    moveForward(paneId: PaneId, listNode: ListNode<DynamicObject>): void;
+    /**
+     * Moves the object inside the drawing order so it's being drawn one layer closer to the back
+     * @param obj
+     * @param paneId
+     */
+    moveBackwards(paneId: PaneId, listNode: ListNode<DynamicObject>): void;
+    /**
+     * Getter for the objects
+     */
+    get objects(): Record<string, LinkedList<DynamicObject<unknown>>>;
+    /**
+     * Sets the objects
+     * @param objects
+     */
+    setDynamicObjects(objects: Record<PaneId, LinkedList<DynamicObject>>): void;
+}

package/dist/chart/components/dynamic-objects/dynamic-objects.model.js

@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2019 - 2023 Devexperts Solutions IE Limited
+ * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+ * If a copy of the MPL was not distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { BehaviorSubject } from 'rxjs';
+import { ChartBaseElement } from '../../model/chart-base-element';
+import { LinkedList, ListNode } from '../../utils/linkedList.utils';
+export class DynamicObjectsModel extends ChartBaseElement {
+    constructor() {
+        super();
+        this.modelToObjectMap = new Map();
+        this._objects = new BehaviorSubject({});
+    }
+    /**
+     * Adds an object from outside chart-core into model
+     * @param obj
+     * @param paneId
+     */
+    addObject(obj, paneId) {
+        var _a;
+        const objects = this.objects;
+        const paneList = (_a = objects[paneId]) !== null && _a !== void 0 ? _a : new LinkedList();
+        if (!Object.keys(objects).find(pane => pane === paneId)) {
+            objects[paneId] = paneList;
+        }
+        paneList.insertAtEnd(obj);
+        this.modelToObjectMap.set(obj.model, obj);
+        this.setDynamicObjects(objects);
+    }
+    /**
+     * Removes an object from model
+     * @param model
+     * @param paneId
+     */
+    removeObject(model, paneId) {
+        const objects = this.objects;
+        const paneList = objects[paneId];
+        const obj = this.modelToObjectMap.get(model);
+        if (paneList && obj) {
+            const targetNode = new ListNode(obj);
+            const targetPos = paneList.getNodePosition(targetNode);
+            paneList.removeAt(targetPos);
+            this.modelToObjectMap.delete(model);
+            if (paneList.size() === 0) {
+                delete objects[paneId];
+            }
+            this.setDynamicObjects(objects);
+        }
+    }
+    /**
+     * Moves the object inside the drawing order so it's being drawn before the other elements
+     * @param paneId
+     * @param listNode
+     */
+    bringToFront(paneId, listNode) {
+        const list = this.objects[paneId];
+        if (list) {
+            const targetPos = list.getNodePosition(listNode);
+            if (targetPos >= 0 && targetPos < list.size()) {
+                const nodeToReplace = list.removeAt(targetPos);
+                if (nodeToReplace) {
+                    list.insertAtEnd(nodeToReplace.data);
+                }
+            }
+            this.setDynamicObjects(this.objects);
+        }
+    }
+    /**
+     * Moves the object inside the drawing order so it's being drawn after the other elements
+     * @param paneId
+     * @param listNode
+     */
+    bringToBack(paneId, listNode) {
+        const list = this.objects[paneId];
+        if (list) {
+            const targetPos = list.getNodePosition(listNode);
+            if (targetPos > 0 && targetPos <= list.size()) {
+                const nodeToReplace = list.removeAt(targetPos);
+                if (nodeToReplace) {
+                    list.insertAt(0, nodeToReplace === null || nodeToReplace === void 0 ? void 0 : nodeToReplace.data);
+                }
+            }
+            this.setDynamicObjects(this.objects);
+        }
+    }
+    /**
+     * Moves the object inside the drawing order so it's being drawn one layer ahead
+     * @param obj
+     * @param paneId
+     */
+    moveForward(paneId, listNode) {
+        const list = this.objects[paneId];
+        if (list) {
+            const targetPos = list.getNodePosition(listNode);
+            if (targetPos >= 0 && targetPos < list.size()) {
+                const nodeToReplace = list.removeAt(targetPos);
+                if (nodeToReplace) {
+                    list.insertAt(targetPos + 1, nodeToReplace.data);
+                }
+            }
+            this.setDynamicObjects(this.objects);
+        }
+    }
+    /**
+     * Moves the object inside the drawing order so it's being drawn one layer closer to the back
+     * @param obj
+     * @param paneId
+     */
+    moveBackwards(paneId, listNode) {
+        const list = this.objects[paneId];
+        if (list) {
+            const targetPos = list.getNodePosition(listNode);
+            if (targetPos > 0 && targetPos <= list.size()) {
+                const nodeToReplace = list.removeAt(targetPos);
+                if (nodeToReplace) {
+                    list.insertAt(targetPos - 1, nodeToReplace === null || nodeToReplace === void 0 ? void 0 : nodeToReplace.data);
+                }
+            }
+            this.setDynamicObjects(this.objects);
+        }
+    }
+    /**
+     * Getter for the objects
+     */
+    get objects() {
+        return this._objects.getValue();
+    }
+    /**
+     * Sets the objects
+     * @param objects
+     */
+    setDynamicObjects(objects) {
+        this._objects.next(objects);
+    }
+}

package/dist/chart/components/events/events-hit-test.drawer.js

@@ -3,4 +3,66 @@
  * 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{CanvasElement as f}from"../../canvas/canvas-bounds-container";import{getEventSize as v}from"./events.drawer";const r=5;export class EventsHitTestDrawer{constructor(e,t,s,c,o){this.hitTestCanvasModel=e,this.chartModel=t,this.config=s,this.canvasBoundsContainer=c,this.model=o}draw(){const e=this.hitTestCanvasModel.ctx,t=this.canvasBoundsContainer.getBounds(f.EVENTS);e.save(),this.model.events.forEach((s,c)=>{const o=this.model.events[c-1],l=o&&this.chartModel.candleFromTimestamp(o.timestamp).xCenter(this.chartModel.scaleModel),i=this.chartModel.candleFromTimestamp(s.timestamp).xCenter(this.chartModel.scaleModel);if(i>t.x&&i<t.x+t.width){const h=this.config.colors.events[s.type].color;e.strokeStyle=h,e.fillStyle=h;const n=v(s);e.fillStyle=this.hitTestCanvasModel.idToColor(s.id);const a=(n+r)*2;if(l!==void 0){const d=v(o);if(l+d>i-a/2){const m=n*2+r;e.fillRect(l+d,t.y,m,t.height)}else e.fillRect(i-n-r,t.y,a,t.height)}else e.fillRect(i-n-r,t.y,a,t.height)}}),e.restore()}getCanvasIds(){return[this.hitTestCanvasModel.canvasId]}}
+import { CanvasElement } from '../../canvas/canvas-bounds-container';
+import { getEventSize } from './events.drawer';
+const hoverExtendedAreaPixels = 5;
+export class EventsHitTestDrawer {
+    constructor(hitTestCanvasModel, chartModel, config, canvasBoundsContainer, model) {
+        this.hitTestCanvasModel = hitTestCanvasModel;
+        this.chartModel = chartModel;
+        this.config = config;
+        this.canvasBoundsContainer = canvasBoundsContainer;
+        this.model = model;
+    }
+    /**
+     * Draws events on the hit test canvas.
+     * @function
+     * @name draw
+     * @memberof CanvasElement.EVENTS
+     * @instance
+     * @returns {void}
+      
+    */
+    draw() {
+        const ctx = this.hitTestCanvasModel.ctx;
+        const bounds = this.canvasBoundsContainer.getBounds(CanvasElement.EVENTS);
+        ctx.save();
+        this.model.events.forEach((event, idx) => {
+            const prevEvent = this.model.events[idx - 1];
+            const prevX = prevEvent &&
+                this.chartModel.candleFromTimestamp(prevEvent.timestamp).xCenter(this.chartModel.scale);
+            const x = this.chartModel.candleFromTimestamp(event.timestamp).xCenter(this.chartModel.scale);
+            if (x > bounds.x && x < bounds.x + bounds.width) {
+                const color = this.config.colors.events[event.type].color;
+                ctx.strokeStyle = color;
+                ctx.fillStyle = color;
+                const size = getEventSize(event);
+                // draw hit test
+                ctx.fillStyle = this.hitTestCanvasModel.idToColor(event.id);
+                const hoverSize = (size + hoverExtendedAreaPixels) * 2;
+                if (prevX !== undefined) {
+                    const prevSize = getEventSize(prevEvent);
+                    const isIntersectsWithPrev = prevX + prevSize > x - hoverSize / 2;
+                    if (isIntersectsWithPrev) {
+                        const hoverSize = size * 2 + hoverExtendedAreaPixels;
+                        ctx.fillRect(prevX + prevSize, bounds.y, hoverSize, bounds.height);
+                    }
+                    else {
+                        ctx.fillRect(x - size - hoverExtendedAreaPixels, bounds.y, hoverSize, bounds.height);
+                    }
+                }
+                else {
+                    ctx.fillRect(x - size - hoverExtendedAreaPixels, bounds.y, hoverSize, bounds.height);
+                }
+            }
+        });
+        ctx.restore();
+    }
+    /**
+     * Returns an array of string containing the canvas ID of the hitTestCanvasModel.
+     * @returns {Array<string>} An array of string containing the canvas ID of the hitTestCanvasModel.
+     */
+    getCanvasIds() {
+        return [this.hitTestCanvasModel.canvasId];
+    }
+}

package/dist/chart/components/events/events.component.js

@@ -3,4 +3,64 @@
  * 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{CanvasElement as E}from"../../canvas/canvas-bounds-container";import{ChartBaseElement as h}from"../../model/chart-base-element";import{recalculateXFormatter as c}from"../../model/date-time.formatter";import{merge as f}from"../../utils/merge.utils";import{EventsHitTestDrawer as p}from"./events-hit-test.drawer";import{EventsDrawer as w}from"./events.drawer";import{EventsModel as b}from"./events.model";export class EventsComponent extends h{constructor(e,s,n,r,i,o,a,v,m){super(),this.config=e,this.canvasModel=s,this.canvasBoundsContainer=i,this.drawingManager=o,this.formatterFactory=a,this.eventsXAxisLabelFormatterProvider=()=>c(this.config.components.events.xAxisLabelFormat,r.getPeriod(),this.formatterFactory);const t=new b(s);this.eventsModel=t,this.addChildEntity(t),n.addSubscriber(t);const d=new w(m,s,r,e,i,t,this.eventsXAxisLabelFormatterProvider);this.drawingManager.addDrawer(d,"EVENTS");const l=new p(n,r,e,i,t);this.drawingManager.addDrawerBefore(l,"HIT_TEST_EVENTS","HIT_TEST_DRAWINGS"),v.setCursorForCanvasEl(E.EVENTS,e.components.events.cursor)}setEvents(e){this.eventsModel.setEvents(e),this.canvasModel.fireDraw()}setVisible(e){this.config.components.events.visible=e,this.canvasBoundsContainer.recalculateBounds(),this.canvasModel.fireDraw()}setEventTypeVisible(e){f(this.config.components.events.eventsVisibility,e,{overrideExisting:!0,addIfMissing:!1}),this.canvasModel.fireDraw()}observeEventHovered(){return this.eventsModel.hoveredEvent.asObservable()}}
+import { CanvasElement } from '../../canvas/canvas-bounds-container';
+import { ChartBaseElement } from '../../model/chart-base-element';
+import { recalculateXFormatter } from '../../model/date-time.formatter';
+import { merge } from '../../utils/merge.utils';
+import { EventsHitTestDrawer } from './events-hit-test.drawer';
+import { EventsDrawer } from './events.drawer';
+import { EventsModel } from './events.model';
+export class EventsComponent extends ChartBaseElement {
+    constructor(config, canvasModel, hitTestCanvasModel, chartModel, canvasBoundsContainer, drawingManager, formatterFactory, cursorHandler, backgroundCanvasModel) {
+        super();
+        this.config = config;
+        this.canvasModel = canvasModel;
+        this.canvasBoundsContainer = canvasBoundsContainer;
+        this.drawingManager = drawingManager;
+        this.formatterFactory = formatterFactory;
+        this.eventsXAxisLabelFormatterProvider = () => recalculateXFormatter(this.config.components.events.xAxisLabelFormat, chartModel.getPeriod(), this.formatterFactory);
+        const eventsModel = new EventsModel(canvasModel);
+        this.eventsModel = eventsModel;
+        this.addChildEntity(eventsModel);
+        hitTestCanvasModel.addSubscriber(eventsModel);
+        const eventsDrawer = new EventsDrawer(backgroundCanvasModel, canvasModel, chartModel, config, canvasBoundsContainer, eventsModel, this.eventsXAxisLabelFormatterProvider);
+        this.drawingManager.addDrawer(eventsDrawer, 'EVENTS');
+        const eventsHitTestDrawer = new EventsHitTestDrawer(hitTestCanvasModel, chartModel, config, canvasBoundsContainer, eventsModel);
+        this.drawingManager.addDrawerBefore(eventsHitTestDrawer, 'HIT_TEST_EVENTS', 'HIT_TEST_DRAWINGS');
+        cursorHandler.setCursorForCanvasEl(CanvasElement.EVENTS, config.components.events.cursor);
+    }
+    /**
+     * Sets the new event list.
+     * @param events
+     */
+    setEvents(events) {
+        this.eventsModel.setEvents(events);
+        this.canvasModel.fireDraw();
+    }
+    /**
+     * Changes the component visibility.
+     * @param visible
+     */
+    setVisible(visible) {
+        this.config.components.events.visible = visible;
+        this.canvasBoundsContainer.recalculateBounds();
+        this.canvasModel.fireDraw();
+    }
+    /**
+     * Changes visibility for the specific event type.
+     * For example, to turn off dividends visibility you can call this method with { dividends: false } argument
+     */
+    setEventTypeVisible(eventsVisibility) {
+        merge(this.config.components.events.eventsVisibility, eventsVisibility, {
+            overrideExisting: true,
+            addIfMissing: false,
+        });
+        this.canvasModel.fireDraw();
+    }
+    /**
+     * Observes hovered event when mouse moves in, and provides null when mouse moves out.
+     */
+    observeEventHovered() {
+        return this.eventsModel.hoveredEvent.asObservable();
+    }
+}