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

package/dist/es2015/rendering/no-records-template.directive.d.ts

@@ -0,0 +1,23 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { TemplateRef } from '@angular/core';
+/**
+ * Represents the no-records template of the TreeList. Provides an option to customize the
+ * appearance of the item that is displayed when no data is present. To define the no-records template,
+ * nest an `<ng-template>` tag with the `kendoTreeListNoRecordsTemplate` directive inside `<kendo-treelist>`.
+ *
+ * > When the locked columns of the TreeList are in use, the template is displayed in the non-locked part of the content.
+ *
+ * {% meta height:533 %}
+ * {% embed_file configuration/no-records-template/app.component.ts preview %}
+ * {% embed_file configuration/no-records-template/app.module.ts %}
+ * {% embed_file shared/main.ts %}
+ * {% embed_file shared/employees.ts %}
+ * {% endmeta %}
+ */
+export declare class NoRecordsTemplateDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+}

package/dist/es2015/rendering/no-records-template.directive.js

@@ -0,0 +1,33 @@
+/**-----------------------------------------------------------------------------------------
+* 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, TemplateRef, Optional } from '@angular/core';
+/**
+ * Represents the no-records template of the TreeList. Provides an option to customize the
+ * appearance of the item that is displayed when no data is present. To define the no-records template,
+ * nest an `<ng-template>` tag with the `kendoTreeListNoRecordsTemplate` directive inside `<kendo-treelist>`.
+ *
+ * > When the locked columns of the TreeList are in use, the template is displayed in the non-locked part of the content.
+ *
+ * {% meta height:533 %}
+ * {% embed_file configuration/no-records-template/app.component.ts preview %}
+ * {% embed_file configuration/no-records-template/app.module.ts %}
+ * {% embed_file shared/main.ts %}
+ * {% embed_file shared/employees.ts %}
+ * {% endmeta %}
+ */
+let NoRecordsTemplateDirective = class NoRecordsTemplateDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+};
+NoRecordsTemplateDirective = tslib_1.__decorate([
+    Directive({
+        selector: '[kendoTreeListNoRecordsTemplate]'
+    }),
+    tslib_1.__param(0, Optional()),
+    tslib_1.__metadata("design:paramtypes", [TemplateRef])
+], NoRecordsTemplateDirective);
+export { NoRecordsTemplateDirective };

package/dist/es2015/rendering/table-body.component.d.ts

@@ -0,0 +1,87 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { SimpleChange, NgZone, Renderer2, ElementRef, OnInit, OnDestroy, OnChanges, TrackByFunction } from '@angular/core';
+import { ColumnBase } from '../columns/column-base';
+import { ChangeNotificationService } from '../data/change-notification.service';
+import { NoRecordsTemplateDirective } from './no-records-template.directive';
+import { EditService } from '../editing/edit.service';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { RowClassFn } from './common/row-class';
+import { DomEventsService } from '../common/dom-events.service';
+import { ColumnInfoService } from "../common/column-info.service";
+import { FilterableSettings } from '../filtering/filterable';
+import { NavigationService } from '../navigation/navigation.service';
+import { TreeListItem } from '../data/treelist-item.interface';
+import { ExpandStateService } from '../expand-state/expand-state.service';
+import { SelectionService } from '../selection/selection.service';
+/**
+ * @hidden
+ */
+export declare class TableBodyComponent implements OnInit, OnDestroy, OnChanges {
+    private changeNotification;
+    editService: EditService;
+    private localization;
+    private ngZone;
+    private renderer;
+    private element;
+    private domEvents;
+    private columnInfoService;
+    private navigationService;
+    private expandState;
+    private selection;
+    columns: Array<ColumnBase>;
+    allColumns: Array<ColumnBase>;
+    noRecordsTemplate: NoRecordsTemplateDirective;
+    view: any;
+    skip: number;
+    filterable: FilterableSettings;
+    noRecordsText: string;
+    isLocked: boolean;
+    lockedColumnsCount: number;
+    totalColumnsCount: number;
+    virtualColumns: boolean;
+    expandIcons: boolean;
+    trackBy: TrackByFunction<TreeListItem>;
+    private clickSubscription;
+    private cellKeydownSubscription;
+    private clickTimeout;
+    private headerOffset;
+    rowClass: RowClassFn;
+    constructor(changeNotification: ChangeNotificationService, editService: EditService, localization: LocalizationService, ngZone: NgZone, renderer: Renderer2, element: ElementRef, domEvents: DomEventsService, columnInfoService: ColumnInfoService, navigationService: NavigationService, expandState: ExpandStateService, selection: SelectionService);
+    readonly newDataItem: any;
+    readonly unlockedColumnsCount: number;
+    isOdd(item: any): boolean;
+    trackByWrapper(index: number, item: TreeListItem): any;
+    trackByColumns(index: number, item: any): any;
+    ngOnChanges(changes: {
+        [propertyName: string]: SimpleChange;
+    }): void;
+    addRowLogicalIndex(): number;
+    logicalColIndex(column: any): number;
+    ariaExpanded(item: any, column: any): any;
+    ariaSelected(item: any, column: any, columnIndex: number): any;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    isEditingCell(item: any, column: any): boolean;
+    isEditingRow(item: any): boolean;
+    readonly columnsContainer: any;
+    readonly hasFooter: boolean;
+    readonly columnsSpan: number;
+    readonly allColumnsSpan: number;
+    readonly colSpan: number;
+    readonly footerColumns: ColumnBase[];
+    logicalRowIndex(rowIndex: number): number;
+    isCellSelected(dataItem: any, column: any, columnIndex: number): boolean;
+    targetArgs(target: any, skipFocusable?: boolean): any;
+    private clickHandler;
+    private emitCellClick;
+    private cellKeydownHandler;
+    private cellClickArgs;
+    private targetElements;
+    private expandClick;
+    private checkboxClick;
+    private rowItem;
+}

