@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/a-chart/chart.component.mjs

@@ -0,0 +1,292 @@
+import { __decorate, __metadata } from "tslib";
+import { ThemeService, isTemplateRef } from '@alauda/ui';
+import { Component, ChangeDetectionStrategy, Input, ViewChild, ElementRef, TemplateRef, EventEmitter, Output, ContentChild, } from '@angular/core';
+import { omit } from 'lodash-es';
+import { Observable, Subject, combineLatest, distinctUntilChanged, takeUntil, } from 'rxjs';
+import { ActionType, ChartEvent, } from 'zz-chart';
+import { ObservableInput, isEqual } from '../core/public-api';
+import { BaseChart } from './base-chart';
+import { LegendComponent, LegendDropdownComponent, TitleComponent, } from './components/public-api';
+import { NULL_POINT_MODE, } from './types';
+import { handleDateFormat, pointFormat } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+const _c0 = ["chartDom"];
+const _c1 = [[["a-title"]], [["a-legend"]], [["a-legend-dropdown"]], [["acl-chart-zoom-button"]], "*"];
+const _c2 = ["a-title", "a-legend", "a-legend-dropdown", "acl-chart-zoom-button", "*"];
+export class ChartComponent extends BaseChart {
+    get background() {
+        return this.backgroundColor;
+    }
+    constructor(themeService) {
+        super();
+        this.themeService = themeService;
+        this.tooltipAppendToBody = true;
+        this.autoFit = true;
+        this.nullPointMode = NULL_POINT_MODE.Null;
+        this.type = 'area';
+        this.xAccessor = (d) => String(d.x).length === 10 ? d.x * 1000 : d.x;
+        this.yAccessor = (d) => d.y;
+        this.enableZoom = false;
+        this.refresh = new EventEmitter();
+        this.markClick = new EventEmitter();
+        this.mouseUp = new EventEmitter();
+        this.contextCallback = new EventEmitter();
+        this.onDestroy$ = new Subject();
+        this.isTemplateRef = isTemplateRef;
+        combineLatest([
+            this.type$,
+            this.options$.pipe(distinctUntilChanged((a, b) => isEqual(a, b))),
+            this.data$,
+        ]).subscribe(([type, options]) => {
+            const render = (!options?.annotation?.lineX && !this.chartOption?.annotation?.lineX) ||
+                !isEqual(options?.annotation?.lineX, this.chartOption?.annotation?.lineX);
+            if (!render) {
+                this.chart.annotation().lineX(options?.annotation?.lineX);
+            }
+            if (options && type && render) {
+                this.renderChart();
+            }
+        });
+        this.status$.pipe(takeUntil(this.onDestroy$)).subscribe(res => {
+            res && this.changeStatus(res);
+        });
+    }
+    ngAfterViewInit() {
+        this.renderChart();
+    }
+    get chartOption() {
+        const customHeader = this.titleRef || this.legendRef || this.legendDropdownRef;
+        const tooltip = this.options?.tooltip === false
+            ? this.options.tooltip
+            : {
+                popupContainer: this.tooltipAppendToBody
+                    ? null
+                    : this.chartEl?.nativeElement,
+                titleFormatter: (value) => handleDateFormat(+value),
+                valueFormatter: (value) => pointFormat(+value),
+                ...(typeof this.options?.tooltip === 'object'
+                    ? this.options.tooltip
+                    : {}),
+            };
+        return {
+            ...(customHeader ? { title: false, legend: false } : {}),
+            scale: {
+                y: {},
+            },
+            ...omit(this.options, 'tooltip'),
+            tooltip,
+        };
+    }
+    renderChart() {
+        if (this.chart) {
+            this.destroy();
+        }
+        if (!this.chartEl?.nativeElement) {
+            return;
+        }
+        this.init({
+            container: this.chartEl.nativeElement,
+            data: this.handelData(this.data),
+            options: this.chartOption,
+        });
+        this.handleChartType(this.type, this.nullPointMode === NULL_POINT_MODE.Connected
+            ? {
+                connectNulls: true,
+            }
+            : {});
+        this.handleTheme();
+        this.render();
+        this.contextCallback.next(this.chart);
+        this.data$.subscribe(data => {
+            const values = this.handelData(data);
+            this.chart?.data(values);
+            this.changeStatus({
+                loading: false,
+            });
+        });
+        this.handleChartEvent();
+    }
+    handelData(data) {
+        return data.map(d => ({
+            ...d,
+            values: d.values?.map(v => ({
+                ...v,
+                x: this.xAccessor(v),
+                y: this.yAccessor(v),
+            })),
+        }));
+    }
+    handleTheme() {
+        if (this.theme) {
+            this.chart.theme(this.theme);
+        }
+        this.themeService.currentTheme$
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe(type => {
+            this.chart.theme(type);
+        });
+    }
+    handleChartEvent() {
+        if (!this.legendRef && !this.legendDropdownRef) {
+            const legend = this.chart?.components.get('legend');
+            this.chart.on(ChartEvent.LEGEND_ITEM_CLICK, () => {
+                this.changeStatus({
+                    noLegend: legend.inactivatedSet.size === legend.getLegend().length,
+                });
+            });
+        }
+        this.chart.on(ChartEvent.PLOT_CLICK, (value) => {
+            this.markClick.next(value);
+        });
+        this.enableZoom$.pipe(takeUntil(this.onDestroy$)).subscribe(() => {
+            if (this.enableZoom) {
+                this.chart.interaction('brush-x', {
+                    end: [
+                        {
+                            trigger: ChartEvent.PLOT_MOUSEUP,
+                            action: ActionType.BRUSH_X_END,
+                            callback: (e) => {
+                                if (e.start !== e.end) {
+                                    this.mouseUp.next(e);
+                                }
+                            },
+                        },
+                    ],
+                });
+            }
+        });
+    }
+    onRefresh() {
+        this.refresh.next(null);
+    }
+    getHeight(height, chartOption) {
+        return typeof chartOption.legend === 'object' &&
+            chartOption.legend?.position?.includes('bottom-left')
+            ? `calc(100% - ${height || 0}px)`
+            : '100%';
+    }
+    ngOnDestroy() {
+        this.destroy();
+        this.onDestroy$.next();
+    }
+    static { this.ɵfac = function ChartComponent_Factory(t) { return new (t || ChartComponent)(i0.ɵɵdirectiveInject(i1.ThemeService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ChartComponent, selectors: [["a-chart"]], contentQueries: function ChartComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, TitleComponent, 5);
+            i0.ɵɵcontentQuery(dirIndex, LegendComponent, 5);
+            i0.ɵɵcontentQuery(dirIndex, LegendDropdownComponent, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.titleRef = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.legendRef = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.legendDropdownRef = _t.first);
+        } }, viewQuery: function ChartComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.chartEl = _t.first);
+        } }, inputs: { status: "status", data: "data", backgroundColor: "backgroundColor", tooltipAppendToBody: "tooltipAppendToBody", autoFit: "autoFit", width: "width", height: "height", padding: "padding", theme: "theme", nullPointMode: "nullPointMode", options: "options", type: "type", customNoData: "customNoData", customError: "customError", xAccessor: "xAccessor", yAccessor: "yAccessor", enableZoom: "enableZoom" }, outputs: { refresh: "refresh", markClick: "markClick", mouseUp: "mouseUp", contextCallback: "contextCallback" }, exportAs: ["aChart"], features: [i0.ɵɵInheritDefinitionFeature], ngContentSelectors: _c2, decls: 14, vars: 13, consts: [[1, "a-chart"], [1, "tw-flex"], ["header", ""], [1, "tw-w-full"], ["chartDom", ""], [3, "status", "customNoData", "customError", "refresh"]], template: function ChartComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef(_c1);
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1, 2);
+            i0.ɵɵprojection(3);
+            i0.ɵɵprojection(4, 1);
+            i0.ɵɵprojection(5, 2);
+            i0.ɵɵprojection(6, 3);
+            i0.ɵɵprojection(7, 4);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(8, "div", 3);
+            i0.ɵɵpipe(9, "pure");
+            i0.ɵɵelement(10, "div", null, 4);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(12, "acl-chart-status", 5);
+            i0.ɵɵlistener("refresh", function ChartComponent_Template_acl_chart_status_refresh_12_listener() { return ctx.onRefresh(); });
+            i0.ɵɵpipe(13, "async");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            const _r0 = i0.ɵɵreference(2);
+            i0.ɵɵstyleProp("background", ctx.background);
+            i0.ɵɵadvance(8);
+            i0.ɵɵstyleProp("height", i0.ɵɵpipeBind3(9, 7, _r0.clientHeight, ctx.getHeight, ctx.chartOption));
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("status", i0.ɵɵpipeBind1(13, 11, ctx.chartStatus$))("customNoData", ctx.customNoData)("customError", ctx.customError);
+        } }, styles: ["[_nghost-%COMP%]{width:100%;height:100%;display:block;min-height:0}.a-chart[_ngcontent-%COMP%]{display:flex;width:100%;position:relative;height:100%;box-sizing:border-box;flex-direction:column}.a-chart[_ngcontent-%COMP%]     .achart-title{font-size:var(--aui-font-size-l)}.a-chart-container[_ngcontent-%COMP%]{width:100%}.a-chart-status[_ngcontent-%COMP%]{left:50%;position:absolute;top:50%;white-space:nowrap;transform:translate(-50%,-50%)}.status[_ngcontent-%COMP%]{padding:6px 16px;display:flex;align-items:center;justify-content:center;background-color:rgb(var(--aui-color-n-8));color:rgb(var(--aui-color-n-4));border-radius:2px}.status[_ngcontent-%COMP%]   aui-icon[_ngcontent-%COMP%]{font-size:14px;margin-right:4px}.loading[_ngcontent-%COMP%]   aui-icon[_ngcontent-%COMP%]{color:rgb(var(--aui-color-primary))}.failed[_ngcontent-%COMP%]   aui-icon[_ngcontent-%COMP%]{color:rgb(var(--aui-color-red))}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ChartComponent.prototype, "status$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ChartComponent.prototype, "data$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ChartComponent.prototype, "options$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ChartComponent.prototype, "type$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ChartComponent.prototype, "enableZoom$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ChartComponent, [{
+        type: Component,
+        args: [{ selector: 'a-chart', exportAs: 'aChart', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  class=\"a-chart\"\n  [style.background]=\"background\"\n>\n  <div\n    class=\"tw-flex\"\n    #header\n  >\n    <ng-content select=\"a-title\"></ng-content>\n    <ng-content select=\"a-legend\"></ng-content>\n    <ng-content select=\"a-legend-dropdown\"></ng-content>\n    <ng-content select=\"acl-chart-zoom-button\"></ng-content>\n    <ng-content></ng-content>\n  </div>\n  <div\n    class=\"tw-w-full\"\n    [style.height]=\"header.clientHeight | pure: getHeight:chartOption\"\n  >\n    <div #chartDom></div>\n  </div>\n\n  <acl-chart-status\n    [status]=\"chartStatus$ | async\"\n    [customNoData]=\"customNoData\"\n    [customError]=\"customError\"\n    (refresh)=\"onRefresh()\"\n  ></acl-chart-status>\n</div>\n", styles: [":host{width:100%;height:100%;display:block;min-height:0}.a-chart{display:flex;width:100%;position:relative;height:100%;box-sizing:border-box;flex-direction:column}.a-chart ::ng-deep .achart-title{font-size:var(--aui-font-size-l)}.a-chart-container{width:100%}.a-chart-status{left:50%;position:absolute;top:50%;white-space:nowrap;transform:translate(-50%,-50%)}.status{padding:6px 16px;display:flex;align-items:center;justify-content:center;background-color:rgb(var(--aui-color-n-8));color:rgb(var(--aui-color-n-4));border-radius:2px}.status aui-icon{font-size:14px;margin-right:4px}.loading aui-icon{color:rgb(var(--aui-color-primary))}.failed aui-icon{color:rgb(var(--aui-color-red))}\n"] }]
+    }], function () { return [{ type: i1.ThemeService }]; }, { status: [{
+            type: Input
+        }], status$: [], data: [{
+            type: Input
+        }], data$: [], backgroundColor: [{
+            type: Input
+        }], tooltipAppendToBody: [{
+            type: Input
+        }], autoFit: [{
+            type: Input
+        }], width: [{
+            type: Input
+        }], height: [{
+            type: Input
+        }], padding: [{
+            type: Input
+        }], theme: [{
+            type: Input
+        }], nullPointMode: [{
+            type: Input
+        }], options: [{
+            type: Input
+        }], options$: [], type: [{
+            type: Input
+        }], type$: [], customNoData: [{
+            type: Input
+        }], customError: [{
+            type: Input
+        }], xAccessor: [{
+            type: Input
+        }], yAccessor: [{
+            type: Input
+        }], enableZoom: [{
+            type: Input
+        }], enableZoom$: [], refresh: [{
+            type: Output
+        }], markClick: [{
+            type: Output
+        }], mouseUp: [{
+            type: Output
+        }], contextCallback: [{
+            type: Output
+        }], chartEl: [{
+            type: ViewChild,
+            args: ['chartDom']
+        }], titleRef: [{
+            type: ContentChild,
+            args: [TitleComponent]
+        }], legendRef: [{
+            type: ContentChild,
+            args: [LegendComponent]
+        }], legendDropdownRef: [{
+            type: ContentChild,
+            args: [LegendDropdownComponent]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.component.js","sourceRoot":"","sources":["../../../../../libs/common/src/a-chart/chart.component.ts","../../../../../libs/common/src/a-chart/chart.component.html"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EACL,SAAS,EACT,uBAAuB,EACvB,KAAK,EACL,SAAS,EACT,UAAU,EAGV,WAAW,EACX,YAAY,EACZ,MAAM,EACN,YAAY,GACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EACL,UAAU,EACV,OAAO,EACP,aAAa,EACb,oBAAoB,EACpB,SAAS,GACV,MAAM,MAAM,CAAC;AACd,OAAO,EACL,UAAU,EAEV,UAAU,GAQX,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAML,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;;;;;;AASxD,MAAM,OAAO,cACX,SAAQ,SAAS;IAgEjB,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAID,YAA6B,YAA0B;QACrD,KAAK,EAAE,CAAC;QADmB,iBAAY,GAAZ,YAAY,CAAc;QAzD9C,wBAAmB,GAAG,IAAI,CAAC;QAE3B,YAAO,GAAG,IAAI,CAAC;QAMf,kBAAa,GAAoB,eAAe,CAAC,IAAI,CAAC;QAMtD,SAAI,GAAU,MAAM,CAAC;QAOrB,cAAS,GAAG,CAAC,CAAwB,EAAE,EAAE,CAChD,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtC,cAAS,GAAG,CAAC,CAAwB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAE9C,eAAU,GAAG,KAAK,CAAC;QAIlB,YAAO,GAAG,IAAI,YAAY,EAAQ,CAAC;QAEnC,cAAS,GAAG,IAAI,YAAY,EAAe,CAAC;QAE5C,YAAO,GAAG,IAAI,YAAY,EAAgB,CAAC;QAE3C,oBAAe,GAAG,IAAI,YAAY,EAAS,CAAC;QAarC,eAAU,GAAG,IAAI,OAAO,EAAQ,CAAC;QAMlD,kBAAa,GAAG,aAAa,CAAC;QAI5B,aAAa,CAAC;YACZ,IAAI,CAAC,KAAK;YACV,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACjE,IAAI,CAAC,KAAK;SACX,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE;YAC/B,MAAM,MAAM,GACV,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,CAAC;gBACrE,CAAC,OAAO,CACN,OAAO,EAAE,UAAU,EAAE,KAAK,EAC1B,IAAI,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,CACpC,CAAC;YACJ,IAAI,CAAC,MAAM,EAAE;gBACX,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;aAC3D;YACD,IAAI,OAAO,IAAI,IAAI,IAAI,MAAM,EAAE;gBAC7B,IAAI,CAAC,WAAW,EAAE,CAAC;aACpB;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC5D,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,eAAe;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,IAAI,WAAW;QACb,MAAM,YAAY,GAChB,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,iBAAiB,CAAC;QAC5D,MAAM,OAAO,GACX,IAAI,CAAC,OAAO,EAAE,OAAO,KAAK,KAAK;YAC7B,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO;YACtB,CAAC,CAAC;gBACE,cAAc,EAAE,IAAI,CAAC,mBAAmB;oBACtC,CAAC,CAAC,IAAI;oBACN,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,aAAa;gBAC/B,cAAc,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,KAAK,CAAC;gBAC3D,cAAc,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC;gBACtD,GAAG,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ;oBAC3C,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO;oBACtB,CAAC,CAAC,EAAE,CAAC;aACR,CAAC;QACR,OAAO;YACL,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxD,KAAK,EAAE;gBACL,CAAC,EAAE,EAAE;aACN;YACD,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC;YAChC,OAAO;SACR,CAAC;IACJ,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,IAAI,CAAC,OAAO,EAAE,CAAC;SAChB;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE;YAChC,OAAO;SACR;QACD,IAAI,CAAC,IAAI,CAAC;YACR,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa;YACrC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC;YAChC,OAAO,EAAE,IAAI,CAAC,WAAW;SAC1B,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAClB,IAAI,CAAC,IAAI,EACT,IAAI,CAAC,aAAa,KAAK,eAAe,CAAC,SAAS;YAC9C,CAAC,CAAC;gBACE,YAAY,EAAE,IAAI;aACnB;YACH,CAAC,CAAC,EAAE,CACP,CAAC;QACF,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;YAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC;gBAChB,OAAO,EAAE,KAAK;aACf,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEO,UAAU,CAAC,IAAU;QAC3B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACpB,GAAG,CAAC;YACJ,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC1B,GAAG,CAAC;gBACJ,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gBACpB,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;aACrB,CAAC,CAAC;SACJ,CAAC,CAAC,CAAC;IACN,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC9B;QACD,IAAI,CAAC,YAAY,CAAC,aAAa;aAC5B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,CAAC,IAAI,CAAC,EAAE;YAChB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;YAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAW,CAAC;YAC9D,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,UAAU,CAAC,iBAAiB,EAAE,GAAG,EAAE;gBAC/C,IAAI,CAAC,YAAY,CAAC;oBAChB,QAAQ,EAAE,MAAM,CAAC,cAAc,CAAC,IAAI,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC,MAAM;iBACnE,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;QACD,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,KAAkB,EAAE,EAAE;YAC1D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC/D,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,EAAE;oBAChC,GAAG,EAAE;wBACH;4BACE,OAAO,EAAE,UAAU,CAAC,YAAY;4BAChC,MAAM,EAAE,UAAU,CAAC,WAAW;4BAC9B,QAAQ,EAAE,CAAC,CAAe,EAAE,EAAE;gCAC5B,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,EAAE;oCACrB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iCACtB;4BACH,CAAC;yBACF;qBACF;iBACF,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,SAAS;QACP,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,SAAS,CAAC,MAAc,EAAE,WAAoB;QAC5C,OAAO,OAAO,WAAW,CAAC,MAAM,KAAK,QAAQ;YAC3C,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC;YACrD,CAAC,CAAC,eAAe,MAAM,IAAI,CAAC,KAAK;YACjC,CAAC,CAAC,MAAM,CAAC;IACb,CAAC;IAED,WAAW;QACT,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;+EAlOU,cAAc;oEAAd,cAAc;wCAsDX,cAAc;wCAGd,eAAe;wCAGf,uBAAuB;;;;;;;;;;;;;YCxHvC,8BAGC,gBAAA;YAKG,kBAA0C;YAC1C,qBAA2C;YAC3C,qBAAoD;YACpD,qBAAwD;YACxD,qBAAyB;YAC3B,iBAAM;YACN,8BAGC;;YACC,gCAAqB;YACvB,iBAAM;YAEN,4CAKC;YADC,0GAAW,eAAW,IAAC;;YACxB,iBAAmB,EAAA;;;YAxBpB,4CAA+B;YAc7B,eAAkE;YAAlE,gGAAkE;YAMlE,eAA+B;YAA/B,iEAA+B,kCAAA,gCAAA;;;AD4CjC;IADC,eAAe,EAAE;8BACR,UAAU;+CAAe;AAInC;IADC,eAAe,EAAE;8BACV,UAAU;6CAAe;AAgBjC;IADC,eAAe,EAAE;8BACP,UAAU;gDAAW;AAIhC;IADC,eAAe,EAAE;8BACV,UAAU;6CAAQ;AAY1B;IADC,eAAe,EAAE;8BACL,UAAU;mDAAU;uFA1CtB,cAAc;cAP1B,SAAS;2BACE,SAAS,YACT,QAAQ,mBAGD,uBAAuB,CAAC,MAAM;+DAMtC,MAAM;kBAAd,KAAK;YAEN,OAAO,MAEE,IAAI;kBAAZ,KAAK;YAEN,KAAK,MAEI,eAAe;kBAAvB,KAAK;YAEG,mBAAmB;kBAA3B,KAAK;YAEG,OAAO;kBAAf,KAAK;YACG,KAAK;kBAAb,KAAK;YACG,MAAM;kBAAd,KAAK;YACG,OAAO;kBAAf,KAAK;YACG,KAAK;kBAAb,KAAK;YAEG,aAAa;kBAArB,KAAK;YAEG,OAAO;kBAAf,KAAK;YAEN,QAAQ,MAEC,IAAI;kBAAZ,KAAK;YAEN,KAAK,MAEI,YAAY;kBAApB,KAAK;YACG,WAAW;kBAAnB,KAAK;YAEG,SAAS;kBAAjB,KAAK;YAGG,SAAS;kBAAjB,KAAK;YAEG,UAAU;kBAAlB,KAAK;YAEN,WAAW,MAED,OAAO;kBAAhB,MAAM;YAEG,SAAS;kBAAlB,MAAM;YAEG,OAAO;kBAAhB,MAAM;YAEG,eAAe;kBAAxB,MAAM;YAEgB,OAAO;kBAA7B,SAAS;mBAAC,UAAU;YAGrB,QAAQ;kBADP,YAAY;mBAAC,cAAc;YAI5B,SAAS;kBADR,YAAY;mBAAC,eAAe;YAI7B,iBAAiB;kBADhB,YAAY;mBAAC,uBAAuB","sourcesContent":["import { ThemeService, isTemplateRef } from '@alauda/ui';\nimport {\n  Component,\n  ChangeDetectionStrategy,\n  Input,\n  ViewChild,\n  ElementRef,\n  AfterViewInit,\n  OnDestroy,\n  TemplateRef,\n  EventEmitter,\n  Output,\n  ContentChild,\n} from '@angular/core';\nimport { omit } from 'lodash-es';\nimport {\n  Observable,\n  Subject,\n  combineLatest,\n  distinctUntilChanged,\n  takeUntil,\n} from 'rxjs';\nimport {\n  ActionType,\n  Chart,\n  ChartEvent,\n  Data,\n  DataItem,\n  Legend,\n  Options,\n  Padding,\n  Theme,\n  BrushContext,\n} from 'zz-chart';\n\nimport { ObservableInput, isEqual } from '../core/public-api';\n\nimport { BaseChart } from './base-chart';\nimport {\n  LegendComponent,\n  LegendDropdownComponent,\n  TitleComponent,\n} from './components/public-api';\nimport {\n  AChartData,\n  AChartStatus,\n  AOptions,\n  AType,\n  MarkContext,\n  NULL_POINT_MODE,\n} from './types';\nimport { handleDateFormat, pointFormat } from './utils';\n\n@Component({\n  selector: 'a-chart',\n  exportAs: 'aChart',\n  templateUrl: './chart.component.html',\n  styleUrls: ['./chart.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ChartComponent\n  extends BaseChart\n  implements AfterViewInit, OnDestroy\n{\n  @Input() status: AChartStatus;\n  @ObservableInput()\n  status$!: Observable<AChartStatus>;\n\n  @Input() data: AChartData[];\n  @ObservableInput()\n  data$!: Observable<AChartData[]>;\n\n  @Input() backgroundColor: string;\n\n  @Input() tooltipAppendToBody = true;\n\n  @Input() autoFit = true;\n  @Input() width: number;\n  @Input() height: number;\n  @Input() padding: Padding;\n  @Input() theme: Theme;\n\n  @Input() nullPointMode: NULL_POINT_MODE = NULL_POINT_MODE.Null;\n\n  @Input() options: AOptions;\n  @ObservableInput()\n  options$!: Observable<AOptions>;\n\n  @Input() type: AType = 'area';\n  @ObservableInput()\n  type$!: Observable<AType>;\n\n  @Input() customNoData: TemplateRef<unknown> | string;\n  @Input() customError: TemplateRef<unknown>;\n\n  @Input() xAccessor = (d: DataItem['values'][0]) =>\n    String(d.x).length === 10 ? d.x * 1000 : d.x;\n\n  @Input() yAccessor = (d: DataItem['values'][0]) => d.y;\n\n  @Input() enableZoom = false;\n  @ObservableInput()\n  enableZoom$: Observable<boolean>;\n\n  @Output() refresh = new EventEmitter<void>();\n\n  @Output() markClick = new EventEmitter<MarkContext>();\n\n  @Output() mouseUp = new EventEmitter<BrushContext>();\n\n  @Output() contextCallback = new EventEmitter<Chart>();\n\n  @ViewChild('chartDom') chartEl!: ElementRef<HTMLDivElement>;\n\n  @ContentChild(TitleComponent)\n  titleRef: TitleComponent;\n\n  @ContentChild(LegendComponent)\n  legendRef: LegendComponent;\n\n  @ContentChild(LegendDropdownComponent)\n  legendDropdownRef: LegendDropdownComponent;\n\n  private readonly onDestroy$ = new Subject<void>();\n\n  get background() {\n    return this.backgroundColor;\n  }\n\n  isTemplateRef = isTemplateRef;\n\n  constructor(private readonly themeService: ThemeService) {\n    super();\n    combineLatest([\n      this.type$,\n      this.options$.pipe(distinctUntilChanged((a, b) => isEqual(a, b))),\n      this.data$,\n    ]).subscribe(([type, options]) => {\n      const render =\n        (!options?.annotation?.lineX && !this.chartOption?.annotation?.lineX) ||\n        !isEqual(\n          options?.annotation?.lineX,\n          this.chartOption?.annotation?.lineX,\n        );\n      if (!render) {\n        this.chart.annotation().lineX(options?.annotation?.lineX);\n      }\n      if (options && type && render) {\n        this.renderChart();\n      }\n    });\n    this.status$.pipe(takeUntil(this.onDestroy$)).subscribe(res => {\n      res && this.changeStatus(res);\n    });\n  }\n\n  ngAfterViewInit() {\n    this.renderChart();\n  }\n\n  get chartOption(): Options {\n    const customHeader =\n      this.titleRef || this.legendRef || this.legendDropdownRef;\n    const tooltip =\n      this.options?.tooltip === false\n        ? this.options.tooltip\n        : {\n            popupContainer: this.tooltipAppendToBody\n              ? null\n              : this.chartEl?.nativeElement,\n            titleFormatter: (value: string) => handleDateFormat(+value),\n            valueFormatter: (value: number) => pointFormat(+value),\n            ...(typeof this.options?.tooltip === 'object'\n              ? this.options.tooltip\n              : {}),\n          };\n    return {\n      ...(customHeader ? { title: false, legend: false } : {}),\n      scale: {\n        y: {},\n      },\n      ...omit(this.options, 'tooltip'),\n      tooltip,\n    };\n  }\n\n  private renderChart() {\n    if (this.chart) {\n      this.destroy();\n    }\n    if (!this.chartEl?.nativeElement) {\n      return;\n    }\n    this.init({\n      container: this.chartEl.nativeElement,\n      data: this.handelData(this.data),\n      options: this.chartOption,\n    });\n    this.handleChartType(\n      this.type,\n      this.nullPointMode === NULL_POINT_MODE.Connected\n        ? {\n            connectNulls: true,\n          }\n        : {},\n    );\n    this.handleTheme();\n    this.render();\n    this.contextCallback.next(this.chart);\n    this.data$.subscribe(data => {\n      const values = this.handelData(data);\n      this.chart?.data(values);\n      this.changeStatus({\n        loading: false,\n      });\n    });\n    this.handleChartEvent();\n  }\n\n  private handelData(data: Data) {\n    return data.map(d => ({\n      ...d,\n      values: d.values?.map(v => ({\n        ...v,\n        x: this.xAccessor(v),\n        y: this.yAccessor(v),\n      })),\n    }));\n  }\n\n  private handleTheme() {\n    if (this.theme) {\n      this.chart.theme(this.theme);\n    }\n    this.themeService.currentTheme$\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe(type => {\n        this.chart.theme(type);\n      });\n  }\n\n  private handleChartEvent() {\n    if (!this.legendRef && !this.legendDropdownRef) {\n      const legend = this.chart?.components.get('legend') as Legend;\n      this.chart.on(ChartEvent.LEGEND_ITEM_CLICK, () => {\n        this.changeStatus({\n          noLegend: legend.inactivatedSet.size === legend.getLegend().length,\n        });\n      });\n    }\n    this.chart.on(ChartEvent.PLOT_CLICK, (value: MarkContext) => {\n      this.markClick.next(value);\n    });\n    this.enableZoom$.pipe(takeUntil(this.onDestroy$)).subscribe(() => {\n      if (this.enableZoom) {\n        this.chart.interaction('brush-x', {\n          end: [\n            {\n              trigger: ChartEvent.PLOT_MOUSEUP,\n              action: ActionType.BRUSH_X_END,\n              callback: (e: BrushContext) => {\n                if (e.start !== e.end) {\n                  this.mouseUp.next(e);\n                }\n              },\n            },\n          ],\n        });\n      }\n    });\n  }\n\n  onRefresh() {\n    this.refresh.next(null);\n  }\n\n  getHeight(height: number, chartOption: Options) {\n    return typeof chartOption.legend === 'object' &&\n      chartOption.legend?.position?.includes('bottom-left')\n      ? `calc(100% - ${height || 0}px)`\n      : '100%';\n  }\n\n  ngOnDestroy(): void {\n    this.destroy();\n    this.onDestroy$.next();\n  }\n}\n","<div\n  class=\"a-chart\"\n  [style.background]=\"background\"\n>\n  <div\n    class=\"tw-flex\"\n    #header\n  >\n    <ng-content select=\"a-title\"></ng-content>\n    <ng-content select=\"a-legend\"></ng-content>\n    <ng-content select=\"a-legend-dropdown\"></ng-content>\n    <ng-content select=\"acl-chart-zoom-button\"></ng-content>\n    <ng-content></ng-content>\n  </div>\n  <div\n    class=\"tw-w-full\"\n    [style.height]=\"header.clientHeight | pure: getHeight:chartOption\"\n  >\n    <div #chartDom></div>\n  </div>\n\n  <acl-chart-status\n    [status]=\"chartStatus$ | async\"\n    [customNoData]=\"customNoData\"\n    [customError]=\"customError\"\n    (refresh)=\"onRefresh()\"\n  ></acl-chart-status>\n</div>\n"]}

package/esm2022/a-chart/components/base-component.mjs

@@ -0,0 +1,23 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { ObservableInput } from '../../core/public-api';
+import { ChartComponent } from '../chart.component';
+import * as i0 from "@angular/core";
+export class BaseComponent {
+    constructor() {
+        this.onDestroy$ = new Subject();
+    }
+    static { this.ɵfac = function BaseComponent_Factory(t) { return new (t || BaseComponent)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseComponent, inputs: { chartRef: "chartRef" } }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], BaseComponent.prototype, "chartRef$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseComponent, [{
+        type: Directive
+    }], null, { chartRef: [{
+            type: Input
+        }], chartRef$: [] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvYS1jaGFydC9jb21wb25lbnRzL2Jhc2UtY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNqRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUUzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDOztBQUdwRCxNQUFNLE9BQWdCLGFBQWE7SUFEbkM7UUFVVyxlQUFVLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztLQUMzQzs4RUFWcUIsYUFBYTtvRUFBYixhQUFhOztBQUdqQztJQURDLGVBQWUsRUFBRTs4QkFDTixVQUFVO2dEQUFpQjt1RkFIbkIsYUFBYTtjQURsQyxTQUFTO2dCQUVDLFFBQVE7a0JBQWhCLEtBQUs7WUFFTixTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBPYnNlcnZhYmxlSW5wdXQgfSBmcm9tICcuLi8uLi9jb3JlL3B1YmxpYy1hcGknO1xuaW1wb3J0IHsgQ2hhcnRDb21wb25lbnQgfSBmcm9tICcuLi9jaGFydC5jb21wb25lbnQnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBCYXNlQ29tcG9uZW50PEMgPSB1bmtub3duPiB7XG4gIEBJbnB1dCgpIGNoYXJ0UmVmOiBDaGFydENvbXBvbmVudDtcbiAgQE9ic2VydmFibGVJbnB1dCgpXG4gIGNoYXJ0UmVmJCE6IE9ic2VydmFibGU8Q2hhcnRDb21wb25lbnQ+O1xuXG4gIHByb3RlY3RlZCBjb25maWc6IEM7XG5cbiAgYWJzdHJhY3QgZ2V0IG5hbWUoKTogc3RyaW5nO1xuXG4gIHJlYWRvbmx5IG9uRGVzdHJveSQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xufVxuIl19

package/esm2022/a-chart/components/legend/base-legend.component.mjs

@@ -0,0 +1,110 @@
+import { ChangeDetectorRef, Directive, EventEmitter, Injector, Input, Output, } from '@angular/core';
+import { get } from 'lodash-es';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ChartEvent, } from 'zz-chart';
+import { ChartComponent } from '../../chart.component';
+import * as i0 from "@angular/core";
+export class BaseLegendComponent {
+    get noData() {
+        return !this.legendItems$$.value.length;
+    }
+    get aChartCtrl() {
+        return this.injector.get(ChartComponent, this.chartRef, {
+            optional: true,
+        });
+    }
+    get legendCtr() {
+        return this.aChartCtrl.chart?.components.get('legend');
+    }
+    constructor(cdr, injector) {
+        this.cdr = cdr;
+        this.injector = injector;
+        this.changeLegend = new EventEmitter();
+        this.legendItems$$ = new BehaviorSubject([]);
+        this.legendChange$$ = new Subject();
+    }
+    ngOnChanges({ chartRef }) {
+        if (chartRef?.currentValue) {
+            this.init();
+        }
+    }
+    ngOnInit() {
+        this.init();
+    }
+    setChartRef(chartRef) {
+        this.chartRef = chartRef;
+        this.init();
+    }
+    init() {
+        if (this.aChartCtrl) {
+            this.handleLegends(this.aChartCtrl?.chart?.getData() || []);
+            this.aChartCtrl.renderComplete$$.subscribe(chart => {
+                if (!chart) {
+                    return;
+                }
+                this.legendItems$$.next(this.legendCtr?.getLegend());
+                chart?.on(ChartEvent.DATA_CHANGE, (data) => {
+                    this.handleLegends(data);
+                });
+            });
+        }
+    }
+    handleLegends(data) {
+        this.legendItems$$.next(data.reduce((acc, d) => [
+            ...acc,
+            ...(d.name
+                ? [
+                    {
+                        name: d.name,
+                        color: d.color,
+                        activated: true,
+                        hover: false,
+                        value: d.values[d.values?.length - 1].y,
+                        source: d,
+                        unit: get(d, 'unit'),
+                        ...d,
+                    },
+                ]
+                : []),
+        ], []));
+        this.cdr.detectChanges();
+    }
+    onSelect(legend) {
+        this.legendCtr.legendItemClick({
+            name: legend.name,
+            activated: !legend.activated,
+        });
+        const legends = this.legendItems$$.value;
+        const legendItem = legends.find(item => item.name === legend.name);
+        legendItem.activated = !legend.activated;
+        this.aChartCtrl.changeStatus({
+            noLegend: legends.every(item => !item.activated),
+        });
+        this.legendItems$$.next(legends);
+    }
+    onAllSelect(select) {
+        const legends = this.legendItems$$.value;
+        legends.forEach(legend => {
+            this.legendCtr.legendItemClick({
+                name: legend.name,
+                activated: select,
+            });
+            legend.activated = select;
+        });
+        this.aChartCtrl.changeStatus({
+            noLegend: legends.every(item => !item.activated),
+        });
+        this.legendItems$$.next(legends);
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = function BaseLegendComponent_Factory(t) { return new (t || BaseLegendComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.Injector)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseLegendComponent, inputs: { chartRef: "chartRef" }, outputs: { changeLegend: "changeLegend" }, features: [i0.ɵɵNgOnChangesFeature] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseLegendComponent, [{
+        type: Directive
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Injector }]; }, { chartRef: [{
+            type: Input
+        }], changeLegend: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-legend.component.js","sourceRoot":"","sources":["../../../../../../../libs/common/src/a-chart/components/legend/base-legend.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  EventEmitter,\n  Injector,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport { get } from 'lodash-es';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport {\n  ChartEvent,\n  Data,\n  Legend,\n  LegendItem as ALegendItem,\n  DataItem,\n} from 'zz-chart';\n\nimport { ChartComponent } from '../../chart.component';\n\nexport interface LegendItem extends ALegendItem {\n  name: string;\n  value?: number;\n  source?: DataItem;\n  unit?: string;\n}\n\n@Directive()\nexport class BaseLegendComponent implements OnInit, OnChanges {\n  @Input()\n  chartRef: ChartComponent;\n\n  @Output() changeLegend = new EventEmitter<LegendItem[]>();\n\n  get noData() {\n    return !this.legendItems$$.value.length;\n  }\n\n  get aChartCtrl() {\n    return this.injector.get(ChartComponent, this.chartRef, {\n      optional: true,\n    });\n  }\n\n  get legendCtr(): Legend {\n    return this.aChartCtrl.chart?.components.get('legend') as Legend;\n  }\n\n  legendItems$$ = new BehaviorSubject<LegendItem[]>([]);\n\n  legendChange$$ = new Subject<LegendItem[]>();\n\n  constructor(\n    public readonly cdr: ChangeDetectorRef,\n    private readonly injector: Injector,\n  ) {}\n\n  ngOnChanges({ chartRef }: SimpleChanges): void {\n    if (chartRef?.currentValue) {\n      this.init();\n    }\n  }\n\n  ngOnInit(): void {\n    this.init();\n  }\n\n  setChartRef(chartRef: ChartComponent) {\n    this.chartRef = chartRef;\n    this.init();\n  }\n\n  init() {\n    if (this.aChartCtrl) {\n      this.handleLegends(this.aChartCtrl?.chart?.getData() || []);\n      this.aChartCtrl.renderComplete$$.subscribe(chart => {\n        if (!chart) {\n          return;\n        }\n        this.legendItems$$.next(this.legendCtr?.getLegend());\n        chart?.on(ChartEvent.DATA_CHANGE, (data: Data) => {\n          this.handleLegends(data);\n        });\n      });\n    }\n  }\n\n  private handleLegends(data: Data) {\n    this.legendItems$$.next(\n      data.reduce(\n        (acc, d) => [\n          ...acc,\n          ...(d.name\n            ? [\n                {\n                  name: d.name,\n                  color: d.color,\n                  activated: true,\n                  hover: false,\n                  value: d.values[d.values?.length - 1].y,\n                  source: d,\n                  unit: get(d, 'unit'),\n                  ...d,\n                },\n              ]\n            : []),\n        ],\n        [],\n      ),\n    );\n    this.cdr.detectChanges();\n  }\n\n  onSelect(legend: LegendItem) {\n    this.legendCtr.legendItemClick({\n      name: legend.name,\n      activated: !legend.activated,\n    });\n    const legends = this.legendItems$$.value;\n    const legendItem = legends.find(item => item.name === legend.name);\n    legendItem.activated = !legend.activated;\n    this.aChartCtrl.changeStatus({\n      noLegend: legends.every(item => !item.activated),\n    });\n    this.legendItems$$.next(legends);\n  }\n\n  onAllSelect(select: boolean) {\n    const legends = this.legendItems$$.value;\n    legends.forEach(legend => {\n      this.legendCtr.legendItemClick({\n        name: legend.name,\n        activated: select,\n      });\n      legend.activated = select;\n    });\n    this.aChartCtrl.changeStatus({\n      noLegend: legends.every(item => !item.activated),\n    });\n    this.legendItems$$.next(legends);\n    this.cdr.markForCheck();\n  }\n}\n"]}