@tetacom/svg-charts 1.0.1

package/dist/chart/model/enum/drag-point-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum DragPointType {
+    x = 0,
+    y = 1,
+    xy = 2
+}

package/dist/chart/model/enum/series-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum SeriesType {
+    line = 0,
+    bar = 1
+}

package/dist/chart/model/enum/tooltip-tracking.d.ts

@@ -0,0 +1,4 @@
+export declare enum TooltipTracking {
+    x = 0,
+    y = 1
+}

package/dist/chart/model/enum/zoom-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum ZoomType {
+    x = 0,
+    y = 1,
+    xy = 2
+}

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

@@ -0,0 +1,5 @@
+export interface IBroadcastMessage {
+    channel: string;
+    message: any;
+    domain?: number[];
+}

package/dist/chart/model/i-builder.d.ts

@@ -0,0 +1,3 @@
+export interface IBuilder<T, U> {
+    build(settings: T): U;
+}

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

@@ -0,0 +1,32 @@
+import { Series } from './series';
+import { BasePoint } from './base-point';
+import { AxisOptions } from './axis-options';
+import { ZoomType } from './enum/zoom-type';
+import { TooltipOptions } from './tooltip-options';
+import { ChartBounds } from './chart-bounds';
+import { BrushType } from './enum/brush-type';
+export interface IChartConfig {
+    name?: string;
+    series?: Series<BasePoint>[];
+    zoom?: {
+        enable: boolean;
+        type: ZoomType;
+        syncChannel?: string;
+    };
+    brush?: {
+        enable: boolean;
+        type: BrushType;
+        axisIndex?: number;
+    };
+    legend?: {
+        enable?: boolean;
+    };
+    bounds?: ChartBounds;
+    inverted?: boolean;
+    tooltip?: TooltipOptions;
+    xAxis: AxisOptions[];
+    yAxis: AxisOptions[];
+    gridLines?: boolean;
+    width?: number;
+    height?: number;
+}

package/dist/chart/model/i-chart-event.d.ts

@@ -0,0 +1,4 @@
+export interface IChartEvent<T> {
+    event?: any;
+    target?: T;
+}

package/dist/chart/model/i-display-tooltip.d.ts

@@ -0,0 +1,6 @@
+import { BasePoint } from './base-point';
+import { Series } from './series';
+export interface IDisplayTooltip {
+    point: BasePoint;
+    series: Series<BasePoint>;
+}

package/dist/chart/model/i-point-move.d.ts

@@ -0,0 +1,6 @@
+import { Series } from './series';
+import { BasePoint } from './base-point';
+export interface IPointMove {
+    series: Series<BasePoint>;
+    point: BasePoint;
+}

package/dist/chart/model/marker-options.d.ts

@@ -0,0 +1,7 @@
+import { DragPointType } from './enum/drag-point-type';
+import { SvgAttributes } from './svg-attributes';
+export interface MarkerOptions {
+    draggable?: boolean;
+    dragType: DragPointType;
+    style?: SvgAttributes;
+}

package/dist/chart/model/plotband.d.ts

@@ -0,0 +1,31 @@
+import { SvgAttributes } from './svg-attributes';
+export declare class Plotband {
+    id: number | string;
+    from: number;
+    to: number;
+    label?: string;
+    showGrabbers?: boolean;
+    draggable?: boolean;
+    resizable?: boolean;
+    min?: number;
+    max?: number;
+    style?: {
+        plotband?: SvgAttributes;
+        grabbers?: SvgAttributes;
+    };
+    constructor(options?: {
+        id: any;
+        from: number;
+        to: number;
+        label?: string;
+        showGrabbers?: boolean;
+        draggable?: boolean;
+        resizable?: boolean;
+        min?: number;
+        max?: number;
+        style?: {
+            plotband?: SvgAttributes;
+            grabbers?: SvgAttributes;
+        };
+    });
+}

package/dist/chart/model/plotline.d.ts

@@ -0,0 +1,19 @@
+import { SvgAttributes } from './svg-attributes';
+export declare class PlotLine {
+    id?: number | string;
+    value: number;
+    label?: string;
+    min?: number;
+    max?: number;
+    draggable?: boolean;
+    style?: SvgAttributes;
+    constructor(options?: {
+        id?: number;
+        value: number;
+        label?: string;
+        min?: number;
+        max?: number;
+        draggable?: boolean;
+        style?: SvgAttributes;
+    });
+}

package/dist/chart/model/series.d.ts

@@ -0,0 +1,17 @@
+import { BasePoint } from './base-point';
+import { SeriesType } from './enum/series-type';
+import { SeriesBaseComponent } from '../base/series-base.component';
+import { SvgAttributes } from './svg-attributes';
+export interface Series<T extends BasePoint> {
+    id?: number | string;
+    type: SeriesType;
+    data: T[];
+    name?: string;
+    xAxisIndex?: number;
+    yAxisIndex?: number;
+    component?: typeof SeriesBaseComponent;
+    visible?: boolean;
+    color?: string;
+    showInLegend?: boolean;
+    style?: SvgAttributes;
+}

