@progress/kendo-angular-treeview 6.0.3-dev.202203091032 → 7.0.0-dev.202204131935

package/dist/es/drag-and-drop/drag-and-drop.directive.js

@@ -1,334 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Directive, ElementRef, NgZone, ContentChild, Input, HostBinding } from '@angular/core';
-import { hasObservers } from '@progress/kendo-angular-common';
-import Draggable from '@telerik/kendo-draggable';
-import { DragClueService } from './drag-clue/drag-clue.service';
-import { DropHintService } from './drop-hint/drop-hint.service';
-import { DragClueTemplateDirective } from './drag-clue/drag-clue-template.directive';
-import { DropHintTemplateDirective } from './drop-hint/drop-hint-template.directive';
-import { getDropAction, getDropPosition, treeItemFromEventTarget, getContainerOffset, getDropTarget } from './drag-and-drop-utils';
-import { closestWithMatch, isPresent, isContent } from '../utils';
-import { TreeViewComponent } from '../treeview.component';
-import { TreeItemDropEvent, DropPosition, TreeItemDragStartEvent } from './models';
-var DEFAULT_SCROLL_SETTINGS = {
-    enabled: true,
-    step: 1,
-    interval: 1
-};
-/**
- * A directive which enables the dragging and dropping items inside the current TreeView or between multiple linked TreeView component instances
- * ([see example]({% slug draganddrop_treeview %})).
- *
- * Triggers the [`nodeDragStart`]({% slug api_treeview_treeviewcomponent %}#toc-nodedragstart),
- * [`nodeDrag`]({% slug api_treeview_treeviewcomponent %}#toc-nodedrag),
- * [`nodeDrop`]({% slug api_treeview_treeviewcomponent %}#toc-nodedrop),
- * [`nodeDragEnd`]({% slug api_treeview_treeviewcomponent %}#toc-nodedragend),
- * [`addItem`]({% slug api_treeview_treeviewcomponent %}#toc-additem) and
- * [`removeItem`]({% slug api_treeview_treeviewcomponent %}#toc-removeitem)
- * events when the corresponding actions occur on the respective TreeView instance.
- */
-var DragAndDropDirective = /** @class */ (function () {
-    function DragAndDropDirective(element, zone, treeview, dragClueService, dropHintService) {
-        this.element = element;
-        this.zone = zone;
-        this.treeview = treeview;
-        this.dragClueService = dragClueService;
-        this.dropHintService = dropHintService;
-        /**
-         * Specifies whether the `removeItem` event will be fired after an item is dropped when the `ctrl` key is pressed.
-         * If enabled, the `removeItem` event will not be fired on the source TreeView
-         * ([see example]({% slug draganddrop_treeview %}#toc-multiple-treeviews)).
-         *
-         * @default false
-         */
-        this.allowCopy = false;
-        /**
-         * Specifes the TreeViewComponent instances into which dragged items from the current TreeViewComponent can be dropped
-         * ([see example]({% slug draganddrop_treeview %}#toc-multiple-treeviews)).
-         */
-        this.dropZoneTreeViews = [];
-        /**
-         * Specifies the distance in pixels from the initial item pointerdown event, before the dragging is initiated.
-         * The `nodeDragStart` and all consequent TreeView drag events will not be fired until the actual dragging begins.
-         *
-         * @default 5
-         */
-        this.startDragAfter = 5;
-        /**
-         * Controlls the auto-scrolling behavior during drag-and-drop ([see example]({% slug draganddrop_treeview %}#toc-auto-scrolling)).
-         * Enbaled by default. To turn the auto-scrolling off, set this prop to `false`.
-         *
-         * By default, the scrolling will be performed by 1 pixel at every 1 millisecond, when the dragged item reaches the top or the bottom of the scrollable container.
-         * The `step` and `interval` can be overridden by providing a `DragAndDropScrollSettings` object to this prop.
-         *
-         * @default true
-         */
-        this.autoScroll = true;
-        /**
-         * @hidden
-         */
-        this.userSelectStyle = 'none';
-        /**
-         * Describes the offset of the parent element if the latter has the `transform` CSS prop applied.
-         * Transformed parents create new stacking context and the fixed children must be position based on the transformed parent.
-         * https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context
-         */
-        this.containerOffset = { top: 0, left: 0 };
-        this.treeview.touchActions = false;
-    }
-    Object.defineProperty(DragAndDropDirective.prototype, "scrollSettings", {
-        get: function () {
-            var userProvidedSettings = typeof this.autoScroll === 'boolean' ?
-                { enabled: this.autoScroll } :
-                this.autoScroll;
-            return Object.assign({}, DEFAULT_SCROLL_SETTINGS, userProvidedSettings);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    DragAndDropDirective.prototype.ngAfterContentInit = function () {
-        this.initalizeDraggable();
-        this.dragClueService.initialize(this.treeview.assetsContainer, this.dragClueTemplate && this.dragClueTemplate.templateRef);
-        this.dropHintService.initialize(this.treeview.assetsContainer, this.dropHintTemplate && this.dropHintTemplate.templateRef);
-    };
-    DragAndDropDirective.prototype.ngOnDestroy = function () {
-        this.draggable.destroy();
-    };
-    /**
-     * @hidden
-     */
-    DragAndDropDirective.prototype.handlePress = function (_a) {
-        var originalEvent = _a.originalEvent;
-        if (!isContent(originalEvent.target)) {
-            return;
-        }
-        // store the drag target on press, show it only when it's actually dragged
-        this.draggedItem = closestWithMatch(originalEvent.target, '.k-treeview-leaf');
-        // record the current pointer down coords - copared to the `startDragAfter` value to calculate whether to initiate dragging
-        this.pendingDragStartEvent = originalEvent;
-    };
-    /**
-     * @hidden
-     */
-    DragAndDropDirective.prototype.handleDrag = function (_a) {
-        var _this = this;
-        var originalEvent = _a.originalEvent, clientX = _a.clientX, clientY = _a.clientY;
-        if (this.shouldInitiateDragStart({ clientX: clientX, clientY: clientY })) {
-            this.initiateDragStart();
-        }
-        if (!isPresent(this.draggedItem) || isPresent(this.pendingDragStartEvent)) {
-            return;
-        }
-        var dropTarget = getDropTarget(originalEvent);
-        if (hasObservers(this.treeview.nodeDrag)) {
-            this.zone.run(function () { return _this.notifyDrag(originalEvent, dropTarget); });
-        }
-        var targetTreeView = this.getTargetTreeView(dropTarget);
-        var dropPosition = getDropPosition(this.draggedItem, dropTarget, clientY, targetTreeView, this.containerOffset);
-        var dropHintAnchor = closestWithMatch(dropTarget, '.k-treeview-mid');
-        var dropAction = getDropAction(dropPosition, dropTarget);
-        var sourceItem = treeItemFromEventTarget(this.treeview, this.draggedItem);
-        var destinationItem = treeItemFromEventTarget(targetTreeView, dropTarget);
-        this.updateDropHintState(dropPosition, dropHintAnchor, dropAction, sourceItem, destinationItem);
-        this.updateDragClueState(dropAction, clientX, clientY, sourceItem, destinationItem);
-        if (this.scrollSettings.enabled) {
-            this.dragClueService.scrollIntoView(this.scrollSettings);
-        }
-    };
-    /**
-     * @hidden
-     */
-    DragAndDropDirective.prototype.handleRelease = function (_a) {
-        var _this = this;
-        var originalEvent = _a.originalEvent, clientY = _a.clientY;
-        if (this.scrollSettings.enabled) {
-            this.dragClueService.cancelScroll();
-        }
-        if (!isPresent(this.draggedItem) || isPresent(this.pendingDragStartEvent)) {
-            this.pendingDragStartEvent = null;
-            this.draggedItem = null;
-            return;
-        }
-        var dropTarget = getDropTarget(originalEvent);
-        var sourceTree = this.treeview;
-        var destinationTree = this.getTargetTreeView(dropTarget);
-        var dropPosition = getDropPosition(this.draggedItem, dropTarget, clientY, this.getTargetTreeView(dropTarget), this.containerOffset);
-        var sourceItem = treeItemFromEventTarget(sourceTree, this.draggedItem);
-        var destinationItem = treeItemFromEventTarget(destinationTree, dropTarget);
-        if (isPresent(destinationItem) && isPresent(dropPosition)) {
-            this.zone.run(function () { return _this.notifyDrop({ sourceItem: sourceItem, destinationItem: destinationItem, dropPosition: dropPosition, sourceTree: sourceTree, destinationTree: destinationTree }, originalEvent); });
-        }
-        else {
-            this.dragClueService.animateDragClueToElementPosition(this.draggedItem);
-        }
-        if (hasObservers(this.treeview.nodeDragEnd)) {
-            this.zone.run(function () { return _this.notifyDragEnd({ sourceItem: sourceItem, destinationItem: destinationItem, originalEvent: originalEvent }); });
-        }
-        this.dropHintService.hide();
-        this.draggedItem = null;
-    };
-    DragAndDropDirective.prototype.updateDropHintState = function (dropPosition, dropHintAnchor, dropAction, sourceItem, destinationItem) {
-        if (!isPresent(dropHintAnchor) || dropPosition === DropPosition.Over || !isPresent(dropPosition)) {
-            this.dropHintService.hide();
-            return;
-        }
-        var anchorViewPortCoords = dropHintAnchor.getBoundingClientRect();
-        var insertBefore = dropPosition === DropPosition.Before;
-        var top = insertBefore ? anchorViewPortCoords.top : (anchorViewPortCoords.top + anchorViewPortCoords.height);
-        this.dropHintService.updateDropHintData(dropAction, sourceItem, destinationItem);
-        // clear any possible container offset created by parent elements with `transform` css property set
-        this.dropHintService.move(anchorViewPortCoords.left - this.containerOffset.left, top - this.containerOffset.top);
-        this.dropHintService.show();
-    };
-    DragAndDropDirective.prototype.updateDragClueState = function (dropAction, clientX, clientY, sourceItem, destinationItem) {
-        // clear any possible container offset created by parent elements with `transform` css property set
-        this.dragClueService.move(clientX - this.containerOffset.left, clientY - this.containerOffset.top);
-        this.dragClueService.updateDragClueData(dropAction, sourceItem, destinationItem);
-        this.dragClueService.show();
-    };
-    DragAndDropDirective.prototype.initalizeDraggable = function () {
-        var _this = this;
-        this.draggable = new Draggable({
-            press: this.handlePress.bind(this),
-            drag: this.handleDrag.bind(this),
-            release: this.handleRelease.bind(this)
-        });
-        this.zone.runOutsideAngular(function () { return _this.draggable.bindTo(_this.element.nativeElement); });
-    };
-    DragAndDropDirective.prototype.notifyDragStart = function (originalEvent, dropTarget) {
-        var sourceItem = treeItemFromEventTarget(this.treeview, dropTarget);
-        var event = new TreeItemDragStartEvent({ sourceItem: sourceItem, originalEvent: originalEvent });
-        this.treeview.nodeDragStart.emit(event);
-        return event;
-    };
-    DragAndDropDirective.prototype.notifyDrag = function (originalEvent, dropTarget) {
-        var dragEvent = {
-            sourceItem: treeItemFromEventTarget(this.treeview, this.draggedItem),
-            destinationItem: treeItemFromEventTarget(this.getTargetTreeView(dropTarget), dropTarget),
-            originalEvent: originalEvent
-        };
-        this.treeview.nodeDrag.emit(dragEvent);
-    };
-    DragAndDropDirective.prototype.notifyDrop = function (args, originalEvent) {
-        var event = new TreeItemDropEvent(args, originalEvent);
-        args.destinationTree.nodeDrop.emit(event);
-        // disable the animations on drop and restore them afterwards (if they were initially turned on)
-        this.disableAnimationsForNextTick(args.destinationTree);
-        if (args.sourceTree !== args.destinationTree) {
-            this.disableAnimationsForNextTick(args.sourceTree);
-        }
-        if (!event.isDefaultPrevented() && event.isValid) {
-            this.dragClueService.hide();
-            // order matters in a flat data binding scenario (first add, then remove)
-            args.destinationTree.addItem.emit(args);
-            if (!(originalEvent.ctrlKey && this.allowCopy)) {
-                args.sourceTree.removeItem.emit(args);
-            }
-        }
-        else if (event.isDefaultPrevented()) {
-            // directly hide the clue if the default is prevented
-            this.dragClueService.hide();
-        }
-        else if (!event.isValid) {
-            // animate the clue back to the source item position if marked as invalid
-            this.dragClueService.animateDragClueToElementPosition(this.draggedItem);
-        }
-    };
-    DragAndDropDirective.prototype.notifyDragEnd = function (dragEndEvent) {
-        this.treeview.nodeDragEnd.emit(dragEndEvent);
-    };
-    DragAndDropDirective.prototype.getTargetTreeView = function (dropTarget) {
-        var treeViewTagName = this.treeview.element.nativeElement.tagName;
-        var targetTreeView = closestWithMatch(dropTarget, treeViewTagName);
-        return [this.treeview].concat(this.dropZoneTreeViews).find(function (treeView) {
-            return isPresent(treeView) && treeView.element.nativeElement === targetTreeView;
-        });
-    };
-    DragAndDropDirective.prototype.disableAnimationsForNextTick = function (treeView) {
-        // the treeView.animate getter returns `true` when the animations are turned off
-        // confusing, but seems on purpose (the `animate` prop sets the value of the @.disabled host-bound attribute)
-        if (treeView.animate) {
-            return;
-        }
-        treeView.animate = false;
-        this.zone.runOutsideAngular(function () {
-            return setTimeout(function () { return treeView.animate = true; });
-        });
-    };
-    DragAndDropDirective.prototype.shouldInitiateDragStart = function (currentPointerCoords) {
-        if (!isPresent(this.pendingDragStartEvent)) {
-            return false;
-        }
-        var distanceFromPointerDown = Math.sqrt(Math.pow((this.pendingDragStartEvent.clientX - currentPointerCoords.clientX), 2) +
-            Math.pow((this.pendingDragStartEvent.clientY - currentPointerCoords.clientY), 2));
-        return distanceFromPointerDown >= this.startDragAfter;
-    };
-    DragAndDropDirective.prototype.initiateDragStart = function () {
-        var _this = this;
-        if (hasObservers(this.treeview.nodeDragStart)) {
-            var dragStartEvent = this.zone.run(function () {
-                return _this.notifyDragStart(_this.pendingDragStartEvent, getDropTarget(_this.pendingDragStartEvent));
-            });
-            if (dragStartEvent.isDefaultPrevented()) {
-                this.pendingDragStartEvent = null;
-                this.draggedItem = null;
-                return;
-            }
-        }
-        this.dragClueService.cancelReturnAnimation();
-        this.dragClueService.updateText(this.draggedItem.innerText);
-        this.containerOffset = getContainerOffset(this.draggedItem);
-        this.pendingDragStartEvent = null;
-    };
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Boolean)
-    ], DragAndDropDirective.prototype, "allowCopy", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Array)
-    ], DragAndDropDirective.prototype, "dropZoneTreeViews", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Number)
-    ], DragAndDropDirective.prototype, "startDragAfter", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DragAndDropDirective.prototype, "autoScroll", void 0);
-    tslib_1.__decorate([
-        ContentChild(DragClueTemplateDirective, { static: false }),
-        tslib_1.__metadata("design:type", DragClueTemplateDirective)
-    ], DragAndDropDirective.prototype, "dragClueTemplate", void 0);
-    tslib_1.__decorate([
-        ContentChild(DropHintTemplateDirective, { static: false }),
-        tslib_1.__metadata("design:type", DropHintTemplateDirective)
-    ], DragAndDropDirective.prototype, "dropHintTemplate", void 0);
-    tslib_1.__decorate([
-        HostBinding('style.user-select'),
-        HostBinding('style.-ms-user-select'),
-        HostBinding('style.-moz-user-select'),
-        HostBinding('style.-webkit-user-select'),
-        tslib_1.__metadata("design:type", String)
-    ], DragAndDropDirective.prototype, "userSelectStyle", void 0);
-    DragAndDropDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoTreeViewDragAndDrop]',
-            providers: [
-                DragClueService,
-                DropHintService
-            ]
-        }),
-        tslib_1.__metadata("design:paramtypes", [ElementRef,
-            NgZone,
-            TreeViewComponent,
-            DragClueService,
-            DropHintService])
-    ], DragAndDropDirective);
-    return DragAndDropDirective;
-}());
-export { DragAndDropDirective };

