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

package/esm2022/rendering/toolbar/toolbar-focusable.directive.mjs

@@ -1,77 +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, ElementRef } from '@angular/core';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { ContextService } from '../../common/provider.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../../common/provider.service";
-/**
- * A directive for toolbar elements that need to be part of TreeList keyboard navigation.
- * Use this directive to make toolbar elements focusable and accessible with the keyboard.
- *
- * @example
- * ```html
- * <kendo-treelist>
- *     <kendo-toolbar>
- *         <button kendoTreeListToolbarFocusable>Custom Button</button>
- *         <button kendoTreeListCancelCommand>Cancel</button>
- *         <button kendoTreeListEditCommand>Edit</button>
- *     </kendo-toolbar>
- * </kendo-treelist>
- * ```
- */
-export class TreeListToolbarFocusableDirective {
-    host;
-    ctx;
-    /**
-     * @hidden
-     */
-    get element() {
-        return this.host.nativeElement;
-    }
-    /**
-     * @hidden
-     */
-    get toolbarPosition() {
-        return isDocumentAvailable() && this.host.nativeElement.closest('.k-toolbar')?.getAttribute('position');
-    }
-    constructor(host, ctx) {
-        this.host = host;
-        this.ctx = ctx;
-    }
-    ngAfterViewInit() {
-        if (!isDocumentAvailable() || !this.toolbarPosition) {
-            return;
-        }
-        this.ctx[`${this.toolbarPosition}ToolbarNavigation`]?.navigableElements.push(this.element);
-        this.ctx[`${this.toolbarPosition}ToolbarNavigation`]?.notify();
-    }
-    ngOnDestroy() {
-        if (!isDocumentAvailable() || !this.toolbarPosition) {
-            return;
-        }
-        const elements = this.ctx[`${this.toolbarPosition}ToolbarNavigation`].navigableElements;
-        this.ctx[`${this.toolbarPosition}ToolbarNavigation`].navigableElements = elements.filter(el => el !== this.element);
-        this.ctx[`${this.toolbarPosition}ToolbarNavigation`].notify();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TreeListToolbarFocusableDirective, deps: [{ token: i0.ElementRef }, { token: i1.ContextService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TreeListToolbarFocusableDirective, isStandalone: true, selector: "\n        [kendoTreeListToolbarFocusable],\n        [kendoTreeListAddCommand],\n        [kendoTreeListCancelCommand],\n        [kendoTreeListEditCommand],\n        [kendoTreeListRemoveCommand],\n        [kendoTreeListSaveCommand],\n        [kendoTreeListExcelCommand],\n        [kendoTreeListPDFCommand]\n    ", ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TreeListToolbarFocusableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: `
-        [kendoTreeListToolbarFocusable],
-        [kendoTreeListAddCommand],
-        [kendoTreeListCancelCommand],
-        [kendoTreeListEditCommand],
-        [kendoTreeListRemoveCommand],
-        [kendoTreeListSaveCommand],
-        [kendoTreeListExcelCommand],
-        [kendoTreeListPDFCommand]
-    `,
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.ContextService }] });

package/esm2022/rendering/toolbar/toolbar-navigation.service.mjs

@@ -1,54 +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, Renderer2 } from '@angular/core';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class TreeListToolbarNavigationService {
-    renderer;
-    navigableElements = [];
-    currentActiveIndex = 0;
-    defaultFocusableSelector = `
-        [kendoTreeListToolbarFocusable],
-        [kendoTreeListAddCommand],
-        [kendoTreeListCancelCommand],
-        [kendoTreeListEditCommand],
-        [kendoTreeListRemoveCommand],
-        [kendoTreeListSaveCommand],
-        [kendoTreeListExcelCommand],
-        [kendoTreeListPDFCommand]
-    `;
-    constructor(renderer) {
-        this.renderer = renderer;
-    }
-    notify() {
-        // ensure focusable elements are in the same order as in the DOM
-        this.navigableElements = (this.navigableElements.length && this.navigableElements[0]?.parentElement) ? Array.from(this.navigableElements[0]?.parentElement?.querySelectorAll(this.defaultFocusableSelector) || []) : [];
-        this.currentActiveIndex = 0;
-        this.updateFocus();
-    }
-    focus() {
-        this.navigableElements[this.currentActiveIndex]?.focus();
-    }
-    updateFocus() {
-        if (!this.navigableElements.length) {
-            return;
-        }
-        this.navigableElements.forEach(el => {
-            this.renderer.setAttribute(el, 'tabindex', '-1');
-        });
-        this.renderer.setAttribute(this.navigableElements[this.currentActiveIndex], 'tabindex', '0');
-        if (isDocumentAvailable() && document.activeElement.closest('.k-toolbar')) {
-            this.navigableElements[this.currentActiveIndex].focus();
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TreeListToolbarNavigationService, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TreeListToolbarNavigationService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TreeListToolbarNavigationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.Renderer2 }] });

