@progress/kendo-angular-gantt 0.2.1-dev.202112101349 → 0.3.0-dev.202201190830

package/dist/es/gantt.module.js

@@ -5,11 +5,19 @@
 import * as tslib_1 from "tslib";
 import { NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { SplitterModule } from '@progress/kendo-angular-layout';
+import { ReactiveFormsModule } from '@angular/forms';
+import { SplitterModule, TabStripModule } from '@progress/kendo-angular-layout';
 import { TreeListModule } from '@progress/kendo-angular-treelist';
 import { ButtonsModule } from '@progress/kendo-angular-buttons';
-import { EventsModule } from '@progress/kendo-angular-common';
+import { DraggableModule, EventsModule } from '@progress/kendo-angular-common';
 import { DialogModule } from '@progress/kendo-angular-dialog';
+import { LabelModule } from '@progress/kendo-angular-label';
+import { InputsModule } from '@progress/kendo-angular-inputs';
+import { DateInputsModule } from '@progress/kendo-angular-dateinputs';
+import { L10N_PREFIX } from '@progress/kendo-angular-l10n';
+import { PopupModule } from '@progress/kendo-angular-popup';
+import { touchEnabled } from '@progress/kendo-common';
+import { TOUCH_ENABLED } from './common/touch-enabled';
 import { GanttComponent } from './gantt.component';
 import { GanttTimelineComponent } from './timeline/gantt-timeline.component';
 import { GanttTasksTableBodyComponent } from './rendering/gantt-tasks-table-body.component';
@@ -28,18 +36,21 @@ import { ToolbarComponent } from './toolbar/toolbar.component';
 import { ToolbarTemplateDirective } from './toolbar/toolbar-template.directive';
 import { ViewSelectorComponent } from './toolbar/view-selector.component';
 import { GanttDependencyDirective } from './dependencies/gantt-dependency.directive';
+import { DependencyDragCreateDirective } from './dragging/dependency-drag-create.directive';
+import { DragValidationTooltipComponent } from './dragging/drag-validation-tooltip.component';
+import { TimelineScrollableDirective } from './scrolling/timeline-scroll.directive';
 import { GanttColumnComponent, GanttColumnGroupComponent, GanttSpanColumnComponent, FilterMenuTemplateDirective, FilterCellTemplateDirective, CellTemplateDirective, ColumnMenuTemplateDirective, FooterTemplateDirective, HeaderTemplateDirective, EditTemplateDirective } from './columns/columns';
 import { TimelineDayViewComponent } from './timeline/timeline-day-view.component';
 import { TimelineWeekViewComponent } from './timeline/timeline-week-view.component';
 import { TimelineMonthViewComponent } from './timeline/timeline-month-view.component';
 import { EditDialogComponent } from './editing/edit-dialog.component';
-import { ReactiveFormsModule } from '@angular/forms';
-import { LabelModule } from '@progress/kendo-angular-label';
-import { InputsModule } from '@progress/kendo-angular-inputs';
-import { DateInputsModule } from '@progress/kendo-angular-dateinputs';
 import { CustomMessagesComponent } from './localization/custom-messages.component';
-import { L10N_PREFIX } from '@progress/kendo-angular-l10n';
 import { LocalizedMessagesDirective } from './localization/localized-messages.directive';
+import { GanttAddTaskComponent } from './editing/add-task.component';
+import { GridModule } from '@progress/kendo-angular-grid';
+import { DropDownsModule } from '@progress/kendo-angular-dropdowns';
+import { DependenciesTableComponent } from './editing/dependencies-table.component';
+import { TaskFieldsComponent } from './editing/task-fields.component';
 var IMPORTED_MODULES = [
     CommonModule,
     ReactiveFormsModule,
@@ -51,7 +62,12 @@ var IMPORTED_MODULES = [
     TreeListModule,
     ButtonsModule,
     DialogModule,
-    EventsModule
+    EventsModule,
+    PopupModule,
+    DraggableModule,
+    TabStripModule,
+    GridModule,
+    DropDownsModule
 ];
 var DECLARATIONS = [
     GanttComponent,
@@ -81,14 +97,21 @@ var DECLARATIONS = [
     FooterTemplateDirective,
     GanttExpandableDirective,
     GanttDependencyDirective,
+    DependencyDragCreateDirective,
     TimelineDayViewComponent,
     TimelineWeekViewComponent,
     TimelineMonthViewComponent,
     SelectableDirective,
     EditDialogComponent,
     CustomMessagesComponent,
-    LocalizedMessagesDirective
+    LocalizedMessagesDirective,
+    GanttAddTaskComponent,
+    DragValidationTooltipComponent,
+    TimelineScrollableDirective,
+    DependenciesTableComponent,
+    TaskFieldsComponent
 ];
+var ɵ0 = touchEnabled;
 /**
  * Represents the [NgModule]({{ site.data.urls.angular['ngmoduleapi'] }})
  * definition for the Gantt component.
@@ -128,12 +151,17 @@ var GanttModule = /** @class */ (function () {
             imports: IMPORTED_MODULES.slice(),
             declarations: DECLARATIONS.slice(),
             exports: DECLARATIONS.slice(),
+            entryComponents: [DragValidationTooltipComponent],
             providers: [{
                     provide: L10N_PREFIX,
                     useValue: 'kendo.gantt'
+                }, {
+                    provide: TOUCH_ENABLED,
+                    useValue: ɵ0
                 }]
         })
     ], GanttModule);
     return GanttModule;
 }());
 export { GanttModule };
+export { ɵ0 };

package/dist/es/index.js

@@ -8,14 +8,21 @@
 export * from './main';
 export { MappingService } from './common/mapping.service';
 export { OptionChangesService } from './common/option-changes.service';
