@progress/kendo-angular-pivotgrid 0.1.5 → 0.2.0-dev.202208181339

package/esm2015/configurator/draggable.directive.js

@@ -0,0 +1,94 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Input, Optional, HostBinding } from '@angular/core';
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
+import { PIVOT_CONFIGURATOR_ACTION } from '@progress/kendo-pivotgrid-common';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-common";
+import * as i2 from "./configurator.service";
+import * as i3 from "./drop-cue.service";
+/**
+ * @hidden
+ */
+export class DraggableChipDirective {
+    constructor(draggable, element, zone, service, cue) {
+        this.draggable = draggable;
+        this.element = element;
+        this.zone = zone;
+        this.service = service;
+        this.cue = cue;
+        this.touchActions = 'none';
+        this.initialX = {};
+        this.initialY = {};
+        this.subs = new Subscription();
+    }
+    get pointerEvents() {
+        return this.drag ? 'none' : undefined;
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => this.subs.add(this.draggable.kendoPress
+            .subscribe((event) => {
+            if (isDocumentAvailable()) {
+                this.cue.create();
+                this.cue.attach();
+                this.initialX.current = event.clientX;
+                this.initialY.current = event.clientY;
+            }
+        })));
+        this.zone.runOutsideAngular(() => this.subs.add(this.draggable.kendoDrag
+            .subscribe((event) => {
+            if (isDocumentAvailable()) {
+                if (Math.abs(this.initialX.current - event.clientX) < 10 &&
+                    Math.abs(this.initialY.current - event.clientY) < 10) {
+                    return;
+                }
+                if (this.element.nativeElement) {
+                    this.element.nativeElement.style.transform = `translate(${event.clientX - this.initialX.current}px, ${event.clientY - this.initialY.current}px)`;
+                }
+            }
+            this.drag = true;
+            this.service.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDragItem, payload: this.item });
+        })));
+        this.zone.runOutsideAngular(() => this.subs.add(this.draggable.kendoRelease
+            .subscribe(() => {
+            this.drag = false;
+            if (this.service.state.dragItem) {
+                if (isDocumentAvailable()) {
+                    if (this.element.nativeElement) {
+                        this.element.nativeElement.style.transform = '';
+                    }
+                    this.cue.remove();
+                }
+                this.service.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.drop, payload: this.item });
+                this.service.state.dragItem = null;
+                this.service.state.dropDirection = null;
+                this.service.state.dropTarget = null;
+                this.service.state.dropZone = null;
+            }
+        })));
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+}
+DraggableChipDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DraggableChipDirective, deps: [{ token: i1.DraggableDirective, optional: true }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i2.ConfiguratorService }, { token: i3.DropCueService }], target: i0.ɵɵFactoryTarget.Directive });
+DraggableChipDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: DraggableChipDirective, selector: "[kendoChipDraggable]", inputs: { item: "item" }, host: { properties: { "style.pointerEvents": "this.pointerEvents", "style.touch-action": "this.touchActions" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DraggableChipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoChipDraggable]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DraggableDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i2.ConfiguratorService }, { type: i3.DropCueService }]; }, propDecorators: { pointerEvents: [{
+                type: HostBinding,
+                args: ['style.pointerEvents']
+            }], touchActions: [{
+                type: HostBinding,
+                args: ['style.touch-action']
+            }], item: [{
+                type: Input
+            }] } });

package/esm2015/configurator/drop-cue.service.js

