@tetacom/svg-charts 1.0.2 → 1.1.0

package/dist/chart/model/{plotband.d.ts → plot-band.d.ts}

@@ -1,6 +1,7 @@
 import { SvgAttributes } from './svg-attributes';
-export declare class Plotband {
-    id: number | string;
+export declare class PlotBand {
+    id?: number | string;
+    name?: string;
     from: number;
     to: number;
     label?: string;
@@ -10,11 +11,12 @@ export declare class Plotband {
     min?: number;
     max?: number;
     style?: {
-        plotband?: SvgAttributes;
+        plotBand?: SvgAttributes;
         grabbers?: SvgAttributes;
     };
     constructor(options?: {
-        id: any;
+        id?: number | string;
+        name?: string;
         from: number;
         to: number;
         label?: string;
@@ -24,7 +26,7 @@ export declare class Plotband {
         min?: number;
         max?: number;
         style?: {
-            plotband?: SvgAttributes;
+            plotBand?: SvgAttributes;
             grabbers?: SvgAttributes;
         };
     });

package/dist/chart/model/{plotline.d.ts → 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/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/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/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/dist/chart/service/scale.service.d.ts

@@ -1,14 +1,19 @@
-import { AxesService } from './axes.service';
-import { IChartConfig } from '../model/i-chart-config';
+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 axesService;
-    yScales: Map<number | string, any>;
-    xScales: Map<number | string, any>;
+    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(axesService: AxesService);
-    createScales(size: DOMRect, config?: IChartConfig): void;
-    private getScale;
+    constructor(chartService: ChartService, zoomService: ZoomService);
     static ɵfac: i0.ɵɵFactoryDeclaration<ScaleService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ScaleService>;
 }

package/dist/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/dist/esm2020/chart/base/series-base.component.mjs

@@ -1,5 +1,4 @@
 import { Component, Input, } from '@angular/core';
-import { tap } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "../service/chart.service";
 import * as i2 from "../service/scale.service";
@@ -11,24 +10,23 @@ export class SeriesBaseComponent {
         this.scaleService = scaleService;
         this.zoomService = zoomService;
         this.element = element;
-        this.zoomService.zoomed
-            .pipe(tap((_) => {
-            this.cdr.detectChanges();
-        }))
-            .subscribe();
     }
     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: { series: "series", size: "size" }, ngImport: i0, template: '', isInline: true });
+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: { series: [{
+        }], 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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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,8 +3,7 @@ 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 { AxesService } from '../service/axes.service';
-import { ChartBounds } from '../model/chart-bounds';
+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";
@@ -12,57 +11,56 @@ 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;
+    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._config = Object.assign({
-            bounds: new ChartBounds(),
-        }, config);
-    }
-    get config() {
-        return this._config;
+        this._svc.setConfig(config);
     }
     ngOnChanges(changes) { }
     ngOnInit() {
-        this.svc.plotbandMove.subscribe((_) => {
+        this._svc.plotBandEvent
+            .pipe(takeWhile(() => this._alive))
+            .subscribe((_) => {
             this.plotBandsMove.emit(_);
         });
-        this.svc.plotlineMove.subscribe((_) => {
+        this._svc.plotLineMove.pipe(takeWhile(() => this._alive)).subscribe((_) => {
             this.plotLinesMove.emit(_);
         });
-        this.svc.pointMove.subscribe((_) => {
+        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.zoomService.broadcastSubscribtion?.unsubscribe();
+        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", plotLinesMove: "plotLinesMove", pointMove: "pointMove" }, providers: [
-        ChartService,
-        ZoomService,
-        ScaleService,
-        AxesService,
-        BrushService,
-    ], usesOnChanges: true, ngImport: i0, template: "<div class=\"column column_auto\">\n  <teta-chart-container class=\"chart-container\" [config]=\"config\"></teta-chart-container>\n</div>\n\n<teta-legend *ngIf=\"config.legend?.enable === true\" [series]=\"config.series\"></teta-legend>\n", styles: [":host{display:flex;flex-direction:column;height:100%;width:100%}\n"], components: [{ type: i3.ChartContainerComponent, selector: "teta-chart-container", inputs: ["config"] }, { type: i4.LegendComponent, selector: "teta-legend", inputs: ["series"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+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,
-                        AxesService,
-                        BrushService,
-                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"column column_auto\">\n  <teta-chart-container class=\"chart-container\" [config]=\"config\"></teta-chart-container>\n</div>\n\n<teta-legend *ngIf=\"config.legend?.enable === true\" [series]=\"config.series\"></teta-legend>\n", styles: [":host{display:flex;flex-direction:column;height:100%;width:100%}\n"] }]
+            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: [{
@@ -70,4 +68,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImpor
             }], config: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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"]}