package/esm2022/rendering/toolbar/toolbar-template.directive.mjs

@@ -1,58 +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, TemplateRef, Optional, Input } from '@angular/core';
-import { OptionChangesService } from '../../common/option-changes.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../../common/option-changes.service";
-/**
- * Represents the toolbar template of the TreeList ([see example](slug:toolbartemplate_treelist)).
- *
- * The template context has the following field:
- * - `position`—The position at which the toolbar template is rendered. The possible values are `top`, `bottom`, and `both`.
- *
- * @example
- * ```html
- * <kendo-treelist ...>
- *   <ng-template kendoTreeListToolbarTemplate>
- *     <button kendoTreeListExcelCommand>Export to Excel</button>
- *   </ng-template>
- * </kendo-treelist>
- * ```
- */
-export class ToolbarTemplateDirective {
-    templateRef;
-    optionChanges;
-    _position = "top";
-    /**
-     * Sets the position of the toolbar. The value can be `top`, `bottom`, or `both`.
-     * Controls whether the toolbar appears above, below, or on both sides of the TreeList. [See example.](slug:toolbartemplate_treelist#toc-setting-the-toolbar-position)
-     * @default 'top'
-     */
-    set position(position) {
-        this._position = position;
-        this.optionChanges.optionChanged();
-    }
-    get position() {
-        return this._position;
-    }
-    constructor(templateRef, optionChanges) {
-        this.templateRef = templateRef;
-        this.optionChanges = optionChanges;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolbarTemplateDirective, deps: [{ token: i0.TemplateRef, optional: true }, { token: i1.OptionChangesService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ToolbarTemplateDirective, isStandalone: true, selector: "[kendoTreeListToolbarTemplate]", inputs: { position: "position" }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolbarTemplateDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoTreeListToolbarTemplate]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.TemplateRef, decorators: [{
-                    type: Optional
-                }] }, { type: i1.OptionChangesService }], propDecorators: { position: [{
-                type: Input,
-                args: ["position"]
-            }] } });

package/esm2022/rendering/toolbar/toolbar.component.mjs

@@ -1,110 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/* eslint-disable @typescript-eslint/no-inferrable-types */
-import { Component, Input, HostBinding, Renderer2, ElementRef } from '@angular/core';
-import { NgTemplateOutlet } from '@angular/common';
-import { Subscription } from 'rxjs';
-import { Keys, isDocumentAvailable, normalizeKeys } from '@progress/kendo-angular-common';
-import { ContextService } from './../../common/provider.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./../../common/provider.service";
-/**
- * @hidden
- */
-export class ToolbarComponent {
-    elem;
-    renderer;
-    ctx;
-    hostRole = 'toolbar';
-    hostClasses = true;
-    context = {};
-    set position(value) {
-        this.context.position = value;
-    }
-    navigable;
-    get toolbarTemplateRef() {
-        return this.ctx.treelist.toolbarTemplate ? this.ctx.treelist.toolbarTemplate.templateRef : undefined;
-    }
-    subs = new Subscription();
-    navigationService;
-    constructor(elem, renderer, ctx) {
-        this.elem = elem;
-        this.renderer = renderer;
-        this.ctx = ctx;
-        this.navigationService = this.ctx[`${this.elem.nativeElement.getAttribute('position')}ToolbarNavigation`];
-    }
-    ngAfterViewInit() {
-        const element = this.elem.nativeElement;
-        this.subs.add(this.renderer.listen(element, 'keydown', event => this.onKeyDown(event)));
-    }
-    ngOnDestroy() {
-        this.subs.unsubscribe();
-    }
-    onKeyDown(event) {
-        if (this.navigable && isDocumentAvailable() && this.navigationService.navigableElements.length) {
-            const keyCode = normalizeKeys(event);
-            if (keyCode === Keys.ArrowLeft || keyCode === Keys.ArrowRight) {
-                event.preventDefault();
-                const dir = keyCode === Keys.ArrowLeft ? -1 : 1;
-                this.changeFocusedItem(dir);
-            }
-        }
-    }
-    changeFocusedItem(dir) {
-        this.navigationService.currentActiveIndex += dir;
-        const bottomRange = this.navigationService.currentActiveIndex < 0;
-        const topRange = this.navigationService.currentActiveIndex >= this.navigationService.navigableElements.length;
-        if (bottomRange || topRange) {
-            this.navigationService.currentActiveIndex = bottomRange ? this.navigationService.navigableElements.length - 1 : 0;
-        }
-        this.navigationService.updateFocus();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolbarComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ContextService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ToolbarComponent, isStandalone: true, selector: "kendo-treelist-toolbar", inputs: { position: "position", navigable: "navigable" }, host: { properties: { "attr.role": "this.hostRole", "class.k-grid-toolbar": "this.hostClasses", "class.k-toolbar": "this.hostClasses", "class.k-toolbar-solid": "this.hostClasses", "class.k-toolbar-md": "this.hostClasses" } }, ngImport: i0, template: `
-        @if (toolbarTemplateRef) {
-          <ng-template
-            [ngTemplateOutlet]="toolbarTemplateRef"
-            [ngTemplateOutletContext]="context"
-            >
-          </ng-template>
-        }
-        `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ToolbarComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'kendo-treelist-toolbar',
-                    template: `
-        @if (toolbarTemplateRef) {
-          <ng-template
-            [ngTemplateOutlet]="toolbarTemplateRef"
-            [ngTemplateOutletContext]="context"
-            >
-          </ng-template>
-        }
-        `,
-                    standalone: true,
-                    imports: [NgTemplateOutlet]
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ContextService }], propDecorators: { hostRole: [{
-                type: HostBinding,
-                args: ['attr.role']
-            }], hostClasses: [{
-                type: HostBinding,
-                args: ['class.k-grid-toolbar']
-            }, {
-                type: HostBinding,
-                args: ['class.k-toolbar']
-            }, {
-                type: HostBinding,
-                args: ['class.k-toolbar-solid']
-            }, {
-                type: HostBinding,
-                args: ['class.k-toolbar-md']
-            }], position: [{
-                type: Input
-            }], navigable: [{
-                type: Input
-            }] } });

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

