@progress/kendo-angular-grid 19.0.0-develop.11 → 19.0.0-develop.12

package/esm2022/index.mjs

@@ -147,6 +147,11 @@ export { ColumnStickyChangeEvent } from './column-menu/column-sticky-change-even
 export { SinglePopupService, PopupCloseEvent } from './common/single-popup.service';
 // Clipboard
 export { GridClipboardDirective } from './common/clipboard.directive';
+// State
+export * from './state-management/grid-state.models';
+export { UndoRedoDirective } from './state-management/undo-redo.directive';
+export { UndoCommandToolbarDirective } from './state-management/undo-command-tool';
+export { RedoCommandToolbarDirective } from './state-management/redo-command-tool';
 // addresses error NG3001: Unsupported private class
 export { ColumnMenuTemplateDirective } from './column-menu/column-menu-template.directive';
 export { EditCommandDirective } from './editing/edit-command.directive';

package/esm2022/package-metadata.mjs

@@ -10,7 +10,7 @@ export const packageMetadata = {
     productName: 'Kendo UI for Angular',
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1746798571,
-    version: '19.0.0-develop.11',
+    publishDate: 1747069795,
+    version: '19.0.0-develop.12',
     licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/'
 };

package/esm2022/rendering/cell.component.mjs

@@ -110,7 +110,7 @@ export class CellComponent {
     get isSpanColumn() {
         return isSpanColumn(this.column) && !this.column.templateRef;
     }
-    get childColumns() {
+    get children() {
         return columnsToRender([this.column]);
     }
     get isRowReorderColumn() {
@@ -183,7 +183,7 @@ export class CellComponent {
                         [ngTemplateOutletContext]="templateContext">
                     </ng-template>
                     <ng-container *ngIf="isSpanColumn">
-                        <ng-container *ngFor="let childColumn of childColumns">
+                        <ng-container *ngFor="let childColumn of children">
                             {{ dataItem | valueOf: childColumn.field: childColumn.format}}
                         </ng-container>
                     </ng-container>
@@ -275,7 +275,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                         [ngTemplateOutletContext]="templateContext">
                     </ng-template>
                     <ng-container *ngIf="isSpanColumn">
-                        <ng-container *ngFor="let childColumn of childColumns">
+                        <ng-container *ngFor="let childColumn of children">
                             {{ dataItem | valueOf: childColumn.field: childColumn.format}}
                         </ng-container>
                     </ng-container>

package/esm2022/rendering/header/header.component.mjs

@@ -433,7 +433,7 @@ export class HeaderComponent {
             const arr = this.dropTargets.toArray();
             const firstSpan = arr.find(t => t.context.column.parent === parent);
             const index = arr.indexOf(firstSpan);
-            const adjust = e.before ? 0 : parent.childColumns.length - 1;
+            const adjust = e.before ? 0 : parent.children.length - 1;
             target = arr[index + adjust];
         }
         return mergeObjects(e, { target });

package/esm2022/rendering/list.component.mjs

@@ -616,7 +616,7 @@ export class ListComponent {
         for (let idx = 0; idx < leafColumns.length; idx++) {
             const column = leafColumns[idx];
             if (column.isSpanColumn) {
-                viewportEnd += column.childColumns.length;
+                viewportEnd += column.children.length;
             }
         }
         this.navigationService.setColumnViewport(viewportStart, viewportEnd);

package/esm2022/rendering/table-body.component.mjs

@@ -348,7 +348,7 @@ export class TableBodyComponent {
     }
     get footerColumns() {
         const colsToRender = Array.from(this.columns).reduce((cols, col) => {
-            const newCols = (col instanceof SpanColumnComponent) ? Array.from(col.childColumns) : [col];
+            const newCols = (col instanceof SpanColumnComponent) ? Array.from(col.children) : [col];
             return [...cols, ...newCols];
         }, []);
         return colsToRender;

package/esm2022/state-management/grid-state.models.mjs

@@ -0,0 +1,26 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { PreventableEvent } from "@progress/kendo-angular-common";
+/**
+ * Arguments for the `undo` and `redo` events.
+ */
+export class UndoRedoEvent extends PreventableEvent {
+    /**
+     * The event data of the original action that triggered the state change.
+     */
+    originalEvent;
+    /**
+     * The grid state and rendered data at the time of the action.
+     */
+    gridState;
+    /**
+     * @hidden
+     */
+    constructor({ originalEvent, gridState }) {
+        super();
+        this.originalEvent = originalEvent;
+        this.gridState = gridState;
+    }
+}

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;
+    }
+}