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

package/dist/npm/column-resizing/column-handle.directive.js

@@ -0,0 +1,284 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = require("@angular/core");
+var rxjs_1 = require("rxjs");
+var kendo_angular_l10n_1 = require("@progress/kendo-angular-l10n");
+var utils_1 = require("../utils");
+var column_base_1 = require("../columns/column-base");
+var column_common_1 = require("../columns/column-common");
+var kendo_angular_common_1 = require("@progress/kendo-angular-common");
+var column_resizing_service_1 = require("./column-resizing.service");
+var operators_1 = require("rxjs/operators");
+// TODO
+// tslint:disable:rxjs-no-unsafe-takeuntil
+/**
+ * @hidden
+ */
+var fromPercentage = function (value, percent) {
+    var sign = percent < 0 ? -1 : 1;
+    return Math.ceil((Math.abs(percent) / 100) * value) * sign;
+};
+var ɵ0 = fromPercentage;
+exports.ɵ0 = ɵ0;
+/**
+ * @hidden
+ */
+var toPercentage = function (value, whole) { return (value / whole) * 100; };
+var ɵ1 = toPercentage;
+exports.ɵ1 = ɵ1;
+/**
+ * @hidden
+ */
+var headerWidth = function (handle) { return handle.nativeElement.parentElement.offsetWidth; };
+var ɵ2 = headerWidth;
+exports.ɵ2 = ɵ2;
+/**
+ * @hidden
+ */
+var allLeafColumns = function (columns) { return column_common_1.expandColumns(columns)
+    .filter(function (c) { return !c.isColumnGroup; }); };
+var ɵ3 = allLeafColumns;
+exports.ɵ3 = ɵ3;
+/**
+ * @hidden
+ */
+var stopPropagation = function (_a) {
+    var event = _a.originalEvent;
+    event.stopPropagation();
+    event.preventDefault();
+};
+var ɵ4 = stopPropagation;
+exports.ɵ4 = ɵ4;
+/**
+ * @hidden
+ */
+var createMoveStream = function (service, draggable) { return function (mouseDown) {
+    return draggable.kendoDrag.pipe(operators_1.takeUntil(draggable.kendoRelease.pipe(operators_1.tap(function () { return service.end(); }))), operators_1.map(function (_a) {
+        var pageX = _a.pageX;
+        return ({
+            originalX: mouseDown.pageX,
+            pageX: pageX
+        });
+    }));
+}; };
+var ɵ5 = createMoveStream;
+exports.ɵ5 = ɵ5;
+/**
+ * @hidden
+ */
+var preventOnDblClick = function (release) { return function (mouseDown) {
+    return rxjs_1.of(mouseDown).pipe(operators_1.delay(150), operators_1.takeUntil(release));
+}; };
+var ɵ6 = preventOnDblClick;
+exports.ɵ6 = ɵ6;
+/**
+ * @hidden
+ */
+var isInSpanColumn = function (column) { return !!(column.parent && column.parent.isSpanColumn); };
+var ɵ7 = isInSpanColumn;
+exports.ɵ7 = ɵ7;
+/**
+ * @hidden
+ *
+ * Calculates the column index. If the column is stated in `SpanColumn`,
+ * the index for all child columns equals the index of the first child.
+ */
+var indexOf = function (target, list) {
+    var index = 0;
+    var ignore = 0;
+    var skip = 0;
+    while (index < list.length) {
+        var current = list[index];
+        var isParentSpanColumn = isInSpanColumn(current);
+        if (current === target) {
+            break;
+        }
+        if ((ignore-- <= 0) && isParentSpanColumn) {
+            ignore = current.parent.childColumns.length - 1;
+            skip += ignore;
+        }
+        index++;
+    }
+    return index - skip;
+};
+var ɵ8 = indexOf;
+exports.ɵ8 = ɵ8;
+/**
+ * @hidden
+ */
+var ColumnHandleDirective = /** @class */ (function () {
+    function ColumnHandleDirective(draggable, element, service, zone, cdr, localization) {
+        this.draggable = draggable;
+        this.element = element;
+        this.service = service;
+        this.zone = zone;
+        this.cdr = cdr;
+        this.localization = localization;
+        this.columns = [];
+        this.subscriptions = new rxjs_1.Subscription();
+        this.rtl = false;
+    }
+    Object.defineProperty(ColumnHandleDirective.prototype, "visible", {
+        get: function () {
+            return this.column.resizable ? 'block' : 'none';
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ColumnHandleDirective.prototype, "leftStyle", {
+        get: function () {
+            return utils_1.isTruthy(this.rtl) ? 0 : null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ColumnHandleDirective.prototype, "rightStyle", {
+        get: function () {
+            return utils_1.isTruthy(this.rtl) ? null : 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ColumnHandleDirective.prototype.autoFit = function () {
+        var _this = this;
+        var allLeafs = allLeafColumns(this.columns);
+        var currentLeafs = column_common_1.leafColumns([this.column]).filter(function (column) { return utils_1.isTruthy(column.resizable); });
+        var columnInfo = currentLeafs.map(function (column) {
+            var isParentSpan = isInSpanColumn(column);
+            var isLastInSpan = isParentSpan ? column.parent.childColumns.last === column : false;
+            var index = indexOf(column, allLeafs);
+            return {
+                column: column,
+                headerIndex: _this.columnsForLevel(column.level).indexOf(column),
+                index: index,
+                isLastInSpan: isLastInSpan,
+                isParentSpan: isParentSpan,
+                level: column.level
+            };
+        });
+        currentLeafs.forEach(function (column) { return column.width = 0; });
+        this.service.measureColumns(columnInfo);
+    };
+    ColumnHandleDirective.prototype.ngOnInit = function () {
+        var _this = this;
+        var service = this.service.changes.pipe(operators_1.filter(function () { return _this.column.resizable; }), operators_1.filter(function (e) { return utils_1.isPresent(e.columns.find(function (column) { return column === _this.column; })); }));
+        this.subscriptions.add(service.pipe(operators_1.filter(function (e) { return e.type === 'start'; }))
+            .subscribe(this.initState.bind(this)));
+        this.subscriptions.add(service.pipe(operators_1.filter(function (e) { return e.type === 'resizeColumn'; }))
+            .subscribe(this.resize.bind(this)));
+        this.subscriptions.add(this.service.changes.pipe(operators_1.filter(function (e) { return e.type === 'start'; }), operators_1.filter(this.shouldUpdate.bind(this)), operators_1.take(1) //on first resize only
+        ).subscribe(this.initColumnWidth.bind(this)));
+        this.subscriptions.add(this.zone.runOutsideAngular(function () {
+            return _this.draggable.kendoPress.pipe(operators_1.tap(stopPropagation), operators_1.tap(function () { return _this.service.start(_this.column); }), operators_1.switchMap(preventOnDblClick(_this.draggable.kendoRelease)), operators_1.switchMap(createMoveStream(_this.service, _this.draggable)))
+                .subscribe(function (_a) {
+                var pageX = _a.pageX, originalX = _a.originalX;
+                var delta = pageX - originalX;
+                var percent = toPercentage(delta, _this.column.resizeStartWidth || _this.column.width);
+                _this.service.resizeColumns(percent);
+            });
+        }));
+        this.subscriptions.add(service.pipe(operators_1.filter(function (e) { return e.type === 'autoFitComplete'; }))
+            .subscribe(this.sizeToFit.bind(this)));
+        this.subscriptions.add(service.pipe(operators_1.filter(function (e) { return e.type === 'triggerAutoFit'; }))
+            .subscribe(this.autoFit.bind(this)));
+        this.subscriptions.add(this.localization.changes.subscribe(function (_a) {
+            var rtl = _a.rtl;
+            return _this.rtl = rtl;
+        }));
+    };
+    ColumnHandleDirective.prototype.ngOnDestroy = function () {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+    };
+    ColumnHandleDirective.prototype.shouldUpdate = function () {
+        return !allLeafColumns(this.columns)
+            .map(function (column) { return column.width; })
+            .some(utils_1.isBlank);
+    };
+    ColumnHandleDirective.prototype.initColumnWidth = function () {
+        this.column.width = headerWidth(this.element);
+    };
+    ColumnHandleDirective.prototype.initState = function () {
+        this.column.resizeStartWidth = headerWidth(this.element);
+        this.service.resizedColumn({
+            column: this.column,
+            oldWidth: this.column.resizeStartWidth
+        });
+    };
+    ColumnHandleDirective.prototype.resize = function (_a) {
+        var deltaPercent = _a.deltaPercent;
+        var delta = fromPercentage(this.column.resizeStartWidth, deltaPercent);
+        if (utils_1.isTruthy(this.rtl)) {
+            delta *= -1;
+        }
+        var newWidth = Math.max(this.column.resizeStartWidth + delta, this.column.minResizableWidth);
+        var tableDelta = newWidth > this.column.minResizableWidth ?
+            delta : this.column.minResizableWidth - this.column.resizeStartWidth;
+        this.updateWidth(this.column, newWidth);
+        this.service.resizeTable(this.column, tableDelta);
+    };
+    ColumnHandleDirective.prototype.sizeToFit = function (_a) {
+        var columns = _a.columns, widths = _a.widths;
+        var index = columns.indexOf(this.column);
+        var width = Math.max.apply(Math, widths.map(function (w) { return w[index]; })) + 1; //add 1px for IE
+        var tableDelta = width - this.column.resizeStartWidth;
+        this.updateWidth(this.column, width);
+        this.service.resizeTable(this.column, tableDelta);
+    };
+    ColumnHandleDirective.prototype.updateWidth = function (column, width) {
+        column.width = width;
+        this.cdr.markForCheck(); //force CD cycle
+    };
+    ColumnHandleDirective.prototype.columnsForLevel = function (level) {
+        return column_common_1.columnsToRender(this.columns ? this.columns.filter(function (column) { return column.level === level; }) : []);
+    };
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", Array)
+    ], ColumnHandleDirective.prototype, "columns", void 0);
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", column_base_1.ColumnBase)
+    ], ColumnHandleDirective.prototype, "column", void 0);
+    tslib_1.__decorate([
+        core_1.HostBinding('style.display'),
+        tslib_1.__metadata("design:type", String),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], ColumnHandleDirective.prototype, "visible", null);
+    tslib_1.__decorate([
+        core_1.HostBinding('style.left'),
+        tslib_1.__metadata("design:type", Number),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], ColumnHandleDirective.prototype, "leftStyle", null);
+    tslib_1.__decorate([
+        core_1.HostBinding('style.right'),
+        tslib_1.__metadata("design:type", Number),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], ColumnHandleDirective.prototype, "rightStyle", null);
+    tslib_1.__decorate([
+        core_1.HostListener('dblclick'),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", void 0)
+    ], ColumnHandleDirective.prototype, "autoFit", null);
+    ColumnHandleDirective = tslib_1.__decorate([
+        core_1.Directive({
+            selector: '[kendoTreeListColumnHandle]'
+        }),
+        tslib_1.__param(0, core_1.Host()),
+        tslib_1.__metadata("design:paramtypes", [kendo_angular_common_1.DraggableDirective,
+            core_1.ElementRef,
+            column_resizing_service_1.ColumnResizingService,
+            core_1.NgZone,
+            core_1.ChangeDetectorRef,
+            kendo_angular_l10n_1.LocalizationService])
+    ], ColumnHandleDirective);
+    return ColumnHandleDirective;
+}());
+exports.ColumnHandleDirective = ColumnHandleDirective;

package/dist/npm/column-resizing/column-resize.interface.js

@@ -0,0 +1,6 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/npm/column-resizing/column-resizing.service.js

@@ -0,0 +1,154 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = require("@angular/core");
+var rxjs_1 = require("rxjs");
+var column_common_1 = require("../columns/column-common");
+var operators_1 = require("rxjs/operators");
+/**
+ * @hidden
+ */
+var isLocked = function (column) { return column.parent ? isLocked(column.parent) : !!column.locked; };
+var ɵ0 = isLocked;
+exports.ɵ0 = ɵ0;
+/**
+ * @hidden
+ */
+var resizeArgs = function (column, extra) { return Object.assign({
+    columns: column_common_1.leafColumns([column]),
+    locked: isLocked(column)
+}, extra); }; // tslint:disable-line:align
+var ɵ1 = resizeArgs;
+exports.ɵ1 = ɵ1;
+/**
+ * @hidden
+ */
+var ColumnResizingService = /** @class */ (function () {
+    function ColumnResizingService() {
+        this.changes = new core_1.EventEmitter();
+        this.tables = [];
+        this.batch = null;
+    }
+    ColumnResizingService.prototype.start = function (column) {
+        this.trackColumns(column);
+        var columns = (this.column.isColumnGroup ? [column] : [])
+            .concat(column_common_1.leafColumns([column]));
+        this.changes.emit({
+            columns: columns,
+            locked: isLocked(this.column),
+            type: 'start'
+        });
+    };
+    ColumnResizingService.prototype.resizeColumns = function (deltaPercent) {
+        var action = resizeArgs(this.column, {
+            deltaPercent: deltaPercent,
+            type: 'resizeColumn'
+        });
+        this.changes.emit(action);
+    };
+    ColumnResizingService.prototype.resizeTable = function (column, delta) {
+        var action = resizeArgs(column, {
+            delta: delta,
+            type: 'resizeTable'
+        });
+        this.changes.emit(action);
+    };
+    ColumnResizingService.prototype.resizedColumn = function (state) {
+        this.resizedColumns.push(state);
+    };
+    ColumnResizingService.prototype.end = function () {
+        this.changes.emit({
+            columns: [],
+            resizedColumns: this.resizedColumns,
+            type: 'end'
+        });
+    };
+    ColumnResizingService.prototype.registerTable = function (tableMetadata) {
+        var _this = this;
+        this.tables.push(tableMetadata);
+        var unregisterTable = function () {
+            _this.tables.splice(_this.tables.indexOf(tableMetadata), 1);
+        };
+        return unregisterTable;
+    };
+    ColumnResizingService.prototype.measureColumns = function (info) {
+        var _this = this;
+        var _a;
+        if (this.batch !== null) {
+            (_a = this.batch).push.apply(_a, info);
+        }
+        else {
+            this.autoFitBatch(info, function () { return _this.end(); });
+        }
+    };
+    ColumnResizingService.prototype.autoFit = function () {
+        var _this = this;
+        var columns = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            columns[_i] = arguments[_i];
+        }
+        var nonLockedColumns = columns.filter(function (column) { return !column.isLocked; });
+        this.autoFitStart(nonLockedColumns);
+        this.autoFitBatch(this.batch, function () {
+            if (nonLockedColumns.length < columns.length) {
+                var lockedColumns = columns.filter(function (column) { return column.isLocked; });
+                _this.autoFitStart(lockedColumns);
+                _this.autoFitBatch(_this.batch, function () { return _this.end(); });
+            }
+            else {
+                _this.end();
+            }
+        });
+    };
+    ColumnResizingService.prototype.trackColumns = function (column) {
+        this.resizedColumns = [];
+        this.column = column;
+    };
+    ColumnResizingService.prototype.autoFitStart = function (columns) {
+        this.batch = [];
+        this.resizedColumns = [];
+        if (columns.length === 0) {
+            return;
+        }
+        var locked = columns[0].isLocked;
+        this.changes.emit({
+            type: 'start',
+            columns: columns,
+            locked: locked
+        });
+        this.changes.emit({
+            type: 'triggerAutoFit',
+            columns: columns,
+            locked: locked
+        });
+    };
+    ColumnResizingService.prototype.autoFitBatch = function (info, onComplete) {
+        var _this = this;
+        var locked = info.length > 0 ? info[0].column.isLocked : false;
+        var observables = this.tables
+            .filter(function (table) { return table.locked === locked; })
+            .map(function (table) { return table.autoFit(info); });
+        rxjs_1.zip.apply(void 0, observables).pipe(operators_1.take(1))
+            .subscribe(function (widths) {
+            _this.changes.emit({
+                columns: info.map(function (i) { return i.column; }),
+                type: 'autoFitComplete',
+                widths: widths,
+                locked: locked
+            });
+            if (onComplete) {
+                onComplete();
+            }
+        });
+        this.batch = null;
+    };
+    ColumnResizingService = tslib_1.__decorate([
+        core_1.Injectable()
+    ], ColumnResizingService);
+    return ColumnResizingService;
+}());
+exports.ColumnResizingService = ColumnResizingService;

package/dist/npm/column-resizing/table.directive.js

@@ -0,0 +1,165 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = require("@angular/core");
+var rxjs_1 = require("rxjs");
+var column_common_1 = require("../columns/column-common");
+var column_resizing_service_1 = require("./column-resizing.service");
+var operators_1 = require("rxjs/operators");
+/**
+ * @hidden
+ */
+var columnsToResize = function (_a) {
+    var columns = _a.columns;
+    return Math.max(1, column_common_1.resizableColumns(columns).length);
+};
+var ɵ0 = columnsToResize;
+exports.ɵ0 = ɵ0;
+/**
+ * @hidden
+ */
+var row = function (selector) { return function (element) { return element.querySelector(selector); }; };
+var ɵ1 = row;
+exports.ɵ1 = ɵ1;
+/**
+ * @hidden
+ */
+var headerRow = function (index) { return function (element) { return element.querySelectorAll('thead>tr')[index]; }; };
+var ɵ2 = headerRow;
+exports.ɵ2 = ɵ2;
+/**
+ * @hidden
+ */
+var cell = function (index, selector) {
+    if (selector === void 0) { selector = 'td'; }
+    return function (element) {
+        return element.querySelectorAll(selector + ":not(.k-group-cell):not(.k-hierarchy-cell)")[index];
+    };
+};
+var ɵ3 = cell;
+exports.ɵ3 = ɵ3;
+/**
+ * @hidden
+ */
+var offsetWidth = function (element) { return element.offsetWidth; };
+var ɵ4 = offsetWidth;
+exports.ɵ4 = ɵ4;
+/**
+ * @hidden
+ */
+var pipe = function () {
+    var fns = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
+    }
+    return function (data) { return fns.reduce(function (state, fn) { return state ? fn(state) : 0; }, data); };
+};
+var ɵ5 = pipe;
+exports.ɵ5 = ɵ5;
+/**
+ * @hidden
+ */
+var TableDirective = /** @class */ (function () {
+    function TableDirective(element, renderer, service, zone, cdr) {
+        this.element = element;
+        this.renderer = renderer;
+        this.service = service;
+        this.zone = zone;
+        this.cdr = cdr;
+        this.locked = false;
+        this.firstResize = false;
+    }
+    Object.defineProperty(TableDirective.prototype, "minWidth", {
+        get: function () {
+            return this.firstResize ? 0 : null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    TableDirective.prototype.ngOnInit = function () {
+        var _this = this;
+        var obs = this.service
+            .changes.pipe(operators_1.filter(function (e) { return _this.locked === e.locked; }));
+        this.subscription = obs.pipe(operators_1.filter(function (e) { return e.type === 'start'; }), operators_1.tap(this.initState.bind(this)), operators_1.map(columnsToResize), operators_1.switchMap(function (take) {
+            return obs.pipe(operators_1.filter(function (e) { return e.type === 'resizeTable'; }), operators_1.map(function (e) { return e.delta; }), operators_1.bufferCount(take));
+        })).subscribe(this.resize.bind(this));
+        this.autoFitSubscription = this.service
+            .registerTable({
+            autoFit: this.autoFitObservable.bind(this),
+            locked: this.locked
+        });
+    };
+    TableDirective.prototype.ngOnDestroy = function () {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        if (this.autoFitSubscription) {
+            this.autoFitSubscription();
+            this.autoFitSubscription = null;
+        }
+    };
+    TableDirective.prototype.initState = function () {
+        this.firstResize = true;
+        if (!this.virtualColumns || this.locked) {
+            this.originalWidth = offsetWidth(this.element.nativeElement);
+        }
+    };
+    TableDirective.prototype.resize = function (deltas) {
+        if (!this.virtualColumns || this.locked) {
+            var delta = deltas.reduce(function (sum, item) { return sum + item; }, 0);
+            var width = this.originalWidth + delta;
+            this.renderer.setStyle(this.element.nativeElement, 'width', width + 'px');
+        }
+        this.cdr.detectChanges();
+    };
+    TableDirective.prototype.autoFitObservable = function (columnInfo) {
+        var _this = this;
+        return rxjs_1.Observable.create(function (observer) {
+            _this.zone.runOutsideAngular(function () {
+                _this.renderer.addClass(_this.element.nativeElement, 'k-autofitting');
+                _this.cdr.detectChanges();
+                var widths = columnInfo.map(_this.measureColumn.bind(_this));
+                _this.renderer.removeClass(_this.element.nativeElement, 'k-autofitting');
+                observer.next(widths);
+            });
+        });
+    };
+    TableDirective.prototype.measureColumn = function (info) {
+        var dom = this.element.nativeElement;
+        var header = pipe(headerRow(info.level), cell(info.headerIndex, 'th'), offsetWidth)(dom);
+        var data = 0;
+        if (!info.isParentSpan || (info.isParentSpan && info.isLastInSpan)) {
+            data = pipe(row('tbody>tr:not(.k-grouping-row):not(.k-grid-norecords)'), cell(info.index), offsetWidth)(dom);
+        }
+        return Math.max(header, data);
+    };
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], TableDirective.prototype, "locked", void 0);
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], TableDirective.prototype, "virtualColumns", void 0);
+    tslib_1.__decorate([
+        core_1.HostBinding('style.min-width'),
+        tslib_1.__metadata("design:type", Number),
+        tslib_1.__metadata("design:paramtypes", [])
+    ], TableDirective.prototype, "minWidth", null);
+    TableDirective = tslib_1.__decorate([
+        core_1.Directive({
+            selector: 'table' // tslint:disable-line:directive-selector
+        }),
+        tslib_1.__metadata("design:paramtypes", [core_1.ElementRef,
+            core_1.Renderer2,
+            column_resizing_service_1.ColumnResizingService,
+            core_1.NgZone,
+            core_1.ChangeDetectorRef])
+    ], TableDirective);
+    return TableDirective;
+}());
+exports.TableDirective = TableDirective;

