@progress/kendo-angular-treelist 4.0.6-dev.202203090952 → 5.0.0-dev.202204191050

package/esm2015/column-menu/column-menu.module.js

@@ -0,0 +1,77 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ColumnListComponent } from './column-list.component';
+import { ColumnChooserComponent } from './column-chooser.component';
+import { ColumnMenuChooserComponent } from './column-menu-chooser.component';
+import { ColumnMenuFilterComponent } from './column-menu-filter.component';
+import { ColumnMenuItemComponent } from './column-menu-item.component';
+import { ColumnMenuItemContentTemplateDirective } from './column-menu-item-content-template.directive';
+import { ColumnMenuSortComponent } from './column-menu-sort.component';
+import { ColumnMenuComponent } from './column-menu.component';
+import { ColumnMenuLockComponent } from './column-menu-lock.component';
+import { FilterMenuModule } from '../filtering/menu/filter-menu.module';
+import { ColumnMenuTemplateDirective } from './column-menu-template.directive';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    ColumnListComponent,
+    ColumnChooserComponent,
+    ColumnMenuChooserComponent,
+    ColumnMenuFilterComponent,
+    ColumnMenuItemComponent,
+    ColumnMenuItemContentTemplateDirective,
+    ColumnMenuSortComponent,
+    ColumnMenuComponent,
+    ColumnMenuLockComponent,
+    ColumnMenuTemplateDirective
+];
+/**
+ * @hidden
+ */
+export class ColumnMenuModule {
+    static exports() {
+        return [
+            ColumnChooserComponent,
+            ColumnMenuFilterComponent,
+            ColumnMenuItemComponent,
+            ColumnMenuItemContentTemplateDirective,
+            ColumnMenuSortComponent,
+            ColumnMenuLockComponent,
+            ColumnMenuChooserComponent,
+            ColumnMenuTemplateDirective,
+            ColumnMenuComponent
+        ];
+    }
+}
+ColumnMenuModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ColumnMenuModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuModule, declarations: [ColumnListComponent,
+        ColumnChooserComponent,
+        ColumnMenuChooserComponent,
+        ColumnMenuFilterComponent,
+        ColumnMenuItemComponent,
+        ColumnMenuItemContentTemplateDirective,
+        ColumnMenuSortComponent,
+        ColumnMenuComponent,
+        ColumnMenuLockComponent,
+        ColumnMenuTemplateDirective], imports: [CommonModule, FilterMenuModule], exports: [ColumnListComponent,
+        ColumnChooserComponent,
+        ColumnMenuChooserComponent,
+        ColumnMenuFilterComponent,
+        ColumnMenuItemComponent,
+        ColumnMenuItemContentTemplateDirective,
+        ColumnMenuSortComponent,
+        ColumnMenuComponent,
+        ColumnMenuLockComponent,
+        ColumnMenuTemplateDirective] });
+ColumnMenuModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuModule, imports: [[CommonModule, FilterMenuModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [COMPONENTS],
+                    imports: [CommonModule, FilterMenuModule],
+                    exports: [COMPONENTS]
+                }]
+        }] });

package/esm2015/column-menu/column-menu.service.js

@@ -0,0 +1,39 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Represents the service that is passed to the
+ * [`ColumnMenuTemplate`]({% slug api_treelist_columnmenutemplatedirective %}) directive.
+ *
+ * {% meta height:500 %}
+ * {% embed_file column-menu/template-item/app.component.ts preview %}
+ * {% embed_file column-menu/template-item/app.module.ts %}
+ * {% embed_file shared/main.ts %}
+ * {% embed_file shared/employees.ts %}
+ * {% endmeta %}
+ */
+export class ColumnMenuService {
+    /**
+     * @hidden
+     */
+    constructor() {
+        /**
+         * @hidden
+         */
+        this.closeMenu = new EventEmitter();
+    }
+    /**
+     * Closes the column menu.
+     */
+    close() {
+        this.closeMenu.emit();
+    }
+}
+ColumnMenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ColumnMenuService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnMenuService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });

package/esm2015/column-resizing/column-handle.directive.js

