@progress/kendo-angular-treelist 3.1.3-dev.202110041229

package/dist/es/scrolling/scroll-sync.service.js

@@ -0,0 +1,89 @@
+/**-----------------------------------------------------------------------------------------
+* 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, NgZone } from '@angular/core';
+import { Subscription, Subject, fromEvent } from 'rxjs';
+import { distinctUntilChanged, filter, map, tap } from 'rxjs/operators';
+/**
+ * @hidden
+ */
+var ScrollSyncService = /** @class */ (function () {
+    function ScrollSyncService(ngZone) {
+        var _this = this;
+        this.ngZone = ngZone;
+        this.changes = new Subject();
+        this.elements = [];
+        this.subscriptions = new Subscription();
+        this.headerSubscription = new Subscription();
+        this.bodySubscription = new Subscription();
+        this.subscriptions.add(this.changes.subscribe(function (args) { return _this.scrollLeft(args); }));
+    }
+    ScrollSyncService.prototype.registerEmitter = function (el, sourceType) {
+        var _this = this;
+        this.unregister(sourceType);
+        this.elements.push({ element: el, sourceType: sourceType });
+        if (sourceType === "body" || sourceType === "header") {
+            this.ngZone.runOutsideAngular(function () {
+                var obs = fromEvent(el, "scroll").pipe(map(function (_a) {
+                    var scrollLeft = _a.target.scrollLeft;
+                    return ({
+                        scrollLeft: scrollLeft,
+                        sourceType: sourceType
+                    });
+                }));
+                var subscription = obs.pipe(distinctUntilChanged(function (x, y) { return (x.scrollLeft === y.scrollLeft); }), filter(function (x) { return !_this.source || _this.source === x.sourceType; }), tap(function (x) { return _this.source = x.sourceType; }))
+                    .subscribe(function (x) { return _this.changes.next(x); });
+                subscription.add(obs.pipe(filter(function (x) { return _this.source && _this.source !== x.sourceType; }))
+                    .subscribe(function () { return _this.source = undefined; }));
+                if (sourceType === "body") {
+                    _this.bodySubscription.add(subscription);
+                }
+                else {
+                    _this.headerSubscription.add(subscription);
+                }
+            });
+        }
+    };
+    /**
+     * destroy
+     */
+    ScrollSyncService.prototype.destroy = function () {
+        this.subscriptions.unsubscribe();
+        this.headerSubscription.unsubscribe();
+        this.bodySubscription.unsubscribe();
+    };
+    ScrollSyncService.prototype.scrollLeft = function (_a) {
+        var _this = this;
+        var scrollLeft = _a.scrollLeft, sourceType = _a.sourceType;
+        this.ngZone.runOutsideAngular(function () {
+            _this.elements
+                .filter(function (x) { return sourceType !== x.sourceType; })
+                .forEach(function (_a) {
+                var element = _a.element;
+                return element.scrollLeft = scrollLeft;
+            });
+        });
+    };
+    ScrollSyncService.prototype.unregister = function (sourceType) {
+        var index = this.elements.findIndex(function (x) { return x.sourceType === sourceType; });
+        if (index > -1) {
+            if (sourceType === "header") {
+                this.headerSubscription.unsubscribe();
+                this.headerSubscription = new Subscription();
+            }
+            else if (sourceType === "body") {
+                this.bodySubscription.unsubscribe();
+                this.bodySubscription = new Subscription();
+            }
+            this.elements.splice(index, 1);
+        }
+    };
+    ScrollSyncService = tslib_1.__decorate([
+        Injectable(),
+        tslib_1.__metadata("design:paramtypes", [NgZone])
+    ], ScrollSyncService);
+    return ScrollSyncService;
+}());
+export { ScrollSyncService };

package/dist/es/scrolling/scroller.service.js

