@tetacom/svg-charts 1.4.21 → 1.4.23

package/esm2022/chart/chart-container/y-axis/y-axis.component.mjs

@@ -0,0 +1,40 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import { map } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "../../service/scale.service";
+import * as i2 from "@angular/common";
+export class YAxisComponent {
+    scaleService;
+    y;
+    axis;
+    size;
+    _alive = true;
+    constructor(scaleService) {
+        this.scaleService = scaleService;
+        this.y = this.scaleService.scales.pipe(map((_) => {
+            return _.y.get(this.axis.index)?.scale;
+        }));
+    }
+    ngOnInit() { }
+    ngOnDestroy() {
+        this._alive = false;
+    }
+    ngAfterViewInit() {
+    }
+    getLabelTransform() {
+        return `translate(${this.axis.options.opposite
+            ? this.axis.selfSize
+            : -this.axis.selfSize}, ${this.size.height / 2}) rotate(-90)`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: YAxisComponent, deps: [{ token: i1.ScaleService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: YAxisComponent, selector: "[teta-y-axis]", inputs: { axis: "axis", size: "size" }, ngImport: i0, template: "<ng-container *ngIf=\"y | async as scale\">\n  <svg:g [attr.text-anchor]=\"axis.options.opposite ? 'start' : 'end'\" *ngFor=\"let tick of scale.ticks()\" [attr.transform]=\"'translate(0, '+ scale(tick) +')'\">\n    <text fill=\"var(--color-text-70)\" dy=\"0.32em\" [attr.x]=\"axis.options.opposite ? 10 : -9\">{{ this.axis.options.tickFormat ? this.axis.options.tickFormat(tick) : this.axis.defaultFormatter()(tick) }}</text>\n    <line stroke=\"var(--color-text-30)\" [attr.x2]=\"axis.options.opposite ? 6 : -6\"></line>\n  </svg:g>\n\n  <svg:g class=\"label-axis font-caption\" [attr.transform]=\"getLabelTransform()\">\n    <text [attr.dy]=\"axis.options.opposite ? '-4px' : '4px'\" text-anchor=\"middle\" [attr.dominant-baseline]=\"axis.options.opposite ? 'auto' : 'hanging'\">{{ axis.options.title }}</text>\n  </svg:g>\n</ng-container>\n\n", styles: [":host{shape-rendering:crispEdges}:host .label-axis{fill:var(--color-text-70)}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: YAxisComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[teta-y-axis]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"y | async as scale\">\n  <svg:g [attr.text-anchor]=\"axis.options.opposite ? 'start' : 'end'\" *ngFor=\"let tick of scale.ticks()\" [attr.transform]=\"'translate(0, '+ scale(tick) +')'\">\n    <text fill=\"var(--color-text-70)\" dy=\"0.32em\" [attr.x]=\"axis.options.opposite ? 10 : -9\">{{ this.axis.options.tickFormat ? this.axis.options.tickFormat(tick) : this.axis.defaultFormatter()(tick) }}</text>\n    <line stroke=\"var(--color-text-30)\" [attr.x2]=\"axis.options.opposite ? 6 : -6\"></line>\n  </svg:g>\n\n  <svg:g class=\"label-axis font-caption\" [attr.transform]=\"getLabelTransform()\">\n    <text [attr.dy]=\"axis.options.opposite ? '-4px' : '4px'\" text-anchor=\"middle\" [attr.dominant-baseline]=\"axis.options.opposite ? 'auto' : 'hanging'\">{{ axis.options.title }}</text>\n  </svg:g>\n</ng-container>\n\n", styles: [":host{shape-rendering:crispEdges}:host .label-axis{fill:var(--color-text-70)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ScaleService }]; }, propDecorators: { axis: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/chart/chart.module.mjs

@@ -27,42 +27,42 @@ import { DraggablePointDirective } from './directives/draggable-point.directive'
 import { BandseriesComponent } from './stories/bandseries/bandseries.component';
 import * as i0 from "@angular/core";
 export class ChartModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: ChartModule, declarations: [ChartComponent,
+            SeriesHostComponent,
+            ChartContainerComponent,
+            LegendComponent,
+            SeriesBaseComponent,
+            LinearSeriesBase,
+            LineSeriesComponent,
+            GridlinesComponent,
+            XAxisComponent,
+            YAxisComponent,
+            PlotlineComponent,
+            PlotBandComponent,
+            BarSeriesComponent,
+            TooltipComponent,
+            ZoomableDirective,
+            BrushableDirective,
+            AreaSeriesComponent,
+            ScatterSeriesComponent,
+            BlockSeriesComponent,
+            BlockAreaSeriesComponent,
+            AnnotationComponent,
+            CrosshairComponent,
+            DraggablePointDirective,
+            BandseriesComponent], imports: [CommonModule, LetModule], exports: [ChartComponent,
+            LegendComponent,
+            SeriesBaseComponent,
+            LineSeriesComponent,
+            BarSeriesComponent,
+            ScatterSeriesComponent,
+            AreaSeriesComponent,
+            BlockSeriesComponent,
+            BlockAreaSeriesComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ChartModule, imports: [CommonModule, LetModule] });
 }
-ChartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: ChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ChartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.2", ngImport: i0, type: ChartModule, declarations: [ChartComponent,
-        SeriesHostComponent,
-        ChartContainerComponent,
-        LegendComponent,
-        SeriesBaseComponent,
-        LinearSeriesBase,
-        LineSeriesComponent,
-        GridlinesComponent,
-        XAxisComponent,
-        YAxisComponent,
-        PlotlineComponent,
-        PlotBandComponent,
-        BarSeriesComponent,
-        TooltipComponent,
-        ZoomableDirective,
-        BrushableDirective,
-        AreaSeriesComponent,
-        ScatterSeriesComponent,
-        BlockSeriesComponent,
-        BlockAreaSeriesComponent,
-        AnnotationComponent,
-        CrosshairComponent,
-        DraggablePointDirective,
-        BandseriesComponent], imports: [CommonModule, LetModule], exports: [ChartComponent,
-        LegendComponent,
-        SeriesBaseComponent,
-        LineSeriesComponent,
-        BarSeriesComponent,
-        ScatterSeriesComponent,
-        AreaSeriesComponent,
-        BlockSeriesComponent,
-        BlockAreaSeriesComponent] });
-ChartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: ChartModule, imports: [CommonModule, LetModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: ChartModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ChartModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
@@ -105,4 +105,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImpor
                     imports: [CommonModule, LetModule],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/core/axis/axis.mjs

@@ -0,0 +1,135 @@
+import { AxisOrientation } from '../../model/enum/axis-orientation';
+import * as d3 from 'd3';
+import { AxisSizeBuilder, ExtremesBuilder } from './builders/public-api';
+import { ScaleType } from '../../model/enum/scale-type';
+export class Axis {
+    chartConfig;
+    _orientation;
+    _index;
+    _extremes = [0, 0];
+    _selfSize;
+    _ticksValues;
+    _options;
+    _originDomain = [0, 0];
+    _scale;
+    defaultFormatters = new Map()
+        .set(ScaleType.linear, d3.format(',.5~r'))
+        .set(ScaleType.time, d3.timeFormat('%d.%m.%Y'))
+        .set(ScaleType.log, d3.format('~s'))
+        .set(ScaleType.symlog, d3.format('~s'))
+        .set(ScaleType.pow, d3.format('~s'))
+        .set(ScaleType.sqrt, d3.format('~s'))
+        .set(ScaleType.band, (_) => { return _; });
+    defaultScales = new Map()
+        .set(ScaleType.linear, d3.scaleLinear)
+        .set(ScaleType.log, d3.scaleLog)
+        .set(ScaleType.symlog, d3.scaleSymlog)
+        .set(ScaleType.pow, d3.scalePow)
+        .set(ScaleType.sqrt, d3.scaleSqrt)
+        .set(ScaleType.time, d3.scaleTime)
+        .set(ScaleType.band, d3.scaleBand);
+    constructor(config) {
+        this.chartConfig = config;
+    }
+    /**
+     * Factory for creating x,y axes
+     * @param {AxisOrientation} orientation
+     * Axis type
+     * @param {IChartConfig} config
+     * Chart config
+     * @param {number} index
+     * New generated axis
+     */
+    static createAxis(orientation, config, index) {
+        const axis = new Axis(config);
+        axis.setLocate(orientation);
+        axis.setIndex(index);
+        axis.setOptions();
+        axis.setExtremes();
+        axis.setTicksValues();
+        axis.setSelfSize();
+        return axis;
+    }
+    /**
+     *
+     * @param {orientation} orientation
+     * Set locate axis x or y
+     */
+    setLocate(orientation) {
+        this._orientation = orientation;
+    }
+    /**
+     *
+     * @param {number} index
+     * Index axis
+     */
+    setIndex(index) {
+        this._index = index;
+    }
+    /**
+     * @return {Array<Series<BasePoint>>}
+     * Linked series
+     */
+    linkedSeries() {
+        const linkedFilter = (serie) => serie[this._orientation === AxisOrientation.y ? 'yAxisIndex' : 'xAxisIndex'] === this._index;
+        return this.chartConfig?.series.filter(linkedFilter);
+    }
+    setExtremes() {
+        const builder = new ExtremesBuilder();
+        this._extremes = builder.build(this);
+    }
+    setOriginDomain(domain) {
+        this._originDomain = domain;
+    }
+    setScale(scale) {
+        this._scale = scale;
+        if (this.options.scaleType.type === ScaleType.band) {
+            this._scale.ticks = () => {
+                return this._scale.domain();
+            };
+        }
+    }
+    setSelfSize() {
+        this._selfSize = new AxisSizeBuilder().build(this);
+    }
+    setTicksValues() {
+        //this._ticksValues = generateTicks(this._extremes);
+    }
+    setOptions() {
+        const options = this.orientation === AxisOrientation.x
+            ? this.chartConfig.xAxis[this.index]
+            : this.chartConfig.yAxis[this.index];
+        this._options = options;
+    }
+    get scale() {
+        return this._scale;
+    }
+    get extremes() {
+        return this._extremes;
+    }
+    get orientation() {
+        return this._orientation;
+    }
+    get selfSize() {
+        return this._selfSize;
+    }
+    get tickValues() {
+        return this._ticksValues;
+    }
+    get index() {
+        return this._index;
+    }
+    get options() {
+        return this._options;
+    }
+    get originDomain() {
+        return this._originDomain;
+    }
+    defaultFormatter() {
+        return this.defaultFormatters.get(this.options.scaleType.type);
+    }
+    defaultScale() {
+        return this.defaultScales.get(this.options.scaleType.type);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axis.js","sourceRoot":"","sources":["../../../../../src/chart/core/axis/axis.ts"],"names":[],"mappings":"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","sourcesContent":["import {IChartConfig} from '../../model/i-chart-config';\nimport {AxisOrientation} from '../../model/enum/axis-orientation';\nimport {Series} from '../../model/series';\nimport {BasePoint} from '../../model/base-point';\nimport * as d3 from 'd3';\nimport {AxisOptions} from '../../model/axis-options';\nimport {AxisSizeBuilder, ExtremesBuilder} from './builders/public-api';\nimport {ScaleType} from '../../model/enum/scale-type';\n\nexport class Axis {\n  private chartConfig: IChartConfig;\n  private _orientation: AxisOrientation;\n  private _index: number;\n  private _extremes: number[] | string[] = [0, 0];\n  private _selfSize: number;\n  private _ticksValues: number[];\n  private _options: AxisOptions;\n  private _originDomain: [number, number] = [0, 0];\n\n  private _scale: any;\n\n  private defaultFormatters = new Map<ScaleType, any>()\n    .set(ScaleType.linear, d3.format(',.5~r'))\n    .set(ScaleType.time, d3.timeFormat('%d.%m.%Y'))\n    .set(ScaleType.log, d3.format('~s'))\n    .set(ScaleType.symlog, d3.format('~s'))\n    .set(ScaleType.pow, d3.format('~s'))\n    .set(ScaleType.sqrt, d3.format('~s'))\n    .set(ScaleType.band, (_) => {return _})\n\n\n\n  private defaultScales = new Map<ScaleType, any>()\n    .set(ScaleType.linear, d3.scaleLinear)\n    .set(ScaleType.log, d3.scaleLog)\n    .set(ScaleType.symlog, d3.scaleSymlog)\n    .set(ScaleType.pow, d3.scalePow)\n    .set(ScaleType.sqrt, d3.scaleSqrt)\n    .set(ScaleType.time, d3.scaleTime)\n    .set(ScaleType.band, d3.scaleBand);\n\n  constructor(config: IChartConfig) {\n    this.chartConfig = config;\n  }\n\n  /**\n   * Factory for creating x,y axes\n   * @param {AxisOrientation} orientation\n   * Axis type\n   * @param {IChartConfig} config\n   * Chart config\n   * @param {number} index\n   * New generated axis\n   */\n  public static createAxis(\n    orientation: AxisOrientation,\n    config: IChartConfig,\n    index: number\n  ): Axis {\n    const axis = new Axis(config);\n    axis.setLocate(orientation);\n    axis.setIndex(index);\n\n    axis.setOptions();\n    axis.setExtremes();\n    axis.setTicksValues();\n    axis.setSelfSize();\n\n    return axis;\n  }\n\n  /**\n   *\n   * @param {orientation} orientation\n   * Set locate axis x or y\n   */\n  private setLocate(orientation: AxisOrientation): void {\n    this._orientation = orientation;\n  }\n\n  /**\n   *\n   * @param {number} index\n   * Index axis\n   */\n  private setIndex(index: number): void {\n    this._index = index;\n  }\n\n  /**\n   * @return {Array<Series<BasePoint>>}\n   * Linked series\n   */\n  public linkedSeries(): Array<Series<BasePoint>> {\n    const linkedFilter = (serie: Series<BasePoint>) =>\n      serie[\n        this._orientation === AxisOrientation.y ? 'yAxisIndex' : 'xAxisIndex'\n        ] === this._index;\n\n    return this.chartConfig?.series.filter(linkedFilter);\n  }\n\n  public setExtremes(): void {\n    const builder = new ExtremesBuilder();\n    this._extremes = builder.build(this);\n  }\n\n  public setOriginDomain(domain: [number, number]) {\n    this._originDomain = domain;\n  }\n\n  public setScale(scale: any) {\n    this._scale = scale;\n\n    if(this.options.scaleType.type === ScaleType.band) {\n      this._scale.ticks = () => {\n        return this._scale.domain()\n      }\n    }\n  }\n\n  private setSelfSize(): void {\n    this._selfSize = new AxisSizeBuilder().build(this);\n  }\n\n  private setTicksValues(): void {\n    //this._ticksValues = generateTicks(this._extremes);\n  }\n\n  private setOptions(): void {\n    const options =\n      this.orientation === AxisOrientation.x\n        ? this.chartConfig.xAxis[this.index]\n        : this.chartConfig.yAxis[this.index];\n\n    this._options = options;\n  }\n\n  get scale(): any {\n    return this._scale;\n  }\n\n  get extremes(): Array<number | string> {\n    return this._extremes;\n  }\n\n  get orientation(): AxisOrientation {\n    return this._orientation;\n  }\n\n  get selfSize(): number {\n    return this._selfSize;\n  }\n\n  get tickValues(): number[] {\n    return this._ticksValues;\n  }\n\n  get index(): number {\n    return this._index;\n  }\n\n  get options(): AxisOptions {\n    return this._options;\n  }\n\n  get originDomain(): [number, number] {\n    return this._originDomain;\n  }\n\n  public defaultFormatter() {\n    return this.defaultFormatters.get(this.options.scaleType.type);\n  }\n\n  public defaultScale() {\n    return this.defaultScales.get(this.options.scaleType.type);\n  }\n\n\n}\n"]}

package/esm2022/chart/core/axis/builders/axis-size-builder.mjs

@@ -0,0 +1,31 @@
+import { AxisOrientation } from '../../../model/enum/axis-orientation';
+import { maxIndex } from 'd3-array';
+import { getTextWidth } from '../../utils/public-api';
+import { ScaleType } from "../../../model/enum/scale-type";
+export class AxisSizeBuilder {
+    titlePadding = 11;
+    basePadding = 16;
+    backupRatio = 0.58;
+    build(settings) {
+        let finalPadding = this.basePadding;
+        if (settings.orientation === AxisOrientation.y) {
+            const formatter = settings.options.tickFormat || settings.defaultFormatter();
+            finalPadding += settings.options.title ? this.titlePadding : 0;
+            const scale = settings.defaultScale()();
+            scale.domain(settings.extremes);
+            if (settings.options.scaleType.type === ScaleType.band) {
+                scale.ticks = (ticks) => {
+                    return scale.domain();
+                };
+            }
+            const ticks = scale.ticks(20);
+            const maxElementLengthIndex = maxIndex(ticks, (_) => formatter(_).length);
+            finalPadding += getTextWidth(formatter(ticks[maxElementLengthIndex]), this.backupRatio);
+        }
+        if (settings.orientation === AxisOrientation.x) {
+            finalPadding += finalPadding + 20;
+        }
+        return finalPadding;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/chart/core/axis/builders/extremes-builder.mjs

@@ -0,0 +1,33 @@
+import { AxisOrientation } from '../../../model/enum/axis-orientation';
+import * as d3 from 'd3';
+import { ScaleType } from "../../../model/enum/scale-type";
+export class ExtremesBuilder {
+    extentAccessorMap = new Map()
+        .set(AxisOrientation.x, (_) => _.x)
+        .set(AxisOrientation.y, (_) => _.y);
+    extremes = [0, 0];
+    build(settings) {
+        const options = settings.options;
+        const hasMin = options?.min != null;
+        const hasMax = options?.max != null;
+        if (!hasMin || !hasMax) {
+            const linkedSeries = settings.linkedSeries();
+            const data = linkedSeries.reduce((acc, current) => {
+                return acc.concat(current.data);
+            }, []);
+            const accessor = this.extentAccessorMap.get(settings.orientation);
+            this.extremes = data.length > 1 ? d3.extent(data, accessor) : [0, 0];
+            if (settings.options.scaleType.type === ScaleType.band) {
+                this.extremes = data.map(accessor);
+            }
+        }
+        if (hasMin) {
+            this.extremes[0] = options?.min;
+        }
+        if (hasMax) {
+            this.extremes[1] = options?.max;
+        }
+        return this.extremes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmVtZXMtYnVpbGRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jaGFydC9jb3JlL2F4aXMvYnVpbGRlcnMvZXh0cmVtZXMtYnVpbGRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0sc0NBQXNDLENBQUM7QUFFckUsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE1BQU0sT0FBTyxlQUFlO0lBQ2xCLGlCQUFpQixHQUFHLElBQUksR0FBRyxFQUNGO1NBQzlCLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQ2xDLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFOUIsUUFBUSxHQUF3QixDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUUvQyxLQUFLLENBQUMsUUFBYztRQUNsQixNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsT0FBTyxDQUFDO1FBRWpDLE1BQU0sTUFBTSxHQUFHLE9BQU8sRUFBRSxHQUFHLElBQUksSUFBSSxDQUFDO1FBQ3BDLE1BQU0sTUFBTSxHQUFHLE9BQU8sRUFBRSxHQUFHLElBQUksSUFBSSxDQUFDO1FBRXBDLElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDdEIsTUFBTSxZQUFZLEdBQUcsUUFBUSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQzdDLE1BQU0sSUFBSSxHQUFHLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFnQixFQUFFLE9BQU8sRUFBRSxFQUFFO2dCQUM3RCxPQUFPLEdBQUcsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ2xDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUNQLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBQ2xFLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUVyRSxJQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksS0FBSyxTQUFTLENBQUMsSUFBSSxFQUFFO2dCQUNyRCxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUE7YUFDbkM7U0FFRjtRQUVELElBQUksTUFBTSxFQUFFO1lBQ1YsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLEVBQUUsR0FBRyxDQUFDO1NBQ2pDO1FBRUQsSUFBSSxNQUFNLEVBQUU7WUFDVixJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxHQUFHLE9BQU8sRUFBRSxHQUFHLENBQUM7U0FDakM7UUFFRCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUM7SUFDdkIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJQnVpbGRlcn0gZnJvbSAnLi4vLi4vLi4vbW9kZWwvaS1idWlsZGVyJztcbmltcG9ydCB7QXhpc30gZnJvbSAnLi4vYXhpcyc7XG5pbXBvcnQge0Jhc2VQb2ludH0gZnJvbSAnLi4vLi4vLi4vbW9kZWwvYmFzZS1wb2ludCc7XG5pbXBvcnQge0F4aXNPcmllbnRhdGlvbn0gZnJvbSAnLi4vLi4vLi4vbW9kZWwvZW51bS9heGlzLW9yaWVudGF0aW9uJztcblxuaW1wb3J0ICogYXMgZDMgZnJvbSAnZDMnO1xuaW1wb3J0IHtTY2FsZVR5cGV9IGZyb20gXCIuLi8uLi8uLi9tb2RlbC9lbnVtL3NjYWxlLXR5cGVcIjtcblxuZXhwb3J0IGNsYXNzIEV4dHJlbWVzQnVpbGRlciBpbXBsZW1lbnRzIElCdWlsZGVyPEF4aXMsIG51bWJlcltdIHwgc3RyaW5nW10+IHtcbiAgcHJpdmF0ZSBleHRlbnRBY2Nlc3Nvck1hcCA9IG5ldyBNYXA8QXhpc09yaWVudGF0aW9uLFxuICAgIChwb2ludDogQmFzZVBvaW50KSA9PiBudW1iZXI+KClcbiAgICAuc2V0KEF4aXNPcmllbnRhdGlvbi54LCAoXykgPT4gXy54KVxuICAgIC5zZXQoQXhpc09yaWVudGF0aW9uLnksIChfKSA9PiBfLnkpO1xuXG4gIHByaXZhdGUgZXh0cmVtZXM6IG51bWJlcltdIHwgc3RyaW5nW10gPSBbMCwgMF07XG5cbiAgYnVpbGQoc2V0dGluZ3M6IEF4aXMpOiBudW1iZXJbXSB8IHN0cmluZ1tdIHtcbiAgICBjb25zdCBvcHRpb25zID0gc2V0dGluZ3Mub3B0aW9ucztcblxuICAgIGNvbnN0IGhhc01pbiA9IG9wdGlvbnM/Lm1pbiAhPSBudWxsO1xuICAgIGNvbnN0IGhhc01heCA9IG9wdGlvbnM/Lm1heCAhPSBudWxsO1xuXG4gICAgaWYgKCFoYXNNaW4gfHwgIWhhc01heCkge1xuICAgICAgY29uc3QgbGlua2VkU2VyaWVzID0gc2V0dGluZ3MubGlua2VkU2VyaWVzKCk7XG4gICAgICBjb25zdCBkYXRhID0gbGlua2VkU2VyaWVzLnJlZHVjZSgoYWNjOiBCYXNlUG9pbnRbXSwgY3VycmVudCkgPT4ge1xuICAgICAgICByZXR1cm4gYWNjLmNvbmNhdChjdXJyZW50LmRhdGEpO1xuICAgICAgfSwgW10pO1xuICAgICAgY29uc3QgYWNjZXNzb3IgPSB0aGlzLmV4dGVudEFjY2Vzc29yTWFwLmdldChzZXR0aW5ncy5vcmllbnRhdGlvbik7XG4gICAgICB0aGlzLmV4dHJlbWVzID0gZGF0YS5sZW5ndGggPiAxID8gZDMuZXh0ZW50KGRhdGEsIGFjY2Vzc29yKSA6IFswLCAwXTtcblxuICAgICAgaWYoc2V0dGluZ3Mub3B0aW9ucy5zY2FsZVR5cGUudHlwZSA9PT0gU2NhbGVUeXBlLmJhbmQpIHtcbiAgICAgICAgdGhpcy5leHRyZW1lcyA9IGRhdGEubWFwKGFjY2Vzc29yKVxuICAgICAgfVxuXG4gICAgfVxuXG4gICAgaWYgKGhhc01pbikge1xuICAgICAgdGhpcy5leHRyZW1lc1swXSA9IG9wdGlvbnM/Lm1pbjtcbiAgICB9XG5cbiAgICBpZiAoaGFzTWF4KSB7XG4gICAgICB0aGlzLmV4dHJlbWVzWzFdID0gb3B0aW9ucz8ubWF4O1xuICAgIH1cblxuICAgIHJldHVybiB0aGlzLmV4dHJlbWVzO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,162 @@
+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 {
+    brushService;
+    chartService;
+    element;
+    zone;
+    config;
+    axis;
+    selection;
+    brush;
+    brushMap = new Map()
+        .set(BrushType.x, d3.brushX())
+        .set(BrushType.y, d3.brushY());
+    _alive = true;
+    _container;
+    constructor(brushService, chartService, element, zone) {
+        this.brushService = brushService;
+        this.chartService = chartService;
+        this.element = element;
+        this.zone = zone;
+        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() {
+        if (this.config?.brush?.enable) {
+            const brushMessage = new BrushMessage({
+                chartId: this.config.id,
+                selection: [this.config?.brush?.from, this.config?.brush?.to],
+                mode: 'init'
+            });
+            this.brushService.setBrush(brushMessage);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes.hasOwnProperty('config')) {
+            this.clearPreviousSelection();
+        }
+        if (this.config?.brush?.enable) {
+            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)],
+                        mode: _.mode
+                    });
+                    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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BrushableDirective, deps: [{ token: i1.BrushService }, { token: i2.ChartService }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: BrushableDirective, selector: "[tetaBrushable]", inputs: { config: "config", axis: "axis" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BrushableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tetaBrushable]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BrushService }, { type: i2.ChartService }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { config: [{
+                type: Input
+            }], axis: [{
+                type: Input
+            }] } });
+//# 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;IAanB;IACA;IACA;IACA;IAfD,MAAM,CAAe;IACrB,IAAI,CAAO;IAEZ,SAAS,CAAW;IACpB,KAAK,CAAwB;IAC7B,QAAQ,GAAG,IAAI,GAAG,EAAoC;SAC3D,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;SAC7B,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;IACzB,MAAM,GAAG,IAAI,CAAC;IACd,UAAU,CAAC;IAEnB,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;QAEpB,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;QACb,IAAG,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE;YAC7B,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC;gBACpC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;gBACvB,SAAS,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;gBAC7D,IAAI,EAAE,MAAM;aACb,CAAC,CAAC;YACH,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;SAC1C;IACH,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;wBAC3D,IAAI,EAAE,CAAC,CAAC,IAAI;qBACb,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;uGA9LU,kBAAkB;2FAAlB,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    if(this.config?.brush?.enable) {\n      const brushMessage = new BrushMessage({\n        chartId: this.config.id,\n        selection: [this.config?.brush?.from, this.config?.brush?.to],\n        mode: 'init'\n      });\n      this.brushService.setBrush(brushMessage);\n    }\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            mode: _.mode\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"]}