@bizdoc/core 1.13.12 → 1.13.13

package/esm2020/lib/cube/grid/spreadsheet.component.mjs

@@ -0,0 +1,365 @@
+import { EventEmitter, Component, Output, HostBinding, Input } from "@angular/core";
+import { Spreadsheet, isNumber } from "@syncfusion/ej2-angular-spreadsheet";
+import { Workbook } from '@syncfusion/ej2-excel-export';
+import { isArray, isString } from "../../core/functions";
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/session.service";
+import * as i2 from "../../core/prompt.service";
+import * as i3 from "../cube.service";
+import * as i4 from "../../core/translate.service";
+import * as i5 from "../../core/datasource.service";
+export class CubeSpreadsheetComponent {
+    //private readonly _intl: Internationalization = new Internationalization();
+    constructor(_session, _sb, _service, _translate, _ds, _elementRef) {
+        this._session = _session;
+        this._sb = _sb;
+        this._service = _service;
+        this._translate = _translate;
+        this._ds = _ds;
+        this._elementRef = _elementRef;
+        this.explore = new EventEmitter();
+        this.loadingChange = new EventEmitter();
+        this.id = `cube-spreadsheet-${CubeSpreadsheetComponent.nextId++}`;
+        this.dataSource = [];
+        this.scrollSettings = { isFinite: true };
+        this.numberStyle = { textAlign: 'right' };
+        this.autoFillSettings = { showFillOptions: false };
+        this._yrows = [];
+        this._xcolumns = [];
+    }
+    set xAxis(val) {
+        this._xAxis = isArray(val) ? val : [val];
+    }
+    set series(val) {
+        if (val)
+            this._series = isArray(val) ? val : [val];
+    }
+    set indices(val) {
+        if (val)
+            this._indices = isArray(val) ? val : [val];
+    }
+    ngOnInit() {
+        this._cube = this.cube ? this._session.profile.cubes.find(c => c.name === this.cube) : this._session.profile.cubes[0];
+        this._numberFormat = `${this._cube.currencyCode ? 'c' : 'n'}${this._service.fractionDigits}`;
+        if (this._series) {
+            const yName = this._series[0], xName = this._xAxis[0], xAxis = this._cube.axes.find(a => a.name === xName), yAxis = this._cube.axes.find(a => a.name === yName);
+            const promises = [];
+            this.columns = [{
+                    width: 120
+                }];
+            // acquire columns source
+            let observe = this._ds.all(xAxis.dataType).toPromise().
+                then(c => {
+                this._xcolumns = c;
+                c.forEach(_ => this.columns.push({
+                    width: 90
+                }));
+            });
+            promises.push(observe);
+            // acquire rows source
+            observe = this._ds.all(yAxis.dataType).toPromise().
+                then(r => this._yrows = r);
+            promises.push(observe);
+            this._prepare = Promise.all(promises);
+        }
+        else {
+            this._axes = this._xAxis.map(c => this._cube.axes.find(a => a.name == c));
+            this.columns = this._axes.map(_ => {
+                return {
+                    width: 120
+                };
+            });
+            this.columns.push({
+                width: 90
+            } /* value */);
+            this._indices && this._indices.forEach(_ => this.columns.push({
+                width: 90
+            }));
+        }
+        if (this._indices)
+            this._cindices = this._cube.indices.filter(i => this._indices.indexOf(i.name) > -1);
+        this.execute();
+    }
+    ngOnChanges(changes) {
+        if (changes['filters'] && !changes['filters'].firstChange)
+            this.execute();
+        else if (changes['height'] || changes['width'])
+            this.resize();
+    }
+    resize() {
+        if (this.spreadsheet) {
+            this.spreadsheet.height = this.height;
+            this.spreadsheet.width = this.width;
+            this.spreadsheet.refresh();
+        }
+    }
+    execute() {
+        this.loadingChange.emit(true);
+        if (this._series)
+            this._service.series(this.cube, this._xAxis, { series: this._series, filters: this.filters, indices: this._indices }).
+                subscribe(data => {
+                this._prepare.then(() => {
+                    this._dataseries(data);
+                    this._draw();
+                    this.loadingChange.emit(false);
+                });
+            }, (e) => {
+                this._sb.error(e.status === 406 ? 'Unauthorized' : null);
+                this.loadingChange.emit(false);
+            });
+        else
+            this._service.table(this._cube.name, this._xAxis, { filters: this.filters, indices: this._indices }).
+                subscribe(data => {
+                this._datatable(data);
+                this._draw();
+                this.loadingChange.emit(false);
+            }, (e) => {
+                this._sb.error(e.status === 406 ? 'Unauthorized' : null);
+                this.loadingChange.emit(false);
+            });
+    }
+    _datatable(data) {
+        const cells = [], style = { fontWeight: 'bold', textAlign: 'center' };
+        this._axes.forEach(c => cells.push({
+            value: c.title, style
+        }));
+        this._cindices?.forEach(i => cells.push({ value: i.title, style }));
+        cells.push({
+            value: this.yAxis ? this.yAxis.title : this._translate.get('Value'),
+            style
+        });
+        this.dataSource = [{
+                cells, height: 25
+            }];
+        data.forEach(d => {
+            const cells = [];
+            this._xAxis.forEach(c => cells.push({
+                value: d[c],
+            }));
+            this._indices?.forEach(i => cells.push({
+                style: this.numberStyle,
+                format: this._numberFormat,
+                value: (d[i] || 0),
+            }));
+            cells.push({
+                style: this.numberStyle,
+                format: this._numberFormat,
+                value: (d.value || 0),
+            });
+            this.dataSource.push({ cells, source: d, height: 25 });
+        });
+    }
+    _dataseries(d) {
+        const style = { fontWeight: 'bold', textAlign: 'center' };
+        const cells = [{ value: '' }];
+        this._xcolumns.forEach(c => cells.push({ value: c.value, style }));
+        this.dataSource = [{ cells, height: 25 }];
+        this._cindices?.forEach(i => {
+            const cells = [{ value: i.title, style }], series = d.find(s => s.index === i.name), map = {};
+            if (series) {
+                series.points.forEach(p => map[p.x] = p.y);
+                this._xcolumns.forEach(c => cells.push({
+                    value: (map[c.key] || 0),
+                    format: this._numberFormat,
+                    style: this.numberStyle
+                }));
+                this.dataSource.push({ cells, height: 25 });
+            }
+        });
+        this._yrows.forEach(r => {
+            const cells = [{ value: r.value, style }], serie = d.find(s => s.name === r.key), map = {};
+            if (serie) {
+                serie.points.forEach(p => map[p.x] = p.y);
+                this._xcolumns.forEach(c => cells.push({
+                    value: (map[c.key] || 0),
+                    format: this._numberFormat,
+                    style: this.numberStyle
+                }));
+            }
+            else
+                this._xcolumns.forEach(_ => cells.push({ value: 0 }));
+            this.dataSource.push({ cells, height: 25 });
+        });
+    }
+    _draw() {
+        this.spreadsheet && this.spreadsheet.destroy();
+        this.spreadsheet = new Spreadsheet({
+            scrollSettings: this.scrollSettings,
+            isProtected: true,
+            allowEditing: false,
+            allowDelete: false,
+            allowInsert: false,
+            showRibbon: false,
+            allowAutoFill: false,
+            autoFillSettings: this.autoFillSettings,
+            enableClipboard: false,
+            enableContextMenu: false,
+            showFormulaBar: false,
+            showSheetTabs: false,
+            select: this.select.bind(this),
+            sheets: [{
+                    columns: this.columns,
+                    frozenColumns: this._series !== undefined ? 1 : 0,
+                    frozenRows: 1,
+                    rows: this.dataSource,
+                }],
+            width: this.width,
+            height: this.height,
+        }, this._elementRef.nativeElement);
+    }
+    select(evt) {
+        const address = this.spreadsheet.getAddressInfo(evt.range);
+        let [y, x, y1, x1] = address.indices;
+        if (y1 < y) {
+            const range = y;
+            y = y1, y1 = range;
+        }
+        if (x1 < x) {
+            const range = x;
+            x = x1, x1 = range;
+        }
+        const axes = {};
+        let index;
+        if (y > this.dataSource.length - 1 || x > this.dataSource[y].cells.length - 1)
+            return;
+        if (y === y1 && x === x1 && this.dataSource[y].cells[x].value === 0)
+            return;
+        if (this._series) {
+            if (y < 1) {
+                if (this._indices)
+                    return;
+                this._fillx(x, x1, axes);
+            }
+            else if (this._indices && y <= this._indices.length + 1) {
+                index = this._indices[y - 1];
+                this._fillx(x, x1, axes);
+            }
+            else {
+                if (this._indices)
+                    this._filly(y - this._indices.length, y1 - this._indices.length, axes);
+                else
+                    this._filly(y, y1, axes);
+                if (x > 1)
+                    this._fillx(x, x1, axes);
+            }
+        }
+        else {
+            if (y === 0)
+                return;
+            index = this._indices && x >= this._axes.length && x < this._axes.length + this._cindices.length ? this._cindices[x - this._axes.length].name : null;
+            let i = y;
+            do {
+                this._axes.forEach(a => {
+                    const key = this.dataSource[i].source['_' + a.name];
+                    if (!axes[a.name])
+                        axes[a.name] = key;
+                    else if (isString(axes[a.name])) {
+                        if (axes[a.name] !== key)
+                            axes[a.name] = [axes[a.name], key];
+                    }
+                    else if (axes[a.name].indexOf(key) < 0)
+                        axes[a.name].push(key);
+                });
+                i++;
+            } while (i <= y1);
+        }
+        this.explore.emit({ axes, index });
+    }
+    _filly(y, y1, axes) {
+        const yName = this._series[0];
+        let i = y - 1;
+        while (i < y1) {
+            let { key } = this._yrows[i];
+            if (!axes[yName])
+                axes[yName] = key;
+            else if (isString(axes[yName]))
+                axes[yName] = [axes[yName], key];
+            else if (axes[yName].indexOf(key) < 0)
+                axes[yName].push(key);
+            i++;
+        }
+    }
+    _fillx(x, x1, axes) {
+        const xName = this._xAxis[0];
+        let i = x - 1;
+        while (i < x1) {
+            let { key } = this._xcolumns[i];
+            if (!axes[xName])
+                axes[xName] = key;
+            else if (isString(axes[xName]))
+                axes[xName] = [axes[xName], key];
+            else if (axes[xName].indexOf(key) < 0)
+                axes[xName].push(key);
+            i++;
+        }
+    }
+    exportToExcel(title) {
+        const { rows } = this.spreadsheet.sheets[0], numberFormat = this._service.numberFormat, book = new Workbook({
+            worksheets: [
+                {
+                    enableRtl: this._session.inverse,
+                    name: this._translate.get('SheetN', 1),
+                    columns: rows[0].cells.map((_, i) => ({ index: i + 1, width: 150 })),
+                    rows: rows.map((r, i) => ({
+                        index: i + 1,
+                        cells: r.cells.map((c, j) => {
+                            const header = i === 0 || (this._series !== undefined && j === 0), isnumber = !header && isNumber(c.value);
+                            return {
+                                type: isnumber ? 'number' : 'text',
+                                index: j + 1,
+                                value: c.value,
+                                style: {
+                                    numberFormat,
+                                    hAlign: isnumber ? 'right' : 'center',
+                                    bold: header
+                                }
+                            };
+                        })
+                    })),
+                },
+            ],
+        }, 'xlsx');
+        book.save(`${title}.xlsx`);
+    }
+    ngOnDestroy() {
+        this.spreadsheet && this.spreadsheet.destroy();
+    }
+}
+CubeSpreadsheetComponent.nextId = 0;
+CubeSpreadsheetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: CubeSpreadsheetComponent, deps: [{ token: i1.SessionService }, { token: i2.PromptService }, { token: i3.CubeService }, { token: i4.TranslateService }, { token: i5.DatasourceService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+CubeSpreadsheetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: CubeSpreadsheetComponent, selector: "bizdoc-cube-spreadsheet", inputs: { width: "width", height: "height", cube: "cube", xAxis: "xAxis", yAxis: "yAxis", series: "series", indices: "indices", filters: "filters", loading: "loading" }, outputs: { explore: "explore", loadingChange: "loadingChange" }, host: { properties: { "id": "this.id" }, classAttribute: "cube-view" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: CubeSpreadsheetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-cube-spreadsheet',
+                    template: '',
+                    host: {
+                        class: 'cube-view'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SessionService }, { type: i2.PromptService }, { type: i3.CubeService }, { type: i4.TranslateService }, { type: i5.DatasourceService }, { type: i0.ElementRef }]; }, propDecorators: { width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], cube: [{
+                type: Input
+            }], xAxis: [{
+                type: Input
+            }], yAxis: [{
+                type: Input
+            }], series: [{
+                type: Input
+            }], indices: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], explore: [{
+                type: Output
+            }], loading: [{
+                type: Input
+            }], loadingChange: [{
+                type: Output
+            }], id: [{
+                type: HostBinding
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spreadsheet.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/cube/grid/spreadsheet.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Component, Output, OnInit, HostBinding, ElementRef, OnDestroy, Input, SimpleChanges, OnChanges } from \"@angular/core\";\r\nimport { HttpResponse } from \"@angular/common/http\";\r\nimport { CellModel, ColumnModel, RowModel, Spreadsheet, CellStyleModel, SelectEventArgs, AutoFillSettingsModel, isNumber, ScrollSettingsModel } from \"@syncfusion/ej2-angular-spreadsheet\";\r\nimport { Workbook } from '@syncfusion/ej2-excel-export';\r\nimport { Worksheet } from '@syncfusion/ej2-excel-export/src/worksheet';\r\nimport { Row } from '@syncfusion/ej2-excel-export/src/row';\r\nimport { Column } from '@syncfusion/ej2-excel-export/src/column';\r\nimport { AxisClickEvent, CubeViewerComponent } from \"../declarations\";\r\nimport { AxesMap, Cube, CubeAxis, CubeIndex, YAxis } from \"../../core/models\";\r\nimport { CubeService, Series } from \"../cube.service\";\r\nimport { PromptService } from \"../../core/prompt.service\";\r\nimport { TranslateService } from \"../../core/translate.service\";\r\nimport { DatasourceService } from \"../../core/datasource.service\";\r\nimport { SessionService } from \"../../core/session.service\";\r\nimport { isArray, isString } from \"../../core/functions\";\r\n\r\n@Component({\r\n  selector: 'bizdoc-cube-spreadsheet',\r\n  template: '',\r\n  host: {\r\n    class: 'cube-view'\r\n  }\r\n})\r\nexport class CubeSpreadsheetComponent implements OnInit, CubeViewerComponent, OnChanges, OnDestroy {\r\n  private static nextId = 0;\r\n  @Input()\r\n  width: string;\r\n  @Input()\r\n  height: string;\r\n  @Input()\r\n  cube: string;\r\n  private _cube: Cube;\r\n  @Input()\r\n  set xAxis(val: string[] | string) {\r\n    this._xAxis = isArray(val) ? val : [val];\r\n  }\r\n  @Input()\r\n  yAxis?: YAxis;\r\n  @Input()\r\n  set series(val: string[] | string) {\r\n    if (val) this._series = isArray(val) ? val : [val];\r\n  }\r\n  @Input()\r\n  set indices(val: string[] | string) {\r\n    if (val) this._indices = isArray(val) ? val : [val];\r\n  }\r\n  @Input()\r\n  filters?: AxesMap;\r\n  @Output() readonly explore = new EventEmitter<AxisClickEvent>();\r\n  @Input() loading: boolean;\r\n  @Output() readonly loadingChange = new EventEmitter<boolean>();\r\n  @HostBinding() id = `cube-spreadsheet-${CubeSpreadsheetComponent.nextId++}`;\r\n  spreadsheet: Spreadsheet;\r\n  dataSource: RowModel[] = [];\r\n  columns: ColumnModel[];\r\n  readonly scrollSettings = { isFinite: true } as ScrollSettingsModel;\r\n  readonly numberStyle = { textAlign: 'right' } as CellStyleModel;\r\n  readonly autoFillSettings = { showFillOptions: false } as AutoFillSettingsModel;\r\n  private _xAxis: string[];\r\n  private _series?: string[];\r\n  private _indices?: string[];\r\n  private _axes: CubeAxis[];\r\n  private _cindices: CubeIndex[];\r\n  private _yrows: { key: any; value: any }[] = [];\r\n  private _xcolumns: { key: any; value: any }[] = [];\r\n  private _prepare: Promise<any[]>;\r\n  private _numberFormat: string;\r\n  //private readonly _intl: Internationalization = new Internationalization();\r\n  constructor(\r\n    private _session: SessionService,\r\n    private _sb: PromptService,\r\n    private _service: CubeService,\r\n    private _translate: TranslateService,\r\n    private _ds: DatasourceService,\r\n    private _elementRef: ElementRef) { }\r\n  ngOnInit(): void {\r\n    this._cube = this.cube ? this._session.profile.cubes.find(c => c.name === this.cube) : this._session.profile.cubes[0];\r\n    this._numberFormat = `${this._cube.currencyCode ? 'c' : 'n'}${this._service.fractionDigits}`\r\n    if (this._series) {\r\n      const yName = this._series[0], xName = this._xAxis[0],\r\n        xAxis = this._cube.axes.find(a => a.name === xName),\r\n        yAxis = this._cube.axes.find(a => a.name === yName);\r\n      const promises: Promise<any>[] = [];\r\n      this.columns = [{\r\n        width: 120\r\n      }];\r\n      // acquire columns source\r\n      let observe = this._ds.all(xAxis.dataType).toPromise().\r\n        then(c => {\r\n          this._xcolumns = c;\r\n          c.forEach(_ => this.columns.push({\r\n            width: 90\r\n          } as ColumnModel\r\n          ));\r\n        }) as Promise<any>;\r\n      promises.push(observe);\r\n      // acquire rows source\r\n      observe = this._ds.all(yAxis.dataType).toPromise().\r\n        then(r => this._yrows = r);\r\n      promises.push(observe);\r\n\r\n      this._prepare = Promise.all(promises);\r\n    }\r\n    else {\r\n      this._axes = this._xAxis.map(c => this._cube.axes.find(a => a.name == c));\r\n      this.columns = this._axes.map(_ => {\r\n        return {\r\n          width: 120\r\n        } as ColumnModel;\r\n      });\r\n      this.columns.push({\r\n        width: 90\r\n      } /* value */);\r\n      this._indices && this._indices.forEach(_ => this.columns.push({\r\n        width: 90\r\n      } as ColumnModel\r\n      ));\r\n    }\r\n    if (this._indices) this._cindices = this._cube.indices.filter(i => this._indices.indexOf(i.name) > -1);\r\n    this.execute();\r\n  }\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['filters'] && !changes['filters'].firstChange)\r\n      this.execute();\r\n    else\r\n      if (changes['height'] || changes['width'])\r\n        this.resize();\r\n  }\r\n  resize() {\r\n    if (this.spreadsheet) {\r\n      this.spreadsheet.height = this.height;\r\n      this.spreadsheet.width = this.width;\r\n      this.spreadsheet.refresh();\r\n    }\r\n  }\r\n\r\n  execute() {\r\n    this.loadingChange.emit(true);\r\n    if (this._series)\r\n      this._service.series(this.cube, this._xAxis, { series: this._series, filters: this.filters, indices: this._indices }).\r\n        subscribe(data => {\r\n          this._prepare.then(() => {\r\n            this._dataseries(data);\r\n            this._draw();\r\n            this.loadingChange.emit(false);\r\n          });\r\n        }, (e: HttpResponse<any>) => {\r\n          this._sb.error(e.status === 406 ? 'Unauthorized' : null);\r\n          this.loadingChange.emit(false);\r\n        });\r\n    else\r\n      this._service.table(this._cube.name, this._xAxis, { filters: this.filters, indices: this._indices }).\r\n        subscribe(data => {\r\n          this._datatable(data);\r\n          this._draw();\r\n          this.loadingChange.emit(false);\r\n        }, (e: HttpResponse<any>) => {\r\n          this._sb.error(e.status === 406 ? 'Unauthorized' : null);\r\n          this.loadingChange.emit(false);\r\n        });\r\n  }\r\n  private _datatable(data: { value: number; }[]) {\r\n    const cells = [], style = { fontWeight: 'bold', textAlign: 'center' } as CellStyleModel;\r\n    this._axes.forEach(c => cells.push({\r\n      value: c.title, style\r\n    } as CellModel));\r\n    this._cindices?.forEach(i => cells.push({ value: i.title, style } as CellModel));\r\n    cells.push({\r\n      value: this.yAxis ? this.yAxis.title : this._translate.get('Value'),\r\n      style\r\n    } as CellModel);\r\n    this.dataSource = [{\r\n      cells, height: 25\r\n    } as RowModel];\r\n    data.forEach(d => {\r\n      const cells = [];\r\n      this._xAxis.forEach(c => cells.push({\r\n        value: d[c],\r\n      } as CellModel));\r\n      this._indices?.forEach(i => cells.push({\r\n        style: this.numberStyle,\r\n        format: this._numberFormat,\r\n        value: (d[i] || 0) as any,\r\n      } as CellModel));\r\n      cells.push({\r\n        style: this.numberStyle,\r\n        format: this._numberFormat,\r\n        value: (d.value || 0) as any,\r\n      } as CellModel);\r\n      this.dataSource.push({ cells, source: d, height: 25 } as RowModel);\r\n    });\r\n  }\r\n\r\n  private _dataseries(d: Series[]) {\r\n    const style = { fontWeight: 'bold', textAlign: 'center' } as CellStyleModel;\r\n    const cells = [{ value: '' } as CellModel];\r\n    this._xcolumns.forEach(c => cells.push({ value: c.value, style }));\r\n    this.dataSource = [{ cells, height: 25 }];\r\n    this._cindices?.forEach(i => {\r\n      const cells = [{ value: i.title, style } as CellModel], series = d.find(s => s.index === i.name), map = {};\r\n      if (series) {\r\n        series.points.forEach(p => map[p.x] = p.y);\r\n        this._xcolumns.forEach(c => cells.push({\r\n          value: (map[c.key] || 0) as any,\r\n          format: this._numberFormat,\r\n          style: this.numberStyle\r\n        })\r\n        );\r\n        this.dataSource.push({ cells, height: 25 } as RowModel);\r\n      }\r\n    });\r\n    this._yrows.forEach(r => {\r\n      const cells = [{ value: r.value, style } as CellModel],\r\n        serie = d.find(s => s.name === r.key), map = {};\r\n      if (serie) {\r\n        serie.points.forEach(p => map[p.x] = p.y);\r\n        this._xcolumns.forEach(c => cells.push({\r\n          value: (map[c.key] || 0) as any,\r\n          format: this._numberFormat,\r\n          style: this.numberStyle\r\n        })\r\n        );\r\n      }\r\n      else\r\n        this._xcolumns.forEach(_ => cells.push({ value: 0 as any })\r\n        );\r\n      this.dataSource.push({ cells, height: 25 } as RowModel);\r\n    });\r\n  }\r\n\r\n  private _draw() {\r\n    this.spreadsheet && this.spreadsheet.destroy();\r\n    this.spreadsheet = new Spreadsheet({\r\n      scrollSettings: this.scrollSettings,\r\n      isProtected: true,\r\n      allowEditing: false,\r\n      allowDelete: false,\r\n      allowInsert: false,\r\n      showRibbon: false,\r\n      allowAutoFill: false,\r\n      autoFillSettings: this.autoFillSettings,\r\n      enableClipboard: false,\r\n      enableContextMenu: false,\r\n      showFormulaBar: false,\r\n      showSheetTabs: false,\r\n      select: this.select.bind(this),\r\n      sheets: [{\r\n        columns: this.columns,\r\n        frozenColumns: this._series !== undefined ? 1 : 0,\r\n        frozenRows: 1,\r\n        rows: this.dataSource,\r\n      }],\r\n      width: this.width,\r\n      height: this.height,\r\n    }, this._elementRef.nativeElement);\r\n  }\r\n  select(evt: SelectEventArgs) {\r\n    const address = this.spreadsheet.getAddressInfo(evt.range);\r\n    let [y, x, y1, x1] = address.indices;\r\n    if (y1 < y) {\r\n      const range = y;\r\n      y = y1, y1 = range;\r\n    }\r\n    if (x1 < x) {\r\n      const range = x;\r\n      x = x1, x1 = range;\r\n    }\r\n    const axes: {} = {};\r\n    let index: string;\r\n    if (y > this.dataSource.length - 1 || x > this.dataSource[y].cells.length - 1) return;\r\n    if (y === y1 && x === x1 && this.dataSource[y].cells[x].value as any === 0) return;\r\n    if (this._series) {\r\n      if (y < 1) {\r\n        if (this._indices) return;\r\n        this._fillx(x, x1, axes);\r\n      }\r\n      else if (this._indices && y <= this._indices.length + 1) {\r\n        index = this._indices[y - 1];\r\n        this._fillx(x, x1, axes);\r\n      }\r\n      else {\r\n        if (this._indices)\r\n          this._filly(y - this._indices.length, y1 - this._indices.length, axes);\r\n        else\r\n          this._filly(y, y1, axes);\r\n        if (x > 1)\r\n          this._fillx(x, x1, axes);\r\n      }\r\n    }\r\n    else {\r\n      if (y === 0) return;\r\n      index = this._indices && x >= this._axes.length && x < this._axes.length + this._cindices.length ? this._cindices[x - this._axes.length].name : null;\r\n      let i = y;\r\n      do {\r\n        this._axes.forEach(a => {\r\n          const key = (this.dataSource[i] as any).source['_' + a.name];\r\n          if (!axes[a.name])\r\n            axes[a.name] = key;\r\n          else if (isString(axes[a.name])) {\r\n            if (axes[a.name] !== key) axes[a.name] = [axes[a.name], key];\r\n          }\r\n          else if ((axes[a.name] as string[]).indexOf(key) < 0) (axes[a.name] as string[]).push(key);\r\n        });\r\n        i++;\r\n      }\r\n      while (i <= y1);\r\n    }\r\n    this.explore.emit({ axes, index });\r\n  }\r\n  private _filly(y: number, y1: number, axes: {}) {\r\n    const yName = this._series[0];\r\n    let i = y - 1;\r\n    while (i < y1) {\r\n      let { key } = this._yrows[i];\r\n      if (!axes[yName])\r\n        axes[yName] = key;\r\n      else if (isString(axes[yName]))\r\n        axes[yName] = [axes[yName], key];\r\n      else if ((axes[yName] as string[]).indexOf(key) < 0)\r\n        (axes[yName] as string[]).push(key);\r\n      i++;\r\n    }\r\n  }\r\n\r\n  private _fillx(x: number, x1: number, axes: {}) {\r\n    const xName = this._xAxis[0];\r\n    let i = x - 1;\r\n    while (i < x1) {\r\n      let { key } = this._xcolumns[i];\r\n      if (!axes[xName])\r\n        axes[xName] = key;\r\n      else if (isString(axes[xName]))\r\n        axes[xName] = [axes[xName], key];\r\n      else if ((axes[xName] as string[]).indexOf(key) < 0)\r\n        (axes[xName] as string[]).push(key);\r\n      i++;\r\n    }\r\n  }\r\n\r\n  exportToExcel(title: string) {\r\n    const { rows } = this.spreadsheet.sheets[0],\r\n      numberFormat = this._service.numberFormat,\r\n      book = new Workbook(\r\n        {\r\n          worksheets: [\r\n            {\r\n              enableRtl: this._session.inverse,\r\n              name: this._translate.get('SheetN', 1),\r\n              columns: rows[0].cells.map((_, i) => ({ index: i + 1, width: 150 } as Column)),\r\n              rows: rows.map((r, i) => (\r\n                {\r\n                  index: i + 1,\r\n                  cells: r.cells.map((c, j) => {\r\n                    const header = i === 0 || (this._series !== undefined && j === 0),\r\n                      isnumber = !header && isNumber(c.value);\r\n                    return {\r\n                      type: isnumber ? 'number' : 'text',\r\n                      index: j + 1,\r\n                      value: c.value,\r\n                      style: {\r\n                        numberFormat,\r\n                        hAlign: isnumber ? 'right' : 'center',\r\n                        bold: header\r\n                      }\r\n                    } as Cell;\r\n                  }\r\n                  )\r\n                } as Row)),\r\n            } as Worksheet,\r\n          ],\r\n        },\r\n        'xlsx'\r\n      );\r\n    book.save(`${title}.xlsx`);\r\n  }\r\n  ngOnDestroy(): void {\r\n    this.spreadsheet && this.spreadsheet.destroy();\r\n  }\r\n}\r\ninterface Cell { }\r\n"]}