package/dist/chart/model/svg-attributes.d.ts

@@ -0,0 +1,14 @@
+export interface SvgAttributes {
+    className?: string;
+    fill?: string;
+    fillOpacity?: number;
+    opacity?: number;
+    stroke?: string;
+    strokeLinecap?: 'butt' | 'round' | 'square';
+    strokeLinejoin?: 'butt' | 'round' | 'square';
+    strokeDasharray?: string;
+    strokeOpacity?: number;
+    strokeWidth?: number;
+    patternImage?: string;
+    radius?: number;
+}

package/dist/chart/model/tooltip-options.d.ts

@@ -0,0 +1,8 @@
+import { TooltipTracking } from './enum/tooltip-tracking';
+export interface TooltipOptions {
+    enable?: boolean;
+    showMarkers?: boolean;
+    showLine?: boolean;
+    tracking?: TooltipTracking;
+    format?: (data: any) => any;
+}

package/dist/chart/service/axes.service.d.ts

@@ -0,0 +1,11 @@
+import { IChartConfig } from '../model/i-chart-config';
+import { Axis } from '../core/axis/axis';
+import * as i0 from "@angular/core";
+export declare class AxesService {
+    yAxis: Map<number, Axis>;
+    xAxis: Map<number, Axis>;
+    constructor();
+    init(config: IChartConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AxesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AxesService>;
+}

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

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

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

@@ -0,0 +1,17 @@
+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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrushService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrushService>;
+}

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

@@ -0,0 +1,38 @@
+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 { IPointMove } from '../model/i-point-move';
+import * as i0 from "@angular/core";
+export declare class ChartService {
+    private axesService;
+    private scaleService;
+    size: Observable<DOMRect>;
+    pointerMove: Observable<any>;
+    tooltips: Observable<IDisplayTooltip>;
+    plotbandMove: Observable<IChartEvent<Plotband>>;
+    plotlineMove: Observable<IChartEvent<PlotLine>>;
+    pointMove: Observable<IChartEvent<IPointMove>>;
+    private size$;
+    private pointerMove$;
+    private tooltips$;
+    private plotbandMove$;
+    private plotlineMove$;
+    private pointMove$;
+    private _config;
+    constructor(axesService: AxesService, scaleService: ScaleService);
+    init(config: IChartConfig): void;
+    setSize(size: DOMRect): void;
+    setPointerMove(event: any): void;
+    setTooltip(tooltip: IDisplayTooltip): void;
+    emitPlotband(event: IChartEvent<Plotband>): void;
+    emitPlotline(event: IChartEvent<PlotLine>): void;
+    emitPoint(event: IChartEvent<IPointMove>): void;
+    get config(): IChartConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChartService>;
+}

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

@@ -0,0 +1,14 @@
+import { AxesService } from './axes.service';
+import { IChartConfig } from '../model/i-chart-config';
+import * as i0 from "@angular/core";
+export declare class ScaleService {
+    private axesService;
+    yScales: Map<number | string, any>;
+    xScales: Map<number | string, any>;
+    private scaleMapping;
+    constructor(axesService: AxesService);
+    createScales(size: DOMRect, config?: IChartConfig): void;
+    private getScale;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScaleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScaleService>;
+}

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

@@ -0,0 +1,25 @@
+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 * as i0 from "@angular/core";
+export declare class ZoomService {
+    private scaleService;
+    private broadcastService;
+    private chartService;
+    zoomed: Observable<any>;
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ZoomService>;
+}

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

