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

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

@@ -1,46 +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 { dataItemsEqual, isPresent } from '../../utils';
-import { DropHintComponent } from './drop-hint.component';
-import { DragAndDropAssetService } from '../editing-services/drag-and-drop-asset.service';
-/**
- * @hidden
- */
-var DropHintService = /** @class */ (function (_super) {
-    tslib_1.__extends(DropHintService, _super);
-    function DropHintService(componentFactoryResolver) {
-        var _this = _super.call(this) || this;
-        _this.componentFactoryResolver = componentFactoryResolver;
-        return _this;
-    }
-    DropHintService.prototype.initialize = function (container, template) {
-        if (isPresent(this._componentRef)) {
-            this.ngOnDestroy();
-        }
-        var hintComponentFactory = this.componentFactoryResolver.resolveComponentFactory(DropHintComponent);
-        this.componentRef = container.createComponent(hintComponentFactory);
-        this.hide();
-        this.componentRef.instance.template = template;
-        this.componentRef.changeDetectorRef.detectChanges();
-    };
-    DropHintService.prototype.updateDropHintData = function (action, sourceItem, destinationItem) {
-        var dropHint = this.componentRef.instance;
-        if (action === dropHint.action && dataItemsEqual(sourceItem, dropHint.sourceItem) && dataItemsEqual(destinationItem, dropHint.destinationItem)) {
-            return;
-        }
-        dropHint.action = action;
-        dropHint.sourceItem = sourceItem;
-        dropHint.destinationItem = destinationItem;
-        dropHint.detectChanges();
-    };
-    DropHintService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [ComponentFactoryResolver])
-    ], DropHintService);
-    return DropHintService;
-}(DragAndDropAssetService));
-export { DropHintService };

package/dist/es/drag-and-drop/editing-services/drag-and-drop-asset.service.js