@@ -0,0 +1,216 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Host, HostBinding, HostListener, Input } from '@angular/core';
+import { Subscription, of } from 'rxjs';
+import { isBlank, isPresent, isTruthy } from '../utils';
+import { expandColumns, leafColumns, columnsToRender } from '../columns/column-common';
+import { delay, takeUntil, filter, take, tap, switchMap, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-common";
+import * as i2 from "./column-resizing.service";
+import * as i3 from "@progress/kendo-angular-l10n";
+/**
+ * @hidden
+ */
+const fromPercentage = (value, percent) => {
+    const sign = percent < 0 ? -1 : 1;
+    return Math.ceil((Math.abs(percent) / 100) * value) * sign;
+};
+/**
+ * @hidden
+ */
+const toPercentage = (value, whole) => (value / whole) * 100;
+/**
+ * @hidden
+ */
+const headerWidth = (handle) => handle.nativeElement.parentElement.offsetWidth;
+/**
+ * @hidden
+ */
+const allLeafColumns = columns => expandColumns(columns)
+    .filter(c => !c.isColumnGroup);
+/**
+ * @hidden
+ */
+const stopPropagation = ({ originalEvent: event }) => {
+    event.stopPropagation();
+    event.preventDefault();
+};
+/**
+ * @hidden
+ */
+const createMoveStream = (service, draggable) => mouseDown => draggable.kendoDrag.pipe(
+// eslint-disable-next-line rxjs/no-unsafe-takeuntil
+takeUntil(draggable.kendoRelease.pipe(tap(() => service.end()))), map(({ pageX }) => ({
+    originalX: mouseDown.pageX,
+    pageX
+})));
+/**
+ * @hidden
+ */
+const preventOnDblClick = release => mouseDown => of(mouseDown).pipe(delay(150), takeUntil(release));
+/**
+ * @hidden
+ */
+const isInSpanColumn = column => !!(column.parent && column.parent.isSpanColumn);
+/**
+ * @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.
+ */
+const indexOf = (target, list) => {
+    let index = 0;
+    let ignore = 0;
+    let skip = 0;
+    while (index < list.length) {
+        const current = list[index];
+        const isParentSpanColumn = isInSpanColumn(current);
+        if (current === target) {
+            break;
+        }
+        if ((ignore-- <= 0) && isParentSpanColumn) {
+            ignore = current.parent.childColumns.length - 1;
+            skip += ignore;
+        }
+        index++;
+    }
+    return index - skip;
+};
+/**
+ * @hidden
+ */
+export class ColumnHandleDirective {
+    constructor(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 Subscription();
+        this.rtl = false;
+    }
+    get visible() {
+        return this.column.resizable ? 'block' : 'none';
+    }
+    get leftStyle() {
+        return isTruthy(this.rtl) ? 0 : null;
+    }
+    get rightStyle() {
+        return isTruthy(this.rtl) ? null : 0;
+    }
+    autoFit() {
+        const allLeafs = allLeafColumns(this.columns);
+        const currentLeafs = leafColumns([this.column]).filter(column => isTruthy(column.resizable));
+        const columnInfo = currentLeafs.map(column => {
+            const isParentSpan = isInSpanColumn(column);
+            const isLastInSpan = isParentSpan ? column.parent.childColumns.last === column : false;
+            const index = indexOf(column, allLeafs);
+            return {
+                column,
+                headerIndex: this.columnsForLevel(column.level).indexOf(column),
+                index,
+                isLastInSpan,
+                isParentSpan,
+                level: column.level
+            };
+        });
+        currentLeafs.forEach(column => column.width = 0);
+        this.service.measureColumns(columnInfo);
+    }
+    ngOnInit() {
+        const service = this.service.changes.pipe(filter(() => this.column.resizable), filter(e => isPresent(e.columns.find(column => column === this.column))));
+        this.subscriptions.add(service.pipe(filter(e => e.type === 'start'))
+            .subscribe(this.initState.bind(this)));
+        this.subscriptions.add(service.pipe(filter(e => e.type === 'resizeColumn'))
+            .subscribe(this.resize.bind(this)));
+        this.subscriptions.add(this.service.changes.pipe(filter(e => e.type === 'start'), filter(this.shouldUpdate.bind(this)), take(1) //on first resize only
+        ).subscribe(this.initColumnWidth.bind(this)));
+        this.subscriptions.add(this.zone.runOutsideAngular(() => this.draggable.kendoPress.pipe(tap(stopPropagation), tap(() => this.service.start(this.column)), switchMap(preventOnDblClick(this.draggable.kendoRelease)), switchMap(createMoveStream(this.service, this.draggable)))
+            .subscribe(({ pageX, originalX }) => {
+            const delta = pageX - originalX;
+            const percent = toPercentage(delta, this.column.resizeStartWidth || this.column.width);
+            this.service.resizeColumns(percent);
+        })));
+        this.subscriptions.add(service.pipe(filter(e => e.type === 'autoFitComplete'))
+            .subscribe(this.sizeToFit.bind(this)));
+        this.subscriptions.add(service.pipe(filter(e => e.type === 'triggerAutoFit'))
+            .subscribe(this.autoFit.bind(this)));
+        this.subscriptions.add(this.localization.changes.subscribe(({ rtl }) => this.rtl = rtl));
+    }
+    ngOnDestroy() {
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+    }
+    shouldUpdate() {
+        return !allLeafColumns(this.columns)
+            .map(column => column.width)
+            .some(isBlank);
+    }
+    initColumnWidth() {
+        this.column.width = headerWidth(this.element);
+    }
+    initState() {
+        this.column.resizeStartWidth = headerWidth(this.element);
+        this.service.resizedColumn({
+            column: this.column,
+            oldWidth: this.column.resizeStartWidth
+        });
+    }
+    resize({ deltaPercent }) {
+        let delta = fromPercentage(this.column.resizeStartWidth, deltaPercent);
+        if (isTruthy(this.rtl)) {
+            delta *= -1;
+        }
+        const newWidth = Math.max(this.column.resizeStartWidth + delta, this.column.minResizableWidth);
+        const tableDelta = newWidth > this.column.minResizableWidth ?
+            delta : this.column.minResizableWidth - this.column.resizeStartWidth;
+        this.updateWidth(this.column, newWidth);
+        this.service.resizeTable(this.column, tableDelta);
+    }
+    sizeToFit({ columns, widths }) {
+        const index = columns.indexOf(this.column);
+        const width = Math.max(...widths.map(w => w[index])) + 1; //add 1px for IE
+        const tableDelta = width - this.column.resizeStartWidth;
+        this.updateWidth(this.column, width);
+        this.service.resizeTable(this.column, tableDelta);
+    }
+    updateWidth(column, width) {
+        column.width = width;
+        this.cdr.markForCheck(); //force CD cycle
+    }
+    columnsForLevel(level) {
+        return columnsToRender(this.columns ? this.columns.filter(column => column.level === level) : []);
+    }
+}
+ColumnHandleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnHandleDirective, deps: [{ token: i1.DraggableDirective, host: true }, { token: i0.ElementRef }, { token: i2.ColumnResizingService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i3.LocalizationService }], target: i0.ɵɵFactoryTarget.Directive });
+ColumnHandleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: ColumnHandleDirective, selector: "[kendoTreeListColumnHandle]", inputs: { columns: "columns", column: "column" }, host: { listeners: { "dblclick": "autoFit()" }, properties: { "style.display": "this.visible", "style.left": "this.leftStyle", "style.right": "this.rightStyle" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoTreeListColumnHandle]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DraggableDirective, decorators: [{
+                    type: Host
+                }] }, { type: i0.ElementRef }, { type: i2.ColumnResizingService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i3.LocalizationService }]; }, propDecorators: { columns: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], visible: [{
+                type: HostBinding,
+                args: ['style.display']
+            }], leftStyle: [{
+                type: HostBinding,
+                args: ['style.left']
+            }], rightStyle: [{
+                type: HostBinding,
+                args: ['style.right']
+            }], autoFit: [{
+                type: HostListener,
+                args: ['dblclick']
+            }] } });

