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

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

@@ -0,0 +1,65 @@
+/**-----------------------------------------------------------------------------------------
+* 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, EventEmitter } from '@angular/core';
+import { contains } from './common';
+/**
+ * @hidden
+ */
+var DragAndDropService = /** @class */ (function () {
+    function DragAndDropService() {
+        this.changes = new EventEmitter();
+        this.register = [];
+        this.lastTarget = null;
+    }
+    DragAndDropService.prototype.add = function (target) {
+        this.register.push(target);
+    };
+    DragAndDropService.prototype.remove = function (target) {
+        this.register = this.register.filter(function (current) { return current !== target; });
+    };
+    DragAndDropService.prototype.notifyDrag = function (draggable, element, mouseEvent) {
+        var target = this.targetFor(element);
+        if (this.lastTarget === target) {
+            return;
+        }
+        this.changes.next({
+            draggable: draggable,
+            mouseEvent: mouseEvent,
+            target: this.lastTarget,
+            type: 'leave'
+        });
+        if (target) {
+            this.changes.next({
+                draggable: draggable,
+                mouseEvent: mouseEvent,
+                target: target,
+                type: 'enter'
+            });
+        }
+        this.lastTarget = target;
+    };
+    DragAndDropService.prototype.notifyDrop = function (draggable, mouseEvent) {
+        this.changes.next({
+            draggable: draggable,
+            mouseEvent: mouseEvent,
+            target: this.lastTarget,
+            type: 'drop'
+        });
+        this.lastTarget = null;
+    };
+    DragAndDropService.prototype.targetFor = function (element) {
+        var comparer = contains.bind(null, element);
+        return this.register.find(function (_a) {
+            var nativeElement = _a.element.nativeElement;
+            return comparer(nativeElement);
+        });
+    };
+    DragAndDropService = tslib_1.__decorate([
+        Injectable()
+    ], DragAndDropService);
+    return DragAndDropService;
+}());
+export { DragAndDropService };

package/dist/es/dragdrop/drag-hint.service.js

@@ -0,0 +1,95 @@
+/**-----------------------------------------------------------------------------------------
+* 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, SecurityContext } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { append, offset } from './common';
+var updateClass = function (element, valid) {
+    var icon = element.querySelector('.k-icon');
+    icon.className = icon.className
+        .replace(/(plus|cancel)/, valid ? 'plus' : 'cancel');
+};
+var ɵ0 = updateClass;
+var updateLock = function (element, locked) {
+    if (locked === void 0) { locked = null; }
+    var icon = element.querySelectorAll('.k-icon')[1];
+    var value = locked == null ? '' : (locked ? 'k-i-lock' : 'k-i-unlock');
+    icon.className = icon.className
+        .replace(/(k-i-unlock|k-i-lock)/, '') + (" " + value);
+};
+var ɵ1 = updateLock;
+var decorate = function (element, target) {
+    var targetStyles = getComputedStyle(target);
+    element.className = 'k-header k-drag-clue';
+    element.style.position = 'absolute';
+    element.style.zIndex = '20000';
+    element.style.paddingLeft = targetStyles.paddingLeft;
+    element.style.paddingTop = targetStyles.paddingTop;
+    element.style.paddingBottom = targetStyles.paddingBottom;
+    element.style.paddingRight = targetStyles.paddingRight;
+    element.style.width = targetStyles.width;
+    element.style.height = targetStyles.height;
+};
+var ɵ2 = decorate;
+/**
+ * @hidden
+ */
+var DragHintService = /** @class */ (function () {
+    function DragHintService(santizer) {
+        this.santizer = santizer;
+    }
+    DragHintService.prototype.create = function (down, target, title) {
+        this.initCoords(down);
+        this.dom = document.createElement("div");
+        decorate(this.dom, target);
+        var safeTitle = this.santizer.sanitize(SecurityContext.HTML, title);
+        this.dom.innerHTML = "\n            <span class=\"k-icon k-drag-status k-i-cancel k-icon-with-modifier\">\n                <span class=\"k-icon k-icon-modifier\"></span>\n            </span>\n            " + safeTitle + "\n        ";
+    };
+    DragHintService.prototype.attach = function () {
+        return append(this.dom);
+    };
+    DragHintService.prototype.remove = function () {
+        if (this.dom && this.dom.parentNode) {
+            (function (el) {
+                setTimeout(function () { return document.body.removeChild(el); });
+            })(this.dom); // hack for IE + pointer events!
+            this.dom = null;
+        }
+    };
+    DragHintService.prototype.show = function () {
+        this.dom.style.display = "";
+    };
+    DragHintService.prototype.hide = function () {
+        this.dom.style.display = "none";
+    };
+    DragHintService.prototype.enable = function () {
+        updateClass(this.dom, true);
+    };
+    DragHintService.prototype.disable = function () {
+        updateClass(this.dom, false);
+    };
+    DragHintService.prototype.removeLock = function () {
+        updateLock(this.dom);
+    };
+    DragHintService.prototype.toggleLock = function (locked) {
+        updateLock(this.dom, locked);
+    };
+    DragHintService.prototype.move = function (move) {
+        this.dom.style.top = this.initialTop + move.pageY + 'px';
+        this.dom.style.left = this.initialLeft + move.pageX + 'px';
+    };
+    DragHintService.prototype.initCoords = function (down) {
+        var _a = offset(down.originalEvent.target), top = _a.top, left = _a.left;
+        this.initialTop = top - down.pageY;
+        this.initialLeft = left - down.pageX;
+    };
+    DragHintService = tslib_1.__decorate([
+        Injectable(),
+        tslib_1.__metadata("design:paramtypes", [DomSanitizer])
+    ], DragHintService);
+    return DragHintService;
+}());
+export { DragHintService };
+export { ɵ0, ɵ1, ɵ2 };

