@tetacom/svg-charts 1.0.2 → 1.1.3

package/{dist/chart/model/plotline.d.ts → chart/model/plot-line.d.ts}

@@ -1,6 +1,7 @@
 import { SvgAttributes } from './svg-attributes';
 export declare class PlotLine {
     id?: number | string;
+    name?: string;
     value: number;
     label?: string;
     min?: number;
@@ -8,7 +9,8 @@ export declare class PlotLine {
     draggable?: boolean;
     style?: SvgAttributes;
     constructor(options?: {
-        id?: number;
+        id?: number | string;
+        name?: string;
         value: number;
         label?: string;
         min?: number;

package/{dist/chart → chart}/model/public-api.d.ts

@@ -7,7 +7,7 @@ export * from './i-chart-config';
 export * from './i-chart-event';
 export * from './i-point-move';
 export * from './marker-options';
-export * from './plotband';
-export * from './plotline';
+export * from './plot-band';
+export * from './plot-line';
 export * from './series';
 export * from './svg-attributes';

package/{dist/chart → chart}/service/brush.service.d.ts

@@ -2,16 +2,13 @@ import { ElementRef } from '@angular/core';
 import { Subscription } from 'rxjs';
 import { BroadcastService } from './broadcast.service';
 import { IChartConfig } from '../model/i-chart-config';
-import { ScaleService } from './scale.service';
 import * as i0 from "@angular/core";
 export declare class BrushService {
     private broadcastService;
-    private scaleService;
     broadcastSubscribtion: Subscription;
     private brushMap;
-    private scaleMap;
-    constructor(broadcastService: BroadcastService, scaleService: ScaleService);
-    applyBrush(svgElement: ElementRef, config: IChartConfig, size: DOMRect): void;
+    constructor(broadcastService: BroadcastService);
+    applyBrush(svgElement: ElementRef, config: IChartConfig, brushScale: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BrushService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BrushService>;
 }

package/{dist/chart → chart}/service/chart.service.d.ts

@@ -1,38 +1,37 @@
 import { IChartConfig } from '../model/i-chart-config';
-import { AxesService } from './axes.service';
 import { Observable } from 'rxjs';
-import { ScaleService } from './scale.service';
 import { IChartEvent } from '../model/i-chart-event';
 import { IDisplayTooltip } from '../model/i-display-tooltip';
-import { Plotband } from '../model/plotband';
-import { PlotLine } from '../model/plotline';
+import { PlotBand } from '../model/plot-band';
+import { PlotLine } from '../model/plot-line';
 import { IPointMove } from '../model/i-point-move';
 import * as i0 from "@angular/core";
 export declare class ChartService {
-    private axesService;
-    private scaleService;
+    config: Observable<IChartConfig>;
     size: Observable<DOMRect>;
-    pointerMove: Observable<any>;
+    pointerMove: Observable<PointerEvent>;
     tooltips: Observable<IDisplayTooltip>;
-    plotbandMove: Observable<IChartEvent<Plotband>>;
-    plotlineMove: Observable<IChartEvent<PlotLine>>;
+    plotBandEvent: Observable<IChartEvent<PlotBand>>;
+    plotLineMove: Observable<IChartEvent<PlotLine>>;
+    plotBandClick: Observable<IChartEvent<PlotBand>>;
     pointMove: Observable<IChartEvent<IPointMove>>;
+    private config$;
     private size$;
     private pointerMove$;
     private tooltips$;
-    private plotbandMove$;
-    private plotlineMove$;
+    private plotBandEvent$;
+    private plotLineMove$;
     private pointMove$;
-    private _config;
-    constructor(axesService: AxesService, scaleService: ScaleService);
-    init(config: IChartConfig): void;
+    constructor();
+    setConfig(config: IChartConfig): void;
     setSize(size: DOMRect): void;
-    setPointerMove(event: any): void;
+    setPointerMove(event: PointerEvent): void;
     setTooltip(tooltip: IDisplayTooltip): void;
-    emitPlotband(event: IChartEvent<Plotband>): void;
+    emitPlotband(event: IChartEvent<PlotBand>): void;
     emitPlotline(event: IChartEvent<PlotLine>): void;
     emitPoint(event: IChartEvent<IPointMove>): void;
-    get config(): IChartConfig;
+    private setDefaults;
+    private setpreparationData;
     static ɵfac: i0.ɵɵFactoryDeclaration<ChartService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ChartService>;
 }

package/chart/service/scale.service.d.ts

@@ -0,0 +1,19 @@
+import { Axis } from '../core/axis/axis';
+import { ChartService } from './chart.service';
+import { Observable } from 'rxjs';
+import { ZoomService } from './zoom.service';
+import * as i0 from "@angular/core";
+export declare class ScaleService {
+    private chartService;
+    private zoomService;
+    yAxisMap: Observable<Map<number, Axis>>;
+    xAxisMap: Observable<Map<number, Axis>>;
+    yScaleMap: Observable<Map<number, any>>;
+    xScaleMap: Observable<Map<number, any>>;
+    private transformCacheX;
+    private transformCacheY;
+    private scaleMapping;
+    constructor(chartService: ChartService, zoomService: ZoomService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScaleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScaleService>;
+}

package/{dist/chart → chart}/service/zoom.service.d.ts

@@ -1,25 +1,17 @@
 import { ElementRef } from '@angular/core';
-import { ScaleService } from './scale.service';
 import { Observable, Subscription } from 'rxjs';
 import { IChartConfig } from '../model/i-chart-config';
 import { BroadcastService } from './broadcast.service';
-import { ChartService } from './chart.service';
+import { Axis } from '../core/axis/axis';
+import { IChartEvent } from '../model/i-chart-event';
 import * as i0 from "@angular/core";
 export declare class ZoomService {
-    private scaleService;
     private broadcastService;
-    private chartService;
-    zoomed: Observable<any>;
+    broadcastSubscription: Subscription[];
+    zoomed: Observable<IChartEvent<Axis>>;
     private zoomed$;
-    broadcastSubscribtion: Subscription;
-    private x;
-    private y;
-    private zoom;
-    private svg;
-    private initialZoom;
-    constructor(scaleService: ScaleService, broadcastService: BroadcastService, chartService: ChartService);
-    applyZoom(svgElement: ElementRef, config: IChartConfig, size: DOMRect): void;
-    setZoom(transform: any): void;
+    constructor(broadcastService: BroadcastService);
+    applyZoom(svgElement: ElementRef, config: IChartConfig, size: DOMRect, axis?: Axis): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ZoomService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ZoomService>;
 }

package/esm2020/chart/base/series-base.component.mjs

@@ -0,0 +1,32 @@
+import { Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/chart.service";
+import * as i2 from "../service/scale.service";
+import * as i3 from "../service/zoom.service";
+export class SeriesBaseComponent {
+    constructor(svc, cdr, scaleService, zoomService, element) {
+        this.svc = svc;
+        this.cdr = cdr;
+        this.scaleService = scaleService;
+        this.zoomService = zoomService;
+        this.element = element;
+    }
+    ngOnInit() { }
+}
+SeriesBaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: SeriesBaseComponent, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ScaleService }, { token: i3.ZoomService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+SeriesBaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: SeriesBaseComponent, selector: "ng-component", inputs: { config: "config", series: "series", size: "size", rect: "rect" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: SeriesBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i0.ChangeDetectorRef }, { type: i2.ScaleService }, { type: i3.ZoomService }, { type: i0.ElementRef }]; }, propDecorators: { config: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], rect: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/chart/chart/chart.component.mjs

@@ -0,0 +1,71 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { ChartService } from '../service/chart.service';
+import { ZoomService } from '../service/zoom.service';
+import { ScaleService } from '../service/scale.service';
+import { BrushService } from '../service/brush.service';
+import { map, takeWhile } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/chart.service";
+import * as i2 from "../service/zoom.service";
+import * as i3 from "../chart-container/chart-container.component";
+import * as i4 from "../legend/legend.component";
+import * as i5 from "@angular/common";
+export class ChartComponent {
+    constructor(_svc, _zoomService) {
+        this._svc = _svc;
+        this._zoomService = _zoomService;
+        this.plotBandsMove = new EventEmitter();
+        this.plotBandsClick = new EventEmitter();
+        this.plotLinesMove = new EventEmitter();
+        this.pointMove = new EventEmitter();
+        this._alive = true;
+        this.svcConfig = this._svc.config;
+        this.hasSeriesData = this.svcConfig.pipe(map((_) => _.series?.length > 0 && _.series?.some((_) => _.data?.length > 0)));
+    }
+    set config(config) {
+        this._svc.setConfig(config);
+    }
+    ngOnChanges(changes) { }
+    ngOnInit() {
+        this._svc.plotBandEvent
+            .pipe(takeWhile(() => this._alive))
+            .subscribe((_) => {
+            this.plotBandsMove.emit(_);
+        });
+        this._svc.plotLineMove.pipe(takeWhile(() => this._alive)).subscribe((_) => {
+            this.plotLinesMove.emit(_);
+        });
+        this._svc.pointMove.pipe(takeWhile(() => this._alive)).subscribe((_) => {
+            this.pointMove.emit(_);
+        });
+        this._svc.plotBandClick
+            .pipe(takeWhile(() => this._alive))
+            .subscribe((_) => {
+            this.plotBandsClick.emit(_);
+        });
+    }
+    ngAfterViewInit() { }
+    ngOnDestroy() {
+        this._alive = false;
+        this._zoomService.broadcastSubscription?.forEach((sub) => {
+            sub.unsubscribe();
+        });
+    }
+}
+ChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartComponent, deps: [{ token: i1.ChartService }, { token: i2.ZoomService }], target: i0.ɵɵFactoryTarget.Component });
+ChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: ChartComponent, selector: "teta-svg-chart", inputs: { config: "config" }, outputs: { plotBandsMove: "plotBandsMove", plotBandsClick: "plotBandsClick", plotLinesMove: "plotLinesMove", pointMove: "pointMove" }, providers: [ChartService, ZoomService, ScaleService, BrushService], usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"{\n  hasSeriesData: hasSeriesData | async,\n  svcConfig: svcConfig | async\n} as data\">\n  <ng-container *ngIf=\"data.hasSeriesData === true else noData\">\n    <div class=\"column column_auto\">\n      <teta-chart-container class=\"chart-container\"></teta-chart-container>\n    </div>\n    <teta-legend *ngIf=\"data.svcConfig.legend?.enable === true\" [series]=\"data.svcConfig.series\"></teta-legend>\n  </ng-container>\n</ng-container>\n<ng-template #noData>\n  <div class=\"column column_auto align-center justify-content-center\">\n    <span class=\"font-body-3 color-text-40\">\u0414\u0430\u043D\u043D\u044B\u0435 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442</span>\n  </div>\n</ng-template>\n", styles: [":host{position:relative;display:flex;flex-direction:column;height:100%;width:100%}\n"], components: [{ type: i3.ChartContainerComponent, selector: "teta-chart-container" }, { type: i4.LegendComponent, selector: "teta-legend", inputs: ["series"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i5.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-svg-chart', providers: [ChartService, ZoomService, ScaleService, BrushService], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"{\n  hasSeriesData: hasSeriesData | async,\n  svcConfig: svcConfig | async\n} as data\">\n  <ng-container *ngIf=\"data.hasSeriesData === true else noData\">\n    <div class=\"column column_auto\">\n      <teta-chart-container class=\"chart-container\"></teta-chart-container>\n    </div>\n    <teta-legend *ngIf=\"data.svcConfig.legend?.enable === true\" [series]=\"data.svcConfig.series\"></teta-legend>\n  </ng-container>\n</ng-container>\n<ng-template #noData>\n  <div class=\"column column_auto align-center justify-content-center\">\n    <span class=\"font-body-3 color-text-40\">\u0414\u0430\u043D\u043D\u044B\u0435 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442</span>\n  </div>\n</ng-template>\n", styles: [":host{position:relative;display:flex;flex-direction:column;height:100%;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i2.ZoomService }]; }, propDecorators: { plotBandsMove: [{
+                type: Output
+            }], plotBandsClick: [{
+                type: Output
+            }], plotLinesMove: [{
+                type: Output
+            }], pointMove: [{
+                type: Output
+            }], config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.component.js","sourceRoot":"","sources":["../../../../src/chart/chart/chart.component.ts","../../../../src/chart/chart/chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport { ChartService } from '../service/chart.service';\nimport { IChartConfig } from '../model/i-chart-config';\nimport { BasePoint } from '../model/base-point';\nimport { Series } from '../model/series';\nimport { ZoomService } from '../service/zoom.service';\nimport { ScaleService } from '../service/scale.service';\nimport { BrushService } from '../service/brush.service';\nimport { IChartEvent } from '../model/i-chart-event';\nimport { PlotLine } from '../model/plot-line';\nimport { PlotBand } from '../model/plot-band';\nimport { IPointMove } from '../model/i-point-move';\nimport { map, Observable, takeWhile, tap } from 'rxjs';\n\n@Component({\n  selector: 'teta-svg-chart',\n  templateUrl: './chart.component.html',\n  styleUrls: ['./chart.component.scss'],\n  providers: [ChartService, ZoomService, ScaleService, BrushService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ChartComponent implements OnInit, OnChanges, OnDestroy {\n  legendSeries: Array<Series<BasePoint>>;\n  hasSeriesData: Observable<boolean>;\n  svcConfig: Observable<IChartConfig>;\n  @Output()\n  plotBandsMove: EventEmitter<IChartEvent<PlotBand>> = new EventEmitter<\n    IChartEvent<PlotBand>\n  >();\n\n  @Output()\n  plotBandsClick: EventEmitter<IChartEvent<PlotBand>> = new EventEmitter<\n    IChartEvent<PlotBand>\n  >();\n\n  @Output()\n  plotLinesMove: EventEmitter<IChartEvent<PlotLine>> = new EventEmitter<\n    IChartEvent<PlotLine>\n  >();\n\n  @Output()\n  pointMove: EventEmitter<IChartEvent<IPointMove>> = new EventEmitter<\n    IChartEvent<IPointMove>\n  >();\n\n  @Input() set config(config: IChartConfig) {\n    this._svc.setConfig(config);\n  }\n\n  private _alive = true;\n\n  constructor(private _svc: ChartService, private _zoomService: ZoomService) {\n    this.svcConfig = this._svc.config;\n    this.hasSeriesData = this.svcConfig.pipe(\n      map(\n        (_) => _.series?.length > 0 && _.series?.some((_) => _.data?.length > 0)\n      )\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges) {}\n\n  ngOnInit(): void {\n    this._svc.plotBandEvent\n      .pipe(takeWhile(() => this._alive))\n      .subscribe((_) => {\n        this.plotBandsMove.emit(_);\n      });\n\n    this._svc.plotLineMove.pipe(takeWhile(() => this._alive)).subscribe((_) => {\n      this.plotLinesMove.emit(_);\n    });\n\n    this._svc.pointMove.pipe(takeWhile(() => this._alive)).subscribe((_) => {\n      this.pointMove.emit(_);\n    });\n\n    this._svc.plotBandClick\n      .pipe(takeWhile(() => this._alive))\n      .subscribe((_) => {\n        this.plotBandsClick.emit(_);\n      });\n  }\n\n  ngAfterViewInit() {}\n\n  ngOnDestroy() {\n    this._alive = false;\n    this._zoomService.broadcastSubscription?.forEach((sub) => {\n      sub.unsubscribe();\n    });\n  }\n}\n","<ng-container *ngIf=\"{\n  hasSeriesData: hasSeriesData | async,\n  svcConfig: svcConfig | async\n} as data\">\n  <ng-container *ngIf=\"data.hasSeriesData === true else noData\">\n    <div class=\"column column_auto\">\n      <teta-chart-container class=\"chart-container\"></teta-chart-container>\n    </div>\n    <teta-legend *ngIf=\"data.svcConfig.legend?.enable === true\" [series]=\"data.svcConfig.series\"></teta-legend>\n  </ng-container>\n</ng-container>\n<ng-template #noData>\n  <div class=\"column column_auto align-center justify-content-center\">\n    <span class=\"font-body-3 color-text-40\">Данные отсутствуют</span>\n  </div>\n</ng-template>\n"]}

package/esm2020/chart/chart-container/chart-container.component.mjs

@@ -0,0 +1,133 @@
+import { ChangeDetectionStrategy, Component, } from '@angular/core';
+import { combineLatest, map, tap } from 'rxjs';
+import { AxisOrientation } from '../model/enum/axis-orientation';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/chart.service";
+import * as i2 from "../service/scale.service";
+import * as i3 from "../service/zoom.service";
+import * as i4 from "./tooltip/tooltip.component";
+import * as i5 from "./y-axis/y-axis.component";
+import * as i6 from "./x-axis/x-axis.component";
+import * as i7 from "./gridlines/gridlines.component";
+import * as i8 from "./plotline/plotline.component";
+import * as i9 from "./plotband/plot-band.component";
+import * as i10 from "./series-host/series-host.component";
+import * as i11 from "@angular/common";
+import * as i12 from "../directives/zoomable.directive";
+import * as i13 from "../directives/brushable.directive";
+export class ChartContainerComponent {
+    constructor(_svc, _cdr, _scaleService, _zoomService, _elementRef) {
+        this._svc = _svc;
+        this._cdr = _cdr;
+        this._scaleService = _scaleService;
+        this._zoomService = _zoomService;
+        this._elementRef = _elementRef;
+        this.filterPositionMap = new Map()
+            .set(true, (axis) => (_) => _.options.opposite && _.options.visible && axis.index <= _.index)
+            .set(false, (axis) => (_) => _.options.opposite !== true &&
+            _.options.visible &&
+            _.index <= axis.index);
+        this.sumSize = (acc, curr) => acc + curr.selfSize;
+        this.config = this._svc.config;
+        this.size = this._svc.size;
+        this.yAxisMap = this._scaleService.yAxisMap;
+        this.xAxisMap = this._scaleService.xAxisMap;
+        this.yScaleMap = this._scaleService.yScaleMap;
+        this.xScaleMap = this._scaleService.xScaleMap;
+        this.brushScale = this._scaleService.xScaleMap.pipe(map((map) => {
+            return map.get(0);
+        }));
+        this.visibleRect = combineLatest([
+            this.size,
+            this.xAxisMap,
+            this.yAxisMap,
+            this._zoomService.zoomed,
+        ]).pipe(map((data) => {
+            const [size, x, y] = data;
+            const yAxesArray = [...y.values()];
+            const xAxesArray = [...x.values()];
+            const left = yAxesArray
+                .filter((_) => _.options.opposite !== true && _.options.visible)
+                .reduce(this.sumSize, 0);
+            const right = yAxesArray
+                .filter((_) => _.options.opposite && _.options.visible)
+                .reduce(this.sumSize, 0);
+            const bottom = xAxesArray
+                .filter((_) => _.options.opposite !== true && _.options.visible)
+                .reduce(this.sumSize, 0);
+            const top = xAxesArray
+                .filter((_) => _.options.opposite && _.options.visible)
+                .reduce(this.sumSize, 0);
+            return {
+                x: left,
+                y: top,
+                width: size.width - left - right + 1,
+                height: size.height - top - bottom + 1,
+            };
+        }), tap((_) => this._cdr.detectChanges()));
+    }
+    ngOnInit() {
+        this.uniqId = (Date.now() + Math.random()).toString(36);
+        this._observer = new ResizeObserver((entries) => {
+            if (!Array.isArray(entries) || !entries.length) {
+                return;
+            }
+            this._svc.setSize(entries[0].contentRect);
+        });
+        this._observer.observe(this._elementRef.nativeElement);
+    }
+    ngAfterViewInit() { }
+    getTranslate(axis, size) {
+        return combineLatest([this.xAxisMap, this.yAxisMap]).pipe(map((data) => {
+            const [x, y] = data;
+            const xAxesArray = [...x.values()];
+            const yAxesArray = [...y.values()];
+            const oppositeFilter = this.filterPositionMap.get(true);
+            const nonOppositeFilter = this.filterPositionMap.get(false);
+            const oppositeOffsetY = yAxesArray.filter(oppositeFilter(axis));
+            const nonOppositeOffsetY = yAxesArray.filter(nonOppositeFilter(axis));
+            const oppositeOffsetX = xAxesArray.filter(oppositeFilter(axis));
+            const nonOppositeOffsetX = xAxesArray.filter(nonOppositeFilter(axis));
+            const oppositeTranslateY = oppositeOffsetY.reduce((acc, curr) => acc + curr.selfSize, 0);
+            const nonOppisteTranslateY = nonOppositeOffsetY.reduce((acc, curr) => acc + curr.selfSize, 0);
+            const oppositeTranslateX = oppositeOffsetX.reduce((acc, curr) => acc + curr.selfSize, 0);
+            const nonOppisteTranslateX = nonOppositeOffsetX.reduce((acc, curr) => acc + curr.selfSize, 0);
+            const left = yAxesArray
+                .filter((_) => _.options.visible && _.options.opposite !== true)
+                .reduce((acc, curr) => acc + curr.selfSize, 0);
+            const top = xAxesArray
+                .filter((_) => _.options.visible && _.options.opposite === true)
+                .reduce((acc, curr) => acc + curr.selfSize, 0);
+            if (axis.orientation === AxisOrientation.x) {
+                return `translate(${left}, ${axis.options.opposite
+                    ? oppositeTranslateX
+                    : size.height - nonOppisteTranslateX})`;
+            }
+            if (axis.orientation === AxisOrientation.y) {
+                return `translate(${axis.options.opposite
+                    ? size.width - oppositeTranslateY
+                    : nonOppisteTranslateY}, ${top})`;
+            }
+            return 'translate(0, 0)';
+        }));
+    }
+    identify(index, item) {
+        return item.value.index;
+    }
+    mouseMove(event) {
+        this._svc.setPointerMove(event);
+    }
+    mouseLeave(event) {
+        this._svc.setPointerMove(event);
+    }
+    id() {
+        return this.uniqId;
+    }
+}
+ChartContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartContainerComponent, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ScaleService }, { token: i3.ZoomService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+ChartContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: ChartContainerComponent, selector: "teta-chart-container", ngImport: i0, template: "<ng-container *ngIf=\"{\n  size: size | async,\n  config: config | async,\n  xAxisMap: xAxisMap | async,\n  yAxisMap: yAxisMap | async,\n  xScaleMap: xScaleMap | async,\n  yScaleMap: yScaleMap | async\n} as data\">\n\n  <teta-tooltip *ngIf=\"data.config?.tooltip?.enable\" [size]=\"data.size\" [config]=\"data.config\"></teta-tooltip>\n  <svg height=\"100%\" width=\"100%\" class=\"position-absolute\">\n    <g class=\"y-axis-container\">\n      <ng-container *ngFor=\"let item of data.yAxisMap | keyvalue; trackBy: identify\">\n        <g\n          teta-y-axis\n          [axis]=\"item.value\"\n          [scale]=\"data.yScaleMap.get(item.key)\"\n          [size]=\"data.size\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></g>\n        <rect\n          tetaZoomable\n          fill-opacity=\"0\"\n          [axis]=\"item.value\"\n          [config]=\"config | async\"\n          [size]=\"data.size\"\n          [attr.x]=\"item.value.options.opposite ? 0 : -item.value.selfSize\"\n          [attr.y]=\"0\"\n          [attr.height]=\"data.size.width\"\n          [attr.width]=\"item.value.selfSize\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></rect>\n      </ng-container>\n    </g>\n    <g class=\"x-axis-container\">\n      <ng-container *ngFor=\"let item of data.xAxisMap | keyvalue; trackBy: identify\">\n        <g\n          teta-x-axis\n          [axis]=\"item.value\"\n          [scale]=\"data.xScaleMap.get(item.key)\"\n          [size]=\"data.size\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></g>\n\n        <rect\n          tetaZoomable\n          fill-opacity=\"0\"\n          [axis]=\"item.value\"\n          [config]=\"config | async\"\n          [size]=\"data.size\"\n          [attr.x]=\"0\"\n          [attr.y]=\"0\"\n          [attr.width]=\"data.size.width\"\n          [attr.height]=\"item.value.selfSize\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></rect>\n      </ng-container>\n    </g>\n  </svg>\n  <ng-container *ngIf=\"visibleRect | async as rect\">\n    <svg\n      tetaBrushable\n      tetaZoomable\n      [size]=\"data.size\"\n      [brushScale]=\"brushScale | async\"\n      [config]=\"config | async\"\n      [attr.width]=\"rect.width\"\n      [attr.height]=\"rect.height\"\n      [attr.transform]=\"'translate('+ rect.x +', '+ rect.y +')'\"\n      [attr.viewBox]=\"'0 0 ' + rect.width + ' ' + rect.height\"\n      (mouseleave)=\"mouseLeave($event)\"\n      (mousemove)=\"mouseMove($event)\">\n      <g>\n        <g>\n          <g class=\"gridlines\"\n             teta-gridlines\n             [size]=\"data.size\"\n             [xScaleMap]=\"data.xScaleMap\"\n             [yScaleMap]=\"data.yScaleMap\"></g>\n          <g class=\"x-axis-plotline-container\">\n            <ng-container *ngFor=\"let axis of data.config.xAxis; let i = index\">\n              <g teta-plot-line *ngFor=\"let plotLine of axis.plotLines\"\n                 [plotLine]=\"plotLine\"\n                 [scale]=\"data.xScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.xAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"y-axis-plotline-container\">\n            <ng-container *ngFor=\"let axis of data.config.yAxis; let i = index\">\n              <g teta-plot-line *ngFor=\"let plotLine of axis.plotLines\"\n                 [plotLine]=\"plotLine\"\n                 [scale]=\"data.yScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.yAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n\n          <g class=\"x-axis-plotband-container\">\n            <ng-container *ngFor=\"let axis of data.config.xAxis; let i = index\">\n              <g teta-plot-band *ngFor=\"let plotBand of axis.plotBands\"\n                 [plotBand]=\"plotBand\"\n                 [scale]=\"data.xScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.xAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"y-axis-plotband-container\">\n            <ng-container *ngFor=\"let axis of data.config.yAxis; let i = index\">\n              <g teta-plot-band *ngFor=\"let plotBand of axis.plotBands\"\n                 [plotBand]=\"plotBand\"\n                 [scale]=\"data.yScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.yAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"series-container\">\n            <g teta-series-host\n               *ngFor=\"let series of data.config.series\"\n               [config]=\"data.config\"\n               [series]=\"series\"\n               [size]=\"data.size\"></g>\n          </g>\n        </g>\n      </g>\n    </svg>\n  </ng-container>\n</ng-container>\n", styles: [":host{display:flex;flex-direction:column;flex-grow:1;min-width:0;min-height:0}:host .zoomable:hover{cursor:grab}:host .zoomable:active{cursor:grabbing}\n"], components: [{ type: i4.TooltipComponent, selector: "teta-tooltip", inputs: ["size", "config"] }, { type: i5.YAxisComponent, selector: "[teta-y-axis]", inputs: ["axis", "scale", "size"] }, { type: i6.XAxisComponent, selector: "[teta-x-axis]", inputs: ["axis", "scale", "size"] }, { type: i7.GridlinesComponent, selector: "[teta-gridlines]", inputs: ["size", "xScaleMap", "yScaleMap"] }, { type: i8.PlotlineComponent, selector: "[teta-plot-line]", inputs: ["plotLine", "size", "axis", "scale"] }, { type: i9.PlotBandComponent, selector: "[teta-plot-band]", inputs: ["plotBand", "axis", "scale", "size"] }, { type: i10.SeriesHostComponent, selector: "[teta-series-host]", inputs: ["config", "series", "size", "rect"] }], directives: [{ type: i11.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i11.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i12.ZoomableDirective, selector: "[tetaZoomable]", inputs: ["config", "axis", "size"] }, { type: i13.BrushableDirective, selector: "svg:svg[tetaBrushable]", inputs: ["config", "size", "brushScale"] }], pipes: { "async": i11.AsyncPipe, "keyvalue": i11.KeyValuePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-chart-container', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"{\n  size: size | async,\n  config: config | async,\n  xAxisMap: xAxisMap | async,\n  yAxisMap: yAxisMap | async,\n  xScaleMap: xScaleMap | async,\n  yScaleMap: yScaleMap | async\n} as data\">\n\n  <teta-tooltip *ngIf=\"data.config?.tooltip?.enable\" [size]=\"data.size\" [config]=\"data.config\"></teta-tooltip>\n  <svg height=\"100%\" width=\"100%\" class=\"position-absolute\">\n    <g class=\"y-axis-container\">\n      <ng-container *ngFor=\"let item of data.yAxisMap | keyvalue; trackBy: identify\">\n        <g\n          teta-y-axis\n          [axis]=\"item.value\"\n          [scale]=\"data.yScaleMap.get(item.key)\"\n          [size]=\"data.size\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></g>\n        <rect\n          tetaZoomable\n          fill-opacity=\"0\"\n          [axis]=\"item.value\"\n          [config]=\"config | async\"\n          [size]=\"data.size\"\n          [attr.x]=\"item.value.options.opposite ? 0 : -item.value.selfSize\"\n          [attr.y]=\"0\"\n          [attr.height]=\"data.size.width\"\n          [attr.width]=\"item.value.selfSize\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></rect>\n      </ng-container>\n    </g>\n    <g class=\"x-axis-container\">\n      <ng-container *ngFor=\"let item of data.xAxisMap | keyvalue; trackBy: identify\">\n        <g\n          teta-x-axis\n          [axis]=\"item.value\"\n          [scale]=\"data.xScaleMap.get(item.key)\"\n          [size]=\"data.size\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></g>\n\n        <rect\n          tetaZoomable\n          fill-opacity=\"0\"\n          [axis]=\"item.value\"\n          [config]=\"config | async\"\n          [size]=\"data.size\"\n          [attr.x]=\"0\"\n          [attr.y]=\"0\"\n          [attr.width]=\"data.size.width\"\n          [attr.height]=\"item.value.selfSize\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></rect>\n      </ng-container>\n    </g>\n  </svg>\n  <ng-container *ngIf=\"visibleRect | async as rect\">\n    <svg\n      tetaBrushable\n      tetaZoomable\n      [size]=\"data.size\"\n      [brushScale]=\"brushScale | async\"\n      [config]=\"config | async\"\n      [attr.width]=\"rect.width\"\n      [attr.height]=\"rect.height\"\n      [attr.transform]=\"'translate('+ rect.x +', '+ rect.y +')'\"\n      [attr.viewBox]=\"'0 0 ' + rect.width + ' ' + rect.height\"\n      (mouseleave)=\"mouseLeave($event)\"\n      (mousemove)=\"mouseMove($event)\">\n      <g>\n        <g>\n          <g class=\"gridlines\"\n             teta-gridlines\n             [size]=\"data.size\"\n             [xScaleMap]=\"data.xScaleMap\"\n             [yScaleMap]=\"data.yScaleMap\"></g>\n          <g class=\"x-axis-plotline-container\">\n            <ng-container *ngFor=\"let axis of data.config.xAxis; let i = index\">\n              <g teta-plot-line *ngFor=\"let plotLine of axis.plotLines\"\n                 [plotLine]=\"plotLine\"\n                 [scale]=\"data.xScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.xAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"y-axis-plotline-container\">\n            <ng-container *ngFor=\"let axis of data.config.yAxis; let i = index\">\n              <g teta-plot-line *ngFor=\"let plotLine of axis.plotLines\"\n                 [plotLine]=\"plotLine\"\n                 [scale]=\"data.yScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.yAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n\n          <g class=\"x-axis-plotband-container\">\n            <ng-container *ngFor=\"let axis of data.config.xAxis; let i = index\">\n              <g teta-plot-band *ngFor=\"let plotBand of axis.plotBands\"\n                 [plotBand]=\"plotBand\"\n                 [scale]=\"data.xScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.xAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"y-axis-plotband-container\">\n            <ng-container *ngFor=\"let axis of data.config.yAxis; let i = index\">\n              <g teta-plot-band *ngFor=\"let plotBand of axis.plotBands\"\n                 [plotBand]=\"plotBand\"\n                 [scale]=\"data.yScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.yAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"series-container\">\n            <g teta-series-host\n               *ngFor=\"let series of data.config.series\"\n               [config]=\"data.config\"\n               [series]=\"series\"\n               [size]=\"data.size\"></g>\n          </g>\n        </g>\n      </g>\n    </svg>\n  </ng-container>\n</ng-container>\n", styles: [":host{display:flex;flex-direction:column;flex-grow:1;min-width:0;min-height:0}:host .zoomable:hover{cursor:grab}:host .zoomable:active{cursor:grabbing}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i0.ChangeDetectorRef }, { type: i2.ScaleService }, { type: i3.ZoomService }, { type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-container.component.js","sourceRoot":"","sources":["../../../../src/chart/chart-container/chart-container.component.ts","../../../../src/chart/chart-container/chart-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  OnInit,\n} from '@angular/core';\nimport { IChartConfig } from '../model/i-chart-config';\nimport { ChartService } from '../service/chart.service';\nimport { combineLatest, filter, map, Observable, tap } from 'rxjs';\nimport { Axis } from '../core/axis/axis';\nimport { AxisOrientation } from '../model/enum/axis-orientation';\nimport { ScaleService } from '../service/scale.service';\nimport { IChartEvent } from '../model/i-chart-event';\nimport { ZoomService } from '../service/zoom.service';\n\ntype Opposite = boolean;\n\n@Component({\n  selector: 'teta-chart-container',\n  templateUrl: './chart-container.component.html',\n  styleUrls: ['./chart-container.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ChartContainerComponent implements OnInit {\n  config: Observable<IChartConfig>;\n\n  yAxisMap: Observable<Map<number, Axis>>;\n  xAxisMap: Observable<Map<number, Axis>>;\n  yScaleMap: Observable<Map<number, any>>;\n  xScaleMap: Observable<Map<number, any>>;\n  size: Observable<DOMRect>;\n  visibleRect: Observable<any>;\n\n  brushScale: Observable<any>;\n\n  private _observer: ResizeObserver;\n  private uniqId: string;\n\n  private filterPositionMap = new Map<\n    Opposite,\n    (axis: Axis) => (_: Axis) => boolean\n  >()\n    .set(\n      true,\n      (axis) => (_: Axis) =>\n        _.options.opposite && _.options.visible && axis.index <= _.index\n    )\n    .set(\n      false,\n      (axis) => (_: Axis) =>\n        _.options.opposite !== true &&\n        _.options.visible &&\n        _.index <= axis.index\n    );\n\n  constructor(\n    private _svc: ChartService,\n    private _cdr: ChangeDetectorRef,\n    private _scaleService: ScaleService,\n    private _zoomService: ZoomService,\n    private _elementRef: ElementRef\n  ) {\n    this.config = this._svc.config;\n    this.size = this._svc.size;\n    this.yAxisMap = this._scaleService.yAxisMap;\n    this.xAxisMap = this._scaleService.xAxisMap;\n    this.yScaleMap = this._scaleService.yScaleMap;\n    this.xScaleMap = this._scaleService.xScaleMap;\n\n    this.brushScale = this._scaleService.xScaleMap.pipe(\n      map((map) => {\n        return map.get(0);\n      })\n    );\n\n    this.visibleRect = combineLatest([\n      this.size,\n      this.xAxisMap,\n      this.yAxisMap,\n      this._zoomService.zoomed,\n    ]).pipe(\n      map(\n        (\n          data: [DOMRect, Map<number, any>, Map<number, any>, IChartEvent<Axis>]\n        ) => {\n          const [size, x, y] = data;\n          const yAxesArray = [...y.values()];\n          const xAxesArray = [...x.values()];\n          const left = yAxesArray\n            .filter((_) => _.options.opposite !== true && _.options.visible)\n            .reduce(this.sumSize, 0);\n\n          const right = yAxesArray\n            .filter((_) => _.options.opposite && _.options.visible)\n            .reduce(this.sumSize, 0);\n\n          const bottom = xAxesArray\n            .filter((_) => _.options.opposite !== true && _.options.visible)\n            .reduce(this.sumSize, 0);\n\n          const top = xAxesArray\n            .filter((_) => _.options.opposite && _.options.visible)\n            .reduce(this.sumSize, 0);\n\n          return {\n            x: left,\n            y: top,\n            width: size.width - left - right + 1,\n            height: size.height - top - bottom + 1,\n          };\n        }\n      ),\n      tap((_) => this._cdr.detectChanges())\n    );\n  }\n\n  ngOnInit(): void {\n    this.uniqId = (Date.now() + Math.random()).toString(36);\n    this._observer = new ResizeObserver((entries: ResizeObserverEntry[]) => {\n      if (!Array.isArray(entries) || !entries.length) {\n        return;\n      }\n\n      this._svc.setSize(entries[0].contentRect);\n    });\n    this._observer.observe(this._elementRef.nativeElement);\n  }\n\n  ngAfterViewInit() {}\n\n  private sumSize = (acc, curr) => acc + curr.selfSize;\n\n  getTranslate(axis?: Axis, size?: DOMRect): Observable<string> {\n    return combineLatest([this.xAxisMap, this.yAxisMap]).pipe(\n      map((data: [Map<number, Axis>, Map<number, Axis>]) => {\n        const [x, y] = data;\n        const xAxesArray = [...x.values()];\n        const yAxesArray = [...y.values()];\n\n        const oppositeFilter = this.filterPositionMap.get(true);\n        const nonOppositeFilter = this.filterPositionMap.get(false);\n\n        const oppositeOffsetY = yAxesArray.filter(oppositeFilter(axis));\n        const nonOppositeOffsetY = yAxesArray.filter(nonOppositeFilter(axis));\n\n        const oppositeOffsetX = xAxesArray.filter(oppositeFilter(axis));\n        const nonOppositeOffsetX = xAxesArray.filter(nonOppositeFilter(axis));\n\n        const oppositeTranslateY = oppositeOffsetY.reduce(\n          (acc, curr) => acc + curr.selfSize,\n          0\n        );\n        const nonOppisteTranslateY = nonOppositeOffsetY.reduce(\n          (acc, curr) => acc + curr.selfSize,\n          0\n        );\n\n        const oppositeTranslateX = oppositeOffsetX.reduce(\n          (acc, curr) => acc + curr.selfSize,\n          0\n        );\n\n        const nonOppisteTranslateX = nonOppositeOffsetX.reduce(\n          (acc, curr) => acc + curr.selfSize,\n          0\n        );\n\n        const left = yAxesArray\n          .filter((_) => _.options.visible && _.options.opposite !== true)\n          .reduce((acc, curr) => acc + curr.selfSize, 0);\n\n        const top = xAxesArray\n          .filter((_) => _.options.visible && _.options.opposite === true)\n          .reduce((acc, curr) => acc + curr.selfSize, 0);\n\n        if (axis.orientation === AxisOrientation.x) {\n          return `translate(${left}, ${\n            axis.options.opposite\n              ? oppositeTranslateX\n              : size.height - nonOppisteTranslateX\n          })`;\n        }\n\n        if (axis.orientation === AxisOrientation.y) {\n          return `translate(${\n            axis.options.opposite\n              ? size.width - oppositeTranslateY\n              : nonOppisteTranslateY\n          }, ${top})`;\n        }\n\n        return 'translate(0, 0)';\n      })\n    );\n  }\n\n  identify(index, item) {\n    return item.value.index;\n  }\n\n  mouseMove(event) {\n    this._svc.setPointerMove(event);\n  }\n\n  mouseLeave(event) {\n    this._svc.setPointerMove(event);\n  }\n\n  id(): string {\n    return this.uniqId;\n  }\n}\n","<ng-container *ngIf=\"{\n  size: size | async,\n  config: config | async,\n  xAxisMap: xAxisMap | async,\n  yAxisMap: yAxisMap | async,\n  xScaleMap: xScaleMap | async,\n  yScaleMap: yScaleMap | async\n} as data\">\n\n  <teta-tooltip *ngIf=\"data.config?.tooltip?.enable\" [size]=\"data.size\" [config]=\"data.config\"></teta-tooltip>\n  <svg height=\"100%\" width=\"100%\" class=\"position-absolute\">\n    <g class=\"y-axis-container\">\n      <ng-container *ngFor=\"let item of data.yAxisMap | keyvalue; trackBy: identify\">\n        <g\n          teta-y-axis\n          [axis]=\"item.value\"\n          [scale]=\"data.yScaleMap.get(item.key)\"\n          [size]=\"data.size\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></g>\n        <rect\n          tetaZoomable\n          fill-opacity=\"0\"\n          [axis]=\"item.value\"\n          [config]=\"config | async\"\n          [size]=\"data.size\"\n          [attr.x]=\"item.value.options.opposite ? 0 : -item.value.selfSize\"\n          [attr.y]=\"0\"\n          [attr.height]=\"data.size.width\"\n          [attr.width]=\"item.value.selfSize\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></rect>\n      </ng-container>\n    </g>\n    <g class=\"x-axis-container\">\n      <ng-container *ngFor=\"let item of data.xAxisMap | keyvalue; trackBy: identify\">\n        <g\n          teta-x-axis\n          [axis]=\"item.value\"\n          [scale]=\"data.xScaleMap.get(item.key)\"\n          [size]=\"data.size\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></g>\n\n        <rect\n          tetaZoomable\n          fill-opacity=\"0\"\n          [axis]=\"item.value\"\n          [config]=\"config | async\"\n          [size]=\"data.size\"\n          [attr.x]=\"0\"\n          [attr.y]=\"0\"\n          [attr.width]=\"data.size.width\"\n          [attr.height]=\"item.value.selfSize\"\n          [attr.transform]=\"getTranslate(item.value, data.size) | async\"></rect>\n      </ng-container>\n    </g>\n  </svg>\n  <ng-container *ngIf=\"visibleRect | async as rect\">\n    <svg\n      tetaBrushable\n      tetaZoomable\n      [size]=\"data.size\"\n      [brushScale]=\"brushScale | async\"\n      [config]=\"config | async\"\n      [attr.width]=\"rect.width\"\n      [attr.height]=\"rect.height\"\n      [attr.transform]=\"'translate('+ rect.x +', '+ rect.y +')'\"\n      [attr.viewBox]=\"'0 0 ' + rect.width + ' ' + rect.height\"\n      (mouseleave)=\"mouseLeave($event)\"\n      (mousemove)=\"mouseMove($event)\">\n      <g>\n        <g>\n          <g class=\"gridlines\"\n             teta-gridlines\n             [size]=\"data.size\"\n             [xScaleMap]=\"data.xScaleMap\"\n             [yScaleMap]=\"data.yScaleMap\"></g>\n          <g class=\"x-axis-plotline-container\">\n            <ng-container *ngFor=\"let axis of data.config.xAxis; let i = index\">\n              <g teta-plot-line *ngFor=\"let plotLine of axis.plotLines\"\n                 [plotLine]=\"plotLine\"\n                 [scale]=\"data.xScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.xAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"y-axis-plotline-container\">\n            <ng-container *ngFor=\"let axis of data.config.yAxis; let i = index\">\n              <g teta-plot-line *ngFor=\"let plotLine of axis.plotLines\"\n                 [plotLine]=\"plotLine\"\n                 [scale]=\"data.yScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.yAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n\n          <g class=\"x-axis-plotband-container\">\n            <ng-container *ngFor=\"let axis of data.config.xAxis; let i = index\">\n              <g teta-plot-band *ngFor=\"let plotBand of axis.plotBands\"\n                 [plotBand]=\"plotBand\"\n                 [scale]=\"data.xScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.xAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"y-axis-plotband-container\">\n            <ng-container *ngFor=\"let axis of data.config.yAxis; let i = index\">\n              <g teta-plot-band *ngFor=\"let plotBand of axis.plotBands\"\n                 [plotBand]=\"plotBand\"\n                 [scale]=\"data.yScaleMap.get(i)\"\n                 [size]=\"data.size\"\n                 [axis]=\"data.yAxisMap.get(i)\"></g>\n            </ng-container>\n          </g>\n          <g class=\"series-container\">\n            <g teta-series-host\n               *ngFor=\"let series of data.config.series\"\n               [config]=\"data.config\"\n               [series]=\"series\"\n               [size]=\"data.size\"></g>\n          </g>\n        </g>\n      </g>\n    </svg>\n  </ng-container>\n</ng-container>\n"]}

package/esm2020/chart/chart-container/gridlines/gridlines.component.mjs

@@ -0,0 +1,29 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class GridlinesComponent {
+    constructor() { }
+    draw() {
+        this.tickYValues = this.yScaleMap.get(0).ticks();
+        this.tickXValues = this.xScaleMap.get(0).ticks();
+    }
+    ngOnChanges(changes) {
+        if (changes.hasOwnProperty('xScaleMap') &&
+            changes.hasOwnProperty('yScaleMap')) {
+            this.draw();
+        }
+    }
+}
+GridlinesComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: GridlinesComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+GridlinesComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: GridlinesComponent, selector: "[teta-gridlines]", inputs: { size: "size", xScaleMap: "xScaleMap", yScaleMap: "yScaleMap" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngFor=\"let tick of tickYValues\">\n  <svg:line [attr.x1]=\"0\" stroke=\"red\"\n            [attr.y1]=\"yScaleMap.get(0)(tick)\"\n            [attr.x2]=\"size?.width\"\n            [attr.y2]=\"yScaleMap.get(0)(tick)\"></svg:line>\n</ng-container>\n\n<ng-container *ngFor=\"let tick of tickXValues\">\n  <svg:line [attr.x1]=\"xScaleMap.get(0)(tick)\"\n            stroke=\"red\"\n            [attr.y1]=\"0\"\n            [attr.x2]=\"xScaleMap.get(0)(tick)\"\n            [attr.y2]=\"size?.height\"></svg:line>\n</ng-container>\n", styles: [":host{shape-rendering:crispEdges}:host line{stroke-dasharray:1,4;stroke:var(--color-text-20)}\n"], directives: [{ type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: GridlinesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[teta-gridlines]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngFor=\"let tick of tickYValues\">\n  <svg:line [attr.x1]=\"0\" stroke=\"red\"\n            [attr.y1]=\"yScaleMap.get(0)(tick)\"\n            [attr.x2]=\"size?.width\"\n            [attr.y2]=\"yScaleMap.get(0)(tick)\"></svg:line>\n</ng-container>\n\n<ng-container *ngFor=\"let tick of tickXValues\">\n  <svg:line [attr.x1]=\"xScaleMap.get(0)(tick)\"\n            stroke=\"red\"\n            [attr.y1]=\"0\"\n            [attr.x2]=\"xScaleMap.get(0)(tick)\"\n            [attr.y2]=\"size?.height\"></svg:line>\n</ng-container>\n", styles: [":host{shape-rendering:crispEdges}:host line{stroke-dasharray:1,4;stroke:var(--color-text-20)}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { size: [{
+                type: Input
+            }], xScaleMap: [{
+                type: Input
+            }], yScaleMap: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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