package/dist/es/drag-and-drop/drag-clue/drag-clue-template.directive.js

@@ -1,34 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Directive, Optional, TemplateRef } from '@angular/core';
-/**
- * Represents the template for the TreeView drag clue when an item is dragged. To define the clue template,
- * nest an `<ng-template>` tag with the `kendoTreeViewDragClueTemplate` directive inside a `<kendo-treeview>` tag
- * ([see example]({% slug draganddrop_treeview %}#toc-templates)).
- *
- *
- * The text, attempted drop action, source item and destination item are available as context variables in the template:
- *
- *
- * - `let-text="text"` (`string`)
- * - `let-action="action"` ([`DropAction`]({% slug api_treeview_dropaction %}))
- * - `let-sourceItem="sourceItem"` ([`TreeItemLookup`]({% slug api_treeview_treeitemlookup %}))
- * - `let-destinationItem="destinationItem"` ([`TreeItemLookup`]({% slug api_treeview_treeitemlookup %}))
- */
-var DragClueTemplateDirective = /** @class */ (function () {
-    function DragClueTemplateDirective(templateRef) {
-        this.templateRef = templateRef;
-    }
-    DragClueTemplateDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoTreeViewDragClueTemplate]'
-        }),
-        tslib_1.__param(0, Optional()),
-        tslib_1.__metadata("design:paramtypes", [TemplateRef])
-    ], DragClueTemplateDirective);
-    return DragClueTemplateDirective;
-}());
-export { DragClueTemplateDirective };