package/dist/es/dragdrop/draggable-column.directive.js

@@ -0,0 +1,170 @@
+/**-----------------------------------------------------------------------------------------
+* 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, EventEmitter, Host, Input, NgZone, Output, Renderer2, HostBinding } from '@angular/core';
+import { Subscription, of } from 'rxjs';
+import { DraggableDirective } from '@progress/kendo-angular-common';
+import { DragAndDropService } from './drag-and-drop.service';
+import { DragHintService } from './drag-hint.service';
+import { DropCueService } from './drop-cue.service';
+import { and, not, or } from '../utils';
+import { NavigationService } from '../navigation/navigation.service';
+import { takeUntil, delay, filter, tap, switchMap, switchMapTo, map } from 'rxjs/operators';
+import { isFocusableWithTabKey, matchesNodeName } from '../rendering/common/dom-queries';
+// TODO
+// tslint:disable:rxjs-no-unsafe-takeuntil
+/**
+ * @hidden
+ */
+var preventOnDblClick = function (release) { return function (mouseDown) {
+    return of(mouseDown).pipe(delay(150), takeUntil(release));
+}; };
+var ɵ0 = preventOnDblClick;
+var hasClass = function (className) { return function (el) { return new RegExp("(^| )" + className + "( |$)").test(el.className); }; };
+var ɵ1 = hasClass;
+var isDeleteButton = or(hasClass("k-i-group-delete"), hasClass("k-button-icon"));
+var isSortIcon = or(hasClass("k-i-sort-asc-sm"), hasClass("k-i-sort-desc-sm"));
+var skipButtons = and(not(isDeleteButton), not(isSortIcon), not(isFocusableWithTabKey), not(matchesNodeName("label")));
+var elementUnderCursor = function (_a) {
+    var clientX = _a.clientX, clientY = _a.clientY;
+    return document.elementFromPoint(clientX, clientY);
+};
+var ɵ2 = elementUnderCursor;
+var hideThenShow = function (element, cont) {
+    element.style.display = 'none';
+    var result = cont();
+    element.style.display = 'block';
+    return result;
+};
+var ɵ3 = hideThenShow;
+/**
+ * @hidden
+ */
+var DraggableColumnDirective = /** @class */ (function () {
+    function DraggableColumnDirective(draggable, element, zone, service, hint, cue, nav, renderer) {
+        this.draggable = draggable;
+        this.element = element;
+        this.zone = zone;
+        this.service = service;
+        this.hint = hint;
+        this.cue = cue;
+        this.nav = nav;
+        this.renderer = renderer;
+        this.context = {};
+        this.drag = new EventEmitter();
+        this.subscriptions = new Subscription();
+    }
+    Object.defineProperty(DraggableColumnDirective.prototype, "enableDrag", {
+        set: function (enabled) {
+            this.enabled = enabled;
+            this.updateTouchAction();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DraggableColumnDirective.prototype, "hostClass", {
+        get: function () {
+            return this.enabled;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DraggableColumnDirective.prototype.ngOnInit = function () {
+        var _this = this;
+        this.subscriptions.add(this.zone.runOutsideAngular(function () {
+            return _this.draggable.kendoPress.pipe(filter(function (_) { return _this.enabled; }), filter(function (_a) {
+                var target = _a.originalEvent.target;
+                return target === _this.element.nativeElement || skipButtons(target);
+            }), tap(function (e) {
+                var originalEvent = e.originalEvent;
+                if (!e.isTouch) {
+                    originalEvent.preventDefault();
+                }
+                _this.nav.navigateTo(originalEvent.target);
+            }), switchMap(preventOnDblClick(_this.draggable.kendoRelease)), tap(function (down) {
+                _this.hint.create(down, _this.element.nativeElement, _this.context.hint);
+                _this.cue.create();
+            }), switchMap(function (down) {
+                return _this.draggable.kendoDrag.pipe(tap(function (e) {
+                    if (e.isTouch) {
+                        e.originalEvent.preventDefault();
+                    }
+                }), tap(_this.hint.attach()), tap(_this.cue.attach()), takeUntil(_this.draggable.kendoRelease), map(function (move) { return ({ move: move, down: down }); }));
+            }), tap(_this.performDrag.bind(_this)), switchMapTo(_this.draggable.kendoRelease)).subscribe(_this.drop.bind(_this));
+        }));
+    };
+    DraggableColumnDirective.prototype.ngOnDestroy = function () {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+    };
+    DraggableColumnDirective.prototype.drop = function (upEvent) {
+        this.hint.remove();
+        this.cue.remove();
+        this.service.notifyDrop(this, upEvent);
+    };
+    DraggableColumnDirective.prototype.performDrag = function (_a) {
+        var move = _a.move;
+        this.hint.move(move);
+        var cursorElement = this.elementUnderCursor(move);
+        if (cursorElement) {
+            this.service.notifyDrag(this, cursorElement, move);
+        }
+        this.drag.emit({
+            draggable: this,
+            mouseEvent: move
+        });
+    };
+    DraggableColumnDirective.prototype.elementUnderCursor = function (mouseEvent) {
+        this.hint.hide();
+        var target = elementUnderCursor(mouseEvent);
+        if (target && /k-grouping-dropclue/.test(target.className)) {
+            target = hideThenShow(target, elementUnderCursor.bind(this, mouseEvent));
+        }
+        this.hint.show();
+        return target;
+    };
+    DraggableColumnDirective.prototype.updateTouchAction = function () {
+        if (!this.element) {
+            return;
+        }
+        this.renderer.setStyle(this.element.nativeElement, 'touch-action', this.enabled ? 'none' : '');
+    };
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Object)
+    ], DraggableColumnDirective.prototype, "context", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Boolean),
+        tslib_1.__metadata("design:paramtypes", [Boolean])
+    ], DraggableColumnDirective.prototype, "enableDrag", null);
+    tslib_1.__decorate([
+        Output(),
+        tslib_1.__metadata("design:type", EventEmitter)
+    ], DraggableColumnDirective.prototype, "drag", void 0);
+    tslib_1.__decorate([
+        HostBinding('class.k-grid-draggable-header'),
+        tslib_1.__metadata("design:type", Boolean),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], DraggableColumnDirective.prototype, "hostClass", null);
+    DraggableColumnDirective = tslib_1.__decorate([
+        Directive({
+            selector: '[kendoDraggableColumn]'
+        }),
+        tslib_1.__param(0, Host()),
+        tslib_1.__metadata("design:paramtypes", [DraggableDirective,
+            ElementRef,
+            NgZone,
+            DragAndDropService,
+            DragHintService,
+            DropCueService,
+            NavigationService,
+            Renderer2])
+    ], DraggableColumnDirective);
+    return DraggableColumnDirective;
+}());
+export { DraggableColumnDirective };
+export { ɵ0, ɵ1, ɵ2, ɵ3 };

