@tetacom/svg-charts 1.1.8 → 1.1.9

package/chart/chart-container/annotation/annotation.component.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef, OnInit, SimpleChanges } from '@angular/core';
+import { Annotation } from '../../model/annotation';
+import * as i0 from "@angular/core";
+export declare class AnnotationComponent implements OnInit {
+    annotations: Annotation[];
+    xScaleMap: Map<number, any>;
+    yScaleMap: Map<number, any>;
+    node: ElementRef;
+    private _node;
+    private _makeAnnotations;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    drawAnnotations(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnnotationComponent, "[teta-annotation]", never, { "annotations": "annotations"; "xScaleMap": "xScaleMap"; "yScaleMap": "yScaleMap"; }, {}, never, never>;
+}

package/chart/chart-container/plotband/plot-band.component.d.ts

@@ -29,6 +29,7 @@ export declare class PlotBandComponent implements AfterViewInit {
     get width(): number;
     get from(): number;
     get to(): number;
+    getTextCenter: () => any;
     getFill(d: PlotBand): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<PlotBandComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PlotBandComponent, "[teta-plot-band]", never, { "plotBand": "plotBand"; "axis": "axis"; "scale": "scale"; "size": "size"; }, {}, never, never>;

package/chart/chart-container/series/area-series/area-series.component.d.ts

@@ -5,7 +5,7 @@ import { ChartService } from '../../../service/chart.service';
 import { ScaleService } from '../../../service/scale.service';
 import { ZoomService } from '../../../service/zoom.service';
 import { Observable } from 'rxjs';
-import { FillType } from '../../../model/enum/fill-type';
+import { FillDirection, FillType } from '../../../model/enum/fill-type';
 import * as i0 from "@angular/core";
 export declare class AreaSeriesComponent<T extends BasePoint> extends SeriesBaseComponent<T> implements OnInit {
     protected svc: ChartService;
@@ -20,6 +20,7 @@ export declare class AreaSeriesComponent<T extends BasePoint> extends SeriesBase
     x: any;
     y: any;
     id: string;
+    fillDirection: typeof FillDirection;
     fillType: typeof FillType;
     constructor(svc: ChartService, cdr: ChangeDetectorRef, scaleService: ScaleService, zoomService: ZoomService, element: ElementRef);
     ngOnInit(): void;

package/chart/chart-container/series/line/line-series.component.d.ts

@@ -22,7 +22,7 @@ export declare class LineSeriesComponent<T extends BasePoint> extends SeriesBase
     ngOnInit(): void;
     ngAfterViewInit(): void;
     getMarkers(): T[];
-    getTransform(event: any, x: Map<number, any>, y: Map<number, any>): Pick<BasePoint, 'x' | 'y'>;
+    getTransform(event: any, scaleX: Map<number, any>, scaleY: Map<number, any>): Pick<BasePoint, 'x' | 'y'>;
     static ɵfac: i0.ɵɵFactoryDeclaration<LineSeriesComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<LineSeriesComponent<any>, "svg:svg[teta-line-series]", never, {}, {}, never, never>;
 }

package/chart/chart-container/tooltip/tooltip.component.d.ts

@@ -1,13 +1,11 @@
-import { ChangeDetectorRef, NgZone, OnDestroy, OnInit } from '@angular/core';
+import { ChangeDetectorRef, NgZone, OnInit } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ChartService } from '../../service/chart.service';
 import { ZoomService } from '../../service/zoom.service';
-import { IDisplayTooltip } from '../../model/i-display-tooltip';
 import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
 import { IChartConfig } from '../../model/i-chart-config';
-import { Series } from '../../model/series';
 import * as i0 from "@angular/core";
-export declare class TooltipComponent implements OnInit, OnDestroy {
+export declare class TooltipComponent implements OnInit {
     private svc;
     private cdr;
     private zoomService;
@@ -22,13 +20,10 @@ export declare class TooltipComponent implements OnInit, OnDestroy {
         right: string;
     }>;
     displayTooltips: Observable<SafeHtml>;
-    tooltips: Observable<Map<Series<any>, IDisplayTooltip>>;
-    private alive;
     display: Observable<number>;
     constructor(svc: ChartService, cdr: ChangeDetectorRef, zoomService: ZoomService, sanitizer: DomSanitizer, _zone: NgZone);
     ngOnInit(): void;
     private getPoisition;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "teta-tooltip", never, { "size": "size"; "config": "config"; }, {}, never, never>;
 }

package/chart/chart.module.d.ts

@@ -18,9 +18,10 @@ import * as i16 from "./chart-container/series/area-series/area-series.component
 import * as i17 from "./chart-container/series/scatter-series/scatter-series.component";
 import * as i18 from "./chart-container/series/block-series/block-series.component";
 import * as i19 from "./chart-container/series/block-area-series/block-area-series.component";
-import * as i20 from "@angular/common";
+import * as i20 from "./chart-container/annotation/annotation.component";
+import * as i21 from "@angular/common";
 export declare class ChartModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ChartModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ChartModule, [typeof i1.ChartComponent, typeof i2.SeriesHostComponent, typeof i3.ChartContainerComponent, typeof i4.LegendComponent, typeof i5.SeriesBaseComponent, typeof i6.LineSeriesComponent, typeof i7.GridlinesComponent, typeof i8.XAxisComponent, typeof i9.YAxisComponent, typeof i10.PlotlineComponent, typeof i11.PlotBandComponent, typeof i12.BarSeriesComponent, typeof i13.TooltipComponent, typeof i14.ZoomableDirective, typeof i15.BrushableDirective, typeof i16.AreaSeriesComponent, typeof i17.ScatterSeriesComponent, typeof i18.BlockSeriesComponent, typeof i19.BlockAreaSeriesComponent], [typeof i20.CommonModule], [typeof i1.ChartComponent, typeof i4.LegendComponent, typeof i5.SeriesBaseComponent, typeof i6.LineSeriesComponent, typeof i12.BarSeriesComponent, typeof i17.ScatterSeriesComponent, typeof i16.AreaSeriesComponent, typeof i18.BlockSeriesComponent, typeof i19.BlockAreaSeriesComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ChartModule, [typeof i1.ChartComponent, typeof i2.SeriesHostComponent, typeof i3.ChartContainerComponent, typeof i4.LegendComponent, typeof i5.SeriesBaseComponent, typeof i6.LineSeriesComponent, typeof i7.GridlinesComponent, typeof i8.XAxisComponent, typeof i9.YAxisComponent, typeof i10.PlotlineComponent, typeof i11.PlotBandComponent, typeof i12.BarSeriesComponent, typeof i13.TooltipComponent, typeof i14.ZoomableDirective, typeof i15.BrushableDirective, typeof i16.AreaSeriesComponent, typeof i17.ScatterSeriesComponent, typeof i18.BlockSeriesComponent, typeof i19.BlockAreaSeriesComponent, typeof i20.AnnotationComponent], [typeof i21.CommonModule], [typeof i1.ChartComponent, typeof i4.LegendComponent, typeof i5.SeriesBaseComponent, typeof i6.LineSeriesComponent, typeof i12.BarSeriesComponent, typeof i17.ScatterSeriesComponent, typeof i16.AreaSeriesComponent, typeof i18.BlockSeriesComponent, typeof i19.BlockAreaSeriesComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ChartModule>;
 }

package/chart/directives/zoomable.directive.d.ts

@@ -1,20 +1,27 @@
-import { ElementRef, SimpleChanges } from '@angular/core';
+import { ElementRef, OnDestroy, SimpleChanges } from '@angular/core';
 import { ZoomService } from '../service/zoom.service';
 import { IChartConfig } from '../model/i-chart-config';
 import { Axis } from '../core/axis/axis';
+import { BroadcastService } from "../service/broadcast.service";
 import * as i0 from "@angular/core";
-export declare class ZoomableDirective {
-    private element;
-    private svc;
+export declare class ZoomableDirective implements OnDestroy {
+    private elementRef;
+    private zoomService;
+    private broadcastService;
     config?: IChartConfig;
     axis?: Axis;
     size?: DOMRect;
     brushScale?: any;
     private zoomable;
-    constructor(element: ElementRef, svc: ZoomService);
+    private _element;
+    private zoomAxis;
+    private zoom;
+    private alive;
+    constructor(elementRef: ElementRef, zoomService: ZoomService, broadcastService: BroadcastService);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ZoomableDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ZoomableDirective, "[tetaZoomable]", never, { "config": "config"; "axis": "axis"; "size": "size"; "brushScale": "brushScale"; }, {}, never>;
 }

package/chart/model/annotation.d.ts

@@ -0,0 +1,31 @@
+import { annotationBadge, annotationCallout, annotationCalloutCircle, annotationCalloutCurve, annotationCalloutElbow, annotationCalloutRect, annotationCustomType, annotationLabel, annotationXYThreshold } from 'd3-svg-annotation';
+import { BasePoint } from './base-point';
+import { SvgAttributes } from './svg-attributes';
+declare const annotationMap: readonly [typeof annotationBadge, typeof annotationLabel, typeof annotationCallout, typeof annotationCalloutCircle, typeof annotationCalloutCurve, typeof annotationCalloutElbow, typeof annotationCalloutRect, typeof annotationCustomType, typeof annotationXYThreshold];
+declare type AnnotationTypes = typeof annotationMap[number];
+export interface Annotation {
+    point: BasePoint;
+    yAxisIndex: number;
+    xAxisIndex: number;
+    type?: AnnotationTypes;
+    enabled?: boolean;
+    dx?: number;
+    dy?: number;
+    className?: string;
+    connector?: {
+        end: string;
+    };
+    note?: {
+        label?: string;
+        title?: string;
+        bgPadding?: {
+            top?: number;
+            right?: number;
+            bottom?: number;
+            left?: number;
+        };
+        bgRadius?: boolean;
+    };
+    style?: SvgAttributes;
+}
+export {};

package/chart/model/enum/fill-type.d.ts

@@ -2,3 +2,7 @@ export declare enum FillType {
     default = 0,
     gradient = 1
 }
+export declare enum FillDirection {
+    x = 0,
+    y = 1
+}

package/chart/model/i-broadcast-message.d.ts

@@ -1,18 +1,29 @@
 import { D3BrushEvent, D3ZoomEvent } from 'd3';
 import { Axis } from '../core/axis/axis';
 import { BrushType } from './enum/brush-type';
-export interface ZoomMessage {
+export declare class ZoomMessage {
     event: D3ZoomEvent<any, any>;
     axis?: Axis;
     brushDomain?: number[];
+    constructor(options?: {
+        event: D3ZoomEvent<any, any>;
+        axis?: Axis;
+        brushDomain?: number[];
+    });
 }
-export interface BrushMessage {
+export declare class BrushMessage {
     event: D3BrushEvent<any>;
     brushType: BrushType;
     selection: number[];
     brushScale?: any;
+    constructor(options?: {
+        event: D3BrushEvent<any>;
+        brushType: BrushType;
+        selection: number[];
+        brushScale?: any;
+    });
 }
-export interface IBroadcastMessage {
+export interface IBroadcastMessage<T> {
     channel: string;
-    message: ZoomMessage | BrushMessage;
+    message: T;
 }

package/chart/model/i-chart-config.d.ts

@@ -5,6 +5,7 @@ import { ZoomType } from './enum/zoom-type';
 import { TooltipOptions } from './tooltip-options';
 import { ChartBounds } from './chart-bounds';
 import { BrushType } from './enum/brush-type';
+import { Annotation } from './annotation';
 export interface IChartConfig {
     name?: string;
     series?: Series<BasePoint>[];
@@ -28,6 +29,7 @@ export interface IChartConfig {
     tooltip?: TooltipOptions;
     xAxis: AxisOptions[];
     yAxis: AxisOptions[];
+    annotations?: Annotation[];
     gridLines?: boolean;
     width?: number;
     height?: number;

package/chart/model/public-api.d.ts

@@ -12,3 +12,4 @@ export * from './plot-band';
 export * from './plot-line';
 export * from './series';
 export * from './svg-attributes';
+export * from './annotation';

package/chart/model/series.d.ts

@@ -2,7 +2,7 @@ import { BasePoint } from './base-point';
 import { SeriesType } from './enum/series-type';
 import { SeriesBaseComponent } from '../base/series-base.component';
 import { SvgAttributes } from './svg-attributes';
-import { FillType } from './enum/fill-type';
+import { FillDirection, FillType } from './enum/fill-type';
 export interface Series<T extends BasePoint> {
     id?: number | string;
     type: SeriesType;
@@ -14,6 +14,7 @@ export interface Series<T extends BasePoint> {
     visible?: boolean;
     color?: string;
     fillType?: FillType;
+    fillDirection?: FillDirection;
     showInLegend?: boolean;
     style?: SvgAttributes;
 }

package/chart/service/broadcast.service.d.ts

@@ -1,11 +1,14 @@
-import { IBroadcastMessage } from '../model/i-broadcast-message';
+import { BrushMessage, IBroadcastMessage, ZoomMessage } from '../model/i-broadcast-message';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class BroadcastService {
-    private emitter;
+    private zoomEmitter;
+    private brushEmitter;
     constructor();
-    broadcast(value: IBroadcastMessage): void;
-    subscribeToChannel(channel: string): Observable<IBroadcastMessage>;
+    broadcastZoom(value: IBroadcastMessage<ZoomMessage>): void;
+    broadcastBrush(value: IBroadcastMessage<BrushMessage>): void;
+    subscribeToZoom(channel: string): Observable<IBroadcastMessage<ZoomMessage>>;
+    subscribeToBrush(channel: string): Observable<IBroadcastMessage<BrushMessage>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BroadcastService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BroadcastService>;
 }

package/chart/service/brush.service.d.ts

@@ -8,8 +8,10 @@ export declare class BrushService {
     broadcastSubscribtion: Subscription;
     private brush;
     private brushMap;
+    private selection;
     constructor(broadcastService: BroadcastService);
-    applyBrush(svgElement: ElementRef, config: IChartConfig, brushScale: any, size: DOMRect): void;
+    applyBrush(svgElement: ElementRef, config: IChartConfig, brushScale: any): void;
+    clearPreviousSelection(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BrushService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BrushService>;
 }

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

@@ -6,12 +6,13 @@ import { PlotBand } from '../model/plot-band';
 import { PlotLine } from '../model/plot-line';
 import { IPointMove } from '../model/i-point-move';
 import { BasePoint } from '../model/base-point';
+import { Series } from '../model/series';
 import * as i0 from "@angular/core";
 export declare class ChartService {
     config: Observable<IChartConfig>;
     size: Observable<DOMRect>;
     pointerMove: Observable<PointerEvent>;
-    tooltips: Observable<IDisplayTooltip>;
+    tooltips: Observable<Map<Series<BasePoint>, IDisplayTooltip>>;
     plotBandEvent: Observable<IChartEvent<PlotBand>>;
     plotLineMove: Observable<IChartEvent<PlotLine>>;
     plotBandClick: Observable<IChartEvent<PlotBand>>;
@@ -33,13 +34,14 @@ export declare class ChartService {
     setSize(size: DOMRect): void;
     setPointerMove(event: PointerEvent): void;
     setTooltip(tooltip: IDisplayTooltip): void;
+    clearTooltips(): void;
     emitPlotband(event: IChartEvent<PlotBand>): void;
     emitPlotline(event: IChartEvent<PlotLine>): void;
     emitPoint(event: IChartEvent<IPointMove>): void;
     emitChartClick(event: IChartEvent<BasePoint>): void;
     emitChartContextMenu(event: IChartEvent<BasePoint>): void;
     private setDefaults;
-    private setpreparationData;
+    private setPreparationData;
     static ɵfac: i0.ɵɵFactoryDeclaration<ChartService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ChartService>;
 }

package/chart/service/zoom.service.d.ts

@@ -1,17 +1,13 @@
-import { ElementRef } from '@angular/core';
 import { Observable, Subscription } from 'rxjs';
-import { IChartConfig } from '../model/i-chart-config';
-import { BroadcastService } from './broadcast.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 broadcastService;
     broadcastSubscription: Subscription[];
     zoomed: Observable<IChartEvent<Axis>>;
     private zoomed$;
-    constructor(broadcastService: BroadcastService);
-    applyZoom(svgElement: ElementRef, config: IChartConfig, size: DOMRect, axis?: Axis, brushScale?: any): void;
+    constructor();
+    setZoom(zoom: IChartEvent<Axis>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ZoomService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ZoomService>;
 }

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

@@ -92,4 +92,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImpor
             }], 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<IChartEvent<PlotBand>>();\n\n  @Output()\n  plotBandClick: EventEmitter<IChartEvent<PlotBand>> = new EventEmitter<IChartEvent<PlotBand>>();\n\n  @Output()\n  plotBandContextMenu: EventEmitter<IChartEvent<PlotBand>> = new EventEmitter<IChartEvent<PlotBand>>();\n\n\n  @Output()\n  plotLinesMove: EventEmitter<IChartEvent<PlotLine>> = new EventEmitter<IChartEvent<PlotLine>>();\n\n  @Output()\n  pointMove: EventEmitter<IChartEvent<IPointMove>> = new EventEmitter<IChartEvent<IPointMove>>();\n\n  @Output()\n  chartClick: EventEmitter<IChartEvent<BasePoint>> = new EventEmitter<IChartEvent<BasePoint>>();\n\n  @Output()\n  chartContextMenu: EventEmitter<IChartEvent<BasePoint>> = new EventEmitter<IChartEvent<BasePoint>>();\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\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.chartClick\n      .pipe(\n        takeWhile(() => this._alive)\n      ).subscribe((_) => {\n      this.chartClick.emit(_);\n    });\n\n    this._svc.chartContextMenu\n      .pipe(\n        takeWhile(() => this._alive)\n      ).subscribe((_) => {\n      this.chartContextMenu.emit(_);\n    });\n\n    this._svc.plotBandClick\n      .pipe(\n        takeWhile(() => this._alive))\n      .subscribe((_) => {\n        this.plotBandClick.emit(_);\n      });\n\n    this._svc.plotBandContextMenu\n      .pipe(\n        takeWhile(() => this._alive))\n      .subscribe((_) => {\n        this.plotBandContextMenu.emit(_);\n      });\n  }\n\n  ngAfterViewInit() {\n  }\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"]}
+//# 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} 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<IChartEvent<PlotBand>>();\n\n  @Output()\n  plotBandClick: EventEmitter<IChartEvent<PlotBand>> = new EventEmitter<IChartEvent<PlotBand>>();\n\n  @Output()\n  plotBandContextMenu: EventEmitter<IChartEvent<PlotBand>> = new EventEmitter<IChartEvent<PlotBand>>();\n\n\n  @Output()\n  plotLinesMove: EventEmitter<IChartEvent<PlotLine>> = new EventEmitter<IChartEvent<PlotLine>>();\n\n  @Output()\n  pointMove: EventEmitter<IChartEvent<IPointMove>> = new EventEmitter<IChartEvent<IPointMove>>();\n\n  @Output()\n  chartClick: EventEmitter<IChartEvent<BasePoint>> = new EventEmitter<IChartEvent<BasePoint>>();\n\n  @Output()\n  chartContextMenu: EventEmitter<IChartEvent<BasePoint>> = new EventEmitter<IChartEvent<BasePoint>>();\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\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.chartClick\n      .pipe(\n        takeWhile(() => this._alive)\n      ).subscribe((_) => {\n      this.chartClick.emit(_);\n    });\n\n    this._svc.chartContextMenu\n      .pipe(\n        takeWhile(() => this._alive)\n      ).subscribe((_) => {\n      this.chartContextMenu.emit(_);\n    });\n\n    this._svc.plotBandClick\n      .pipe(\n        takeWhile(() => this._alive))\n      .subscribe((_) => {\n        this.plotBandClick.emit(_);\n      });\n\n    this._svc.plotBandContextMenu\n      .pipe(\n        takeWhile(() => this._alive))\n      .subscribe((_) => {\n        this.plotBandContextMenu.emit(_);\n      });\n  }\n\n  ngAfterViewInit() {\n  }\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/annotation/annotation.component.mjs

@@ -0,0 +1,57 @@
+import { Component, Input, ViewChild, } from '@angular/core';
+import * as d3annotation from 'd3-svg-annotation';
+import * as d3 from 'd3';
+import * as i0 from "@angular/core";
+export class AnnotationComponent {
+    constructor() { }
+    ngOnInit() { }
+    ngAfterViewInit() {
+        this._node = d3.select(this.node.nativeElement);
+        this.drawAnnotations();
+    }
+    drawAnnotations() {
+        if (!this.node)
+            return;
+        const annotations = this.annotations?.map((annotation) => {
+            const x = this.xScaleMap.get(annotation.xAxisIndex);
+            const y = this.yScaleMap.get(annotation.yAxisIndex);
+            return {
+                note: annotation.note,
+                connector: annotation.connector,
+                x: x(annotation.point?.x),
+                y: y(annotation.point?.y),
+                dx: annotation.dx,
+                dy: annotation.dy,
+                type: annotation.type ?? d3annotation.annotationLabel,
+                className: annotation.className,
+            };
+        });
+        this._makeAnnotations = d3annotation
+            .annotation()
+            .annotations(annotations ?? [])
+            .editMode(false);
+        this._node.call(this._makeAnnotations);
+    }
+    ngOnChanges(changes) {
+        if (changes.hasOwnProperty('xScaleMap') &&
+            changes.hasOwnProperty('yScaleMap')) {
+            this.drawAnnotations();
+        }
+    }
+}
+AnnotationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: AnnotationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AnnotationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: AnnotationComponent, selector: "[teta-annotation]", inputs: { annotations: "annotations", xScaleMap: "xScaleMap", yScaleMap: "yScaleMap" }, viewQueries: [{ propertyName: "node", first: true, predicate: ["svg"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<svg:g #svg></svg:g>\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: AnnotationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[teta-annotation]', template: "<svg:g #svg></svg:g>\n", styles: [""] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { annotations: [{
+                type: Input
+            }], xScaleMap: [{
+                type: Input
+            }], yScaleMap: [{
+                type: Input
+            }], node: [{
+                type: ViewChild,
+                args: ['svg']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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