package/dist/es/drag-and-drop/drag-clue/drag-clue.component.js

@@ -1,54 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Component, HostBinding, ChangeDetectorRef, ChangeDetectionStrategy } from "@angular/core";
-import { DropAction } from '../models';
-/**
- * @hidden
- */
-var DragClueComponent = /** @class */ (function () {
-    function DragClueComponent(cdr) {
-        this.cdr = cdr;
-        this.hostClasses = true;
-        this.posistionStyle = 'fixed';
-    }
-    Object.defineProperty(DragClueComponent.prototype, "statusIconClass", {
-        get: function () {
-            switch (this.action) {
-                case DropAction.Add: return 'k-i-plus';
-                case DropAction.InsertTop: return 'k-i-insert-up';
-                case DropAction.InsertBottom: return 'k-i-insert-down';
-                case DropAction.InsertMiddle: return 'k-i-insert-middle';
-                case DropAction.Invalid:
-                default: return 'k-i-cancel';
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    // exposed as a public method that can be called from outside as the component uses `OnPush` strategy
-    DragClueComponent.prototype.detectChanges = function () {
-        this.cdr.detectChanges();
-    };
-    tslib_1.__decorate([
-        HostBinding('class.k-header'),
-        HostBinding('class.k-drag-clue'),
-        tslib_1.__metadata("design:type", Boolean)
-    ], DragClueComponent.prototype, "hostClasses", void 0);
-    tslib_1.__decorate([
-        HostBinding('style.position'),
-        tslib_1.__metadata("design:type", String)
-    ], DragClueComponent.prototype, "posistionStyle", void 0);
-    DragClueComponent = tslib_1.__decorate([
-        Component({
-            changeDetection: ChangeDetectionStrategy.OnPush,
-            selector: 'kendo-treeview-drag-clue',
-            template: "\n        <ng-container *ngIf=\"!template\">\n            <span class=\"k-icon {{statusIconClass}} k-drag-status\"></span>\n            <span>{{text}}</span>\n        </ng-container>\n\n        <ng-template\n            *ngIf=\"template\"\n            [ngTemplateOutlet]=\"template\"\n            [ngTemplateOutletContext]=\"{\n                text: text,\n                action: action,\n                sourceItem: sourceItem,\n                destinationItem: destinationItem\n            }\"\n        >\n        </ng-template>\n    "
-        }),
-        tslib_1.__metadata("design:paramtypes", [ChangeDetectorRef])
-    ], DragClueComponent);
-    return DragClueComponent;
-}());
-export { DragClueComponent };

package/dist/es/drag-and-drop/drag-clue/drag-clue.service.js

@@ -1,132 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable, ComponentFactoryResolver } from '@angular/core';
-import { DragClueComponent } from './drag-clue.component';
-import { ScrollDirection } from '../models';
-import { isPresent, dataItemsEqual } from '../../utils';
-import { DragAndDropAssetService } from '../editing-services/drag-and-drop-asset.service';
-import { scrollElementBy, getScrollableContainer } from '../drag-and-drop-utils';
-/**
- * @hidden
- */
-export var CLUE_OFFSET = 10;
-/**
- * @hidden
- */
-export var RETURN_ANIMATION_DURATION = 200;
-/**
- * @hidden
- */
-var DragClueService = /** @class */ (function (_super) {
-    tslib_1.__extends(DragClueService, _super);
-    function DragClueService(componentFactoryResolver) {
-        var _this = _super.call(this) || this;
-        _this.componentFactoryResolver = componentFactoryResolver;
-        return _this;
-    }
-    DragClueService.prototype.initialize = function (container, template) {
-        if (isPresent(this._componentRef)) {
-            this.ngOnDestroy();
-        }
-        var clueComponentFactory = this.componentFactoryResolver.resolveComponentFactory(DragClueComponent);
-        this.componentRef = container.createComponent(clueComponentFactory);
-        this.hide();
-        this.componentRef.instance.template = template;
-        this.componentRef.changeDetectorRef.detectChanges();
-    };
-    DragClueService.prototype.ngOnDestroy = function () {
-        this.cancelReturnAnimation();
-        this.cancelScroll();
-        _super.prototype.ngOnDestroy.call(this);
-    };
-    DragClueService.prototype.move = function (left, top) {
-        _super.prototype.move.call(this, left, top, CLUE_OFFSET);
-    };
-    DragClueService.prototype.animateDragClueToElementPosition = function (target) {
-        var _this = this;
-        if (!(isPresent(target) && isPresent(this.element.animate))) {
-            this.hide();
-            return;
-        }
-        var targetElementViewPortCoords = target.getBoundingClientRect();
-        var clueElementViewPortCoords = this.element.getBoundingClientRect();
-        this.returnAnimation = this.element.animate([
-            { transform: 'translate(0, 0)' },
-            { transform: "translate(" + (targetElementViewPortCoords.left - clueElementViewPortCoords.left) + "px, " + (targetElementViewPortCoords.top - clueElementViewPortCoords.top) + "px)" }
-        ], RETURN_ANIMATION_DURATION);
-        this.returnAnimation.onfinish = function () { return _this.hide(); };
-    };
-    DragClueService.prototype.cancelReturnAnimation = function () {
-        if (!isPresent(this.returnAnimation)) {
-            return;
-        }
-        this.returnAnimation.cancel();
-        this.returnAnimation = null;
-    };
-    DragClueService.prototype.updateDragClueData = function (action, sourceItem, destinationItem) {
-        var dragClue = this.componentRef.instance;
-        if (action === dragClue.action && dataItemsEqual(sourceItem, dragClue.sourceItem) && dataItemsEqual(destinationItem, dragClue.destinationItem)) {
-            return;
-        }
-        dragClue.action = action;
-        dragClue.sourceItem = sourceItem;
-        dragClue.destinationItem = destinationItem;
-        dragClue.detectChanges();
-    };
-    DragClueService.prototype.updateText = function (text) {
-        if (text === this.componentRef.instance.text) {
-            return;
-        }
-        this.componentRef.instance.text = text;
-        this.componentRef.instance.detectChanges();
-    };
-    /**
-     * Triggers the first scrollable parent to scroll upwards or downwards.
-     * Uses setInterval, so should be called outside the angular zone.
-     */
-    DragClueService.prototype.scrollIntoView = function (_a) {
-        var step = _a.step, interval = _a.interval;
-        this.cancelScroll();
-        var scrollableContainer = getScrollableContainer(this.element);
-        if (!isPresent(scrollableContainer)) {
-            return;
-        }
-        var containerRect = scrollableContainer.getBoundingClientRect();
-        var clueRect = this.element.getBoundingClientRect();
-        // if the beginning of the scrollable container is above the current viewport, fall-back to 0
-        var firstVisibleClientTopPart = Math.max(containerRect.top, 0);
-        // start scrolling up when the first visible item is dragged over
-        var topLimit = firstVisibleClientTopPart + clueRect.height;
-        // if the end of the scrollable container is beneath the current viewport, fall-back to its client height
-        // add the distance from the start of the viewport to the beginning of the container to ensure scrolling bottom begins when the actual end of the container is reached
-        var bottomLimit = firstVisibleClientTopPart + Math.min(containerRect.bottom, scrollableContainer.clientHeight);
-        if (clueRect.top < topLimit) {
-            this.scrollInterval = setInterval(function () {
-                return scrollElementBy(scrollableContainer, step, ScrollDirection.Up);
-            }, interval);
-        }
-        else if (clueRect.bottom > bottomLimit) {
-            this.scrollInterval = setInterval(function () {
-                return scrollElementBy(scrollableContainer, step, ScrollDirection.Down);
-            }, interval);
-        }
-    };
-    /**
-     * Cancels out the on-going scroll animation, if present.
-     */
-    DragClueService.prototype.cancelScroll = function () {
-        if (isPresent(this.scrollInterval)) {
-            clearInterval(this.scrollInterval);
-            this.scrollInterval = null;
-        }
-    };
-    DragClueService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [ComponentFactoryResolver])
-    ], DragClueService);
-    return DragClueService;
-}(DragAndDropAssetService));
-export { DragClueService };