package/dist/es/dragdrop/drop-cue.service.js

@@ -0,0 +1,44 @@
+/**-----------------------------------------------------------------------------------------
+* 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 { append } from './common';
+/**
+ * @hidden
+ */
+var DropCueService = /** @class */ (function () {
+    function DropCueService() {
+    }
+    DropCueService.prototype.create = function () {
+        this.dom = document.createElement("div");
+        this.dom.className = 'k-grouping-dropclue';
+        this.hide();
+    };
+    DropCueService.prototype.attach = function () {
+        return append(this.dom);
+    };
+    DropCueService.prototype.remove = function () {
+        if (this.dom && this.dom.parentElement) {
+            document.body.removeChild(this.dom);
+            this.dom = null;
+        }
+    };
+    DropCueService.prototype.hide = function () {
+        this.dom.style.display = "none";
+    };
+    DropCueService.prototype.position = function (_a) {
+        var left = _a.left, top = _a.top, height = _a.height;
+        this.dom.style.display = 'block';
+        this.dom.style.height = height + 'px';
+        this.dom.style.top = top + 'px';
+        var width = this.dom.offsetWidth / 2;
+        this.dom.style.left = left - width + 'px';
+    };
+    DropCueService = tslib_1.__decorate([
+        Injectable()
+    ], DropCueService);
+    return DropCueService;
+}());
+export { DropCueService };

