@progress/kendo-angular-gantt 1.0.1 → 2.0.0-dev.202204150748

package/dist/es/models/sort-settings.js

@@ -1,23 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-var DEFAULTS = {
-    allowUnsort: true,
-    mode: 'single',
-    showIndexes: true,
-    initialDirection: 'asc'
-};
-/**
- * @hidden
- */
-export var normalize = function () {
-    var settings = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        settings[_i] = arguments[_i];
-    }
-    return Object.assign.apply(Object, [{}, DEFAULTS].concat(settings));
-};

package/dist/es/models/splitter-pane-options.interface.js

@@ -1,20 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export var DEFAULT_TREELIST_PANE_SETTINGS = Object.freeze({
-    collapsible: true,
-    collapsed: false
-});
-/**
- * @hidden
- */
-export var DEFAULT_TIMELINE_PANE_SETTINGS = Object.freeze({
-    collapsible: true,
-    collapsed: false,
-    size: '50%',
-    resizable: true
-});

package/dist/es/navigation/navigation.service.js

@@ -1,390 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable, NgZone, Renderer2 } from '@angular/core';
-import { Keys, hasObservers } from '@progress/kendo-angular-common';
-import { Subject } from 'rxjs';
-import { ScrollSyncService } from '../scrolling/scroll-sync.service';
-import { fitToRange, getClosestTaskIndex, isClearButton, isPresent, isTask, isToolbar } from '../utils';
-import { getIndexFromViewDigitKeyCode, isArrowUpDownKey, isExpandCollapseKey, isNavigationKey, isViewDigitKey } from './utils';
-/**
- * @hidden
- */
-var NavigationService = /** @class */ (function () {
-    function NavigationService(zone, renderer, scrollSyncService) {
-        this.zone = zone;
-        this.renderer = renderer;
-        this.scrollSyncService = scrollSyncService;
-        /**
-         * Notifies when the tasks' focused and interactive (tabindex) state has changed.
-         *
-         * All tasks are rendered with tabindex="-1".
-         * When one is clicked, or when some navigation key keyboard key is pressed, it should be focused, assigned the focus class, and its tabindex updated to 0.
-         * All other tasks should get -1 tabindex and have the focus class removed from them.
-         */
-        this.taskStatusChanges = new Subject();
-        /**
-         * Keeps track of whether the Timeline part is focused.
-         * Used when the index of the task elements change (tasks are changed, pushed to, spliced from, etc.)
-         * and their status should be updated accordingly.
-         */
-        this.isTimelineFocused = false;
-        /**
-         * Keeps track of which part has last been focused.
-         * Used when calling `gantt.focus()` to determine which part of the component should receive focus.
-         */
-        this.treeListLastActive = false;
-        /**
-         * Keeps track of which part has last been focused.
-         * Used when calling `gantt.focus()` to determine which part of the component should receive focus.
-         */
-        this.timelineLastActive = false;
-        this._enabled = false;
-        this._activeTimelineIndex = 0;
-        this._activeTreeListCell = { rowIndex: 0, colIndex: 0 };
-    }
-    Object.defineProperty(NavigationService.prototype, "enabled", {
-        /**
-         * Specifies whether navigation is enabled.
-         */
-        get: function () {
-            return this._enabled;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(NavigationService.prototype, "activeTask", {
-        /**
-         * Used to retrieve read-only data about the currently active task.
-         */
-        get: function () {
-            return {
-                activeIndex: this.activeTimelineIndex,
-                isFocused: this.isTimelineFocused
-            };
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(NavigationService.prototype, "activeTreeListCell", {
-        get: function () {
-            var firstAvailableIndex = 0;
-            var lastAvailableRowIndex = this.treeListHeaderRowsCount + this.gantt.treeList.view.data.length - 1;
-            var rowIndex = fitToRange(this._activeTreeListCell.rowIndex, firstAvailableIndex, lastAvailableRowIndex);
-            var lastAvailableColIndex = this.gantt.columns.length;
-            var colIndex = fitToRange(this._activeTreeListCell.colIndex, firstAvailableIndex, lastAvailableColIndex);
-            return { rowIndex: rowIndex, colIndex: colIndex };
-        },
-        /**
-         * Persists the expected TreeList focused cell coords.
-         * When the tasks in the Timeline are navigated through, the expected TreeList focus target should also change,
-         * in order to allow back-tabbing from the Timeline to the same row in the TreeList.
-         */
-        set: function (cell) {
-            this._activeTreeListCell = cell;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(NavigationService.prototype, "activeTimelineIndex", {
-        get: function () {
-            var firstAvailableIndex = 0;
-            var lastAvailableIndex = this.gantt.treeList.view.data.length - 1;
-            return fitToRange(this._activeTimelineIndex, firstAvailableIndex, lastAvailableIndex);
-        },
-        /**
-         * Persists the expected Timeline focused task index.
-         * When the cells in the TreeList are navigated through, the expected Timeline focus target should also change,
-         * in order to allow tabbing from the TreeList to the same row in the Timeline.
-         */
-        set: function (index) {
-            this._activeTimelineIndex = index;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(NavigationService.prototype, "treeListHeaderRowsCount", {
-        /**
-         * The TreeList row index takes into account the header and filter rows.
-         * Used when translating Timeline task indices to TreeList row indices.
-         */
-        get: function () {
-            // captures nested group header rows + filter row if we start supporting it at some point
-            return this.treeListElement.querySelectorAll('.k-grid-header tr').length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    NavigationService.prototype.initialize = function (_a) {
-        var _this = this;
-        var gantt = _a.gantt, host = _a.host, treeListElement = _a.treeListElement, timelineElement = _a.timelineElement;
-        // no private property setters in TypeScript, so use a getter and a poorly named private prop for this value
-        this._enabled = true;
-        this.gantt = gantt;
-        this.host = host;
-        this.treeListElement = treeListElement;
-        this.timelineElement = timelineElement;
-        // TODO: fix in the splitter package and remove
-        // move the splitbar HTML element between the two panes to keep the visial tabbing order in tact
-        var splitbar = this.host.querySelector('.k-splitbar');
-        if (isPresent(splitbar) && isPresent(splitbar.previousElementSibling) && isPresent(splitbar.after)) {
-            splitbar.after(splitbar.previousElementSibling);
-        }
-        this.zone.runOutsideAngular(function () {
-            _this.eventListenerDisposers = [
-                _this.renderer.listen(_this.host, 'keydown', _this.handleKeydown.bind(_this)),
-                _this.renderer.listen(_this.treeListElement, 'mousedown', _this.focusTreeList.bind(_this)),
-                _this.renderer.listen(_this.treeListElement, 'focusin', _this.handleTreeListFocusIn.bind(_this)),
-                _this.renderer.listen(_this.timelineElement, 'mousedown', _this.handleTimelineMousedown.bind(_this)),
-                _this.renderer.listen(_this.timelineElement, 'focusin', _this.handleTimelineFocusIn.bind(_this)),
-                _this.renderer.listen(_this.timelineElement, 'focusout', _this.handleTimelineFocusOut.bind(_this))
-            ];
-        });
-    };
-    NavigationService.prototype.ngOnDestroy = function () {
-        if (isPresent(this.eventListenerDisposers)) {
-            this.eventListenerDisposers.forEach(function (removeListener) { return removeListener(); });
-            this.eventListenerDisposers = null;
-        }
-        this.gantt = null;
-        this.host = null;
-        this.treeListElement = null;
-        this.timelineElement = null;
-    };
-    /**
-     * Focuses either the last active TreeList cell, or the last active Timeline task,
-     * dependening on which of the two last held focus.
-     *
-     * Focuses the first TreeList cell by default.
-     */
-    NavigationService.prototype.focusLastActiveItem = function () {
-        if (this.gantt.data.length === 0 || (!this.treeListLastActive && !this.timelineLastActive)) {
-            this.focusCell(0, 0);
-        }
-        else if (this.treeListLastActive) {
-            var _a = this.activeTreeListCell, rowIndex = _a.rowIndex, colIndex = _a.colIndex;
-            this.gantt.treeList.focusCell(rowIndex, colIndex);
-        }
-        else if (this.timelineLastActive) {
-            this.focusTask(this.activeTimelineIndex);
-        }
-    };
-    /**
-     * Focuses the targeted TreeList cell regardless of the last peresisted target.
-     */
-    NavigationService.prototype.focusCell = function (rowIndex, colIndex) {
-        this.activeTreeListCell = { rowIndex: rowIndex, colIndex: colIndex };
-        this.activeTimelineIndex = rowIndex - this.treeListHeaderRowsCount;
-        this.gantt.treeList.focusCell(this.activeTreeListCell.rowIndex, this.activeTreeListCell.colIndex);
-    };
-    /**
-     * Focuses the targeted Timeline task regardless of the last peresisted target.
-     */
-    NavigationService.prototype.focusTask = function (index) {
-        this.activeTimelineIndex = index;
-        this.isTimelineFocused = true;
-        this.activeTreeListCell = {
-            rowIndex: index + this.treeListHeaderRowsCount,
-            colIndex: this.activeTreeListCell.colIndex
-        };
-        this.notifyTaskStatusChange();
-    };
-    /**
-     * Updates the focus target flags and notifies the active task to update its focused state.
-     */
-    NavigationService.prototype.handleTimelineFocusIn = function (_a) {
-        var target = _a.target;
-        this.treeListLastActive = false;
-        this.timelineLastActive = true;
-        this.isTimelineFocused = true;
-        if (isTask(target, this.timelineElement)) {
-            this.notifyTaskStatusChange();
-        }
-    };
-    /**
-     * Updates the timeline focus state flag and notifies the active task to update its focused state.
-     */
-    NavigationService.prototype.handleTimelineFocusOut = function (_a) {
-        var relatedTarget = _a.relatedTarget;
-        this.isTimelineFocused = this.timelineElement.contains(relatedTarget);
-        // update the task element only if the new focus target is not in the Timeline - focus change between tasks is handled in the focusin handler
-        if (!isTask(relatedTarget, this.timelineElement)) {
-            this.notifyTaskStatusChange();
-        }
-    };
-    /**
-     * Updates the focus target flags and corrects the TreeList focus target if needed.
-     * As the TreeList will keep its last focused cell with tabindex="0",
-     * this methods forcefully focuses the correct cell,
-     * when navigating in the Timeline has updated the expected TreeList focus target.
-     */
-    NavigationService.prototype.handleTreeListFocusIn = function (event) {
-        this.treeListLastActive = true;
-        this.timelineLastActive = false;
-        // if the previous focus target was in the TreeList, rely on its component navigation and just record the focused item index
-        if (this.treeListElement.contains(event.relatedTarget)) {
-            var _a = this.gantt.treeList.activeCell, colIndex = _a.colIndex, rowIndex = _a.rowIndex;
-            this.activeTreeListCell = { colIndex: colIndex, rowIndex: rowIndex };
-        }
-        else {
-            // if the previous focus target was outside the TreeList, ensure the expected focus coords are used
-            var _b = this.activeTreeListCell, rowIndex = _b.rowIndex, colIndex = _b.colIndex;
-            this.gantt.treeList.focusCell(rowIndex, colIndex); // activates the target cell even if it has tabindex="-1"
-        }
-        this.activeTimelineIndex = this.gantt.treeList.activeCell.dataRowIndex;
-        this.notifyTaskStatusChange();
-        if (this.gantt.treeList.activeCell.dataRowIndex >= 0) {
-            this.scrollHorizontallyToTask(this.activeTimelineIndex);
-            this.scrollSyncService.syncScrollTop('treelist', 'timeline');
-        }
-    };
-    NavigationService.prototype.handleKeydown = function (event) {
-        var _this = this;
-        var _a = event, keyCode = _a.keyCode, target = _a.target, altKey = _a.altKey;
-        var isTimelineActive = this.timelineElement.contains(target);
-        if (isTimelineActive) {
-            if (isArrowUpDownKey(keyCode)) {
-                var direction = keyCode === Keys.ArrowUp ? -1 : 1;
-                this.activeTimelineIndex = this.activeTimelineIndex + direction;
-                this.activeTreeListCell = {
-                    rowIndex: this.activeTimelineIndex + this.treeListHeaderRowsCount,
-                    colIndex: this.activeTreeListCell.colIndex
-                };
-            }
-            else if (keyCode === Keys.Home) {
-                this.activeTimelineIndex = 0;
-                this.activeTreeListCell = {
-                    rowIndex: this.activeTimelineIndex + this.treeListHeaderRowsCount,
-                    colIndex: this.activeTreeListCell.colIndex
-                };
-            }
-            else if (keyCode === Keys.End) {
-                var lastAvailableIndex = this.gantt.treeList.view.data.length - 1;
-                this.activeTimelineIndex = lastAvailableIndex;
-                this.activeTreeListCell = {
-                    rowIndex: this.activeTimelineIndex + this.treeListHeaderRowsCount,
-                    colIndex: this.activeTreeListCell.colIndex
-                };
-            }
-            if (isNavigationKey(keyCode)) {
-                this.scrollHorizontallyToTask(this.activeTimelineIndex);
-                this.scrollSyncService.syncScrollTop('timeline', 'treelist');
-                this.notifyTaskStatusChange();
-                event.preventDefault();
-            }
-            if (keyCode === Keys.Space && hasObservers(this.gantt.selectionChange)) {
-                var task_1 = this.gantt.renderedTreeListItems[this.activeTimelineIndex];
-                var selectionAction_1 = this.gantt.getSelectionAction(event, task_1);
-                if (isPresent(task_1) && !this.gantt.isSameSelection(selectionAction_1, task_1)) {
-                    this.zone.run(function () {
-                        return _this.gantt.notifySelectionChange(task_1, selectionAction_1);
-                    });
-                }
-                event.preventDefault();
-            }
-            if (keyCode === Keys.Enter && hasObservers(this.gantt.taskClick)) {
-                var task_2 = this.gantt.renderedTreeListItems[this.activeTimelineIndex];
-                if (isPresent(task_2)) {
-                    this.zone.run(function () {
-                        return _this.gantt.notifyTaskClick(event, task_2, _this.activeTimelineIndex);
-                    });
-                }
-                event.preventDefault();
-            }
-            if (isExpandCollapseKey(keyCode, altKey)) {
-                var task_3 = this.gantt.renderedTreeListItems[this.activeTimelineIndex];
-                if (isPresent(task_3) && this.gantt.hasChildren(task_3)) {
-                    var shouldExpand_1 = keyCode === Keys.ArrowRight;
-                    var isExpanded = this.gantt.isExpanded(task_3);
-                    var sameState = shouldExpand_1 === isExpanded;
-                    if (!sameState) {
-                        this.zone.run(function () {
-                            var expandEvent = { dataItem: task_3 };
-                            // order is not arbitrary
-                            // the TreeList emits the individual events first, then the combined `expandStateChange` event
-                            var individualEmitter = shouldExpand_1 ? _this.gantt.rowExpand : _this.gantt.rowCollapse;
-                            individualEmitter.emit(expandEvent);
-                            _this.gantt.expandStateChange.emit(tslib_1.__assign({}, expandEvent, { expand: shouldExpand_1 }));
-                            _this.gantt.updateView();
-                            _this.scrollHorizontallyToTask(_this.activeTimelineIndex);
-                        });
-                    }
-                }
-                event.preventDefault();
-            }
-        }
-        var isTreeListActive = this.treeListElement.contains(target);
-        if (keyCode === Keys.Delete && (isTimelineActive || isTreeListActive) && hasObservers(this.gantt.taskDelete)) {
-            var taskIndex = isTreeListActive ?
-                this.gantt.treeList.activeCell.dataRowIndex :
-                this.activeTimelineIndex;
-            var task_4 = this.gantt.renderedTreeListItems[taskIndex];
-            if (isPresent(task_4)) {
-                this.zone.run(function () {
-                    return _this.gantt.notifyTaskDelete(task_4);
-                });
-            }
-        }
-        if (isViewDigitKey(keyCode) && !isToolbar(target, this.host) && !this.gantt.isInEditMode) {
-            var targetViewIndex = getIndexFromViewDigitKeyCode(keyCode);
-            var availableViews = this.gantt.views.toArray();
-            var targetView_1 = availableViews[targetViewIndex];
-            if (isPresent(targetView_1) && targetView_1.type !== this.gantt.activeView) {
-                this.zone.run(function () {
-                    return _this.gantt.changeActiveView(targetView_1.type);
-                });
-            }
-        }
-    };
-    /**
-     * Filters for task mousedown in the Timeline.
-     */
-    NavigationService.prototype.handleTimelineMousedown = function (_a) {
-        var target = _a.target;
-        if (isTask(target, this.host) && !isClearButton(target, this.host)) {
-            var taskIndex = getClosestTaskIndex(target, this.host);
-            this.focusTask(taskIndex);
-        }
-    };
-    /**
-     * Scrolls horizontally to the beginning of the target task if the beginning of its content is not in the viewport.
-     */
-    NavigationService.prototype.scrollHorizontallyToTask = function (index) {
-        var task = this.timelineElement.querySelectorAll('.k-task-wrap').item(index);
-        if (!isPresent(task)) {
-            return;
-        }
-        // scroll horizontally to the item if less than 200px from the beginning of its content are visible
-        var targetVisibleWidth = 200;
-        var isScrollBeforeTask = (this.timelineElement.clientWidth + this.timelineElement.scrollLeft) < (task.offsetLeft + targetVisibleWidth);
-        var isScrollAfterTask = this.timelineElement.scrollLeft > task.offsetLeft;
-        if (isScrollBeforeTask || isScrollAfterTask) {
-            this.timelineElement.scrollLeft = task.offsetLeft;
-        }
-    };
-    /**
-     * Focus the TreeList on TreeList mousedown.
-     * A nasty hack to trick `handleTreeListFocusIn` into regarding the previous focus target as again the TreeList.
-     * Otherwise cell clicks are wrongly overwritten in `handleTreeListFocusIn` and the click focus target is not respected.
-     */
-    NavigationService.prototype.focusTreeList = function () {
-        this.gantt.treeList.focus();
-    };
-    /**
-     * Fires the `taskStatusChanges` event with active and focused status retrieved from
-     * `this.activeTimelineIndex` and `this.isTimelineFocused`.
-     */
-    NavigationService.prototype.notifyTaskStatusChange = function () {
-        this.taskStatusChanges.next(this.activeTask);
-    };
-    NavigationService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [NgZone,
-            Renderer2,
-            ScrollSyncService])
-    ], NavigationService);
-    return NavigationService;
-}());
-export { NavigationService };

package/dist/es/navigation/utils.js

@@ -1,77 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Keys } from '@progress/kendo-angular-common';
-// TODO: add those keys to `import { Keys } from '@progress/kendo-angular-common';`
-var NumpadKeys;
-(function (NumpadKeys) {
-    NumpadKeys[NumpadKeys["Digit1"] = 97] = "Digit1";
-    NumpadKeys[NumpadKeys["Digit2"] = 98] = "Digit2";
-    NumpadKeys[NumpadKeys["Digit3"] = 99] = "Digit3";
-    NumpadKeys[NumpadKeys["Digit4"] = 100] = "Digit4";
-})(NumpadKeys || (NumpadKeys = {}));
-/**
- * @hidden
- */
-export var isArrowUpDownKey = function (keyCode) { return [
-    Keys.ArrowUp,
-    Keys.ArrowDown
-].some(function (arrowKeyCode) {
-    return keyCode === arrowKeyCode;
-}); };
-/**
- * @hidden
- */
-export var isNavigationKey = function (keyCode) { return [
-    Keys.ArrowUp,
-    Keys.ArrowDown,
-    Keys.Home,
-    Keys.End
-].some(function (navigationKeyCode) {
-    return keyCode === navigationKeyCode;
-}); };
-/**
- * @hidden
- */
-export var isExpandCollapseKey = function (keyCode, altKey) {
-    return altKey && [
-        Keys.ArrowLeft,
-        Keys.ArrowRight
-    ].some(function (navigationKeyCode) {
-        return keyCode === navigationKeyCode;
-    });
-};
-/**
- * @hidden
- */
-export var isViewDigitKey = function (keyCode) { return [
-    Keys.Digit1,
-    NumpadKeys.Digit1,
-    Keys.Digit2,
-    NumpadKeys.Digit2,
-    Keys.Digit3,
-    NumpadKeys.Digit3,
-    Keys.Digit4,
-    NumpadKeys.Digit4
-].some(function (digitKeyCode) {
-    return keyCode === digitKeyCode;
-}); };
-/**
- * @hidden
- *
- * Returns the corresponding view index for the pressed digit key (Digit 1 => 0, Digit 2 => 1, etc.).
- */
-export var getIndexFromViewDigitKeyCode = function (keyCode) {
-    switch (keyCode) {
-        case NumpadKeys.Digit1:
-        case Keys.Digit1: return 0;
-        case NumpadKeys.Digit2:
-        case Keys.Digit2: return 1;
-        case NumpadKeys.Digit3:
-        case Keys.Digit3: return 2;
-        case NumpadKeys.Digit4:
-        case Keys.Digit4: return 3;
-        default: return null;
-    }
-};

package/dist/es/package-metadata.js

@@ -1,15 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export var packageMetadata = {
-    name: '@progress/kendo-angular-gantt',
-    productName: 'Kendo UI for Angular',
-    productCodes: ['KENDOUIANGULAR', 'KENDOUICOMPLETE'],
-    publishDate: 1647344447,
-    version: '',
-    licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/?utm_medium=product&utm_source=kendoangular&utm_campaign=kendo-ui-angular-purchase-license-keys-warning'
-};

package/dist/es/rendering/gantt-header-table-body.component.js

@@ -1,29 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* 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 } from "@angular/core";
-/**
- * @hidden
- */
-var GanttHeaderTableBodyComponent = /** @class */ (function () {
-    function GanttHeaderTableBodyComponent() {
-    }
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Array)
-    ], GanttHeaderTableBodyComponent.prototype, "groupSlots", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Array)
-    ], GanttHeaderTableBodyComponent.prototype, "slots", void 0);
-    GanttHeaderTableBodyComponent = tslib_1.__decorate([
-        Component({
-            selector: '[kendoGanttHeaderTableBody]',
-            template: "\n        <tr>\n            <td *ngFor=\"let item of groupSlots\" [attr.colspan]=\"item.span\" class=\"k-header\">{{ item.text }}</td>\n        </tr>\n\n        <tr>\n            <td *ngFor=\"let item of slots\" [attr.colspan]=\"item.span\" class=\"k-header\" [attr.title]=\"item.text\">{{ item.text }}</td>\n        </tr>\n    "
-        })
-    ], GanttHeaderTableBodyComponent);
-    return GanttHeaderTableBodyComponent;
-}());
-export { GanttHeaderTableBodyComponent };

package/dist/es/rendering/gantt-milestone-task.component.js

@@ -1,53 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* 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, forwardRef, HostBinding, ChangeDetectorRef, Inject } from '@angular/core';
-import { MappingService } from '../common/mapping.service';
-import { NavigationService } from '../navigation/navigation.service';
-import { TOUCH_ENABLED } from '../common/touch-enabled';
-import { DependencyDomService } from '../dependencies/dependency-dom.service';
-import { OptionChangesService } from '../common/option-changes.service';
-import { TimelineViewService } from './../timeline/timeline-view.service';
-import { GanttTaskBase } from './gantt-task-base';
-/**
- * @hidden
- */
-var GanttMilestoneTaskComponent = /** @class */ (function (_super) {
-    tslib_1.__extends(GanttMilestoneTaskComponent, _super);
-    function GanttMilestoneTaskComponent(touchEnabled, mapper, timelineViewService, dependencyDomService, optionChangesService, cdr, navigationService) {
-        var _this = _super.call(this, mapper, timelineViewService, dependencyDomService, optionChangesService, cdr, navigationService) || this;
-        _this.touchEnabled = touchEnabled;
-        _this.milestoneWrapperClass = true;
-        return _this;
-    }
-    GanttMilestoneTaskComponent_1 = GanttMilestoneTaskComponent;
-    var GanttMilestoneTaskComponent_1;
-    tslib_1.__decorate([
-        HostBinding('class.k-milestone-wrap'),
-        tslib_1.__metadata("design:type", Boolean)
-    ], GanttMilestoneTaskComponent.prototype, "milestoneWrapperClass", void 0);
-    GanttMilestoneTaskComponent = GanttMilestoneTaskComponent_1 = tslib_1.__decorate([
-        Component({
-            selector: 'kendo-gantt-milestone-task',
-            providers: [
-                {
-                    provide: GanttTaskBase,
-                    useExisting: forwardRef(function () { return GanttMilestoneTaskComponent_1; })
-                }
-            ],
-            template: "\n        <div\n            #task\n            role=\"treeitem\"\n            class=\"k-task k-task-milestone\"\n            [ngClass]=\"taskClass(dataItem)\"\n            [attr.title]=\"mapper.extractFromTask(dataItem, 'title')\"\n            [class.k-state-selected]=\"isSelected(dataItem)\"\n            [attr.aria-selected]=\"ariaSelected\"\n            [attr.aria-level]=\"level + 1\"\n        >\n        </div>\n        <ng-container *ngIf=\"renderDependencyDragClues\">\n            <div\n                class=\"k-task-dot k-task-start k-touch-action-none\"\n                [class.k-display-block]=\"touchEnabled\"\n            >\n            </div>\n            <div\n                class=\"k-task-dot k-task-end k-touch-action-none\"\n                [class.k-display-block]=\"touchEnabled\"\n            >\n            </div>\n        </ng-container>\n    ",
-            styles: ["\n        .k-task.k-focus {\n            box-shadow: 0 0 4px 3px grey;\n            outline: none;\n        }\n        .k-task.k-focus.k-state-selected {\n            box-shadow: 0 0 4px 3px #ffaea8;\n        }\n    "]
-        }),
-        tslib_1.__param(0, Inject(TOUCH_ENABLED)),
-        tslib_1.__metadata("design:paramtypes", [Boolean, MappingService,
-            TimelineViewService,
-            DependencyDomService,
-            OptionChangesService,
-            ChangeDetectorRef,
-            NavigationService])
-    ], GanttMilestoneTaskComponent);
-    return GanttMilestoneTaskComponent;
-}(GanttTaskBase));
-export { GanttMilestoneTaskComponent };