@@ -0,0 +1,115 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Observable, BehaviorSubject } from 'rxjs';
+/**
+ * @hidden
+ */
+var ScrollAction = /** @class */ (function () {
+    function ScrollAction(offset) {
+        this.offset = offset;
+    }
+    return ScrollAction;
+}());
+export { ScrollAction };
+/**
+ * @hidden
+ */
+var PageAction = /** @class */ (function () {
+    function PageAction(skip, take) {
+        this.skip = skip;
+        this.take = take;
+    }
+    return PageAction;
+}());
+export { PageAction };
+/**
+ * @hidden
+ */
+var ScrollBottomAction = /** @class */ (function () {
+    function ScrollBottomAction() {
+    }
+    return ScrollBottomAction;
+}());
+export { ScrollBottomAction };
+var SCROLL_BOTTOM_THRESHOLD = 1;
+/**
+ * @hidden
+ */
+var ScrollerService = /** @class */ (function () {
+    function ScrollerService(scrollObservable) {
+        this.scrollObservable = scrollObservable;
+        this.firstLoaded = 0;
+        this.lastScrollTop = 0;
+    }
+    ScrollerService.prototype.create = function (rowHeightService, skip, take, total, scrollTop) {
+        var _this = this;
+        if (scrollTop === void 0) { scrollTop = 0; }
+        this.rowHeightService = rowHeightService;
+        this.firstLoaded = skip;
+        this.lastLoaded = skip + take;
+        this.take = take;
+        this.total = total;
+        this.lastScrollTop = scrollTop;
+        var subject = new BehaviorSubject(new ScrollAction(this.rowHeightService.offset(skip)));
+        this.subscription = Observable.create(function (observer) {
+            _this.unsubscribe();
+            _this.scrollSubscription = _this.scrollObservable.subscribe(function (x) { return _this.onScroll(x, observer); });
+        }).subscribe(function (x) { return subject.next(x); });
+        return subject;
+    };
+    ScrollerService.prototype.destroy = function () {
+        this.unsubscribe();
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    };
+    ScrollerService.prototype.onScroll = function (_a, observer) {
+        var scrollTop = _a.scrollTop, offsetHeight = _a.offsetHeight, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;
+        if (this.lastScrollTop === scrollTop) {
+            return;
+        }
+        var up = this.lastScrollTop >= scrollTop;
+        this.lastScrollTop = scrollTop;
+        var firstItemIndex = this.rowHeightService.index(scrollTop);
+        var firstItemOffset = this.rowHeightService.offset(firstItemIndex);
+        var lastItemIndex = this.rowHeightService.index(scrollTop + offsetHeight);
+        if (!up) {
+            if (lastItemIndex >= this.lastLoaded && this.lastLoaded < this.total) {
+                var overflow = (firstItemIndex + this.take) - this.total;
+                if (overflow > 0) {
+                    firstItemIndex = firstItemIndex - overflow;
+                    firstItemOffset = this.rowHeightService.offset(firstItemIndex);
+                }
+                this.firstLoaded = firstItemIndex;
+                observer.next(new ScrollAction(firstItemOffset));
+                var nextTake = this.firstLoaded + this.take;
+                this.lastLoaded = Math.min(nextTake, this.total);
+                nextTake = nextTake > this.total ? this.total - this.firstLoaded : this.take;
+                observer.next(new PageAction(this.firstLoaded, this.take));
+            }
+            else {
+                var atBottom = scrollHeight - clientHeight - scrollTop < SCROLL_BOTTOM_THRESHOLD;
+                if (atBottom) {
+                    observer.next(new ScrollBottomAction());
+                }
+            }
+        }
+        if (up && firstItemIndex < this.firstLoaded) {
+            var nonVisibleBuffer = Math.floor(this.take * 0.3);
+            this.firstLoaded = Math.max(firstItemIndex - nonVisibleBuffer, 0);
+            observer.next(new ScrollAction(this.rowHeightService.offset(this.firstLoaded)));
+            this.lastLoaded = Math.min(this.firstLoaded + this.take, this.total);
+            observer.next(new PageAction(this.firstLoaded, this.take));
+        }
+    };
+    ScrollerService.prototype.unsubscribe = function () {
+        if (this.scrollSubscription) {
+            this.scrollSubscription.unsubscribe();
+            this.scrollSubscription = undefined;
+        }
+    };
+    return ScrollerService;
+}());
+export { ScrollerService };

