@tetacom/svg-charts 1.0.1

package/dist/esm2020/chart/service/brush.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { BrushType } from '../model/enum/brush-type';
+import * as d3 from 'd3';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./broadcast.service";
+import * as i2 from "./scale.service";
+export class BrushService {
+    constructor(broadcastService, scaleService) {
+        this.broadcastService = broadcastService;
+        this.scaleService = scaleService;
+        this.brushMap = new Map()
+            .set(BrushType.x, d3.brushX())
+            .set(BrushType.y, d3.brushY());
+        this.scaleMap = new Map()
+            .set(BrushType.x, 'xScales')
+            .set(BrushType.y, 'yScales');
+    }
+    applyBrush(svgElement, config, size) {
+        this.broadcastSubscribtion?.unsubscribe();
+        if (config.brush?.enable) {
+            const s = this.scaleService[this.scaleMap.get(config?.brush?.type ?? BrushType.x)].get(config?.brush?.axisIndex ?? 0);
+            const brush = this.brushMap.get(config?.brush?.type ?? BrushType.x);
+            const container = d3.select(svgElement.nativeElement);
+            const brushBehavior = brush.on('start brush end', (_) => {
+                if (_.sourceEvent) {
+                    const [from, to] = _.selection;
+                    if (to - from < 5) {
+                        container.call(brush.move, [from, to]);
+                        return;
+                    }
+                    this.broadcastService.broadcast({
+                        channel: config?.zoom?.syncChannel,
+                        message: {
+                            ..._,
+                            selection: [s.invert(from), s.invert(to)],
+                            brushType: config?.brush?.type ?? BrushType.x,
+                        },
+                    });
+                }
+            });
+            container.call(brushBehavior);
+            setTimeout(() => {
+                container.call(brush.move, s.domain().map(s), {});
+            });
+            this.broadcastSubscribtion = this.broadcastService
+                .subscribeToChannel(config?.zoom?.syncChannel)
+                .pipe(map((_) => {
+                if (_.message?.transform) {
+                    const s = this.scaleService[this.scaleMap.get(config?.brush?.type ?? BrushType.x)].get(config?.brush?.axisIndex ?? 0);
+                    const domain = _.domain;
+                    container.call(brush.move, [s(domain[0]), s(domain[1])]);
+                }
+            }))
+                .subscribe();
+        }
+    }
+}
+BrushService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: BrushService, deps: [{ token: i1.BroadcastService }, { token: i2.ScaleService }], target: i0.ɵɵFactoryTarget.Injectable });
+BrushService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: BrushService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: BrushService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BroadcastService }, { type: i2.ScaleService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/chart/service/chart.service.mjs

@@ -0,0 +1,76 @@
+import { Injectable } from '@angular/core';
+import { map, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./axes.service";
+import * as i2 from "./scale.service";
+export class ChartService {
+    constructor(axesService, scaleService) {
+        this.axesService = axesService;
+        this.scaleService = scaleService;
+        this.size$ = new Subject();
+        this.pointerMove$ = new Subject();
+        this.tooltips$ = new Subject();
+        this.plotbandMove$ = new Subject();
+        this.plotlineMove$ = new Subject();
+        this.pointMove$ = new Subject();
+        this.size = this.size$.asObservable();
+        this.pointerMove = this.pointerMove$.asObservable();
+        this.tooltips = this.tooltips$.asObservable();
+        this.plotbandMove = this.plotbandMove$.asObservable();
+        this.plotlineMove = this.plotlineMove$.asObservable();
+        this.pointMove = this.pointMove$.asObservable();
+        this.size
+            .pipe(map((size) => {
+            this.scaleService.createScales(size, this._config);
+        }))
+            .subscribe();
+    }
+    init(config) {
+        this._config = config;
+        if (config.inverted) {
+            this._config.series = this._config?.series?.map((serie) => {
+                return {
+                    ...serie,
+                    data: serie?.data?.map((point) => {
+                        return {
+                            ...point,
+                            x: point?.y,
+                            y: point?.x,
+                        };
+                    }),
+                };
+            });
+        }
+        this.axesService.init(this._config);
+    }
+    setSize(size) {
+        this.size$.next(size);
+    }
+    setPointerMove(event) {
+        this.pointerMove$.next({ event });
+    }
+    setTooltip(tooltip) {
+        this.tooltips$.next(tooltip);
+    }
+    emitPlotband(event) {
+        this.plotbandMove$.next(event);
+    }
+    emitPlotline(event) {
+        this.plotlineMove$.next(event);
+    }
+    emitPoint(event) {
+        this.pointMove$.next(event);
+    }
+    get config() {
+        return this._config;
+    }
+}
+ChartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartService, deps: [{ token: i1.AxesService }, { token: i2.ScaleService }], target: i0.ɵɵFactoryTarget.Injectable });
+ChartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AxesService }, { type: i2.ScaleService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/chart/service/scale.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import * as d3 from 'd3';
+import { AxisType } from '../model/enum/axis-type';
+import { AxisOrientation } from '../model/enum/axis-orientation';
+import * as i0 from "@angular/core";
+import * as i1 from "./axes.service";
+export class ScaleService {
+    constructor(axesService) {
+        this.axesService = axesService;
+        this.yScales = new Map();
+        this.xScales = new Map();
+        this.scaleMapping = new Map()
+            .set(AxisType.number, d3.scaleLinear)
+            .set(AxisType.time, d3.scaleTime)
+            .set(AxisType.category, d3.scaleOrdinal)
+            .set(AxisType.log, d3.scaleLog);
+    }
+    createScales(size, config) {
+        this.yScales.clear();
+        this.xScales.clear();
+        const topBound = [...this.axesService.xAxis.values()]
+            .filter((_) => _.options?.visible && _.options?.opposite)
+            .reduce((acc, cur) => acc + cur.selfSize, 0);
+        const bottomBound = [...this.axesService.xAxis.values()]
+            .filter((_) => _.options?.visible && _.options?.opposite !== true)
+            .reduce((acc, cur) => acc + cur.selfSize, 0);
+        const leftBound = [...this.axesService.yAxis.values()]
+            .filter((_) => _.options?.visible && _.options.opposite !== true)
+            .reduce((acc, cur) => acc + cur.selfSize, 0);
+        const rightBound = [...this.axesService.yAxis.values()]
+            .filter((_) => _.options?.visible && _.options.opposite)
+            .reduce((acc, cur) => acc + cur.selfSize, 0);
+        this.axesService.yAxis.forEach((axis) => {
+            const scale = this.getScale(axis).range([
+                0,
+                size.height - topBound - bottomBound,
+            ]);
+            this.yScales.set(axis.index, scale);
+        });
+        this.axesService.xAxis.forEach((axis) => {
+            const scale = this.getScale(axis).range([
+                0,
+                size.width - leftBound - rightBound,
+            ]);
+            this.xScales.set(axis.index, scale);
+        });
+    }
+    getScale(axis) {
+        return this.scaleMapping
+            .get(axis.options?.type)()
+            .domain(axis.orientation === AxisOrientation.y
+            ? [...axis.extremes].reverse()
+            : axis.extremes);
+    }
+}
+ScaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ScaleService, deps: [{ token: i1.AxesService }], target: i0.ɵɵFactoryTarget.Injectable });
+ScaleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ScaleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ScaleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AxesService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/chart/service/zoom.service.mjs

