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

package/esm2022/row-reordering/row-reorder.service.mjs

@@ -1,280 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { EventEmitter, Injectable, Output, Renderer2 } from '@angular/core';
-import { isDocumentAvailable, isPresent } from '@progress/kendo-angular-common';
-import { getOffset, isNextSibling, isPreviousSibling, dropPosition, hintIcons, hintSVGIcons, hintClasses, hintStyles, dropIndicatorClasses, dropIndicatorStyles, isDifferentParent, getDefaultSelectors } from './utils';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class RowReorderService {
-    renderer;
-    hintElement = null;
-    defaultSelectors = getDefaultSelectors;
-    hintText = '';
-    skip;
-    dropIndicator;
-    lastDropPosition = dropPosition.forbidden;
-    dragTarget = null;
-    dropTarget = null;
-    offsetY;
-    rowReorder = new EventEmitter();
-    constructor(renderer) {
-        this.renderer = renderer;
-    }
-    ngOnDestroy() {
-        this.destroyDropIndicator();
-        this.destroyHintElement();
-    }
-    press(ev) {
-        this.dragTarget = ev.dragTarget;
-        this.offsetY = ev.dragEvent.offsetY;
-    }
-    dragStart() {
-        this.createDropIndicator();
-    }
-    drag(ev) {
-        if (isPresent(ev.hintElement) && !isPresent(this.hintElement)) {
-            this.hintElement = ev.hintElement;
-            this.decorateHint();
-        }
-        const position = {
-            x: ev.dragEvent.clientX,
-            y: ev.dragEvent.clientY - this.offsetY
-        };
-        if (isPresent(this.hintElement)) {
-            this.renderer.setStyle(this.hintElement, 'left', `${position.x}px`);
-            this.renderer.setStyle(this.hintElement, 'top', `${position.y}px`);
-        }
-        this.positionDropIndicator(ev);
-    }
-    dragEnter(ev) {
-        this.dropTarget = ev.dropTarget;
-    }
-    dragLeave() {
-        this.dropTarget = null;
-        this.hide();
-    }
-    dragEnd() {
-        this.destroyDropIndicator();
-        this.destroyHintElement();
-        this.dragTarget = null;
-        this.dropTarget = null;
-        this.hintElement = null;
-    }
-    drop(ev) {
-        this.destroyDropIndicator();
-        this.destroyHintElement();
-        const rowReorderArgs = this.rowReorderArgs(this.dragTarget, this.dropTarget, ev.dragData);
-        this.rowReorder.emit(rowReorderArgs);
-    }
-    reorderRows(ev, collection) {
-        if (this.lastDropPosition === dropPosition.forbidden) {
-            return;
-        }
-        const { draggedRows, dropTargetRow } = ev;
-        const draggedDataItem = draggedRows[0].dataItem;
-        const dropTargetDataItem = dropTargetRow.dataItem;
-        const draggedItemIndex = collection.indexOf(draggedDataItem);
-        const dropTargetIndex = collection.indexOf(dropTargetDataItem);
-        const idxToAdd = this.calculateIndexToAdd(draggedItemIndex, dropTargetIndex);
-        collection.splice(draggedItemIndex, 1);
-        collection.splice(idxToAdd, 0, draggedDataItem);
-    }
-    get hintIcon() {
-        return hintIcons[this.lastDropPosition];
-    }
-    get hintSVGIcon() {
-        return hintSVGIcons[this.lastDropPosition];
-    }
-    getDefaultHintText(columns, data) {
-        let hintText = '';
-        const columnFieldsArray = columns
-            .toArray()
-            .filter(column => !column.hidden && isPresent(column.field))
-            .map(column => column.field);
-        const draggedDragRow = this.getDragRowPerElement(this.dragTarget, data);
-        const draggedDataItem = draggedDragRow?.dataItem;
-        isPresent(draggedDataItem) && columnFieldsArray.forEach(column => {
-            const columnValue = draggedDataItem[column];
-            if (isPresent(columnValue)) {
-                hintText += `${columnValue} `;
-            }
-        });
-        return hintText.trim();
-    }
-    getDraggedRow(data) {
-        return this.getDragRowPerElement(this.dragTarget, data);
-    }
-    /**
-     * Triggers row reordering programmatically via keyboard shortcut.
-     * @param dragRowIndex - The index of the row to move
-     * @param dropRowIndex - The index of the target row
-     * @param dropPosition - The position relative to the target row ('before' or 'after')
-     * @param data - The data array
-     */
-    reorderViaKeyboard(dragRowIndex, dropRowIndex, dropPosition, data) {
-        if (dropPosition === 'forbidden') {
-            return;
-        }
-        const dragRow = this.createVirtualRowElement(dragRowIndex);
-        const dropRow = this.createVirtualRowElement(dropRowIndex);
-        this.lastDropPosition = dropPosition;
-        const rowReorderArgs = this.rowReorderArgs(dragRow, dropRow, data);
-        this.rowReorder.emit(rowReorderArgs);
-    }
-    createVirtualRowElement(rowIndex) {
-        const virtualElement = {
-            getAttribute: (attr) => {
-                if (attr === 'data-kendo-grid-item-index') {
-                    return String(rowIndex);
-                }
-                return null;
-            }
-        };
-        return virtualElement;
-    }
-    rowReorderArgs(dragRow, dropRow, data) {
-        const dragRowData = this.getDragRowPerElement(dragRow, data);
-        const dropRowData = this.getDragRowPerElement(dropRow, data);
-        return {
-            draggedRows: [dragRowData],
-            dropTargetRow: dropRowData,
-            dropPosition: this.lastDropPosition
-        };
-    }
-    getDragRowPerElement(row, data) {
-        let rowIndex = row?.getAttribute('data-kendo-grid-item-index');
-        rowIndex = rowIndex ? parseInt(rowIndex, 10) : -1;
-        const skip = this.skip || 0;
-        const dataItem = rowIndex === -1 ? null : data[rowIndex - skip];
-        return {
-            dataItem,
-            rowIndex,
-            element: row
-        };
-    }
-    createDropIndicator() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        this.dropIndicator = document.createElement('div');
-        this.decorateDropIndicator();
-        this.dropIndicator.innerHTML = `
-            <div class="k-drop-hint-start"></div>
-            <div class="k-drop-hint-line"></div>
-        `;
-        document.body.appendChild(this.dropIndicator);
-        this.hide();
-    }
-    destroyDropIndicator() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        if (this.dropIndicator && this.dropIndicator.parentElement) {
-            document.body.removeChild(this.dropIndicator);
-            this.dropIndicator = null;
-        }
-    }
-    destroyHintElement() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        if (this.hintElement?.parentElement) {
-            this.hintElement.parentElement.removeChild(this.hintElement);
-            this.hintElement = null;
-        }
-    }
-    decorateHint() {
-        hintClasses.forEach(className => this.renderer.addClass(this.hintElement, className));
-        Object.keys(hintStyles)
-            .forEach(style => this.renderer.setStyle(this.hintElement, style, hintStyles[style]));
-    }
-    positionDropIndicator(ev) {
-        this.lastDropPosition = this.getDropPosition(ev.dragEvent);
-        this.updateDropIndicatorPosition();
-    }
-    calculateIndexToAdd(dragIndex, dropIndex) {
-        if (dragIndex > dropIndex && this.lastDropPosition === dropPosition.after) {
-            return dropIndex + 1;
-        }
-        else if (dragIndex > dropIndex && this.lastDropPosition === dropPosition.before) {
-            return dropIndex;
-        }
-        else if (dragIndex < dropIndex && this.lastDropPosition === dropPosition.after) {
-            return dropIndex;
-        }
-        else if (dragIndex < dropIndex && this.lastDropPosition === dropPosition.before) {
-            return dropIndex - 1;
-        }
-    }
-    decorateDropIndicator() {
-        dropIndicatorClasses.forEach(className => this.renderer.addClass(this.dropIndicator, className));
-        Object.keys(dropIndicatorStyles)
-            .forEach(style => this.renderer.setStyle(this.dropIndicator, style, dropIndicatorStyles[style]));
-    }
-    getDropPosition(e) {
-        if (this.dropTarget === this.dragTarget || !isPresent(this.dropTarget)) {
-            return dropPosition.forbidden;
-        }
-        if (isDifferentParent(this.dropTarget, this.dragTarget)) {
-            return dropPosition.forbidden;
-        }
-        const itemViewPortCoords = this.dropTarget.getBoundingClientRect();
-        const itemDivisionsCount = 2;
-        const itemDivisionHeight = itemViewPortCoords.height / itemDivisionsCount;
-        const pointerPosition = e.clientY;
-        const itemTop = itemViewPortCoords.top;
-        let currentDropPosition = null;
-        if (pointerPosition < itemTop + itemDivisionHeight) {
-            currentDropPosition = dropPosition.before;
-        }
-        else if (pointerPosition >= itemTop + itemViewPortCoords.height - itemDivisionHeight) {
-            currentDropPosition = dropPosition.after;
-        }
-        if (currentDropPosition === dropPosition.before && isNextSibling(this.dropTarget, this.dragTarget)) {
-            currentDropPosition = dropPosition.forbidden;
-        }
-        else if (currentDropPosition === dropPosition.after && isPreviousSibling(this.dropTarget, this.dragTarget)) {
-            currentDropPosition = dropPosition.forbidden;
-        }
-        return currentDropPosition;
-    }
-    updateDropIndicatorPosition() {
-        if (this.shouldHideDropIndicator() || !this.dropTarget) {
-            this.hide();
-            return;
-        }
-        this.show();
-        const destinationItemOffset = getOffset(this.dropTarget);
-        let indicatorOffsetTop = destinationItemOffset.top;
-        const indicatorOffsetLeft = destinationItemOffset.left + this.dropIndicator.offsetWidth / 2;
-        if (this.lastDropPosition === dropPosition.after) {
-            indicatorOffsetTop += this.dropTarget.offsetHeight;
-        }
-        this.renderer.setStyle(this.dropIndicator, 'left', `${indicatorOffsetLeft}px`);
-        this.renderer.setStyle(this.dropIndicator, 'top', `${indicatorOffsetTop}px`);
-    }
-    shouldHideDropIndicator() {
-        return this.lastDropPosition === dropPosition.forbidden;
-    }
-    hide() {
-        if (isPresent(this.dropIndicator)) {
-            this.dropIndicator.style.display = 'none';
-        }
-    }
-    show() {
-        if (isPresent(this.dropIndicator)) {
-            this.dropIndicator.style.display = '';
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RowReorderService, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RowReorderService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RowReorderService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.Renderer2 }], propDecorators: { rowReorder: [{
-                type: Output
-            }] } });