@@ -1,53 +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 { isPresent } from '../../utils';
-/**
- * @hidden
- */
-var DragAndDropAssetService = /** @class */ (function () {
-    function DragAndDropAssetService() {
-    }
-    Object.defineProperty(DragAndDropAssetService.prototype, "componentRef", {
-        get: function () {
-            if (!isPresent(this._componentRef)) {
-                throw new Error('The `initalize` method must be called before calling other service methods.');
-            }
-            return this._componentRef;
-        },
-        set: function (componentRef) {
-            this._componentRef = componentRef;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DragAndDropAssetService.prototype, "element", {
-        get: function () {
-            return this.componentRef.location.nativeElement;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    DragAndDropAssetService.prototype.ngOnDestroy = function () {
-        if (!isPresent(this._componentRef)) {
-            return;
-        }
-        this.element.parentElement.removeChild(this.element);
-        this.componentRef.destroy();
-        this.componentRef = null;
-    };
-    DragAndDropAssetService.prototype.show = function () {
-        this.element.style.display = '';
-    };
-    DragAndDropAssetService.prototype.hide = function () {
-        this.element.style.display = 'none';
-    };
-    DragAndDropAssetService.prototype.move = function (left, top, offset) {
-        if (offset === void 0) { offset = 0; }
-        this.element.style.left = left + offset + "px";
-        this.element.style.top = top + offset + "px";
-    };
-    return DragAndDropAssetService;
-}());
-export { DragAndDropAssetService };

package/dist/es/drag-and-drop/editing-services/flat-editing.service.js

@@ -1,145 +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 { getter, setter } from '@progress/kendo-common';
-import { take } from 'rxjs/operators';
-import { DropPosition } from '../models';
-import { expandDropTarget, collapseEmptyParent, updateMovedItemIndex } from '../drag-and-drop-utils';
-import { incrementPageSize, copyPageSize, decrementPageSize } from '../../load-more/load-more-utils';
-import { buildTreeIndex, getDataItem, isPresent } from '../../utils';
-/**
- * @hidden
- */
-var FlatEditingService = /** @class */ (function () {
-    function FlatEditingService(flatBinding) {
-        this.flatBinding = flatBinding;
-    }
-    FlatEditingService.prototype.add = function (_a) {
-        var sourceItem = _a.sourceItem, destinationItem = _a.destinationItem, dropPosition = _a.dropPosition, sourceTree = _a.sourceTree, destinationTree = _a.destinationTree;
-        // shallow clone the item as not to mistake it for its 'older' version when the remove handler kicks in to splice the item at its old position
-        var clonedSourceDataItem = Object.assign({}, getDataItem(sourceItem));
-        if (dropPosition === DropPosition.Over) {
-            // expand the item that was dropped into
-            expandDropTarget(destinationItem, destinationTree);
-            var destinationItemId = getter(this.flatBinding.idField)(getDataItem(destinationItem));
-            setter(this.flatBinding.parentIdField)(clonedSourceDataItem, destinationItemId);
-            var lastChildNodeIndex = this.getLastVisibleChildNodeIndex(destinationTree, this.flatBinding.originalData, getDataItem(destinationItem));
-            // insert after the last visible child
-            var targetIndex = lastChildNodeIndex + 1;
-            this.flatBinding.originalData.splice(targetIndex, 0, clonedSourceDataItem);
-            // rebind the treeview data before searching for the focus target index
-            this.rebindData();
-            var focusTarget = this.fetchChildNodes(getDataItem(destinationItem), destinationTree).indexOf(clonedSourceDataItem);
-            this.movedItemNewIndex = buildTreeIndex(destinationItem.item.index, focusTarget);
-        }
-        else {
-            var shiftIndex = dropPosition === DropPosition.After ? 1 : 0;
-            var targetIndex = this.flatBinding.originalData.indexOf(getDataItem(destinationItem)) + shiftIndex;
-            this.flatBinding.originalData.splice(targetIndex, 0, clonedSourceDataItem);
-            var destinationItemParentId = getter(this.flatBinding.parentIdField)(getDataItem(destinationItem));
-            setter(this.flatBinding.parentIdField)(clonedSourceDataItem, destinationItemParentId);
-            // rebind the treeview data before searching for the focus target index
-            this.rebindData();
-            var parentIndex = destinationItem.parent ?
-                destinationItem.parent.item.index :
-                null;
-            var parentContainer = destinationItem.parent ?
-                this.fetchChildNodes(getDataItem(destinationItem.parent), destinationTree) :
-                destinationTree.nodes;
-            var focusTarget = parentContainer.indexOf(clonedSourceDataItem);
-            this.movedItemNewIndex = buildTreeIndex(parentIndex, focusTarget);
-        }
-        if (sourceTree !== destinationTree) {
-            this.addChildNodes(clonedSourceDataItem, sourceTree);
-        }
-        // increment the parent page size => an item is moved into it
-        var updatedParent = dropPosition === DropPosition.Over ? getDataItem(destinationItem) : getDataItem(destinationItem.parent);
-        incrementPageSize(destinationTree, updatedParent);
-        // the page sizes are stored by data-item reference => copy the old item ref page size to the new item reference
-        copyPageSize(destinationTree, getDataItem(sourceItem), clonedSourceDataItem);
-        // the source tree nodes are reloaded on `removeItem` - reload the destination tree nodes if the soruce and the destination tree are different
-        if (sourceTree !== destinationTree && !destinationTree.loadOnDemand) {
-            destinationTree.preloadChildNodes();
-        }
-        // if the source and destination trees are the same, focusing the moved item here will not have the desired effect
-        // as the `remove` handler has not yet kicked-in to remove the item from its old position
-        if (sourceTree !== destinationTree) {
-            // ensure the focus target is rendered and registered
-            destinationTree.changeDetectorRef.detectChanges();
-            destinationTree.focus(this.movedItemNewIndex);
-        }
-    };
-    FlatEditingService.prototype.remove = function (_a) {
-        var sourceItem = _a.sourceItem, sourceTree = _a.sourceTree, destinationTree = _a.destinationTree;
-        var sourceDataItem = getDataItem(sourceItem);
-        var sourceItemIndex = this.flatBinding.originalData.indexOf(sourceDataItem);
-        this.flatBinding.originalData.splice(sourceItemIndex, 1);
-        if (sourceTree !== destinationTree) {
-            this.removeChildNodes(sourceDataItem, sourceTree);
-        }
-        this.rebindData();
-        // emit collapse for the parent node if its last child node was spliced
-        var parentChildren = sourceItem.parent ? sourceItem.parent.children : [];
-        collapseEmptyParent(sourceItem.parent, parentChildren, sourceTree);
-        // decrement source item parent page size => an item has been removed from it
-        decrementPageSize(sourceTree, getDataItem(sourceItem.parent));
-        // reload the treeview nodes
-        if (!sourceTree.loadOnDemand) {
-            sourceTree.preloadChildNodes();
-        }
-        // if the source and destination trees are different we want to focus only the moved item in the destination tree
-        if (sourceTree === destinationTree) {
-            // ensure the focus target is rendered and registered
-            destinationTree.changeDetectorRef.detectChanges();
-            // after the source item is removed from its original position, the candidate index might have to be corrected
-            var index = updateMovedItemIndex(this.movedItemNewIndex, sourceItem.item.index);
-            destinationTree.focus(index);
-        }
-    };
-    FlatEditingService.prototype.addChildNodes = function (dataItem, source) {
-        var _a;
-        var itemChildren = this.fetchAllDescendantNodes(dataItem, source);
-        (_a = this.flatBinding.originalData).push.apply(_a, itemChildren);
-    };
-    FlatEditingService.prototype.removeChildNodes = function (dataItem, source) {
-        var _this = this;
-        var sourceChildren = this.fetchAllDescendantNodes(dataItem, source);
-        sourceChildren.forEach(function (item) {
-            var index = _this.flatBinding.originalData.indexOf(item);
-            _this.flatBinding.originalData.splice(index, 1);
-        });
-    };
-    FlatEditingService.prototype.fetchAllDescendantNodes = function (node, treeview) {
-        var _this = this;
-        var nodes = this.fetchChildNodes(node, treeview);
-        nodes.forEach(function (node) { return nodes = nodes.concat(_this.fetchAllDescendantNodes(node, treeview) || []); });
-        return nodes;
-    };
-    FlatEditingService.prototype.fetchChildNodes = function (node, treeview) {
-        if (!node) {
-            return [];
-        }
-        var nodes = [];
-        treeview
-            .children(node)
-            .pipe(take(1))
-            .subscribe(function (children) { return nodes = nodes.concat(children || []); });
-        return nodes;
-    };
-    FlatEditingService.prototype.getLastVisibleChildNodeIndex = function (treeview, data, node) {
-        if (!isPresent(treeview.loadMoreService) || !treeview.hasChildren(node)) {
-            return data.length;
-        }
-        var visibleNodesCount = treeview.loadMoreService.getGroupSize(node);
-        var visibleChildren = this.fetchChildNodes(node, treeview).slice(0, visibleNodesCount);
-        var lastNode = visibleChildren[visibleChildren.length - 1];
-        var lastNodeIndex = data.indexOf(lastNode);
-        return lastNodeIndex;
-    };
-    FlatEditingService.prototype.rebindData = function () {
-        this.flatBinding.nodes = this.flatBinding.originalData;
-    };
-    return FlatEditingService;
-}());
-export { FlatEditingService };

package/dist/es/drag-and-drop/editing-services/hierarchy-editing.service.js

@@ -1,90 +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 { getter, setter } from '@progress/kendo-common';
-import { DropPosition } from '../models';
-import { collapseEmptyParent, expandDropTarget, updateMovedItemIndex } from '../drag-and-drop-utils';
-import { decrementPageSize, incrementPageSize, copyPageSize } from '../../load-more/load-more-utils';
-import { isPresent, getDataItem, buildTreeIndex } from '../../utils';
-/**
- * @hidden
- */
-var HierarchyEditingService = /** @class */ (function () {
-    function HierarchyEditingService(hierarchyBinding) {
-        this.hierarchyBinding = hierarchyBinding;
-    }
-    HierarchyEditingService.prototype.add = function (_a) {
-        var sourceItem = _a.sourceItem, destinationItem = _a.destinationItem, dropPosition = _a.dropPosition, sourceTree = _a.sourceTree, destinationTree = _a.destinationTree;
-        // shallow clone the item as not to mistake it for its 'older' version when the remove handler kicks in to splice the item at its old position
-        var clonedSourceDataItem = Object.assign({}, getDataItem(sourceItem));
-        if (dropPosition === DropPosition.Over) {
-            // expand the item that was dropped into
-            expandDropTarget(destinationItem, destinationTree);
-            var destinationChildren = this.childrenFor(getDataItem(destinationItem));
-            // add the moved node just before the load more button if load more is enabled
-            var targetIndex = isPresent(destinationTree.loadMoreService) ?
-                Math.min(destinationTree.loadMoreService.getGroupSize(getDataItem(destinationItem)), destinationChildren.length) : // the page size might be greater than the actual children array length
-                destinationChildren.length;
-            destinationChildren.splice(targetIndex, 0, clonedSourceDataItem);
-            setter(this.hierarchyBinding.childrenField)(getDataItem(destinationItem), destinationChildren);
-            this.movedItemNewIndex = buildTreeIndex(destinationItem.item.index, targetIndex);
-        }
-        else {
-            var destinationParentNodes = this.getParentNodes(destinationItem, destinationTree);
-            var shiftIndex = dropPosition === DropPosition.After ? 1 : 0;
-            var targetIndex = destinationParentNodes.indexOf(getDataItem(destinationItem)) + shiftIndex;
-            destinationParentNodes.splice(targetIndex, 0, clonedSourceDataItem);
-            var parentIndex = destinationItem.parent ? destinationItem.parent.item.index : null;
-            this.movedItemNewIndex = buildTreeIndex(parentIndex, targetIndex);
-        }
-        // increment the parent page size => an item is moved into it
-        var updatedParent = dropPosition === DropPosition.Over ? getDataItem(destinationItem) : getDataItem(destinationItem.parent);
-        incrementPageSize(destinationTree, updatedParent);
-        // the page sizes are stored by data-item reference => copy the old item ref page size to the new item reference
-        copyPageSize(destinationTree, getDataItem(sourceItem), clonedSourceDataItem);
-        // the source tree nodes are reloaded on `removeItem` - reload the destination tree nodes if the soruce and the destination tree are different
-        if (sourceTree !== destinationTree && !destinationTree.loadOnDemand) {
-            destinationTree.preloadChildNodes();
-        }
-        // if the source and destination trees are the same, focusing the moved item here will not have the desired effect
-        // as the `remove` handler has not yet kicked-in to remove the item from its old position
-        if (sourceTree !== destinationTree) {
-            // ensure the focus target is rendered and registered
-            destinationTree.changeDetectorRef.detectChanges();
-            destinationTree.focus(this.movedItemNewIndex);
-        }
-    };
-    HierarchyEditingService.prototype.remove = function (_a) {
-        var sourceItem = _a.sourceItem, sourceTree = _a.sourceTree, destinationTree = _a.destinationTree;
-        var sourceParentNodes = this.getParentNodes(sourceItem, sourceTree);
-        var sourceItemIndex = sourceParentNodes.indexOf(getDataItem(sourceItem));
-        sourceParentNodes.splice(sourceItemIndex, 1);
-        // emit collapse for the parent node if its last child node was spliced
-        collapseEmptyParent(sourceItem.parent, sourceParentNodes, sourceTree);
-        // decrement source item parent page size => an item has been removed from it
-        decrementPageSize(sourceTree, getDataItem(sourceItem.parent));
-        // reload the treeview nodes
-        if (!sourceTree.loadOnDemand) {
-            sourceTree.preloadChildNodes();
-        }
-        // if the source and destination trees are different we want to focus only the moved item in the destination tree
-        if (sourceTree === destinationTree) {
-            // ensure the focus target is rendered and registered
-            destinationTree.changeDetectorRef.detectChanges();
-            // after the source item is removed from its original position, the candidate index might have to be corrected
-            var index = updateMovedItemIndex(this.movedItemNewIndex, sourceItem.item.index);
-            destinationTree.focus(index);
-        }
-    };
-    HierarchyEditingService.prototype.getParentNodes = function (node, treeView) {
-        return isPresent(node.parent) ?
-            this.childrenFor(getDataItem(node.parent)) :
-            treeView.nodes;
-    };
-    HierarchyEditingService.prototype.childrenFor = function (dataItem) {
-        return getter(this.hierarchyBinding.childrenField)(dataItem) || [];
-    };
-    return HierarchyEditingService;
-}());
-export { HierarchyEditingService };

package/dist/es/drag-and-drop/models/editing-service.js

@@ -1,4 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/

package/dist/es/drag-and-drop/models/preventable-event.js

@@ -1,29 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-var PreventableEvent = /** @class */ (function () {
-    function PreventableEvent() {
-        this.prevented = false;
-    }
-    /**
-     * Prevents the default action for a specified event.
-     * In this way, the source component suppresses the built-in behavior that follows the event.
-     */
-    PreventableEvent.prototype.preventDefault = function () {
-        this.prevented = true;
-    };
-    /**
-     * If the event is prevented by any of its subscribers, returns `true`.
-     *
-     * @returns `true` if the default action was prevented. Otherwise, returns `false`.
-     */
-    PreventableEvent.prototype.isDefaultPrevented = function () {
-        return this.prevented;
-    };
-    return PreventableEvent;
-}());
-export { PreventableEvent };

package/dist/es/drag-and-drop/models/treeitem-drag-event.js

@@ -1,14 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * Arguments for the TreeView [`nodeDrag`]({% slug api_treeview_treeviewcomponent %}#toc-nodedrag) and
- * [`nodeDragEnd`]({% slug api_treeview_treeviewcomponent %}#toc-nodedragend) events.
- */
-var TreeItemDragEvent = /** @class */ (function () {
-    function TreeItemDragEvent() {
-    }
-    return TreeItemDragEvent;
-}());
-export { TreeItemDragEvent };

package/dist/es/drag-and-drop/models/treeitem-drag-start-event.js

@@ -1,22 +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 { PreventableEvent } from './preventable-event';
-/**
- * Arguments for the TreeView [`nodeDragStart`]({% slug api_treeview_treeviewcomponent %}#toc-nodedragstart) event.
- */
-var TreeItemDragStartEvent = /** @class */ (function (_super) {
-    tslib_1.__extends(TreeItemDragStartEvent, _super);
-    /**
-     * @hidden
-     */
-    function TreeItemDragStartEvent(initializer) {
-        var _this = _super.call(this) || this;
-        Object.assign(_this, initializer);
-        return _this;
-    }
-    return TreeItemDragStartEvent;
-}(PreventableEvent));
-export { TreeItemDragStartEvent };

package/dist/es/drag-and-drop/models/treeitem-drop-event.js

@@ -1,36 +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 { PreventableEvent } from './preventable-event';
-/**
- * Arguments for the TreeView [`nodeDrop`]({% slug api_treeview_treeviewcomponent %}#toc-nodedrop) event.
- */
-var TreeItemDropEvent = /** @class */ (function (_super) {
-    tslib_1.__extends(TreeItemDropEvent, _super);
-    /**
-     * @hidden
-     */
-    function TreeItemDropEvent(initializer, originalEvent) {
-        var _this = _super.call(this) || this;
-        /**
-         * @hidden
-         */
-        _this.isValid = true;
-        Object.assign(_this, initializer);
-        _this.originalEvent = originalEvent;
-        return _this;
-    }
-    /**
-     * Specifies if the drop action should be marked as valid.
-     * If set to `false`, the [`addItem`]({% slug api_treeview_treeviewcomponent %}#toc-additem) and
-     * [`removeItem`]({% slug api_treeview_treeviewcomponent %}#toc-removeitem) events will not be fired and the drag clue
-     * will be animated back to the source item to indicate the action is marked as invalid.
-     */
-    TreeItemDropEvent.prototype.setValid = function (isValid) {
-        this.isValid = isValid;
-    };
-    return TreeItemDropEvent;
-}(PreventableEvent));
-export { TreeItemDropEvent };

package/dist/es/expand-state.service.js

@@ -1,26 +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 } from "@angular/core";
-import { Subject } from "rxjs";
-/**
- * @hidden
- */
-var ExpandStateService = /** @class */ (function () {
-    function ExpandStateService() {
-        this.changes = new Subject();
-    }
-    ExpandStateService.prototype.expand = function (index, dataItem) {
-        this.changes.next({ dataItem: dataItem, index: index, expand: true });
-    };
-    ExpandStateService.prototype.collapse = function (index, dataItem) {
-        this.changes.next({ dataItem: dataItem, index: index, expand: false });
-    };
-    ExpandStateService = tslib_1.__decorate([
-        Injectable()
-    ], ExpandStateService);
-    return ExpandStateService;
-}());
-export { ExpandStateService };