@bizdoc/core 2.3.36 → 2.3.40

package/esm2022/lib/reports/cube/performance-hilo.component.mjs

@@ -0,0 +1,184 @@
+import { __decorate } from "tslib";
+import { Component } from '@angular/core';
+import { Subject, startWith, takeUntil } from 'rxjs';
+/// <reference path="./node_modules/dayjs/plugin/duration.d.ts" />
+import dayjs from 'dayjs';
+import { BizDoc } from '../../core/decorators';
+import { FONT_FAMILY } from '../../core/colors';
+//import { CircularGauge, GaugeTheme, IAxisLabelRenderEventArgs, ITooltipRenderEventArgs, LegendSettingsModel, RangeModel, TooltipSettingsModel } from '@syncfusion/ej2-angular-circulargauge';
+import { Chart } from '@syncfusion/ej2-angular-charts';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/account.service";
+import * as i2 from "../../core/session.service";
+import * as i3 from "../../core/translate.service";
+import * as i4 from "../report-ref";
+let PerformanceHiloComponent = class PerformanceHiloComponent {
+    constructor(_elementRef, _accounts, _session, _translate, _reportRef) {
+        this._elementRef = _elementRef;
+        this._accounts = _accounts;
+        this._session = _session;
+        this._translate = _translate;
+        this._reportRef = _reportRef;
+        this.titleStyle = {
+            fontFamily: FONT_FAMILY
+        };
+        this._destroy = new Subject();
+        _session.themeChange.pipe(takeUntil(this._destroy), startWith(_session.theme)).subscribe(t => {
+            //this.theme = t.dark ? 'Material3Dark' : 'Material3';
+            //this.gauge && this._draw();
+            this.chart && this._draw();
+        });
+    }
+    onBind(data) {
+        //this.gauge?.destroy();
+        this.chart?.destroy();
+        if (!data.length)
+            return;
+        let accumStd = 0, countStd = 0, accumDuration = 0;
+        this.maxStd = 0, this.minStd = 0, this.maxDuration = 0, this.minDuration = data[0].durationLow;
+        data.forEach(e => {
+            if (e.standardAvg) {
+                if (e.standardHigh > this.maxStd)
+                    this.maxStd = e.standardHigh;
+                if (e.standardLow < this.minStd || this.minStd === 0)
+                    this.minStd = e.standardLow;
+                countStd++;
+                accumStd += e.standardAvg;
+            }
+            accumDuration += e.durationAvg;
+            if (e.durationHigh > this.maxDuration)
+                this.maxDuration = e.durationHigh;
+            if (e.durationLow < this.minDuration)
+                this.minDuration = e.durationLow;
+        });
+        this.stdAvg = countStd ? accumStd / countStd : 0,
+            this.durationAvg = accumDuration / data.length;
+        this._accounts.getAll(data.map(e => e.userId)).
+            subscribe(users => {
+            this.data = data.map((d, i) => {
+                const durationDev = d.durationAvg / this.durationAvg, standardDev = this.stdAvg ? d.durationAvg / this.stdAvg : 0;
+                return ({
+                    durationDev,
+                    standardDev,
+                    ...d,
+                    name: users[i].name,
+                    values: [d.standardHigh, d.durationHigh, d.durationAvg, d.durationLow, d.standardLow]
+                });
+            });
+            this._draw();
+        });
+    }
+    onExport() {
+        this.chart?.export('XLSX', this._reportRef.name);
+    }
+    _draw() {
+        this.chart?.destroy();
+        //const colors = this._session.accentPalette;
+        //this.gauge?.destroy();
+        //this.gauge = new CircularGauge({
+        //  theme: this.theme,
+        //  title: this._translate.get('AverageValue', dayjs.duration(this.durationAvg, 'seconds').format('DD:HH:mm')),
+        //  titleStyle: this.titleStyle,
+        //  tooltip: this.tooltip,
+        //  axes: [{
+        //    startAngle: 270,
+        //    endAngle: 90,
+        //    pointers: [{
+        //      text: this._translate.get('Standard'),
+        //      color: this._session.getPrimery(),
+        //      value: this.stdAvg
+        //    }],
+        //    ranges: this.data.map((e, i) => ({
+        //      legendText: e.name,
+        //      radius: `${100 - i * 5}%`,
+        //      startWidth: 3,
+        //      endWidth: 3,
+        //      start: this.minDuration,
+        //      end: this.stdAvg ? Math.floor(e.durationAvg / this.stdAvg) : Math.floor(e.durationAvg / this.durationAvg),
+        //      color: colors[Math.floor((i + 9) / i)]
+        //    } as RangeModel))
+        //  }],
+        //  tooltipRender: this.tooltipRender.bind(this),
+        //  legendSettings: this.legendSettings,
+        //  enableRtl: this._session.inverse,
+        //  height: '100%',
+        //},
+        //  this._elementRef.nativeElement);
+        this.chart = new Chart({
+            primaryYAxis: {
+                stripLines: [{
+                        text: this._translate.get('Standard'),
+                        textStyle: {
+                            fontFamily: FONT_FAMILY,
+                        },
+                        opacity: .8,
+                        start: this.minStd,
+                        end: this.maxStd,
+                    }]
+            },
+            primaryXAxis: {
+                valueType: 'Category'
+            },
+            tooltip: { enable: true },
+            tooltipRender: this.tooltipRender.bind(this),
+            series: [{
+                    type: 'BoxAndWhisker',
+                    dataSource: this.data,
+                    boxPlotMode: 'Normal',
+                    enableTooltip: true,
+                    xName: 'name',
+                    yName: 'values'
+                }, {
+                    type: 'Spline',
+                    dataSource: this.data,
+                    xName: 'name',
+                    width: 3,
+                    dashArray: '3 2',
+                    yName: 'durationAvg',
+                }],
+            height: '100%',
+            axisLabelRender: this.axisLabelRender.bind(this),
+            enableExport: true,
+            palettes: [
+                this._session.getAccent(), this._session.getPrimery()
+            ]
+        }, this._elementRef.nativeElement);
+    }
+    axisLabelRender(evt) {
+        if (evt.axis.name === 'primaryYAxis')
+            evt.text = dayjs.duration(evt.value, 's').humanize(); // 'DD:HH:mm'
+    }
+    tooltipRender(evt) {
+        //evt.content = dayjs.duration(evt.range.end, 's').humanize();// 'DD:HH:mm'
+        if (evt.data.seriesIndex === 0) {
+            const [standardHigh, durationHigh, durationAvg, durationLow, standardLow] = evt.point.y;
+            evt.text = dayjs.duration(durationHigh, 's').format('DD:HH:mm');
+            if (standardHigh) {
+                const deviation = Math.round(this.data[evt.data.pointIndex].standardDev);
+                evt.text += ` ${deviation}%`;
+            }
+        }
+        else {
+            evt.headerText = this._translate.get('Average');
+            evt.text = dayjs.duration(evt.data.pointY, 's').format('DD:HH:mm');
+        }
+    }
+    ngOnDestroy() {
+        //this.gauge?.destroy();
+        this.chart?.destroy();
+        this._destroy.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: PerformanceHiloComponent, deps: [{ token: i0.ElementRef }, { token: i1.AccountService }, { token: i2.SessionService }, { token: i3.TranslateService }, { token: i4.ReportRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.2", type: PerformanceHiloComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true, styles: [":host{flex:1}\n"] }); }
+};
+PerformanceHiloComponent = __decorate([
+    BizDoc({
+        selector: 'bizdoc-performance-hilo'
+    })
+], PerformanceHiloComponent);
+export { PerformanceHiloComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: PerformanceHiloComponent, decorators: [{
+            type: Component,
+            args: [{ template: '', styles: [":host{flex:1}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.AccountService }, { type: i2.SessionService }, { type: i3.TranslateService }, { type: i4.ReportRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"performance-hilo.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/reports/cube/performance-hilo.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, OnDestroy } from '@angular/core';\r\nimport { Subject, startWith, takeUntil } from 'rxjs';\r\n/// <reference path=\"./node_modules/dayjs/plugin/duration.d.ts\" />\r\nimport dayjs from 'dayjs';\r\nimport { BizDoc } from '../../core/decorators';\r\nimport { ReportComponent } from '../../core/base';\r\nimport { AccountService } from '../../core/account.service';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { AxesMap, UserInfo } from '../../core/models';\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { FONT_FAMILY } from '../../core/colors';\r\n//import { CircularGauge, GaugeTheme, IAxisLabelRenderEventArgs, ITooltipRenderEventArgs, LegendSettingsModel, RangeModel, TooltipSettingsModel } from '@syncfusion/ej2-angular-circulargauge';\r\nimport { Chart, IAxisLabelRenderEventArgs, ITooltipRenderEventArgs } from '@syncfusion/ej2-angular-charts';\r\nimport { ReportRef } from '../report-ref';\r\n\r\n@Component({\r\n  template: '',\r\n  styles: `:host {flex: 1}`\r\n})\r\n@BizDoc({\r\n  selector: 'bizdoc-performance-hilo'\r\n})\r\nexport class PerformanceHiloComponent implements ReportComponent<Model>, OnDestroy {\r\n  //theme: GaugeTheme;\r\n  //gauge: CircularGauge;\r\n  durationAvg: number;\r\n  stdAvg: number;\r\n  maxStd: number;\r\n  minStd: number;\r\n  minDuration: number;\r\n  maxDuration: number;\r\n  data: Item[];\r\n  readonly titleStyle = {\r\n    fontFamily: FONT_FAMILY\r\n  };\r\n  private readonly _destroy = new Subject<void>();\r\n  //readonly legendSettings: LegendSettingsModel = {};\r\n  //readonly tooltip: TooltipSettingsModel = {};\r\n  chart: Chart;\r\n  constructor(\r\n    private _elementRef: ElementRef<HTMLDivElement>,\r\n    private _accounts: AccountService,\r\n    private _session: SessionService,\r\n    private _translate: TranslateService,\r\n      private _reportRef: ReportRef<PerformanceSettingsModel>\r\n  ) {\r\n    _session.themeChange.pipe(takeUntil(this._destroy), startWith(_session.theme)).subscribe(t => {\r\n      //this.theme = t.dark ? 'Material3Dark' : 'Material3';\r\n      //this.gauge && this._draw();\r\n      this.chart && this._draw();\r\n    })\r\n  }\r\n  onBind(data: Model[]) {\r\n    //this.gauge?.destroy();\r\n    this.chart?.destroy();\r\n    if (!data.length) return;\r\n    let accumStd = 0, countStd = 0, accumDuration = 0;\r\n    this.maxStd = 0, this.minStd = 0, this.maxDuration = 0, this.minDuration = data[0].durationLow;\r\n    data.forEach(e => {\r\n      if (e.standardAvg) {\r\n        if (e.standardHigh > this.maxStd)\r\n          this.maxStd = e.standardHigh;\r\n        if (e.standardLow < this.minStd || this.minStd === 0)\r\n          this.minStd = e.standardLow;\r\n        countStd++;\r\n        accumStd += e.standardAvg;\r\n      }\r\n      accumDuration += e.durationAvg;\r\n      if (e.durationHigh > this.maxDuration)\r\n        this.maxDuration = e.durationHigh;\r\n      if (e.durationLow < this.minDuration)\r\n        this.minDuration = e.durationLow;\r\n    });\r\n    this.stdAvg = countStd ? accumStd / countStd : 0,\r\n      this.durationAvg = accumDuration / data.length;\r\n    this._accounts.getAll(data.map(e => e.userId)).\r\n      subscribe(users => {\r\n        this.data = data.map((d, i) => {\r\n          const durationDev = d.durationAvg / this.durationAvg,\r\n            standardDev = this.stdAvg ? d.durationAvg / this.stdAvg : 0;\r\n\r\n          return ({\r\n            durationDev,\r\n            standardDev,\r\n            ...d,\r\n            name: users[i].name,\r\n            values: [d.standardHigh, d.durationHigh, d.durationAvg, d.durationLow, d.standardLow]\r\n          });\r\n        });\r\n        this._draw();\r\n      });\r\n  }\r\n  onExport() {\r\n    this.chart?.export('XLSX', this._reportRef.name);\r\n  }\r\n  private _draw() {\r\n    this.chart?.destroy();\r\n    //const colors = this._session.accentPalette;\r\n    //this.gauge?.destroy();\r\n    //this.gauge = new CircularGauge({\r\n    //  theme: this.theme,\r\n    //  title: this._translate.get('AverageValue', dayjs.duration(this.durationAvg, 'seconds').format('DD:HH:mm')),\r\n    //  titleStyle: this.titleStyle,\r\n    //  tooltip: this.tooltip,\r\n    //  axes: [{\r\n    //    startAngle: 270,\r\n    //    endAngle: 90,\r\n    //    pointers: [{\r\n    //      text: this._translate.get('Standard'),\r\n    //      color: this._session.getPrimery(),\r\n    //      value: this.stdAvg\r\n    //    }],\r\n    //    ranges: this.data.map((e, i) => ({\r\n    //      legendText: e.name,\r\n    //      radius: `${100 - i * 5}%`,\r\n    //      startWidth: 3,\r\n    //      endWidth: 3,\r\n    //      start: this.minDuration,\r\n    //      end: this.stdAvg ? Math.floor(e.durationAvg / this.stdAvg) : Math.floor(e.durationAvg / this.durationAvg),\r\n    //      color: colors[Math.floor((i + 9) / i)]\r\n    //    } as RangeModel))\r\n    //  }],\r\n    //  tooltipRender: this.tooltipRender.bind(this),\r\n    //  legendSettings: this.legendSettings,\r\n    //  enableRtl: this._session.inverse,\r\n    //  height: '100%',\r\n    //},\r\n    //  this._elementRef.nativeElement);\r\n    this.chart = new Chart({\r\n      primaryYAxis: {\r\n        stripLines: [{\r\n          text: this._translate.get('Standard'),\r\n          textStyle: {\r\n            fontFamily: FONT_FAMILY,\r\n          },\r\n          opacity: .8,\r\n          start: this.minStd,\r\n          end: this.maxStd,\r\n        }]\r\n      },\r\n      primaryXAxis: {\r\n        valueType: 'Category'\r\n      },\r\n      tooltip: { enable: true },\r\n      tooltipRender: this.tooltipRender.bind(this),\r\n      series: [{\r\n        type: 'BoxAndWhisker',\r\n        dataSource: this.data,\r\n        boxPlotMode: 'Normal',\r\n        enableTooltip: true,\r\n        xName: 'name',\r\n        yName: 'values'\r\n      }, {\r\n        type: 'Spline',\r\n        dataSource: this.data,\r\n        xName: 'name',\r\n        width: 3,\r\n        dashArray: '3 2',\r\n        yName: 'durationAvg',\r\n      }],\r\n      height: '100%',\r\n      axisLabelRender: this.axisLabelRender.bind(this),\r\n      enableExport: true,\r\n      palettes: [\r\n        this._session.getAccent(), this._session.getPrimery()]\r\n    },\r\n      this._elementRef.nativeElement);\r\n  }\r\n  axisLabelRender(evt: IAxisLabelRenderEventArgs) {\r\n    if (evt.axis.name === 'primaryYAxis')\r\n      evt.text = dayjs.duration(evt.value, 's').humanize();// 'DD:HH:mm'\r\n  }\r\n  tooltipRender(evt: ITooltipRenderEventArgs) {\r\n    //evt.content = dayjs.duration(evt.range.end, 's').humanize();// 'DD:HH:mm'\r\n    if (evt.data.seriesIndex === 0) {\r\n      const [standardHigh, durationHigh, durationAvg, durationLow, standardLow] = evt.point.y as number[];\r\n      evt.text = dayjs.duration(durationHigh, 's').format('DD:HH:mm');\r\n      if (standardHigh) {\r\n        const deviation = Math.round(this.data[evt.data.pointIndex].standardDev);\r\n        evt.text += ` ${deviation}%`\r\n      }\r\n    }\r\n    else {\r\n      evt.headerText = this._translate.get('Average');\r\n      evt.text = dayjs.duration(evt.data.pointY as any, 's').format('DD:HH:mm');\r\n    }\r\n  }\r\n  ngOnDestroy(): void {\r\n    //this.gauge?.destroy();\r\n    this.chart?.destroy();\r\n    this._destroy.next();\r\n  }\r\n}\r\n\r\ninterface Model {\r\n  userId: string;\r\n  standardAvg: number;\r\n  standardHigh: number;\r\n  standardLow: number;\r\n  durationAvg: number;\r\n  durationHigh: number;\r\n  durationLow: number;\r\n}\r\ntype Item = Model & {\r\n  standardDev?: number;\r\n  durationDev: number;\r\n  name: string;\r\n  values: number[]\r\n};\r\ninterface PerformanceSettingsModel {\r\n  cube?: string;\r\n  filters?: AxesMap;\r\n}\r\n"]}

package/esm2022/lib/reports/cube/role-performance.component.mjs

@@ -1,6 +1,7 @@
 import { __decorate } from "tslib";
 import { Component } from '@angular/core';
 import { Chart } from '@syncfusion/ej2-charts';
+import { Subject, startWith, takeUntil } from 'rxjs';
 /// <reference path="./node_modules/dayjs/plugin/duration.d.ts" />
 import dayjs from 'dayjs';
 import { BizDoc } from '../../core/decorators';
@@ -11,7 +12,7 @@ import * as i2 from "../../core/account.service";
 import * as i3 from "../../core/session.service";
 import * as i4 from "../../core/translate.service";
 import * as i5 from "../report-ref";
-let RolesPerformanceComponent = class RolesPerformanceComponent {
+let PerformanceWindComponent = class PerformanceWindComponent {
     constructor(_elementRef, _router, _accounts, _session, _translate, _reportRef) {
         this._elementRef = _elementRef;
         this._router = _router;
@@ -19,64 +20,82 @@ let RolesPerformanceComponent = class RolesPerformanceComponent {
         this._session = _session;
         this._translate = _translate;
         this._reportRef = _reportRef;
-        this.maxStd = 0;
-        this.maxDuration = 0;
-        this.actions = {};
         this.legendSettings = {
             position: 'Left',
+            isInversed: this._session.inverse,
+            //toggleVisibility: false,
+            enablePages: true,
             enableHighlight: true,
         };
         this.tooltip = {
             enable: true,
+            textStyle: {
+                fontFamily: FONT_FAMILY
+            }
         };
-        this.primaryXAxis = { valueType: 'DateTime' };
+        this.titleStyle = {
+            fontFamily: FONT_FAMILY
+        };
+        this.primaryXAxis = { valueType: 'Double' };
         this.primaryYAxis = {};
-        const { cube: name } = _reportRef.options;
-        this._cube = name ?
-            _session.profile.cubes.find(c => c.name === name) :
-            _session.profile.cubes[0];
+        this.actions = {};
+        this._destroy = new Subject();
         _session.profile.actions.forEach(a => this.actions[a.name] = a);
+        _session.themeChange.pipe(takeUntil(this._destroy), startWith(_session.theme)).subscribe(t => {
+            this.theme = t.dark ? 'Material3Dark' : 'Material3';
+            this.chart && this._draw();
+        });
     }
-    ;
-    onBind(data, args) {
+    onBind(data) {
+        this.chart?.destroy();
         if (!data.length)
             return;
-        let accumStd = 0, countStd = 0, accumDuration = 0;
+        let accumStd = 0, countStd = 0, accumDuration = 0, maxStd = 0, maxDuration = 0, standards = [], map = {};
         data.forEach(e => {
-            if (e.standardTime) {
-                if (e.standardTime > this.maxStd)
-                    this.maxStd = e.standardTime;
-                countStd++;
-                accumStd += e.standardTime;
-            }
-            if (e.duration > this.maxDuration)
-                this.maxDuration = e.duration;
-            accumDuration += e.duration;
-            e.yDate = new Date(e.date).valueOf();
+            let accumStd1 = 0, countStd1 = 0, accumDuration1 = 0;
+            e.items.forEach(e => {
+                if (e.standardTime) {
+                    if (e.standardTime > maxStd)
+                        maxStd = e.standardTime;
+                    countStd++;
+                    countStd1++;
+                    accumStd += e.standardTime;
+                    accumStd1 += e.standardTime;
+                    standards.push(e);
+                }
+                if (e.duration > maxDuration)
+                    maxDuration = e.duration;
+                accumDuration += e.duration;
+                accumDuration1 += e.duration;
+            });
+            map[e.userId] = {
+                items: e.items,
+                stdAvg: countStd1 ? accumStd1 / countStd1 : 0,
+                durationAvg: accumDuration1 / data.length,
+            };
         });
-        let stdAvg = accumStd / countStd, durationAvg = accumDuration / data.length;
-        const ids = data.distinct(e => e.userId);
-        this._accounts.getAll([...ids]).
+        this.stdAvg = countStd ? accumStd / countStd : 0,
+            this.durationAvg = accumDuration / data.length;
+        this._accounts.getAll(data.map(e => e.userId)).
             subscribe(users => {
-            const series = [{
+            this.series = [{
                     name: this._translate.get('Standard'),
-                    xName: 'yDate',
+                    xName: 'date',
                     yName: 'standardTime',
                     type: 'Polar',
                     drawType: 'Line',
-                    //opacity: .5,
                     marker: {
                         visible: true,
                         shape: 'Triangle',
                         width: 5,
                         height: 5
                     },
-                    dataSource: data.filter(e => e.standardTime).
+                    //animation: { enable: true },
+                    dataSource: standards.
                         sort((e1, e2) => e1.standardTime < e2.standardTime ? -1 : 1),
                 },
                 ...users.map(u => ({
-                    dataSource: data.filter(e => e.userId === u.id).
-                        sort((e1, e2) => e1.duration < e2.duration ? -1 : 1),
+                    dataSource: map[u.id].items,
                     name: u.name,
                     type: 'Polar',
                     drawType: 'Line',
@@ -85,70 +104,84 @@ let RolesPerformanceComponent = class RolesPerformanceComponent {
                         width: 5, height: 5,
                         shape: 'Pentagon',
                     },
-                    xName: 'yDate',
+                    xName: 'date',
                     yName: 'duration',
                 }))];
-            new Chart({
-                title: this._translate.get('AverageValue', dayjs.duration(durationAvg, 'seconds').format('DD:HH:ss')),
-                titleStyle: { fontFamily: FONT_FAMILY },
-                subTitle: stdAvg ?
-                    this._translate.get('StandardValue', dayjs.duration(stdAvg, 'seconds').format('DD:HH:ss')) : null,
-                subTitleStyle: { fontFamily: FONT_FAMILY },
-                //          primaryXAxis: { valueType: 'Double' },
-                primaryYAxis: {
-                //minimum: 0, maximum: Math.max(durationAvg, stdAvg)
-                //interval: 60 * 5,
-                },
-                series,
-                //          pointRender: this.pointRender.bind(this),
-                tooltip: this.tooltip,
-                tooltipRender: this.tooltipRender.bind(this),
-                legendSettings: this.legendSettings,
-                axisLabelRender: this.labelRender.bind(this),
-                palettes: [this._session.getPrimery(), ...this._session.accentPalette],
-                enableRtl: this._session.inverse,
-                height: '100%',
-                highlightMode: 'Cluster',
-                pointClick: this.explore.bind(this)
-            }, this._elementRef.nativeElement);
+            this._draw();
         });
     }
-    tooltipRender(evt) {
-        evt.text = dayjs.duration(evt.data.pointY, 's').format('DD:HH:ss');
+    onExport() {
+        this.chart?.export('XLSX', this._reportRef.name);
+    }
+    _draw() {
+        this.chart?.destroy();
+        const colors = this._session.accentPalette;
+        let palettes = [this._session.getPrimery(),
+            ...colors
+        ];
+        while (this.series.length > palettes.length)
+            palettes.push(...colors);
+        this.chart = new Chart({
+            theme: this.theme,
+            selectionMode: 'Series',
+            title: this._translate.get('AverageValue', dayjs.duration(this.durationAvg, 'seconds').format('DD:HH:mm')),
+            titleStyle: this.titleStyle,
+            subTitle: this.stdAvg ?
+                this._translate.get('StandardValue', dayjs.duration(this.stdAvg, 'seconds').format('DD:HH:mm')) : null,
+            subTitleStyle: this.titleStyle,
+            series: this.series,
+            tooltip: this.tooltip,
+            enableAnimation: true,
+            enableExport: true,
+            tooltipRender: this.tooltipRender.bind(this),
+            legendSettings: this.legendSettings,
+            legendRender: this.legendRender.bind(this),
+            axisLabelRender: this.labelRender.bind(this),
+            palettes,
+            enableRtl: this._session.inverse,
+            height: '100%',
+            highlightMode: 'Series',
+            pointClick: this.explore.bind(this)
+        }, this._elementRef.nativeElement);
+    }
+    legendRender(evt) {
+        //evt.text
     }
-    pointRender(evt) {
-        //  const action = this.actions[(evt.point.series[evt.point.index] as Model).actionId];
-        // if (action.color) evt.fill = action.color;
+    tooltipRender(evt) {
+        evt.text = dayjs.duration(evt.data.pointY, 's').format('DD:HH:mm');
     }
     labelRender(evt) {
         switch (evt.axis.name) {
             case 'primaryYAxis':
-                evt.text = dayjs.duration(evt.value, 's').format('DD:HH:ss');
+                evt.text = dayjs.duration(evt.value, 's').humanize();
                 break;
             case 'primaryXAxis':
-                evt.text = dayjs(evt.value).format('MMM YYYY');
+                evt.text = dayjs(evt.value * 1000).format('MMM YYYY');
                 break;
         }
     }
     explore(evt) {
-        const { point: { x, yValue }, series: { name: title } } = evt;
-        //const { cube } = this._reportRef.options;
-        //  this._router.navigate(PerformanceExplroeCompinent,
-        //    {
-        //      queryParams: axes,
-        //    });
+        const { pointIndex, seriesIndex } = evt;
+        if (seriesIndex === 0)
+            return;
+        const { documentId } = this.chart.series[seriesIndex].dataSource[pointIndex];
+        this._router.navigate(['mailbox', 'd', documentId.encodeId()]);
+    }
+    ngOnDestroy() {
+        this.chart?.destroy();
+        this._destroy.next();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: RolesPerformanceComponent, deps: [{ token: i0.ElementRef }, { token: i1.RouterImpl }, { token: i2.AccountService }, { token: i3.SessionService }, { token: i4.TranslateService }, { token: i5.ReportRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: RolesPerformanceComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true, styles: [":host{flex:1}\n"] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: PerformanceWindComponent, deps: [{ token: i0.ElementRef }, { token: i1.RouterImpl }, { token: i2.AccountService }, { token: i3.SessionService }, { token: i4.TranslateService }, { token: i5.ReportRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.2", type: PerformanceWindComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true, styles: [":host{flex:1}\n"] }); }
 };
-RolesPerformanceComponent = __decorate([
+PerformanceWindComponent = __decorate([
     BizDoc({
-        selector: 'bizdoc-role-performance'
+        selector: 'bizdoc-performance-wind'
     })
-], RolesPerformanceComponent);
-export { RolesPerformanceComponent };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: RolesPerformanceComponent, decorators: [{
+], PerformanceWindComponent);
+export { PerformanceWindComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: PerformanceWindComponent, decorators: [{
             type: Component,
             args: [{ template: '', styles: [":host{flex:1}\n"] }]
         }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.RouterImpl }, { type: i2.AccountService }, { type: i3.SessionService }, { type: i4.TranslateService }, { type: i5.ReportRef }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role-performance.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/reports/cube/role-performance.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef } from '@angular/core';\r\nimport { Chart, IAxisLabelRenderEventArgs, LegendSettingsModel, SeriesModel, TooltipSettings, ChartAnnotationSettingsModel, TooltipSettingsModel } from '@syncfusion/ej2-charts';\r\n/// <reference path=\"./node_modules/dayjs/plugin/duration.d.ts\" />\r\nimport dayjs from 'dayjs';\r\nimport { BizDoc } from '../../core/decorators';\r\nimport { ReportRef } from '../report-ref';\r\nimport { ReportComponent } from '../../core/base';\r\nimport { AccountService } from '../../core/account.service';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { RouterImpl } from '../../core/router';\r\nimport { Action, AxesMap, Cube, UserInfo } from '../../core/models';\r\nimport { AxisModel, IAnnotationRenderEventArgs, IPointRenderEventArgs, ITooltipRenderEventArgs, LineSeries, PolarSeries } from '@syncfusion/ej2-angular-charts';\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { FONT_FAMILY } from '../../core/colors';\r\n\r\n@Component({\r\n  template: '',\r\n  styles: `:host {flex: 1}`\r\n})\r\n@BizDoc({\r\n  selector: 'bizdoc-role-performance'\r\n})\r\nexport class RolesPerformanceComponent implements ReportComponent<Model> {\r\n  private readonly _cube: Cube;\r\n  maxStd = 0; maxDuration = 0;\r\n  private actions: { [name: string]: Action } = {};\r\n  constructor(\r\n    private _elementRef: ElementRef<HTMLDivElement>,\r\n    private _router: RouterImpl,\r\n    private _accounts: AccountService,\r\n    private _session: SessionService,\r\n    private _translate: TranslateService,\r\n    private _reportRef: ReportRef<PerformanceSettingsModel>) {\r\n    const { cube: name } = _reportRef.options;\r\n    this._cube = name ?\r\n      _session.profile.cubes.find(c => c.name === name) :\r\n      _session.profile.cubes[0];\r\n    _session.profile.actions.forEach(a =>\r\n      this.actions[a.name] = a\r\n    )\r\n  }\r\n  readonly legendSettings = {\r\n    position: 'Left',\r\n    enableHighlight: true,\r\n  } as LegendSettingsModel;\r\n  readonly tooltip = {\r\n    enable: true,\r\n  } as TooltipSettingsModel;\r\n  readonly primaryXAxis = { valueType: 'DateTime' } as AxisModel;\r\n  readonly primaryYAxis = {} as AxisModel;\r\n  ;\r\n  onBind(data: Model[], args?: any) {\r\n    if (!data.length) return;\r\n    let accumStd = 0, countStd = 0, accumDuration = 0;\r\n    data.forEach(e => {\r\n      if (e.standardTime) {\r\n        if (e.standardTime > this.maxStd)\r\n          this.maxStd = e.standardTime;\r\n        countStd++;\r\n        accumStd += e.standardTime;\r\n      }\r\n      if (e.duration > this.maxDuration)\r\n        this.maxDuration = e.duration;\r\n      accumDuration += e.duration;\r\n      e.yDate = new Date(e.date).valueOf();\r\n    });\r\n    let stdAvg = accumStd / countStd, durationAvg = accumDuration / data.length;\r\n    const ids = data.distinct(e => e.userId);\r\n    this._accounts.getAll([...ids]).\r\n      subscribe(users => {\r\n        const series = [{\r\n          name: this._translate.get('Standard'),\r\n          xName: 'yDate',\r\n          yName: 'standardTime',\r\n          type: 'Polar',\r\n          drawType: 'Line',\r\n          //opacity: .5,\r\n          marker: {\r\n            visible: true,\r\n            shape: 'Triangle',\r\n            width: 5,\r\n            height: 5\r\n          },\r\n          dataSource: data.filter(e => e.standardTime).\r\n            sort((e1, e2) => e1.standardTime < e2.standardTime ? -1 : 1),\r\n        } as SeriesModel,\r\n        ...users.map(u =>\r\n        ({\r\n          dataSource: data.filter(e => e.userId === u.id).\r\n            sort((e1, e2) => e1.duration < e2.duration ? -1 : 1),\r\n          name: u.name,\r\n          type: 'Polar',\r\n          drawType: 'Line',\r\n          marker: {\r\n            visible: true,\r\n            width: 5, height: 5,\r\n            shape: 'Pentagon',\r\n          },\r\n          xName: 'yDate',\r\n          yName: 'duration',\r\n        } as SeriesModel))];\r\n        new Chart({\r\n          title:\r\n            this._translate.get('AverageValue', dayjs.duration(durationAvg, 'seconds').format('DD:HH:ss')),\r\n          titleStyle: { fontFamily: FONT_FAMILY },\r\n          subTitle: stdAvg ?\r\n            this._translate.get('StandardValue', dayjs.duration(stdAvg, 'seconds').format('DD:HH:ss')) : null,\r\n          subTitleStyle: { fontFamily: FONT_FAMILY },\r\n          //          primaryXAxis: { valueType: 'Double' },\r\n          primaryYAxis: {\r\n          //minimum: 0, maximum: Math.max(durationAvg, stdAvg)\r\n          //interval: 60 * 5,\r\n          },\r\n          series,\r\n          //          pointRender: this.pointRender.bind(this),\r\n          tooltip: this.tooltip,\r\n          tooltipRender: this.tooltipRender.bind(this),\r\n          legendSettings: this.legendSettings,\r\n          axisLabelRender: this.labelRender.bind(this),\r\n          palettes: [this._session.getPrimery(), ...this._session.accentPalette],\r\n          enableRtl: this._session.inverse,\r\n          height: '100%',\r\n          highlightMode: 'Cluster',\r\n          pointClick: this.explore.bind(this)\r\n        },\r\n          this._elementRef.nativeElement);\r\n      });\r\n  }\r\n  tooltipRender(evt: ITooltipRenderEventArgs) {\r\n    evt.text = dayjs.duration(evt.data.pointY as any, 's').format('DD:HH:ss');\r\n  }\r\n  pointRender(evt: IPointRenderEventArgs) {\r\n    //  const action = this.actions[(evt.point.series[evt.point.index] as Model).actionId];\r\n    // if (action.color) evt.fill = action.color;\r\n  }\r\n  labelRender(evt: IAxisLabelRenderEventArgs) {\r\n    switch (evt.axis.name) {\r\n      case 'primaryYAxis':\r\n        evt.text = dayjs.duration(evt.value, 's').format('DD:HH:ss');\r\n        break;\r\n      case 'primaryXAxis':\r\n        evt.text = dayjs(evt.value).format('MMM YYYY');\r\n        break;\r\n    }\r\n  }\r\n  explore(evt: any) {\r\n    const { point: { x, yValue }, series: { name: title } } = evt;\r\n    //const { cube } = this._reportRef.options;\r\n\r\n    //  this._router.navigate(PerformanceExplroeCompinent,\r\n    //    {\r\n    //      queryParams: axes,\r\n    //    });\r\n  }\r\n}\r\n\r\ninterface Model {\r\n  yDate: number;\r\n  //xStandardTime?: string;\r\n  //xDuration: string;\r\n  userId: string;\r\n  date: Date;\r\n  standardTime?: number;\r\n  duration: number;\r\n  isFYI: boolean;\r\n  actionId: string;\r\n}\r\ninterface PerformanceSettingsModel {\r\n  cube?: string;\r\n  filters?: AxesMap;\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role-performance.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/reports/cube/role-performance.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, OnDestroy } from '@angular/core';\r\nimport { ILegendRenderEventArgs, IPointEventArgs, AxisModel, ChartTheme, IPointRenderEventArgs, ITooltipRenderEventArgs, Chart, IAxisLabelRenderEventArgs, LegendSettingsModel, SeriesModel, TooltipSettingsModel, titleSettingsModel } from '@syncfusion/ej2-charts';\r\nimport { Subject, startWith, takeUntil } from 'rxjs';\r\n/// <reference path=\"./node_modules/dayjs/plugin/duration.d.ts\" />\r\nimport dayjs from 'dayjs';\r\nimport { BizDoc } from '../../core/decorators';\r\nimport { ReportRef } from '../report-ref';\r\nimport { ReportComponent } from '../../core/base';\r\nimport { AccountService } from '../../core/account.service';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { RouterImpl } from '../../core/router';\r\nimport { Action, AxesMap } from '../../core/models';\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { FONT_FAMILY } from '../../core/colors';\r\n\r\n@Component({\r\n  template: '',\r\n  styles: `:host {flex: 1}`\r\n})\r\n@BizDoc({\r\n  selector: 'bizdoc-performance-wind'\r\n})\r\nexport class PerformanceWindComponent implements ReportComponent<Model>, OnDestroy {\r\n  durationAvg: number;\r\n  stdAvg: number;\r\n  series: SeriesModel[];\r\n  chart: Chart;\r\n  readonly legendSettings = {\r\n    position: 'Left',\r\n    isInversed: this._session.inverse,\r\n    //toggleVisibility: false,\r\n    enablePages: true,\r\n    enableHighlight: true,\r\n  } as LegendSettingsModel;\r\n  readonly tooltip = {\r\n    enable: true,\r\n    textStyle: {\r\n      fontFamily: FONT_FAMILY\r\n    }\r\n  } as TooltipSettingsModel;\r\n  theme: ChartTheme;\r\n  readonly titleStyle = {\r\n    fontFamily: FONT_FAMILY\r\n  } as titleSettingsModel;\r\n  readonly primaryXAxis = { valueType: 'Double' } as AxisModel;\r\n  readonly primaryYAxis = {} as AxisModel;\r\n  private actions: { [name: string]: Action } = {};\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(\r\n    private _elementRef: ElementRef<HTMLDivElement>,\r\n    private _router: RouterImpl,\r\n    private _accounts: AccountService,\r\n    private _session: SessionService,\r\n    private _translate: TranslateService,\r\n    private _reportRef: ReportRef<PerformanceSettingsModel>\r\n  ) {\r\n    _session.profile.actions.forEach(a =>\r\n      this.actions[a.name] = a\r\n    );\r\n    _session.themeChange.pipe(takeUntil(this._destroy), startWith(_session.theme)).subscribe(t => {\r\n      this.theme = t.dark ? 'Material3Dark' : 'Material3';\r\n      this.chart && this._draw();\r\n    })\r\n  }\r\n  onBind(data: Model[]) {\r\n    this.chart?.destroy();\r\n    if (!data.length) return;\r\n    let accumStd = 0, countStd = 0, accumDuration = 0, maxStd = 0, maxDuration = 0,\r\n      standards = [] as ItemModel[], map: {\r\n        [userId: string]: {\r\n          items: ItemModel[];\r\n          durationAvg: number;\r\n          stdAvg: number;\r\n        }\r\n      } = {};\r\n    data.forEach(e => {\r\n      let accumStd1 = 0, countStd1 = 0, accumDuration1 = 0;\r\n      e.items.forEach(e => {\r\n        if (e.standardTime) {\r\n          if (e.standardTime > maxStd)\r\n            maxStd = e.standardTime;\r\n          countStd++;\r\n          countStd1++;\r\n          accumStd += e.standardTime;\r\n          accumStd1 += e.standardTime;\r\n          standards.push(e);\r\n        }\r\n        if (e.duration > maxDuration)\r\n          maxDuration = e.duration;\r\n        accumDuration += e.duration;\r\n        accumDuration1 += e.duration;\r\n      });\r\n      map[e.userId] = {\r\n        items: e.items,\r\n        stdAvg: countStd1 ? accumStd1 / countStd1 : 0,\r\n        durationAvg: accumDuration1 / data.length,\r\n      };\r\n    });\r\n    this.stdAvg = countStd ? accumStd / countStd : 0,\r\n      this.durationAvg = accumDuration / data.length;\r\n    this._accounts.getAll(data.map(e => e.userId)).\r\n      subscribe(users => {\r\n        this.series = [{\r\n          name: this._translate.get('Standard'),\r\n          xName: 'date',\r\n          yName: 'standardTime',\r\n          type: 'Polar',\r\n          drawType: 'Line',\r\n          marker: {\r\n            visible: true,\r\n            shape: 'Triangle',\r\n            width: 5,\r\n            height: 5\r\n          },\r\n          //animation: { enable: true },\r\n          dataSource: standards.\r\n            sort((e1, e2) => e1.standardTime < e2.standardTime ? -1 : 1),\r\n        } as SeriesModel,\r\n        ...users.map(u =>\r\n        ({\r\n          dataSource: map[u.id].items,\r\n          name: u.name,\r\n          type: 'Polar',\r\n          drawType: 'Line',\r\n          marker: {\r\n            visible: true,\r\n            width: 5, height: 5,\r\n            shape: 'Pentagon',\r\n          },\r\n          xName: 'date',\r\n          yName: 'duration',\r\n        } as SeriesModel))];\r\n        this._draw();\r\n      });\r\n  }\r\n  onExport() {\r\n    this.chart?.export('XLSX', this._reportRef.name);\r\n  }\r\n  private _draw() {\r\n    this.chart?.destroy();\r\n    const colors = this._session.accentPalette;\r\n    let palettes = [this._session.getPrimery(),\r\n    ...colors\r\n    ];\r\n    while (this.series.length > palettes.length)\r\n      palettes.push(...colors);\r\n    this.chart = new Chart({\r\n      theme: this.theme,\r\n      selectionMode: 'Series',\r\n      title: this._translate.get('AverageValue', dayjs.duration(this.durationAvg, 'seconds').format('DD:HH:mm')),\r\n      titleStyle: this.titleStyle,\r\n      subTitle: this.stdAvg ?\r\n        this._translate.get('StandardValue', dayjs.duration(this.stdAvg, 'seconds').format('DD:HH:mm')) : null,\r\n      subTitleStyle: this.titleStyle,\r\n      series: this.series,\r\n      tooltip: this.tooltip,\r\n      enableAnimation: true,\r\n      enableExport: true,\r\n      tooltipRender: this.tooltipRender.bind(this),\r\n      legendSettings: this.legendSettings,\r\n      legendRender: this.legendRender.bind(this),\r\n      axisLabelRender: this.labelRender.bind(this),\r\n      palettes,\r\n      enableRtl: this._session.inverse,\r\n      height: '100%',\r\n      highlightMode: 'Series',\r\n      pointClick: this.explore.bind(this)\r\n    },\r\n      this._elementRef.nativeElement);\r\n  }\r\n  legendRender(evt: ILegendRenderEventArgs) {\r\n    //evt.text\r\n  }\r\n  tooltipRender(evt: ITooltipRenderEventArgs) {\r\n    evt.text = dayjs.duration(evt.data.pointY as any, 's').format('DD:HH:mm');\r\n  }\r\n  labelRender(evt: IAxisLabelRenderEventArgs) {\r\n    switch (evt.axis.name) {\r\n      case 'primaryYAxis':\r\n        evt.text = dayjs.duration(evt.value, 's').humanize();\r\n        break;\r\n      case 'primaryXAxis':\r\n        evt.text = dayjs(evt.value * 1000).format('MMM YYYY');\r\n        break;\r\n    }\r\n  }\r\n  explore(evt: IPointEventArgs) {\r\n    const { pointIndex, seriesIndex } = evt;\r\n    if (seriesIndex === 0) return;\r\n\r\n    const { documentId } = this.chart.series[seriesIndex].dataSource[pointIndex] as ItemModel;\r\n\r\n    this._router.navigate(['mailbox', 'd', documentId.encodeId()]);\r\n  }\r\n  ngOnDestroy(): void {\r\n    this.chart?.destroy();\r\n    this._destroy.next();\r\n  }\r\n}\r\n\r\ninterface Model {\r\n  userId: string;\r\n  items: ItemModel[];\r\n}\r\ninterface ItemModel {\r\n  documentId: number;\r\n  date: number;\r\n  standardTime?: number;\r\n  duration: number;\r\n  isFYI: boolean;\r\n  actionId: string;\r\n}\r\ninterface PerformanceSettingsModel {\r\n  cube?: string;\r\n  filters?: AxesMap;\r\n}\r\n"]}

package/esm2022/lib/reports/cube/table-documents.component.mjs

@@ -40,10 +40,10 @@ export class CubeDocumentsTableComponent {
     open(id) {
         this._info.open(id);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: CubeDocumentsTableComponent, deps: [{ token: i1.ReportRef }, { token: i2.DocumentInfo }, { token: i3.SessionService }, { token: i4.CubeService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.2.1", type: CubeDocumentsTableComponent, selector: "ng-component", viewQueries: [{ propertyName: "sort", first: true, predicate: MatSort, descendants: true }, { propertyName: "paginator", first: true, predicate: MatPaginator, descendants: true }], ngImport: i0, template: "<table mat-table matSort [dataSource]=\"dataSource\" [@list]=\"PAGE_SIZE\">\n  <ng-container matColumnDef=\"number\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Number' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> <a (click)=\"open(element.id)\">{{element.number}}</a> </td>\n  </ng-container>\n  <ng-container matColumnDef=\"subject\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Subject' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> {{element.subject}} </td>\n  </ng-container>\n  <ng-container matColumnDef=\"userId\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{ 'Name' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\">\n      <bizdoc-identity-name [identity]=\"element.userId\" [by]=\"element.byId\"></bizdoc-identity-name>\n    </td>\n  </ng-container>\n  <ng-container matColumnDef=\"stateId\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Status' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> <span class=\"document-state\" [style.color]=\"element.stateId|state : 'color'\" [style.borderColor]=\"element.stateId|state : 'color'\">{{element.stateId | state}}</span> </td>\n  </ng-container>\n  <ng-container matColumnDef=\"value\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Value' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\" class=\"figure\">\n      {{element.value | currency : (element.currencyCode || DEFAULT_CURRENCY) : 'symbol' : CURRENCY_FORMAT }}\n      @if (element.partial) {\n        <mat-icon [bizdocTooltip]=\"element.total | currency : element.currencyCode : 'symbol' : CURRENCY_FORMAT\">error_outline</mat-icon>\n      }\n    </td>\n  </ng-container>\n  <tr mat-header-row *matHeaderRowDef=\"displayColumns\"></tr>\n  <tr mat-row [@item] *matRowDef=\"let element; columns: displayColumns;\"></tr>\n</table>\n<mat-paginator [pageSize]=\"PAGE_SIZE\" hidePageSize showFirstLastButtons [style.display]=\"paging ? '' : 'none'\"></mat-paginator>\n", styles: ["table{width:100%}td.figure{text-align:right}.document-state{border-radius:2px 3px;padding:4px;border-width:1px;border-style:solid}\n"], dependencies: [{ kind: "component", type: i5.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i5.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i5.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i5.MatColumnDef, selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { kind: "directive", type: i5.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i5.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i5.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i5.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i5.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i5.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "directive", type: i6.MatSort, selector: "[matSort]", inputs: ["matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear", "matSortDisabled"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i6.MatSortHeader, selector: "[mat-sort-header]", inputs: ["mat-sort-header", "arrowPosition", "start", "disabled", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "component", type: i7.MatPaginator, selector: "mat-paginator", inputs: ["color", "pageIndex", "length", "pageSize", "pageSizeOptions", "hidePageSize", "showFirstLastButtons", "selectConfig", "disabled"], outputs: ["page"], exportAs: ["matPaginator"] }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i9.IdentityName, selector: "bizdoc-identity-name", inputs: ["identity", "by", "chating"] }, { kind: "directive", type: i10.TooltipDirective, selector: "[bizdocTooltip]", inputs: ["bizdocTooltip", "bizdocTooltipTemplate", "bizdocTooltipContext", "bizdocTooltipPosition", "bizdocTooltipDuration", "bizdocTooltipDisabled"] }, { kind: "pipe", type: i11.CurrencyPipe, name: "currency" }, { kind: "pipe", type: i12.TranslatePipe, name: "translate" }, { kind: "pipe", type: i13.StatePipe, name: "state" }], animations: [listAnimation, itemAnimation] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: CubeDocumentsTableComponent, deps: [{ token: i1.ReportRef }, { token: i2.DocumentInfo }, { token: i3.SessionService }, { token: i4.CubeService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.2.2", type: CubeDocumentsTableComponent, selector: "ng-component", viewQueries: [{ propertyName: "sort", first: true, predicate: MatSort, descendants: true }, { propertyName: "paginator", first: true, predicate: MatPaginator, descendants: true }], ngImport: i0, template: "<table mat-table matSort [dataSource]=\"dataSource\" [@list]=\"PAGE_SIZE\">\n  <ng-container matColumnDef=\"number\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Number' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> <a (click)=\"open(element.id)\">{{element.number}}</a> </td>\n  </ng-container>\n  <ng-container matColumnDef=\"subject\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Subject' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> {{element.subject}} </td>\n  </ng-container>\n  <ng-container matColumnDef=\"userId\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{ 'Name' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\">\n      <bizdoc-identity-name [identity]=\"element.userId\" [by]=\"element.byId\"></bizdoc-identity-name>\n    </td>\n  </ng-container>\n  <ng-container matColumnDef=\"stateId\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Status' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> <span class=\"document-state\" [style.color]=\"element.stateId|state : 'color'\" [style.borderColor]=\"element.stateId|state : 'color'\">{{element.stateId | state}}</span> </td>\n  </ng-container>\n  <ng-container matColumnDef=\"value\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Value' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\" class=\"figure\">\n      {{element.value | currency : (element.currencyCode || DEFAULT_CURRENCY) : 'symbol' : CURRENCY_FORMAT }}\n      @if (element.partial) {\n        <mat-icon [bizdocTooltip]=\"element.total | currency : element.currencyCode : 'symbol' : CURRENCY_FORMAT\">error_outline</mat-icon>\n      }\n    </td>\n  </ng-container>\n  <tr mat-header-row *matHeaderRowDef=\"displayColumns\"></tr>\n  <tr mat-row [@item] *matRowDef=\"let element; columns: displayColumns;\"></tr>\n</table>\n<mat-paginator [pageSize]=\"PAGE_SIZE\" hidePageSize showFirstLastButtons [style.display]=\"paging ? '' : 'none'\"></mat-paginator>\n", styles: ["table{width:100%}td.figure{text-align:right}.document-state{border-radius:2px 3px;padding:4px;border-width:1px;border-style:solid}\n"], dependencies: [{ kind: "component", type: i5.MatTable, selector: "mat-table, table[mat-table]", exportAs: ["matTable"] }, { kind: "directive", type: i5.MatHeaderCellDef, selector: "[matHeaderCellDef]" }, { kind: "directive", type: i5.MatHeaderRowDef, selector: "[matHeaderRowDef]", inputs: ["matHeaderRowDef", "matHeaderRowDefSticky"] }, { kind: "directive", type: i5.MatColumnDef, selector: "[matColumnDef]", inputs: ["sticky", "matColumnDef"] }, { kind: "directive", type: i5.MatCellDef, selector: "[matCellDef]" }, { kind: "directive", type: i5.MatRowDef, selector: "[matRowDef]", inputs: ["matRowDefColumns", "matRowDefWhen"] }, { kind: "directive", type: i5.MatHeaderCell, selector: "mat-header-cell, th[mat-header-cell]" }, { kind: "directive", type: i5.MatCell, selector: "mat-cell, td[mat-cell]" }, { kind: "component", type: i5.MatHeaderRow, selector: "mat-header-row, tr[mat-header-row]", exportAs: ["matHeaderRow"] }, { kind: "component", type: i5.MatRow, selector: "mat-row, tr[mat-row]", exportAs: ["matRow"] }, { kind: "directive", type: i6.MatSort, selector: "[matSort]", inputs: ["matSortActive", "matSortStart", "matSortDirection", "matSortDisableClear", "matSortDisabled"], outputs: ["matSortChange"], exportAs: ["matSort"] }, { kind: "component", type: i6.MatSortHeader, selector: "[mat-sort-header]", inputs: ["mat-sort-header", "arrowPosition", "start", "disabled", "sortActionDescription", "disableClear"], exportAs: ["matSortHeader"] }, { kind: "component", type: i7.MatPaginator, selector: "mat-paginator", inputs: ["color", "pageIndex", "length", "pageSize", "pageSizeOptions", "hidePageSize", "showFirstLastButtons", "selectConfig", "disabled"], outputs: ["page"], exportAs: ["matPaginator"] }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i9.IdentityName, selector: "bizdoc-identity-name", inputs: ["identity", "by", "chating"] }, { kind: "directive", type: i10.TooltipDirective, selector: "[bizdocTooltip]", inputs: ["bizdocTooltip", "bizdocTooltipTemplate", "bizdocTooltipContext", "bizdocTooltipPosition", "bizdocTooltipDuration", "bizdocTooltipDisabled"] }, { kind: "pipe", type: i11.CurrencyPipe, name: "currency" }, { kind: "pipe", type: i12.TranslatePipe, name: "translate" }, { kind: "pipe", type: i13.StatePipe, name: "state" }], animations: [listAnimation, itemAnimation] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: CubeDocumentsTableComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: CubeDocumentsTableComponent, decorators: [{
             type: Component,
             args: [{ animations: [listAnimation, itemAnimation], template: "<table mat-table matSort [dataSource]=\"dataSource\" [@list]=\"PAGE_SIZE\">\n  <ng-container matColumnDef=\"number\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Number' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> <a (click)=\"open(element.id)\">{{element.number}}</a> </td>\n  </ng-container>\n  <ng-container matColumnDef=\"subject\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Subject' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> {{element.subject}} </td>\n  </ng-container>\n  <ng-container matColumnDef=\"userId\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{ 'Name' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\">\n      <bizdoc-identity-name [identity]=\"element.userId\" [by]=\"element.byId\"></bizdoc-identity-name>\n    </td>\n  </ng-container>\n  <ng-container matColumnDef=\"stateId\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Status' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\"> <span class=\"document-state\" [style.color]=\"element.stateId|state : 'color'\" [style.borderColor]=\"element.stateId|state : 'color'\">{{element.stateId | state}}</span> </td>\n  </ng-container>\n  <ng-container matColumnDef=\"value\">\n    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{'Value' | translate}}</th>\n    <td mat-cell *matCellDef=\"let element\" class=\"figure\">\n      {{element.value | currency : (element.currencyCode || DEFAULT_CURRENCY) : 'symbol' : CURRENCY_FORMAT }}\n      @if (element.partial) {\n        <mat-icon [bizdocTooltip]=\"element.total | currency : element.currencyCode : 'symbol' : CURRENCY_FORMAT\">error_outline</mat-icon>\n      }\n    </td>\n  </ng-container>\n  <tr mat-header-row *matHeaderRowDef=\"displayColumns\"></tr>\n  <tr mat-row [@item] *matRowDef=\"let element; columns: displayColumns;\"></tr>\n</table>\n<mat-paginator [pageSize]=\"PAGE_SIZE\" hidePageSize showFirstLastButtons [style.display]=\"paging ? '' : 'none'\"></mat-paginator>\n", styles: ["table{width:100%}td.figure{text-align:right}.document-state{border-radius:2px 3px;padding:4px;border-width:1px;border-style:solid}\n"] }]
         }], ctorParameters: () => [{ type: i1.ReportRef }, { type: i2.DocumentInfo }, { type: i3.SessionService }, { type: i4.CubeService }], propDecorators: { sort: [{

package/esm2022/lib/reports/cube/usage-args.component.mjs

@@ -45,8 +45,8 @@ let UsageReportArgs = class UsageReportArgs {
         this.form.reset({}, { emitEvent: false });
         this.form.patchValue(axes);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: UsageReportArgs, deps: [{ token: i1.ReportRef }, { token: i2.FormBuilder }, { token: i3.SessionService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: UsageReportArgs, selector: "ng-component", ngImport: i0, template: "<bizdoc-cube-filter [cube]=\"cube\"\r\n                    [axes]=\"values\"\r\n                    (axesChange)=\"valuesChange($event)\"></bizdoc-cube-filter>\r\n", dependencies: [{ kind: "component", type: i4.CubeFilterComponent, selector: "bizdoc-cube-filter", inputs: ["cube", "exclude", "include", "axes"], outputs: ["axesChange"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: UsageReportArgs, deps: [{ token: i1.ReportRef }, { token: i2.FormBuilder }, { token: i3.SessionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.2", type: UsageReportArgs, selector: "ng-component", ngImport: i0, template: "<bizdoc-cube-filter [cube]=\"cube\"\r\n                    [axes]=\"values\"\r\n                    (axesChange)=\"valuesChange($event)\"></bizdoc-cube-filter>\r\n", dependencies: [{ kind: "component", type: i4.CubeFilterComponent, selector: "bizdoc-cube-filter", inputs: ["cube", "exclude", "include", "axes"], outputs: ["axesChange"] }] }); }
 };
 UsageReportArgs = __decorate([
     BizDoc({
@@ -54,7 +54,7 @@ UsageReportArgs = __decorate([
     })
 ], UsageReportArgs);
 export { UsageReportArgs };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: UsageReportArgs, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.2", ngImport: i0, type: UsageReportArgs, decorators: [{
             type: Component,
             args: [{ template: "<bizdoc-cube-filter [cube]=\"cube\"\r\n                    [axes]=\"values\"\r\n                    (axesChange)=\"valuesChange($event)\"></bizdoc-cube-filter>\r\n" }]
         }], ctorParameters: () => [{ type: i1.ReportRef }, { type: i2.FormBuilder }, { type: i3.SessionService }] });