@progress/kendo-angular-grid 19.0.0-develop.3 → 19.0.0-develop.31

package/esm2022/state-management/redo-command-tool.mjs

@@ -0,0 +1,66 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive } from '@angular/core';
+import { ToolBarButtonComponent } from '@progress/kendo-angular-toolbar';
+import { Subscription } from 'rxjs';
+import { redoIcon } from '@progress/kendo-svg-icons';
+import { UndoRedoService } from './undo-redo.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./undo-redo.service";
+import * as i2 from "@progress/kendo-angular-toolbar";
+/**
+ * Represents the command for triggering the redo action in the Grid.
+ * You can apply this directive to any `kendo-toolbar-button` element inside a
+ * ToolbarComponent used in the Grid.
+ *
+ * When the user clicks the toolbar button that is associated with the directive, the
+ * [redo]({% slug api_grid_undoredodirective %}#toc-redo) event is triggered.
+ *
+ * @example
+ * ```html-no-run
+ * <kendo-grid>
+ *      <kendo-toolbar>
+ *         <kendo-toolbar-button kendoGridRedoTool></kendo-toolbar-button>
+ *      </kendo-toolbar>
+ * </kendo-grid>
+ * ```
+ */
+export class RedoCommandToolbarDirective {
+    undoRedoService;
+    host;
+    subs = new Subscription();
+    constructor(undoRedoService, host) {
+        this.undoRedoService = undoRedoService;
+        this.host = host;
+    }
+    ngOnInit() {
+        this.subs = this.host.click.subscribe(e => this.onClick(e));
+        this.host.className = 'k-grid-redo-command';
+        this.host.svgIcon = redoIcon;
+        this.host.icon = 'redo';
+        this.host.text = 'Redo';
+        this.host.disabled = true;
+        this.subs.add(this.undoRedoService.stackEndReached.subscribe((stackEnd) => this.host.disabled = stackEnd === 'end'));
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+    /**
+     * @hidden
+     */
+    onClick(e) {
+        e.preventDefault();
+        this.undoRedoService.onRedo.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RedoCommandToolbarDirective, deps: [{ token: i1.UndoRedoService }, { token: i2.ToolBarButtonComponent }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: RedoCommandToolbarDirective, isStandalone: true, selector: "[kendoGridRedoTool]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RedoCommandToolbarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridRedoTool]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UndoRedoService }, { type: i2.ToolBarButtonComponent }]; } });

package/esm2022/state-management/undo-command-tool.mjs

@@ -0,0 +1,66 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive } from '@angular/core';
+import { ToolBarButtonComponent } from '@progress/kendo-angular-toolbar';
+import { Subscription } from 'rxjs';
+import { undoIcon } from '@progress/kendo-svg-icons';
+import { UndoRedoService } from './undo-redo.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./undo-redo.service";
+import * as i2 from "@progress/kendo-angular-toolbar";
+/**
+ * Represents the command for triggering the undo action in the Grid.
+ * You can apply this directive to any `kendo-toolbar-button` element inside a
+ * ToolbarComponent used in the Grid.
+ *
+ * When the user clicks the toolbar button that is associated with the directive, the
+ * [undo]({% slug api_grid_undoredodirective %}#toc-undo) event is triggered.
+ *
+ * @example
+ * ```html-no-run
+ * <kendo-grid>
+ *      <kendo-toolbar>
+ *         <kendo-toolbar-button kendoGridUndoTool></kendo-toolbar-button>
+ *      </kendo-toolbar>
+ * </kendo-grid>
+ * ```
+ */
+export class UndoCommandToolbarDirective {
+    undoRedoService;
+    host;
+    subs = new Subscription();
+    constructor(undoRedoService, host) {
+        this.undoRedoService = undoRedoService;
+        this.host = host;
+    }
+    ngOnInit() {
+        this.subs = this.host.click.subscribe(e => this.onClick(e));
+        this.host.className = 'k-grid-undo-command';
+        this.host.svgIcon = undoIcon;
+        this.host.icon = 'undo';
+        this.host.text = 'Undo';
+        this.host.disabled = true;
+        this.subs.add(this.undoRedoService.stackEndReached.subscribe((stackEnd) => this.host.disabled = stackEnd === 'start'));
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+    /**
+     * @hidden
+     */
+    onClick(e) {
+        e.preventDefault();
+        this.undoRedoService.onUndo.next();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoCommandToolbarDirective, deps: [{ token: i1.UndoRedoService }, { token: i2.ToolBarButtonComponent }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: UndoCommandToolbarDirective, isStandalone: true, selector: "[kendoGridUndoTool]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoCommandToolbarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridUndoTool]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UndoRedoService }, { type: i2.ToolBarButtonComponent }]; } });

package/esm2022/state-management/undo-redo.directive.mjs

@@ -0,0 +1,178 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { UndoRedoStack } from './undo-redo.stack';
+import { GridComponent } from '../grid.component';
+import { UndoRedoEvent } from './grid-state.models';
+import { Subscription } from 'rxjs';
+import { EditService } from '../editing/edit.service';
+import { filter, tap } from 'rxjs/operators';
+import { UndoRedoService } from './undo-redo.service';
+import { hasObservers } from '@progress/kendo-angular-common';
+import { ChangeNotificationService } from '../data/change-notification.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../grid.component";
+import * as i2 from "../editing/edit.service";
+import * as i3 from "./undo-redo.service";
+import * as i4 from "../data/change-notification.service";
+export class UndoRedoDirective {
+    host;
+    editService;
+    undoRedoService;
+    changeNotification;
+    /**
+     * Determines the maximum number of actions to keep in the undo-redo stack.
+     * @default 10
+     */
+    maxStoredStates = 10;
+    /**
+     * Fires when undo action is performed. Exposes the state of the grid that will be applied.
+     */
+    onUndo = new EventEmitter();
+    /**
+     * Fires when undo action is performed. Exposes the state of the grid that will be applied.
+     */
+    onRedo = new EventEmitter();
+    /**
+     * Returns an array of all undo-redo actions that are currently in the stack.
+     */
+    get undoRedoItems() {
+        return this.stack.toArray();
+    }
+    stack;
+    subs = new Subscription();
+    addToState = true;
+    constructor(host, editService, undoRedoService, changeNotification) {
+        this.host = host;
+        this.editService = editService;
+        this.undoRedoService = undoRedoService;
+        this.changeNotification = changeNotification;
+        this.host.undoRedoService = this.undoRedoService;
+    }
+    ngOnInit() {
+        this.stack = new UndoRedoStack(this.maxStoredStates);
+        this.stack.add({
+            originalEvent: {
+                skip: this.host.skip,
+                take: this.host.pageSize,
+                sort: this.host.sort,
+                filter: this.host.filter,
+                group: this.host.group
+            }, gridState: structuredClone(this.host.currentState)
+        });
+        this.subs = this.host.gridStateChange.subscribe((state) => {
+            if (this.addToState) {
+                this.stack.add({
+                    originalEvent: {
+                        skip: state.skip,
+                        take: state.take,
+                        sort: state.sort,
+                        filter: state.filter,
+                        group: state.group
+                    },
+                    gridState: structuredClone(state)
+                });
+            }
+            let stackEndPointReached;
+            if (this.stack.canUndo) {
+                stackEndPointReached = this.stack.canRedo ? false : 'end';
+            }
+            else {
+                stackEndPointReached = 'start';
+            }
+            this.undoRedoService.stackEndReached.next(stackEndPointReached);
+        });
+        this.subs.add(this.editService.changes
+            .pipe(filter(event => event.action === 'save' || event.action === 'remove'), tap(event => this.undoRedoService.originalEvent = event))
+            .subscribe(event => {
+            this.stack.add({
+                originalEvent: event,
+                gridState: structuredClone(this.host.currentState)
+            });
+            this.addToState = false;
+            this.host.gridStateChange.emit(this.stack.current.gridState);
+            this.addToState = true;
+            this.updateUndoRedoDisabled();
+        }));
+        this.subs.add(this.changeNotification.changes.subscribe(() => this.stack.current.gridState = this.host.currentState));
+        ['Undo', 'Redo'].forEach((action) => {
+            this.subs.add(this.undoRedoService[`on${action}`].subscribe(() => {
+                if (!this.stack[`can${action}`]) {
+                    return;
+                }
+                this.stack[`${action.toLowerCase()}`]();
+                if (hasObservers(this[`on${action}`])) {
+                    const event = new UndoRedoEvent(this.stack.current);
+                    this[`on${action}`].emit(event);
+                    if (event.isDefaultPrevented()) {
+                        return;
+                    }
+                }
+                this.updateUndoRedoDisabled();
+                this.host.loadState(this.stack.current.gridState);
+            }));
+        });
+        this.subs.add(this.undoRedoService.setState.subscribe((state) => this.stack.add({ originalEvent: 'dataChange', gridState: state })));
+    }
+    ngOnDestroy() {
+        this.stack.clear();
+        this.stack = null;
+        this.subs.unsubscribe();
+    }
+    /**
+     * Re-applies the last action, reverted by the `undo` method.
+     */
+    redo() {
+        if (this.stack.canRedo) {
+            this.stack.redo();
+            this.host.loadState(this.stack.current.gridState);
+            if (!this.stack.canRedo) {
+                this.undoRedoService.stackEndReached.next('end');
+            }
+        }
+    }
+    /**
+     * Reverts the last user action.
+     */
+    undo() {
+        if (this.stack.canUndo) {
+            this.stack.undo();
+            this.host.loadState(this.stack.current.gridState);
+            if (!this.stack.canUndo) {
+                this.undoRedoService.stackEndReached.next('start');
+            }
+        }
+    }
+    updateUndoRedoDisabled() {
+        if (!this.stack.canRedo) {
+            this.undoRedoService.stackEndReached.next('end');
+            return;
+        }
+        if (!this.stack.canUndo) {
+            this.undoRedoService.stackEndReached.next('start');
+            return;
+        }
+        this.undoRedoService.stackEndReached.next(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoRedoDirective, deps: [{ token: i1.GridComponent }, { token: i2.EditService }, { token: i3.UndoRedoService }, { token: i4.ChangeNotificationService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: UndoRedoDirective, isStandalone: true, selector: "[kendoGridUndoRedo]", inputs: { maxStoredStates: "maxStoredStates" }, outputs: { onUndo: "undo", onRedo: "redo" }, providers: [UndoRedoService], exportAs: ["kendoGridUndoRedo"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoRedoDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridUndoRedo]',
+                    standalone: true,
+                    exportAs: 'kendoGridUndoRedo',
+                    providers: [UndoRedoService]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GridComponent }, { type: i2.EditService }, { type: i3.UndoRedoService }, { type: i4.ChangeNotificationService }]; }, propDecorators: { maxStoredStates: [{
+                type: Input
+            }], onUndo: [{
+                type: Output,
+                args: ['undo']
+            }], onRedo: [{
+                type: Output,
+                args: ['redo']
+            }] } });

package/esm2022/state-management/undo-redo.service.mjs

@@ -0,0 +1,22 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 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 { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class UndoRedoService {
+    originalEvent;
+    onUndo = new Subject();
+    onRedo = new Subject();
+    stackEndReached = new Subject();
+    setState = new Subject();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoRedoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoRedoService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UndoRedoService, decorators: [{
+            type: Injectable
+        }] });

package/esm2022/state-management/undo-redo.stack.mjs

@@ -0,0 +1,232 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { isPresent } from "@progress/kendo-angular-common";
+/**
+ * @hidden
+ * A linked-list based implementation of an undo-redo stack.
+ * Maintains a chain of states that can be navigated forward and backward.
+ */
+export class UndoRedoStack {
+    maxSize;
+    /** The current active node in the undo-redo history */
+    currentNode = null;
+    /** The root node of the stack (first state) */
+    rootNode = null;
+    /** Track the size of the stack */
+    _size = 0;
+    /**
+     * Creates a new UndoRedoStack.
+     * @param maxSize Optional maximum number of states to maintain (unlimited if not provided)
+     */
+    constructor(maxSize = -1) {
+        this.maxSize = maxSize;
+    }
+    /**
+     * Gets the current number of states in the stack
+     */
+    get size() {
+        return this._size;
+    }
+    /**
+     * Gets the current active state
+     */
+    get current() {
+        return this.currentNode ? this.currentNode.state : null;
+    }
+    /**
+     * Checks if undo is available (if there's a previous state)
+     */
+    get canUndo() {
+        return isPresent(this.currentNode?.previous);
+    }
+    /**
+     * Checks if redo is available (if there's a next state)
+     */
+    get canRedo() {
+        return isPresent(this.currentNode?.next);
+    }
+    /**
+     * Adds a new state to the undo-redo stack
+     * @param state The state to add
+     * @param id Optional identifier for the state
+     * @returns The newly created node
+     */
+    add(state, id) {
+        const newNode = {
+            state,
+            previous: this.currentNode,
+            next: null,
+            id
+        };
+        // If we have a current node, update its next reference
+        if (this.currentNode) {
+            // If we're adding after a node that already had a "next",
+            // we need to discard that branch of history
+            if (this.currentNode.next) {
+                this.truncateForward(this.currentNode);
+            }
+            this.currentNode.next = newNode;
+        }
+        else {
+            // This is the first node
+            this.rootNode = newNode;
+        }
+        this.currentNode = newNode;
+        this._size++;
+        // If we've exceeded the max size, remove oldest nodes
+        this.enforceMaxSize();
+        return newNode;
+    }
+    /**
+     * Finds a node by its identifier
+     * @param id The identifier to search for
+     * @returns The found node or null if not found
+     */
+    find(id) {
+        if (!this.rootNode) {
+            return null;
+        }
+        let node = this.rootNode;
+        while (node) {
+            if (node.id === id) {
+                return node;
+            }
+            node = node.next;
+        }
+        return null;
+    }
+    /**
+     * Removes a node by its identifier
+     * @param id The identifier of the node to remove
+     * @returns True if the node was found and removed, false otherwise
+     */
+    remove(id) {
+        const nodeToRemove = this.find(id);
+        if (!nodeToRemove) {
+            return false;
+        }
+        // Handle removal of current node
+        if (nodeToRemove === this.currentNode) {
+            this.currentNode = nodeToRemove.previous || nodeToRemove.next;
+        }
+        // Connect previous and next nodes
+        if (nodeToRemove.previous) {
+            nodeToRemove.previous.next = nodeToRemove.next;
+        }
+        else {
+            // Removing the root node
+            this.rootNode = nodeToRemove.next;
+        }
+        if (nodeToRemove.next) {
+            nodeToRemove.next.previous = nodeToRemove.previous;
+        }
+        // Clean up references to help garbage collection
+        nodeToRemove.previous = null;
+        nodeToRemove.next = null;
+        this._size--;
+        return true;
+    }
+    /**
+     * Performs an undo operation, moving to the previous state
+     * @returns The previous state or null if can't undo
+     */
+    undo() {
+        if (!this.canUndo) {
+            return null;
+        }
+        this.currentNode = this.currentNode.previous;
+        return this.currentNode.state;
+    }
+    /**
+     * Performs a redo operation, moving to the next state
+     * @returns The next state or null if can't redo
+     */
+    redo() {
+        if (!this.canRedo) {
+            return null;
+        }
+        this.currentNode = this.currentNode.next;
+        return this.currentNode.state;
+    }
+    /**
+     * Clears all history
+     */
+    clear() {
+        this.currentNode = null;
+        this.rootNode = null;
+        this._size = 0;
+    }
+    /**
+     * Removes all states after the specified node
+     * @param node The node to truncate from
+     * @returns The number of nodes removed
+     */
+    truncateForward(node) {
+        if (!node.next) {
+            return 0;
+        }
+        let removedCount = 0;
+        let currentNext = node.next;
+        while (currentNext) {
+            const temp = currentNext.next;
+            // Clean up references for garbage collection
+            currentNext.previous = null;
+            currentNext.next = null;
+            currentNext = temp;
+            removedCount++;
+        }
+        // Update the node's next pointer
+        node.next = null;
+        this._size -= removedCount;
+        return removedCount;
+    }
+    /**
+     * Ensures the stack doesn't exceed the maximum size by removing oldest nodes
+     */
+    enforceMaxSize() {
+        if (this.maxSize <= 0 || this._size <= this.maxSize) {
+            return;
+        }
+        let nodesToRemove = this._size - this.maxSize;
+        let currentNode = this.rootNode;
+        // Find the new root node
+        while (nodesToRemove > 0 && currentNode) {
+            currentNode = currentNode.next;
+            nodesToRemove--;
+        }
+        if (currentNode) {
+            // Disconnect from previous history
+            currentNode.previous = null;
+            // Update root node
+            this.rootNode = currentNode;
+            // Update size
+            this._size = this.maxSize;
+        }
+    }
+    /**
+     * Gets all states in the stack as an array (from oldest to newest)
+     */
+    toArray() {
+        const result = [];
+        let node = this.rootNode;
+        while (node) {
+            result.push(node.state);
+            node = node.next;
+        }
+        return result;
+    }
+    /**
+     * Gets the history nodes as an array (useful for debugging)
+     */
+    getNodes() {
+        const result = [];
+        let node = this.rootNode;
+        while (node) {
+            result.push(node);
+            node = node.next;
+        }
+        return result;
+    }
+}

package/esm2022/utils.mjs

@@ -3,7 +3,6 @@
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
 import { InjectionToken } from '@angular/core';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
 import { merge, of } from 'rxjs';
 export { isChanged, anyChanged, hasObservers } from '@progress/kendo-angular-common';
 const EMPTY_REGEX = /^\s*$/;
@@ -109,18 +108,6 @@ const wnd = typeof window !== 'undefined' ? window : {};
 export const requestAnimationFrame = wnd.requestAnimationFrame || wnd.msRequestAnimationFrame || (callback => setTimeout(callback, FRAME_DURATION));
 /** @hidden */
 export const cancelAnimationFrame = wnd.cancelAnimationFrame || wnd.msCancelRequestAnimationFrame || clearTimeout;
-/**
- * @hidden
- */
-export const detectIE = () => {
-    if (!isDocumentAvailable()) {
-        return;
-    }
-    const ua = window.navigator.userAgent;
-    const msie = ua.indexOf('MSIE ');
-    const trident = ua.indexOf('Trident/');
-    return msie > 0 || trident > 0;
-};
 /**
  * @hidden
  */
@@ -133,6 +120,19 @@ export const replaceMessagePlaceholder = (message, name, value) => (message ?? '
  * @hidden
  */
 export const recursiveFlatMap = (item) => isGroupResult(item) ? item.items.flatMap(recursiveFlatMap) : [{ ...item }];
+const mapColumnItemState = (c) => ({ id: c.id, width: c.width, hidden: c.hidden, locked: c.locked, sticky: c.sticky, orderIndex: c.orderIndex });
+/**
+ * @hidden
+ */
+export const updateColumnFromState = (columnState, c) => {
+    Object.keys(columnState).forEach((key) => c[key] = columnState[key]);
+};
+/**
+ * @hidden
+ */
+export const recursiveColumnsFlatMap = (item) => (item.isColumnGroup || item.isSpanColumn) ?
+    [mapColumnItemState(item), ...item.children.toArray().flatMap(recursiveColumnsFlatMap)] :
+    [mapColumnItemState(item)];
 /**
  * @hidden
  */

package/excel/excel-command-tool.directive.d.ts

@@ -2,8 +2,11 @@
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
+import { ChangeDetectorRef, NgZone } from '@angular/core';
 import { ToolBarButtonComponent } from '@progress/kendo-angular-toolbar';
 import { ExcelService } from './excel.service';
+import { ContextService } from '../common/provider.service';
+import { ToolbarToolBase } from '../common/toolbar-tool-base.directive';
 import * as i0 from "@angular/core";
 /**
  * Represents the `export-to-Excel` toolbar tool of the Grid.
@@ -25,13 +28,10 @@ import * as i0 from "@angular/core";
  * </kendo-grid>
  * ```
  */
-export declare class ExcelCommandToolbarDirective {
+export declare class ExcelCommandToolbarDirective extends ToolbarToolBase {
     private excelService;
-    private host;
-    private clickSub;
-    constructor(excelService: ExcelService, host: ToolBarButtonComponent);
+    constructor(excelService: ExcelService, host: ToolBarButtonComponent, ctx: ContextService, zone: NgZone, cdr: ChangeDetectorRef);
     ngOnInit(): void;
-    ngOnDestroy(): void;
     /**
      * @hidden
      */