+export { TOUCH_ENABLED } from './common/touch-enabled';
 export { DependencyDomService } from './dependencies/dependency-dom.service';
 export { GanttDependencyDirective } from './dependencies/gantt-dependency.directive';
+export { DragValidationTooltipComponent } from './dragging/drag-validation-tooltip.component';
+export { GanttAddTaskComponent } from './editing/add-task.component';
+export { DependenciesTableComponent } from './editing/dependencies-table.component';
 export { EditDialogComponent } from './editing/edit-dialog.component';
 export { EditService } from './editing/edit.service';
+export { TaskFieldsComponent } from './editing/task-fields.component';
 export { CustomMessagesComponent } from './localization/custom-messages.component';
+export { GanttLocalizationService } from './localization/gantt-localization.service';
 export { LocalizedMessagesDirective } from './localization/localized-messages.directive';
 export { Messages } from './localization/messages';
 export { PreventableEvent } from './models/events/preventable-event';
+export { NavigationService } from './navigation/navigation.service';
 export { GanttHeaderTableBodyComponent } from './rendering/gantt-header-table-body.component';
 export { GanttMilestoneTaskComponent } from './rendering/gantt-milestone-task.component';
 export { GanttSummaryTaskComponent } from './rendering/gantt-summary-task.component';
@@ -23,6 +30,8 @@ export { GanttTaskBase } from './rendering/gantt-task-base';
 export { GanttTaskComponent } from './rendering/gantt-task.component';
 export { GanttTasksTableBodyComponent } from './rendering/gantt-tasks-table-body.component';
 export { ScrollSyncService } from './scrolling/scroll-sync.service';
+export { TimelineScrollableDirective } from './scrolling/timeline-scroll.directive';
+export { TimelineScrollService } from './scrolling/timeline-scroll.service';
 export { GanttTimelineComponent } from './timeline/gantt-timeline.component';
 export { TimelineBaseViewService } from './timeline/timeline-base-view.service';
 export { TimelineDayViewComponent } from './timeline/timeline-day-view.component';

package/dist/es/localization/gantt-localization.service.js

@@ -0,0 +1,26 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+/**
+ * @hidden
+ *
+ * Needed to keep the Gantt's LocalizationService reference and be able to use it component's inside the TabStrip
+ */
+var GanttLocalizationService = /** @class */ (function () {
+    function GanttLocalizationService(localizationService) {
+        this.localizationService = localizationService;
+    }
+    GanttLocalizationService.prototype.get = function (token) {
+        return this.localizationService.get(token);
+    };
+    GanttLocalizationService = tslib_1.__decorate([
+        Injectable(),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], GanttLocalizationService);
+    return GanttLocalizationService;
+}());
+export { GanttLocalizationService };

package/dist/es/localization/messages.js

@@ -13,6 +13,38 @@ var Messages = /** @class */ (function (_super) {
     function Messages() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingGeneralTabTitle", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingPredecessorsTabTitle", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingSuccessorsTabTitle", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingDependenciesAddButtonText", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingDependenciesRemoveButtonText", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingDependenciesGridNameColumnTitle", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "taskEditingDependenciesGridTypeColumnTitle", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "deleteButtonText", void 0);
     tslib_1.__decorate([
         Input(),
         tslib_1.__metadata("design:type", String)
@@ -36,7 +68,19 @@ var Messages = /** @class */ (function (_super) {
     tslib_1.__decorate([
         Input(),
         tslib_1.__metadata("design:type", String)
-    ], Messages.prototype, "deleteButtonText", void 0);
+    ], Messages.prototype, "addTaskText", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "addChildText", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "addAboveText", void 0);
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String)
+    ], Messages.prototype, "addBelowText", void 0);
     tslib_1.__decorate([
         Input(),
         tslib_1.__metadata("design:type", String)

package/dist/es/main.js

@@ -7,6 +7,7 @@ export { GanttModule } from './gantt.module';
 export { GanttHierarchyBindingDirective } from './binding-directives/hierarchy-binding.directive';
 export { GanttFlatBindingDirective } from './binding-directives/flat-binding.directive';
 export { GanttExpandableDirective } from './expanded-state/expandable.directive';
+export { DependencyDragCreateDirective } from './dragging/dependency-drag-create.directive';
 export { GanttTaskTemplateDirective } from './template-directives/task-template.directive';
 export { GanttTaskContentTemplateDirective } from './template-directives/task-content-template.directive';
 export { GanttSummaryTaskTemplateDirective } from './template-directives/summary-task-template.directive';

package/dist/es/models/dependency-type.enum.js

@@ -2,3 +2,19 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
+/**
+ * The dependency type when two tasks are connected.
+ *
+ * The supported values are:
+ * * `FF`—from 'finish' to 'finish'
+ * * `FS`—from 'finish' to 'start'
+ * * `SS`—from 'start' to 'start'
+ * * `SF`—from 'start' to 'finish'
+ */
+export var DependencyType;
+(function (DependencyType) {
+    DependencyType[DependencyType["FF"] = 0] = "FF";
+    DependencyType[DependencyType["FS"] = 1] = "FS";
+    DependencyType[DependencyType["SF"] = 2] = "SF";
+    DependencyType[DependencyType["SS"] = 3] = "SS"; // task B can't start before task A starts
+})(DependencyType || (DependencyType = {}));

package/dist/es/models/models.js

@@ -2,4 +2,5 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
+export { DependencyType } from './dependency-type.enum';
 export { CellCloseEvent } from './events/cell-close-event.interface';

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

@@ -0,0 +1,390 @@
+/**-----------------------------------------------------------------------------------------
+* 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 };