package/dist/es/scrolling/scrollmode.js

@@ -0,0 +1,4 @@
+/**-----------------------------------------------------------------------------------------
+* 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/scrolling/suspend.service.js

@@ -0,0 +1,19 @@
+/**-----------------------------------------------------------------------------------------
+* 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';
+/**
+ * @hidden
+ */
+var SuspendService = /** @class */ (function () {
+    function SuspendService() {
+        this.scroll = false;
+    }
+    SuspendService = tslib_1.__decorate([
+        Injectable()
+    ], SuspendService);
+    return SuspendService;
+}());
+export { SuspendService };

package/dist/es/selection/is-selected.js

@@ -0,0 +1,4 @@
+/**-----------------------------------------------------------------------------------------
+* 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/selection/marquee.directive.js

@@ -0,0 +1,179 @@
+/**-----------------------------------------------------------------------------------------
+* 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, HostBinding, ChangeDetectorRef } from '@angular/core';
+import { DraggableDirective } from '@progress/kendo-angular-common';
+import { SelectionService } from './selection.service';
+import { createState } from './selection-state';
+var createElement = function () {
+    var marquee = document.createElement("div");
+    marquee.className = "k-marquee";
+    var marqueeColor = document.createElement("div");
+    marqueeColor.className = "k-marquee-color";
+    marquee.appendChild(marqueeColor);
+    return marquee;
+};
+var ɵ0 = createElement;
+var elementUnderCursor = function (_a) {
+    var clientX = _a.clientX, clientY = _a.clientY;
+    return document.elementFromPoint(clientX, clientY);
+};
+var ɵ1 = elementUnderCursor;
+/**
+ * @hidden
+ */
+var MarqueeDirective = /** @class */ (function () {
+    function MarqueeDirective(draggable, selection, changeDetector) {
+        this.draggable = draggable;
+        this.selection = selection;
+        this.changeDetector = changeDetector;
+        this.cellSelected = this.cellSelected.bind(this);
+        this.rowSelected = this.rowSelected.bind(this);
+    }
+    Object.defineProperty(MarqueeDirective.prototype, "userSelection", {
+        get: function () {
+            return this.selection.enableMarquee ? 'none' : null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    MarqueeDirective.prototype.ngOnInit = function () {
+        // handle esc
+        // trigger cancel
+        this.subscriptions = this.draggable.kendoPress.subscribe(this.start.bind(this));
+        this.subscriptions.add(this.draggable.kendoDrag.subscribe(this.moveMarquee.bind(this)));
+        this.subscriptions.add(this.draggable.kendoRelease.subscribe(this.endSelection.bind(this)));
+    };
+    MarqueeDirective.prototype.ngOnDestroy = function () {
+        this.subscriptions.unsubscribe();
+        this.clean();
+    };
+    MarqueeDirective.prototype.cellSelected = function (dataItem, column) {
+        return this.state.has(dataItem, column);
+    };
+    MarqueeDirective.prototype.rowSelected = function (dataItem) {
+        return this.state.has(dataItem);
+    };
+    MarqueeDirective.prototype.start = function (args) {
+        var pressTarget = this.targetArgs(args, true);
+        if (!pressTarget) {
+            return;
+        }
+        this.pressTarget = pressTarget;
+        this.pressArgs = args;
+    };
+    MarqueeDirective.prototype.moveMarquee = function (args) {
+        if (this.pressTarget && !this.state) {
+            this.initMarquee();
+        }
+        if (this.marqueeElement) {
+            var element = this.marqueeElement;
+            var press = this.pressArgs;
+            var left = Math.min(args.pageX, press.pageX);
+            var top_1 = Math.min(args.pageY, press.pageY);
+            var width = Math.abs(args.pageX - press.pageX);
+            var height = Math.abs(args.pageY - press.pageY);
+            element.style.left = left + "px";
+            element.style.top = top_1 + "px";
+            element.style.width = width + "px";
+            element.style.height = height + "px";
+        }
+        else if (this.state) {
+            var currentTarget = this.targetArgs(args);
+            if (currentTarget && (!this.currentTarget || this.currentTarget.item.data !== currentTarget.item.data ||
+                (this.selection.settings.mode === 'cell' && this.currentTarget.column !== currentTarget.column))) {
+                this.currentTarget = currentTarget;
+                this.state.fromArray(this.selection.rangeItems(this.pressTarget, currentTarget).map(function (item) { return ({ itemKey: item.dataItem, columnKey: item.column }); }));
+                this.selection.updateSelectedState();
+                this.changeDetector.detectChanges();
+            }
+        }
+    };
+    MarqueeDirective.prototype.endSelection = function (args) {
+        if (!this.state) {
+            return;
+        }
+        if ((this.pressArgs.pageX !== args.pageX || this.pressArgs.pageY !== args.pageY)) {
+            var pressTarget = this.pressTarget;
+            var releaseTarget = this.targetArgs(args);
+            this.clean();
+            // if one is missing select first / last viewItem depending on the position
+            // select column based on coordinates
+            if (pressTarget && releaseTarget) {
+                this.selection.selectRange(pressTarget, releaseTarget);
+            }
+            else {
+                this.changeDetector.detectChanges();
+            }
+        }
+        else {
+            this.clean();
+            this.changeDetector.detectChanges();
+        }
+    };
+    MarqueeDirective.prototype.clean = function () {
+        if (this.marqueeElement) {
+            document.body.removeChild(this.marqueeElement);
+            this.marqueeElement = null;
+        }
+        if (this.selectionSelected) {
+            if (this.selection.settings.mode === 'cell') {
+                this.selection.isCellSelected = this.selectionSelected;
+            }
+            else {
+                this.selection.isRowSelected = this.selectionSelected;
+            }
+            this.selectionSelected = null;
+        }
+        if (this.state) {
+            this.state.clear();
+            this.state = null;
+        }
+        this.pressTarget = null;
+        this.pressArgs = null;
+    };
+    MarqueeDirective.prototype.targetArgs = function (args, skipFocusable) {
+        var target = args.originalEvent.target;
+        if (this.marqueeElement) {
+            this.marqueeElement.style.display = 'none';
+            target = elementUnderCursor(args);
+            this.marqueeElement.style.display = 'block';
+        }
+        return this.selection.targetArgs(target, skipFocusable);
+    };
+    MarqueeDirective.prototype.initMarquee = function () {
+        this.state = createState(this.selection.settings);
+        if (this.selection.settings.mode === 'cell') {
+            this.selectionSelected = this.selection.isCellSelected;
+            this.selection.isCellSelected = this.cellSelected;
+        }
+        else {
+            this.selectionSelected = this.selection.isRowSelected;
+            this.selection.isRowSelected = this.rowSelected;
+        }
+        this.changeDetector.detectChanges();
+        var drag = this.selection.settings.drag;
+        if (!(drag && drag.snap)) {
+            this.marqueeElement = createElement();
+            document.body.appendChild(this.marqueeElement);
+        }
+    };
+    tslib_1.__decorate([
+        HostBinding('style.user-select'),
+        tslib_1.__metadata("design:type", String),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], MarqueeDirective.prototype, "userSelection", null);
+    MarqueeDirective = tslib_1.__decorate([
+        Directive({
+            selector: '[kendoTreeListSelectionMarquee]'
+        }),
+        tslib_1.__metadata("design:paramtypes", [DraggableDirective,
+            SelectionService,
+            ChangeDetectorRef])
+    ], MarqueeDirective);
+    return MarqueeDirective;
+}());
+export { MarqueeDirective };
+export { ɵ0, ɵ1 };

package/dist/es/selection/selectable-settings.js

@@ -0,0 +1,4 @@
+/**-----------------------------------------------------------------------------------------
+* 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/selection/selectable.directive.js

@@ -0,0 +1,231 @@
+/**-----------------------------------------------------------------------------------------
+* 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, Input, Output, EventEmitter } from '@angular/core';
+import { TreeListComponent } from '../treelist.component';
+import { getter } from '@progress/kendo-common';
+import { isString } from '../utils';
+import { createState, RowSelectionState } from './selection-state';
+var defaultColumnKeyGetter = function (_column, columnIndex) { return columnIndex; };
+var ɵ0 = defaultColumnKeyGetter;
+/**
+ * A directive which controls the selection state
+ */
+var SelectableDirective = /** @class */ (function () {
+    function SelectableDirective(treelist) {
+        this.treelist = treelist;
+        /**
+         * Fires when the selected items are changed.
+         */
+        this.selectedItemsChange = new EventEmitter();
+        this.state = new RowSelectionState();
+        this._selectedItems = [];
+        this.cellSelected = this.cellSelected.bind(this);
+        this.rowSelected = this.rowSelected.bind(this);
+        this.selectionChange = this.selectionChange.bind(this);
+        this.updateColumnIndices = this.updateColumnIndices.bind(this);
+        this.treelist.selectable = this.selectable = true;
+    }
+    Object.defineProperty(SelectableDirective.prototype, "selectable", {
+        /**
+         * @hidden
+         */
+        set: function (value) {
+            if (typeof value === 'object') { // add method to normalize this
+                this._settings = value;
+            }
+            else {
+                this._settings = {
+                    enabled: value
+                };
+            }
+            this.state = createState(this._settings);
+            this.state.fromArray(this._selectedItems || []);
+            if (this._settings.enabled !== false) {
+                this.treelist.isSelected = this._settings.mode === 'cell' ? this.cellSelected : this.rowSelected;
+                this.subscribeSelection();
+            }
+            else {
+                this.treelist.isSelected = function () { return false; };
+                this.unsubscribeSelection();
+            }
+            this.treelist.updateView();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectableDirective.prototype, "selectedItems", {
+        /**
+         * Specifies the selected items.
+         */
+        set: function (value) {
+            if (!value) {
+                this.state.clear();
+            }
+            else if (value !== this.lastChange) {
+                this.state.fromArray(value);
+                this.treelist.updateView();
+            }
+            this._selectedItems = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectableDirective.prototype, "itemKey", {
+        /**
+         * The field name or a function that specify the dataItems key.
+         */
+        set: function (value) {
+            if (isString(value)) {
+                this._keyGetter = getter(String(value));
+            }
+            else {
+                this._keyGetter = value;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectableDirective.prototype, "columnKey", {
+        /**
+         * The field name or a function that specify the columns key.
+         */
+        set: function (value) {
+            if (isString(value)) {
+                this._columnKeyGetter = getter(String(value));
+            }
+            else if (value) {
+                this._columnKeyGetter = value;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectableDirective.prototype, "keyGetter", {
+        get: function () {
+            return this._keyGetter || this.treelist.idGetter;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectableDirective.prototype, "columnKeyGetter", {
+        get: function () {
+            return this._columnKeyGetter || defaultColumnKeyGetter;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    SelectableDirective.prototype.ngOnDestroy = function () {
+        this.unsubscribeSelection();
+    };
+    /**
+     * @hidden
+     */
+    SelectableDirective.prototype.cellSelected = function (dataItem, column, columnIndex) {
+        return this.state.has(this.keyGetter(dataItem), this.columnKeyGetter(column, columnIndex));
+    };
+    /**
+     * @hidden
+     */
+    SelectableDirective.prototype.rowSelected = function (dataItem) {
+        return this.state.has(this.keyGetter(dataItem));
+    };
+    SelectableDirective.prototype.selectionChange = function (_a) {
+        var _this = this;
+        var action = _a.action, items = _a.items;
+        if (action === 'select' || action === 'add') {
+            if (action === 'select') {
+                this.state.clear();
+            }
+            items.forEach(function (item) {
+                _this.state.add(_this.keyGetter(item.dataItem), _this.columnKeyGetter(item.column, item.columnIndex));
+            });
+        }
+        else {
+            items.forEach(function (item) {
+                _this.state.remove(_this.keyGetter(item.dataItem), _this.columnKeyGetter(item.column, item.columnIndex));
+            });
+        }
+        this.emitSelectedItemsChange();
+    };
+    SelectableDirective.prototype.emitSelectedItemsChange = function () {
+        this.lastChange = this.state.toArray();
+        this.selectedItemsChange.emit(this.lastChange);
+    };
+    SelectableDirective.prototype.subscribeSelection = function () {
+        this.unsubscribeSelection();
+        this.subscriptions = this.treelist.selectionChange.subscribe(this.selectionChange);
+        if (this._settings.mode === 'cell') {
+            this.subscriptions.add(this.treelist.columnOrderChange.subscribe(this.updateColumnIndices));
+            this.subscriptions.add(this.treelist.columnLockedChange.subscribe(this.updateColumnIndices));
+        }
+    };
+    SelectableDirective.prototype.unsubscribeSelection = function () {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+            this.subscriptions = null;
+        }
+    };
+    SelectableDirective.prototype.updateColumnIndices = function () {
+        if (!this._columnKeyGetter) {
+            var changes_1 = new Map();
+            var currentIndices_1 = [];
+            this.leafColumns.forEach(function (column) {
+                currentIndices_1.push(column);
+            });
+            this.treelist.columnsContainer.refresh();
+            var leafColumns_1 = this.leafColumns;
+            currentIndices_1.forEach(function (column, index) {
+                if (column !== leafColumns_1[index]) {
+                    changes_1.set(index, leafColumns_1.indexOf(column));
+                }
+            });
+            if (changes_1.size && this.state.updateColumKeys(changes_1)) {
+                this.emitSelectedItemsChange();
+            }
+        }
+    };
+    Object.defineProperty(SelectableDirective.prototype, "leafColumns", {
+        get: function () {
+            return this.treelist.lockedLeafColumns.toArray().concat(this.treelist.nonLockedLeafColumns.toArray());
+        },
+        enumerable: true,
+        configurable: true
+    });
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Object),
+        tslib_1.__metadata("design:paramtypes", [Object])
+    ], SelectableDirective.prototype, "selectable", null);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Array),
+        tslib_1.__metadata("design:paramtypes", [Array])
+    ], SelectableDirective.prototype, "selectedItems", null);
+    tslib_1.__decorate([
+        Output(),
+        tslib_1.__metadata("design:type", EventEmitter)
+    ], SelectableDirective.prototype, "selectedItemsChange", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Object),
+        tslib_1.__metadata("design:paramtypes", [Object])
+    ], SelectableDirective.prototype, "itemKey", null);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Object),
+        tslib_1.__metadata("design:paramtypes", [Object])
+    ], SelectableDirective.prototype, "columnKey", null);
+    SelectableDirective = tslib_1.__decorate([
+        Directive({
+            exportAs: 'kendoTreeListSelectable',
+            selector: '[kendoTreeListSelectable]'
+        }),
+        tslib_1.__metadata("design:paramtypes", [TreeListComponent])
+    ], SelectableDirective);
+    return SelectableDirective;
+}());
+export { SelectableDirective };
+export { ɵ0 };

package/dist/es/selection/selection-change-event.js

@@ -0,0 +1,18 @@
+/**-----------------------------------------------------------------------------------------
+* 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 TreeList `selectionChange` event.
+ */
+var SelectionChangeEvent = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function SelectionChangeEvent(action, items) {
+        this.action = action;
+        this.items = items;
+    }
+    return SelectionChangeEvent;
+}());
+export { SelectionChangeEvent };