package/esm2022/row-reordering/types.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/row-reordering/utils.mjs

@@ -1,88 +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 { cancelIcon, insertMiddleIcon } from '@progress/kendo-svg-icons';
-/**
- * @hidden
- */
-export const isNextSibling = (dropTarget, dragTarget) => dropTarget === dragTarget.nextElementSibling;
-/**
- * @hidden
- */
-export const isPreviousSibling = (dropTarget, dragTarget) => dropTarget === dragTarget.previousElementSibling;
-/**
- * @hidden
- */
-export const isDifferentParent = (dropTarget, dragTarget) => dropTarget?.parentElement !== dragTarget?.parentElement;
-/**
- * @hidden
- */
-export function getOffset(element) {
-    const { clientTop, clientLeft } = getDocument(element);
-    const { pageYOffset, pageXOffset } = getWindow(element);
-    const { top, left } = element.getBoundingClientRect();
-    return {
-        top: top + pageYOffset - clientTop,
-        left: left + pageXOffset - clientLeft
-    };
-}
-/**
- * @hidden
- */
-export const hintIcons = {
-    forbidden: 'cancel',
-    before: 'insert-middle',
-    after: 'insert-middle'
-};
-/**
- * @hidden
- */
-export const hintSVGIcons = {
-    forbidden: cancelIcon,
-    before: insertMiddleIcon,
-    after: insertMiddleIcon
-};
-/**
- * @hidden
- */
-export const dropPosition = {
-    forbidden: 'forbidden',
-    before: 'before',
-    after: 'after'
-};
-/**
- * @hidden
- */
-export const hintStyles = {
-    zIndex: '20000',
-    display: 'flex',
-    position: 'fixed'
-};
-/**
- * @hidden
- */
-export const hintClasses = ['k-drag-clue', 'k-reorder-clue'];
-/**
- * @hidden
- */
-export const dropIndicatorStyles = {
-    zIndex: '19000',
-    position: 'absolute'
-};
-/**
- * @hidden
- */
-export const dropIndicatorClasses = ['k-drop-hint', 'k-drop-hint-h'];
-/**
- * @hidden
- */
-export const getDefaultSelectors = (isStacked) => {
-    return {
-        handle: isStacked ? '.k-grid-stack-cell.k-drag-cell' : '.k-table-td.k-drag-cell',
-        dragTarget: '.k-master-row',
-        dropTarget: '.k-master-row'
-    };
-};
-const getDocument = element => element?.ownerDocument.documentElement;
-const getWindow = element => element?.ownerDocument.defaultView;