package/dist/es2015/rendering/table-body.component.js

@@ -0,0 +1,457 @@
+/**-----------------------------------------------------------------------------------------
+* 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 { Component, Input, NgZone, Renderer2, ElementRef } from '@angular/core';
+import { ChangeNotificationService } from '../data/change-notification.service';
+import { isChanged, isPresent } from '../utils';
+import { NoRecordsTemplateDirective } from './no-records-template.directive';
+import { EditService } from '../editing/edit.service';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+import { columnsSpan } from "../columns/column-common";
+import { closest, closestInScope, hasClasses, isFocusableWithTabKey, matchesClasses, matchesNodeName } from './common/dom-queries';
+import { DomEventsService } from '../common/dom-events.service';
+import { ColumnInfoService } from "../common/column-info.service";
+import { hasFilterRow } from '../filtering/filterable';
+import { NavigationService } from '../navigation/navigation.service';
+import { Keys } from '@progress/kendo-angular-common';
+import { defaultTrackBy } from '../common/default-track-by';
+import { ExpandStateService } from '../expand-state/expand-state.service';
+import { SelectionService } from '../selection/selection.service';
+import { NON_DATA_CELL_CLASSES, NON_DATA_ROW_CLASSES, IGNORE_TARGET_CLASSSES, IGNORE_CONTAINER_CLASSES } from './constants';
+const columnCellIndex = (cell, cells) => {
+    for (let idx = 0; idx < cells.length; idx++) {
+        if (cells[idx] === cell) {
+            return idx;
+        }
+    }
+};
+const ɵ0 = columnCellIndex;
+/**
+ * @hidden
+ */
+let TableBodyComponent = class TableBodyComponent {
+    constructor(changeNotification, editService, localization, ngZone, renderer, element, domEvents, columnInfoService, navigationService, expandState, selection) {
+        this.changeNotification = changeNotification;
+        this.editService = editService;
+        this.localization = localization;
+        this.ngZone = ngZone;
+        this.renderer = renderer;
+        this.element = element;
+        this.domEvents = domEvents;
+        this.columnInfoService = columnInfoService;
+        this.navigationService = navigationService;
+        this.expandState = expandState;
+        this.selection = selection;
+        this.columns = [];
+        this.skip = 0;
+        this.noRecordsText = this.localization.get('noRecords');
+        this.isLocked = false;
+        this.lockedColumnsCount = 0;
+        this.totalColumnsCount = 0;
+        this.trackBy = defaultTrackBy;
+        this.rowClass = () => null;
+        this.cellKeydownSubscription = this.navigationService.cellKeydown.subscribe((args) => this.cellKeydownHandler(args));
+        this.trackByWrapper = this.trackByWrapper.bind(this);
+        this.trackByColumns = this.trackByColumns.bind(this);
+        this.selection.registerTable(this);
+    }
+    get newDataItem() {
+        return this.editService.newDataItem;
+    }
+    // Number of unlocked columns in the next table, if any
+    get unlockedColumnsCount() {
+        return this.totalColumnsCount - this.lockedColumnsCount - (this.allColumns || this.columns).length;
+    }
+    isOdd(item) {
+        return item.index % 2 !== 0;
+    }
+    trackByWrapper(index, item) {
+        if (item.type === 'data') {
+            item.isEditing = this.editService.isEdited(item.data);
+        }
+        return this.trackBy(index, item);
+    }
+    trackByColumns(index, item) {
+        return this.virtualColumns ? index : item;
+    }
+    ngOnChanges(changes) {
+        if (isChanged("columns", changes, false)) {
+            this.changeNotification.notify();
+        }
+    }
+    addRowLogicalIndex() {
+        return this.columnInfoService.totalLevels + 1;
+    }
+    logicalColIndex(column) {
+        if (!isPresent(column.leafIndex)) {
+            return -1;
+        }
+        return column.leafIndex;
+    }
+    ariaExpanded(item, column) {
+        if (!column.expandable || !item.hasChildren) {
+            return;
+        }
+        return Boolean(item.expanded);
+    }
+    ariaSelected(item, column, columnIndex) {
+        if (!this.selection.enabled) {
+            return;
+        }
+        return item.selected || this.isCellSelected(item.data, column, columnIndex);
+    }
+    ngOnInit() {
+        this.ngZone.runOutsideAngular(() => {
+            const clickHandler = this.clickHandler.bind(this);
+            const mousedownSubscription = this.renderer.listen(this.element.nativeElement, 'mousedown', clickHandler);
+            const clickSubscription = this.renderer.listen(this.element.nativeElement, 'click', clickHandler);
+            const contextmenuSubscription = this.renderer.listen(this.element.nativeElement, 'contextmenu', clickHandler);
+            this.clickSubscription = () => {
+                mousedownSubscription();
+                clickSubscription();
+                contextmenuSubscription();
+            };
+        });
+        let originalNoRecordText = this.localization.get('noRecords');
+        this.localization.changes.subscribe(() => {
+            if (this.noRecordsText === originalNoRecordText) {
+                this.noRecordsText = this.localization.get('noRecords');
+                originalNoRecordText = this.noRecordsText;
+            }
+        });
+    }
+    ngDoCheck() {
+        this.headerOffset = this.columnInfoService.totalLevels + (hasFilterRow(this.filterable) ? 1 : 0);
+    }
+    ngOnDestroy() {
+        if (this.clickSubscription) {
+            this.clickSubscription();
+        }
+        this.cellKeydownSubscription.unsubscribe();
+        this.selection.unregisterTable(this);
+        clearTimeout(this.clickTimeout);
+    }
+    isEditingCell(item, column) {
+        return Boolean(item.editContext && this.editService.isEditingColumn(column));
+    }
+    isEditingRow(item) {
+        return Boolean(item.editContext) || item.isNew;
+    }
+    get columnsContainer() {
+        return this.columnInfoService.columnsContainer;
+    }
+    get hasFooter() {
+        return this.columnsContainer.hasFooter;
+    }
+    get columnsSpan() {
+        return columnsSpan(this.columns);
+    }
+    get allColumnsSpan() {
+        return columnsSpan(this.allColumns || this.columns);
+    }
+    get colSpan() {
+        return this.columnsSpan;
+    }
+    get footerColumns() {
+        return this.isLocked ? this.columnsContainer.lockedColumnsToRender : this.columnsContainer.nonLockedColumnsToRender;
+    }
+    logicalRowIndex(rowIndex) {
+        return 1 + rowIndex + this.headerOffset;
+    }
+    isCellSelected(dataItem, column, columnIndex) {
+        return this.selection.isCellSelected(dataItem, column, columnIndex);
+    }
+    targetArgs(target, skipFocusable) {
+        const { cell, row } = this.targetElements(target);
+        if (cell && (!skipFocusable || target === cell || !isFocusableWithTabKey(target, false))) {
+            const index = columnCellIndex(cell, row.cells);
+            const column = this.columns.toArray()[index];
+            const columnIndex = this.lockedColumnsCount + index;
+            return {
+                item: this.rowItem(row),
+                column: column,
+                columnIndex: columnIndex
+            };
+        }
+    }
+    clickHandler(eventArg) {
+        const target = eventArg.target;
+        const { cell, row } = this.targetElements(target);
+        if (cell && !hasClasses(cell, NON_DATA_CELL_CLASSES) &&
+            !hasClasses(row, NON_DATA_ROW_CLASSES)) {
+            if (this.expandClick(eventArg, row) || this.checkboxClick(cell, row, eventArg)) {
+                return;
+            }
+            this.editService.preventCellClose();
+            const focusable = target !== cell && isFocusableWithTabKey(target, false);
+            if (!focusable && !matchesNodeName('label')(target) && !hasClasses(target, IGNORE_TARGET_CLASSSES) &&
+                !closestInScope(target, matchesClasses(IGNORE_CONTAINER_CLASSES), cell)) {
+                const args = this.cellClickArgs(cell, row, eventArg);
+                if (!args) {
+                    return;
+                }
+                if (eventArg.type === 'mousedown') {
+                    this.domEvents.cellMousedown.emit(args);
+                }
+                else {
+                    if (args.isEditedColumn || !this.editService.closeCell(eventArg)) {
+                        if (eventArg.type === 'click') {
+                            this.clickTimeout = setTimeout(() => {
+                                this.emitCellClick(args);
+                            }, 0);
+                        }
+                        else {
+                            this.emitCellClick(args);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    emitCellClick(args) {
+        this.domEvents.cellClick.emit(args);
+    }
+    cellKeydownHandler(args) {
+        if (args.keyCode === Keys.Enter) {
+            this.clickHandler(args);
+        }
+    }
+    cellClickArgs(cell, row, eventArg) {
+        const index = columnCellIndex(cell, row.cells);
+        const column = this.columns.toArray()[index];
+        const columnIndex = this.lockedColumnsCount + index;
+        const viewItem = this.rowItem(row);
+        if (viewItem.type !== 'data') {
+            return;
+        }
+        const type = eventArg.type === 'keydown' ? 'click' : eventArg.type;
+        return {
+            column: column,
+            columnIndex: columnIndex,
+            viewItem: viewItem,
+            dataItem: viewItem.data,
+            rowIndex: viewItem.index,
+            index: viewItem.index,
+            isEditedColumn: (viewItem.editContext && this.editService.isEditingColumn(column)),
+            isEdited: viewItem.isNew || (viewItem.editContext && this.editService.isEditedColumn(column)),
+            originalEvent: eventArg,
+            type: type
+        };
+    }
+    targetElements(target) {
+        const element = this.element.nativeElement;
+        let cell, row, body, treelistElement;
+        let currentTarget = target;
+        do {
+            cell = closest(currentTarget, matchesNodeName('td'));
+            row = closest(cell, matchesNodeName('tr'));
+            body = closest(row, matchesNodeName('tbody'));
+            currentTarget = body;
+            treelistElement = closestInScope(currentTarget, matchesClasses('k-treelist k-grid'), element);
+        } while (body && body !== element && !treelistElement);
+        if (cell && body === element && !treelistElement) {
+            return {
+                cell,
+                row
+            };
+        }
+        return {};
+    }
+    expandClick(eventArg, row) {
+        if (eventArg.type === 'click' && hasClasses(eventArg.target, 'k-i-expand k-i-collapse')) {
+            eventArg.preventDefault();
+            const viewItem = this.rowItem(row);
+            if (viewItem.type === 'data') {
+                this.ngZone.run(() => {
+                    this.expandState.toggleState(viewItem.data);
+                });
+                return true;
+            }
+        }
+    }
+    checkboxClick(cell, row, eventArg) {
+        if (eventArg.type === 'click' && hasClasses(cell, 'k-checkbox-cell') &&
+            this.selection.enabled && this.selection.rowSelection) {
+            const args = this.cellClickArgs(cell, row, eventArg);
+            this.selection.checkboxClick(args);
+            if (eventArg.target.checked !== this.selection.isRowSelected(args.dataItem)) {
+                eventArg.preventDefault();
+            }
+            return true;
+        }
+    }
+    rowItem(row) {
+        let viewIndex = row.getAttribute('data-treelist-view-index');
+        viewIndex = viewIndex ? parseInt(viewIndex, 10) : -1;
+        const viewItem = this.view.at(viewIndex);
+        return viewItem;
+    }
+};
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Array)
+], TableBodyComponent.prototype, "columns", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Array)
+], TableBodyComponent.prototype, "allColumns", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", NoRecordsTemplateDirective)
+], TableBodyComponent.prototype, "noRecordsTemplate", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object)
+], TableBodyComponent.prototype, "view", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number)
+], TableBodyComponent.prototype, "skip", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object)
+], TableBodyComponent.prototype, "filterable", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", String)
+], TableBodyComponent.prototype, "noRecordsText", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean)
+], TableBodyComponent.prototype, "isLocked", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number)
+], TableBodyComponent.prototype, "lockedColumnsCount", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Number)
+], TableBodyComponent.prototype, "totalColumnsCount", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean)
+], TableBodyComponent.prototype, "virtualColumns", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean)
+], TableBodyComponent.prototype, "expandIcons", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Function)
+], TableBodyComponent.prototype, "trackBy", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Function)
+], TableBodyComponent.prototype, "rowClass", void 0);
+TableBodyComponent = tslib_1.__decorate([
+    Component({
+        selector: '[kendoTreeListTableBody]',
+        template: `
+    <tr *ngIf="!view || view.data?.length === 0 || view.data == null" class="k-grid-norecords">
+        <td [attr.colspan]="colSpan">
+            <ng-container *ngIf="noRecordsTemplate?.templateRef" [ngTemplateOutlet]="noRecordsTemplate.templateRef">
+            </ng-container>
+            <ng-container *ngIf="!noRecordsTemplate?.templateRef">
+                {{noRecordsText}}
+            </ng-container>
+        </td>
+    </tr>
+    <ng-container *ngFor="let item of view?.data;let rowIndex = index;trackBy: trackByWrapper;">
+        <tr *ngIf="item.type === 'data'"
+            kendoTreeListLogicalRow
+                [dataRowIndex]="item.index"
+                [dataItem]="item.data"
+                [logicalRowIndex]="logicalRowIndex(item.rowIndex)"
+                [logicalSlaveRow]="lockedColumnsCount > 0"
+                [logicalCellsCount]="columns.length"
+                [logicalSlaveCellsCount]="unlockedColumnsCount"
+                [isNew]="item.isNew"
+            [ngClass]="rowClass({ dataItem: item.data, index: item.index })"
+            [class.k-alt]="isOdd(item)"
+            [class.k-grid-edit-row]="isEditingRow(item)"
+            [class.k-grid-add-row]="item.isNew"
+            [class.k-state-selected]="item.selected"
+            [attr.data-treelist-view-index]="rowIndex">
+
+            <td kendoTreeListCell
+                    [columnIndex]="lockedColumnsCount + columnIndex"
+                    [column]="column"
+                    [viewItem]="item"
+                    [dataItem]="item.data"
+                    [level]="item.level"
+                    [hasChildren]="item.hasChildren"
+                    [isExpanded]="item.expanded"
+                    [loading]="item.loading"
+                    [isNew]="item.isNew"
+                    [selected]="item.selected"
+                    [expandIcons]="expandIcons"
+                kendoTreeListLogicalCell
+                    [logicalRowIndex]="logicalRowIndex(item.rowIndex)"
+                    [logicalColIndex]="logicalColIndex(column)"
+                    [dataRowIndex]="item.index"
+                    [column]="column"
+                    [colIndex]="columnIndex"
+                    [colSpan]="column.colspan"
+                    [expandable]="column.expandable"
+                    role="gridcell"
+                    [attr.aria-expanded]="ariaExpanded(item, column)"
+                    [attr.aria-selected]="ariaSelected(item, column, lockedColumnsCount + columnIndex)"
+                [ngClass]="column.cssClass"
+                [class.k-grid-edit-cell]="isEditingCell(item, column)"
+                [class.k-state-selected]="isCellSelected(item.data, column, lockedColumnsCount + columnIndex)"
+                [ngStyle]="column.style"
+                [attr.colspan]="column.colspan"
+                *ngFor="let column of columns; let columnIndex = index; trackBy: trackByColumns;">
+            </td>
+        </tr>
+        <tr *ngIf="item.type === 'footer' && hasFooter"
+            class="k-footer"
+            [attr.data-treelist-view-index]="rowIndex"
+            kendoTreeListLogicalRow
+                [logicalRowIndex]="logicalRowIndex(item.rowIndex)"
+                [logicalSlaveRow]="lockedColumnsCount > 0"
+                [logicalCellsCount]="columns.length"
+                [logicalSlaveCellsCount]="unlockedColumnsCount">
+
+            <td kendoTreeListLogicalCell
+                    [logicalRowIndex]="logicalRowIndex(item.rowIndex)"
+                    [logicalColIndex]="logicalColIndex(column)"
+                    [column]="column"
+                    [colIndex]="columnIndex"
+                [ngClass]="column.footerClass"
+                [ngStyle]="column.footerStyle"
+                *ngFor="let column of footerColumns; let columnIndex = index; trackBy: trackByColumns;">
+                <ng-container *ngIf="column.expandable">
+                    <span class="k-icon k-i-none" *ngFor="let item of item.level | levelItems"></span>
+                </ng-container>
+                <ng-container [ngTemplateOutlet]="column.footerTemplateRef"
+                    [ngTemplateOutletContext]="{
+                        items: item.items,
+                        field: column.field,
+                        column: column,
+                        columnIndex: columnIndex,
+                        aggregates: item.aggregates,
+                        $implicit: item.aggregates
+                    }">
+                </ng-container>
+           </td>
+        </tr>
+    </ng-container>
+    `
+    }),
+    tslib_1.__metadata("design:paramtypes", [ChangeNotificationService,
+        EditService,
+        LocalizationService,
+        NgZone,
+        Renderer2,
+        ElementRef,
+        DomEventsService,
+        ColumnInfoService,
+        NavigationService,
+        ExpandStateService,
+        SelectionService])
+], TableBodyComponent);
+export { TableBodyComponent };
+export { ɵ0 };

