@bizdoc/core 1.14.9 → 1.14.12

package/esm2020/lib/dashboard/cube/compare.widget.mjs

@@ -0,0 +1,215 @@
+var CubeCompareWidget_1;
+import { __decorate } from "tslib";
+import { Component, ViewChild } from "@angular/core";
+import { Chart, LineSeriesService, CrosshairService, ColumnSeriesService, ChartComponent } from "@syncfusion/ej2-angular-charts";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs/operators";
+import dayjs from 'dayjs';
+import { BizDoc } from "../../core/decorators";
+import { FONT_FAMILY } from "../../core/colors";
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/translate.service";
+import * as i2 from "../widget-ref";
+import * as i3 from "../../core/datasource.service";
+import * as i4 from "../../core/session.service";
+/** */
+let CubeCompareWidget = CubeCompareWidget_1 = class CubeCompareWidget {
+    constructor(_translate, _widgetRef, _elementRef, _type, _session) {
+        this._translate = _translate;
+        this._widgetRef = _widgetRef;
+        this._elementRef = _elementRef;
+        this._type = _type;
+        this._session = _session;
+        this.id = `cube-compare-${CubeCompareWidget_1.nextId++}`;
+        this.palettes = this._session.accentPalette;
+        this.theme = this._session.theme.dark ? 'MaterialDark' : 'Material';
+        this.enableRtl = this._session.inverse;
+        this.rows = [
+            {
+                height: '15%'
+            }, {
+                height: '85%'
+            }
+        ];
+        this.axes = [{
+                name: 'primary',
+                labelStyle: { size: '0px' },
+                rowIndex: 1
+            }, {
+                name: 'volume',
+                rowIndex: 0,
+                majorGridLines: { width: 0 }, lineStyle: { width: 0 },
+                labelStyle: { size: '0px' },
+                majorTickLines: { width: 0 }
+            }];
+        this.chartArea = {
+            border: {
+                width: 0
+            }
+        };
+        this.zoomSettings = {
+            mode: 'X',
+            enableMouseWheelZooming: true,
+            enablePinchZooming: true,
+            toolbarItems: [],
+            enableSelectionZooming: false,
+            enableScrollbar: true
+        };
+        this.primaryXAxis = {
+            valueType: 'DateTime',
+            labelFormat: 'MMM dd',
+            labelStyle: {
+                fontFamily: FONT_FAMILY
+            },
+            labelIntersectAction: 'Hide',
+            majorGridLines: { width: 0 }
+        };
+        this.crosshair = {
+            enable: true,
+            lineType: 'Vertical'
+        };
+        this.tooltip = {
+            enable: true, shared: true, textStyle: {
+                fontFamily: FONT_FAMILY
+            },
+        };
+        this.legend = {
+            visible: true,
+            isInversed: this._session.inverse,
+            textStyle: {
+                fontFamily: FONT_FAMILY
+            },
+        };
+        this.primaryYAxis = {
+            skeleton: 'duration',
+            labelStyle: {
+            //size: '0px'
+            },
+            labelFormat: '',
+            titleStyle: {
+                fontFamily: FONT_FAMILY
+            },
+            title: this._translate.get('Duration'),
+            //lineStyle: { width: 0 },
+            //minorTickLines: { width: 0 }
+        };
+        this.margin = {
+            bottom: 0
+        };
+        this._destroy = new Subject();
+        _session.themeChange.pipe(takeUntil(this._destroy)).subscribe(t => {
+            this.theme = t.dark ? 'MaterialDark' : 'Material';
+            this.palettes = _session.accentPalette;
+            this._draw();
+        });
+        _widgetRef.resize.subscribe(d => {
+            this.height = `${d.height}px`;
+            if (this.chart)
+                this.chart.height = this.height;
+        });
+    }
+    async onBind(data) {
+        await this._prepare(data);
+        this._draw();
+    }
+    _draw() {
+        this.chart && this.chart.destroy();
+        this.chart = new Chart({
+            axes: this.axes,
+            series: this.series,
+            height: this.height,
+            rows: this.rows,
+            legendSettings: this.legend,
+            crosshair: this.crosshair,
+            tooltip: this.tooltip,
+            background: 'transparent',
+            chartArea: this.chartArea,
+            primaryXAxis: this.primaryXAxis,
+            primaryYAxis: this.primaryYAxis,
+            theme: this.theme,
+            margin: this.margin,
+            useGroupingSeparator: true,
+            palettes: this.palettes,
+            zoomSettings: this.zoomSettings,
+            sharedTooltipRender: this.sharedTooltipRender.bind(this),
+        }, this._elementRef.nativeElement);
+    }
+    sharedTooltipRender(evt) {
+        evt.data.forEach((d, i) => {
+            if (evt.series[d.seriesIndex].yName !== 'count')
+                evt.text[i] = `${d.seriesName} : <b>${dayjs.duration(d.pointY, 's').humanize()}</b>`;
+        });
+    }
+    async _prepare(data) {
+        const indicatorData = [], series = [];
+        for (var item of data) {
+            item.points.forEach(p => {
+                const date = p.date = new Date(p.date), indicator = indicatorData.find(i => i.date.valueOf() === date.valueOf());
+                if (indicator)
+                    indicator.count += p.count;
+                else
+                    indicatorData.push({ count: p.count, date });
+            });
+            const cube = this._session.profile.cubes.find(c => c.name === this._widgetRef.options.cube || this._widgetRef.options.cube == null);
+            const axis = cube.axes.find(a => a.name === this._widgetRef.options.series);
+            const title = await this._type.get(axis.dataType, item.series).toPromise();
+            series.push({
+                type: 'Line',
+                xName: 'date',
+                yName: 'duration',
+                yAxisName: 'primary',
+                name: title,
+                dataSource: item.points,
+                marker: {
+                    width: 6,
+                    height: 6,
+                    visible: false
+                }
+            });
+        }
+        series.push({
+            type: 'Column',
+            xName: 'date',
+            yName: 'count',
+            name: this._translate.get('Volume'),
+            dataSource: indicatorData,
+            yAxisName: 'volume',
+            marker: {
+                width: 0,
+                height: 0,
+                visible: false
+            }
+        });
+        this.series = series;
+    }
+    ngOnDestroy() {
+        this.chart && this.chart.destroy();
+        this._destroy.next();
+        this._destroy.complete();
+    }
+};
+CubeCompareWidget.nextId = 0;
+CubeCompareWidget.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeCompareWidget, deps: [{ token: i1.TranslateService }, { token: i2.WidgetRef }, { token: i0.ElementRef }, { token: i3.DatasourceService }, { token: i4.SessionService }], target: i0.ɵɵFactoryTarget.Component });
+CubeCompareWidget.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: CubeCompareWidget, selector: "ng-component", host: { attributes: { "dir": "ltr" }, properties: { "id": "id" } }, providers: [LineSeriesService, CrosshairService, ColumnSeriesService], viewQueries: [{ propertyName: "chart", first: true, predicate: ChartComponent, descendants: true }], ngImport: i0, template: '', isInline: true });
+CubeCompareWidget = CubeCompareWidget_1 = __decorate([
+    BizDoc({
+        selector: 'bizdoc-cube-compare'
+    })
+], CubeCompareWidget);
+export { CubeCompareWidget };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeCompareWidget, decorators: [{
+            type: Component,
+            args: [{
+                    //templateUrl: './compare.widget.html',
+                    template: '',
+                    providers: [LineSeriesService, CrosshairService, ColumnSeriesService],
+                    host: {
+                        '[id]': 'id',
+                        dir: 'ltr'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.WidgetRef }, { type: i0.ElementRef }, { type: i3.DatasourceService }, { type: i4.SessionService }]; }, propDecorators: { chart: [{
+                type: ViewChild,
+                args: [ChartComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compare.widget.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/dashboard/cube/compare.widget.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnDestroy, ViewChild, ElementRef } from \"@angular/core\";\r\nimport { Chart, AxisModel, CrosshairSettingsModel, TooltipSettingsModel, SeriesModel, LegendSeriesModel, RowModel, LineSeriesService, CrosshairService, ColumnSeriesService, MarginModel, ZoomSettingsModel, ITooltipRenderEventArgs, ChartAreaModel, ChartComponent, ISharedTooltipRenderEventArgs } from \"@syncfusion/ej2-angular-charts\";\r\nimport { Subject } from \"rxjs\";\r\nimport { takeUntil } from \"rxjs/operators\";\r\nimport dayjs from 'dayjs';\r\nimport { WidgetComponent } from \"../../core/base\";\r\nimport { BizDoc } from \"../../core/decorators\";\r\nimport { TranslateService } from \"../../core/translate.service\";\r\nimport { SessionService } from \"../../core/session.service\";\r\nimport { DatasourceService } from \"../../core/datasource.service\";\r\nimport { WidgetRef } from \"../widget-ref\";\r\nimport { FONT_FAMILY } from \"../../core/colors\";\r\n/** */\r\n@Component({\r\n  //templateUrl: './compare.widget.html',\r\n  template: '',\r\n  providers: [LineSeriesService, CrosshairService, ColumnSeriesService],\r\n  host: {\r\n    '[id]': 'id',\r\n    dir: 'ltr'\r\n  }\r\n})\r\n@BizDoc({\r\n  selector: 'bizdoc-cube-compare'\r\n})\r\nexport class CubeCompareWidget implements WidgetComponent<Model[]>, OnDestroy {\r\n  static nextId = 0;\r\n  readonly id = `cube-compare-${CubeCompareWidget.nextId++}`;\r\n  palettes = this._session.accentPalette;\r\n  @ViewChild(ChartComponent) chart: Chart;\r\n  theme: 'Material' | 'MaterialDark' = this._session.theme.dark ? 'MaterialDark' : 'Material'\r\n  readonly enableRtl = this._session.inverse;\r\n  readonly rows: RowModel[] = [\r\n    {\r\n      height: '15%'\r\n    }, {\r\n      height: '85%'\r\n    }\r\n  ];\r\n  readonly axes: AxisModel[] = [{\r\n    name: 'primary',\r\n    labelStyle: { size: '0px' },\r\n    rowIndex: 1\r\n  }, {\r\n    name: 'volume',\r\n    rowIndex: 0,\r\n    majorGridLines: { width: 0 }, lineStyle: { width: 0 },\r\n    labelStyle: { size: '0px' },\r\n    majorTickLines: { width: 0 }\r\n  }];\r\n  readonly chartArea: ChartAreaModel = {\r\n    border: {\r\n      width: 0\r\n    }\r\n  };\r\n  readonly zoomSettings: ZoomSettingsModel = {\r\n    mode: 'X',\r\n    enableMouseWheelZooming: true,\r\n    enablePinchZooming: true,\r\n    toolbarItems: [],\r\n    enableSelectionZooming: false,\r\n    enableScrollbar: true\r\n  };\r\n  readonly primaryXAxis: AxisModel = {\r\n    valueType: 'DateTime',\r\n    labelFormat: 'MMM dd',\r\n    labelStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    },\r\n    labelIntersectAction: 'Hide',\r\n    majorGridLines: { width: 0 }\r\n  };\r\n  readonly crosshair: CrosshairSettingsModel = {\r\n    enable: true,\r\n    lineType: 'Vertical'\r\n  };\r\n  readonly tooltip: TooltipSettingsModel = {\r\n    enable: true, shared: true, textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    },\r\n  };\r\n  readonly legend: LegendSeriesModel = {\r\n    visible: true,\r\n    isInversed: this._session.inverse,\r\n    textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    },\r\n  };\r\n  readonly primaryYAxis: AxisModel = {\r\n    skeleton: 'duration',\r\n    labelStyle: {\r\n      //size: '0px'\r\n    },\r\n    labelFormat: '',\r\n    titleStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    },\r\n    title: this._translate.get('Duration'),\r\n    //lineStyle: { width: 0 },\r\n    //minorTickLines: { width: 0 }\r\n  };\r\n  readonly margin: MarginModel = {\r\n    bottom: 0\r\n  };\r\n  series: SeriesModel[];\r\n  height: string;\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(private _translate: TranslateService,\r\n    private _widgetRef: WidgetRef,\r\n    private _elementRef: ElementRef,\r\n    private _type: DatasourceService,\r\n    private _session: SessionService) {\r\n    _session.themeChange.pipe(takeUntil(this._destroy)).subscribe(t => {\r\n      this.theme = t.dark ? 'MaterialDark' : 'Material';\r\n      this.palettes = _session.accentPalette;\r\n      this._draw();\r\n    });\r\n    _widgetRef.resize.subscribe(d => {\r\n      this.height = `${d.height}px`;\r\n      if (this.chart) this.chart.height = this.height;\r\n    });\r\n  }\r\n  async onBind(data: Model[]) {\r\n    await this._prepare(data);\r\n    this._draw();\r\n  }\r\n  private _draw() {\r\n    this.chart && this.chart.destroy();\r\n    this.chart = new Chart({\r\n      axes: this.axes,\r\n      series: this.series,\r\n      height: this.height,\r\n      rows: this.rows,\r\n      legendSettings: this.legend,\r\n      crosshair: this.crosshair,\r\n      tooltip: this.tooltip,\r\n      background: 'transparent',\r\n      chartArea: this.chartArea,\r\n      primaryXAxis: this.primaryXAxis,\r\n      primaryYAxis: this.primaryYAxis,\r\n      theme: this.theme,\r\n      margin: this.margin,\r\n      useGroupingSeparator: true,\r\n      palettes: this.palettes,\r\n      zoomSettings: this.zoomSettings,\r\n      sharedTooltipRender: this.sharedTooltipRender.bind(this),\r\n    }, this._elementRef.nativeElement);\r\n\r\n  }\r\n  sharedTooltipRender(evt: ISharedTooltipRenderEventArgs) {\r\n    evt.data.forEach((d, i) => {\r\n      if (evt.series[d.seriesIndex].yName !== 'count')\r\n        evt.text[i] = `${d.seriesName} : <b>${dayjs.duration(d.pointY as any, 's').humanize()}</b>`;\r\n    });\r\n  }\r\n  private async _prepare(data: Model[]) {\r\n    const indicatorData: Volume[] = [], series: SeriesModel[] = [];\r\n    for (var item of data) {\r\n      item.points.forEach(p => {\r\n        const date = p.date = new Date(p.date),\r\n          indicator = indicatorData.find(i => i.date.valueOf() === date.valueOf());\r\n        if (indicator)\r\n          indicator.count += p.count;\r\n        else\r\n          indicatorData.push({ count: p.count, date });\r\n      });\r\n      const cube = this._session.profile.cubes.find(c => c.name === this._widgetRef.options.cube || this._widgetRef.options.cube == null);\r\n      const axis = cube.axes.find(a => a.name === this._widgetRef.options.series);\r\n      const title = await this._type.get(axis.dataType, item.series).toPromise();\r\n      series.push({\r\n        type: 'Line',\r\n        xName: 'date',\r\n        yName: 'duration',\r\n        yAxisName: 'primary',\r\n        name: title,\r\n        dataSource: item.points,\r\n        marker: {\r\n          width: 6,\r\n          height: 6,\r\n          visible: false\r\n        }\r\n      } as SeriesModel);\r\n    }\r\n    series.push({\r\n      type: 'Column',\r\n      xName: 'date',\r\n      yName: 'count',\r\n      name: this._translate.get('Volume'),\r\n      dataSource: indicatorData,\r\n      yAxisName: 'volume',\r\n      marker: {\r\n        width: 0,\r\n        height: 0,\r\n        visible: false\r\n      }\r\n    });\r\n    this.series = series;\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.chart && this.chart.destroy();\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\n\r\ninterface Model {\r\n  points: Point[];\r\n  series: string;\r\n}\r\ninterface Point {\r\n  date: Date;\r\n  duration: number;\r\n  count: number;\r\n}\r\ninterface Volume {\r\n  date: Date;\r\n  count: number;\r\n}\r\n"]}

package/esm2020/lib/dashboard/cube/cube-analysis.base.mjs

@@ -0,0 +1,90 @@
+import { Directive } from '@angular/core';
+import { forkJoin, Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { Internationalization } from '@syncfusion/ej2-base';
+import { AXES_LABEL_DIVIDER, AXES_CODE_DIVIDER } from '../../cube/cube.service';
+import { isArray } from '../../core/functions';
+import * as i0 from "@angular/core";
+import * as i1 from "../widget-ref";
+import * as i2 from "../../cube/cube-info.service";
+import * as i3 from "../../core/session.service";
+import * as i4 from "../../core/datasource.service";
+import * as i5 from "../../cube/cube.service";
+export class CubeAnalysisBase {
+    constructor(ref, _info, _session, _ds, _service) {
+        this._info = _info;
+        this._session = _session;
+        this._ds = _ds;
+        this._service = _service;
+        this.id = `cube-analysis-${CubeAnalysisBase.nextId++}`;
+        this.palettes = this._session.accentPalette;
+        this.theme = this._session.theme.dark ? 'MaterialDark' : 'Material';
+        this._axisTypeMap = {};
+        this._intl = new Internationalization();
+        this._destroy = new Subject();
+        this._options = ref.options;
+        const { xAxis, series, cube } = this._options;
+        this._cube = cube ? this._session.profile.cubes.find(c => c.name === cube) : this._session.profile.cubes[0];
+        if (!this._cube)
+            throw `cube not found ${cube}`;
+        this._xAxis = !xAxis ? [this._cube.axes[0].name] : isArray(xAxis) ? xAxis : [xAxis];
+        this._series = !series ? [] : isArray(series) ? series : [series];
+        this.currencyCode = this._cube.currencyCode;
+        this._cube.axes.forEach((a) => this._axisTypeMap[a.name] = a.dataType);
+        _session.themeChange.pipe(takeUntil(this._destroy)).subscribe(t => {
+            this.theme = t.dark ? 'MaterialDark' : 'Material';
+            this.palettes = _session.accentPalette;
+            this.onThemeChange();
+        });
+        ref.resize.subscribe(d => {
+            this.height = `${d.height}px`;
+            this.width = `${d.width}px`;
+            this._data && this.onResize(d);
+        });
+    }
+    get series() { return this._series; }
+    get xAxis() { return this._xAxis; }
+    explore(axes, options) {
+        this._info.explore(axes, {
+            cube: this._cube.name,
+            index: options && options.index ? options.index : null,
+            scope: this._options.scope
+        });
+    }
+    onBind(data) {
+        const observables = [];
+        data.forEach(s => {
+            s.points.forEach(p => {
+                if (p.x) {
+                    const pobservable = forkJoin(p.x.split(AXES_CODE_DIVIDER).map((k, j) => this._ds.get(this._axisTypeMap[this._xAxis[j]], k))).
+                        pipe(tap(o => p.name = o.join(AXES_LABEL_DIVIDER)));
+                    observables.push(pobservable);
+                }
+            });
+            if (s.index) {
+                const index = this._cube.indices.find(i => i.name === s.index);
+                s.title = index.title;
+            }
+            else if (s.name) {
+                const sobservable = forkJoin(s.name.split(AXES_CODE_DIVIDER).map((k, i) => this._ds.get(this._axisTypeMap[this._series[i]], k))).pipe(tap(v => s.title = v.join(AXES_LABEL_DIVIDER)));
+                observables.push(sobservable);
+            }
+        });
+        this._data = data;
+        if (observables.length)
+            forkJoin(observables).subscribe(() => this.onLoad(data));
+        else
+            this.onLoad(data);
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+    }
+}
+CubeAnalysisBase.nextId = 0;
+CubeAnalysisBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeAnalysisBase, deps: [{ token: i1.WidgetRef }, { token: i2.CubeInfo }, { token: i3.SessionService }, { token: i4.DatasourceService }, { token: i5.CubeService }], target: i0.ɵɵFactoryTarget.Directive });
+CubeAnalysisBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.1", type: CubeAnalysisBase, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeAnalysisBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.WidgetRef }, { type: i2.CubeInfo }, { type: i3.SessionService }, { type: i4.DatasourceService }, { type: i5.CubeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cube-analysis.base.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/dashboard/cube/cube-analysis.base.ts"],"names":[],"mappings":"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","sourcesContent":["import { OnDestroy, Directive } from '@angular/core';\r\nimport { Observable, forkJoin, Subject } from 'rxjs';\r\nimport { takeUntil, tap } from 'rxjs/operators';\r\nimport { Internationalization } from '@syncfusion/ej2-base';\r\nimport { WidgetComponent } from '../../core/base';\r\nimport { AxesMap, ChartType, Cube } from '../../core/models';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { DatasourceService } from '../../core/datasource.service';\r\nimport { AXES_LABEL_DIVIDER, AXES_CODE_DIVIDER, CubeService, Series } from '../../cube/cube.service';\r\nimport { WidgetRef } from \"../widget-ref\";\r\nimport { isArray } from '../../core/functions';\r\nimport { CubeInfo } from '../../cube/cube-info.service';\r\nimport { ScopeType } from '../../core/configuration';\r\n\r\n@Directive()\r\nexport abstract class CubeAnalysisBase implements WidgetComponent<Series[]>, OnDestroy {\r\n  static nextId = 0;\r\n  readonly id = `cube-analysis-${CubeAnalysisBase.nextId++}`;\r\n  palettes = this._session.accentPalette;\r\n  theme: 'Material' | 'MaterialDark' = this._session.theme.dark ? 'MaterialDark' : 'Material';\r\n  height: string;\r\n  width: string;\r\n  readonly currencyCode: string;\r\n  protected _cube: Cube;\r\n  protected _options: Options;\r\n  protected _data: Series[];\r\n  private _series: string[];\r\n  private _xAxis: string[];\r\n  protected get series() { return this._series}\r\n  protected get xAxis() { return this._xAxis}\r\n  private readonly _axisTypeMap: { [name: string]: string } = {};\r\n  protected readonly _intl: Internationalization = new Internationalization();\r\n  protected readonly _destroy = new Subject<void>();\r\n  constructor(ref: WidgetRef<Options>,\r\n    private _info: CubeInfo,\r\n    protected _session: SessionService,\r\n    private _ds: DatasourceService,\r\n    protected _service: CubeService) {\r\n    this._options = ref.options;\r\n    const { xAxis, series, cube } = this._options;\r\n    this._cube = cube ? this._session.profile.cubes.find(c => c.name === cube) : this._session.profile.cubes[0];\r\n    if (!this._cube)\r\n      throw `cube not found ${cube}`;\r\n    this._xAxis = !xAxis ? [this._cube.axes[0].name] : isArray(xAxis) ? xAxis : [xAxis];\r\n    this._series = !series ? [] : isArray(series) ? series : [series];\r\n    this.currencyCode = this._cube.currencyCode;\r\n    this._cube.axes.forEach((a) =>\r\n      this._axisTypeMap[a.name] = a.dataType);\r\n    _session.themeChange.pipe(takeUntil(this._destroy)).subscribe(t => {\r\n      this.theme = t.dark ? 'MaterialDark' : 'Material';\r\n      this.palettes = _session.accentPalette;\r\n      this.onThemeChange();\r\n    });\r\n    ref.resize.subscribe(d => {\r\n      this.height = `${d.height}px`;\r\n      this.width = `${d.width}px`;\r\n      this._data && this.onResize(d);\r\n    });\r\n  }\r\n  protected explore(axes: AxesMap, options?: { index?: string }) {\r\n    this._info.explore(axes, {\r\n      cube: this._cube.name,\r\n      index: options && options.index ? options.index : null,\r\n      scope: this._options.scope\r\n });\r\n  }\r\n  abstract onResize(dim: { height: number; width: number });\r\n  onBind(data: Series[]) {\r\n    const observables: Observable<any>[] = [];\r\n    data.forEach(s => {\r\n      s.points.forEach(p => {\r\n        if (p.x) {\r\n          const pobservable = forkJoin(p.x.split(AXES_CODE_DIVIDER).map((k, j) =>\r\n            this._ds.get(this._axisTypeMap[this._xAxis[j]], k))).\r\n            pipe(tap(o => p.name = o.join(AXES_LABEL_DIVIDER)));\r\n          observables.push(pobservable);\r\n        }\r\n      });\r\n      if (s.index) {\r\n        const index = this._cube.indices.find(i => i.name === s.index);\r\n        s.title = index.title;\r\n      }\r\n      else if (s.name) {\r\n        const sobservable = forkJoin(s.name.split(AXES_CODE_DIVIDER).map((k, i) =>\r\n          this._ds.get(this._axisTypeMap[this._series[i]], k)\r\n        )).pipe(tap(v => s.title = v.join(AXES_LABEL_DIVIDER)));\r\n        observables.push(sobservable);\r\n      }\r\n    });\r\n    this._data = data;\r\n    if (observables.length) forkJoin(observables).subscribe(() =>\r\n      this.onLoad(data)\r\n    );\r\n    else\r\n      this.onLoad(data);\r\n  }\r\n  abstract onLoad(data: Series[]);\r\n  abstract onThemeChange();\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\nexport interface Options {\r\n  scope?: ScopeType;\r\n  chartType?: ChartType;\r\n  indicesChartType?: ChartType;\r\n  cube?: string;\r\n  xAxis?: string[] | string;\r\n  exclude?: string[] | string;\r\n  series?: string[] | string;\r\n  indices?: string[] | string;\r\n}\r\n"]}