package/esm2022/scrolling/content-scroll-event.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/scrolling/row-height.service.mjs

@@ -1,55 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export class RowHeightService {
-    total;
-    offsets = [];
-    heights = [];
-    constructor(total = 0, rowHeight) {
-        this.total = total;
-        let agg = 0;
-        for (let idx = 0; idx < total; idx++) {
-            this.offsets.push(agg);
-            agg += rowHeight;
-            this.heights.push(rowHeight);
-        }
-    }
-    height(rowIndex) {
-        return this.heights[rowIndex];
-    }
-    index(position) {
-        for (let i = 0; i < this.offsets.length; i++) {
-            if (position === this.offsets[i]) {
-                return i;
-            }
-            if (position < this.offsets[i]) {
-                return i - 1;
-            }
-        }
-        return this.total - 1;
-    }
-    offset(rowIndex) {
-        return this.offsets[rowIndex];
-    }
-    totalHeight() {
-        if (!this.offsets.length) {
-            return 0;
-        }
-        const lastOffset = this.offsets[this.offsets.length - 1];
-        const lastHeight = this.heights[this.heights.length - 1];
-        return lastOffset + lastHeight;
-    }
-    update(startIndex, rowHeights) {
-        let agg = this.offsets[startIndex];
-        for (let i = startIndex; i < this.heights.length; i++) {
-            this.offsets[i] = agg;
-            const currHeight = rowHeights[i - startIndex] || this.heights[i];
-            agg += currHeight;
-            this.heights[i] = currHeight;
-        }
-    }
-}

