@progress/kendo-angular-gantt 0.3.0-dev.202201131518 → 1.0.1-dev.202201201207

package/dist/es2015/models/events/task-click-event.interface.d.ts

@@ -10,7 +10,7 @@ export interface TaskClickEvent {
     /**
      * The DOM event that triggered the `taskClick` event.
      */
-    originalEvent: PointerEvent;
+    originalEvent: PointerEvent | KeyboardEvent;
     /**
      * The data item associated with the clicked task.
      */
@@ -20,9 +20,9 @@ export interface TaskClickEvent {
      */
     sender: GanttComponent;
     /**
-     * The row index for the clicked task.
+     * The order index of the clicked task, defined by the number of rendered tasks in the Timeline.
      */
-    rowIndex: number;
+    index: number;
     /**
      * The type of the event that triggered the `taskClick` event.
      */

package/dist/es2015/models/events/task-delete-event.interface.d.ts

@@ -0,0 +1,21 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { GanttComponent } from '../../gantt.component';
+import { TaskEditItem } from './task-edit-event.interface';
+/**
+ * The event data of the [`taskDelete`]({% slug api_gantt_ganttcomponent %}#toc-taskdelete) event.
+ */
+export interface TaskDeleteEvent {
+    /**
+     * The item associated with the delete request.
+     * The parent item is accessible through the `parent` property,
+     * and allows traversing all ancestors that need to be updated.
+     */
+    item: TaskEditItem;
+    /**
+     * The GanttComponent instance.
+     */
+    sender: GanttComponent;
+}

package/dist/es2015/models/events/task-delete-event.interface.js

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

package/dist/es2015/models/events/task-edit-event.interface.d.ts

@@ -32,10 +32,35 @@ export interface TaskEditEvent {
  * The parent item is accessible through the `parent` property,
  * and allows traversing all ancestors that need to be updated.
  */
-export declare type TaskEditItem = {
+export interface TaskEditItem {
+    /**
+     * The original data item for this entry.
+     */
     dataItem: any;
+    /**
+     * Holds the parent data item and data about its parent.
+     * If the current data item is at root level, this prop will be set to `null`.
+     */
     parent?: TaskEditItem;
-};
+}
+/**
+ * The `EditEventDependencies` object associated with the edited task.
+ * The created, updated and deleted items are accessible through their respective properties.
+ */
+export interface EditEventDependencies {
+    /**
+     * Lists the newly created dependencies.
+     */
+    createdItems: any[];
+    /**
+     * Lists the updated dependencies.
+     */
+    updatedItems: any[];
+    /**
+     * Lists the deleted dependencies.
+     */
+    deletedItems: any[];
+}
 /**
  * @hidden
  */
@@ -49,11 +74,3 @@ export interface EditEvent {
     dependencies: EditEventDependencies;
     editResultType: EditResultType;
 }
-/**
- * @hidden
- */
-export interface EditEventDependencies {
-    createdItems: any[];
-    updatedItems: any[];
-    deletedItems: any[];
-}

package/dist/es2015/models/models.d.ts

@@ -31,8 +31,10 @@ export { TaskClickEvent } from './events/task-click-event.interface';
 export { TaskAddEvent, GanttAddTaskActionItem } from './events/task-add-event.interface';
 export { TaskEditEvent } from './events/task-edit-event.interface';
 export { TaskEditItem } from './events/task-edit-event.interface';
+export { EditEventDependencies } from './events/task-edit-event.interface';
 export { DependencyAddEvent } from './events/dependency-add-event.interface';
 export { DragScrollSettings } from '../scrolling/drag-scroll-settings';
+export { TaskDeleteEvent } from './events/task-delete-event.interface';
 export { ColumnLockedChangeEvent } from './events/column-locked-change-event.interface';
 export { ColumnReorderEvent } from './events/column-reorder-event.interface';
 export { ColumnResizeEvent } from './events/column-resize-event.interface';

package/dist/es2015/navigation/navigation-models.d.ts

@@ -0,0 +1,34 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { GanttComponent } from '../gantt.component';
+/**
+ * @hidden
+ */
+export interface NavigationMetadata {
+    gantt: GanttComponent;
+    host: HTMLElement;
+    treeListElement: HTMLElement;
+    timelineElement: HTMLElement;
+}
+/**
+ * @hidden
+ */
+export interface TableCellCoords {
+    rowIndex: number;
+    colIndex: number;
+}
+/**
+ * @hidden
+ */
+export interface TaskActivityStatus {
+    /**
+     * Represents the timeline task index of the task element which should have tabindex="0".
+     */
+    activeIndex: number;
+    /**
+     * Specifies if the active task should be focused.
+     */
+    isFocused: boolean;
+}

package/dist/es2015/navigation/navigation-models.js

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

package/dist/es2015/navigation/navigation.service.d.ts

@@ -0,0 +1,126 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NgZone, OnDestroy, Renderer2 } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ScrollSyncService } from '../scrolling/scroll-sync.service';
+import { NavigationMetadata, TaskActivityStatus } from './navigation-models';
+/**
+ * @hidden
+ */
+export declare class NavigationService implements OnDestroy {
+    private zone;
+    private renderer;
+    private 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.
+     */
+    readonly taskStatusChanges: Subject<TaskActivityStatus>;
+    /**
+     * Specifies whether navigation is enabled.
+     */
+    readonly enabled: boolean;
+    /**
+     * Used to retrieve read-only data about the currently active task.
+     */
+    readonly activeTask: TaskActivityStatus;
+    /**
+     * 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.
+     */
+    private activeTreeListCell;
+    /**
+     * 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.
+     */
+    private activeTimelineIndex;
+    /**
+     * 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.
+     */
+    private isTimelineFocused;
+    /**
+     * The TreeList row index takes into account the header and filter rows.
+     * Used when translating Timeline task indices to TreeList row indices.
+     */
+    private readonly treeListHeaderRowsCount;
+    /**
+     * Keeps track of which part has last been focused.
+     * Used when calling `gantt.focus()` to determine which part of the component should receive focus.
+     */
+    private treeListLastActive;
+    /**
+     * Keeps track of which part has last been focused.
+     * Used when calling `gantt.focus()` to determine which part of the component should receive focus.
+     */
+    private timelineLastActive;
+    private gantt;
+    private host;
+    private treeListElement;
+    private timelineElement;
+    private _enabled;
+    private _activeTimelineIndex;
+    private _activeTreeListCell;
+    private eventListenerDisposers;
+    constructor(zone: NgZone, renderer: Renderer2, scrollSyncService: ScrollSyncService);
+    initialize({ gantt, host, treeListElement, timelineElement }: NavigationMetadata): void;
+    ngOnDestroy(): void;
+    /**
+     * 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.
+     */
+    focusLastActiveItem(): void;
+    /**
+     * Focuses the targeted TreeList cell regardless of the last peresisted target.
+     */
+    focusCell(rowIndex: number, colIndex: number): void;
+    /**
+     * Focuses the targeted Timeline task regardless of the last peresisted target.
+     */
+    focusTask(index: number): void;
+    /**
+     * Updates the focus target flags and notifies the active task to update its focused state.
+     */
+    handleTimelineFocusIn({ target }: FocusEvent): void;
+    /**
+     * Updates the timeline focus state flag and notifies the active task to update its focused state.
+     */
+    handleTimelineFocusOut({ relatedTarget }: FocusEvent): void;
+    /**
+     * 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.
+     */
+    handleTreeListFocusIn(event: FocusEvent): void;
+    handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Filters for task mousedown in the Timeline.
+     */
+    private handleTimelineMousedown;
+    /**
+     * Scrolls horizontally to the beginning of the target task if the beginning of its content is not in the viewport.
+     */
+    private scrollHorizontallyToTask;
+    /**
+     * 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.
+     */
+    private focusTreeList;
+    /**
+     * Fires the `taskStatusChanges` event with active and focused status retrieved from
+     * `this.activeTimelineIndex` and `this.isTimelineFocused`.
+     */
+    private notifyTaskStatusChange;
+}

package/dist/es2015/navigation/navigation.service.js

@@ -0,0 +1,355 @@
+/**-----------------------------------------------------------------------------------------
+* 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
+ */
+let NavigationService = class NavigationService {
+    constructor(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 };
+    }
+    /**
+     * Specifies whether navigation is enabled.
+     */
+    get enabled() {
+        return this._enabled;
+    }
+    /**
+     * Used to retrieve read-only data about the currently active task.
+     */
+    get activeTask() {
+        return {
+            activeIndex: this.activeTimelineIndex,
+            isFocused: this.isTimelineFocused
+        };
+    }
+    /**
+     * 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 activeTreeListCell(cell) {
+        this._activeTreeListCell = cell;
+    }
+    get activeTreeListCell() {
+        const firstAvailableIndex = 0;
+        const lastAvailableRowIndex = this.treeListHeaderRowsCount + this.gantt.treeList.view.data.length - 1;
+        const rowIndex = fitToRange(this._activeTreeListCell.rowIndex, firstAvailableIndex, lastAvailableRowIndex);
+        const lastAvailableColIndex = this.gantt.columns.length;
+        const colIndex = fitToRange(this._activeTreeListCell.colIndex, firstAvailableIndex, lastAvailableColIndex);
+        return { rowIndex, colIndex };
+    }
+    /**
+     * 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 activeTimelineIndex(index) {
+        this._activeTimelineIndex = index;
+    }
+    get activeTimelineIndex() {
+        const firstAvailableIndex = 0;
+        const lastAvailableIndex = this.gantt.treeList.view.data.length - 1;
+        return fitToRange(this._activeTimelineIndex, firstAvailableIndex, lastAvailableIndex);
+    }
+    /**
+     * The TreeList row index takes into account the header and filter rows.
+     * Used when translating Timeline task indices to TreeList row indices.
+     */
+    get treeListHeaderRowsCount() {
+        // captures nested group header rows + filter row if we start supporting it at some point
+        return this.treeListElement.querySelectorAll('.k-grid-header tr').length;
+    }
+    initialize({ gantt, host, treeListElement, 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
+        const splitbar = this.host.querySelector('.k-splitbar');
+        if (isPresent(splitbar) && isPresent(splitbar.previousElementSibling) && isPresent(splitbar.after)) {
+            splitbar.after(splitbar.previousElementSibling);
+        }
+        this.zone.runOutsideAngular(() => {
+            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))
+            ];
+        });
+    }
+    ngOnDestroy() {
+        if (isPresent(this.eventListenerDisposers)) {
+            this.eventListenerDisposers.forEach(removeListener => 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.
+     */
+    focusLastActiveItem() {
+        if (this.gantt.data.length === 0 || (!this.treeListLastActive && !this.timelineLastActive)) {
+            this.focusCell(0, 0);
+        }
+        else if (this.treeListLastActive) {
+            const { rowIndex, colIndex } = this.activeTreeListCell;
+            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.
+     */
+    focusCell(rowIndex, colIndex) {
+        this.activeTreeListCell = { rowIndex, 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.
+     */
+    focusTask(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.
+     */
+    handleTimelineFocusIn({ 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.
+     */
+    handleTimelineFocusOut({ 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.
+     */
+    handleTreeListFocusIn(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)) {
+            const { colIndex, rowIndex } = this.gantt.treeList.activeCell;
+            this.activeTreeListCell = { colIndex, rowIndex };
+        }
+        else {
+            // if the previous focus target was outside the TreeList, ensure the expected focus coords are used
+            const { rowIndex, colIndex } = this.activeTreeListCell;
+            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');
+        }
+    }
+    handleKeydown(event) {
+        const { keyCode, target, altKey } = event;
+        const isTimelineActive = this.timelineElement.contains(target);
+        if (isTimelineActive) {
+            if (isArrowUpDownKey(keyCode)) {
+                const 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) {
+                const 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)) {
+                const task = this.gantt.renderedTreeListItems[this.activeTimelineIndex];
+                const selectionAction = this.gantt.getSelectionAction(event, task);
+                if (isPresent(task) && !this.gantt.isSameSelection(selectionAction, task)) {
+                    this.zone.run(() => this.gantt.notifySelectionChange(task, selectionAction));
+                }
+                event.preventDefault();
+            }
+            if (keyCode === Keys.Enter && hasObservers(this.gantt.taskClick)) {
+                const task = this.gantt.renderedTreeListItems[this.activeTimelineIndex];
+                if (isPresent(task)) {
+                    this.zone.run(() => this.gantt.notifyTaskClick(event, task, this.activeTimelineIndex));
+                }
+                event.preventDefault();
+            }
+            if (isExpandCollapseKey(keyCode, altKey)) {
+                const task = this.gantt.renderedTreeListItems[this.activeTimelineIndex];
+                if (isPresent(task) && this.gantt.hasChildren(task)) {
+                    const shouldExpand = keyCode === Keys.ArrowRight;
+                    const isExpanded = this.gantt.isExpanded(task);
+                    const sameState = shouldExpand === isExpanded;
+                    if (!sameState) {
+                        this.zone.run(() => {
+                            const expandEvent = { dataItem: task };
+                            // order is not arbitrary
+                            // the TreeList emits the individual events first, then the combined `expandStateChange` event
+                            const individualEmitter = shouldExpand ? this.gantt.rowExpand : this.gantt.rowCollapse;
+                            individualEmitter.emit(expandEvent);
+                            this.gantt.expandStateChange.emit(Object.assign({}, expandEvent, { expand: shouldExpand }));
+                            this.gantt.updateView();
+                            this.scrollHorizontallyToTask(this.activeTimelineIndex);
+                        });
+                    }
+                }
+                event.preventDefault();
+            }
+        }
+        const isTreeListActive = this.treeListElement.contains(target);
+        if (keyCode === Keys.Delete && (isTimelineActive || isTreeListActive) && hasObservers(this.gantt.taskDelete)) {
+            const taskIndex = isTreeListActive ?
+                this.gantt.treeList.activeCell.dataRowIndex :
+                this.activeTimelineIndex;
+            const task = this.gantt.renderedTreeListItems[taskIndex];
+            if (isPresent(task)) {
+                this.zone.run(() => this.gantt.notifyTaskDelete(task));
+            }
+        }
+        if (isViewDigitKey(keyCode) && !isToolbar(target, this.host) && !this.gantt.isInEditMode) {
+            const targetViewIndex = getIndexFromViewDigitKeyCode(keyCode);
+            const availableViews = this.gantt.views.toArray();
+            const targetView = availableViews[targetViewIndex];
+            if (isPresent(targetView) && targetView.type !== this.gantt.activeView) {
+                this.zone.run(() => this.gantt.changeActiveView(targetView.type));
+            }
+        }
+    }
+    /**
+     * Filters for task mousedown in the Timeline.
+     */
+    handleTimelineMousedown({ target }) {
+        if (isTask(target, this.host) && !isClearButton(target, this.host)) {
+            const 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.
+     */
+    scrollHorizontallyToTask(index) {
+        const 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
+        const targetVisibleWidth = 200;
+        const isScrollBeforeTask = (this.timelineElement.clientWidth + this.timelineElement.scrollLeft) < (task.offsetLeft + targetVisibleWidth);
+        const 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.
+     */
+    focusTreeList() {
+        this.gantt.treeList.focus();
+    }
+    /**
+     * Fires the `taskStatusChanges` event with active and focused status retrieved from
+     * `this.activeTimelineIndex` and `this.isTimelineFocused`.
+     */
+    notifyTaskStatusChange() {
+        this.taskStatusChanges.next(this.activeTask);
+    }
+};
+NavigationService = tslib_1.__decorate([
+    Injectable(),
+    tslib_1.__metadata("design:paramtypes", [NgZone,
+        Renderer2,
+        ScrollSyncService])
+], NavigationService);
+export { NavigationService };

package/dist/es2015/navigation/utils.d.ts

@@ -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
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export declare const isArrowUpDownKey: (keyCode: number) => boolean;
+/**
+ * @hidden
+ */
+export declare const isNavigationKey: (keyCode: number) => boolean;
+/**
+ * @hidden
+ */
+export declare const isExpandCollapseKey: (keyCode: number, altKey: boolean) => boolean;
+/**
+ * @hidden
+ */
+export declare const isViewDigitKey: (keyCode: number) => boolean;
+/**
+ * @hidden
+ *
+ * Returns the corresponding view index for the pressed digit key (Digit 1 => 0, Digit 2 => 1, etc.).
+ */
+export declare const getIndexFromViewDigitKeyCode: (keyCode: number) => number;