@progress/kendo-angular-grid 17.0.0-develop.8 → 17.0.0

package/{esm2020 → esm2022}/columns/span-column.component.mjs

@@ -39,27 +39,40 @@ export function isSpanColumnComponent(column) {
  * ```
  */
 export class SpanColumnComponent extends ColumnBase {
-    constructor(parent, idService) {
-        super(parent, idService);
-        /*
-         * @hidden
-         */
-        this.isSpanColumn = true;
-        this.template = new QueryList();
-        this.editTemplate = new QueryList();
-        /**
-         * @hidden
-         */
-        this.childColumns = new QueryList();
-        /**
-         * @hidden
-         */
-        this.includeInChooser = false;
-        this._editable = true;
-        if (parent && parent.isSpanColumn) {
-            throw new Error(ColumnConfigurationErrorMessages.nestedInside('SpanColumnComponent', 'SpanColumnComponent'));
-        }
-    }
+    /*
+     * @hidden
+     */
+    isSpanColumn = true;
+    template = new QueryList();
+    editTemplate = new QueryList();
+    /**
+     * @hidden
+     */
+    childColumns = new QueryList();
+    /**
+     * @hidden
+     */
+    title;
+    /**
+     * @hidden
+     */
+    headerStyle;
+    /**
+     * @hidden
+     */
+    footerStyle;
+    /**
+     * @hidden
+     */
+    headerClass;
+    /**
+     * @hidden
+     */
+    footerClass;
+    /**
+     * @hidden
+     */
+    includeInChooser = false;
     /**
      * Defines whether the edit template of the column will be rendered.
      * To enable the editing functionality for a spanned column, set an edit template for it ([see example](slug:custom_reactive_editing_grid)).
@@ -86,6 +99,13 @@ export class SpanColumnComponent extends ColumnBase {
     get leafIndex() {
         return this.childColumns.first.leafIndex;
     }
+    _editable = true;
+    constructor(parent, idService) {
+        super(parent, idService);
+        if (parent && parent.isSpanColumn) {
+            throw new Error(ColumnConfigurationErrorMessages.nestedInside('SpanColumnComponent', 'SpanColumnComponent'));
+        }
+    }
     /**
      * @hidden
      */
@@ -122,15 +142,15 @@ export class SpanColumnComponent extends ColumnBase {
     get hasChildren() {
         return this.childColumns.length > 0;
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SpanColumnComponent, deps: [{ token: i1.ColumnBase, host: true, optional: true, skipSelf: true }, { token: i2.IdService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: SpanColumnComponent, isStandalone: true, selector: "kendo-grid-span-column", inputs: { editable: "editable", locked: "locked" }, providers: [
+            {
+                provide: ColumnBase,
+                useExisting: forwardRef(() => SpanColumnComponent)
+            }
+        ], queries: [{ propertyName: "template", predicate: CellTemplateDirective }, { propertyName: "editTemplate", predicate: EditTemplateDirective }, { propertyName: "childColumns", predicate: ColumnComponent }], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
 }
-SpanColumnComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SpanColumnComponent, deps: [{ token: i1.ColumnBase, host: true, optional: true, skipSelf: true }, { token: i2.IdService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-SpanColumnComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: SpanColumnComponent, isStandalone: true, selector: "kendo-grid-span-column", inputs: { editable: "editable", locked: "locked" }, providers: [
-        {
-            provide: ColumnBase,
-            useExisting: forwardRef(() => SpanColumnComponent)
-        }
-    ], queries: [{ propertyName: "template", predicate: CellTemplateDirective }, { propertyName: "editTemplate", predicate: EditTemplateDirective }, { propertyName: "childColumns", predicate: ColumnComponent }], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SpanColumnComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SpanColumnComponent, decorators: [{
             type: Component,
             args: [{
                     providers: [

package/esm2022/common/clipboard.directive.mjs

@@ -0,0 +1,190 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2024 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, Renderer2, isDevMode } from '@angular/core';
+import { ClipboardService } from './clipboard.service';
+import { GridComponent } from '../grid.component';
+import { hasObservers, isDocumentAvailable } from '@progress/kendo-angular-common';
+import { Subscription } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { closest, contains } from '../rendering/common/dom-queries';
+import { recursiveFlatMap } from '../utils';
+import { ClipboardErrorMessages } from './error-messages';
+import * as i0 from "@angular/core";
+import * as i1 from "../grid.component";
+import * as i2 from "./clipboard.service";
+/**
+ * The directive that enables the Grid built-in clipboard support. Allows copy, cut, and paste interactions
+ * with the Grid.
+ */
+export class GridClipboardDirective {
+    host;
+    clipboardService;
+    renderer;
+    zone;
+    /**
+     * Determines the target of the clipboard operation ([see example]({% slug clipboard_grid %}#toc-clipboard-target)). The possible options are:
+     * - `activeCell`
+     * - `selection`
+     *
+     * @default 'selection'
+     */
+    set clipboardTarget(value) {
+        if (isDevMode()) {
+            this.zone.onStable.pipe(take(1)).subscribe(() => {
+                if (value === 'activeCell' && !(this.host.navigable.length)) {
+                    console.warn(ClipboardErrorMessages.clipboardTarget.activeCellNavigable);
+                }
+                else if (value === 'selection' && !(this.host.selectable || this.host.selectionDirective)) {
+                    console.warn(ClipboardErrorMessages.selectionSelectable);
+                }
+            });
+        }
+        this._target = value;
+    }
+    get clipboardTarget() {
+        return this._target;
+    }
+    /**
+     * The `GridClipboardDirective` settings.
+     *
+     * @default { wholeRow: false, copyHeaders: false copy: true, cut: true, paste: true }
+     */
+    set clipboardSettings(value) {
+        this._clipboardSettings = Object.assign({}, this._clipboardSettings, value);
+    }
+    get clipboardSettings() {
+        return this._clipboardSettings;
+    }
+    /**
+     * Fires when the user performs `cut`, `copy` or `paste` action within the Grid content area.
+     */
+    clipboard = new EventEmitter();
+    _target = 'selection';
+    _clipboardSettings = {
+        wholeRow: false,
+        copyHeaders: false,
+        copy: true,
+        cut: true,
+        paste: true
+    };
+    subs = new Subscription();
+    constructor(host, clipboardService, renderer, zone) {
+        this.host = host;
+        this.clipboardService = clipboardService;
+        this.renderer = renderer;
+        this.zone = zone;
+    }
+    ngAfterViewInit() {
+        if (!isDocumentAvailable()) {
+            return;
+        }
+        if (this.clipboardTarget === 'selection' && !(this.host.selectable || this.host.selectionDirective)) {
+            console.warn(ClipboardErrorMessages.selectionSelectable);
+        }
+        // needed due to the following issue in Chrome
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=1156117&q=focus%20programmatically%20paste&can=2
+        this.zone.runOutsideAngular(() => {
+            this.subs.add(this.renderer.listen(document, 'copy', (args) => this.onClipboard('copy', args)));
+            this.subs.add(this.renderer.listen(document, 'cut', (args) => this.onClipboard('cut', args)));
+            this.subs.add(this.renderer.listen(document, 'paste', (args) => this.onClipboard('paste', args)));
+        });
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+    onClipboard = (operationType, args) => {
+        if (!this.clipboardSettings[operationType] || !this.inGrid(args)) {
+            return;
+        }
+        const gridData = Array.isArray(this.host.data) ? this.host.data : this.host.data.data;
+        const gridDataItems = gridData.flatMap(recursiveFlatMap);
+        const selection = this.host.selection;
+        const selectionDirective = this.host.selectionDirective;
+        const targetType = this.clipboardTarget;
+        const isCellSelection = (this.host.selectable?.cell || selectionDirective.isCellSelectionMode);
+        let clipboardData = [];
+        switch (targetType) {
+            case 'activeCell':
+                {
+                    const targetCell = { ...this.host.activeCell };
+                    clipboardData = targetCell && [{ dataItem: targetCell.dataItem, dataRowIndex: targetCell.dataRowIndex, colIndex: targetCell.colIndex }];
+                }
+                break;
+            case 'selection':
+                {
+                    const identifier = selectionDirective.selectionKey;
+                    clipboardData = gridDataItems.flatMap((item, index) => {
+                        if (identifier) {
+                            const key = typeof identifier === 'string' ? item[identifier] : identifier({ index: index + this.host.skip, dataItem: item });
+                            return isCellSelection ?
+                                selection.some(s => s.itemKey === key) ? [{ dataItem: item, dataRowIndex: index + this.host.skip }] : [] :
+                                selection.indexOf(key) > -1 ? [{ dataItem: item, dataRowIndex: index + this.host.skip }] : [];
+                        }
+                        return isCellSelection ?
+                            selection.some(s => s.itemKey === index + this.host.skip) ? [{ dataItem: item, dataRowIndex: index + this.host.skip }] : [] :
+                            selection.indexOf(index + this.host.skip) > -1 ? [{ dataItem: item, dataRowIndex: index + this.host.skip }] : [];
+                    });
+                }
+                break;
+        }
+        const isPaste = operationType === 'paste';
+        const pastedData = args.clipboardData.getData('text');
+        const visibleCols = this.host.columns.toArray().filter(c => c.isVisible);
+        const data = isPaste ?
+            {
+                dataString: pastedData,
+                gridItems: this.clipboardService.getGridData(pastedData, visibleCols, this.clipboardTarget, clipboardData[0]?.dataRowIndex, {
+                    wholeRow: this.clipboardSettings.wholeRow,
+                    isCellSelection
+                })
+            } :
+            this.clipboardService.createClipboardData(clipboardData || [], visibleCols, {
+                wholeRow: this.clipboardSettings.wholeRow || (this.clipboardTarget === 'selection' && !isCellSelection),
+                target: this.clipboardTarget,
+                copyHeaders: this.clipboardSettings.copyHeaders,
+                operationType
+            });
+        !isPaste && navigator.clipboard.writeText(data.dataString);
+        if (hasObservers(this.clipboard)) {
+            this.zone.run(() => {
+                this.clipboard.emit({
+                    type: operationType,
+                    originalEvent: args,
+                    clipboardData: data.dataString,
+                    gridData: data.gridItems,
+                    target: {
+                        dataRowIndex: this.clipboardService.targetRowIndex,
+                        colField: this.clipboardService.targetColField,
+                        dataItem: clipboardData.find(item => item.dataRowIndex === this.clipboardService.targetRowIndex)?.dataItem
+                    }
+                });
+            });
+        }
+        this.clipboardService.targetColField = this.clipboardService.targetRowIndex = null;
+    };
+    inGrid = (args) => {
+        const target = document.activeElement.matches('.k-table-td') ? document.activeElement : args.target;
+        const inContentArea = closest(target, node => node.parentElement?.classList.contains('k-grid-container'));
+        const inHost = contains(this.host.wrapper.nativeElement, target);
+        return target && inHost && inContentArea;
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GridClipboardDirective, deps: [{ token: i1.GridComponent }, { token: i2.ClipboardService }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: GridClipboardDirective, isStandalone: true, selector: "[kendoGridClipboard]", inputs: { clipboardTarget: "clipboardTarget", clipboardSettings: "clipboardSettings" }, outputs: { clipboard: "clipboard" }, providers: [ClipboardService], exportAs: ["kendoGridClipboard"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GridClipboardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridClipboard]',
+                    exportAs: 'kendoGridClipboard',
+                    providers: [ClipboardService],
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GridComponent }, { type: i2.ClipboardService }, { type: i0.Renderer2 }, { type: i0.NgZone }]; }, propDecorators: { clipboardTarget: [{
+                type: Input
+            }], clipboardSettings: [{
+                type: Input
+            }], clipboard: [{
+                type: Output
+            }] } });

package/{esm2020 → esm2022}/common/clipboard.service.mjs

@@ -13,14 +13,11 @@ import * as i1 from "./provider.service";
  * @hidden
  */
 export class ClipboardService {
+    contextService;
+    targetColField;
+    targetRowIndex;
     constructor(contextService) {
         this.contextService = contextService;
-        this.itemToString = (item, cols) => {
-            if (!cols.length) {
-                return null;
-            }
-            return cols.map(col => item[col.field]).join(`\t`);
-        };
     }
     createClipboardData(data, columns, options) {
         let result = {
@@ -175,6 +172,12 @@ export class ClipboardService {
         });
         return items;
     }
+    itemToString = (item, cols) => {
+        if (!cols.length) {
+            return null;
+        }
+        return cols.map(col => item[col.field]).join(`\t`);
+    };
     groupSelection() {
         const selection = this.contextService.grid.selection;
         const groups = groupBy(selection, [{ field: 'itemKey' }])
@@ -210,9 +213,9 @@ export class ClipboardService {
         const headersRowData = cols.map(c => c.title || c.field).join(`\t`);
         return `${headersRowData}\r\n${initialData}`;
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClipboardService, deps: [{ token: i1.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClipboardService });
 }
-ClipboardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ClipboardService, deps: [{ token: i1.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
-ClipboardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ClipboardService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ClipboardService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClipboardService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.ContextService }]; } });

package/{esm2020 → esm2022}/common/column-info.service.mjs

@@ -12,13 +12,13 @@ const NO_STICKY = { left: '0px', right: '0px' };
  * @hidden
  */
 export class ColumnInfoService {
-    constructor() {
-        this.visibilityChange = new EventEmitter();
-        this.lockedChange = new EventEmitter();
-        this.stickyChange = new EventEmitter();
-        this.columnRangeChange = new EventEmitter();
-        this.columnsContainer = new ColumnsContainer(() => []);
-    }
+    visibilityChange = new EventEmitter();
+    lockedChange = new EventEmitter();
+    stickyChange = new EventEmitter();
+    columnRangeChange = new EventEmitter();
+    columnsContainer = new ColumnsContainer(() => []);
+    list;
+    stickyColumns;
     get lockedLeafColumns() {
         return this.columnsContainer.lockedLeafColumns;
     }
@@ -81,9 +81,9 @@ export class ColumnInfoService {
         this.stickyColumns = null;
         this.stickyChange.emit(columns);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnInfoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnInfoService });
 }
-ColumnInfoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ColumnInfoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ColumnInfoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ColumnInfoService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ColumnInfoService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnInfoService, decorators: [{
             type: Injectable
         }] });

package/esm2022/common/dom-events.service.mjs

@@ -0,0 +1,26 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2024 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class DomEventsService {
+    cellClick = new EventEmitter();
+    cellMousedown = new EventEmitter();
+    cellMouseup = new EventEmitter();
+    click = new EventEmitter();
+    keydown = new EventEmitter();
+    focus = new EventEmitter();
+    focusIn = new EventEmitter();
+    focusOut = new EventEmitter();
+    windowBlur = new EventEmitter();
+    paste = new EventEmitter();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DomEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DomEventsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DomEventsService, decorators: [{
+            type: Injectable
+        }] });

package/{esm2020 → esm2022}/common/error-messages.mjs

@@ -60,5 +60,8 @@ export const GridConfigurationErrorMessages = {
     groupBindingDirectives: `Using the "kendoGridGroupBinding" directive in combination with the "kendoGridExpandGroupBy" directive
         or the "isGroupExpanded" callback is not supported. To use grouping with the "kendoGridGroupBinding" directive,
         set the Grid "groupable" property to "true".`,
-    unsupportedMethod: (methodName, suggestedMethodName) => `Using ${methodName} in this context is not supported. Use ${suggestedMethodName} instead.`
+    unsupportedMethod: (methodName, suggestedMethodName) => `Using ${methodName} in this context is not supported. Use ${suggestedMethodName} instead.`,
+    unsupportedToolbarConfig: `
+        Defining both a toolbar template and a ToolBarComponent within the Grid is not supported.
+        Please use either the ToolBarComponent or a custom template.`
 };

package/{esm2020 → esm2022}/common/event-emitter.mjs

@@ -7,6 +7,7 @@ import { EventEmitter } from "@angular/core";
  * @hidden
  */
 export class ZoneAwareEventEmitter extends EventEmitter {
+    ngZone;
     constructor(ngZone, isAsync = false) {
         super(isAsync);
         this.ngZone = ngZone;

package/{esm2020 → esm2022}/common/id.service.mjs

@@ -10,6 +10,7 @@ let sequence = 0;
  * @hidden
  */
 export class IdService {
+    prefix;
     constructor() {
         this.prefix = `k-grid${sequence++}`;
     }
@@ -25,9 +26,9 @@ export class IdService {
     selectAllCheckboxId() {
         return `${this.prefix}-select-all`;
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IdService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IdService });
 }
-IdService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: IdService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-IdService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: IdService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: IdService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IdService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return []; } });

package/{esm2020 → esm2022}/common/preventable-event.mjs

@@ -6,9 +6,7 @@
  * @hidden
  */
 export class PreventableEvent {
-    constructor() {
-        this.prevented = false;
-    }
+    prevented = false;
     /**
      * Prevents the default action for a specified event.
      * In this way, the source component suppresses

package/{esm2020 → esm2022}/common/provider.service.mjs

@@ -17,15 +17,22 @@ import * as i1 from "@progress/kendo-angular-l10n";
  * and a avoids dependency cycles between components.
  */
 export class ContextService {
+    renderer;
+    localization;
+    grid;
+    topToolbarNavigation;
+    bottomToolbarNavigation;
+    navigable;
+    groupBindingDirective;
     constructor(renderer, localization) {
         this.renderer = renderer;
         this.localization = localization;
         this.topToolbarNavigation = new GridToolbarNavigationService(this.renderer);
         this.bottomToolbarNavigation = new GridToolbarNavigationService(this.renderer);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContextService, deps: [{ token: i0.Renderer2 }, { token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContextService });
 }
-ContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ContextService, deps: [{ token: i0.Renderer2 }, { token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Injectable });
-ContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ContextService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ContextService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ContextService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i1.LocalizationService }]; } });

package/{esm2020 → esm2022}/common/single-popup.service.mjs

@@ -28,6 +28,10 @@ const contains = (node, predicate) => {
  * Arguments for the `close` event of the filter and column-menu popup.
  */
 export class PopupCloseEvent extends PreventableEvent {
+    /**
+     * The original DOM event that causes the popup to close.
+     */
+    originalEvent;
     constructor(e) {
         super();
         this.originalEvent = e;
@@ -39,6 +43,20 @@ const DEFAULT_POPUP_CLASS = 'k-grid-filter-popup';
  * ([see example]({% slug filter_menu %}#toc-filter-menu-with-popup)).
  */
 export class SinglePopupService {
+    popupService;
+    renderer;
+    ngZone;
+    ctx;
+    /**
+     * Fires when the filter or column menus are about to close because the user clicked outside their popups.
+     * Used to prevent the popup from closing.
+     */
+    onClose = new Subject();
+    removeClick;
+    pointerEventsSub = new Subscription();
+    popupRef;
+    scrollSubscription;
+    canClosePopup = true;
     /**
      * @hidden
      */
@@ -47,13 +65,6 @@ export class SinglePopupService {
         this.renderer = renderer;
         this.ngZone = ngZone;
         this.ctx = ctx;
-        /**
-         * Fires when the filter or column menus are about to close because the user clicked outside their popups.
-         * Used to prevent the popup from closing.
-         */
-        this.onClose = new Subject();
-        this.pointerEventsSub = new Subscription();
-        this.canClosePopup = true;
         this.scrollSubscription = scrollSyncService.changes.pipe(skip(1)).subscribe(() => this.destroy());
     }
     /**
@@ -130,9 +141,9 @@ export class SinglePopupService {
             }));
         });
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SinglePopupService, deps: [{ token: i1.PopupService }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i2.ScrollSyncService }, { token: i3.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SinglePopupService });
 }
-SinglePopupService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SinglePopupService, deps: [{ token: i1.PopupService }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i2.ScrollSyncService }, { token: i3.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
-SinglePopupService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SinglePopupService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SinglePopupService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SinglePopupService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.PopupService }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i2.ScrollSyncService }, { type: i3.ContextService }]; } });

package/{esm2020 → esm2022}/common/sort.service.mjs

@@ -7,9 +7,7 @@ import { Subject } from 'rxjs';
  * @hidden
  */
 export class SortService {
-    constructor() {
-        this.changes = new Subject();
-    }
+    changes = new Subject();
     sort(value) {
         this.changes.next(value);
     }

package/{esm2020 → esm2022}/data/change-notification.service.mjs

@@ -9,9 +9,11 @@ import * as i0 from "@angular/core";
  * @hidden
  */
 export class ChangeNotificationService {
+    ngZone;
+    changes = new EventEmitter();
+    subscription;
     constructor(ngZone) {
         this.ngZone = ngZone;
-        this.changes = new EventEmitter();
     }
     notify() {
         if (!this.subscription || this.subscription.closed) {
@@ -20,9 +22,9 @@ export class ChangeNotificationService {
                 .subscribe(() => this.changes.emit());
         }
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChangeNotificationService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChangeNotificationService });
 }
-ChangeNotificationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ChangeNotificationService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-ChangeNotificationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ChangeNotificationService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ChangeNotificationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ChangeNotificationService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });

package/{esm2020 → esm2022}/data/data.collection.mjs

@@ -8,6 +8,10 @@ import { getIterator, itemAt } from './data.iterators';
  * @hidden
  */
 export class DataResultIterator {
+    source;
+    skip;
+    groupFooters;
+    isObject;
     constructor(source, skip = 0, groupFooters = false) {
         this.source = source;
         this.skip = skip;
@@ -52,6 +56,7 @@ export class DataResultIterator {
  * @hidden
  */
 export class DataCollection {
+    accessor;
     constructor(accessor) {
         this.accessor = accessor;
     }

package/{esm2020 → esm2022}/data/data.iterators.mjs

@@ -42,6 +42,8 @@ export const getIterator = (data, { footers, level, dataIndex, parentGroupIndex,
     return new ItemIterator(data, dataIndex, parentGroupIndex, parentGroup);
 };
 class ArrayIterator {
+    arr;
+    idx;
     constructor(arr, idx = 0) {
         this.arr = arr;
         this.idx = idx;
@@ -61,6 +63,9 @@ class ArrayIterator {
  * @hidden
  */
 export class Iterator {
+    dataIndex;
+    resultMap;
+    _innerIterator;
     constructor(arr, dataIndex = 0, resultMap = (x) => x) {
         this.dataIndex = dataIndex;
         this.resultMap = resultMap;
@@ -107,6 +112,17 @@ const prefix = (s, n) => {
  * @hidden
  */
 export class GroupIterator {
+    arr;
+    outputFooters;
+    level;
+    dataIndex;
+    parentIndex;
+    groupIndex;
+    parentGroup;
+    current;
+    _innerIterator;
+    _iterator;
+    currentGroupIndex = "";
     constructor(arr, outputFooters = false, level = 0, dataIndex = 0, parentIndex = '', groupIndex = 0, parentGroup = undefined) {
         this.arr = arr;
         this.outputFooters = outputFooters;
@@ -115,7 +131,6 @@ export class GroupIterator {
         this.parentIndex = parentIndex;
         this.groupIndex = groupIndex;
         this.parentGroup = parentGroup;
-        this.currentGroupIndex = "";
         this.arr = arr || [];
         this._iterator = new Iterator(this.arr, this.dataIndex);
     }