@@ -0,0 +1,117 @@
+import { Injectable } from '@angular/core';
+import * as d3 from 'd3';
+import { zoomIdentity } from 'd3';
+import { map, merge, of, Subject } from 'rxjs';
+import { ZoomType } from '../model/enum/zoom-type';
+import { BrushType } from '../model/enum/brush-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./scale.service";
+import * as i2 from "./broadcast.service";
+import * as i3 from "./chart.service";
+export class ZoomService {
+    constructor(scaleService, broadcastService, chartService) {
+        this.scaleService = scaleService;
+        this.broadcastService = broadcastService;
+        this.chartService = chartService;
+        this.zoomed$ = new Subject();
+        this.x = new Map();
+        this.y = new Map();
+        this.initialZoom = zoomIdentity;
+        this.zoomed = this.zoomed$.asObservable();
+        merge(of(1), this.chartService.size)
+            .pipe(map((_) => {
+            this.x = new Map(this.scaleService.xScales);
+            this.y = new Map(this.scaleService.yScales);
+            if (this.svg) {
+                const currentTransform = d3.zoomTransform(this.svg.node());
+                this.setZoom(currentTransform);
+            }
+        }))
+            .subscribe();
+    }
+    applyZoom(svgElement, config, size) {
+        this.broadcastSubscribtion?.unsubscribe();
+        this.svg = d3.select(svgElement.nativeElement);
+        const zoomType = config?.zoom?.type;
+        const enable = config?.zoom?.enable;
+        const zoomed = (event) => {
+            const { transform } = event;
+            if (zoomType === ZoomType.x || zoomType === ZoomType.xy) {
+                for (let [index, scale] of this.x.entries()) {
+                    this.scaleService.xScales.set(index, transform.rescaleX(scale));
+                }
+            }
+            if (zoomType === ZoomType.y || zoomType === ZoomType.xy) {
+                for (let [index, scale] of this.y.entries()) {
+                    this.scaleService.yScales.set(index, transform.rescaleY(scale));
+                }
+            }
+            if (enable) {
+                this.zoomed$.next({ event });
+                if (event.sourceEvent) {
+                    this.broadcastService.broadcast({
+                        channel: config?.zoom?.syncChannel,
+                        message: event,
+                        domain: this.scaleService[config?.zoom?.type === ZoomType.x ? 'xScales' : 'yScales']
+                            .get(config.brush?.axisIndex ?? 0)
+                            .domain(),
+                    });
+                }
+            }
+        };
+        if (enable) {
+            this.zoom = d3
+                .zoom()
+                .scaleExtent([1, Infinity])
+                .extent([
+                [0, 0],
+                [size.width, size.height],
+            ]);
+            this.zoom.on('start zoom end', zoomed);
+            this.svg.call(this.zoom);
+            this.svg.call(this.zoom.transform, this.initialZoom);
+            const sc = config?.zoom?.type === ZoomType.x
+                ? this.x.get(config.brush?.axisIndex ?? 0)
+                : this.y.get(config.brush?.axisIndex ?? 0);
+            this.broadcastSubscribtion = this.broadcastService
+                .subscribeToChannel(config?.zoom?.syncChannel)
+                .pipe(map((_) => {
+                const currentTransform = d3.zoomTransform(this.svg.node());
+                const { message } = _;
+                if (currentTransform !== message?.transform) {
+                    if (message.selection) {
+                        const s = message.selection;
+                        const domain = sc.domain();
+                        const scale = (domain[1] - domain[0]) / (s[1] - s[0]);
+                        let transform = zoomIdentity.scale(scale);
+                        if (message?.brushType === BrushType.x) {
+                            transform = transform.translate(-sc(s[0]), 0);
+                        }
+                        if (message?.brushType === BrushType.y) {
+                            transform = transform.translate(0, -sc(s[0]));
+                        }
+                        this.setZoom(transform);
+                        return;
+                    }
+                    this.setZoom(message?.transform);
+                }
+            }))
+                .subscribe();
+        }
+    }
+    setZoom(transform) {
+        // requestAnimationFrame(() => {
+        //
+        // });
+        this.svg?.call(this.zoom.transform, transform);
+    }
+}
+ZoomService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ZoomService, deps: [{ token: i1.ScaleService }, { token: i2.BroadcastService }, { token: i3.ChartService }], target: i0.ɵɵFactoryTarget.Injectable });
+ZoomService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ZoomService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ZoomService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ScaleService }, { type: i2.BroadcastService }, { type: i3.ChartService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zoom.service.js","sourceRoot":"","sources":["../../../../src/chart/service/zoom.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable } from '@angular/core';\nimport * as d3 from 'd3';\nimport { D3ZoomEvent, zoomIdentity } from 'd3';\nimport { ScaleService } from './scale.service';\nimport { map, merge, Observable, of, Subject, Subscription } from 'rxjs';\nimport { IChartEvent } from '../model/i-chart-event';\nimport { ZoomType } from '../model/enum/zoom-type';\nimport { IChartConfig } from '../model/i-chart-config';\nimport { BroadcastService } from './broadcast.service';\nimport { ChartService } from './chart.service';\nimport { BrushType } from '../model/enum/brush-type';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ZoomService {\n  zoomed: Observable<any>;\n  private zoomed$ = new Subject<any>();\n\n  broadcastSubscribtion: Subscription;\n\n  private x = new Map<number | string, any>();\n  private y = new Map<number | string, any>();\n\n  private zoom;\n  private svg;\n  private initialZoom = zoomIdentity;\n\n  constructor(\n    private scaleService: ScaleService,\n    private broadcastService: BroadcastService,\n    private chartService: ChartService\n  ) {\n    this.zoomed = this.zoomed$.asObservable();\n\n    merge(of(1), this.chartService.size)\n      .pipe(\n        map((_) => {\n          this.x = new Map(this.scaleService.xScales);\n          this.y = new Map(this.scaleService.yScales);\n\n          if (this.svg) {\n            const currentTransform = d3.zoomTransform(this.svg.node());\n            this.setZoom(currentTransform);\n          }\n        })\n      )\n      .subscribe();\n  }\n\n  applyZoom(svgElement: ElementRef, config: IChartConfig, size: DOMRect) {\n    this.broadcastSubscribtion?.unsubscribe();\n\n    this.svg = d3.select(svgElement.nativeElement);\n\n    const zoomType = config?.zoom?.type;\n    const enable = config?.zoom?.enable;\n\n    const zoomed = (event: D3ZoomEvent<any, any>) => {\n      const { transform } = event;\n\n      if (zoomType === ZoomType.x || zoomType === ZoomType.xy) {\n        for (let [index, scale] of this.x.entries()) {\n          this.scaleService.xScales.set(index, transform.rescaleX(scale));\n        }\n      }\n\n      if (zoomType === ZoomType.y || zoomType === ZoomType.xy) {\n        for (let [index, scale] of this.y.entries()) {\n          this.scaleService.yScales.set(index, transform.rescaleY(scale));\n        }\n      }\n\n      if (enable) {\n        this.zoomed$.next({ event });\n\n        if (event.sourceEvent) {\n          this.broadcastService.broadcast({\n            channel: config?.zoom?.syncChannel,\n            message: event,\n            domain: this.scaleService[\n              config?.zoom?.type === ZoomType.x ? 'xScales' : 'yScales'\n            ]\n              .get(config.brush?.axisIndex ?? 0)\n              .domain(),\n          });\n        }\n      }\n    };\n\n    if (enable) {\n      this.zoom = d3\n        .zoom()\n        .scaleExtent([1, Infinity])\n        .extent([\n          [0, 0],\n          [size.width, size.height],\n        ]);\n\n      this.zoom.on('start zoom end', zoomed);\n      this.svg.call(this.zoom);\n      this.svg.call(this.zoom.transform, this.initialZoom);\n\n      const sc =\n        config?.zoom?.type === ZoomType.x\n          ? this.x.get(config.brush?.axisIndex ?? 0)\n          : this.y.get(config.brush?.axisIndex ?? 0);\n\n      this.broadcastSubscribtion = this.broadcastService\n        .subscribeToChannel(config?.zoom?.syncChannel)\n        .pipe(\n          map((_) => {\n            const currentTransform = d3.zoomTransform(this.svg.node());\n\n            const { message } = _;\n            if (currentTransform !== message?.transform) {\n              if (message.selection) {\n                const s = message.selection;\n\n                const domain = sc.domain();\n\n                const scale = (domain[1] - domain[0]) / (s[1] - s[0]);\n\n                let transform = zoomIdentity.scale(scale);\n\n                if (message?.brushType === BrushType.x) {\n                  transform = transform.translate(-sc(s[0]), 0);\n                }\n                if (message?.brushType === BrushType.y) {\n                  transform = transform.translate(0, -sc(s[0]));\n                }\n\n                this.setZoom(transform);\n\n                return;\n              }\n\n              this.setZoom(message?.transform);\n            }\n          })\n        )\n        .subscribe();\n    }\n  }\n\n  setZoom(transform: any) {\n    // requestAnimationFrame(() => {\n    //\n    // });\n\n    this.svg?.call(this.zoom.transform, transform);\n  }\n}\n"]}

package/dist/esm2020/public-api.mjs

@@ -0,0 +1,7 @@
+/*
+ * Public API Surface of chart
+ */
+export * from './chart/chart.module';
+export * from './chart/service/chart.service';
+export * from './chart/chart/chart.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGNoYXJ0XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9jaGFydC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9zZXJ2aWNlL2NoYXJ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9jaGFydC9jaGFydC5jb21wb25lbnQnO1xuIl19

package/dist/esm2020/tetacom-svg-charts.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV0YWNvbS1zdmctY2hhcnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RldGFjb20tc3ZnLWNoYXJ0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19