@tetacom/svg-charts 1.2.30 → 1.3.0

package/esm2020/chart/directives/brushable.directive.mjs

@@ -1,34 +1,144 @@
 import { Directive, Input, } from '@angular/core';
+import { BrushType } from '../model/enum/brush-type';
+import * as d3 from 'd3';
+import { BrushMessage } from '../model/i-broadcast-message';
+import { filter, takeWhile } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "../service/brush.service";
 import * as i2 from "../service/chart.service";
 export class BrushableDirective {
-    constructor(brushService, chartService, element) {
+    constructor(brushService, chartService, element, zone) {
         this.brushService = brushService;
         this.chartService = chartService;
         this.element = element;
+        this.zone = zone;
+        this.brushMap = new Map()
+            .set(BrushType.x, d3.brushX())
+            .set(BrushType.y, d3.brushY());
+        this._alive = true;
+        this._container = d3.select(this.element.nativeElement);
+    }
+    ngOnInit() {
+        this.brushService.brushDomain.pipe(takeWhile(() => this._alive), filter((brush) => brush.chartId !== this.config.id)).subscribe((brush) => {
+            this._container.call(this.brush.move, [
+                Math.floor(brush.selection[0]),
+                Math.floor(brush.selection[1]),
+            ].map(this.axis.scale));
+        });
+    }
+    ngOnDestroy() {
+        this._alive = false;
+    }
+    ngAfterViewInit() {
     }
-    ngOnInit() { }
-    ngAfterViewInit() { }
     ngOnChanges(changes) {
         if (changes.hasOwnProperty('config')) {
-            this.brushService.clearPreviousSelection();
+            this.clearPreviousSelection();
         }
         if (this.config?.brush?.enable) {
-            this.brushService.applyBrush(this.element, this.config, this.brushScale);
+            this.applyBrush(this.config, this.axis.scale);
         }
     }
+    applyBrush(config, brushScale) {
+        this.brush?.on('start brush end', null);
+        if (config.brush?.enable) {
+            this.brush = this.brushMap.get(config?.brush?.type ?? BrushType.x);
+            this.brush.on('start brush end', (_) => {
+                if (_.sourceEvent) {
+                    if (!_.selection)
+                        return;
+                    const [from, to] = _.selection;
+                    if (to - from === 0) {
+                        const selection = this.selection?.map(brushScale) ??
+                            [config.brush?.from, config.brush?.to].map(brushScale);
+                        const halfBrushHeight = (selection[1] - selection[0]) / 2;
+                        const invertedSelection = [
+                            from - halfBrushHeight,
+                            to + halfBrushHeight,
+                        ].map(brushScale.invert);
+                        if (invertedSelection[1] - invertedSelection[0] >
+                            config.brush?.max) {
+                            this._container.call(this.brush.move, [
+                                Math.floor(invertedSelection[0]),
+                                Math.floor(invertedSelection[0] + config.brush?.max),
+                            ].map(brushScale));
+                            return;
+                        }
+                        if (invertedSelection[1] - invertedSelection[0] <
+                            config.brush?.min) {
+                            this._container.call(this.brush.move, [
+                                Math.floor(invertedSelection[0]),
+                                Math.ceil(invertedSelection[0] + config.brush?.min),
+                            ].map(brushScale));
+                            return;
+                        }
+                        this._container.call(this.brush.move, [
+                            from - halfBrushHeight,
+                            to + halfBrushHeight,
+                        ]);
+                        return;
+                    }
+                    if (brushScale.invert(to) - brushScale.invert(from) >
+                        config.brush?.max) {
+                        this._container.call(this.brush.move, this.selection
+                            ? [
+                                this.selection[0],
+                                this.selection[0] + config.brush?.max,
+                            ].map(brushScale)
+                            : [config.brush?.from, config.brush?.to].map(brushScale));
+                        return;
+                    }
+                    if (brushScale.invert(to) - brushScale.invert(from) <
+                        config.brush?.min) {
+                        this._container.call(this.brush.move, this.selection
+                            ? [
+                                this.selection[0],
+                                this.selection[0] + config.brush?.min,
+                            ].map(brushScale)
+                            : [config.brush?.from, config.brush?.to].map(brushScale));
+                        return;
+                    }
+                    if (_.sourceEvent instanceof MouseEvent) {
+                        this.selection = _.selection.map(brushScale.invert);
+                    }
+                    const brushMessage = new BrushMessage({
+                        chartId: this.config.id,
+                        selection: [brushScale.invert(from), brushScale.invert(to)],
+                    });
+                    this.brushService.setBrush(brushMessage);
+                }
+            });
+            this.zone.runOutsideAngular(() => {
+                setTimeout(() => {
+                    this._container.call(this.brush);
+                    let domain = brushScale.domain();
+                    if (config?.brush?.from) {
+                        domain[0] = config.brush.from;
+                    }
+                    if (config?.brush?.to) {
+                        domain[1] = config.brush.to;
+                    }
+                    this._container.call(this.brush.move, this.selection
+                        ? this.selection.map(brushScale)
+                        : domain.map(brushScale), {});
+                }, 0);
+            });
+        }
+    }
+    clearPreviousSelection() {
+        this.selection = null;
+    }
 }
-BrushableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: BrushableDirective, deps: [{ token: i1.BrushService }, { token: i2.ChartService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-BrushableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.2", type: BrushableDirective, selector: "[tetaBrushable]", inputs: { config: "config", brushScale: "brushScale" }, usesOnChanges: true, ngImport: i0 });
+BrushableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: BrushableDirective, deps: [{ token: i1.BrushService }, { token: i2.ChartService }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+BrushableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.2", type: BrushableDirective, selector: "[tetaBrushable]", inputs: { config: "config", axis: "axis" }, usesOnChanges: true, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: BrushableDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[tetaBrushable]',
                 }]
-        }], ctorParameters: function () { return [{ type: i1.BrushService }, { type: i2.ChartService }, { type: i0.ElementRef }]; }, propDecorators: { config: [{
+        }], ctorParameters: function () { return [{ type: i1.BrushService }, { type: i2.ChartService }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { config: [{
                 type: Input
-            }], brushScale: [{
+            }], axis: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brushable.directive.js","sourceRoot":"","sources":["../../../../src/chart/directives/brushable.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,GAGN,MAAM,eAAe,CAAC;AAKvB,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,EAAC,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAC,MAAM,EAAE,SAAS,EAAC,MAAM,MAAM,CAAC;;;;AAKvC,MAAM,OAAO,kBAAkB;IAY7B,YACU,YAA0B,EAC1B,YAA0B,EAC1B,OAAmB,EACnB,IAAY;QAHZ,iBAAY,GAAZ,YAAY,CAAc;QAC1B,iBAAY,GAAZ,YAAY,CAAc;QAC1B,YAAO,GAAP,OAAO,CAAY;QACnB,SAAI,GAAJ,IAAI,CAAQ;QAVd,aAAQ,GAAG,IAAI,GAAG,EAAoC;aAC3D,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;aAC7B,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;QACzB,WAAM,GAAG,IAAI,CAAC;QASpB,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAC1D,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAChC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAC5B,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CACpD,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACpB,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,IAAI,CAAC,KAAK,CAAC,IAAI,EACf;gBACE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gBAC9B,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;aAC/B,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CACvB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,eAAe;IACf,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;YACpC,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;YAC9B,IAAI,CAAC,UAAU,CACb,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,IAAI,CAAC,KAAK,CAChB,CAAC;SACH;IACH,CAAC;IAED,UAAU,CAAC,MAAoB,EAAE,UAAe;QAC9C,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;QACxC,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE;YACxB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;YACnE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,CAAuB,EAAE,EAAE;gBAC3D,IAAI,CAAC,CAAC,WAAW,EAAE;oBACjB,IAAI,CAAC,CAAC,CAAC,SAAS;wBAAE,OAAO;oBACzB,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,SAAqB,CAAC;oBAC3C,IAAI,EAAE,GAAG,IAAI,KAAK,CAAC,EAAE;wBACnB,MAAM,SAAS,GACb,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,UAAU,CAAC;4BAC/B,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;wBACzD,MAAM,eAAe,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;wBAC1D,MAAM,iBAAiB,GAAa;4BAClC,IAAI,GAAG,eAAe;4BACtB,EAAE,GAAG,eAAe;yBACrB,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;wBAEzB,IACE,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC;4BAC3C,MAAM,CAAC,KAAK,EAAE,GAAG,EACjB;4BACA,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,IAAI,CAAC,KAAK,CAAC,IAAI,EACf;gCACE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;gCAChC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC;6BACrD,CAAC,GAAG,CAAC,UAAU,CAAC,CAClB,CAAC;4BACF,OAAO;yBACR;wBAED,IACE,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC;4BAC3C,MAAM,CAAC,KAAK,EAAE,GAAG,EACjB;4BACA,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,IAAI,CAAC,KAAK,CAAC,IAAI,EACf;gCACE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;gCAChC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC;6BACpD,CAAC,GAAG,CAAC,UAAU,CAAC,CAClB,CAAC;4BACF,OAAO;yBACR;wBAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;4BACpC,IAAI,GAAG,eAAe;4BACtB,EAAE,GAAG,eAAe;yBACrB,CAAC,CAAC;wBACH,OAAO;qBACR;oBAED,IACE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC;wBAC/C,MAAM,CAAC,KAAK,EAAE,GAAG,EACjB;wBACA,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,IAAI,CAAC,KAAK,CAAC,IAAI,EACf,IAAI,CAAC,SAAS;4BACZ,CAAC,CAAC;gCACA,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gCACjB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG;6BACtC,CAAC,GAAG,CAAC,UAAU,CAAC;4BACjB,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAC3D,CAAC;wBACF,OAAO;qBACR;oBAED,IACE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC;wBAC/C,MAAM,CAAC,KAAK,EAAE,GAAG,EACjB;wBACA,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,IAAI,CAAC,KAAK,CAAC,IAAI,EACf,IAAI,CAAC,SAAS;4BACZ,CAAC,CAAC;gCACA,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gCACjB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG;6BACtC,CAAC,GAAG,CAAC,UAAU,CAAC;4BACjB,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAC3D,CAAC;wBACF,OAAO;qBACR;oBAED,IAAI,CAAC,CAAC,WAAW,YAAY,UAAU,EAAE;wBACvC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;qBACrD;oBAED,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC;wBACpC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;wBACvB,SAAS,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;qBAC5D,CAAC,CAAC;oBACH,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;iBAC1C;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;gBAC/B,UAAU,CAAC,GAAG,EAAE;oBACd,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAEjC,IAAI,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC;oBAEjC,IAAI,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE;wBACvB,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;qBAC/B;oBAED,IAAI,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE;wBACrB,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;qBAC7B;oBAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,IAAI,CAAC,KAAK,CAAC,IAAI,EACf,IAAI,CAAC,SAAS;wBACZ,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC;wBAChC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAC1B,EAAE,CACH,CAAC;gBACJ,CAAC,EAAE,CAAC,CAAC,CAAC;YACR,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED,sBAAsB;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACxB,CAAC;;+GArLU,kBAAkB;mGAAlB,kBAAkB;2FAAlB,kBAAkB;kBAH9B,SAAS;mBAAC;oBACT,QAAQ,EAAE,iBAAiB;iBAC5B;4KAEU,MAAM;sBAAd,KAAK;gBACG,IAAI;sBAAZ,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  Input, NgZone, OnChanges, OnDestroy,\n  OnInit,\n  SimpleChanges,\n} from '@angular/core';\nimport {IChartConfig} from '../model/i-chart-config';\nimport {BrushService} from '../service/brush.service';\nimport {ChartService} from '../service/chart.service';\nimport {Axis} from '../core/axis/axis';\nimport {BrushType} from '../model/enum/brush-type';\nimport * as d3 from 'd3';\nimport {BrushMessage} from '../model/i-broadcast-message';\nimport {filter, takeWhile} from 'rxjs';\n\n@Directive({\n  selector: '[tetaBrushable]',\n})\nexport class BrushableDirective implements OnDestroy, OnInit, AfterViewInit, OnChanges {\n  @Input() config: IChartConfig;\n  @Input() axis: Axis;\n\n  private selection: number[];\n  private brush: d3.BrushBehavior<any>;\n  private brushMap = new Map<BrushType, d3.BrushBehavior<any>>()\n    .set(BrushType.x, d3.brushX())\n    .set(BrushType.y, d3.brushY());\n  private _alive = true;\n  private _container;\n\n  constructor(\n    private brushService: BrushService,\n    private chartService: ChartService,\n    private element: ElementRef,\n    private zone: NgZone\n  ) {\n    this._container = d3.select(this.element.nativeElement);\n  }\n\n  ngOnInit() {\n    this.brushService.brushDomain.pipe(\n      takeWhile(() => this._alive),\n      filter((brush) => brush.chartId !== this.config.id)\n    ).subscribe((brush) => {\n      this._container.call(\n        this.brush.move,\n        [\n          Math.floor(brush.selection[0]),\n          Math.floor(brush.selection[1]),\n        ].map(this.axis.scale)\n      );\n    });\n  }\n\n  ngOnDestroy() {\n    this._alive = false;\n  }\n\n  ngAfterViewInit() {\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.hasOwnProperty('config')) {\n      this.clearPreviousSelection();\n    }\n\n    if (this.config?.brush?.enable) {\n      this.applyBrush(\n        this.config,\n        this.axis.scale\n      );\n    }\n  }\n\n  applyBrush(config: IChartConfig, brushScale: any) {\n    this.brush?.on('start brush end', null);\n    if (config.brush?.enable) {\n      this.brush = this.brushMap.get(config?.brush?.type ?? BrushType.x);\n      this.brush.on('start brush end', (_: d3.D3BrushEvent<any>) => {\n        if (_.sourceEvent) {\n          if (!_.selection) return;\n          const [from, to] = _.selection as number[];\n          if (to - from === 0) {\n            const selection: number[] =\n              this.selection?.map(brushScale) ??\n              [config.brush?.from, config.brush?.to].map(brushScale);\n            const halfBrushHeight = (selection[1] - selection[0]) / 2;\n            const invertedSelection: number[] = [\n              from - halfBrushHeight,\n              to + halfBrushHeight,\n            ].map(brushScale.invert);\n\n            if (\n              invertedSelection[1] - invertedSelection[0] >\n              config.brush?.max\n            ) {\n              this._container.call(\n                this.brush.move,\n                [\n                  Math.floor(invertedSelection[0]),\n                  Math.floor(invertedSelection[0] + config.brush?.max),\n                ].map(brushScale)\n              );\n              return;\n            }\n\n            if (\n              invertedSelection[1] - invertedSelection[0] <\n              config.brush?.min\n            ) {\n              this._container.call(\n                this.brush.move,\n                [\n                  Math.floor(invertedSelection[0]),\n                  Math.ceil(invertedSelection[0] + config.brush?.min),\n                ].map(brushScale)\n              );\n              return;\n            }\n\n            this._container.call(this.brush.move, [\n              from - halfBrushHeight,\n              to + halfBrushHeight,\n            ]);\n            return;\n          }\n\n          if (\n            brushScale.invert(to) - brushScale.invert(from) >\n            config.brush?.max\n          ) {\n            this._container.call(\n              this.brush.move,\n              this.selection\n                ? [\n                  this.selection[0],\n                  this.selection[0] + config.brush?.max,\n                ].map(brushScale)\n                : [config.brush?.from, config.brush?.to].map(brushScale)\n            );\n            return;\n          }\n\n          if (\n            brushScale.invert(to) - brushScale.invert(from) <\n            config.brush?.min\n          ) {\n            this._container.call(\n              this.brush.move,\n              this.selection\n                ? [\n                  this.selection[0],\n                  this.selection[0] + config.brush?.min,\n                ].map(brushScale)\n                : [config.brush?.from, config.brush?.to].map(brushScale)\n            );\n            return;\n          }\n\n          if (_.sourceEvent instanceof MouseEvent) {\n            this.selection = _.selection.map(brushScale.invert);\n          }\n\n          const brushMessage = new BrushMessage({\n            chartId: this.config.id,\n            selection: [brushScale.invert(from), brushScale.invert(to)],\n          });\n          this.brushService.setBrush(brushMessage);\n        }\n      });\n\n      this.zone.runOutsideAngular(() => {\n        setTimeout(() => {\n          this._container.call(this.brush);\n\n          let domain = brushScale.domain();\n\n          if (config?.brush?.from) {\n            domain[0] = config.brush.from;\n          }\n\n          if (config?.brush?.to) {\n            domain[1] = config.brush.to;\n          }\n\n          this._container.call(\n            this.brush.move,\n            this.selection\n              ? this.selection.map(brushScale)\n              : domain.map(brushScale),\n            {}\n          );\n        }, 0);\n      });\n    }\n  }\n\n  clearPreviousSelection() {\n    this.selection = null;\n  }\n}\n"]}