package/esm2015/column-resizing/column-resize.interface.js

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

package/esm2015/column-resizing/column-resizing.service.js

@@ -0,0 +1,140 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, EventEmitter } from '@angular/core';
+import { zip } from 'rxjs';
+import { leafColumns } from '../columns/column-common';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+const isLocked = column => column.parent ? isLocked(column.parent) : !!column.locked;
+/**
+ * @hidden
+ */
+const resizeArgs = (column, extra) => Object.assign({
+    columns: leafColumns([column]),
+    locked: isLocked(column)
+}, extra);
+/**
+ * @hidden
+ */
+export class ColumnResizingService {
+    constructor() {
+        this.changes = new EventEmitter();
+        this.tables = [];
+        this.batch = null;
+    }
+    start(column) {
+        this.trackColumns(column);
+        const columns = (this.column.isColumnGroup ? [column] : [])
+            .concat(leafColumns([column]));
+        this.changes.emit({
+            columns: columns,
+            locked: isLocked(this.column),
+            type: 'start'
+        });
+    }
+    resizeColumns(deltaPercent) {
+        const action = resizeArgs(this.column, {
+            deltaPercent,
+            type: 'resizeColumn'
+        });
+        this.changes.emit(action);
+    }
+    resizeTable(column, delta) {
+        const action = resizeArgs(column, {
+            delta,
+            type: 'resizeTable'
+        });
+        this.changes.emit(action);
+    }
+    resizedColumn(state) {
+        this.resizedColumns.push(state);
+    }
+    end() {
+        this.changes.emit({
+            columns: [],
+            resizedColumns: this.resizedColumns,
+            type: 'end'
+        });
+    }
+    registerTable(tableMetadata) {
+        this.tables.push(tableMetadata);
+        const unregisterTable = () => {
+            this.tables.splice(this.tables.indexOf(tableMetadata), 1);
+        };
+        return unregisterTable;
+    }
+    measureColumns(info) {
+        if (this.batch !== null) {
+            this.batch.push(...info);
+        }
+        else {
+            this.autoFitBatch(info, () => this.end());
+        }
+    }
+    autoFit(...columns) {
+        const nonLockedColumns = columns.filter(column => !column.isLocked);
+        this.autoFitStart(nonLockedColumns);
+        this.autoFitBatch(this.batch, () => {
+            if (nonLockedColumns.length < columns.length) {
+                const lockedColumns = columns.filter(column => column.isLocked);
+                this.autoFitStart(lockedColumns);
+                this.autoFitBatch(this.batch, () => this.end());
+            }
+            else {
+                this.end();
+            }
+        });
+    }
+    trackColumns(column) {
+        this.resizedColumns = [];
+        this.column = column;
+    }
+    autoFitStart(columns) {
+        this.batch = [];
+        this.resizedColumns = [];
+        if (columns.length === 0) {
+            return;
+        }
+        const locked = columns[0].isLocked;
+        this.changes.emit({
+            type: 'start',
+            columns,
+            locked
+        });
+        this.changes.emit({
+            type: 'triggerAutoFit',
+            columns,
+            locked
+        });
+    }
+    autoFitBatch(info, onComplete) {
+        const locked = info.length > 0 ? info[0].column.isLocked : false;
+        const observables = this.tables
+            .filter(table => table.locked === locked)
+            .map(table => table.autoFit(info));
+        zip(...observables)
+            .pipe(take(1))
+            .subscribe(widths => {
+            this.changes.emit({
+                columns: info.map(i => i.column),
+                type: 'autoFitComplete',
+                widths,
+                locked
+            });
+            if (onComplete) {
+                onComplete();
+            }
+        });
+        this.batch = null;
+    }
+}
+ColumnResizingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnResizingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ColumnResizingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnResizingService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ColumnResizingService, decorators: [{
+            type: Injectable
+        }] });