@@ -0,0 +1,64 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export const append = (element) => {
+    let appended = false;
+    return () => {
+        if (!appended) {
+            document.body.appendChild(element);
+            appended = true;
+        }
+        return element;
+    };
+};
+/**
+ * @hidden
+ */
+export class DropCueService {
+    create() {
+        this.dom = document.createElement('span');
+        this.dom.style.position = 'absolute';
+        const wrapper = document.createElement('div');
+        wrapper.classList.add('k-drop-hint', 'k-drop-hint-v');
+        const hintStart = document.createElement('div');
+        hintStart.classList.add('k-drop-hint-start');
+        const hintLine = document.createElement('div');
+        hintLine.classList.add('k-drop-hint-line');
+        const hintEnd = document.createElement('div');
+        hintEnd.classList.add('k-drop-hint-end');
+        wrapper.append(hintStart, hintLine, hintEnd);
+        this.dom.append(wrapper);
+        this.hide();
+    }
+    attach() {
+        return append(this.dom)();
+    }
+    remove() {
+        if (this.dom && this.dom.parentElement) {
+            document.body.removeChild(this.dom);
+            this.dom = null;
+        }
+    }
+    hide() {
+        this.dom.style.display = "none";
+    }
+    position({ left, top, height }) {
+        this.dom.style.display = 'block';
+        this.dom.style.height = height + 'px';
+        this.dom.style.top = top + 'px';
+        this.dom.style.zIndex = '1000';
+        const width = this.dom.offsetWidth / 2;
+        this.dom.style.left = left - width + 'px';
+    }
+}
+DropCueService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DropCueService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DropCueService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DropCueService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DropCueService, decorators: [{
+            type: Injectable
+        }] });

package/esm2015/configurator/drop-target.directive.js

@@ -0,0 +1,82 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Input } from "@angular/core";
+import { PIVOT_CONFIGURATOR_ACTION } from "@progress/kendo-pivotgrid-common";
+import { Subscription } from "rxjs";
+import { position } from "../util";
+import * as i0 from "@angular/core";
+import * as i1 from "./configurator.service";
+import * as i2 from "./drop-cue.service";
+/**
+ * @hidden
+ */
+export class DropTargetDirective {
+    constructor(element, configuratorService, cue, renderer, zone) {
+        this.element = element;
+        this.configuratorService = configuratorService;
+        this.cue = cue;
+        this.renderer = renderer;
+        this.zone = zone;
+        this.subs = new Subscription();
+    }
+    ngOnInit() {
+        const element = this.element.nativeElement;
+        this.elementType = element.nodeName === 'KENDO-CHIP' ? 'chip' : 'container';
+        this.zone.runOutsideAngular(() => {
+            this.subs.add(this.renderer.listen(element, 'mouseenter', this.handleMouseEnter.bind(this)));
+            this.subs.add(this.renderer.listen(element, 'mousemove', this.handleMouseMove.bind(this)));
+            this.subs.add(this.renderer.listen(element, 'mouseleave', this.handleMouseLeave.bind(this)));
+        });
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+    handleMouseEnter(event) {
+        if (this.configuratorService.state.dragItem) {
+            if (this.elementType === 'chip') {
+                this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropTarget, payload: this.item });
+                this.targetElement = event.target;
+                this.cue.position(position(event.target, this.configuratorService.state.dropDirection === 'before'));
+            }
+            this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropZone, payload: this.axes });
+        }
+    }
+    handleMouseMove($event) {
+        if (this.configuratorService.state.dragItem) {
+            if (this.elementType !== 'chip') {
+                return;
+            }
+            if (this.element.nativeElement) {
+                const rect = this.element.nativeElement.getBoundingClientRect();
+                const x = $event.clientX - rect.left;
+                const direction = x < rect.width / 2 ? 'before' : 'after';
+                if ((direction !== this.configuratorService.state.dropDirection) && this.targetElement) {
+                    this.cue.position(position(this.targetElement, direction === 'before'));
+                }
+                this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropDirection, payload: direction });
+            }
+        }
+    }
+    handleMouseLeave() {
+        if (this.elementType === 'chip') {
+            return;
+        }
+        if (this.configuratorService.state.dragItem) {
+            this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropZone, payload: null });
+        }
+    }
+}
+DropTargetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DropTargetDirective, deps: [{ token: i0.ElementRef }, { token: i1.ConfiguratorService }, { token: i2.DropCueService }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+DropTargetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: DropTargetDirective, selector: "[kendoDropTarget]", inputs: { item: "item", axes: "axes" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DropTargetDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoDropTarget]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ConfiguratorService }, { type: i2.DropCueService }, { type: i0.Renderer2 }, { type: i0.NgZone }]; }, propDecorators: { item: [{
+                type: Input
+            }], axes: [{
+                type: Input
+            }] } });