package/dist/es2015/rendering/toolbar/toolbar-template.directive.d.ts

@@ -0,0 +1,36 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { TemplateRef } from '@angular/core';
+import { OptionChangesService } from '../../common/option-changes.service';
+/**
+ * Represents the toolbar template of the TreeList.
+ *
+ * The template context has the following field:
+ * - `position`—The position at which the toolbar template is rendered. The possible values are "top" and "bottom".
+ *
+ * @example
+ * {% meta height:470 %}
+ * {% embed_file configuration/toolbar-template/basic/app.component.ts preview %}
+ * {% embed_file configuration/toolbar-template/basic/app.module.ts %}
+ * {% embed_file shared/main.ts %}
+ * {% embed_file shared/employees.ts %}
+ * {% endmeta %}
+ */
+export declare class ToolbarTemplateDirective {
+    templateRef: TemplateRef<any>;
+    private optionChanges;
+    _position: 'top' | 'bottom' | 'both';
+    /**
+     * The position of the toolbar ([see example]({% slug toolbartemplate_treelist %})).
+     *
+     * The possible values are:
+     * - `top`&mdash;Positions the toolbar above the group panel or header.
+     * - `bottom`&mdash;Positions the toolbar below the pager.
+     * - `both`&mdash;Displays two toolbar instances. Positions the first one above
+     * the group panel or header and the second one below the pager.
+     */
+    position: 'top' | 'bottom' | 'both';
+    constructor(templateRef: TemplateRef<any>, optionChanges: OptionChangesService);
+}