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

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

@@ -1,249 +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, 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 } from 'rxjs/operators';
-import { UndoRedoService } from './undo-redo.service';
-import { hasObservers, isPresent } from '@progress/kendo-angular-common';
-import { ChangeNotificationService } from '../data/change-notification.service';
-import { ContextService } from '../common/provider.service';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { recursiveFlatMap } from '../utils';
-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";
-import * as i5 from "../common/provider.service";
-import * as i6 from "../editing/local-data-changes.service";
-/**
- * Represents the directive that manages undo-redo operations in the Grid.
- * Use this directive to enable undo and redo functionality for user actions in the Grid.
- *
- * @example
- * ```html
- * <kendo-grid [data]="data" kendoGridUndoRedo></kendo-grid>
- * ```
- * @remarks
- * Applied to: {@link GridComponent}.
- */
-export class UndoRedoDirective {
-    host;
-    editService;
-    undoRedoService;
-    changeNotification;
-    ctx;
-    localDataChangesService;
-    /**
-     * Sets the maximum number of actions to keep in the undo-redo stack.
-     * @default 10
-     */
-    maxStoredStates = 10;
-    /**
-     * Defines the property name of the data item unique key that will be used to identify the items when performing undo-redo actions.
-     */
-    itemIdKey;
-    /**
-     * Fires when you perform the undo action. Provides the Grid state to apply.
-     */
-    onUndo = new EventEmitter();
-    /**
-     * Fires when you perform the redo action. Provides the Grid state to apply.
-     */
-    onRedo = new EventEmitter();
-    /**
-     * Returns all undo-redo actions currently in the stack.
-     */
-    get undoRedoItems() {
-        return this.stack.toArray();
-    }
-    stack;
-    subs = new Subscription();
-    addToState = true;
-    constructor(host, editService, undoRedoService, changeNotification, ctx, localDataChangesService) {
-        this.host = host;
-        this.editService = editService;
-        this.undoRedoService = undoRedoService;
-        this.changeNotification = changeNotification;
-        this.ctx = ctx;
-        this.localDataChangesService = localDataChangesService;
-        this.host.undoRedoService = this.undoRedoService;
-    }
-    ngOnInit() {
-        this.stack = new UndoRedoStack(this.maxStoredStates);
-        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: 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'))
-            .subscribe(event => {
-            this.stack.add({
-                originalEvent: { ...event, dataItem: structuredClone(event.dataItem) },
-                gridState: 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(() => {
-            if (!this.ctx.dataBindingDirective) {
-                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;
-                }
-                let eventData;
-                if (action === 'Undo') {
-                    const isSaveOrRemove = this.stack.current.originalEvent.action === 'save' || this.stack.current.originalEvent.action === 'remove';
-                    eventData = isSaveOrRemove ? this.stack.current : this.stack.peekPrev();
-                }
-                else {
-                    eventData = this.stack.peekNext();
-                }
-                const event = new UndoRedoEvent(eventData);
-                if (hasObservers(this[`on${action}`])) {
-                    this[`on${action}`].emit(event);
-                    if (event.isDefaultPrevented()) {
-                        return;
-                    }
-                }
-                this.stack[`${action.toLowerCase()}`]();
-                this.updateUndoRedoDisabled();
-                const originalAction = event.originalEvent.action;
-                const isLocalData = isPresent(this.ctx?.dataBindingDirective);
-                if (!isLocalData) {
-                    return;
-                }
-                const isSaveOrRemove = originalAction === 'save' || originalAction === 'remove';
-                if (isSaveOrRemove) {
-                    if (originalAction === 'save') {
-                        const stateItem = this.getGridDataItems(this.stack.current.gridState.currentData).find(item => item[this.itemIdKey] === event.originalEvent.dataItem[this.itemIdKey]);
-                        this.localDataChangesService?.data.splice(event.originalEvent.rowIndex, 1, stateItem);
-                    }
-                    else if (action === 'Undo') {
-                        this.localDataChangesService?.data.splice(event.originalEvent.rowIndex, 0, event.originalEvent.dataItem);
-                    }
-                    else {
-                        this.localDataChangesService?.data.splice(event.originalEvent.rowIndex, 1);
-                    }
-                    this.localDataChangesService?.changes.emit();
-                }
-                else {
-                    this.host.loadState({ ...this.stack.current.gridState, currentData: null });
-                    if (this.isDataStateChangeEvent(event.originalEvent)) {
-                        const { skip, take, sort, filter, group } = event.gridState;
-                        this.host.dataStateChange.emit({ skip, take, sort, filter, group });
-                    }
-                }
-            }));
-        });
-    }
-    ngAfterViewInit() {
-        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: this.host.currentState
-        });
-    }
-    ngOnDestroy() {
-        this.stack.clear();
-        this.stack = null;
-        this.subs.unsubscribe();
-    }
-    /**
-     * Re-applies the last action that you reverted with 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 that you performed.
-     */
-    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);
-    }
-    getGridDataItems(data) {
-        return Array.isArray(data) ? data.flatMap(recursiveFlatMap) :
-            data.data.flatMap(recursiveFlatMap);
-    }
-    isDataStateChangeEvent(event) {
-        return event && ['skip', 'take', 'sort', 'filter', 'group'].some(prop => prop in event);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UndoRedoDirective, deps: [{ token: i1.GridComponent }, { token: i2.EditService }, { token: i3.UndoRedoService }, { token: i4.ChangeNotificationService }, { token: i5.ContextService }, { token: i6.LocalDataChangesService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: UndoRedoDirective, isStandalone: true, selector: "[kendoGridUndoRedo]", inputs: { maxStoredStates: "maxStoredStates", itemIdKey: "itemIdKey" }, outputs: { onUndo: "undo", onRedo: "redo" }, providers: [UndoRedoService], exportAs: ["kendoGridUndoRedo"], ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UndoRedoDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridUndoRedo]',
-                    standalone: true,
-                    exportAs: 'kendoGridUndoRedo',
-                    providers: [UndoRedoService]
-                }]
-        }], ctorParameters: () => [{ type: i1.GridComponent }, { type: i2.EditService }, { type: i3.UndoRedoService }, { type: i4.ChangeNotificationService }, { type: i5.ContextService }, { type: i6.LocalDataChangesService }], propDecorators: { maxStoredStates: [{
-                type: Input
-            }], itemIdKey: [{
-                type: Input
-            }], onUndo: [{
-                type: Output,
-                args: ['undo']
-            }], onRedo: [{
-                type: Output,
-                args: ['redo']
-            }] } });

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

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

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

@@ -1,238 +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 { 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;
-    }
-    peekNext() {
-        return this.currentNode.next?.state || null;
-    }
-    peekPrev() {
-        return this.currentNode.previous?.state || null;
-    }
-    /**
-     * 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;
-    }
-}