package/esm2020/lib/dashboard/cube/cube-analysis.widget.mjs

@@ -0,0 +1,53 @@
+import { __decorate } from "tslib";
+import { Component } from '@angular/core';
+import { BizDoc } from '../../core/decorators';
+import { CubeAccumAnalysisWidget } from './accum-cube.widget';
+import { CubeChartAnalysisWidget } from './cube-chart.widget';
+import * as i0 from "@angular/core";
+import * as i1 from "../widget-ref";
+let CubeAnalysisWidget = class CubeAnalysisWidget {
+    constructor(_ref, _resolver, _injector, _vc) {
+        this._ref = _ref;
+        this._resolver = _resolver;
+        this._injector = _injector;
+        this._vc = _vc;
+    }
+    ngOnInit() {
+        const { chartType } = this._ref.options;
+        let comp;
+        switch (chartType) {
+            case 'Doughnut':
+            case 'HalfDoughnut':
+            case 'Pie':
+            case 'Funnel':
+            case 'Pyramid':
+                comp = CubeAccumAnalysisWidget;
+                break;
+            default:
+                comp = CubeChartAnalysisWidget;
+        }
+        const factory = this._resolver.resolveComponentFactory(comp);
+        const cRef = this._vc.createComponent(factory, 0, this._injector);
+        this._instance = cRef.instance;
+    }
+    onBind(data, args) {
+        this._instance.onBind(data, args);
+    }
+};
+CubeAnalysisWidget.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeAnalysisWidget, deps: [{ token: i1.WidgetRef }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });
+CubeAnalysisWidget.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: CubeAnalysisWidget, selector: "ng-component", ngImport: i0, template: '', isInline: true });
+CubeAnalysisWidget = __decorate([
+    BizDoc({
+        selector: 'bizdoc-cube-analysis'
+    })
+    /** statistics component*/
+], CubeAnalysisWidget);
+export { CubeAnalysisWidget };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeAnalysisWidget, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                    entryComponents: [CubeAccumAnalysisWidget, CubeChartAnalysisWidget]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.WidgetRef }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ViewContainerRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3ViZS1hbmFseXNpcy53aWRnZXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJyYXJpZXMvY29yZS9zcmMvbGliL2Rhc2hib2FyZC9jdWJlL2N1YmUtYW5hbHlzaXMud2lkZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFnRSxNQUFNLGVBQWUsQ0FBQztBQUN4RyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFJL0MsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDOUQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0scUJBQXFCLENBQUM7OztJQVNqRCxrQkFBa0IsU0FBbEIsa0JBQWtCO0lBRTdCLFlBQW9CLElBQXdCLEVBQ2xDLFNBQW1DLEVBQ25DLFNBQW1CLEVBQ25CLEdBQXFCO1FBSFgsU0FBSSxHQUFKLElBQUksQ0FBb0I7UUFDbEMsY0FBUyxHQUFULFNBQVMsQ0FBMEI7UUFDbkMsY0FBUyxHQUFULFNBQVMsQ0FBVTtRQUNuQixRQUFHLEdBQUgsR0FBRyxDQUFrQjtJQUMvQixDQUFDO0lBQ0QsUUFBUTtRQUNOLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUN4QyxJQUFJLElBQUksQ0FBQztRQUNULFFBQVEsU0FBUyxFQUFFO1lBQ2pCLEtBQUssVUFBVSxDQUFDO1lBQ2hCLEtBQUssY0FBYyxDQUFDO1lBQ3BCLEtBQUssS0FBSyxDQUFDO1lBQ1gsS0FBSyxRQUFRLENBQUM7WUFDZCxLQUFLLFNBQVM7Z0JBQ1osSUFBSSxHQUFHLHVCQUF1QixDQUFDO2dCQUMvQixNQUFNO1lBQ1I7Z0JBQ0UsSUFBSSxHQUFHLHVCQUF1QixDQUFDO1NBQ2xDO1FBQ0QsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUM3RCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNsRSxJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxRQUFvQyxDQUFDO0lBQzdELENBQUM7SUFDRCxNQUFNLENBQUMsSUFBUyxFQUFFLElBQVU7UUFDMUIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ3BDLENBQUM7Q0FDRixDQUFBOytHQTVCWSxrQkFBa0I7bUdBQWxCLGtCQUFrQixvREFQbkIsRUFBRTtBQU9ELGtCQUFrQjtJQUo5QixNQUFNLENBQUM7UUFDTixRQUFRLEVBQUUsc0JBQXNCO0tBQ2pDLENBQUM7SUFDRiwwQkFBMEI7R0FDYixrQkFBa0IsQ0E0QjlCO1NBNUJZLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQVI5QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxFQUFFO29CQUNaLGVBQWUsRUFBRSxDQUFDLHVCQUF1QixFQUFFLHVCQUF1QixDQUFDO2lCQUNwRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgVmlld0NvbnRhaW5lclJlZiwgT25Jbml0LCBDb21wb25lbnRGYWN0b3J5UmVzb2x2ZXIsIEluamVjdG9yIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEJpekRvYyB9IGZyb20gJy4uLy4uL2NvcmUvZGVjb3JhdG9ycyc7XHJcbmltcG9ydCB7IFdpZGdldFJlZiB9IGZyb20gXCIuLi93aWRnZXQtcmVmXCI7XHJcbmltcG9ydCB7IFdpZGdldENvbXBvbmVudCB9IGZyb20gJy4uLy4uL2NvcmUvYmFzZSc7XHJcbmltcG9ydCB7IE9wdGlvbnMgfSBmcm9tICcuL2N1YmUtYW5hbHlzaXMuYmFzZSc7XHJcbmltcG9ydCB7IEN1YmVBY2N1bUFuYWx5c2lzV2lkZ2V0IH0gZnJvbSAnLi9hY2N1bS1jdWJlLndpZGdldCc7XHJcbmltcG9ydCB7IEN1YmVDaGFydEFuYWx5c2lzV2lkZ2V0IH0gZnJvbSAnLi9jdWJlLWNoYXJ0LndpZGdldCc7XHJcbkBDb21wb25lbnQoe1xyXG4gIHRlbXBsYXRlOiAnJyxcclxuICBlbnRyeUNvbXBvbmVudHM6IFtDdWJlQWNjdW1BbmFseXNpc1dpZGdldCwgQ3ViZUNoYXJ0QW5hbHlzaXNXaWRnZXRdXHJcbn0pXHJcbkBCaXpEb2Moe1xyXG4gIHNlbGVjdG9yOiAnYml6ZG9jLWN1YmUtYW5hbHlzaXMnXHJcbn0pXHJcbi8qKiBzdGF0aXN0aWNzIGNvbXBvbmVudCovXHJcbmV4cG9ydCBjbGFzcyBDdWJlQW5hbHlzaXNXaWRnZXQgaW1wbGVtZW50cyBXaWRnZXRDb21wb25lbnQ8YW55PiwgT25Jbml0IHtcclxuICBwcml2YXRlIF9pbnN0YW5jZTogV2lkZ2V0Q29tcG9uZW50PE9wdGlvbnMsIGFueT47XHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBfcmVmOiBXaWRnZXRSZWY8T3B0aW9ucz4sXHJcbiAgICBwcml2YXRlIF9yZXNvbHZlcjogQ29tcG9uZW50RmFjdG9yeVJlc29sdmVyLFxyXG4gICAgcHJpdmF0ZSBfaW5qZWN0b3I6IEluamVjdG9yLFxyXG4gICAgcHJpdmF0ZSBfdmM6IFZpZXdDb250YWluZXJSZWYpIHtcclxuICB9XHJcbiAgbmdPbkluaXQoKTogdm9pZCB7XHJcbiAgICBjb25zdCB7IGNoYXJ0VHlwZSB9ID0gdGhpcy5fcmVmLm9wdGlvbnM7XHJcbiAgICBsZXQgY29tcDtcclxuICAgIHN3aXRjaCAoY2hhcnRUeXBlKSB7XHJcbiAgICAgIGNhc2UgJ0RvdWdobnV0JzpcclxuICAgICAgY2FzZSAnSGFsZkRvdWdobnV0JzpcclxuICAgICAgY2FzZSAnUGllJzpcclxuICAgICAgY2FzZSAnRnVubmVsJzpcclxuICAgICAgY2FzZSAnUHlyYW1pZCc6XHJcbiAgICAgICAgY29tcCA9IEN1YmVBY2N1bUFuYWx5c2lzV2lkZ2V0O1xyXG4gICAgICAgIGJyZWFrO1xyXG4gICAgICBkZWZhdWx0OlxyXG4gICAgICAgIGNvbXAgPSBDdWJlQ2hhcnRBbmFseXNpc1dpZGdldDtcclxuICAgIH1cclxuICAgIGNvbnN0IGZhY3RvcnkgPSB0aGlzLl9yZXNvbHZlci5yZXNvbHZlQ29tcG9uZW50RmFjdG9yeShjb21wKTtcclxuICAgIGNvbnN0IGNSZWYgPSB0aGlzLl92Yy5jcmVhdGVDb21wb25lbnQoZmFjdG9yeSwgMCwgdGhpcy5faW5qZWN0b3IpO1xyXG4gICAgdGhpcy5faW5zdGFuY2UgPSBjUmVmLmluc3RhbmNlIGFzIFdpZGdldENvbXBvbmVudDxPcHRpb25zPjtcclxuICB9XHJcbiAgb25CaW5kKGRhdGE6IGFueSwgYXJncz86IGFueSkge1xyXG4gICAgdGhpcy5faW5zdGFuY2Uub25CaW5kKGRhdGEsIGFyZ3MpO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/dashboard/cube/cube-chart.widget.mjs