package/esm2020/lib/cube/matrix/matrix.base.mjs

@@ -0,0 +1,127 @@
+import { Directive, ViewChild } from '@angular/core';
+import { filter, first } from 'rxjs';
+import { ACCOUNT_DELIMITER } from '../cube.service';
+import { isArray } from '../../core/functions';
+import { CubeMatrixComponent } from './table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../cube.service";
+import * as i2 from "../../core/datasource.service";
+import * as i3 from "../../core/session.service";
+export class CubeMatrixBase {
+    constructor(_service, _ds, _session) {
+        this._service = _service;
+        this._ds = _ds;
+        this._session = _session;
+        this.sources = {};
+        /** filters */
+        this.values = {};
+    }
+    set originalAxes(value) {
+        this._originalAxes = { ...value };
+    }
+    get originalAxes() {
+        return this._originalAxes;
+    }
+    get axes() {
+        return this._axes;
+    }
+    set axes(value) {
+        this._axes = value;
+        this.filters?.forEach(f => this.values[f.name] = value[f.name]);
+    }
+    get cube() {
+        return this._cube;
+    }
+    set cube(value) {
+        this.configuration = this._session.profile.cubes.find(c => c.name === value);
+        if (!this.configuration) {
+            this.configuration = this._session.profile.cubes[0];
+            value = this.configuration.name;
+        }
+        this._service.patterns(value).
+            subscribe(p => this.patterns = p);
+        this._cube = value;
+    }
+    get selection() {
+        return this._selection;
+    }
+    set selection(value) {
+        /** one or more axis */
+        this.filters = this.configuration.axes.filter(a => isArray(value) ?
+            value.indexOf(a.name) > -1 :
+            a.name === value);
+        this.filters.forEach(f => this.sources[f.name] = this._ds.all(f.dataType));
+        this._selection = value;
+    }
+    _populate() {
+        const axes = { ...this._originalAxes };
+        if (this.aggregation)
+            (isArray(this.aggregation) ? this.aggregation : [this.aggregation]).
+                forEach(g => {
+                if (axes[g])
+                    delete axes[g];
+            });
+        this.axes = axes;
+        this._listen().then(() => {
+            const combination = this._combine(axes);
+            this.title = combination.join(ACCOUNT_DELIMITER);
+        });
+    }
+    /**
+     *
+     * @param axes
+     */
+    _combine(axes) {
+        return this.configuration.axes.
+            filter(a => a.combination).
+            map(a => axes[a.name]);
+    }
+    /**
+   *
+   * @param value
+   */
+    filter(name, value, title) {
+        const axes = { ...this.axes };
+        axes[name] = value;
+        this.onFilter(axes);
+        this._listen().then(() => this.values[name] = value);
+    }
+    _listen() {
+        return this.table.loadingChange.pipe(filter(ok => !ok), first()).toPromise();
+    }
+    onFilter(axes) {
+        this.axes = axes;
+    }
+    /**
+      *
+      * @param pattern
+      */
+    aggregate(pattern) {
+        const axes = { ...pattern.axes };
+        this._service.base(this.cube, axes, this.originalAxes);
+        this.axes = { ...axes, ...this.values };
+        this._listen().then(() => {
+            this.title = pattern.title;
+            this.pattern = pattern;
+        });
+    }
+    reset() {
+        this._populate();
+        this._listen().then(() => {
+            this.pattern = null;
+            this.title = null;
+        });
+    }
+    refresh() {
+        this.axes = { ...this.axes };
+    }
+}
+CubeMatrixBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: CubeMatrixBase, deps: [{ token: i1.CubeService }, { token: i2.DatasourceService }, { token: i3.SessionService }], target: i0.ɵɵFactoryTarget.Directive });
+CubeMatrixBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: CubeMatrixBase, viewQueries: [{ propertyName: "table", first: true, predicate: CubeMatrixComponent, descendants: true, static: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: CubeMatrixBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.CubeService }, { type: i2.DatasourceService }, { type: i3.SessionService }]; }, propDecorators: { table: [{
+                type: ViewChild,
+                args: [CubeMatrixComponent, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matrix.base.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/cube/matrix/matrix.base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ViewChild } from '@angular/core';\r\nimport { filter, first, Observable } from 'rxjs';\r\nimport { SessionService } from '../../core/session.service';\r\nimport { DatasourceService } from '../../core/datasource.service';\r\nimport { ACCOUNT_DELIMITER, CubeService, Pattern } from '../cube.service';\r\nimport { AxesMap, Cube, CubeAxis } from '../../core/models';\r\nimport { isArray } from '../../core/functions';\r\nimport { CubeMatrixComponent, SumSettings } from './table.component';\r\n\r\n@Directive()\r\nexport abstract class CubeMatrixBase {\r\n  @ViewChild(CubeMatrixComponent, { static: true }) table: CubeMatrixComponent;\r\n  seriesTotalLabel: string;\r\n  xAxisTotalLabel: string;\r\n  indexAt?: 'series' | 'xAxis';\r\n  placeAt?: 'leading' | 'trailing';\r\n  loading: boolean;\r\n  private _axes: AxesMap;\r\n  private _originalAxes: AxesMap;\r\n  public set originalAxes(value: AxesMap) {\r\n    this._originalAxes = { ...value };\r\n  }\r\n  public get originalAxes(): AxesMap {\r\n    return this._originalAxes;\r\n  }\r\n  public get axes(): AxesMap {\r\n    return this._axes;\r\n  }\r\n  public set axes(value: AxesMap) {\r\n    this._axes = value;\r\n    this.filters?.forEach(f =>\r\n      this.values[f.name] = value[f.name]\r\n    );\r\n  }\r\n  title: string;\r\n\r\n  readonly sources: { [axis: string]: Observable<{ key: string; value: any; }[]>; } = {};\r\n  /** filters */\r\n  readonly values: AxesMap = {};\r\n  filters: CubeAxis[];\r\n  patterns: Pattern[];\r\n  pattern: Pattern;\r\n  indices?: string | string[];\r\n  xAxis: string;\r\n  series: string;\r\n  private _cube: string;\r\n  public get cube(): string {\r\n    return this._cube;\r\n  }\r\n  public set cube(value: string) {\r\n    this.configuration = this._session.profile.cubes.find(c => c.name === value);\r\n    if (!this.configuration) {\r\n      this.configuration = this._session.profile.cubes[0];\r\n      value = this.configuration.name;\r\n    }\r\n    this._service.patterns(value).\r\n      subscribe(p =>\r\n        this.patterns = p);\r\n    this._cube = value;\r\n  }\r\n  sum?: SumSettings | SumSettings[];\r\n  /** one or more axis */\r\n  protected aggregation?: string[] | string;\r\n  private _selection: string | string[];\r\n  protected get selection(): string | string[] {\r\n    return this._selection;\r\n  }\r\n  protected set selection(value: string | string[]) {\r\n    /** one or more axis */\r\n    this.filters = this.configuration.axes.filter(a => isArray(value) ?\r\n      value.indexOf(a.name) > -1 :\r\n      a.name === value);\r\n\r\n    this.filters.forEach(f => this.sources[f.name] = this._ds.all(f.dataType));\r\n    this._selection = value;\r\n  }\r\n  configuration: Cube;\r\n  constructor(\r\n    protected _service: CubeService,\r\n    private _ds: DatasourceService,\r\n    protected _session: SessionService) { }\r\n  private _populate() {\r\n    const axes = { ...this._originalAxes };\r\n    if (this.aggregation)\r\n      (isArray(this.aggregation) ? this.aggregation : [this.aggregation as string]).\r\n        forEach(g => {\r\n          if (axes[g])\r\n            delete axes[g];\r\n        });\r\n    this.axes = axes;\r\n    this._listen().then(() => {\r\n      const combination = this._combine(axes);\r\n      this.title = combination.join(ACCOUNT_DELIMITER);\r\n    });\r\n  }\r\n  /**\r\n   *\r\n   * @param axes\r\n   */\r\n  private _combine(axes: AxesMap): (string | number)[] {\r\n    return this.configuration.axes.\r\n      filter(a => a.combination).\r\n      map(a => axes[a.name] as string | number);\r\n  }\r\n  /**\r\n *\r\n * @param value\r\n */\r\n  filter(name: string, value: string | number, title: string) {\r\n    const axes = { ...this.axes };\r\n    axes[name] = value;\r\n    this.onFilter(axes);\r\n    this._listen().then(() =>\r\n      this.values[name] = value\r\n    );\r\n  }\r\n  private _listen() {\r\n    return this.table.loadingChange.pipe(filter(ok => !ok), first()).toPromise()\r\n  }\r\n\r\n  onFilter(axes: AxesMap) {\r\n    this.axes = axes;\r\n  }\r\n  /**\r\n    *\r\n    * @param pattern\r\n    */\r\n  aggregate(pattern: Pattern) {\r\n    const axes = { ...pattern.axes };\r\n    this._service.base(this.cube, axes, this.originalAxes);\r\n    this.axes = { ...axes, ...this.values };\r\n    this._listen().then(() => {\r\n      this.title = pattern.title;\r\n      this.pattern = pattern;\r\n    });\r\n  }\r\n\r\n  reset() {\r\n    this._populate();\r\n    this._listen().then(() => {\r\n      this.pattern = null;\r\n      this.title = null;\r\n    });\r\n  }\r\n\r\n  refresh() {\r\n    this.axes = { ...this.axes };\r\n  }\r\n}\r\n"]}