@progress/kendo-angular-pivotgrid 21.4.1 → 22.0.0-develop.1

package/esm2022/configurator/configurator.service.mjs

@@ -1,53 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { EventEmitter, Injectable, Output } from '@angular/core';
-import { configuratorReducer } from '@progress/kendo-pivotgrid-common';
-import { PivotGridDataService } from '../data-binding/pivotgrid-data.service';
-import { PivotGridState } from './../models/configurator-settings';
-import * as i0 from "@angular/core";
-import * as i1 from "../data-binding/pivotgrid-data.service";
-/**
- * @hidden
- */
-export class ConfiguratorService {
-    dataService;
-    configuratorInstance;
-    state;
-    draggedElement;
-    dropTargetElement;
-    cueContainer;
-    orientation;
-    configuratorStateChange = new EventEmitter();
-    closeMenu = new EventEmitter();
-    constructor(dataService) {
-        this.dataService = dataService;
-    }
-    parseConfiguratorState(action) {
-        const newState = configuratorReducer({
-            filter: this.dataService.state.filter,
-            sort: this.dataService.state.sort,
-            rowAxes: this.dataService.state.rowAxes,
-            columnAxes: this.dataService.state.columnAxes,
-            measureAxes: this.dataService.state.measureAxes,
-            dragItem: this.state.dragItem,
-            dropDirection: this.state.dropDirection,
-            dropTarget: this.state.dropTarget,
-            dropZone: this.state.dropZone
-        }, action);
-        Object.keys(newState).forEach(key => newState[key] === undefined && delete newState[key]);
-        this.state = { ...this.state, ...newState };
-        this.dataService.state = new PivotGridState(this.state.columnAxes, this.state.rowAxes, this.state.measureAxes, this.state.sort, this.state.filter);
-        this.configuratorStateChange.emit(this.state);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfiguratorService, deps: [{ token: i1.PivotGridDataService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfiguratorService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConfiguratorService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.PivotGridDataService }], propDecorators: { configuratorStateChange: [{
-                type: Output
-            }], closeMenu: [{
-                type: Output
-            }] } });

package/esm2022/configurator/draggable.directive.mjs