package/esm2015/data-binding/base-binding-directive.js

@@ -2,9 +2,13 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import { Directive, Input } from '@angular/core';
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
 import { headersReducer, HEADERS_ACTION, toTree } from '@progress/kendo-pivotgrid-common';
 import { Subscription } from 'rxjs';
+import { PivotGridState } from '../models/configurator-settings';
+import { ExpandChangeEvent } from '../models/expanded-change-event';
+import { hasObservers } from '@progress/kendo-angular-common';
+import { ConfigurationChangeEvent } from '../models/configuration-change-event';
 import * as i0 from "@angular/core";
 import * as i1 from "./pivotgrid-data.service";
 /**
@@ -27,11 +31,28 @@ export class PivotBaseBindingDirective {
          * Represents the measure axes configuration of the PivotGrid.
          */
         this.measureAxes = [];
-        this.expandedStateSub = new Subscription();
+        /**
+         * Fires each time a row or column header gets expanded or collapsed by the end user. The event is preventable.
+         * If you prevent the event, the PivotGrid will not be rerendered with the new state, resulting from the end user interaction.
+         */
+        this.expandChange = new EventEmitter();
+        /**
+         * Fires when the Configurator Apply button is pressed. The event is preventable.
+         * If you prevent the event, the PivotGrid will not be rerendered with the new state, resulting from the configuration changes, applied through the configurator interface.
+         */
+        this.configurationChange = new EventEmitter();
+        this.subs = new Subscription();
+    }
+    /**
+     * @hidden
+     */
+    get state() {
+        return new PivotGridState(this.columnAxes, this.rowAxes, this.measureAxes);
     }
     ngOnInit() {
-        this.loadData();
-        this.expandedStateSub = this.dataService.expandedStateChange.subscribe((state) => {
+        this.loadData(this.state);
+        this.loadFields();
+        this.subs.add(this.dataService.expandedStateChange.subscribe((state) => {
             this.zone.run(() => {
                 const isCol = state.tableType === 'columnHeader';
                 const axes = isCol ? 'columnAxes' : 'rowAxes';
@@ -39,10 +60,28 @@ export class PivotBaseBindingDirective {
                 const tree = toTree((isCol ? this.dataService.columns : this.dataService.rows || []).slice());
                 this.updateHeaders(axes, tree, state.cell.path);
             });
-        });
+        }));
+        this.subs.add(this.dataService.configuratorFieldChange.subscribe((state) => {
+            this.zone.run(() => {
+                if (hasObservers(this.configurationChange)) {
+                    const event = new ConfigurationChangeEvent(state);
+                    this.configurationChange.emit(event);
+                    if (event.isDefaultPrevented()) {
+                        return;
+                    }
+                }
+                this.dataService.configuredFields.next({
+                    columnAxes: state.columnAxes,
+                    rowAxes: state.rowAxes,
+                    measureAxes: state.measureAxes
+                });
+                this.loadData(state);
+            });
+        }));
+        this.dataService.directive = this;
     }
     ngOnDestroy() {
-        this.expandedStateSub.unsubscribe();
+        this.subs.unsubscribe();
     }
     updateDataServiceFields() {
         this.dataService.normalizedData = this.dataState.data;
@@ -50,6 +89,14 @@ export class PivotBaseBindingDirective {
         this.dataService.columns = this.dataState.columns;
         this.dataService.updateRowsAndCols();
     }
+    updateConfiguratorFields() {
+        this.dataService.fields.next(this.configuratorFields);
+        this.dataService.configuredFields.next({
+            columnAxes: this.columnAxes,
+            rowAxes: this.rowAxes,
+            measureAxes: this.measureAxes
+        });
+    }
     updateHeaders(axes, tree, path) {
         // Action to determine expand/collapse state
         const action = {
@@ -58,15 +105,23 @@ export class PivotBaseBindingDirective {
         };
         // The `headersReducer` method is responsible for udpating
         // the expanded state based on the toggle action (expand/collapse)
-        const newHeaders = headersReducer(this[axes].slice(), Object.assign(Object.assign({}, action), { tree }));
         // Update axes and reload data
+        const newHeaders = headersReducer(this[axes].slice(), Object.assign(Object.assign({}, action), { tree }));
+        if (hasObservers(this.expandChange)) {
+            const newState = Object.assign(Object.assign({}, this.state), { [axes]: newHeaders });
+            const event = new ExpandChangeEvent(newState);
+            this.expandChange.emit(event);
+            if (event.isDefaultPrevented()) {
+                return;
+            }
+        }
         this[axes] = newHeaders;
-        this.loadData();
+        this.loadData(this.state);
     }
     ;
 }
 PivotBaseBindingDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotBaseBindingDirective, deps: [{ token: i1.PivotGridDataService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
-PivotBaseBindingDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: PivotBaseBindingDirective, selector: "kendo-base-binding-directive", inputs: { columnAxes: "columnAxes", rowAxes: "rowAxes", measureAxes: "measureAxes" }, ngImport: i0 });
+PivotBaseBindingDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: PivotBaseBindingDirective, selector: "kendo-base-binding-directive", inputs: { columnAxes: "columnAxes", rowAxes: "rowAxes", measureAxes: "measureAxes" }, outputs: { expandChange: "expandChange", configurationChange: "configurationChange" }, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotBaseBindingDirective, decorators: [{
             type: Directive,
             args: [{
@@ -78,4 +133,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImpo
                 type: Input
             }], measureAxes: [{
                 type: Input
+            }], expandChange: [{
+                type: Output
+            }], configurationChange: [{
+                type: Output
             }] } });

package/esm2015/data-binding/local-binding.directive.js

@@ -3,7 +3,7 @@
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
 import { Directive, Input } from '@angular/core';
-import { createDataTree, createLocalDataState, rootFields } from '@progress/kendo-pivotgrid-common';
+import { createDataTree, createFlatSchemaDimensions, createLocalDataState, rootFields } from '@progress/kendo-pivotgrid-common';
 import { anyChanged } from '@progress/kendo-angular-common';
 import { PivotBaseBindingDirective } from './base-binding-directive';
 import * as i0 from "@angular/core";
@@ -18,26 +18,38 @@ const stringSeparator = '&';
 export class PivotLocalBindingDirective extends PivotBaseBindingDirective {
     constructor(dataService, zone) {
         super(dataService, zone);
+        this.type = 'local';
         this.createAxisSettings = (key) => (Object.assign({ key }, this.dimensions[key]));
     }
     ngOnChanges(changes) {
         if (anyChanged(['data', 'dimensions', 'columnAxes', 'rowAxes', 'measureAxes', 'measures'], changes)) {
-            this.loadData();
+            this.loadData(this.state);
         }
     }
-    loadData() {
-        const rootColumnAxes = this.getRootAxes(this.columnAxes);
-        const rootRowAxes = this.getRootAxes(this.rowAxes);
+    /**
+     * @hidden
+     */
+    fetchChildren(node) {
+        return node.children;
+    }
+    loadFields() {
+        this.configuratorFields = createFlatSchemaDimensions(this.dimensions, this.measures);
+        this.updateConfiguratorFields();
+    }
+    loadData(state) {
+        const { columnAxes, rowAxes, measureAxes } = state;
+        const rootColumnAxes = this.getRootAxes(columnAxes);
+        const rootRowAxes = this.getRootAxes(rowAxes);
         const columnSettings = rootColumnAxes.split(stringSeparator).map(this.createAxisSettings);
         const rowSettings = rootRowAxes.split(stringSeparator).map(this.createAxisSettings);
-        const measuresSettings = this.measureAxes.map(m => this.measures.find(meas => String(meas.name) === String(m.name))).filter(Boolean);
+        const measuresSettings = measureAxes.map(m => this.measures.find(meas => String(meas.name) === String(m.name))).filter(Boolean);
         const dataTree = createDataTree(this.data, rowSettings, columnSettings, measuresSettings, bindingFields);
         this.dataState = createLocalDataState({
             dataTree,
             rowSettings,
             columnSettings,
-            rowAxes: this.rowAxes,
-            columnAxes: this.columnAxes,
+            rowAxes: rowAxes,
+            columnAxes: columnAxes,
             measures: measuresSettings,
             sort: [],
             fields: bindingFields

package/esm2015/data-binding/olap-binding.directive.js

@@ -2,8 +2,9 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
+import { __awaiter } from "tslib";
 import { Directive, Input } from '@angular/core';
-import { createDataState, fetchData } from '@progress/kendo-pivotgrid-common';
+import { addKPI, buildKPIMeasures, createDataState, fetchData, fetchDiscover } from '@progress/kendo-pivotgrid-common';
 import { anyChanged } from '@progress/kendo-angular-common';
 import { PivotBaseBindingDirective } from './base-binding-directive';
 import * as i0 from "@angular/core";
@@ -14,22 +15,25 @@ import * as i1 from "./pivotgrid-data.service";
 export class PivotOLAPBindingDirective extends PivotBaseBindingDirective {
     constructor(dataService, zone) {
         super(dataService, zone);
+        this.type = 'olap';
     }
     ngOnChanges(changes) {
         if (anyChanged(['url', 'cube', 'catalog', 'columnAxes', 'rowAxes', 'measureAxes'], changes)) {
-            this.loadData();
+            this.loadData(this.state);
+            this.loadFields();
         }
     }
-    loadData() {
+    loadData(state) {
+        const { columnAxes, rowAxes, measureAxes } = state;
         this.dataService.loading.next(true);
         const options = {
             connection: {
                 catalog: this.catalog,
                 cube: this.cube
             },
-            columnAxes: this.columnAxes,
-            rowAxes: this.rowAxes,
-            measureAxes: this.measureAxes
+            columnAxes: columnAxes,
+            rowAxes: rowAxes,
+            measureAxes: measureAxes
         };
         fetchData({ url: this.url }, JSON.parse(JSON.stringify(options)))
             .then(createDataState)
@@ -39,6 +43,127 @@ export class PivotOLAPBindingDirective extends PivotBaseBindingDirective {
             this.dataService.loading.next(false);
         });
     }
+    loadFields() {
+        const options = {
+            connection: {
+                catalog: this.catalog,
+                cube: this.cube
+            },
+            restrictions: {
+                catalogName: this.catalog,
+                cubeName: this.cube
+            },
+            command: 'schemaDimensions'
+        };
+        fetchDiscover({ url: this.url }, options)
+            .then((newFields) => {
+            addKPI(newFields);
+            this.configuratorFields = newFields;
+            this.updateConfiguratorFields();
+        });
+    }
+    updateFields(event, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const newFields = fields.slice();
+            const field = this.getField(newFields, event);
+            if (field && field.uniqueName === '[KPIs]') {
+                const KPIs = this.normalizeKPIs(yield this.loadKPIs());
+                field.children = KPIs;
+            }
+            else if (field && field.type === 'kpi') {
+                field.children = buildKPIMeasures(field);
+            }
+            else if (field && !field.children) {
+                const additionalFields = yield this.loadAvailableFields(field);
+                field.children = additionalFields;
+            }
+            return field === null || field === void 0 ? void 0 : field.children;
+        });
+    }
+    /**
+     * @hidden
+     */
+    fetchChildren(event, fields) {
+        return this.updateFields(event, fields);
+    }
+    normalizeKPIs(data) {
+        for (let idx = 0, length = data.length; idx < length; idx++) {
+            data[idx].uniqueName = data[idx].name;
+            data[idx].type = 'kpi';
+        }
+        return data;
+    }
+    ;
+    getField(nodes = [], target) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (node.uniqueName === target.uniqueName) {
+                return node;
+            }
+            let result = this.getField(node.children, target);
+            if (result !== null) {
+                return result;
+            }
+        }
+        return null;
+    }
+    ;
+    loadKPIs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = {
+                connection: {
+                    catalog: this.catalog,
+                    cube: this.cube
+                },
+                restrictions: {
+                    catalogName: this.catalog,
+                    cubeName: this.cube
+                },
+                command: 'schemaKPIs'
+            };
+            return fetchDiscover({ url: this.url }, options);
+        });
+    }
+    ;
+    loadAvailableFields(field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let command;
+            let dimensionUniqueName;
+            let hierarchyUniqueName;
+            let levelUniqueName;
+            let memberUniqueName;
+            let treeOp;
+            if (field.type === 2) {
+                command = 'schemaMeasures';
+            }
+            else if (field.dimensionUniqueName) {
+                command = 'schemaLevels';
+                hierarchyUniqueName = field.uniqueName;
+            }
+            else {
+                command = 'schemaHierarchies';
+                dimensionUniqueName = field.uniqueName;
+            }
+            const options = {
+                connection: {
+                    catalog: this.catalog,
+                    cube: this.cube
+                },
+                restrictions: {
+                    catalogName: this.catalog,
+                    cubeName: this.cube,
+                    hierarchyUniqueName,
+                    dimensionUniqueName,
+                    levelUniqueName,
+                    memberUniqueName,
+                    treeOp
+                },
+                command
+            };
+            return fetchDiscover({ url: this.url }, options);
+        });
+    }
+    ;
 }
 PivotOLAPBindingDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotOLAPBindingDirective, deps: [{ token: i1.PivotGridDataService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
 PivotOLAPBindingDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: PivotOLAPBindingDirective, selector: "[kendoPivotOLAPBinding]", inputs: { url: "url", cube: "cube", catalog: "catalog" }, exportAs: ["kendoPivotOLAPBinding"], usesInheritance: true, usesOnChanges: true, ngImport: i0 });