package/dist/es/dragdrop/drop-target.directive.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 { Directive, ElementRef, EventEmitter, Input, Output } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { DragAndDropService } from './drag-and-drop.service';
+import { filter } from 'rxjs/operators';
+/**
+ * @hidden
+ */
+var DropTargetDirective = /** @class */ (function () {
+    function DropTargetDirective(element, service) {
+        this.element = element;
+        this.service = service;
+        this.context = {};
+        this.enter = new EventEmitter();
+        this.leave = new EventEmitter();
+        this.drop = new EventEmitter();
+        this.subscriptions = new Subscription();
+    }
+    DropTargetDirective.prototype.ngOnInit = function () {
+        var _this = this;
+        this.service.add(this);
+        var changes = this.service.changes.pipe(filter(function (_a) {
+            var target = _a.target;
+            return target === _this;
+        }));
+        this.subscriptions.add(changes.pipe(filter(function (_a) {
+            var type = _a.type;
+            return type === 'leave';
+        }))
+            .subscribe(function (e) {
+            _this.leave.next(_this.eventArgs(e));
+        }));
+        this.subscriptions.add(changes.pipe(filter(function (_a) {
+            var type = _a.type;
+            return type === 'enter';
+        }))
+            .subscribe(function (e) {
+            _this.enter.next(_this.eventArgs(e));
+        }));
+        this.subscriptions.add(changes.pipe(filter(function (_a) {
+            var type = _a.type;
+            return type === 'drop';
+        }))
+            .subscribe(function (e) {
+            _this.drop.next(_this.eventArgs(e));
+        }));
+    };
+    DropTargetDirective.prototype.ngOnDestroy = function () {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+    };
+    DropTargetDirective.prototype.eventArgs = function (e) {
+        return {
+            target: this,
+            mouseEvent: e.mouseEvent,
+            draggable: e.draggable
+        };
+    };
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", Object)
+    ], DropTargetDirective.prototype, "context", void 0);
+    tslib_1.__decorate([
+        Output(),
+        tslib_1.__metadata("design:type", EventEmitter)
+    ], DropTargetDirective.prototype, "enter", void 0);
+    tslib_1.__decorate([
+        Output(),
+        tslib_1.__metadata("design:type", EventEmitter)
+    ], DropTargetDirective.prototype, "leave", void 0);
+    tslib_1.__decorate([
+        Output(),
+        tslib_1.__metadata("design:type", EventEmitter)
+    ], DropTargetDirective.prototype, "drop", void 0);
+    DropTargetDirective = tslib_1.__decorate([
+        Directive({
+            selector: '[kendoDropTarget]'
+        }),
+        tslib_1.__metadata("design:paramtypes", [ElementRef,
+            DragAndDropService])
+    ], DropTargetDirective);
+    return DropTargetDirective;
+}());
+export { DropTargetDirective };

package/dist/es/editing/add-command.directive.js