package/dist/es/drag-and-drop/drop-hint/drop-hint-template.directive.js

@@ -1,31 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Directive, Optional, TemplateRef } from '@angular/core';
-/**
- * Represents the template for the TreeView drop hint when an item is dragged. To define the hint template,
- * nest an `<ng-template>` tag with the `kendoTreeViewDropHintTemplate` directive inside a `<kendo-treeview>` tag
- * ([see example]({% slug draganddrop_treeview %}#toc-templates)).
- *
- * The attempted drop action, source item and destination item are available as context variables in the template:
- *
- * - `let-action="action"` ([`DropAction`]({% slug api_treeview_dropaction %}))
- * - `let-sourceItem="sourceItem"` ([`TreeItemLookup`]({% slug api_treeview_treeitemlookup %}))
- * - `let-destinationItem="destinationItem"` ([`TreeItemLookup`]({% slug api_treeview_treeitemlookup %}))
- */
-var DropHintTemplateDirective = /** @class */ (function () {
-    function DropHintTemplateDirective(templateRef) {
-        this.templateRef = templateRef;
-    }
-    DropHintTemplateDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoTreeViewDropHintTemplate]'
-        }),
-        tslib_1.__param(0, Optional()),
-        tslib_1.__metadata("design:paramtypes", [TemplateRef])
-    ], DropHintTemplateDirective);
-    return DropHintTemplateDirective;
-}());
-export { DropHintTemplateDirective };

