@bizdoc/core 1.13.12 → 1.13.16

package/esm2020/lib/cube/parallel/parallel.component.mjs

@@ -0,0 +1,160 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { debounceTime, Subject, takeUntil } from 'rxjs';
+import { AXES_CODE_DIVIDER } from '../../cube/cube.service';
+import { isArray } from '../../core/functions';
+import { Item } from './item';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/prompt.service";
+import * as i2 from "../../cube/cube.service";
+import * as i3 from "../../core/session.service";
+import * as i4 from "@syncfusion/ej2-angular-charts";
+import * as i5 from "@angular/common";
+/** */
+export class CubeParallelComponent {
+    constructor(_sb, _service, _session) {
+        this._sb = _sb;
+        this._service = _service;
+        this._session = _session;
+        this.onExplore = new EventEmitter();
+        this.theme = this._session.theme.dark ? 'MaterialDark' : 'Material';
+        this._palettes = this._session.accentPalette;
+        this.items = [];
+        this.axisSettings = {
+            lineSettings: {},
+        };
+        this.width = '150px';
+        this.enableRtl = this._session.inverse;
+        this._primary = this._session.primeryPalette;
+        this._loading = new Subject();
+        this._destroy = new Subject();
+        this._loading.pipe(debounceTime(200)).subscribe(ok => this.loading = ok);
+    }
+    get palettes() {
+        return this._palettes;
+    }
+    set palettes(value) {
+        this._palettes = value;
+    }
+    ngOnChanges(changes) {
+        delete this.filters[this.xAxis];
+        this._cube = this._session.profile.cubes.find(c => c.name === this.cube) || this._session.profile.cubes[0];
+        this.format = (this._cube.currencyCode ? 'c' : 'n') + this._service.fractionDigits;
+        if (changes['filters'])
+            this._initialize();
+        else if (changes['size'] && this.items.length)
+            this.width = Math.round(this.size / this.items.length) + 'px';
+    }
+    ngOnInit() {
+        this._session.themeChange.pipe(takeUntil(this._destroy)).
+            subscribe(t => {
+            this.theme = t.dark ? 'MaterialDark' : 'Material';
+            this._primary = this._session.primeryPalette;
+            this._palettes = this._session.accentPalette;
+            this._draw();
+        });
+    }
+    _initialize() {
+        this._loading.next(true);
+        const filters = { ...this.filters };
+        this._service.series(this._cube.name, this.xAxis, {
+            series: this.series,
+            filters,
+            indices: this.indices,
+            groupIndices: true,
+            scope: this.scope
+        }).subscribe(r => {
+            this._data = r;
+            this._draw();
+            if (this.items.length)
+                this.width = Math.max(Math.round(this.size / this.items.length), 150) + 'px';
+            this._loading.next(false);
+        }, (e) => {
+            this._sb.error(e.status === 406 ? 'Unauthorized' : null);
+            this._loading.next(false);
+        });
+    }
+    _draw() {
+        this.items = [];
+        const colorMap = {};
+        let colorIndex = 0;
+        let originalXAxis = this.filters[isArray(this.xAxis) ? this.xAxis[0] : this.xAxis], originalSeries = this.filters[isArray(this.series) ? this.series[0] : this.series];
+        if (!isArray(originalXAxis))
+            originalXAxis = [originalXAxis];
+        if (!isArray(originalSeries))
+            originalSeries = [originalSeries];
+        let max = 0;
+        this._data.forEach(s => {
+            if (s.points.length < 2)
+                return;
+            const palettes = [];
+            for (var i = 0; i < s.points.length; i++) {
+                let point = s.points[i], color = colorMap[point.x];
+                if (!color) {
+                    color = colorMap[point.x] =
+                        s.index
+                            || (!this.indices && originalXAxis.indexOf(point.x) > -1
+                                && originalSeries.indexOf(s.name) > -1)
+                            ? this._primary[colorIndex] : this._palettes[colorIndex];
+                    colorIndex++;
+                }
+                palettes.push(color);
+                if (point.y > max)
+                    max = point.y;
+            }
+            this.items.push(new Item(this.chartType || 'Pie', s, palettes, s.index ? this._primary[6] :
+                this._palettes[6]));
+        });
+        this.axisSettings.maxY = max;
+    }
+    sprklineClick(item, evt) {
+        const name = item.data.name, x = item.data.points[evt.pointIndex].x, index = item.data.index;
+        const axes = {};
+        let { xAxis, series } = this;
+        if (!isArray(xAxis))
+            xAxis = [xAxis];
+        if (!isArray(series))
+            xAxis = [series];
+        for (let i = 0; i < series.length; i++)
+            axes[series[i]] = name.split(AXES_CODE_DIVIDER)[i];
+        for (let i = 0; i < xAxis.length; i++) {
+            axes[xAxis[i]] = x.split(AXES_CODE_DIVIDER)[i];
+        }
+        this.onExplore.emit({
+            axes: { ...this.filters, ...axes },
+            index
+        });
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+        this._loading.complete();
+    }
+}
+CubeParallelComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CubeParallelComponent, deps: [{ token: i1.PromptService }, { token: i2.CubeService }, { token: i3.SessionService }], target: i0.ɵɵFactoryTarget.Component });
+CubeParallelComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: CubeParallelComponent, selector: "bizdoc-cube-parallel", inputs: { filters: "filters", xAxis: "xAxis", series: "series", indices: "indices", cube: "cube", size: "size", chartType: "chartType", scope: "scope", palettes: "palettes" }, outputs: { onExplore: "explore" }, usesOnChanges: true, ngImport: i0, template: "<div *ngIf=\"items.length\" class=\"row\">\r\n  <div *ngFor=\"let s of items\" class=\"element\">\r\n    <ejs-sparkline [width]='width' height='100px' [type]='s.chartType' [id]=\"s.data.name\"\r\n                   [dataSource]=\"s.data.points\" xName=\"name\"\r\n                   yName=\"y\" [palette]=\"s.palette\" [format]=\"format\"\r\n                   valueType=\"Category\"\r\n                   [enableRtl]=\"enableRtl\"\r\n                   [border]=\"s.border\"\r\n                   [fill]=\"s.fill\"\r\n                   [axisSettings]=\"axisSettings\"\r\n                   [markerSettings]=\"s.markerSettings\"\r\n                   (pointRegionMouseClick)=\"sprklineClick(s, $event)\"\r\n                   [tooltipSettings]=\"s.tooltipSettings\">\r\n    </ejs-sparkline>\r\n    <h4 class=\"mat-h4\">{{s.data.title}}</h4>\r\n  </div>\r\n</div>\r\n", styles: [":host{padding:8px}.element{display:flex;flex-direction:column;align-items:center;flex:1 1 auto}\n"], components: [{ type: i4.SparklineComponent, selector: "ejs-sparkline", inputs: ["axisSettings", "border", "containerArea", "dataLabelSettings", "dataSource", "enablePersistence", "enableRtl", "endPointColor", "fill", "format", "height", "highPointColor", "lineWidth", "locale", "lowPointColor", "markerSettings", "negativePointColor", "opacity", "padding", "palette", "query", "rangeBandSettings", "rangePadding", "startPointColor", "theme", "tiePointColor", "tooltipSettings", "type", "useGroupingSeparator", "valueType", "width", "xName", "yName"], outputs: ["axisRendering", "dataLabelRendering", "load", "loaded", "markerRendering", "pointRegionMouseClick", "pointRegionMouseMove", "pointRendering", "resize", "seriesRendering", "sparklineMouseClick", "sparklineMouseMove", "tooltipInitialize"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CubeParallelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-cube-parallel', template: "<div *ngIf=\"items.length\" class=\"row\">\r\n  <div *ngFor=\"let s of items\" class=\"element\">\r\n    <ejs-sparkline [width]='width' height='100px' [type]='s.chartType' [id]=\"s.data.name\"\r\n                   [dataSource]=\"s.data.points\" xName=\"name\"\r\n                   yName=\"y\" [palette]=\"s.palette\" [format]=\"format\"\r\n                   valueType=\"Category\"\r\n                   [enableRtl]=\"enableRtl\"\r\n                   [border]=\"s.border\"\r\n                   [fill]=\"s.fill\"\r\n                   [axisSettings]=\"axisSettings\"\r\n                   [markerSettings]=\"s.markerSettings\"\r\n                   (pointRegionMouseClick)=\"sprklineClick(s, $event)\"\r\n                   [tooltipSettings]=\"s.tooltipSettings\">\r\n    </ejs-sparkline>\r\n    <h4 class=\"mat-h4\">{{s.data.title}}</h4>\r\n  </div>\r\n</div>\r\n", styles: [":host{padding:8px}.element{display:flex;flex-direction:column;align-items:center;flex:1 1 auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PromptService }, { type: i2.CubeService }, { type: i3.SessionService }]; }, propDecorators: { filters: [{
+                type: Input
+            }], xAxis: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], indices: [{
+                type: Input
+            }], cube: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], chartType: [{
+                type: Input
+            }], scope: [{
+                type: Input
+            }], onExplore: [{
+                type: Output,
+                args: ['explore']
+            }], palettes: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parallel.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/cube/parallel/parallel.component.ts","../../../../../../libraries/core/src/lib/cube/parallel/parallel.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges } from '@angular/core';\r\nimport { HttpResponse } from '@angular/common/http';\r\nimport { AxisSettingsModel, IPointRegionEventArgs, LineSettingsModel, SparklineType } from '@syncfusion/ej2-angular-charts';\r\nimport { debounceTime, Subject, takeUntil } from 'rxjs';\r\nimport { PromptService } from '../../core/prompt.service';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { AXES_CODE_DIVIDER, CubeService, Series } from '../../cube/cube.service';\r\nimport { isArray } from '../../core/functions';\r\nimport { AxesMap, Cube } from '../../core/models';\r\nimport { Item } from './item';\r\nimport { ScopeType } from '../../core/configuration';\r\n/** */\r\n@Component({\r\n  selector: 'bizdoc-cube-parallel',\r\n  templateUrl: './parallel.component.html',\r\n  styleUrls: ['parallel.component.scss']\r\n})\r\nexport\r\n  class CubeParallelComponent implements OnInit, OnChanges, OnDestroy {\r\n  @Input()\r\n  filters: AxesMap;\r\n  @Input()\r\n  xAxis!: string | string[];\r\n  @Input()\r\n  series!: string | string[];\r\n  @Input()\r\n  indices?: string | string[];\r\n  @Input()\r\n  cube: string;\r\n  @Input()\r\n  size: number;\r\n  @Input()\r\n  chartType?: SparklineType;\r\n  @Input()\r\n  scope?: ScopeType;\r\n  @Output('explore')\r\n  readonly onExplore = new EventEmitter<ExploreEvent>();\r\n  theme: 'Material' | 'MaterialDark' = this._session.theme.dark ? 'MaterialDark' : 'Material';\r\n  private _palettes = this._session.accentPalette;\r\n  public get palettes() {\r\n    return this._palettes;\r\n  }\r\n  @Input()\r\n  public set palettes(value) {\r\n    this._palettes = value;\r\n  }\r\n  items: Item[] = [];\r\n  format: string;\r\n  readonly axisSettings = {\r\n    lineSettings: {\r\n    } as LineSettingsModel,\r\n  } as AxisSettingsModel;\r\n  width: string = '150px';\r\n  loading: boolean;\r\n  private _data: Series[];\r\n  private _cube: Cube;\r\n  readonly enableRtl = this._session.inverse;\r\n  private _primary = this._session.primeryPalette;\r\n  private readonly _loading = new Subject<boolean>();\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(\r\n    private _sb: PromptService,\r\n    private _service: CubeService,\r\n    private _session: SessionService) {\r\n    this._loading.pipe(debounceTime(200)).subscribe(ok => this.loading = ok);\r\n  }\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    delete this.filters[this.xAxis as string];\r\n    this._cube = this._session.profile.cubes.find(c => c.name === this.cube) || this._session.profile.cubes[0];\r\n    this.format = (this._cube.currencyCode ? 'c' : 'n') + this._service.fractionDigits;\r\n    if (changes['filters']) this._initialize();\r\n    else if (changes['size'] && this.items.length) this.width = Math.round(this.size / this.items.length) + 'px';\r\n  }\r\n  ngOnInit(): void {\r\n    this._session.themeChange.pipe(takeUntil(this._destroy)).\r\n      subscribe(t => {\r\n        this.theme = t.dark ? 'MaterialDark' : 'Material';\r\n        this._primary = this._session.primeryPalette;\r\n        this._palettes = this._session.accentPalette;\r\n        this._draw();\r\n      });\r\n  }\r\n  private _initialize() {\r\n    this._loading.next(true);\r\n    const filters = { ...this.filters };\r\n\r\n    this._service.series(this._cube.name, this.xAxis, {\r\n      series: this.series,\r\n      filters,\r\n      indices: this.indices,\r\n      groupIndices: true,\r\n      scope: this.scope\r\n    }).subscribe(r => {\r\n      this._data = r;\r\n      this._draw();\r\n      if (this.items.length) this.width = Math.max(Math.round(this.size / this.items.length), 150) + 'px';\r\n      this._loading.next(false);\r\n    }, (e: HttpResponse<any>) => {\r\n      this._sb.error(e.status === 406 ? 'Unauthorized' : null);\r\n      this._loading.next(false);\r\n    }\r\n    );\r\n  }\r\n  private _draw() {\r\n    this.items = [];\r\n    const colorMap = {};\r\n    let colorIndex = 0;\r\n\r\n    let originalXAxis = this.filters[isArray(this.xAxis) ? this.xAxis[0] : this.xAxis] as string | string[],\r\n      originalSeries = this.filters[isArray(this.series) ? this.series[0] : this.series] as string | string[];\r\n\r\n    if (!isArray(originalXAxis))\r\n      originalXAxis = [originalXAxis];\r\n    if (!isArray(originalSeries))\r\n      originalSeries = [originalSeries];\r\n    let max = 0;\r\n    this._data.forEach(s => {\r\n      if (s.points.length < 2)\r\n        return;\r\n      const palettes = [];\r\n      for (var i = 0; i < s.points.length; i++) {\r\n        let point = s.points[i], color = colorMap[point.x];\r\n        if (!color) {\r\n          color = colorMap[point.x] =\r\n            s.index\r\n              || (!this.indices && originalXAxis.indexOf(point.x) > -1\r\n                && originalSeries.indexOf(s.name) > -1)\r\n              ? this._primary[colorIndex] : this._palettes[colorIndex];\r\n          colorIndex++;\r\n        }\r\n        palettes.push(color);\r\n        if (point.y > max)\r\n          max = point.y;\r\n      }\r\n      this.items.push(new Item(this.chartType || 'Pie',\r\n        s, palettes, s.index ? this._primary[6] :\r\n        this._palettes[6]));\r\n    });\r\n    this.axisSettings.maxY = max;\r\n  }\r\n  sprklineClick(item: Item, evt: IPointRegionEventArgs) {\r\n    const name = item.data.name,\r\n      x = item.data.points[evt.pointIndex].x, index = item.data.index;\r\n    const axes: { [axis: string]: any } = {};\r\n    let { xAxis, series } = this;\r\n    if (!isArray(xAxis)) xAxis = [xAxis];\r\n    if (!isArray(series)) xAxis = [series];\r\n    for (let i = 0; i < series.length; i++)\r\n      axes[series[i]] = name.split(AXES_CODE_DIVIDER)[i];\r\n    for (let i = 0; i < xAxis.length; i++) {\r\n      axes[xAxis[i]] = x.split(AXES_CODE_DIVIDER)[i];\r\n    }\r\n    this.onExplore.emit({\r\n      axes: { ...this.filters, ...axes },\r\n      index\r\n    });\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n    this._loading.complete();\r\n  }\r\n}\r\nexport interface ExploreEvent {\r\n  axes: AxesMap;\r\n  index?: string;\r\n}\r\n","<div *ngIf=\"items.length\" class=\"row\">\r\n  <div *ngFor=\"let s of items\" class=\"element\">\r\n    <ejs-sparkline [width]='width' height='100px' [type]='s.chartType' [id]=\"s.data.name\"\r\n                   [dataSource]=\"s.data.points\" xName=\"name\"\r\n                   yName=\"y\" [palette]=\"s.palette\" [format]=\"format\"\r\n                   valueType=\"Category\"\r\n                   [enableRtl]=\"enableRtl\"\r\n                   [border]=\"s.border\"\r\n                   [fill]=\"s.fill\"\r\n                   [axisSettings]=\"axisSettings\"\r\n                   [markerSettings]=\"s.markerSettings\"\r\n                   (pointRegionMouseClick)=\"sprklineClick(s, $event)\"\r\n                   [tooltipSettings]=\"s.tooltipSettings\">\r\n    </ejs-sparkline>\r\n    <h4 class=\"mat-h4\">{{s.data.title}}</h4>\r\n  </div>\r\n</div>\r\n"]}