@@ -0,0 +1,74 @@
+/**-----------------------------------------------------------------------------------------
+* 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, Renderer2, NgZone, HostBinding, Input } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { EditService } from './edit.service';
+import { BaseCommandDirective } from './base-command.directive';
+/**
+ * Represents the command for adding a new item to the TreeList. You can apply this directive to any
+ * `button` element inside a [`ToolbarTemplate`]({% slug api_treelist_commandcolumncomponent %}) or
+ * inside a [`CommandColumnComponent`]({% slug api_treelist_commandcolumncomponent %}).
+ *
+ * When an associated button with the directive is clicked, the
+ * [`add`]({% slug api_treelist_treelistcomponent %}#toc-add) event is triggered
+ * ([see example]({% slug editing_treelist %})).
+ *
+ * > When the row is in the edit mode, the button with `kendoTreeListAddCommand` is automatically hidden.
+ *
+ * @example
+ * ```html-no-run
+ * <kendo-treelist>
+ *    <ng-template kendoTreeListToolbarTemplate>
+ *       <button kendoTreeListAddCommand>Add new</button>
+ *    </ng-template>
+ * </kendo-treelist>
+ * ```
+ *
+ * When added to the command column, the directive takes as input the `cellContext` from the cell template.
+ *
+ * @example
+ * ```html-no-run
+ * <kendo-treelist>
+ *   <kendo-treelist-command-column title="command">
+ *     <ng-template kendoTreeListCellTemplate let-cellContext="cellContext">
+ *       <button [kendoTreeListAddCommand]="cellContext" class="k-primary">Edit</button>
+ *     </ng-template>
+ *   </kendo-treelist-command-column>
+ * </kendo-treelist>
+ * ```
+ */
+var AddCommandDirective = /** @class */ (function (_super) {
+    tslib_1.__extends(AddCommandDirective, _super);
+    function AddCommandDirective(editService, element, renderer, localization, ngZone) {
+        var _this = _super.call(this, editService, element, renderer, localization, ngZone) || this;
+        _this.commandClass = true;
+        _this.readVisible = true;
+        return _this;
+    }
+    AddCommandDirective.prototype.onClick = function () {
+        this.editService.beginAdd(this.dataItem);
+    };
+    tslib_1.__decorate([
+        Input('kendoTreeListAddCommand'),
+        tslib_1.__metadata("design:type", Object)
+    ], AddCommandDirective.prototype, "cellContext", void 0);
+    tslib_1.__decorate([
+        HostBinding('class.k-grid-add-command'),
+        tslib_1.__metadata("design:type", Boolean)
+    ], AddCommandDirective.prototype, "commandClass", void 0);
+    AddCommandDirective = tslib_1.__decorate([
+        Directive({
+            selector: '[kendoTreeListAddCommand]'
+        }),
+        tslib_1.__metadata("design:paramtypes", [EditService,
+            ElementRef,
+            Renderer2,
+            LocalizationService,
+            NgZone])
+    ], AddCommandDirective);
+    return AddCommandDirective;
+}(BaseCommandDirective));
+export { AddCommandDirective };

package/dist/es/editing/add-event-args.interface.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/editing/base-command.directive.js

@@ -0,0 +1,78 @@
+/**-----------------------------------------------------------------------------------------
+* 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 { HostListener, HostBinding, ElementRef, Renderer2, NgZone, Directive } from '@angular/core';
+import { Button } from '@progress/kendo-angular-buttons';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { EditService } from './edit.service';
+/**
+ * @hidden
+ */
+var BaseCommandDirective = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseCommandDirective, _super);
+    function BaseCommandDirective(editService, element, renderer, localization, ngZone) {
+        var _this = _super.call(this, element, renderer, null, localization, ngZone) || this;
+        _this.editService = editService;
+        return _this;
+    }
+    Object.defineProperty(BaseCommandDirective.prototype, "visible", {
+        /**
+         * @hidden
+         */
+        get: function () {
+            if (this.cellContext) {
+                return this.isEdited !== this.readVisible ? '' : 'none';
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BaseCommandDirective.prototype, "isEdited", {
+        get: function () {
+            return Boolean(this.cellContext && this.editService.isEdited(this.dataItem) && !this.editService.isEditingCell());
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BaseCommandDirective.prototype, "dataItem", {
+        get: function () {
+            if (this.cellContext) {
+                return this.cellContext.viewItem.data;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @hidden
+     */
+    BaseCommandDirective.prototype.clickHandler = function (e) {
+        e.preventDefault();
+        this.onClick();
+    };
+    tslib_1.__decorate([
+        HostBinding('style.display'),
+        tslib_1.__metadata("design:type", String),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], BaseCommandDirective.prototype, "visible", null);
+    tslib_1.__decorate([
+        HostListener('click', ['$event']),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", [Object]),
+        tslib_1.__metadata("design:returntype", void 0)
+    ], BaseCommandDirective.prototype, "clickHandler", null);
+    BaseCommandDirective = tslib_1.__decorate([
+        Directive({
+            selector: '[kendoTreeListBaseCommand]'
+        }),
+        tslib_1.__metadata("design:paramtypes", [EditService,
+            ElementRef,
+            Renderer2,
+            LocalizationService,
+            NgZone])
+    ], BaseCommandDirective);
+    return BaseCommandDirective;
+}(Button));
+export { BaseCommandDirective };