package/esm2015/data-binding/pivotgrid-data.service.js

@@ -3,21 +3,33 @@
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
 import { EventEmitter, Injectable, Output } from '@angular/core';
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
 import { toColumns, toData, toRows, toTree } from '@progress/kendo-pivotgrid-common';
+import { matchAriaAttributes } from '../util';
 import { BehaviorSubject } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+let nextPivotGridId = 0;
 /**
  * @hidden
  */
 export class PivotGridDataService {
-    constructor() {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
         this.expandedStateChange = new EventEmitter();
+        this.configuratorFieldChange = new EventEmitter();
+        this.expandedFieldChange = new EventEmitter();
         this.columnHeaderRows = new BehaviorSubject([]);
         this.columnHeaderCols = new BehaviorSubject([]);
         this.rowHeaderCols = new BehaviorSubject([]);
         this.rowHeaderRows = new BehaviorSubject([]);
         this.valuesRows = new BehaviorSubject([]);
         this.loading = new BehaviorSubject(false);
+        this.fields = new BehaviorSubject([]);
+        this.configuredFields = new BehaviorSubject([]);
+        this.pivotGridId = nextPivotGridId++;
     }
     updateRowsAndCols() {
         const rowsTree = toTree((this.rows || []).slice());
@@ -31,12 +43,23 @@ export class PivotGridDataService {
         this.rowHeaderCols.next(new Array(rowHeaderBreadth).fill({}));
         this.rowHeaderRows.next(rowHeaderRows);
         this.valuesRows.next(toData((this.normalizedData || []).slice(), columnHeaderLeaves, rowHeaderLeaves, columnHeaderBreadth, rowHeaderDepth));
+        if (isDocumentAvailable()) {
+            this.ngZone.runOutsideAngular(() => {
+                // needed because all tables need to be rendered in accordance with the new settings
+                // before applying the required DOM attributes
+                setTimeout(() => matchAriaAttributes(this.wrapper));
+            });
+        }
     }
 }
-PivotGridDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotGridDataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PivotGridDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotGridDataService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
 PivotGridDataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotGridDataService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PivotGridDataService, decorators: [{
             type: Injectable
-        }], propDecorators: { expandedStateChange: [{
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; }, propDecorators: { expandedStateChange: [{
+                type: Output
+            }], configuratorFieldChange: [{
+                type: Output
+            }], expandedFieldChange: [{
                 type: Output
             }] } });