@@ -1,131 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Directive, Input, ElementRef, NgZone, Optional, HostBinding, Renderer2 } from '@angular/core';
-import { DraggableDirective, isDocumentAvailable } from '@progress/kendo-angular-common';
-import { PIVOT_CONFIGURATOR_ACTION } from '@progress/kendo-pivotgrid-common';
-import { ConfiguratorService } from './configurator.service';
-import { DropCueService } from './drop-cue.service';
-import { Subscription } from 'rxjs';
-import { tap } from 'rxjs/operators';
-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 {
-    draggable;
-    element;
-    zone;
-    service;
-    cue;
-    renderer;
-    get pointerEvents() {
-        return this.drag ? 'none' : undefined;
-    }
-    touchActions = 'none';
-    item;
-    initialX = {};
-    initialY = {};
-    drag;
-    invalidTarget = false;
-    subs = new Subscription();
-    constructor(draggable, element, zone, service, cue, renderer) {
-        this.draggable = draggable;
-        this.element = element;
-        this.zone = zone;
-        this.service = service;
-        this.cue = cue;
-        this.renderer = renderer;
-    }
-    ngOnInit() {
-        this.subs.add(this.draggable.kendoPress
-            .pipe(tap((e) => {
-            this.service.closeMenu.emit();
-            if (e.originalEvent.target.closest('.k-icon-wrapper-host')) {
-                this.invalidTarget = true;
-            }
-        })).subscribe((event) => {
-            this.zone.runOutsideAngular(() => {
-                if (isDocumentAvailable() && !this.invalidTarget) {
-                    this.initialX.current = event.clientX;
-                    this.initialY.current = event.clientY;
-                    const element = this.element.nativeElement;
-                    this.renderer.setStyle(element, 'z-index', 1);
-                    this.service.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDragItem, payload: this.item });
-                    this.service.draggedElement = {
-                        element,
-                        fromSection: element.closest('.k-chip-list').getAttribute('axes').split('Axes')[0]
-                    };
-                }
-            });
-        }));
-        this.subs.add(this.draggable.kendoDrag
-            .subscribe((event) => {
-            this.zone.runOutsideAngular(() => {
-                if (isDocumentAvailable() && !this.invalidTarget) {
-                    const isDragging = Math.abs(this.initialX.current - event.clientX) > 5 ||
-                        Math.abs(this.initialY.current - event.clientY) > 5;
-                    if (!isDragging) {
-                        return;
-                    }
-                    this.drag = true;
-                    if (!document.elementFromPoint(event.clientX, event.clientY)?.closest('.k-pivotgrid-configurator')) {
-                        return;
-                    }
-                    this.renderer.setStyle(this.element.nativeElement, 'transform', `translate(${event.clientX - this.initialX.current}px, ${event.clientY - this.initialY.current}px)`);
-                }
-            });
-        }));
-        this.subs.add(this.draggable.kendoRelease
-            .subscribe(() => {
-            this.zone.runOutsideAngular(() => {
-                this.drag = false;
-                this.invalidTarget = false;
-                if (this.service.state.dragItem) {
-                    const element = this.element.nativeElement;
-                    if (isDocumentAvailable()) {
-                        this.renderer.removeStyle(element, 'transform');
-                        this.cue.remove(this.service.cueContainer);
-                    }
-                    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;
-                    this.renderer.removeStyle(element, 'z-index');
-                    this.service.draggedElement = null;
-                    if (this.service.dropTargetElement) {
-                        this.renderer.removeStyle(this.service.dropTargetElement, 'cursor');
-                        this.service.dropTargetElement = null;
-                    }
-                }
-            });
-        }));
-    }
-    ngOnDestroy() {
-        this.subs.unsubscribe();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DraggableChipDirective, deps: [{ token: i1.DraggableDirective, optional: true }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i2.ConfiguratorService }, { token: i3.DropCueService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DraggableChipDirective, isStandalone: true, 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: "18.2.14", ngImport: i0, type: DraggableChipDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoChipDraggable]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.DraggableDirective, decorators: [{
-                    type: Optional
-                }] }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i2.ConfiguratorService }, { type: i3.DropCueService }, { type: i0.Renderer2 }], propDecorators: { pointerEvents: [{
-                type: HostBinding,
-                args: ['style.pointerEvents']
-            }], touchActions: [{
-                type: HostBinding,
-                args: ['style.touch-action']
-            }], item: [{
-                type: Input
-            }] } });

package/esm2022/configurator/drop-cue.service.mjs