package/dist/npm/columns/checkbox-column.component.js

@@ -0,0 +1,66 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = require("@angular/core");
+var column_base_1 = require("./column-base");
+var cell_template_directive_1 = require("../rendering/cell-template.directive");
+/**
+ * Represents the checkbox for selecting rows in the TreeList.
+ */
+var CheckboxColumnComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(CheckboxColumnComponent, _super);
+    function CheckboxColumnComponent(parent) {
+        var _this = _super.call(this, parent) || this;
+        _this.parent = parent;
+        /*
+         * @hidden
+         */
+        _this.isCheckboxColumn = true;
+        return _this;
+    }
+    CheckboxColumnComponent_1 = CheckboxColumnComponent;
+    Object.defineProperty(CheckboxColumnComponent.prototype, "templateRef", {
+        get: function () {
+            return this.template ? this.template.templateRef : undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    var CheckboxColumnComponent_1;
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], CheckboxColumnComponent.prototype, "showSelectAll", void 0);
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], CheckboxColumnComponent.prototype, "checkChildren", void 0);
+    tslib_1.__decorate([
+        core_1.Input(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], CheckboxColumnComponent.prototype, "expandable", void 0);
+    tslib_1.__decorate([
+        core_1.ContentChild(cell_template_directive_1.CellTemplateDirective, { static: false }),
+        tslib_1.__metadata("design:type", cell_template_directive_1.CellTemplateDirective)
+    ], CheckboxColumnComponent.prototype, "template", void 0);
+    CheckboxColumnComponent = CheckboxColumnComponent_1 = tslib_1.__decorate([
+        core_1.Component({
+            providers: [
+                {
+                    provide: column_base_1.ColumnBase,
+                    useExisting: core_1.forwardRef(function () { return CheckboxColumnComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-checkbox-column',
+            template: ""
+        }),
+        tslib_1.__param(0, core_1.SkipSelf()), tslib_1.__param(0, core_1.Host()), tslib_1.__param(0, core_1.Optional()),
+        tslib_1.__metadata("design:paramtypes", [column_base_1.ColumnBase])
+    ], CheckboxColumnComponent);
+    return CheckboxColumnComponent;
+}(column_base_1.ColumnBase));
+exports.CheckboxColumnComponent = CheckboxColumnComponent;