package/dist/es/drag-and-drop/drop-hint/drop-hint.component.js

@@ -1,43 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Component, HostBinding, ChangeDetectionStrategy, ChangeDetectorRef } from '@angular/core';
-/**
- * @hidden
- */
-var DropHintComponent = /** @class */ (function () {
-    function DropHintComponent(changeDetectorRef) {
-        this.changeDetectorRef = changeDetectorRef;
-        this.hostClass = true;
-        this.position = 'fixed';
-        this.pointerEvents = 'none';
-    }
-    // exposed as a public method that can be called from outside as the component uses `OnPush` strategy
-    DropHintComponent.prototype.detectChanges = function () {
-        this.changeDetectorRef.detectChanges();
-    };
-    tslib_1.__decorate([
-        HostBinding('class.k-drop-hint-container'),
-        tslib_1.__metadata("design:type", Boolean)
-    ], DropHintComponent.prototype, "hostClass", void 0);
-    tslib_1.__decorate([
-        HostBinding('style.position'),
-        tslib_1.__metadata("design:type", String)
-    ], DropHintComponent.prototype, "position", void 0);
-    tslib_1.__decorate([
-        HostBinding('style.pointer-events'),
-        tslib_1.__metadata("design:type", String)
-    ], DropHintComponent.prototype, "pointerEvents", void 0);
-    DropHintComponent = tslib_1.__decorate([
-        Component({
-            changeDetection: ChangeDetectionStrategy.OnPush,
-            selector: 'kendo-treeview-drop-hint',
-            template: "\n        <div\n            *ngIf=\"!template\"\n            class=\"k-drop-hint k-drop-hint-h\"\n        >\n            <div class='k-drop-hint-start'></div>\n            <div class='k-drop-hint-line'></div>\n        </div>\n\n        <ng-template\n            *ngIf=\"template\"\n            [ngTemplateOutlet]=\"template\"\n            [ngTemplateOutletContext]=\"{\n                action: action,\n                sourceItem: sourceItem,\n                destinationItem: destinationItem\n            }\"\n        >\n        <ng-template>\n    "
-        }),
-        tslib_1.__metadata("design:paramtypes", [ChangeDetectorRef])
-    ], DropHintComponent);
-    return DropHintComponent;
-}());
-export { DropHintComponent };