package/esm2022/scrolling/scroll-bottom-event.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/scrolling/scroll-request.service.mjs

@@ -1,24 +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 ScrollRequestService {
-    requests = new Subject();
-    scrollTo(request, adjustIndex = true) {
-        this.requests.next({ request, adjustIndex });
-    }
-    scrollToItem(request) {
-        this.requests.next({ request });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollRequestService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollRequestService, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/scrolling/scroll-sync.service.mjs

@@ -1,80 +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, NgZone } from '@angular/core';
-import { Subscription, Subject, fromEvent } from 'rxjs';
-import { distinctUntilChanged, filter, map, tap } from 'rxjs/operators';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class ScrollSyncService {
-    ngZone;
-    changes = new Subject();
-    elements = [];
-    source;
-    subscriptions = new Subscription();
-    headerSubscription = new Subscription();
-    bodySubscription = new Subscription();
-    constructor(ngZone) {
-        this.ngZone = ngZone;
-        this.subscriptions.add(this.changes.subscribe(args => this.scrollLeft(args)));
-    }
-    registerEmitter(el, sourceType) {
-        this.unregister(sourceType);
-        this.elements.push({ element: el, sourceType });
-        if (sourceType === "body" || sourceType === "header") {
-            this.ngZone.runOutsideAngular(() => {
-                const obs = fromEvent(el, "scroll").pipe(map(({ target: { scrollLeft } }) => ({
-                    scrollLeft,
-                    sourceType
-                })));
-                const subscription = obs.pipe(distinctUntilChanged((x, y) => (x.scrollLeft === y.scrollLeft)), filter(x => !this.source || this.source === x.sourceType), tap(x => this.source = x.sourceType))
-                    .subscribe((x) => this.changes.next(x));
-                subscription.add(obs.pipe(filter(x => this.source && this.source !== x.sourceType))
-                    .subscribe(() => this.source = undefined));
-                if (sourceType === "body") {
-                    this.bodySubscription.add(subscription);
-                }
-                else {
-                    this.headerSubscription.add(subscription);
-                }
-            });
-        }
-    }
-    /**
-     * destroy
-     */
-    destroy() {
-        this.subscriptions.unsubscribe();
-        this.headerSubscription.unsubscribe();
-        this.bodySubscription.unsubscribe();
-    }
-    scrollLeft({ scrollLeft, sourceType }) {
-        this.ngZone.runOutsideAngular(() => {
-            this.elements
-                .filter(x => sourceType !== x.sourceType)
-                .forEach(({ element }) => element.scrollLeft = scrollLeft);
-        });
-    }
-    unregister(sourceType) {
-        const index = this.elements.findIndex(x => x.sourceType === sourceType);
-        if (index > -1) {
-            if (sourceType === "header") {
-                this.headerSubscription.unsubscribe();
-                this.headerSubscription = new Subscription();
-            }
-            else if (sourceType === "body") {
-                this.bodySubscription.unsubscribe();
-                this.bodySubscription = new Subscription();
-            }
-            this.elements.splice(index, 1);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollSyncService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollSyncService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollSyncService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.NgZone }] });