@tetacom/svg-charts 1.4.21 → 1.4.22

package/esm2022/chart/service/zoom.service.mjs

@@ -0,0 +1,85 @@
+import { BehaviorSubject, combineLatest, filter, shareReplay } from 'rxjs';
+import { AxisOrientation } from '../model/enum/axis-orientation';
+import { Injectable } from '@angular/core';
+import { zoomIdentity } from 'd3';
+import { ZoomType } from "../model/enum/zoom-type";
+import * as i0 from "@angular/core";
+import * as i1 from "./broadcast.service";
+import * as i2 from "./chart.service";
+export class ZoomService {
+    _broadcast;
+    _chart;
+    zoomed;
+    zoomed$ = new BehaviorSubject(null);
+    broadcastChannel;
+    broadcastSub;
+    constructor(_broadcast, _chart) {
+        this._broadcast = _broadcast;
+        this._chart = _chart;
+        this.zoomed = this.zoomed$.asObservable().pipe(shareReplay({
+            bufferSize: 1,
+            refCount: true
+        }));
+    }
+    fireZoom(zoom) {
+        this.zoomed$.next(zoom);
+    }
+    broadcastZoom(zoom) {
+        if (this.broadcastChannel?.length) {
+            this._broadcast.broadcastZoom({
+                channel: this.broadcastChannel,
+                message: zoom
+            });
+        }
+    }
+    setBroadcastChannel(channel) {
+        if (this.broadcastSub) {
+            this.broadcastSub?.unsubscribe();
+        }
+        this.broadcastChannel = channel;
+        if (this.broadcastChannel?.length) {
+            this.broadcastSub = combineLatest([this._broadcast.subscribeToZoom(this.broadcastChannel), this._chart.config])
+                .pipe(filter(([zoom, config]) => {
+                return zoom.message?.chartId !== config.id && (config.zoom.syncType === ZoomType.xy ||
+                    (zoom.message.axis.orientation === AxisOrientation.y && config.zoom.syncType === ZoomType.y) ||
+                    (zoom.message.axis.orientation === AxisOrientation.x && config.zoom.syncType === ZoomType.x));
+            }))
+                .subscribe(([zoom, config]) => {
+                this.fireZoom(zoom.message);
+            });
+        }
+    }
+    getD3Transform(targetDomain, originalDomain, scale, orientation, inverted) {
+        const zoomScale = Math.abs(scale(originalDomain[1]) - scale(originalDomain[0])) / Math.abs(scale(targetDomain[1]) - scale(targetDomain[0]));
+        let transform = zoomIdentity.scale(zoomScale);
+        if (orientation === AxisOrientation.x) {
+            if (!!inverted) {
+                transform = transform.translate(-scale(Math.max(...targetDomain)), 0);
+            }
+            else {
+                transform = transform.translate(-scale(Math.min(...targetDomain)), 0);
+            }
+        }
+        if (orientation === AxisOrientation.y) {
+            if (!!inverted) {
+                transform = transform.translate(0, -scale(Math.min(...targetDomain)));
+            }
+            else {
+                transform = transform.translate(0, -scale(Math.max(...targetDomain)));
+            }
+        }
+        return transform;
+    }
+    ngOnDestroy() {
+        this.broadcastSub?.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ZoomService, deps: [{ token: i1.BroadcastService }, { token: i2.ChartService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ZoomService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ZoomService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BroadcastService }, { type: i2.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 {BehaviorSubject, combineLatest, filter, Observable, shareReplay, Subscription} from 'rxjs';\nimport {AxisOrientation} from '../model/enum/axis-orientation';\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {IBroadcastMessage, ZoomMessage} from '../model/i-broadcast-message';\nimport {zoomIdentity} from 'd3';\nimport {BroadcastService} from './broadcast.service';\nimport {ChartService} from './chart.service';\nimport {IChartConfig} from \"../model/i-chart-config\";\nimport {ZoomType} from \"../model/enum/zoom-type\";\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ZoomService implements OnDestroy {\n  zoomed: Observable<ZoomMessage>;\n\n  private zoomed$ = new BehaviorSubject<ZoomMessage>(null);\n  private broadcastChannel: string;\n  private broadcastSub: Subscription;\n\n  constructor(private _broadcast: BroadcastService,\n              private _chart: ChartService) {\n    this.zoomed = this.zoomed$.asObservable().pipe(shareReplay({\n      bufferSize: 1,\n      refCount: true\n    }));\n  }\n\n  fireZoom(zoom: ZoomMessage) {\n    this.zoomed$.next(zoom);\n  }\n\n  broadcastZoom(zoom: ZoomMessage) {\n    if (this.broadcastChannel?.length) {\n      this._broadcast.broadcastZoom({\n        channel: this.broadcastChannel,\n        message: zoom\n      });\n    }\n  }\n\n  setBroadcastChannel(channel: string) {\n    if (this.broadcastSub) {\n      this.broadcastSub?.unsubscribe();\n    }\n    this.broadcastChannel = channel;\n    if (this.broadcastChannel?.length) {\n      this.broadcastSub = combineLatest(\n        [this._broadcast.subscribeToZoom(this.broadcastChannel), this._chart.config]\n      )\n        .pipe(filter(([zoom, config]: [IBroadcastMessage<ZoomMessage>, IChartConfig]) => {\n          return zoom.message?.chartId !== config.id && (\n            config.zoom.syncType === ZoomType.xy ||\n            (zoom.message.axis.orientation === AxisOrientation.y && config.zoom.syncType === ZoomType.y) ||\n            (zoom.message.axis.orientation === AxisOrientation.x && config.zoom.syncType === ZoomType.x)\n          );\n        }))\n        .subscribe(([zoom, config]) => {\n          this.fireZoom(zoom.message);\n        });\n    }\n  }\n\n  getD3Transform(targetDomain: [number, number],\n                 originalDomain: [number, number],\n                 scale,\n                 orientation: AxisOrientation,\n                 inverted: boolean) {\n    const zoomScale = Math.abs(scale(originalDomain[1]) - scale(originalDomain[0])) / Math.abs(scale(targetDomain[1]) - scale(targetDomain[0]));\n    let transform = zoomIdentity.scale(zoomScale);\n    if (orientation === AxisOrientation.x) {\n      if (!!inverted) {\n        transform = transform.translate(-scale(Math.max(...targetDomain)), 0);\n      } else {\n        transform = transform.translate(-scale(Math.min(...targetDomain)), 0);\n      }\n    }\n\n    if (orientation === AxisOrientation.y) {\n      if (!!inverted) {\n        transform = transform.translate(0, -scale(Math.min(...targetDomain)));\n      } else {\n        transform = transform.translate(0, -scale(Math.max(...targetDomain)));\n      }\n    }\n    return transform;\n  }\n\n  ngOnDestroy() {\n    this.broadcastSub?.unsubscribe();\n  }\n}\n"]}

package/esm2022/chart/stories/bandseries/bandseries.component.mjs

@@ -0,0 +1,36 @@
+import { Component } from '@angular/core';
+import { SeriesBaseComponent } from "../../base/series-base.component";
+import { map } 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";
+import * as i4 from "@angular/common";
+export class BandseriesComponent extends SeriesBaseComponent {
+    svc;
+    cdr;
+    scaleService;
+    zoomService;
+    element;
+    x;
+    y;
+    constructor(svc, cdr, scaleService, zoomService, element) {
+        super(svc, cdr, scaleService, zoomService, element);
+        this.svc = svc;
+        this.cdr = cdr;
+        this.scaleService = scaleService;
+        this.zoomService = zoomService;
+        this.element = element;
+    }
+    ngOnInit() {
+        this.x = this.scaleService.scales.pipe(map(_ => _.x.get(this.series.xAxisIndex)?.scale));
+        this.y = this.scaleService.scales.pipe(map(_ => _.y.get(this.series.yAxisIndex)?.scale));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BandseriesComponent, deps: [{ token: i1.ChartService }, { token: i0.ChangeDetectorRef }, { token: i2.ScaleService }, { token: i3.ZoomService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: BandseriesComponent, selector: "svg:svg[teta-bandseries]", usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"{x: x | async, y: y | async} as scales\">\n  <ng-container *ngFor=\"let band of _series.data\">\n    <svg:rect [attr.x]=\"scales.x(band.x)\"\n              [attr.y]=\"scales.y(band.y) - scales.y.bandwidth() / 2\"\n              [attr.width]=\"scales.x(band.x1) - scales.x(band.x)\"\n              fill=\"red\"\n              [attr.height]=\"scales.y.bandwidth()\">\n    </svg:rect>\n    <svg:text\n      text-anchor=\"middle\"\n      dominant-baseline=\"middle\"\n      class=\"label font-caption fill-text-90\"\n      [attr.x]=\"scales.x(band.x) + (scales.x(band.x1) - scales.x(band.x)) / 2\"\n      [attr.y]=\"scales.y(band.y)\">{{band.y}}\n    </svg:text>\n  </ng-container>\n\n</ng-container>\n", styles: [""], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BandseriesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'svg:svg[teta-bandseries]', template: "<ng-container *ngIf=\"{x: x | async, y: y | async} as scales\">\n  <ng-container *ngFor=\"let band of _series.data\">\n    <svg:rect [attr.x]=\"scales.x(band.x)\"\n              [attr.y]=\"scales.y(band.y) - scales.y.bandwidth() / 2\"\n              [attr.width]=\"scales.x(band.x1) - scales.x(band.x)\"\n              fill=\"red\"\n              [attr.height]=\"scales.y.bandwidth()\">\n    </svg:rect>\n    <svg:text\n      text-anchor=\"middle\"\n      dominant-baseline=\"middle\"\n      class=\"label font-caption fill-text-90\"\n      [attr.x]=\"scales.x(band.x) + (scales.x(band.x1) - scales.x(band.x)) / 2\"\n      [attr.y]=\"scales.y(band.y)\">{{band.y}}\n    </svg:text>\n  </ng-container>\n\n</ng-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ChartService }, { type: i0.ChangeDetectorRef }, { type: i2.ScaleService }, { type: i3.ZoomService }, { type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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