@@ -1,86 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 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, container) => {
-    let appended = false;
-    return () => {
-        if (!appended) {
-            container.appendChild(element);
-            appended = true;
-        }
-        return element;
-    };
-};
-/**
- * @hidden
- */
-export class DropCueService {
-    dom;
-    create() {
-        this.dom = document.createElement('span');
-        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(container) {
-        return append(this.dom, container)();
-    }
-    remove(container) {
-        if (this.dom && this.dom.parentElement && container.contains(this.dom)) {
-            container.removeChild(this.dom);
-            this.dom = null;
-        }
-    }
-    hide() {
-        this.dom.style.display = 'none';
-    }
-    show(direction, container, target) {
-        if (!this.dom) {
-            this.create();
-        }
-        if (!target || !container) {
-            return;
-        }
-        if (direction === 'before') {
-            if (container.contains(target)) {
-                container.insertBefore(this.dom, target);
-            }
-            else {
-                container.appendChild(this.dom);
-            }
-        }
-        else {
-            if (target.classList.contains('k-chip') && target.matches(':last-child')) {
-                if (container.contains(target)) {
-                    container.insertBefore(this.dom, target);
-                }
-                else {
-                    container.appendChild(this.dom);
-                }
-                return;
-            }
-            // eslint-disable-next-line no-unused-expressions
-            target.classList.contains('k-chip') ? target.after(this.dom) : container.appendChild(this.dom);
-        }
-        this.dom.style.display = '';
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DropCueService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DropCueService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DropCueService, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/configurator/drop-target.directive.mjs

@@ -1,190 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Directive, ElementRef, Input, NgZone, Renderer2 } from "@angular/core";
-import { PIVOT_CONFIGURATOR_ACTION } from "@progress/kendo-pivotgrid-common";
-import { Subscription } from "rxjs";
-import { ConfiguratorService } from "./configurator.service";
-import { DropCueService } from "./drop-cue.service";
-import { isPresent } 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 {
-    element;
-    configuratorService;
-    cue;
-    renderer;
-    zone;
-    item;
-    axes;
-    elementType;
-    elementSectionType;
-    targetElement;
-    nextChipOffset;
-    subs = new Subscription();
-    constructor(element, configuratorService, cue, renderer, zone) {
-        this.element = element;
-        this.configuratorService = configuratorService;
-        this.cue = cue;
-        this.renderer = renderer;
-        this.zone = zone;
-    }
-    ngOnInit() {
-        const element = this.element.nativeElement;
-        this.elementType = this.getElementType(element);
-        this.elementSectionType = element.getAttribute('axes')?.split('Axes')[0];
-        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) {
-        this.zone.runOutsideAngular(() => {
-            if (this.configuratorService.state.dragItem) {
-                this.configuratorService.dropTargetElement = this.element.nativeElement;
-                if (this.configuratorService.draggedElement && !this.isDropAllowed(this.configuratorService.draggedElement.fromSection)) {
-                    return;
-                }
-                this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropTarget, payload: this.item });
-                this.targetElement = this.elementType === 'header' ? event.target.nextElementSibling : event.target;
-                // eslint-disable-next-line no-unused-expressions
-                this.cue.dom && this.cue.remove(this.getCueContainer());
-                this.cue.create();
-                this.cue.attach(this.getCueContainer());
-                this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropZone, payload: this.axes });
-            }
-        });
-    }
-    handleMouseMove(event) {
-        this.zone.runOutsideAngular(() => {
-            event.stopImmediatePropagation();
-            if (this.configuratorService.state.dragItem) {
-                if (this.configuratorService.draggedElement && !this.isDropAllowed(this.configuratorService.draggedElement.fromSection)) {
-                    this.renderer.setStyle(this.element.nativeElement, 'cursor', 'not-allowed');
-                    return;
-                }
-                this.renderer.setStyle(this.element.nativeElement, 'cursor', 'pointer');
-                const singleOrNoChip = this.targetElement?.querySelectorAll('.k-chip').length < 2;
-                const isInOwnContainer = this.elementSectionType === this.configuratorService.draggedElement.fromSection;
-                if (!this.targetElement) {
-                    return;
-                }
-                switch (this.elementType) {
-                    case 'chip': {
-                        const rect = this.element.nativeElement.getBoundingClientRect();
-                        const x = event.clientX - rect.left;
-                        const direction = x < rect.width / 2 ? 'before' : 'after';
-                        this.cue.show(direction, this.configuratorService.cueContainer, this.targetElement);
-                        if (direction !== this.configuratorService.state.dropDirection) {
-                            this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropDirection, payload: direction });
-                        }
-                        break;
-                    }
-                    case 'container':
-                    case 'header':
-                        if (singleOrNoChip && isInOwnContainer) {
-                            return;
-                        }
-                        if (isInOwnContainer) {
-                            const draggedElement = this.configuratorService.draggedElement.element;
-                            const nextChip = this.getNextChip(draggedElement);
-                            if (!nextChip) {
-                                this.cue.show('before', this.configuratorService.cueContainer, draggedElement);
-                                if (this.configuratorService.state.dropDirection !== 'before') {
-                                    this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropDirection, payload: 'before' });
-                                }
-                                return;
-                            }
-                            const isVertical = this.configuratorService.orientation === 'vertical';
-                            if (!isPresent(this.nextChipOffset)) {
-                                this.nextChipOffset = isVertical ? nextChip.getBoundingClientRect().left : nextChip.getBoundingClientRect().top;
-                            }
-                            const isBefore = isVertical ? event.clientX < this.nextChipOffset : event.clientY < this.nextChipOffset;
-                            if (isBefore) {
-                                this.cue.show('after', this.configuratorService.cueContainer, draggedElement);
-                                return;
-                            }
-                        }
-                        if (this.configuratorService.state.dropDirection !== 'after') {
-                            this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropDirection, payload: 'after' });
-                        }
-                        this.cue.show('after', this.configuratorService.cueContainer, this.targetElement);
-                        break;
-                    default:
-                }
-            }
-        });
-    }
-    handleMouseLeave(event) {
-        this.renderer.removeStyle(this.element.nativeElement, 'cursor');
-        if (!this.configuratorService.draggedElement) {
-            return;
-        }
-        this.zone.runOutsideAngular(() => {
-            event.stopImmediatePropagation();
-            this.configuratorService.dropTargetElement = null;
-            this.cue.remove(this.getCueContainer());
-            if (this.elementType === 'chip') {
-                return;
-            }
-            if (this.configuratorService.state.dragItem) {
-                this.configuratorService.parseConfiguratorState({ type: PIVOT_CONFIGURATOR_ACTION.setDropZone, payload: null });
-            }
-        });
-    }
-    isDropAllowed(fromSection) {
-        const element = this.element.nativeElement;
-        const fromRowsOrColsToMeasures = (fromSection === 'row' || fromSection === 'column') && element.closest('[axes=measureAxes]');
-        const fromMeasuresToRowsOrCols = fromSection === 'measure' && (element.closest('[axes=rowAxes]') || element.closest('[axes=columnAxes]'));
-        return !(fromRowsOrColsToMeasures || fromMeasuresToRowsOrCols);
-    }
-    getElementType(element) {
-        return {
-            'KENDO-CHIP': 'chip',
-            'KENDO-CHIPLIST': 'container',
-            'DIV': 'header'
-        }[element.tagName];
-    }
-    getCueContainer() {
-        const element = this.element.nativeElement;
-        const cueContainer = {
-            chip: element.parentElement,
-            container: element,
-            header: element.classList.contains('k-settings-description') ? element : element.nextElementSibling
-        }[this.elementType];
-        this.configuratorService.cueContainer = cueContainer;
-        return cueContainer;
-    }
-    getNextChip(draggedElement) {
-        let nextChip = draggedElement.nextElementSibling;
-        if (nextChip && nextChip.matches('.k-chip')) {
-            return nextChip;
-        }
-        while (nextChip) {
-            nextChip = nextChip.nextElementSibling;
-            if (nextChip === null || nextChip.matches('.k-chip')) {
-                return nextChip;
-            }
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DropTargetDirective, deps: [{ token: i0.ElementRef }, { token: i1.ConfiguratorService }, { token: i2.DropCueService }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DropTargetDirective, isStandalone: true, selector: "[kendoDropTarget]", inputs: { item: "item", axes: "axes" }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DropTargetDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoDropTarget]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.ConfiguratorService }, { type: i2.DropCueService }, { type: i0.Renderer2 }, { type: i0.NgZone }], propDecorators: { item: [{
-                type: Input
-            }], axes: [{
-                type: Input
-            }] } });

