@tetacom/svg-charts 1.0.2 → 1.1.3

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

@@ -0,0 +1,95 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, filter, map, Subject } from 'rxjs';
+import { defaultChartConfig } from '../default/default-chart-config';
+import { defaultAxisConfig } from '../default/default-axis-config';
+import { defaultSeriesConfig } from '../default/default-series-config';
+import * as i0 from "@angular/core";
+export class ChartService {
+    constructor() {
+        this.config$ = new BehaviorSubject(defaultChartConfig);
+        this.size$ = new BehaviorSubject(new DOMRectReadOnly());
+        this.pointerMove$ = new BehaviorSubject(null);
+        this.tooltips$ = new Subject();
+        this.plotBandEvent$ = new Subject();
+        this.plotLineMove$ = new Subject();
+        this.pointMove$ = new Subject();
+        this.config = this.config$
+            .asObservable()
+            .pipe(map(this.setDefaults), map(this.setpreparationData));
+        this.size = this.size$.asObservable().pipe(filter((_) => {
+            return _.height > 0 && _.width > 0;
+        }));
+        this.pointerMove = this.pointerMove$.asObservable();
+        this.tooltips = this.tooltips$.asObservable();
+        this.plotBandEvent = this.plotBandEvent$.asObservable();
+        this.plotLineMove = this.plotLineMove$.asObservable();
+        this.pointMove = this.pointMove$.asObservable();
+        this.plotBandClick = this.plotBandEvent$
+            .asObservable()
+            .pipe(filter((_) => _?.event?.type === 'click'));
+    }
+    setConfig(config) {
+        this.config$.next(config);
+    }
+    setSize(size) {
+        this.size$.next(size);
+    }
+    setPointerMove(event) {
+        this.pointerMove$.next(event);
+    }
+    setTooltip(tooltip) {
+        this.tooltips$.next(tooltip);
+    }
+    emitPlotband(event) {
+        this.plotBandEvent$.next(event);
+    }
+    emitPlotline(event) {
+        this.plotLineMove$.next(event);
+    }
+    emitPoint(event) {
+        this.pointMove$.next(event);
+    }
+    setDefaults(config) {
+        const defaultConfig = (defaultConfig) => {
+            return (source) => {
+                return Object.assign({}, defaultConfig, source);
+            };
+        };
+        config = Object.assign({}, defaultChartConfig, config);
+        config.xAxis = config.xAxis.map(defaultConfig(defaultAxisConfig));
+        config.yAxis = config.yAxis.map(defaultConfig(defaultAxisConfig));
+        config.series = config.series.map(defaultConfig(defaultSeriesConfig));
+        config.tooltip = Object.assign({}, defaultChartConfig.tooltip, config.tooltip);
+        return config;
+    }
+    setpreparationData(config) {
+        if (config.inverted) {
+            config.series = config.series?.map((serie) => {
+                return {
+                    ...serie,
+                    data: serie?.data?.map((point) => {
+                        return {
+                            ...point,
+                            x: point?.y,
+                            y: point?.x,
+                        };
+                    }),
+                };
+            });
+        }
+        if (config.brush?.enable) {
+            config.yAxis = config.yAxis.map((_) => ({ ..._, zoom: false }));
+            config.xAxis = config.xAxis.map((_) => ({ ..._, zoom: false }));
+        }
+        return config;
+    }
+}
+ChartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ChartService, deps: [], 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 []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.service.js","sourceRoot":"","sources":["../../../../src/chart/service/chart.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { IChartConfig } from '../model/i-chart-config';\nimport { BehaviorSubject, filter, map, Observable, Subject } from 'rxjs';\nimport { IChartEvent } from '../model/i-chart-event';\nimport { IDisplayTooltip } from '../model/i-display-tooltip';\nimport { PlotBand } from '../model/plot-band';\nimport { PlotLine } from '../model/plot-line';\nimport { IPointMove } from '../model/i-point-move';\nimport { defaultChartConfig } from '../default/default-chart-config';\nimport { defaultAxisConfig } from '../default/default-axis-config';\nimport { defaultSeriesConfig } from '../default/default-series-config';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ChartService {\n  public config: Observable<IChartConfig>;\n  public size: Observable<DOMRect>;\n  public pointerMove: Observable<PointerEvent>;\n  public tooltips: Observable<IDisplayTooltip>;\n  public plotBandEvent: Observable<IChartEvent<PlotBand>>;\n  public plotLineMove: Observable<IChartEvent<PlotLine>>;\n  public plotBandClick: Observable<IChartEvent<PlotBand>>;\n  public pointMove: Observable<IChartEvent<IPointMove>>;\n\n  private config$ = new BehaviorSubject<IChartConfig>(defaultChartConfig);\n  private size$ = new BehaviorSubject<DOMRect>(new DOMRectReadOnly());\n  private pointerMove$ = new BehaviorSubject<PointerEvent>(null);\n  private tooltips$ = new Subject<IDisplayTooltip>();\n  private plotBandEvent$ = new Subject<IChartEvent<PlotBand>>();\n  private plotLineMove$ = new Subject<IChartEvent<PlotLine>>();\n  private pointMove$ = new Subject<IChartEvent<IPointMove>>();\n\n  constructor() {\n    this.config = this.config$\n      .asObservable()\n      .pipe(map(this.setDefaults), map(this.setpreparationData));\n    this.size = this.size$.asObservable().pipe(\n      filter((_) => {\n        return _.height > 0 && _.width > 0;\n      })\n    );\n\n    this.pointerMove = this.pointerMove$.asObservable();\n    this.tooltips = this.tooltips$.asObservable();\n    this.plotBandEvent = this.plotBandEvent$.asObservable();\n    this.plotLineMove = this.plotLineMove$.asObservable();\n    this.pointMove = this.pointMove$.asObservable();\n    this.plotBandClick = this.plotBandEvent$\n      .asObservable()\n      .pipe(filter((_) => _?.event?.type === 'click'));\n  }\n\n  public setConfig(config: IChartConfig) {\n    this.config$.next(config);\n  }\n\n  public setSize(size: DOMRect) {\n    this.size$.next(size);\n  }\n\n  public setPointerMove(event: PointerEvent) {\n    this.pointerMove$.next(event);\n  }\n\n  public setTooltip(tooltip: IDisplayTooltip) {\n    this.tooltips$.next(tooltip);\n  }\n\n  public emitPlotband(event: IChartEvent<PlotBand>) {\n    this.plotBandEvent$.next(event);\n  }\n\n  public emitPlotline(event: IChartEvent<PlotLine>) {\n    this.plotLineMove$.next(event);\n  }\n\n  public emitPoint(event: IChartEvent<IPointMove>) {\n    this.pointMove$.next(event);\n  }\n\n  private setDefaults(config: IChartConfig): IChartConfig {\n    const defaultConfig = (defaultConfig) => {\n      return (source) => {\n        return Object.assign({}, defaultConfig, source);\n      };\n    };\n    config = Object.assign({}, defaultChartConfig, config);\n\n    config.xAxis = config.xAxis.map(defaultConfig(defaultAxisConfig));\n    config.yAxis = config.yAxis.map(defaultConfig(defaultAxisConfig));\n    config.series = config.series.map(defaultConfig(defaultSeriesConfig));\n\n    config.tooltip = Object.assign(\n      {},\n      defaultChartConfig.tooltip,\n      config.tooltip\n    );\n\n    return config;\n  }\n\n  private setpreparationData(config: IChartConfig): IChartConfig {\n    if (config.inverted) {\n      config.series = config.series?.map((serie) => {\n        return {\n          ...serie,\n          data: serie?.data?.map((point) => {\n            return {\n              ...point,\n              x: point?.y,\n              y: point?.x,\n            };\n          }),\n        };\n      });\n    }\n\n    if (config.brush?.enable) {\n      config.yAxis = config.yAxis.map((_) => ({ ..._, zoom: false }));\n      config.xAxis = config.xAxis.map((_) => ({ ..._, zoom: false }));\n    }\n\n    return config;\n  }\n}\n"]}

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

