@tetacom/svg-charts 1.4.21 → 1.4.23

package/esm2022/chart/directives/draggable-point.directive.mjs

@@ -0,0 +1,147 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { DragPointType } from '../model/enum/drag-point-type';
+import * as i0 from "@angular/core";
+export class DraggablePointDirective {
+    _elementRef;
+    tetaDraggablePoint;
+    dragDirection;
+    allowDrag;
+    startPosition;
+    transformCache;
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+    }
+    moveStart = new EventEmitter();
+    moveProcess = new EventEmitter();
+    moveEnd = new EventEmitter();
+    mouseDown(event) {
+        if (!this.tetaDraggablePoint) {
+            return;
+        }
+        event.stopPropagation();
+        event.preventDefault();
+        this.startPosition = {
+            x: event.x,
+            y: event.y
+        };
+        this.moveStart.emit(this.startPosition);
+    }
+    mouseUp(event) {
+        if (this.startPosition !== null && this.startPosition !== undefined) {
+            let deltaX = event.x - this.startPosition.x;
+            let deltaY = event.y - this.startPosition.y;
+            if (this.dragDirection === DragPointType.x) {
+                deltaY = 0;
+            }
+            if (this.dragDirection === DragPointType.y) {
+                deltaX = 0;
+            }
+            if (this.allowDrag && !this.allowDrag({
+                x: event.x,
+                y: event.y,
+                deltaX,
+                deltaY
+            })) {
+                this.startPosition = null;
+                return;
+            }
+            if (this.transformCache) {
+                this.transformCache.x = this.transformCache.x + deltaX;
+                this.transformCache.y = this.transformCache.y + deltaY;
+            }
+            else {
+                this.transformCache = {
+                    x: deltaX,
+                    y: deltaY
+                };
+            }
+            this.moveEnd.emit({
+                x: event.x,
+                y: event.y,
+                deltaX,
+                deltaY
+            });
+        }
+        this.startPosition = null;
+    }
+    mouseMove(event) {
+        if (this.startPosition) {
+            let deltaX = event.x - this.startPosition.x;
+            let deltaY = event.y - this.startPosition.y;
+            if (this.transformCache) {
+                deltaX = this.transformCache.x + deltaX;
+                deltaY = this.transformCache.y + deltaY;
+            }
+            if (this.allowDrag && !this.allowDrag({
+                x: event.x,
+                y: event.y,
+                deltaX,
+                deltaY
+            })) {
+                return;
+            }
+            if (this.dragDirection === DragPointType.x) {
+                deltaY = 0;
+            }
+            if (this.dragDirection === DragPointType.y) {
+                deltaX = 0;
+            }
+            this.setTransform(deltaX, deltaY);
+            event.stopPropagation();
+            event.preventDefault();
+            this.moveProcess.emit({
+                x: event.x,
+                y: event.y,
+                deltaX,
+                deltaY
+            });
+        }
+    }
+    setTransform(x, y) {
+        this._elementRef.nativeElement.style.transform = `translate(${x}px, ${y}px)`;
+    }
+    resetTransform() {
+        this.setTransform(0, 0);
+        this.transformCache = null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DraggablePointDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DraggablePointDirective, selector: "[tetaDraggablePoint]", inputs: { tetaDraggablePoint: "tetaDraggablePoint", dragDirection: "dragDirection", allowDrag: "allowDrag" }, outputs: { moveStart: "moveStart", moveProcess: "moveProcess", moveEnd: "moveEnd" }, host: { listeners: { "mousedown": "mouseDown($event)", "touchstart": "mouseDown($event)", "window:mouseup": "mouseUp($event)", "window:touchend": "mouseUp($event)", "window:mousemove": "mouseMove($event)", "window:touchmove": "mouseMove($event)" } }, exportAs: ["tetaDraggablePoint"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DraggablePointDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaDraggablePoint]',
+                    exportAs: 'tetaDraggablePoint'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { tetaDraggablePoint: [{
+                type: Input
+            }], dragDirection: [{
+                type: Input
+            }], allowDrag: [{
+                type: Input
+            }], moveStart: [{
+                type: Output
+            }], moveProcess: [{
+                type: Output
+            }], moveEnd: [{
+                type: Output
+            }], mouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchstart', ['$event']]
+            }], mouseUp: [{
+                type: HostListener,
+                args: ['window:mouseup', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['window:touchend', ['$event']]
+            }], mouseMove: [{
+                type: HostListener,
+                args: ['window:mousemove', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['window:touchmove', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draggable-point.directive.js","sourceRoot":"","sources":["../../../../src/chart/directives/draggable-point.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAc,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AAC/F,OAAO,EAAC,aAAa,EAAC,MAAM,+BAA+B,CAAC;;AAM5D,MAAM,OAAO,uBAAuB;IAoBd;IAnBX,kBAAkB,CAAU;IAC5B,aAAa,CAAgB;IAC7B,SAAS,CAKJ;IAEN,aAAa,CAGnB;IAEM,cAAc,CAGpB;IAEF,YAAoB,WAAuB;QAAvB,gBAAW,GAAX,WAAW,CAAY;IAC3C,CAAC;IAES,SAAS,GAAG,IAAI,YAAY,EAGlC,CAAC;IAEK,WAAW,GAAG,IAAI,YAAY,EAKpC,CAAC;IAEK,OAAO,GAAG,IAAI,YAAY,EAKhC,CAAC;IAIL,SAAS,CAAC,KAAiB;QACzB,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC5B,OAAO;SACR;QACD,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,IAAI,CAAC,aAAa,GAAG;YACnB,CAAC,EAAE,KAAK,CAAC,CAAC;YACV,CAAC,EAAE,KAAK,CAAC,CAAC;SACX,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1C,CAAC;IAID,OAAO,CAAC,KAAiB;QACvB,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE;YACnE,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC5C,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC5C,IAAI,IAAI,CAAC,aAAa,KAAK,aAAa,CAAC,CAAC,EAAE;gBAC1C,MAAM,GAAG,CAAC,CAAC;aACZ;YACD,IAAI,IAAI,CAAC,aAAa,KAAK,aAAa,CAAC,CAAC,EAAE;gBAC1C,MAAM,GAAG,CAAC,CAAC;aACZ;YACD,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;gBACpC,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,MAAM;gBACN,MAAM;aACP,CAAC,EAAE;gBACF,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;gBAC1B,OAAO;aACR;YACD,IAAI,IAAI,CAAC,cAAc,EAAE;gBACvB,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC;gBACvD,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC;aACxD;iBAAM;gBACL,IAAI,CAAC,cAAc,GAAG;oBACpB,CAAC,EAAE,MAAM;oBACT,CAAC,EAAE,MAAM;iBACV,CAAC;aACH;YACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;gBAChB,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,MAAM;gBACN,MAAM;aACP,CAAC,CAAC;SACJ;QACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAID,SAAS,CAAC,KAAiB;QACzB,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC5C,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC5C,IAAI,IAAI,CAAC,cAAc,EAAE;gBACvB,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC;gBACxC,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC;aACzC;YACD,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;gBACpC,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,MAAM;gBACN,MAAM;aACP,CAAC,EAAE;gBACF,OAAO;aACR;YACD,IAAI,IAAI,CAAC,aAAa,KAAK,aAAa,CAAC,CAAC,EAAE;gBAC1C,MAAM,GAAG,CAAC,CAAC;aACZ;YACD,IAAI,IAAI,CAAC,aAAa,KAAK,aAAa,CAAC,CAAC,EAAE;gBAC1C,MAAM,GAAG,CAAC,CAAC;aACZ;YACD,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAClC,KAAK,CAAC,eAAe,EAAE,CAAC;YACxB,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;gBACpB,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,MAAM;gBACN,MAAM;aACP,CAAC,CAAC;SACJ;IACH,CAAC;IAED,YAAY,CAAC,CAAS,EAAE,CAAS;QAC/B,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC;IAC/E,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC7B,CAAC;uGA5IU,uBAAuB;2FAAvB,uBAAuB;;2FAAvB,uBAAuB;kBAJnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,sBAAsB;oBAChC,QAAQ,EAAE,oBAAoB;iBAC/B;iGAEU,kBAAkB;sBAA1B,KAAK;gBACG,aAAa;sBAArB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAoBI,SAAS;sBAAlB,MAAM;gBAKG,WAAW;sBAApB,MAAM;gBAOG,OAAO;sBAAhB,MAAM;gBASP,SAAS;sBAFR,YAAY;uBAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;;sBACpC,YAAY;uBAAC,YAAY,EAAE,CAAC,QAAQ,CAAC;gBAgBtC,OAAO;sBAFN,YAAY;uBAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC;;sBACzC,YAAY;uBAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC;gBAyC3C,SAAS;sBAFR,YAAY;uBAAC,kBAAkB,EAAE,CAAC,QAAQ,CAAC;;sBAC3C,YAAY;uBAAC,kBAAkB,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import {Directive, ElementRef, EventEmitter, HostListener, Input, Output} from '@angular/core';\nimport {DragPointType} from '../model/enum/drag-point-type';\n\n@Directive({\n  selector: '[tetaDraggablePoint]',\n  exportAs: 'tetaDraggablePoint'\n})\nexport class DraggablePointDirective {\n  @Input() tetaDraggablePoint: boolean;\n  @Input() dragDirection: DragPointType;\n  @Input() allowDrag: (point: {\n    x: number,\n    y: number,\n    deltaX: number,\n    deltaY: number\n  }) => boolean;\n\n  private startPosition: {\n    x: number,\n    y: number;\n  };\n\n  private transformCache: {\n    x: number,\n    y: number;\n  };\n\n  constructor(private _elementRef: ElementRef) {\n  }\n\n  @Output() moveStart = new EventEmitter<{\n    x: number,\n    y: number\n  }>();\n\n  @Output() moveProcess = new EventEmitter<{\n    x: number,\n    y: number,\n    deltaX: number,\n    deltaY: number\n  }>();\n\n  @Output() moveEnd = new EventEmitter<{\n    x: number,\n    y: number,\n    deltaX: number,\n    deltaY: number\n  }>();\n\n  @HostListener('mousedown', ['$event'])\n  @HostListener('touchstart', ['$event'])\n  mouseDown(event: MouseEvent) {\n    if (!this.tetaDraggablePoint) {\n      return;\n    }\n    event.stopPropagation();\n    event.preventDefault();\n    this.startPosition = {\n      x: event.x,\n      y: event.y\n    };\n    this.moveStart.emit(this.startPosition);\n  }\n\n  @HostListener('window:mouseup', ['$event'])\n  @HostListener('window:touchend', ['$event'])\n  mouseUp(event: MouseEvent) {\n    if (this.startPosition !== null && this.startPosition !== undefined) {\n      let deltaX = event.x - this.startPosition.x;\n      let deltaY = event.y - this.startPosition.y;\n      if (this.dragDirection === DragPointType.x) {\n        deltaY = 0;\n      }\n      if (this.dragDirection === DragPointType.y) {\n        deltaX = 0;\n      }\n      if (this.allowDrag && !this.allowDrag({\n        x: event.x,\n        y: event.y,\n        deltaX,\n        deltaY\n      })) {\n        this.startPosition = null;\n        return;\n      }\n      if (this.transformCache) {\n        this.transformCache.x = this.transformCache.x + deltaX;\n        this.transformCache.y = this.transformCache.y + deltaY;\n      } else {\n        this.transformCache = {\n          x: deltaX,\n          y: deltaY\n        };\n      }\n      this.moveEnd.emit({\n        x: event.x,\n        y: event.y,\n        deltaX,\n        deltaY\n      });\n    }\n    this.startPosition = null;\n  }\n\n  @HostListener('window:mousemove', ['$event'])\n  @HostListener('window:touchmove', ['$event'])\n  mouseMove(event: MouseEvent) {\n    if (this.startPosition) {\n      let deltaX = event.x - this.startPosition.x;\n      let deltaY = event.y - this.startPosition.y;\n      if (this.transformCache) {\n        deltaX = this.transformCache.x + deltaX;\n        deltaY = this.transformCache.y + deltaY;\n      }\n      if (this.allowDrag && !this.allowDrag({\n        x: event.x,\n        y: event.y,\n        deltaX,\n        deltaY\n      })) {\n        return;\n      }\n      if (this.dragDirection === DragPointType.x) {\n        deltaY = 0;\n      }\n      if (this.dragDirection === DragPointType.y) {\n        deltaX = 0;\n      }\n      this.setTransform(deltaX, deltaY);\n      event.stopPropagation();\n      event.preventDefault();\n      this.moveProcess.emit({\n        x: event.x,\n        y: event.y,\n        deltaX,\n        deltaY\n      });\n    }\n  }\n\n  setTransform(x: number, y: number) {\n    this._elementRef.nativeElement.style.transform = `translate(${x}px, ${y}px)`;\n  }\n\n  resetTransform() {\n    this.setTransform(0, 0);\n    this.transformCache = null;\n  }\n}\n"]}

package/esm2022/chart/directives/zoomable.directive.mjs

@@ -0,0 +1,263 @@
+import { Directive, HostBinding, HostListener, Input, } from '@angular/core';
+import * as d3 from 'd3';
+import { zoomIdentity } from 'd3';
+import { ZoomType } from '../model/enum/zoom-type';
+import { AxisOrientation } from '../model/enum/axis-orientation';
+import { ZoomMessage, } from '../model/i-broadcast-message';
+import { takeWhile } from 'rxjs';
+import { ZoomBehaviorType } from '../model/enum/zoom-behavior-type';
+import { ScaleType } from "../model/enum/scale-type";
+import * as i0 from "@angular/core";
+import * as i1 from "../service/zoom.service";
+import * as i2 from "../service/chart.service";
+export class ZoomableDirective {
+    elementRef;
+    zoomService;
+    chartService;
+    zone;
+    config;
+    axis;
+    size;
+    zoomable = false;
+    crosshair = false;
+    _element;
+    zoom;
+    alive = true;
+    mouseenter() {
+        this.zoom?.on('start zoom end', this.zoomed);
+        this._element?.call(this.zoom).on('dblclick.zoom', null);
+        // Run wheel event listener
+        if (this.config?.zoom?.zoomBehavior === ZoomBehaviorType.wheel) {
+            this.runWheelTranslate();
+        }
+    }
+    mouseleave() {
+        this.zoom?.on('start zoom end', null);
+        this._element?.on('wheel', null);
+    }
+    currentTransform = zoomIdentity;
+    constructor(elementRef, zoomService, chartService, zone) {
+        this.elementRef = elementRef;
+        this.zoomService = zoomService;
+        this.chartService = chartService;
+        this.zone = zone;
+    }
+    ngOnInit() {
+        if (this.axis?.options?.zoom || this.config?.zoom?.enable) {
+            this.zoomable = this.config?.zoom?.zoomBehavior === ZoomBehaviorType.move && !this.config?.tooltip?.showCrosshair;
+            this.crosshair = this.config?.tooltip?.showCrosshair;
+        }
+    }
+    ngAfterViewInit() {
+        this.initZoomListeners();
+        this.initZoomSync();
+    }
+    ngOnDestroy() {
+        this.zoom?.on('start zoom end', null);
+        this._element?.on('wheel', null);
+        this.alive = false;
+    }
+    initZoomSync() {
+        this.zoomService.zoomed.pipe(takeWhile(() => this.alive)).subscribe((zoomed) => {
+            if (this._element && this.elementRef !== zoomed?.element
+                && zoomed?.axis?.index === this.axis.index
+                && zoomed?.axis?.orientation === this.axis.orientation) {
+                const scale = this.axis.scale.copy().domain(this.axis.originDomain);
+                let transform;
+                if (zoomed.domain === null) {
+                    transform = zoomIdentity;
+                }
+                else {
+                    transform =
+                        this.zoomService.getD3Transform(zoomed.domain, this.axis.originDomain, scale, this.axis.orientation, this.axis.options.inverted);
+                }
+                this._element.call(this.zoom.transform, transform);
+                this.currentTransform = transform;
+            }
+        });
+    }
+    initZoomListeners() {
+        const enable = (this.axis?.options?.zoom && this.axis?.options.visible !== false) ||
+            this.config?.zoom?.enable;
+        if (!enable) {
+            return;
+        }
+        this._element = d3.select(this.elementRef.nativeElement);
+        this.zoom = d3.zoom().extent([
+            [0, 0],
+            [this.size.width, this.size.height],
+        ]);
+        const min = this.config?.zoom?.minTranslate != null
+            ? this.axis.scale(this.config?.zoom?.minTranslate)
+            : -Infinity;
+        const max = (this.config?.zoom?.maxTranslate != null
+            ? this.axis.scale(this.config?.zoom?.maxTranslate)
+            : Infinity);
+        if (this.axis.orientation === AxisOrientation.x && this.config.zoom.type === ZoomType.x) {
+            this.zoom.translateExtent([
+                [Math.min(min, max), -Infinity],
+                [Math.max(min, max), Infinity],
+            ]);
+        }
+        if (this.axis.orientation === AxisOrientation.y && this.config.zoom.type === ZoomType.y) {
+            this.zoom.translateExtent([
+                [-Infinity, Math.min(min, max)],
+                [Infinity, Math.max(min, max)],
+            ]);
+        }
+        if (this.config.zoom?.wheelDelta) {
+            this.zoom.wheelDelta(this.config.zoom?.wheelDelta);
+        }
+        if (this.config?.zoom?.wheelFilter) {
+            this.zoom.filter(this.config?.zoom?.wheelFilter);
+        }
+        if (this.axis.options.scaleType.type !== ScaleType.band) {
+            const extremes = this.axis.extremes;
+            const maxZoom = this.config.zoom?.max
+                ? (extremes[1] - extremes[0]) /
+                    this.config.zoom?.max
+                : this.config.zoom?.limitZoomByData
+                    ? 1
+                    : 0;
+            const minZoom = this.config.zoom?.min
+                ? (extremes[1] - extremes[0]) /
+                    this.config.zoom?.min
+                : Infinity;
+            this.zoom.scaleExtent([maxZoom, minZoom]);
+        }
+        if (this.config?.zoom?.zoomBehavior === ZoomBehaviorType.wheel) {
+            this.runWheelTranslate();
+        }
+    }
+    zoomed = (event) => {
+        if (event.sourceEvent && (this.elementRef.nativeElement === event.sourceEvent.target || this.elementRef.nativeElement.contains(event.sourceEvent.target))) {
+            if (Object.keys(event.sourceEvent).length !== 0) {
+                const origin = this.axis.scale.copy().domain(this.axis.originDomain);
+                if (this.axis.options.scaleType.type === ScaleType.band) {
+                    return;
+                }
+                const domain = this.axis.orientation === AxisOrientation.y
+                    ? event.transform.rescaleY(origin).domain()
+                    : event.transform.rescaleX(origin).domain();
+                if (domain[0] === null || domain[0] === undefined
+                    || domain[1] === null || domain[1] === undefined
+                    || Math.abs(domain[0] - domain[1]) < 0.000001) {
+                    return;
+                }
+                const message = new ZoomMessage({
+                    eventType: event.type,
+                    axis: {
+                        index: this.axis.index,
+                        orientation: this.axis.orientation,
+                    },
+                    element: this.elementRef,
+                    domain,
+                    chartId: this.config.id
+                });
+                this.zoomService.fireZoom(message);
+                this.zoomService.broadcastZoom(message);
+            }
+            this.currentTransform = event.transform;
+        }
+    };
+    runWheelTranslate() {
+        let type = 'start';
+        let wheeling;
+        // For touch events
+        this.zoom.on('start zoom end', this.zoomed);
+        this._element?.call(this.zoom);
+        this.zoom
+            .filter((event) => {
+            return (event.ctrlKey && event.type === 'wheel') ||
+                Boolean(window.TouchEvent && event.type !== 'wheel');
+        })
+            .wheelDelta((event) => {
+            const delta = this.config?.zoom.type === ZoomType.x
+                ? -event.deltaX
+                : -event.deltaY;
+            return delta * 0.002;
+        });
+        const emit = (type, event) => {
+            const origin = this.axis.scale.copy().domain(this.axis.originDomain);
+            let transform = zoomIdentity;
+            const delta = type === 'end'
+                ? 0
+                : this.axis.orientation === AxisOrientation.y
+                    ? event.deltaY
+                    : event.deltaX;
+            if (this.axis.orientation === AxisOrientation.y) {
+                transform = transform.translate(0, this.currentTransform.y - delta / 2);
+            }
+            if (this.axis.orientation === AxisOrientation.x) {
+                transform = transform.translate(this.currentTransform.x - delta / 2, 0);
+            }
+            transform = transform.scale(this.currentTransform.k);
+            let domain = this.axis.orientation === AxisOrientation.y
+                ? transform.rescaleY(origin).domain()
+                : transform.rescaleX(origin).domain();
+            const extent = this.axis.options?.inverted ? domain : [...domain].reverse();
+            if (extent[0] <= this.config.zoom?.minTranslate) {
+                return;
+            }
+            if (extent[1] >= this.config.zoom?.maxTranslate) {
+                return;
+            }
+            const message = new ZoomMessage({
+                eventType: type,
+                element: this.elementRef,
+                axis: {
+                    index: this.axis.index,
+                    orientation: this.axis.orientation
+                },
+                domain,
+                chartId: this.config.id,
+            });
+            this._element?.call(this.zoom.transform, transform);
+            this.zoomService.fireZoom(message);
+            this.zoomService.broadcastZoom(message);
+            this.currentTransform = transform;
+        };
+        this._element.on('wheel', (event) => {
+            event.preventDefault();
+            if (event.ctrlKey) {
+                return;
+            }
+            this.zone.runOutsideAngular(() => {
+                clearTimeout(wheeling);
+                emit(type, event);
+                type = 'zoom';
+                wheeling = setTimeout(() => {
+                    emit('end', event);
+                    type = 'start';
+                }, 50);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ZoomableDirective, deps: [{ token: i0.ElementRef }, { token: i1.ZoomService }, { token: i2.ChartService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: ZoomableDirective, selector: "[tetaZoomable]", inputs: { config: "config", axis: "axis", size: "size" }, host: { listeners: { "mouseenter": "mouseenter()", "mouseleave": "mouseleave()" }, properties: { "class.zoomable": "this.zoomable", "class.crosshair": "this.crosshair" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ZoomableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaZoomable]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ZoomService }, { type: i2.ChartService }, { type: i0.NgZone }]; }, propDecorators: { config: [{
+                type: Input
+            }], axis: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], zoomable: [{
+                type: HostBinding,
+                args: ['class.zoomable']
+            }], crosshair: [{
+                type: HostBinding,
+                args: ['class.crosshair']
+            }], mouseenter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], mouseleave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zoomable.directive.js","sourceRoot":"","sources":["../../../../src/chart/directives/zoomable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  HostBinding,\n  HostListener,\n  Input,\n  NgZone,\n  OnDestroy,\n} from '@angular/core';\nimport {ZoomService} from '../service/zoom.service';\nimport {IChartConfig} from '../model/i-chart-config';\nimport {Axis} from '../core/axis/axis';\nimport * as d3 from 'd3';\nimport {D3ZoomEvent, ZoomBehavior, zoomIdentity} from 'd3';\nimport {ZoomType} from '../model/enum/zoom-type';\nimport {AxisOrientation} from '../model/enum/axis-orientation';\nimport {ZoomMessage,} from '../model/i-broadcast-message';\nimport {takeWhile} from 'rxjs';\nimport {ChartService} from '../service/chart.service';\nimport {ZoomBehaviorType} from '../model/enum/zoom-behavior-type';\nimport {ScaleType} from \"../model/enum/scale-type\";\n\n@Directive({\n  selector: '[tetaZoomable]',\n})\nexport class ZoomableDirective implements OnDestroy, AfterViewInit {\n  @Input() config: IChartConfig;\n  @Input() axis: Axis;\n  @Input() size: DOMRect;\n\n  @HostBinding('class.zoomable') private zoomable = false;\n  @HostBinding('class.crosshair') private crosshair = false;\n\n  private _element: d3.Selection<SVGElement, any, any, any>;\n  private zoom: ZoomBehavior<any, any>;\n  private alive = true;\n\n  @HostListener('mouseenter')\n  mouseenter() {\n    this.zoom?.on('start zoom end', this.zoomed);\n    this._element?.call(this.zoom).on('dblclick.zoom', null);\n    // Run wheel event listener\n    if (this.config?.zoom?.zoomBehavior === ZoomBehaviorType.wheel) {\n      this.runWheelTranslate();\n    }\n  }\n\n  @HostListener('mouseleave')\n  mouseleave() {\n    this.zoom?.on('start zoom end', null);\n    this._element?.on('wheel', null);\n  }\n\n  private currentTransform = zoomIdentity;\n\n  constructor(\n    private elementRef: ElementRef,\n    private zoomService: ZoomService,\n    private chartService: ChartService,\n    private zone: NgZone\n  ) {\n  }\n\n  ngOnInit() {\n    if (this.axis?.options?.zoom || this.config?.zoom?.enable) {\n      this.zoomable = this.config?.zoom?.zoomBehavior === ZoomBehaviorType.move && !this.config?.tooltip?.showCrosshair;\n      this.crosshair = this.config?.tooltip?.showCrosshair;\n    }\n  }\n\n  ngAfterViewInit() {\n    this.initZoomListeners();\n    this.initZoomSync();\n  }\n\n  ngOnDestroy(): void {\n    this.zoom?.on('start zoom end', null);\n    this._element?.on('wheel', null);\n    this.alive = false;\n  }\n\n  private initZoomSync() {\n    this.zoomService.zoomed.pipe(\n      takeWhile(() => this.alive)\n    ).subscribe((zoomed: ZoomMessage) => {\n      if (this._element && this.elementRef !== zoomed?.element\n        && zoomed?.axis?.index === this.axis.index\n        && zoomed?.axis?.orientation === this.axis.orientation) {\n        const scale = this.axis.scale.copy().domain(this.axis.originDomain);\n        let transform;\n        if (zoomed.domain === null) {\n          transform = zoomIdentity;\n        } else {\n          transform =\n            this.zoomService.getD3Transform(zoomed.domain, this.axis.originDomain, scale, this.axis.orientation, this.axis.options.inverted);\n        }\n        this._element.call(this.zoom.transform, transform);\n        this.currentTransform = transform;\n      }\n    });\n  }\n\n  private initZoomListeners() {\n    const enable =\n      (this.axis?.options?.zoom && this.axis?.options.visible !== false) ||\n      this.config?.zoom?.enable;\n\n    if (!enable) {\n      return;\n    }\n\n    this._element = d3.select(this.elementRef.nativeElement);\n    this.zoom = d3.zoom().extent([\n      [0, 0],\n      [this.size.width, this.size.height],\n    ]);\n\n    const min = this.config?.zoom?.minTranslate != null\n      ? this.axis.scale(this.config?.zoom?.minTranslate)\n      : -Infinity;\n    const max = (this.config?.zoom?.maxTranslate != null\n      ? this.axis.scale(this.config?.zoom?.maxTranslate)\n      : Infinity);\n    if (this.axis.orientation === AxisOrientation.x && this.config.zoom.type === ZoomType.x) {\n      this.zoom.translateExtent([\n        [Math.min(min, max), -Infinity],\n        [Math.max(min, max), Infinity],\n      ]);\n    }\n\n    if (this.axis.orientation === AxisOrientation.y && this.config.zoom.type === ZoomType.y) {\n      this.zoom.translateExtent([\n        [-Infinity, Math.min(min, max)],\n        [Infinity, Math.max(min, max)],\n      ]);\n    }\n\n    if (this.config.zoom?.wheelDelta) {\n      this.zoom.wheelDelta(this.config.zoom?.wheelDelta);\n    }\n\n    if (this.config?.zoom?.wheelFilter) {\n      this.zoom.filter(this.config?.zoom?.wheelFilter)\n    }\n\n    if (this.axis.options.scaleType.type !== ScaleType.band) {\n      const extremes = this.axis.extremes as number[];\n      const maxZoom = this.config.zoom?.max\n        ? (extremes[1] - extremes[0]) /\n        this.config.zoom?.max\n        : this.config.zoom?.limitZoomByData\n          ? 1\n          : 0;\n\n      const minZoom = this.config.zoom?.min\n        ? (extremes[1] - extremes[0]) /\n        this.config.zoom?.min\n        : Infinity;\n\n      this.zoom.scaleExtent([maxZoom, minZoom]);\n    }\n\n    if (this.config?.zoom?.zoomBehavior === ZoomBehaviorType.wheel) {\n      this.runWheelTranslate();\n    }\n  }\n\n  zoomed = (event: D3ZoomEvent<any, any>) => {\n    if (event.sourceEvent && (this.elementRef.nativeElement === event.sourceEvent.target || this.elementRef.nativeElement.contains(event.sourceEvent.target))) {\n      if (Object.keys(event.sourceEvent).length !== 0) {\n        const origin = this.axis.scale.copy().domain(this.axis.originDomain);\n        if (this.axis.options.scaleType.type === ScaleType.band) {\n          return\n        }\n\n        const domain =\n          this.axis.orientation === AxisOrientation.y\n            ? event.transform.rescaleY(origin).domain()\n            : event.transform.rescaleX(origin).domain();\n        if (domain[0] === null || domain[0] === undefined\n          || domain[1] === null || domain[1] === undefined\n          || Math.abs(domain[0] - domain[1]) < 0.000001) {\n          return;\n        }\n        const message = new ZoomMessage({\n          eventType: event.type,\n          axis: {\n            index: this.axis.index,\n            orientation: this.axis.orientation,\n          },\n          element: this.elementRef,\n          domain,\n          chartId: this.config.id\n        });\n        this.zoomService.fireZoom(message);\n        this.zoomService.broadcastZoom(message);\n      }\n      this.currentTransform = event.transform;\n    }\n  };\n\n  private runWheelTranslate() {\n    let type: 'start' | 'zoom' | 'end' = 'start';\n    let wheeling;\n\n    // For touch events\n    this.zoom.on('start zoom end', this.zoomed);\n    this._element?.call(this.zoom);\n\n    this.zoom\n      .filter(\n        (event) => {\n          return (event.ctrlKey && event.type === 'wheel') ||\n            Boolean(window.TouchEvent && event.type !== 'wheel');\n        }\n      )\n      .wheelDelta((event) => {\n        const delta =\n          this.config?.zoom.type === ZoomType.x\n            ? -event.deltaX\n            : -event.deltaY;\n        return delta * 0.002;\n      });\n\n    const emit = (type: string, event: WheelEvent) => {\n      const origin = this.axis.scale.copy().domain(this.axis.originDomain);\n      let transform = zoomIdentity;\n      const delta =\n        type === 'end'\n          ? 0\n          : this.axis.orientation === AxisOrientation.y\n            ? event.deltaY\n            : event.deltaX;\n\n      if (this.axis.orientation === AxisOrientation.y) {\n        transform = transform.translate(\n          0,\n          this.currentTransform.y - delta / 2\n        );\n      }\n\n      if (this.axis.orientation === AxisOrientation.x) {\n        transform = transform.translate(\n          this.currentTransform.x - delta / 2,\n          0\n        );\n      }\n\n      transform = transform.scale(this.currentTransform.k);\n\n      let domain =\n        this.axis.orientation === AxisOrientation.y\n          ? transform.rescaleY(origin).domain()\n          : transform.rescaleX(origin).domain();\n\n      const extent = this.axis.options?.inverted ? domain : [...domain].reverse();\n\n      if (extent[0] <= this.config.zoom?.minTranslate) {\n        return;\n      }\n\n      if (extent[1] >= this.config.zoom?.maxTranslate) {\n        return;\n      }\n\n\n\n      const message = new ZoomMessage({\n        eventType: type,\n        element: this.elementRef,\n        axis: {\n          index: this.axis.index,\n          orientation: this.axis.orientation\n        },\n        domain,\n        chartId: this.config.id,\n      });\n\n      this._element?.call(this.zoom.transform, transform);\n      this.zoomService.fireZoom(message);\n      this.zoomService.broadcastZoom(message);\n      this.currentTransform = transform;\n    };\n\n    this._element.on('wheel', (event: WheelEvent) => {\n      event.preventDefault();\n\n      if (event.ctrlKey) {\n        return;\n      }\n      this.zone.runOutsideAngular(() => {\n        clearTimeout(wheeling);\n        emit(type, event);\n        type = 'zoom';\n        wheeling = setTimeout(() => {\n          emit('end', event);\n          type = 'start';\n        }, 50);\n      });\n    });\n  }\n}\n"]}

package/esm2022/chart/legend/legend.component.mjs

@@ -0,0 +1,38 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, } from '@angular/core';
+import { SeriesType } from '../model/enum/series-type';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/chart.service";
+import * as i2 from "@angular/common";
+export class LegendComponent {
+    chartService;
+    sizeMapping = new Map()
+        .set(SeriesType.line, 2)
+        .set(SeriesType.scatter, 2)
+        .set(SeriesType.bar, 12)
+        .set(SeriesType.area, 2)
+        .set(SeriesType.block, 12)
+        .set(SeriesType.blockArea, 2);
+    series;
+    classLegend = true;
+    constructor(chartService) {
+        this.chartService = chartService;
+    }
+    getHeight(serie) {
+        return this.sizeMapping.get(serie.type ?? SeriesType.line);
+    }
+    click(serie) {
+        this.chartService.toggleVisibilitySeries([serie.id]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: LegendComponent, deps: [{ token: i1.ChartService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: LegendComponent, selector: "teta-legend", inputs: { series: "series" }, host: { properties: { "class.padding-bottom-4": "this.classLegend" } }, ngImport: i0, template: "<ng-container *ngFor=\"let serie of series\" class=\"padding-bottom-4\">\n  <div *ngIf=\"serie?.showInLegend !== false\">\n    <div class=\"legend-item cursor-pointer\" (click)=\"click(serie)\">\n      <div class=\"legend-icon-form\"\n           [style.height.px]=\"getHeight(serie)\"\n           [style.border-top-color]=\"serie.visible ? serie.color : 'var(--color-text-30)'\"\n           [style.border-top-style]=\"serie.style?.strokeDasharray ? 'dashed' : 'solid'\"\n           [style.border-width.px]=\"serie.style?.strokeDasharray ? 1 : 2\"></div>\n      <div class=\"legend-label\" style=\"user-select: none\" [style.text-decoration]=\"serie.visible ? 'none' : 'line-through'\">{{ serie.name }}</div>\n    </div>\n  </div>\n</ng-container>\n", styles: [":host{display:flex;grid-gap:8px;flex-wrap:wrap;align-items:center;justify-content:space-evenly}:host .legend-item{display:flex;align-items:center}:host .legend-icon-form{width:12px}:host .legend-label{margin-left:5px}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: LegendComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-legend', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngFor=\"let serie of series\" class=\"padding-bottom-4\">\n  <div *ngIf=\"serie?.showInLegend !== false\">\n    <div class=\"legend-item cursor-pointer\" (click)=\"click(serie)\">\n      <div class=\"legend-icon-form\"\n           [style.height.px]=\"getHeight(serie)\"\n           [style.border-top-color]=\"serie.visible ? serie.color : 'var(--color-text-30)'\"\n           [style.border-top-style]=\"serie.style?.strokeDasharray ? 'dashed' : 'solid'\"\n           [style.border-width.px]=\"serie.style?.strokeDasharray ? 1 : 2\"></div>\n      <div class=\"legend-label\" style=\"user-select: none\" [style.text-decoration]=\"serie.visible ? 'none' : 'line-through'\">{{ serie.name }}</div>\n    </div>\n  </div>\n</ng-container>\n", styles: [":host{display:flex;grid-gap:8px;flex-wrap:wrap;align-items:center;justify-content:space-evenly}:host .legend-item{display:flex;align-items:center}:host .legend-icon-form{width:12px}:host .legend-label{margin-left:5px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }]; }, propDecorators: { series: [{
+                type: Input
+            }], classLegend: [{
+                type: HostBinding,
+                args: ['class.padding-bottom-4']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/chart/model/chart-bounds.mjs

@@ -1,13 +1,13 @@
 export class ChartBounds {
+    top = 0;
+    right = 0;
+    bottom = 0;
+    left = 0;
     constructor(options) {
-        this.top = 0;
-        this.right = 0;
-        this.bottom = 0;
-        this.left = 0;
         this.top = options?.top || 0;
         this.right = options?.right || 0;
         this.bottom = options?.bottom || 0;
         this.left = options?.left || 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnQtYm91bmRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NoYXJ0L21vZGVsL2NoYXJ0LWJvdW5kcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sV0FBVztJQU10QixZQUFZLE9BS1g7UUFWRCxRQUFHLEdBQVksQ0FBQyxDQUFDO1FBQ2pCLFVBQUssR0FBWSxDQUFDLENBQUM7UUFDbkIsV0FBTSxHQUFZLENBQUMsQ0FBQztRQUNwQixTQUFJLEdBQVksQ0FBQyxDQUFDO1FBUWhCLElBQUksQ0FBQyxHQUFHLEdBQUcsT0FBTyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUM7UUFDN0IsSUFBSSxDQUFDLEtBQUssR0FBRyxPQUFPLEVBQUUsS0FBSyxJQUFJLENBQUMsQ0FBQztRQUNqQyxJQUFJLENBQUMsTUFBTSxHQUFHLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQyxDQUFDO1FBQ25DLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxFQUFFLElBQUksSUFBSSxDQUFDLENBQUM7SUFDakMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIENoYXJ0Qm91bmRzIHtcbiAgdG9wPzogbnVtYmVyID0gMDtcbiAgcmlnaHQ/OiBudW1iZXIgPSAwO1xuICBib3R0b20/OiBudW1iZXIgPSAwO1xuICBsZWZ0PzogbnVtYmVyID0gMDtcblxuICBjb25zdHJ1Y3RvcihvcHRpb25zPzoge1xuICAgIHRvcD86IG51bWJlcjtcbiAgICByaWdodD86IG51bWJlcjtcbiAgICBib3R0b20/OiBudW1iZXI7XG4gICAgbGVmdD86IG51bWJlcjtcbiAgfSkge1xuICAgIHRoaXMudG9wID0gb3B0aW9ucz8udG9wIHx8IDA7XG4gICAgdGhpcy5yaWdodCA9IG9wdGlvbnM/LnJpZ2h0IHx8IDA7XG4gICAgdGhpcy5ib3R0b20gPSBvcHRpb25zPy5ib3R0b20gfHwgMDtcbiAgICB0aGlzLmxlZnQgPSBvcHRpb25zPy5sZWZ0IHx8IDA7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnQtYm91bmRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NoYXJ0L21vZGVsL2NoYXJ0LWJvdW5kcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sV0FBVztJQUN0QixHQUFHLEdBQVksQ0FBQyxDQUFDO0lBQ2pCLEtBQUssR0FBWSxDQUFDLENBQUM7SUFDbkIsTUFBTSxHQUFZLENBQUMsQ0FBQztJQUNwQixJQUFJLEdBQVksQ0FBQyxDQUFDO0lBRWxCLFlBQVksT0FLWDtRQUNDLElBQUksQ0FBQyxHQUFHLEdBQUcsT0FBTyxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUM7UUFDN0IsSUFBSSxDQUFDLEtBQUssR0FBRyxPQUFPLEVBQUUsS0FBSyxJQUFJLENBQUMsQ0FBQztRQUNqQyxJQUFJLENBQUMsTUFBTSxHQUFHLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQyxDQUFDO1FBQ25DLElBQUksQ0FBQyxJQUFJLEdBQUcsT0FBTyxFQUFFLElBQUksSUFBSSxDQUFDLENBQUM7SUFDakMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIENoYXJ0Qm91bmRzIHtcbiAgdG9wPzogbnVtYmVyID0gMDtcbiAgcmlnaHQ/OiBudW1iZXIgPSAwO1xuICBib3R0b20/OiBudW1iZXIgPSAwO1xuICBsZWZ0PzogbnVtYmVyID0gMDtcblxuICBjb25zdHJ1Y3RvcihvcHRpb25zPzoge1xuICAgIHRvcD86IG51bWJlcjtcbiAgICByaWdodD86IG51bWJlcjtcbiAgICBib3R0b20/OiBudW1iZXI7XG4gICAgbGVmdD86IG51bWJlcjtcbiAgfSkge1xuICAgIHRoaXMudG9wID0gb3B0aW9ucz8udG9wIHx8IDA7XG4gICAgdGhpcy5yaWdodCA9IG9wdGlvbnM/LnJpZ2h0IHx8IDA7XG4gICAgdGhpcy5ib3R0b20gPSBvcHRpb25zPy5ib3R0b20gfHwgMDtcbiAgICB0aGlzLmxlZnQgPSBvcHRpb25zPy5sZWZ0IHx8IDA7XG4gIH1cbn1cbiJdfQ==

package/esm2022/chart/model/i-broadcast-message.mjs

@@ -0,0 +1,27 @@
+export class ZoomMessage {
+    eventType;
+    element;
+    axis;
+    domain;
+    chartId;
+    style;
+    constructor(options) {
+        this.eventType = options?.eventType;
+        this.element = options?.element;
+        this.axis = options?.axis;
+        this.domain = options.domain;
+        this.chartId = options?.chartId;
+        this.style = options?.style;
+    }
+}
+export class BrushMessage {
+    chartId;
+    selection;
+    mode;
+    constructor(options) {
+        this.chartId = options?.chartId;
+        this.selection = options?.selection;
+        this.mode = options?.mode;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/model/plot-band.mjs

@@ -0,0 +1,28 @@
+export class PlotBand {
+    id;
+    name;
+    from;
+    to;
+    label;
+    showGrabbers;
+    draggable;
+    resizable;
+    min;
+    max;
+    style;
+    constructor(options) {
+        this.id = options?.id;
+        this.name = options?.name;
+        this.from = options?.from;
+        this.to = options?.to;
+        this.label = options?.label;
+        this.showGrabbers =
+            options?.showGrabbers != null ? options.showGrabbers : true;
+        this.draggable = options?.draggable != null ? options?.draggable : false;
+        this.resizable = options?.resizable != null ? options?.resizable : true;
+        this.min = options?.min;
+        this.max = options?.max;
+        this.style = options?.style;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/model/plot-line.mjs

@@ -0,0 +1,21 @@
+export class PlotLine {
+    id;
+    name;
+    value;
+    label;
+    min;
+    max;
+    draggable;
+    style;
+    constructor(options) {
+        this.id = options?.id;
+        this.name = options?.name;
+        this.value = options?.value;
+        this.label = options?.label;
+        this.min = options?.min;
+        this.max = options?.max;
+        this.draggable = options?.draggable;
+        this.style = options?.style;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxvdC1saW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NoYXJ0L21vZGVsL3Bsb3QtbGluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sUUFBUTtJQUNuQixFQUFFLENBQW1CO0lBQ3JCLElBQUksQ0FBVTtJQUNkLEtBQUssQ0FBUztJQUNkLEtBQUssQ0FBVTtJQUNmLEdBQUcsQ0FBVTtJQUNiLEdBQUcsQ0FBVTtJQUNiLFNBQVMsQ0FBVztJQUNwQixLQUFLLENBQWlCO0lBRXRCLFlBQVksT0FTWDtRQUNDLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxFQUFFLEVBQUUsQ0FBQztRQUN0QixJQUFJLENBQUMsSUFBSSxHQUFHLE9BQU8sRUFBRSxJQUFJLENBQUM7UUFDMUIsSUFBSSxDQUFDLEtBQUssR0FBRyxPQUFPLEVBQUUsS0FBSyxDQUFDO1FBQzVCLElBQUksQ0FBQyxLQUFLLEdBQUcsT0FBTyxFQUFFLEtBQUssQ0FBQztRQUM1QixJQUFJLENBQUMsR0FBRyxHQUFHLE9BQU8sRUFBRSxHQUFHLENBQUM7UUFDeEIsSUFBSSxDQUFDLEdBQUcsR0FBRyxPQUFPLEVBQUUsR0FBRyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxFQUFFLFNBQVMsQ0FBQztRQUNwQyxJQUFJLENBQUMsS0FBSyxHQUFHLE9BQU8sRUFBRSxLQUFLLENBQUM7SUFDOUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtTdmdBdHRyaWJ1dGVzfSBmcm9tICcuL3N2Zy1hdHRyaWJ1dGVzJztcblxuZXhwb3J0IGNsYXNzIFBsb3RMaW5lIHtcbiAgaWQ/OiBudW1iZXIgfCBzdHJpbmc7XG4gIG5hbWU/OiBzdHJpbmc7XG4gIHZhbHVlOiBudW1iZXI7XG4gIGxhYmVsPzogc3RyaW5nO1xuICBtaW4/OiBudW1iZXI7XG4gIG1heD86IG51bWJlcjtcbiAgZHJhZ2dhYmxlPzogYm9vbGVhbjtcbiAgc3R5bGU/OiBTdmdBdHRyaWJ1dGVzO1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM/OiB7XG4gICAgaWQ/OiBudW1iZXIgfCBzdHJpbmc7XG4gICAgbmFtZT86IHN0cmluZztcbiAgICB2YWx1ZTogbnVtYmVyO1xuICAgIGxhYmVsPzogc3RyaW5nO1xuICAgIG1pbj86IG51bWJlcjtcbiAgICBtYXg/OiBudW1iZXI7XG4gICAgZHJhZ2dhYmxlPzogYm9vbGVhbjtcbiAgICBzdHlsZT86IFN2Z0F0dHJpYnV0ZXM7XG4gIH0pIHtcbiAgICB0aGlzLmlkID0gb3B0aW9ucz8uaWQ7XG4gICAgdGhpcy5uYW1lID0gb3B0aW9ucz8ubmFtZTtcbiAgICB0aGlzLnZhbHVlID0gb3B0aW9ucz8udmFsdWU7XG4gICAgdGhpcy5sYWJlbCA9IG9wdGlvbnM/LmxhYmVsO1xuICAgIHRoaXMubWluID0gb3B0aW9ucz8ubWluO1xuICAgIHRoaXMubWF4ID0gb3B0aW9ucz8ubWF4O1xuICAgIHRoaXMuZHJhZ2dhYmxlID0gb3B0aW9ucz8uZHJhZ2dhYmxlO1xuICAgIHRoaXMuc3R5bGUgPSBvcHRpb25zPy5zdHlsZTtcbiAgfVxufVxuIl19