@@ -0,0 +1,34 @@
+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";
+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;
+        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 });
+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: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWVzLWJhc2UuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2NoYXJ0L2Jhc2Uvc2VyaWVzLWJhc2UuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxTQUFTLEVBRVQsS0FBSyxHQUVOLE1BQU0sZUFBZSxDQUFDO0FBTXZCLE9BQU8sRUFBYyxHQUFHLEVBQUUsTUFBTSxNQUFNLENBQUM7Ozs7O0FBS3ZDLE1BQU0sT0FBTyxtQkFBbUI7SUFNOUIsWUFDWSxHQUFpQixFQUNqQixHQUFzQixFQUN0QixZQUEwQixFQUMxQixXQUF3QixFQUN4QixPQUFtQjtRQUpuQixRQUFHLEdBQUgsR0FBRyxDQUFjO1FBQ2pCLFFBQUcsR0FBSCxHQUFHLENBQW1CO1FBQ3RCLGlCQUFZLEdBQVosWUFBWSxDQUFjO1FBQzFCLGdCQUFXLEdBQVgsV0FBVyxDQUFhO1FBQ3hCLFlBQU8sR0FBUCxPQUFPLENBQVk7UUFFN0IsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNO2FBQ3BCLElBQUksQ0FDSCxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRTtZQUNSLElBQUksQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUM7UUFDM0IsQ0FBQyxDQUFDLENBQ0g7YUFDQSxTQUFTLEVBQUUsQ0FBQztJQUNqQixDQUFDO0lBRUQsUUFBUSxLQUFVLENBQUM7O2dIQXRCUixtQkFBbUI7b0dBQW5CLG1CQUFtQixnR0FGcEIsRUFBRTsyRkFFRCxtQkFBbUI7a0JBSC9CLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLEVBQUU7aUJBQ2I7aU5BRVUsTUFBTTtzQkFBZCxLQUFLO2dCQUNHLElBQUk7c0JBQVosS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENoYW5nZURldGVjdG9yUmVmLFxuICBDb21wb25lbnQsXG4gIEVsZW1lbnRSZWYsXG4gIElucHV0LFxuICBPbkluaXQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ2hhcnRTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZS9jaGFydC5zZXJ2aWNlJztcbmltcG9ydCB7IFNlcmllcyB9IGZyb20gJy4uL21vZGVsL3Nlcmllcyc7XG5pbXBvcnQgeyBCYXNlUG9pbnQgfSBmcm9tICcuLi9tb2RlbC9iYXNlLXBvaW50JztcbmltcG9ydCB7IFNjYWxlU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2Uvc2NhbGUuc2VydmljZSc7XG5pbXBvcnQgeyBab29tU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2Uvem9vbS5zZXJ2aWNlJztcbmltcG9ydCB7IE9ic2VydmFibGUsIHRhcCB9IGZyb20gJ3J4anMnO1xuXG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6ICcnLFxufSlcbmV4cG9ydCBjbGFzcyBTZXJpZXNCYXNlQ29tcG9uZW50PFQgZXh0ZW5kcyBCYXNlUG9pbnQ+IGltcGxlbWVudHMgT25Jbml0IHtcbiAgQElucHV0KCkgc2VyaWVzOiBTZXJpZXM8VD47XG4gIEBJbnB1dCgpIHNpemU6IERPTVJlY3Q7XG5cbiAgem9vbTogT2JzZXJ2YWJsZTxhbnk+O1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByb3RlY3RlZCBzdmM6IENoYXJ0U2VydmljZSxcbiAgICBwcm90ZWN0ZWQgY2RyOiBDaGFuZ2VEZXRlY3RvclJlZixcbiAgICBwcm90ZWN0ZWQgc2NhbGVTZXJ2aWNlOiBTY2FsZVNlcnZpY2UsXG4gICAgcHJvdGVjdGVkIHpvb21TZXJ2aWNlOiBab29tU2VydmljZSxcbiAgICBwcm90ZWN0ZWQgZWxlbWVudDogRWxlbWVudFJlZlxuICApIHtcbiAgICB0aGlzLnpvb21TZXJ2aWNlLnpvb21lZFxuICAgICAgLnBpcGUoXG4gICAgICAgIHRhcCgoXykgPT4ge1xuICAgICAgICAgIHRoaXMuY2RyLmRldGVjdENoYW5nZXMoKTtcbiAgICAgICAgfSlcbiAgICAgIClcbiAgICAgIC5zdWJzY3JpYmUoKTtcbiAgfVxuXG4gIG5nT25Jbml0KCk6IHZvaWQge31cbn1cbiJdfQ==

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

@@ -0,0 +1,73 @@
+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 { AxesService } from '../service/axes.service';
+import { ChartBounds } from '../model/chart-bounds';
+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.plotLinesMove = new EventEmitter();
+        this.pointMove = new EventEmitter();
+    }
+    set config(config) {
+        this._config = Object.assign({
+            bounds: new ChartBounds(),
+        }, config);
+    }
+    get config() {
+        return this._config;
+    }
+    ngOnChanges(changes) { }
+    ngOnInit() {
+        this.svc.plotbandMove.subscribe((_) => {
+            this.plotBandsMove.emit(_);
+        });
+        this.svc.plotlineMove.subscribe((_) => {
+            this.plotLinesMove.emit(_);
+        });
+        this.svc.pointMove.subscribe((_) => {
+            this.pointMove.emit(_);
+        });
+    }
+    ngAfterViewInit() { }
+    ngOnDestroy() {
+        this.zoomService.broadcastSubscribtion?.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-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 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-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"] }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i2.ZoomService }]; }, propDecorators: { plotBandsMove: [{
+                type: Output
+            }], plotLinesMove: [{
+                type: Output
+            }], pointMove: [{
+                type: Output
+            }], config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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