@@ -0,0 +1,152 @@
+import { Injectable } from '@angular/core';
+import * as d3 from 'd3';
+import { Axis } from '../core/axis/axis';
+import { AxisOrientation } from '../model/enum/axis-orientation';
+import { combineLatest, map, shareReplay, withLatestFrom, } from 'rxjs';
+import { ScaleType } from '../model/enum/scale-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./chart.service";
+import * as i2 from "./zoom.service";
+export class ScaleService {
+    constructor(chartService, zoomService) {
+        this.chartService = chartService;
+        this.zoomService = zoomService;
+        this.transformCacheX = new Map();
+        this.transformCacheY = new Map();
+        this.scaleMapping = new Map()
+            .set(ScaleType.linear, d3.scaleLinear)
+            .set(ScaleType.time, d3.scaleTime)
+            .set(ScaleType.category, d3.scaleOrdinal)
+            .set(ScaleType.log, d3.scaleLog)
+            .set(ScaleType.pow, d3.scalePow)
+            .set(ScaleType.sqrt, d3.scaleSqrt);
+        this.xAxisMap = combineLatest([
+            this.chartService.size,
+            this.chartService.config,
+        ]).pipe(map((data) => {
+            const [, config] = data;
+            const map = new Map();
+            config.xAxis.map((_, index) => {
+                map.set(index, Axis.createAxis(AxisOrientation.x, config, index));
+            });
+            return map;
+        }));
+        this.yAxisMap = combineLatest([
+            this.chartService.size,
+            this.chartService.config,
+        ]).pipe(map((data) => {
+            const [, config] = data;
+            const map = new Map();
+            config.yAxis.map((_, index) => {
+                map.set(index, Axis.createAxis(AxisOrientation.y, config, index));
+            });
+            return map;
+        }));
+        this.xScaleMap = combineLatest([
+            this.chartService.size,
+            this.chartService.config,
+            this.zoomService.zoomed,
+        ]).pipe(withLatestFrom(this.yAxisMap, this.xAxisMap), map((data) => {
+            const [[size, config, zoom], yAxes, xAxes] = data;
+            const map = new Map();
+            const left = [...yAxes.values()]
+                .filter((_) => _.options?.visible && _.options?.opposite)
+                .reduce((acc, cur) => acc + cur.selfSize, 0);
+            const right = [...yAxes.values()]
+                .filter((_) => _.options?.visible && _.options?.opposite !== true)
+                .reduce((acc, cur) => acc + cur.selfSize, 0);
+            const finalWidth = (size.width || 0) - left - right;
+            xAxes.forEach((axis) => {
+                let domain = axis.extremes;
+                if (axis?.options.inverted) {
+                    domain = [...axis.extremes].reverse();
+                }
+                const scale = this.scaleMapping
+                    .get(axis.options.scaleType.type)()
+                    .domain(domain)
+                    .range([0, finalWidth]);
+                if (axis.options.scaleType.type === ScaleType.log) {
+                    scale.base(axis.options.scaleType.base);
+                }
+                map.set(axis.index, scale);
+                const hasCache = this.transformCacheX.has(axis.index);
+                const shouldRestore = zoom?.target?.orientation !== AxisOrientation.x ||
+                    zoom.target?.index !== axis.index;
+                if (hasCache && shouldRestore) {
+                    const restoredTransform = this.transformCacheX.get(axis.index);
+                    map.set(axis.index, restoredTransform.rescaleX(scale));
+                }
+            });
+            if (zoom) {
+                const event = zoom.event;
+                if (zoom.target?.orientation === AxisOrientation.x) {
+                    const currentScale = map.get(zoom.target.index);
+                    const rescaled = event.transform.rescaleX(currentScale);
+                    map.set(zoom.target.index, rescaled);
+                    const axis = xAxes.get(zoom.target.index);
+                    this.transformCacheX.set(axis.index, event.transform);
+                }
+            }
+            return map;
+        }), shareReplay(1));
+        this.yScaleMap = combineLatest([
+            this.chartService.size,
+            this.chartService.config,
+            this.zoomService.zoomed,
+        ]).pipe(withLatestFrom(this.yAxisMap, this.xAxisMap), map((data) => {
+            const [[size, config, zoom], yAxes, xAxes] = data;
+            const map = new Map();
+            const top = [...xAxes.values()]
+                .filter((_) => _.options?.visible && _.options?.opposite)
+                .reduce((acc, cur) => acc + cur.selfSize, 0);
+            const bottom = [...xAxes.values()]
+                .filter((_) => _.options?.visible && _.options?.opposite !== true)
+                .reduce((acc, cur) => acc + cur.selfSize, 0);
+            const finalHeight = (size.height || 0) - top - bottom;
+            yAxes.forEach((axis) => {
+                let domain = axis.extremes;
+                if (axis.orientation === AxisOrientation.y) {
+                    domain = [...axis.extremes].reverse();
+                }
+                if (axis?.options.inverted) {
+                    domain = domain.reverse();
+                }
+                const scale = this.scaleMapping
+                    .get(axis.options.scaleType.type)()
+                    .domain(domain)
+                    .range([0, finalHeight]);
+                if (axis.options.scaleType.type === ScaleType.log) {
+                    scale.base(axis.options.scaleType.base);
+                }
+                map.set(axis.index, scale);
+                const hasCache = this.transformCacheY.has(axis.index);
+                const shouldRestore = zoom?.target?.orientation !== AxisOrientation.y ||
+                    zoom.target?.index !== axis.index;
+                if (hasCache && shouldRestore) {
+                    const restoredTransform = this.transformCacheY.get(axis.index);
+                    map.set(axis.index, restoredTransform.rescaleY(scale));
+                }
+            });
+            if (zoom) {
+                const event = zoom.event;
+                if (zoom.target?.orientation === AxisOrientation.y) {
+                    const currentScale = map.get(zoom.target.index);
+                    const rescaled = event.transform.rescaleY(currentScale);
+                    map.set(zoom.target.index, rescaled);
+                    const axis = yAxes.get(zoom.target.index);
+                    this.transformCacheY.set(axis.index, event.transform);
+                }
+            }
+            return map;
+        }), shareReplay(1));
+    }
+}
+ScaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ScaleService, deps: [{ token: i1.ChartService }, { token: i2.ZoomService }], 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.ChartService }, { type: i2.ZoomService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scale.service.js","sourceRoot":"","sources":["../../../../src/chart/service/scale.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AAEzB,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGjE,OAAO,EACL,aAAa,EACb,GAAG,EAEH,WAAW,EACX,cAAc,GACf,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;;;;AAKrD,MAAM,OAAO,YAAY;IAkBvB,YACU,YAA0B,EAC1B,WAAwB;QADxB,iBAAY,GAAZ,YAAY,CAAc;QAC1B,gBAAW,GAAX,WAAW,CAAa;QAb1B,oBAAe,GAAG,IAAI,GAAG,EAAyB,CAAC;QACnD,oBAAe,GAAG,IAAI,GAAG,EAAyB,CAAC;QAEnD,iBAAY,GAAG,IAAI,GAAG,EAAkB;aAC7C,GAAG,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,WAAW,CAAC;aACrC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC;aACjC,GAAG,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC;aACxC,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC;aAC/B,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC;aAC/B,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC;QAMnC,IAAI,CAAC,QAAQ,GAAG,aAAa,CAAC;YAC5B,IAAI,CAAC,YAAY,CAAC,IAAI;YACtB,IAAI,CAAC,YAAY,CAAC,MAAM;SACzB,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,CAAC,IAAqC,EAAE,EAAE;YAC5C,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;YACxB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAgB,CAAC;YACpC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;gBAC5B,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC,CAAC;YACH,OAAO,GAAG,CAAC;QACb,CAAC,CAAC,CACH,CAAC;QAEF,IAAI,CAAC,QAAQ,GAAG,aAAa,CAAC;YAC5B,IAAI,CAAC,YAAY,CAAC,IAAI;YACtB,IAAI,CAAC,YAAY,CAAC,MAAM;SACzB,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,CAAC,IAAqC,EAAE,EAAE;YAC5C,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;YACxB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAgB,CAAC;YACpC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;gBAC5B,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC,CAAC;YAEH,OAAO,GAAG,CAAC;QACb,CAAC,CAAC,CACH,CAAC;QAEF,IAAI,CAAC,SAAS,GAAG,aAAa,CAAC;YAC7B,IAAI,CAAC,YAAY,CAAC,IAAI;YACtB,IAAI,CAAC,YAAY,CAAC,MAAM;YACxB,IAAI,CAAC,WAAW,CAAC,MAAM;SACxB,CAAC,CAAC,IAAI,CACL,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EAC5C,GAAG,CACD,CACE,IAIC,EACD,EAAE;YACF,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAElD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAe,CAAC;YAEnC,MAAM,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;iBAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC;iBACxD,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;YAE/C,MAAM,KAAK,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;iBAC9B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,CAAC;iBACjE,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;YAE/C,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;YAEpD,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACrB,IAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC;gBAE3B,IAAI,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE;oBAC1B,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC;iBACvC;gBAED,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY;qBAC5B,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;qBAClC,MAAM,CAAC,MAAM,CAAC;qBACd,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;gBAE1B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,GAAG,EAAE;oBACjD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;iBACzC;gBAED,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBAE3B,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACtD,MAAM,aAAa,GACjB,IAAI,EAAE,MAAM,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC;oBAC/C,IAAI,CAAC,MAAM,EAAE,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC;gBAEpC,IAAI,QAAQ,IAAI,aAAa,EAAE;oBAC7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC/D,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;iBACxD;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,IAAI,EAAE;gBACR,MAAM,KAAK,GAAG,IAAI,CAAC,KAA8B,CAAC;gBAElD,IAAI,IAAI,CAAC,MAAM,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC,EAAE;oBAClD,MAAM,YAAY,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAChD,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;oBACxD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;oBAErC,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC1C,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;iBACvD;aACF;YAED,OAAO,GAAG,CAAC;QACb,CAAC,CACF,EACD,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAEF,IAAI,CAAC,SAAS,GAAG,aAAa,CAAC;YAC7B,IAAI,CAAC,YAAY,CAAC,IAAI;YACtB,IAAI,CAAC,YAAY,CAAC,MAAM;YACxB,IAAI,CAAC,WAAW,CAAC,MAAM;SACxB,CAAC,CAAC,IAAI,CACL,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EAC5C,GAAG,CACD,CACE,IAIC,EACD,EAAE;YACF,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAElD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAe,CAAC;YAEnC,MAAM,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;iBAC5B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC;iBACxD,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;YAE/C,MAAM,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;iBAC/B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,KAAK,IAAI,CAAC;iBACjE,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;YAE/C,MAAM,WAAW,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,GAAG,GAAG,MAAM,CAAC;YAEtD,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACrB,IAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC;gBAE3B,IAAI,IAAI,CAAC,WAAW,KAAK,eAAe,CAAC,CAAC,EAAE;oBAC1C,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC;iBACvC;gBAED,IAAI,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE;oBAC1B,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;iBAC3B;gBAED,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY;qBAC5B,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;qBAClC,MAAM,CAAC,MAAM,CAAC;qBACd,KAAK,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;gBAE3B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,GAAG,EAAE;oBACjD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;iBACzC;gBAED,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBAE3B,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAEtD,MAAM,aAAa,GACjB,IAAI,EAAE,MAAM,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC;oBAC/C,IAAI,CAAC,MAAM,EAAE,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC;gBAEpC,IAAI,QAAQ,IAAI,aAAa,EAAE;oBAC7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC/D,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;iBACxD;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,IAAI,EAAE;gBACR,MAAM,KAAK,GAAG,IAAI,CAAC,KAA8B,CAAC;gBAElD,IAAI,IAAI,CAAC,MAAM,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC,EAAE;oBAClD,MAAM,YAAY,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAChD,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;oBACxD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;oBAErC,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC1C,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;iBACvD;aACF;YAED,OAAO,GAAG,CAAC;QACb,CAAC,CACF,EACD,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IACJ,CAAC;;yGA/MU,YAAY;6GAAZ,YAAY,cAFX,MAAM;2FAEP,YAAY;kBAHxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport * as d3 from 'd3';\nimport { D3ZoomEvent, ZoomTransform } from 'd3';\nimport { Axis } from '../core/axis/axis';\nimport { AxisOrientation } from '../model/enum/axis-orientation';\nimport { IChartConfig } from '../model/i-chart-config';\nimport { ChartService } from './chart.service';\nimport {\n  combineLatest,\n  map,\n  Observable,\n  shareReplay,\n  withLatestFrom,\n} from 'rxjs';\nimport { IChartEvent } from '../model/i-chart-event';\nimport { ZoomService } from './zoom.service';\nimport { ScaleType } from '../model/enum/scale-type';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ScaleService {\n  public yAxisMap: Observable<Map<number, Axis>>;\n  public xAxisMap: Observable<Map<number, Axis>>;\n\n  public yScaleMap: Observable<Map<number, any>>;\n  public xScaleMap: Observable<Map<number, any>>;\n\n  private transformCacheX = new Map<number, ZoomTransform>();\n  private transformCacheY = new Map<number, ZoomTransform>();\n\n  private scaleMapping = new Map<ScaleType, any>()\n    .set(ScaleType.linear, d3.scaleLinear)\n    .set(ScaleType.time, d3.scaleTime)\n    .set(ScaleType.category, d3.scaleOrdinal)\n    .set(ScaleType.log, d3.scaleLog)\n    .set(ScaleType.pow, d3.scalePow)\n    .set(ScaleType.sqrt, d3.scaleSqrt);\n\n  constructor(\n    private chartService: ChartService,\n    private zoomService: ZoomService\n  ) {\n    this.xAxisMap = combineLatest([\n      this.chartService.size,\n      this.chartService.config,\n    ]).pipe(\n      map((data: [DOMRectReadOnly, IChartConfig]) => {\n        const [, config] = data;\n        const map = new Map<number, Axis>();\n        config.xAxis.map((_, index) => {\n          map.set(index, Axis.createAxis(AxisOrientation.x, config, index));\n        });\n        return map;\n      })\n    );\n\n    this.yAxisMap = combineLatest([\n      this.chartService.size,\n      this.chartService.config,\n    ]).pipe(\n      map((data: [DOMRectReadOnly, IChartConfig]) => {\n        const [, config] = data;\n        const map = new Map<number, Axis>();\n        config.yAxis.map((_, index) => {\n          map.set(index, Axis.createAxis(AxisOrientation.y, config, index));\n        });\n\n        return map;\n      })\n    );\n\n    this.xScaleMap = combineLatest([\n      this.chartService.size,\n      this.chartService.config,\n      this.zoomService.zoomed,\n    ]).pipe(\n      withLatestFrom(this.yAxisMap, this.xAxisMap),\n      map(\n        (\n          data: [\n            [DOMRectReadOnly, IChartConfig, IChartEvent<Axis>],\n            Map<number, Axis>,\n            Map<number, Axis>\n          ]\n        ) => {\n          const [[size, config, zoom], yAxes, xAxes] = data;\n\n          const map = new Map<number, any>();\n\n          const left = [...yAxes.values()]\n            .filter((_) => _.options?.visible && _.options?.opposite)\n            .reduce((acc, cur) => acc + cur.selfSize, 0);\n\n          const right = [...yAxes.values()]\n            .filter((_) => _.options?.visible && _.options?.opposite !== true)\n            .reduce((acc, cur) => acc + cur.selfSize, 0);\n\n          const finalWidth = (size.width || 0) - left - right;\n\n          xAxes.forEach((axis) => {\n            let domain = axis.extremes;\n\n            if (axis?.options.inverted) {\n              domain = [...axis.extremes].reverse();\n            }\n\n            const scale = this.scaleMapping\n              .get(axis.options.scaleType.type)()\n              .domain(domain)\n              .range([0, finalWidth]);\n\n            if (axis.options.scaleType.type === ScaleType.log) {\n              scale.base(axis.options.scaleType.base);\n            }\n\n            map.set(axis.index, scale);\n\n            const hasCache = this.transformCacheX.has(axis.index);\n            const shouldRestore =\n              zoom?.target?.orientation !== AxisOrientation.x ||\n              zoom.target?.index !== axis.index;\n\n            if (hasCache && shouldRestore) {\n              const restoredTransform = this.transformCacheX.get(axis.index);\n              map.set(axis.index, restoredTransform.rescaleX(scale));\n            }\n          });\n\n          if (zoom) {\n            const event = zoom.event as D3ZoomEvent<any, any>;\n\n            if (zoom.target?.orientation === AxisOrientation.x) {\n              const currentScale = map.get(zoom.target.index);\n              const rescaled = event.transform.rescaleX(currentScale);\n              map.set(zoom.target.index, rescaled);\n\n              const axis = xAxes.get(zoom.target.index);\n              this.transformCacheX.set(axis.index, event.transform);\n            }\n          }\n\n          return map;\n        }\n      ),\n      shareReplay(1)\n    );\n\n    this.yScaleMap = combineLatest([\n      this.chartService.size,\n      this.chartService.config,\n      this.zoomService.zoomed,\n    ]).pipe(\n      withLatestFrom(this.yAxisMap, this.xAxisMap),\n      map(\n        (\n          data: [\n            [DOMRectReadOnly, IChartConfig, IChartEvent<Axis>],\n            Map<number, Axis>,\n            Map<number, Axis>\n          ]\n        ) => {\n          const [[size, config, zoom], yAxes, xAxes] = data;\n\n          const map = new Map<number, any>();\n\n          const top = [...xAxes.values()]\n            .filter((_) => _.options?.visible && _.options?.opposite)\n            .reduce((acc, cur) => acc + cur.selfSize, 0);\n\n          const bottom = [...xAxes.values()]\n            .filter((_) => _.options?.visible && _.options?.opposite !== true)\n            .reduce((acc, cur) => acc + cur.selfSize, 0);\n\n          const finalHeight = (size.height || 0) - top - bottom;\n\n          yAxes.forEach((axis) => {\n            let domain = axis.extremes;\n\n            if (axis.orientation === AxisOrientation.y) {\n              domain = [...axis.extremes].reverse();\n            }\n\n            if (axis?.options.inverted) {\n              domain = domain.reverse();\n            }\n\n            const scale = this.scaleMapping\n              .get(axis.options.scaleType.type)()\n              .domain(domain)\n              .range([0, finalHeight]);\n\n            if (axis.options.scaleType.type === ScaleType.log) {\n              scale.base(axis.options.scaleType.base);\n            }\n\n            map.set(axis.index, scale);\n\n            const hasCache = this.transformCacheY.has(axis.index);\n\n            const shouldRestore =\n              zoom?.target?.orientation !== AxisOrientation.y ||\n              zoom.target?.index !== axis.index;\n\n            if (hasCache && shouldRestore) {\n              const restoredTransform = this.transformCacheY.get(axis.index);\n              map.set(axis.index, restoredTransform.rescaleY(scale));\n            }\n          });\n\n          if (zoom) {\n            const event = zoom.event as D3ZoomEvent<any, any>;\n\n            if (zoom.target?.orientation === AxisOrientation.y) {\n              const currentScale = map.get(zoom.target.index);\n              const rescaled = event.transform.rescaleY(currentScale);\n              map.set(zoom.target.index, rescaled);\n\n              const axis = yAxes.get(zoom.target.index);\n              this.transformCacheY.set(axis.index, event.transform);\n            }\n          }\n\n          return map;\n        }\n      ),\n      shareReplay(1)\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,114 @@
+import { Injectable } from '@angular/core';
+import * as d3 from 'd3';
+import { zoomIdentity, zoomTransform } from 'd3';
+import { BehaviorSubject, filter, map, shareReplay, } from 'rxjs';
+import { Axis } from '../core/axis/axis';
+import { AxisOrientation } from '../model/enum/axis-orientation';
+import { ZoomType } from '../model/enum/zoom-type';
+import { BrushType } from '../model/enum/brush-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./broadcast.service";
+export class ZoomService {
+    constructor(broadcastService) {
+        this.broadcastService = broadcastService;
+        this.broadcastSubscription = [];
+        this.zoomed$ = new BehaviorSubject(null);
+        this.zoomed = this.zoomed$.asObservable().pipe(shareReplay(1));
+    }
+    applyZoom(svgElement, config, size, axis) {
+        const enable = axis?.options?.zoom || config?.zoom?.enable;
+        const fakeAxis = Axis.createAxis(config?.zoom.type === ZoomType.x ? AxisOrientation.x : AxisOrientation.y, config, 0, true);
+        const _axis = axis ? axis : fakeAxis;
+        const zoom = d3
+            .zoom()
+            .scaleExtent([1, 50])
+            .extent([
+            [0, 0],
+            [size.width, size.height],
+        ]);
+        if (config?.zoom?.enable) {
+            this.zoomed
+                .pipe(filter((_) => (_?.target?.orientation === AxisOrientation.x &&
+                _?.target.index === 0 &&
+                config?.zoom.type === ZoomType.x &&
+                _axis.orientation === AxisOrientation.x) ||
+                (_?.target?.orientation === AxisOrientation.y &&
+                    _?.target.index === 0 &&
+                    config?.zoom.type === ZoomType.y &&
+                    _axis.orientation === AxisOrientation.y)), filter((_) => _?.event?.type === 'end'), map((_) => {
+                const eventTransform = _?.event.transform;
+                const currentTransform = zoomTransform(svgElement.nativeElement);
+                if (currentTransform !== eventTransform) {
+                    d3.select(svgElement.nativeElement).call(zoom.transform, eventTransform);
+                }
+            }))
+                .subscribe();
+        }
+        const zoomed = (event) => {
+            if (enable) {
+                if (event.sourceEvent) {
+                    this.zoomed$.next({
+                        event,
+                        target: _axis,
+                    });
+                    const message = {
+                        event: event,
+                        axis: _axis,
+                    };
+                    this.broadcastService.broadcast({
+                        channel: config?.zoom?.syncChannel,
+                        message,
+                    });
+                }
+            }
+        };
+        if (enable) {
+            const element = d3.select(svgElement.nativeElement);
+            zoom.on('start zoom end', zoomed);
+            element.call(zoom);
+            const subscription = this.broadcastService
+                .subscribeToChannel(config?.zoom?.syncChannel)
+                .pipe(filter((_) => {
+                if ('axis' in _.message) {
+                    return (_axis.index === _.message?.axis?.index &&
+                        _axis.orientation === _.message?.axis?.orientation);
+                }
+                if ('selection' in _.message) {
+                    return (_axis.index === 0 && _axis.orientation === AxisOrientation.x);
+                }
+                return false;
+            }), map((broadcaseMessage) => {
+                if ('axis' in broadcaseMessage.message) {
+                    const currentTransform = d3.zoomTransform(svgElement.nativeElement);
+                    if (currentTransform !== broadcaseMessage.message.event?.transform) {
+                        d3.select(svgElement.nativeElement).call(zoom.transform, broadcaseMessage.message.event?.transform, null, {});
+                    }
+                }
+                if ('selection' in broadcaseMessage.message) {
+                    const s = broadcaseMessage.message.selection;
+                    const domain = broadcaseMessage.message.brushScale.domain();
+                    const scale = (domain[1] - domain[0]) / (s[1] - s[0]);
+                    let transform = zoomIdentity.scale(scale);
+                    if (broadcaseMessage.message?.brushType === BrushType.x) {
+                        transform = transform.translate(-broadcaseMessage.message.brushScale(s[0]), 0);
+                    }
+                    if (broadcaseMessage.message?.brushType === BrushType.y) {
+                        transform = transform.translate(0, -broadcaseMessage.message.brushScale(s[0]));
+                    }
+                    d3.select(svgElement.nativeElement).call(zoom.transform, transform, null, {});
+                }
+                this.broadcastSubscription.push(subscription);
+            }))
+                .subscribe();
+        }
+    }
+}
+ZoomService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: ZoomService, deps: [{ token: i1.BroadcastService }], 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.BroadcastService }]; } });
+//# 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, zoomTransform } from 'd3';\nimport {\n  BehaviorSubject,\n  filter,\n  map,\n  Observable,\n  shareReplay,\n  Subscription,\n} from 'rxjs';\nimport { IChartConfig } from '../model/i-chart-config';\nimport { BroadcastService } from './broadcast.service';\nimport { Axis } from '../core/axis/axis';\nimport { IChartEvent } from '../model/i-chart-event';\nimport { AxisOrientation } from '../model/enum/axis-orientation';\nimport { ZoomType } from '../model/enum/zoom-type';\nimport { IBroadcastMessage, ZoomMessage } from '../model/i-broadcast-message';\nimport { BrushType } from '../model/enum/brush-type';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ZoomService {\n  broadcastSubscription: Subscription[] = [];\n\n  zoomed: Observable<IChartEvent<Axis>>;\n  private zoomed$ = new BehaviorSubject<IChartEvent<Axis>>(null);\n\n  constructor(private broadcastService: BroadcastService) {\n    this.zoomed = this.zoomed$.asObservable().pipe(shareReplay(1));\n  }\n\n  applyZoom(\n    svgElement: ElementRef,\n    config: IChartConfig,\n    size: DOMRect,\n    axis?: Axis\n  ) {\n    const enable = axis?.options?.zoom || config?.zoom?.enable;\n\n    const fakeAxis = Axis.createAxis(\n      config?.zoom.type === ZoomType.x ? AxisOrientation.x : AxisOrientation.y,\n      config,\n      0,\n      true\n    );\n\n    const _axis = axis ? axis : fakeAxis;\n\n    const zoom = d3\n      .zoom()\n      .scaleExtent([1, 50])\n      .extent([\n        [0, 0],\n        [size.width, size.height],\n      ]);\n\n    if (config?.zoom?.enable) {\n      this.zoomed\n        .pipe(\n          filter(\n            (_) =>\n              (_?.target?.orientation === AxisOrientation.x &&\n                _?.target.index === 0 &&\n                config?.zoom.type === ZoomType.x &&\n                _axis.orientation === AxisOrientation.x) ||\n              (_?.target?.orientation === AxisOrientation.y &&\n                _?.target.index === 0 &&\n                config?.zoom.type === ZoomType.y &&\n                _axis.orientation === AxisOrientation.y)\n          ),\n          filter((_) => _?.event?.type === 'end'),\n          map((_) => {\n            const eventTransform = _?.event.transform;\n            const currentTransform = zoomTransform(svgElement.nativeElement);\n\n            if (currentTransform !== eventTransform) {\n              d3.select(svgElement.nativeElement).call(\n                zoom.transform,\n                eventTransform\n              );\n            }\n          })\n        )\n        .subscribe();\n    }\n\n    const zoomed = (event: D3ZoomEvent<any, any>) => {\n      if (enable) {\n        if (event.sourceEvent) {\n          this.zoomed$.next({\n            event,\n            target: _axis,\n          });\n\n          const message: ZoomMessage = {\n            event: event,\n            axis: _axis,\n          };\n\n          this.broadcastService.broadcast({\n            channel: config?.zoom?.syncChannel,\n            message,\n          });\n        }\n      }\n    };\n\n    if (enable) {\n      const element = d3.select(svgElement.nativeElement);\n      zoom.on('start zoom end', zoomed);\n      element.call(zoom);\n\n      const subscription = this.broadcastService\n        .subscribeToChannel(config?.zoom?.syncChannel)\n        .pipe(\n          filter((_) => {\n            if ('axis' in _.message) {\n              return (\n                _axis.index === _.message?.axis?.index &&\n                _axis.orientation === _.message?.axis?.orientation\n              );\n            }\n            if ('selection' in _.message) {\n              return (\n                _axis.index === 0 && _axis.orientation === AxisOrientation.x\n              );\n            }\n            return false;\n          }),\n          map((broadcaseMessage: IBroadcastMessage) => {\n            if ('axis' in broadcaseMessage.message) {\n              const currentTransform = d3.zoomTransform(\n                svgElement.nativeElement\n              );\n\n              if (\n                currentTransform !== broadcaseMessage.message.event?.transform\n              ) {\n                d3.select(svgElement.nativeElement).call(\n                  zoom.transform,\n                  broadcaseMessage.message.event?.transform,\n                  null,\n                  {}\n                );\n              }\n            }\n\n            if ('selection' in broadcaseMessage.message) {\n              const s = broadcaseMessage.message.selection;\n              const domain = broadcaseMessage.message.brushScale.domain();\n\n              const scale = (domain[1] - domain[0]) / (s[1] - s[0]);\n              let transform = zoomIdentity.scale(scale);\n\n              if (broadcaseMessage.message?.brushType === BrushType.x) {\n                transform = transform.translate(\n                  -broadcaseMessage.message.brushScale(s[0]),\n                  0\n                );\n              }\n              if (broadcaseMessage.message?.brushType === BrushType.y) {\n                transform = transform.translate(\n                  0,\n                  -broadcaseMessage.message.brushScale(s[0])\n                );\n              }\n\n              d3.select(svgElement.nativeElement).call(\n                zoom.transform,\n                transform,\n                null,\n                {}\n              );\n            }\n\n            this.broadcastSubscription.push(subscription);\n          })\n        )\n        .subscribe();\n    }\n  }\n}\n"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,9 @@
+/*
+ * Public API Surface of chart
+ */
+window.__zone_symbol__BLACK_LISTED_EVENTS = ['mousemove'];
+export * from './chart/chart.module';
+export * from './chart/service/chart.service';
+export * from './chart/chart/chart.component';
+export * from './chart/model/public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUYsTUFBYyxDQUFDLGtDQUFrQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUM7QUFHbkUsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY2hhcnRcbiAqL1xuXG4od2luZG93IGFzIGFueSkuX196b25lX3N5bWJvbF9fQkxBQ0tfTElTVEVEX0VWRU5UUyA9IFsnbW91c2Vtb3ZlJ107XG5cblxuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9jaGFydC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9zZXJ2aWNlL2NoYXJ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9jaGFydC9jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9tb2RlbC9wdWJsaWMtYXBpJztcbiJdfQ==