@tetacom/svg-charts 1.0.2 → 1.1.0

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

@@ -1,64 +1,152 @@
 import { Injectable } from '@angular/core';
 import * as d3 from 'd3';
-import { AxisType } from '../model/enum/axis-type';
+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 "./axes.service";
+import * as i1 from "./chart.service";
+import * as i2 from "./zoom.service";
 export class ScaleService {
-    constructor(axesService) {
-        this.axesService = axesService;
-        this.yScales = new Map();
-        this.xScales = new Map();
+    constructor(chartService, zoomService) {
+        this.chartService = chartService;
+        this.zoomService = zoomService;
+        this.transformCacheX = new Map();
+        this.transformCacheY = 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);
+            .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.AxesService }], target: i0.ɵɵFactoryTarget.Injectable });
+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.AxesService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], 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":"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","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 { ZoomType } from '../model/enum/zoom-type';\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/dist/esm2020/chart/service/zoom.service.mjs

@@ -1,117 +1,114 @@
 import { Injectable } from '@angular/core';
 import * as d3 from 'd3';
-import { zoomIdentity } from 'd3';
-import { map, merge, of, Subject } from 'rxjs';
+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 "./scale.service";
-import * as i2 from "./broadcast.service";
-import * as i3 from "./chart.service";
+import * as i1 from "./broadcast.service";
 export class ZoomService {
-    constructor(scaleService, broadcastService, chartService) {
-        this.scaleService = scaleService;
+    constructor(broadcastService) {
         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();
+        this.broadcastSubscription = [];
+        this.zoomed$ = new BehaviorSubject(null);
+        this.zoomed = this.zoomed$.asObservable().pipe(shareReplay(1));
     }
-    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));
+    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) {
-                this.zoomed$.next({ event });
                 if (event.sourceEvent) {
+                    this.zoomed$.next({
+                        event,
+                        target: _axis,
+                    });
+                    const message = {
+                        event: event,
+                        axis: _axis,
+                    };
                     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(),
+                        message,
                     });
                 }
             }
         };
         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
+            const element = d3.select(svgElement.nativeElement);
+            zoom.on('start zoom end', zoomed);
+            element.call(zoom);
+            const subscription = 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;
+                .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, {});
                     }
-                    this.setZoom(message?.transform);
                 }
+                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();
         }
     }