package/esm2022/data-binding/base-binding-directive.mjs

@@ -1,164 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Directive, EventEmitter, Input, NgZone, Output } from '@angular/core';
-import { PivotGridDataService } from './pivotgrid-data.service';
-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";
-/**
- * @hidden
- * A directive which binds the PivotGrid to an array of objects.
- */
-export class PivotBaseBindingDirective {
-    dataService;
-    zone;
-    /**
-     * Defines the column axes configuration of the PivotGrid.
-     */
-    columnAxes = [];
-    /**
-     * Defines the row axes configuration of the PivotGrid.
-     */
-    rowAxes = [];
-    /**
-     * Defines the measure axes configuration of the PivotGrid.
-     */
-    measureAxes = [];
-    /**
-     * Sets the initial sorted state of the PivotGrid.
-     */
-    sort = [];
-    /**
-     * Sets the initial filtered state of the PivotGrid.
-     */
-    filter;
-    /**
-     * Fires each time a row or column header gets expanded or collapsed by the user.
-     *
-     * The event is preventable. If you prevent the event, the PivotGrid will not rerender with the new state that results from the user interaction.
-     */
-    expandChange = new EventEmitter();
-    /**
-     * Fires when the Configurator **Apply** button is pressed.
-     *
-     * The event is preventable. If you prevent the event, the PivotGrid will not rerender with the new state that results from the configuration changes.
-     */
-    configurationChange = new EventEmitter();
-    /**
-     * Fires each time new data is loaded and transformed to show aggregated values.
-     *
-     * The event fires upon initialization and on user interaction that changes the state of the PivotGrid.
-     */
-    dataLoaded = new EventEmitter();
-    dataState;
-    configuratorFields;
-    subs = new Subscription();
-    constructor(dataService, zone) {
-        this.dataService = dataService;
-        this.zone = zone;
-    }
-    ngOnInit() {
-        this.dataService.state = new PivotGridState(this.columnAxes, this.rowAxes, this.measureAxes, this.sort, this.filter);
-        this.loadData(this.dataService.state);
-        this.loadFields();
-        this.subs.add(this.dataService.expandedStateChange.subscribe((state) => {
-            this.zone.run(() => {
-                const isCol = state.tableType === 'columnHeader';
-                const axes = isCol ? 'columnAxes' : 'rowAxes';
-                // Converts current rows state to a tree-like structure (using the PivotGrid Common pkg)
-                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(this.dataService.state);
-                this.loadData(state);
-                this.dataService.state = state;
-                this.rowAxes = this.dataService.state.rowAxes;
-                this.columnAxes = this.dataService.state.columnAxes;
-            });
-        }));
-        this.subs.add(this.dataService.valuesRows.subscribe((data) => {
-            this.zone.run(() => {
-                this.dataService.aggregateData = data;
-                this.dataLoaded.emit(data);
-            });
-        }));
-        this.dataService.directive = this;
-    }
-    ngOnDestroy() {
-        this.subs.unsubscribe();
-    }
-    updateDataServiceFields() {
-        this.dataService.normalizedData = this.dataState.data;
-        this.dataService.rows = this.dataState.rows;
-        this.dataService.columns = this.dataState.columns;
-        this.dataService.updateRowsAndCols();
-    }
-    updateConfiguratorFields() {
-        this.dataService.fields.next(this.configuratorFields);
-        this.dataService.configuredFields.next(this.dataService.state);
-    }
-    updateHeaders(axes, tree, path) {
-        // Action to determine expand/collapse state
-        const action = {
-            type: HEADERS_ACTION.toggle,
-            payload: path
-        };
-        // The `headersReducer` method is responsible for udpating
-        // the expanded state based on the toggle action (expand/collapse)
-        // Update axes and reload data
-        const newHeaders = headersReducer(this[axes].slice(), { ...action, tree });
-        const newState = { ...this.dataService.state, ...{ [axes]: newHeaders } };
-        this.dataService.state = newState;
-        if (hasObservers(this.expandChange)) {
-            const event = new ExpandChangeEvent(newState);
-            this.expandChange.emit(event);
-            if (event.isDefaultPrevented()) {
-                return;
-            }
-        }
-        this.dataService.configuredFields.next(this.dataService.state);
-        this[axes] = newHeaders;
-        this.loadData(this.dataService.state);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PivotBaseBindingDirective, deps: [{ token: i1.PivotGridDataService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: PivotBaseBindingDirective, selector: "kendo-base-binding-directive", inputs: { columnAxes: "columnAxes", rowAxes: "rowAxes", measureAxes: "measureAxes", sort: "sort", filter: "filter" }, outputs: { expandChange: "expandChange", configurationChange: "configurationChange", dataLoaded: "dataLoaded" }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PivotBaseBindingDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'kendo-base-binding-directive'
-                }]
-        }], ctorParameters: () => [{ type: i1.PivotGridDataService }, { type: i0.NgZone }], propDecorators: { columnAxes: [{
-                type: Input
-            }], rowAxes: [{
-                type: Input
-            }], measureAxes: [{
-                type: Input
-            }], sort: [{
-                type: Input
-            }], filter: [{
-                type: Input
-            }], expandChange: [{
-                type: Output
-            }], configurationChange: [{
-                type: Output
-            }], dataLoaded: [{
-                type: Output
-            }] } });