package/esm2015/column-resizing/table.directive.js

@@ -0,0 +1,120 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, HostBinding, Input } from '@angular/core';
+import { Observable } from 'rxjs';
+import { resizableColumns } from '../columns/column-common';
+import { filter, tap, map, switchMap, bufferCount } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./column-resizing.service";
+/**
+ * @hidden
+ */
+const columnsToResize = ({ columns }) => Math.max(1, resizableColumns(columns).length);
+/**
+ * @hidden
+ */
+const row = selector => element => element.querySelector(selector);
+/**
+ * @hidden
+ */
+const headerRow = index => element => element.querySelectorAll('thead>tr')[index];
+/**
+ * @hidden
+ */
+const cell = (index, selector = 'td') => element => element.querySelectorAll(`${selector}:not(.k-group-cell):not(.k-hierarchy-cell)`)[index];
+/**
+ * @hidden
+ */
+const offsetWidth = element => element.offsetWidth;
+/**
+ * @hidden
+ */
+const pipe = (...fns) => data => fns.reduce((state, fn) => state ? fn(state) : 0, data);
+/**
+ * @hidden
+ */
+export class TableDirective {
+    constructor(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;
+    }
+    get minWidth() {
+        return this.firstResize ? 0 : null;
+    }
+    ngOnInit() {
+        const obs = this.service
+            .changes.pipe(filter(e => this.locked === e.locked));
+        this.subscription = obs.pipe(filter(e => e.type === 'start'), tap(this.initState.bind(this)), map(columnsToResize), switchMap((take) => obs.pipe(filter(e => e.type === 'resizeTable'), map(e => e.delta), bufferCount(take)))).subscribe(this.resize.bind(this));
+        this.autoFitSubscription = this.service
+            .registerTable({
+            autoFit: this.autoFitObservable.bind(this),
+            locked: this.locked
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        if (this.autoFitSubscription) {
+            this.autoFitSubscription();
+            this.autoFitSubscription = null;
+        }
+    }
+    initState() {
+        this.firstResize = true;
+        if (!this.virtualColumns || this.locked) {
+            this.originalWidth = offsetWidth(this.element.nativeElement);
+        }
+    }
+    resize(deltas) {
+        if (!this.virtualColumns || this.locked) {
+            const delta = deltas.reduce((sum, item) => sum + item, 0);
+            const width = this.originalWidth + delta;
+            this.renderer.setStyle(this.element.nativeElement, 'width', width + 'px');
+        }
+        this.cdr.detectChanges();
+    }
+    autoFitObservable(columnInfo) {
+        return Observable.create(observer => {
+            this.zone.runOutsideAngular(() => {
+                this.renderer.addClass(this.element.nativeElement, 'k-autofitting');
+                this.cdr.detectChanges();
+                const widths = columnInfo.map(this.measureColumn.bind(this));
+                this.renderer.removeClass(this.element.nativeElement, 'k-autofitting');
+                observer.next(widths);
+            });
+        });
+    }
+    measureColumn(info) {
+        const dom = this.element.nativeElement;
+        const header = pipe(headerRow(info.level), cell(info.headerIndex, 'th'), offsetWidth)(dom);
+        let 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);
+    }
+}
+TableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ColumnResizingService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+TableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: TableDirective, selector: "table", inputs: { locked: "locked", virtualColumns: "virtualColumns" }, host: { properties: { "style.min-width": "this.minWidth" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'table'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ColumnResizingService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { locked: [{
+                type: Input
+            }], virtualColumns: [{
+                type: Input
+            }], minWidth: [{
+                type: HostBinding,
+                args: ['style.min-width']
+            }] } });

package/esm2015/columns/checkbox-column.component.js

@@ -0,0 +1,60 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef, ContentChild, SkipSelf, Host, Optional, Input } from '@angular/core';
+import { ColumnBase } from './column-base';
+import { CellTemplateDirective } from '../rendering/cell-template.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./column-base";
+/**
+ * Represents the checkbox for selecting rows in the TreeList.
+ */
+export class CheckboxColumnComponent extends ColumnBase {
+    constructor(parent) {
+        super(parent);
+        this.parent = parent;
+        /*
+         * @hidden
+         */
+        this.isCheckboxColumn = true;
+    }
+    get templateRef() {
+        return this.template ? this.template.templateRef : undefined;
+    }
+}
+CheckboxColumnComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CheckboxColumnComponent, deps: [{ token: i1.ColumnBase, host: true, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Component });
+CheckboxColumnComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: CheckboxColumnComponent, selector: "kendo-treelist-checkbox-column", inputs: { showSelectAll: "showSelectAll", checkChildren: "checkChildren", expandable: "expandable" }, providers: [
+        {
+            provide: ColumnBase,
+            useExisting: forwardRef(() => CheckboxColumnComponent)
+        }
+    ], queries: [{ propertyName: "template", first: true, predicate: CellTemplateDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CheckboxColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: ColumnBase,
+                            useExisting: forwardRef(() => CheckboxColumnComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-checkbox-column',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ColumnBase, decorators: [{
+                    type: SkipSelf
+                }, {
+                    type: Host
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { showSelectAll: [{
+                type: Input
+            }], checkChildren: [{
+                type: Input
+            }], expandable: [{
+                type: Input
+            }], template: [{
+                type: ContentChild,
+                args: [CellTemplateDirective, { static: false }]
+            }] } });