-    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.ɵ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.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"]}
+        }], 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":"AAAA,OAAO,EAAc,UAAU,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,EAAe,YAAY,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAC9D,OAAO,EACL,eAAe,EACf,MAAM,EACN,GAAG,EAEH,WAAW,GAEZ,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEnD,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;;;AAKrD,MAAM,OAAO,WAAW;IAMtB,YAAoB,gBAAkC;QAAlC,qBAAgB,GAAhB,gBAAgB,CAAkB;QALtD,0BAAqB,GAAmB,EAAE,CAAC;QAGnC,YAAO,GAAG,IAAI,eAAe,CAAoB,IAAI,CAAC,CAAC;QAG7D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAED,SAAS,CACP,UAAsB,EACtB,MAAoB,EACpB,IAAa,EACb,IAAW;QAEX,MAAM,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;QAE3D,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAC9B,MAAM,EAAE,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,EACxE,MAAM,EACN,CAAC,EACD,IAAI,CACL,CAAC;QAEF,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;QAErC,MAAM,IAAI,GAAG,EAAE;aACZ,IAAI,EAAE;aACN,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;aACpB,MAAM,CAAC;YACN,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC;SAC1B,CAAC,CAAC;QAEL,IAAI,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE;YACxB,IAAI,CAAC,MAAM;iBACR,IAAI,CACH,MAAM,CACJ,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC;gBAC3C,CAAC,EAAE,MAAM,CAAC,KAAK,KAAK,CAAC;gBACrB,MAAM,EAAE,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;gBAChC,KAAK,CAAC,WAAW,KAAK,eAAe,CAAC,CAAC,CAAC;gBAC1C,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,eAAe,CAAC,CAAC;oBAC3C,CAAC,EAAE,MAAM,CAAC,KAAK,KAAK,CAAC;oBACrB,MAAM,EAAE,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;oBAChC,KAAK,CAAC,WAAW,KAAK,eAAe,CAAC,CAAC,CAAC,CAC7C,EACD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,KAAK,KAAK,CAAC,EACvC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACR,MAAM,cAAc,GAAG,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;gBAC1C,MAAM,gBAAgB,GAAG,aAAa,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;gBAEjE,IAAI,gBAAgB,KAAK,cAAc,EAAE;oBACvC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,IAAI,CACtC,IAAI,CAAC,SAAS,EACd,cAAc,CACf,CAAC;iBACH;YACH,CAAC,CAAC,CACH;iBACA,SAAS,EAAE,CAAC;SAChB;QAED,MAAM,MAAM,GAAG,CAAC,KAA4B,EAAE,EAAE;YAC9C,IAAI,MAAM,EAAE;gBACV,IAAI,KAAK,CAAC,WAAW,EAAE;oBACrB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;wBAChB,KAAK;wBACL,MAAM,EAAE,KAAK;qBACd,CAAC,CAAC;oBAEH,MAAM,OAAO,GAAgB;wBAC3B,KAAK,EAAE,KAAK;wBACZ,IAAI,EAAE,KAAK;qBACZ,CAAC;oBAEF,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;wBAC9B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW;wBAClC,OAAO;qBACR,CAAC,CAAC;iBACJ;aACF;QACH,CAAC,CAAC;QAEF,IAAI,MAAM,EAAE;YACV,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;YACpD,IAAI,CAAC,EAAE,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;YAClC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEnB,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB;iBACvC,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC;iBAC7C,IAAI,CACH,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;gBACX,IAAI,MAAM,IAAI,CAAC,CAAC,OAAO,EAAE;oBACvB,OAAO,CACL,KAAK,CAAC,KAAK,KAAK,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK;wBACtC,KAAK,CAAC,WAAW,KAAK,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,CACnD,CAAC;iBACH;gBACD,IAAI,WAAW,IAAI,CAAC,CAAC,OAAO,EAAE;oBAC5B,OAAO,CACL,KAAK,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,WAAW,KAAK,eAAe,CAAC,CAAC,CAC7D,CAAC;iBACH;gBACD,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,gBAAmC,EAAE,EAAE;gBAC1C,IAAI,MAAM,IAAI,gBAAgB,CAAC,OAAO,EAAE;oBACtC,MAAM,gBAAgB,GAAG,EAAE,CAAC,aAAa,CACvC,UAAU,CAAC,aAAa,CACzB,CAAC;oBAEF,IACE,gBAAgB,KAAK,gBAAgB,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAC9D;wBACA,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,IAAI,CACtC,IAAI,CAAC,SAAS,EACd,gBAAgB,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EACzC,IAAI,EACJ,EAAE,CACH,CAAC;qBACH;iBACF;gBAED,IAAI,WAAW,IAAI,gBAAgB,CAAC,OAAO,EAAE;oBAC3C,MAAM,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC,SAAS,CAAC;oBAC7C,MAAM,MAAM,GAAG,gBAAgB,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;oBAE5D,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACtD,IAAI,SAAS,GAAG,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBAE1C,IAAI,gBAAgB,CAAC,OAAO,EAAE,SAAS,KAAK,SAAS,CAAC,CAAC,EAAE;wBACvD,SAAS,GAAG,SAAS,CAAC,SAAS,CAC7B,CAAC,gBAAgB,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAC1C,CAAC,CACF,CAAC;qBACH;oBACD,IAAI,gBAAgB,CAAC,OAAO,EAAE,SAAS,KAAK,SAAS,CAAC,CAAC,EAAE;wBACvD,SAAS,GAAG,SAAS,CAAC,SAAS,CAC7B,CAAC,EACD,CAAC,gBAAgB,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC3C,CAAC;qBACH;oBAED,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,IAAI,CACtC,IAAI,CAAC,SAAS,EACd,SAAS,EACT,IAAI,EACJ,EAAE,CACH,CAAC;iBACH;gBAED,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChD,CAAC,CAAC,CACH;iBACA,SAAS,EAAE,CAAC;SAChB;IACH,CAAC;;wGA/JU,WAAW;4GAAX,WAAW,cAFV,MAAM;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","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/dist/esm2020/public-api.mjs

@@ -1,8 +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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY2hhcnRcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0L2NoYXJ0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0L3NlcnZpY2UvY2hhcnQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0L2NoYXJ0L2NoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0L21vZGVsL3B1YmxpYy1hcGknO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUYsTUFBYyxDQUFDLGtDQUFrQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUM7QUFHbkUsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY2hhcnRcbiAqL1xuXG4od2luZG93IGFzIGFueSkuX196b25lX3N5bWJvbF9fQkxBQ0tfTElTVEVEX0VWRU5UUyA9IFsnbW91c2Vtb3ZlJ107XG5cblxuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9jaGFydC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9zZXJ2aWNlL2NoYXJ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9jaGFydC9jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC9tb2RlbC9wdWJsaWMtYXBpJztcbiJdfQ==