@@ -0,0 +1,144 @@
+import { Component } from '@angular/core';
+import { Chart } from '@syncfusion/ej2-angular-charts';
+import { CubeAnalysisBase } from './cube-analysis.base';
+import { AXES_CODE_DIVIDER } from '../../cube/cube.service';
+import { FONT_FAMILY } from '../../core/colors';
+import * as i0 from "@angular/core";
+import * as i1 from "../widget-ref";
+import * as i2 from "../../core/session.service";
+import * as i3 from "../../core/datasource.service";
+import * as i4 from "../../cube/cube.service";
+import * as i5 from "../../cube/cube-info.service";
+import * as i6 from "../../core/translate.service";
+/** statistics component*/
+export class CubeChartAnalysisWidget extends CubeAnalysisBase {
+    constructor(ref, session, ds, cube, info, _elementRef, _translate) {
+        super(ref, info, session, ds, cube);
+        this._elementRef = _elementRef;
+        this._translate = _translate;
+        this.type = this._options.chartType || 'Column';
+        this.indexType = this._options.indicesChartType || 'Line';
+        this.marker = {
+            visible: true,
+            width: 10,
+            height: 10
+        };
+        this.primaryXAxis = {
+            valueType: 'Category',
+            labelStyle: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this.primaryYAxis = {
+            labelFormat: this.currencyCode ? 'c0' : 'n0',
+            labelStyle: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this.tooltip = {
+            enable: true,
+            enableAnimation: false,
+            shared: false,
+            textStyle: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this.legend = {
+            visible: false,
+            textStyle: {
+                fontFamily: FONT_FAMILY
+            }
+        };
+        this.animation = { enable: true };
+    }
+    onLoad(data) {
+        const series = data.map(s => {
+            if (s.index)
+                return {
+                    yName: 'y', xName: 'name',
+                    type: this.indexType,
+                    name: s.title,
+                    width: 2,
+                    stackingGroup: 'index',
+                    marker: {
+                        shape: 'Diamond', width: 4
+                    },
+                    dataSource: s.points,
+                    fill: this._session.getPrimery(400)
+                };
+            else
+                return {
+                    yName: 'y', xName: 'name', type: this.type,
+                    dataSource: s.points,
+                    name: s.title ||
+                        this._translate.get('Usage')
+                };
+        });
+        this.chart && this.chart.destroy();
+        if (series.length)
+            this.chart = new Chart({
+                width: '100%',
+                height: this.height,
+                background: 'transparent',
+                theme: this.theme,
+                enableAnimation: true,
+                useGroupingSeparator: true,
+                primaryXAxis: this.primaryXAxis,
+                primaryYAxis: this.primaryYAxis,
+                tooltip: this.tooltip,
+                palettes: this.palettes,
+                currencyCode: this.currencyCode,
+                series,
+                pointClick: this.pointClick.bind(this),
+                legendSettings: {
+                    isInversed: this._session.inverse,
+                    visible: series.length > 1
+                }
+            }, this._elementRef.nativeElement);
+    }
+    pointClick(evt) {
+        const axes = {}, serie = this._data[evt.seriesIndex], { index, name, points } = serie;
+        if (this.series.length && !index)
+            for (let i = 0; i < this.series.length; i++)
+                axes[this.series[i]] = name.split(AXES_CODE_DIVIDER)[i];
+        for (let i = 0; i < this.xAxis.length; i++) {
+            const x = points[evt.pointIndex].x;
+            axes[this.xAxis[i]] = x.split(AXES_CODE_DIVIDER)[i];
+        }
+        this.explore(axes, { index });
+    }
+    onThemeChange() {
+        this.onBind(this._data);
+    }
+    onResize() {
+        if (this.chart) {
+            this.chart.height = this.height;
+        }
+    }
+    tooltipRender(e) {
+        e.text = this._intl.formatNumber(e.point.y, {
+            currency: this.currencyCode,
+            format: this.currencyCode ? 'c' : 'n',
+            maximumFractionDigits: this._service.fractionDigits
+        });
+    }
+    ngOnDestroy() {
+        this.chart && this.chart.destroy();
+        super.ngOnDestroy();
+    }
+}
+CubeChartAnalysisWidget.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeChartAnalysisWidget, deps: [{ token: i1.WidgetRef }, { token: i2.SessionService }, { token: i3.DatasourceService }, { token: i4.CubeService }, { token: i5.CubeInfo }, { token: i0.ElementRef }, { token: i6.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+CubeChartAnalysisWidget.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: CubeChartAnalysisWidget, selector: "bizdoc-cube-chart-analysis", host: { attributes: { "dir": "ltr" }, properties: { "id": "id" } }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: CubeChartAnalysisWidget, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-cube-chart-analysis',
+                    template: '',
+                    //templateUrl: './cube-chart.widget.html'
+                    host: {
+                        '[id]': 'id',
+                        dir: 'ltr'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.WidgetRef }, { type: i2.SessionService }, { type: i3.DatasourceService }, { type: i4.CubeService }, { type: i5.CubeInfo }, { type: i0.ElementRef }, { type: i6.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cube-chart.widget.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/dashboard/cube/cube-chart.widget.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ViewChild, ElementRef } from '@angular/core';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { Chart, AxisModel, MarkerOptionsModel, LegendSeriesModel, TooltipSettingsModel, ChartSeriesType, AnimationModel, SeriesModel, ChartComponent, ITooltipRenderEventArgs, AreaSeries, BarSeries, BubbleSeries, ColumnSeries, DateTime, LineSeries, PolarSeries, RadarSeries, ScatterSeries, SplineAreaSeries, SplineSeries, StackingAreaSeries, StackingBarSeries, StackingColumnSeries, StackingLineSeries, StepAreaSeries, StepLineSeries, IPointEventArgs, Point } from '@syncfusion/ej2-angular-charts';\r\nimport { CubeAnalysisBase } from './cube-analysis.base';\r\nimport { DatasourceService } from '../../core/datasource.service';\r\nimport { WidgetRef } from \"../widget-ref\";\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { AXES_CODE_DIVIDER, CubeService, Series } from '../../cube/cube.service';\r\nimport { FONT_FAMILY } from '../../core/colors';\r\nimport { CubeInfo } from '../../cube/cube-info.service';\r\nimport { AxesMap } from '../../core/models';\r\n\r\n@Component({\r\n  selector: 'bizdoc-cube-chart-analysis',\r\n  template: '',\r\n  //templateUrl: './cube-chart.widget.html'\r\n  host: {\r\n    '[id]': 'id',\r\n    dir: 'ltr'\r\n  }\r\n})\r\n/** statistics component*/\r\nexport class CubeChartAnalysisWidget extends CubeAnalysisBase {\r\n  //@ViewChild(ChartComponent)\r\n  chart: Chart;\r\n  readonly type: ChartSeriesType = this._options.chartType as ChartSeriesType || 'Column';\r\n  readonly indexType: ChartSeriesType = this._options.indicesChartType as ChartSeriesType || 'Line';\r\n  readonly marker: MarkerOptionsModel = {\r\n    visible: true,\r\n    width: 10,\r\n    height: 10\r\n  }\r\n  readonly primaryXAxis: AxisModel = {\r\n    valueType: 'Category',\r\n    labelStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  readonly primaryYAxis: AxisModel = {\r\n    labelFormat: this.currencyCode ? 'c0' : 'n0',\r\n    labelStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  readonly tooltip: TooltipSettingsModel = {\r\n    enable: true,\r\n    enableAnimation: false,\r\n    shared: false,\r\n    textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  readonly legend: LegendSeriesModel = {\r\n    visible: false,\r\n    textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  };\r\n  readonly animation: AnimationModel = { enable: true };\r\n  constructor(ref: WidgetRef,\r\n    session: SessionService,\r\n    ds: DatasourceService,\r\n    cube: CubeService,\r\n    info: CubeInfo,\r\n    private _elementRef: ElementRef,\r\n    private _translate: TranslateService) {\r\n    super(ref, info, session, ds, cube);\r\n  }\r\n  onLoad(data: Series[]) {\r\n    const series = data.map(s => {\r\n      if (s.index)\r\n        return {\r\n          yName: 'y', xName: 'name',\r\n          type: this.indexType,\r\n          name: s.title,\r\n          width: 2,\r\n          stackingGroup: 'index',\r\n          marker: {\r\n            shape: 'Diamond', width: 4\r\n          },\r\n          dataSource: s.points,\r\n          fill: this._session.getPrimery(400)\r\n        } as SeriesModel;\r\n      else return {\r\n        yName: 'y', xName: 'name', type: this.type,\r\n        dataSource: s.points,\r\n        name: s.title ||\r\n          this._translate.get('Usage')\r\n      } as SeriesModel;\r\n    });\r\n    this.chart && this.chart.destroy();\r\n    if (series.length) this.chart = new Chart({\r\n      width: '100%',\r\n      height: this.height,\r\n      background: 'transparent',\r\n      theme: this.theme,\r\n      enableAnimation: true,\r\n      useGroupingSeparator: true,\r\n      primaryXAxis: this.primaryXAxis,\r\n      primaryYAxis: this.primaryYAxis,\r\n      tooltip: this.tooltip,\r\n      palettes: this.palettes,\r\n      currencyCode: this.currencyCode,\r\n      series,\r\n      pointClick: this.pointClick.bind(this),\r\n      legendSettings: {\r\n        isInversed: this._session.inverse,\r\n        visible: series.length > 1\r\n      } as LegendSeriesModel\r\n    }, this._elementRef.nativeElement);\r\n  }\r\n  pointClick(evt: IPointEventArgs) {\r\n    const axes: AxesMap = {},\r\n      serie = this._data[evt.seriesIndex],\r\n      { index, name, points } = serie;\r\n    if (this.series.length && !index)\r\n      for (let i = 0; i < this.series.length; i++)\r\n        axes[this.series[i]] = name.split(AXES_CODE_DIVIDER)[i];\r\n    for (let i = 0; i < this.xAxis.length; i++) {\r\n      const x = points[evt.pointIndex].x;\r\n      axes[this.xAxis[i]] = x.split(AXES_CODE_DIVIDER)[i];\r\n    }\r\n    this.explore(axes, { index });\r\n  }\r\n  onThemeChange() {\r\n    this.onBind(this._data);\r\n  }\r\n  onResize() {\r\n    if (this.chart) {\r\n      this.chart.height = this.height;\r\n    }\r\n  }\r\n  tooltipRender(e: ITooltipRenderEventArgs) {\r\n    e.text = this._intl.formatNumber(e.point.y as number, {\r\n      currency: this.currencyCode,\r\n      format: this.currencyCode ? 'c' : 'n',\r\n      maximumFractionDigits: this._service.fractionDigits\r\n    });\r\n  }\r\n  ngOnDestroy() {\r\n    this.chart && this.chart.destroy();\r\n    super.ngOnDestroy();\r\n  }\r\n}\r\n"]}