@@ -1,48 +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 { RowReorderService } from './row-reorder.service';
-import { isPresent } from "../utils";
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class FlatRowReorderService extends RowReorderService {
-    isOverChild(targetItem) {
-        const { draggedRows } = this.rowReorderArgs(this.dragTarget, this.dropTarget, this.view);
-        const draggedItem = draggedRows[0].dataItem;
-        const hasParent = isPresent(targetItem[this.parentIdField]);
-        const sameParents = draggedItem[this.parentIdField] === targetItem[this.parentIdField];
-        if (!hasParent || sameParents) {
-            return false;
-        }
-        if (targetItem && targetItem.hasOwnProperty(this.parentIdField)) {
-            if (draggedItem[this.idField] === targetItem[this.parentIdField]) {
-                return true;
-            }
-            const parent = this.data.find(i => i[this.idField] === targetItem[this.parentIdField]);
-            if (parent) {
-                return this.isOverChild(parent);
-            }
-        }
-    }
-    reorderRows(ev, collection) {
-        const { draggedRows, dropTargetRow } = ev;
-        const draggedDataItem = draggedRows[0].dataItem;
-        const dropTargetDataItem = dropTargetRow.dataItem;
-        let dropTargetIdx = collection.indexOf(dropTargetDataItem);
-        const draggedItemIdx = collection.indexOf(draggedDataItem);
-        collection.splice(draggedItemIdx, 1);
-        if (ev.dropPosition === 'after' && dropTargetIdx < draggedItemIdx) {
-            dropTargetIdx++;
-        }
-        collection.splice(dropTargetIdx, 0, draggedDataItem);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FlatRowReorderService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FlatRowReorderService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FlatRowReorderService, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/row-reordering/hierarchical-reorder.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
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from "@angular/core";
-import { RowReorderService } from './row-reorder.service';
-import { isPresent } from "../utils";
-import { dropPosition, findParent } from "./utils";
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class HierarchicalRowReorderService extends RowReorderService {
-    isOverChild(targetItem) {
-        const { draggedRows } = this.rowReorderArgs(this.dragTarget, this.dropTarget, this.view);
-        const draggedItem = draggedRows[0].dataItem;
-        const hasChildren = isPresent(draggedItem[this.childrenField]) && draggedItem[this.childrenField].length > 0;
-        if (!hasChildren) {
-            return false;
-        }
-        if (targetItem && draggedItem.hasOwnProperty(this.childrenField)) {
-            if (draggedItem[this.childrenField].includes(targetItem)) {
-                return true;
-            }
-            const parent = findParent(this.data, targetItem, this.childrenField);
-            if (parent) {
-                return this.isOverChild(parent);
-            }
-        }
-        return false;
-    }
-    reorderRows(ev, collection, field) {
-        const draggedItem = ev.draggedRows[0].dataItem;
-        const dropTargetItem = ev.dropTargetRow.dataItem;
-        const draggedItemParent = findParent(collection, draggedItem, field);
-        const dropTargetParent = findParent(collection, dropTargetItem, field);
-        const draggedItemIdx = draggedItemParent ? draggedItemParent[field].indexOf(draggedItem) : collection.indexOf(draggedItem);
-        let dropTargetItemIdx = dropTargetParent ? dropTargetParent[field].indexOf(dropTargetItem) : collection.indexOf(dropTargetItem);
-        if (ev.dropPosition === dropPosition.after && dropTargetItemIdx < draggedItemIdx) {
-            dropTargetItemIdx++;
-        }
-        draggedItemParent ? draggedItemParent[field].splice(draggedItemIdx, 1) : collection.splice(draggedItemIdx, 1);
-        if (ev.dropPosition !== dropPosition.over) {
-            dropTargetParent ? dropTargetParent[field].splice(dropTargetItemIdx, 0, draggedItem) : collection.splice(dropTargetItemIdx, 0, draggedItem);
-        }
-        else {
-            dropTargetItem[field].unshift(draggedItem);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HierarchicalRowReorderService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HierarchicalRowReorderService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HierarchicalRowReorderService, decorators: [{
-            type: Injectable
-        }] });

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

@@ -1,273 +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, defaultSelectors, rowIndexAttr } from './utils';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class RowReorderService {
-    renderer;
-    defaultSelectors = defaultSelectors;
-    dragTarget = null;
-    dropTarget = null;
-    view;
-    bindingDirective;
-    offsetY;
-    dropIndicator;
-    lastDropPosition = dropPosition.forbidden;
-    hintElement = null;
-    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;
-        this.view = ev.dragData;
-    }
-    dragLeave() {
-        this.dropTarget = null;
-        this.lastDropPosition === dropPosition.forbidden && this.hide();
-    }
-    dragEnd() {
-        this.destroyDropIndicator();
-        this.destroyHintElement();
-        this.dragTarget = null;
-        this.dropTarget = null;
-        this.hintElement = null;
-    }
-    drop() {
-        this.destroyDropIndicator();
-        this.destroyHintElement();
-        const rowReorderArgs = this.rowReorderArgs(this.dragTarget, this.dropTarget, this.view);
-        this.rowReorder.emit(rowReorderArgs);
-    }
-    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();
-    }
-    rowReorderArgs(dragRow, dropRow, data) {
-        const dragRowData = this.getDragRowPerElement(dragRow, data);
-        const dropRowData = this.getDragRowPerElement(dropRow, data);
-        return {
-            draggedRows: [dragRowData],
-            dropTargetRow: dropRowData,
-            dropPosition: this.lastDropPosition
-        };
-    }
-    isOverChild(_item) { return false; }
-    reorderRows(_ev, _collection, _field) { }
-    /**
-     * 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 (view)
-     */
-    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 === rowIndexAttr) {
-                    return String(rowIndex);
-                }
-                return null;
-            }
-        };
-        return virtualElement;
-    }
-    get parentIdField() {
-        return this.bindingDirective.parentIdField;
-    }
-    get idField() {
-        return this.bindingDirective.idField;
-    }
-    get childrenField() {
-        return this.bindingDirective.childrenField;
-    }
-    get data() {
-        return this.bindingDirective.data;
-    }
-    getDragRowPerElement(row, data) {
-        let rowIndex = row?.getAttribute(rowIndexAttr);
-        rowIndex = rowIndex ? parseInt(rowIndex, 10) : -1;
-        const dataItem = rowIndex === -1 ? null : data?.at(rowIndex)?.data;
-        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();
-    }
-    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;
-        }
-        const itemViewPortCoords = this.dropTarget.getBoundingClientRect();
-        const itemDivisionsCount = 3;
-        const itemDivisionHeight = itemViewPortCoords.height / itemDivisionsCount;
-        const { dropTargetRow } = this.rowReorderArgs(this.dragTarget, this.dropTarget, this.view);
-        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;
-        }
-        else {
-            currentDropPosition = dropPosition.over;
-        }
-        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;
-        }
-        if (isPresent(dropTargetRow.dataItem)) {
-            if (this.isOverChild(dropTargetRow.dataItem)) {
-                currentDropPosition = dropPosition.forbidden;
-            }
-        }
-        else {
-            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 || this.lastDropPosition === dropPosition.over;
-    }
-    hide() {
-        if (isPresent(this.dropIndicator)) {
-            this.renderer.setStyle(this.dropIndicator, 'display', 'none');
-        }
-    }
-    show() {
-        if (isPresent(this.dropIndicator)) {
-            this.renderer.removeStyle(this.dropIndicator, '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
-            }] } });