@progress/kendo-angular-treeview 6.0.2 → 7.0.0-next.202203241311

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

@@ -1,274 +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 { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { isPresent, closestNode, closestWithMatch, hasParent, isContent, nodeId, getContentElement } from '../utils';
-import { DropPosition, DropAction, ScrollDirection } from './models';
-var ɵ0 = function () {
-    if (!(isDocumentAvailable() && isPresent(document.body))) {
-        return false;
-    }
-    var top = 10;
-    var parent = document.createElement("div");
-    parent.style.transform = "matrix(10, 0, 0, 10, 0, 0)";
-    parent.innerHTML = "<div style=\"position: fixed; top: " + top + "px;\">child</div>";
-    document.body.appendChild(parent);
-    var isDifferent = parent.children[0].getBoundingClientRect().top !== top;
-    document.body.removeChild(parent);
-    return isDifferent;
-};
-/**
- * Checks if the browser supports relative stacking context.
- * https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context
- */
-var hasRelativeStackingContext = memoize(ɵ0);
-/**
- * Stores the result of the passed function's first invokation and returns it instead of invoking it again afterwards.
- */
-function memoize(fn) {
-    var result;
-    var called = false;
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        if (called) {
-            return result;
-        }
-        result = fn.apply(void 0, args);
-        called = true;
-        return result;
-    };
-}
-/**
- * @hidden
- *
- * Gets 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
- *
- * If no parent container is `transform`-ed the function will return `{ left: 0, top: 0 }`;
- */
-export var getContainerOffset = function (element) {
-    if (!(element && hasRelativeStackingContext())) {
-        return { left: 0, top: 0 };
-    }
-    var offsetParent = element.parentElement;
-    while (offsetParent) {
-        if (window.getComputedStyle(offsetParent).transform !== 'none') {
-            break;
-        }
-        offsetParent = offsetParent.parentElement;
-    }
-    if (offsetParent) {
-        var rect = offsetParent.getBoundingClientRect();
-        return {
-            left: rect.left - offsetParent.scrollLeft,
-            top: rect.top - offsetParent.scrollTop
-        };
-    }
-    return { left: 0, top: 0 };
-};
-/**
- * @hidden
- */
-export var getDropAction = function (dropPosition, dropTarget) {
-    if (!(isPresent(dropPosition) && isPresent(dropTarget))) {
-        return DropAction.Invalid;
-    }
-    switch (dropPosition) {
-        case DropPosition.Over:
-            return DropAction.Add;
-        case DropPosition.Before:
-            return isPresent(closestNode(dropTarget).previousElementSibling) ? DropAction.InsertMiddle : DropAction.InsertTop;
-        case DropPosition.After:
-            return isPresent(closestNode(dropTarget).nextElementSibling) ? DropAction.InsertMiddle : DropAction.InsertBottom;
-        default:
-            return DropAction.Invalid;
-    }
-};
-/**
- * @hidden
- */
-export var getDropPosition = function (draggedItem, target, clientY, targetTreeView, containerOffset) {
-    if (!(isPresent(draggedItem) && isPresent(target) && isPresent(targetTreeView) && isPresent(containerOffset))) {
-        return;
-    }
-    // the .k-treeview-mid element starts just after the checkbox/expand arrow and stretches till the end of the treeview on the right
-    var item = closestWithMatch(target, '.k-treeview-mid');
-    if (!isPresent(item)) {
-        return;
-    }
-    // the content element (.k-treeview-leaf:not(.k-treeview-load-more-button)) holds just the treeview item text
-    var content = getContentElement(item);
-    var targetChildOfDraggedItem = hasParent(item, closestNode(draggedItem));
-    if (!isPresent(content) || (content === draggedItem) || targetChildOfDraggedItem) {
-        return;
-    }
-    var itemViewPortCoords = content.getBoundingClientRect();
-    /*
-        if the user is hovering a treeview item, split the item height into four parts:
-            - dropping into the top quarter should insert the dragged item before the drop target
-            - dropping into the bottom quarter should insert the dragged item after the drop target
-            - dropping into the second or third quarter should add the item as child node of the drop target
-
-        if the user is NOT hovering a treeview item (he's dragging somewhere on the right), split the item height to just two parts:
-            - dropping should insert before or after
-    */
-    var itemDivisionHeight = itemViewPortCoords.height / (isContent(target) ? 4 : 2);
-    // clear any possible container offset created by parent elements with `transform` css property set
-    var pointerPosition = clientY - containerOffset.top;
-    var itemTop = itemViewPortCoords.top - containerOffset.top;
-    if (pointerPosition < itemTop + itemDivisionHeight) {
-        return DropPosition.Before;
-    }
-    if (pointerPosition >= itemTop + itemViewPortCoords.height - itemDivisionHeight) {
-        return DropPosition.After;
-    }
-    return DropPosition.Over;
-};
-/**
- * @hidden
- */
-export var treeItemFromEventTarget = function (treeView, dropTarget) {
-    if (!(isPresent(treeView) && isPresent(dropTarget))) {
-        return null;
-    }
-    var node = closestNode(dropTarget);
-    var index = nodeId(node);
-    var lookup = treeView.itemLookup(index);
-    if (!(isPresent(lookup) && isPresent(lookup.item.dataItem))) {
-        return null;
-    }
-    return lookup;
-};
-/**
- * @hidden
- *
- * Emits `collapse` on the specified TreeView node if the latter is left empty after its last child node was dragged out.
- */
-export var collapseEmptyParent = function (parent, parentNodes, treeview) {
-    if (isPresent(parent) && parentNodes.length === 0 && treeview.isExpanded(parent.item.dataItem, parent.item.index)) {
-        treeview.collapseNode(parent.item.dataItem, parent.item.index);
-    }
-};
-/**
- * @hidden
- *
- * Expands the node if it's dropped into and it's not yet expanded.
- */
-export var expandDropTarget = function (dropTarget, treeView) {
-    if (!treeView.isExpanded(dropTarget.item.dataItem, dropTarget.item.index)) {
-        treeView.expandNode(dropTarget.item.dataItem, dropTarget.item.index);
-    }
-};
-/**
- * @hidden
- *
- * Extracts the event target from the viewport coords. Required for touch devices
- * where the `event.target` of a `pointermove` event is always the initially dragged item.
- */
-export var getDropTarget = function (event) {
-    if (!(isDocumentAvailable() && isPresent(document.elementFromPoint))) {
-        return event.target;
-    }
-    return document.elementFromPoint(event.clientX, event.clientY);
-};
-/**
- * @hidden
- *
- * Checks if the original index is before the new one and corrects the new one by decrementing the index for the level, where the original item stood.
- */
-export var updateMovedItemIndex = function (newIndex, originalIndex) {
-    var movedItemNewIndexParts = newIndex.split('_');
-    var originalItemIndexParts = originalIndex.split('_');
-    // if the original item was moved from a deeper level, there's no need for index correction
-    // e.g. 4_0_1 is moved to 5_0 => removing 4_0_1 will not cause 5_0 to be moved
-    if (movedItemNewIndexParts.length < originalItemIndexParts.length) {
-        return newIndex;
-    }
-    // check if the parent item paths are the same - index correction is not required when the original item path differs from the path of the moved item - they belong to different hierarchies
-    // e.g. 4_1 is moved to 5_1 - the parent item paths are differen (4 compared to 5) => removing 4_1 will not cause 5_1 to be moved
-    // e.g 4_1 is moved to 4_3 - the parent paths are the same (both 4) => removing 4_1 will cause 4_3 to be moved
-    var originalItemParentPathLength = originalItemIndexParts.length - 1;
-    var originalItemParentPath = originalItemIndexParts.slice(0, originalItemParentPathLength).join('_');
-    var movedItemParentPath = movedItemNewIndexParts.slice(0, originalItemParentPathLength).join('_');
-    // check if the the index of the level where the original item is taken from is greater than the one of the moved item
-    // e.g. 4_5 is moved to 4_1 (comapre 5 and 1) => removing 4_5 will not cause 4_1 to be moved
-    // e.g. 4_1 is moved to 4_5 (comapre 1 and 5) => removing 4_1 will cause 4_5 to be moved
-    var originalItemIndexLevel = originalItemIndexParts.length - 1;
-    var originalItemLevelIndex = Number(originalItemIndexParts[originalItemIndexLevel]);
-    var movedItemLevelIndex = Number(movedItemNewIndexParts[originalItemIndexLevel]);
-    if ((originalItemParentPath === movedItemParentPath) && (movedItemLevelIndex > originalItemLevelIndex)) {
-        // if the removed item causes the dropped item to be moved a position up - decrement the index at that level
-        movedItemNewIndexParts[originalItemIndexLevel] = String(movedItemLevelIndex - 1);
-        return movedItemNewIndexParts.join('_');
-    }
-    return newIndex;
-};
-/**
- * @hidden
- */
-var SCROLLBAR_REG_EXP = new RegExp('(auto|scroll)');
-/**
- * @hidden
- *
- * Retrives the first scrollable element starting the search from the provided one, traversing to the top of the DOM tree.
- */
-export var getScrollableContainer = function (node) {
-    while (isPresent(node) && node.nodeName !== 'HTML') {
-        var hasOverflow = node.scrollHeight > node.clientHeight;
-        var hasScrollbar = SCROLLBAR_REG_EXP.test(getComputedStyle(node).overflowY);
-        if (hasOverflow && hasScrollbar) {
-            return node;
-        }
-        node = node.parentNode;
-    }
-    return node;
-};
-/**
- * @hidden
- *
- * Checks if the top of the scrollable element is reached.
- * Floors the scrollTop value.
- */
-var isTopReached = function (element) { return Math.floor(element.scrollTop) <= 0; };
-var ɵ1 = isTopReached;
-/**
- * @hidden
- *
- * Checks if the bottom of the scrollable element is reached.
- * Ceils the scrollTop value.
- */
-var isBottomReached = function (element) { return Math.ceil(element.scrollTop) >= element.scrollHeight - element.clientHeight; };
-var ɵ2 = isBottomReached;
-/**
- * @hidden
- *
- * Scrolls the element in the given direction by the provided step.
- *
- * If the targeted scroll incrementation doesn't yield any result due to device pixel ratio issues (https://github.com/dimitar-pechev/RenderingIndependentScrollOffsets#readme),
- * increments the step with 1px and again attempts to change the scrollTop of the element, until the content is actually scrolled.
- *
- * Cuts the operation short after 20 unsuccessful attempts to prevent infinite loops in possible corner-case scenarios.
- */
-export var scrollElementBy = function (element, step, direction) {
-    if (!(isPresent(element) && isDocumentAvailable())) {
-        return;
-    }
-    var initialScrollTop = element.scrollTop;
-    var currentStep = step;
-    var iterations = 0;
-    while (initialScrollTop === element.scrollTop &&
-        !(direction === ScrollDirection.Up && isTopReached(element)) &&
-        !(direction === ScrollDirection.Down && isBottomReached(element)) &&
-        iterations < 20 // as the bulgarian saying goes - to ties our underpants
-    ) {
-        element.scrollTop += (currentStep * direction);
-        currentStep += 1;
-        iterations += 1;
-    }
-};
-export { ɵ0, ɵ1, ɵ2 };

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