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

package/dist/es/utils.js

@@ -4,6 +4,7 @@
 *-------------------------------------------------------------------------------------------*/
 import { isDocumentAvailable, closestInScope, matchesClasses } from '@progress/kendo-angular-common';
 import { addDays, addWeeks, cloneDate, firstDayInWeek } from '@progress/kendo-date-math';
+import { DependencyType } from './models/dependency-type.enum';
 /**
  * @hidden
  */
@@ -110,24 +111,43 @@ export var isNumber = function (contender) { return typeof contender === 'number
  * @hidden
  */
 export var isString = function (contender) { return typeof contender === 'string'; };
+/**
+ * @hidden
+ *
+ * Gets the closest timeline task wrapper element from an event target.
+ * Restricts the search up to the provided parent element from the second param.
+ */
+export var getClosestTaskWrapper = function (element, parentScope) {
+    return closestInScope(element, matchesClasses('k-task-wrap'), parentScope);
+};
+/**
+ * @hidden
+ *
+ * Checks whether the queried item or its parent items has a `k-task-wrap` selector.
+ * Restricts the search up to the provided parent element from the second param.
+ */
+export var isTaskWrapper = function (contender, parentScope) {
+    var taskWrapper = closestInScope(contender, matchesClasses('k-task-wrap'), parentScope);
+    return isPresent(taskWrapper);
+};
 /**
  * @hidden
  *
  * Gets the closest timeline task element from an event target.
- * Restricts the search up to the provided gantt element from the second param.
+ * Restricts the search up to the provided parent element from the second param.
  */
-export var getClosestTask = function (element, gantt) {
-    return closestInScope(element, matchesClasses('k-task'), gantt);
+export var getClosestTask = function (element, parentScope) {
+    return closestInScope(element, matchesClasses('k-task'), parentScope);
 };
 /**
  * @hidden
  *
  * Gets the closest timeline task element index from an event target.
  * Uses the `data-task-index` attribute assigned to each task.
- * Restricts the search up to the provided gantt element from the second param.
+ * Restricts the search up to the provided parent element from the second param.
  */
-export var getClosestTaskIndex = function (element, gantt) {
-    var task = closestInScope(element, matchesClasses('k-task'), gantt);
+export var getClosestTaskIndex = function (element, parentScope) {
+    var task = closestInScope(element, matchesClasses('k-task-wrap'), parentScope);
     if (!isPresent(task)) {
         return null;
     }
@@ -137,19 +157,130 @@ export var getClosestTaskIndex = function (element, gantt) {
  * @hidden
  *
  * Checks whether the queried item or its parent items has a `k-task` selector.
- * Restricts the search up to the provided gantt element from the second param.
+ * Restricts the search up to the provided parent element from the second param.
  */
-export var isTask = function (contender, gantt) {
-    var task = closestInScope(contender, matchesClasses('k-task'), gantt);
+export var isTask = function (contender, parentScope) {
+    var task = closestInScope(contender, matchesClasses('k-task'), parentScope);
     return isPresent(task);
 };
 /**
  * @hidden
  *
  * Checks whether the queried item or its parent items has a `k-task-actions` selector - used for the clear button.
- * Restricts the search up to the provided gantt element from the second param.
+ * Restricts the search up to the provided parent element from the second param.
  */
-export var isClearButton = function (contender, gantt) {
-    var clearButtonContainer = closestInScope(contender, matchesClasses('k-task-actions'), gantt);
+export var isClearButton = function (contender, parentScope) {
+    var clearButtonContainer = closestInScope(contender, matchesClasses('k-task-actions'), parentScope);
     return isPresent(clearButtonContainer);
 };
+/**
+ * @hidden
+ *
+ * Checks whether the queried item has a `k-task-dot` selector - used for the dependency drag clues.
+ */
+export var isDependencyDragClue = function (element) {
+    if (!isPresent(element)) {
+        return false;
+    }
+    return element.classList.contains('k-task-dot');
+};
+/**
+ * @hidden
+ *
+ * Checks whether the queried item has a `k-task-dot` & `k-task-start` selector - used for the dependency drag start clues.
+ */
+export var isDependencyDragStartClue = function (element) {
+    if (!isPresent(element)) {
+        return false;
+    }
+    return element.classList.contains('k-task-dot') && element.classList.contains('k-task-start');
+};
+/**
+ * @hidden
+ *
+ * Gets the `DependencyType` for an attempted dependency create from the provided two elements.
+ * The two linked drag clue HTML elements are used to extract this data (via their CSS classes).
+ */
+export var getDependencyTypeFromTargetTasks = function (fromTaskClue, toTaskClue) {
+    if (!isDependencyDragClue(fromTaskClue) || !isDependencyDragClue(toTaskClue)) {
+        return null;
+    }
+    var fromTaskType = isDependencyDragStartClue(fromTaskClue) ? 'S' : 'F';
+    var toTaskType = isDependencyDragStartClue(toTaskClue) ? 'S' : 'F';
+    var dependencyTypeName = "" + fromTaskType + toTaskType;
+    switch (dependencyTypeName) {
+        case 'FF': return DependencyType.FF;
+        case 'FS': return DependencyType.FS;
+        case 'SF': return DependencyType.SF;
+        case 'SS': return DependencyType.SS;
+        default: return null;
+    }
+};
+/**
+ * @hidden
+ *
+ * Checks whether the two provided drag clues belong to the same task element.
+ */
+export var sameTaskClues = function (fromTaskClue, toTaskClue, parentScope) {
+    if (!isPresent(fromTaskClue) || !isPresent(toTaskClue)) {
+        return false;
+    }
+    var fromTaskWrapper = getClosestTaskWrapper(fromTaskClue, parentScope);
+    var toTaskWrapper = getClosestTaskWrapper(toTaskClue, parentScope);
+    return fromTaskWrapper === toTaskWrapper;
+};
+/**
+ * @hidden
+ *
+ * Fits a contender number between a min and max range.
+ * If the contender is below the min value, the min value is returned.
+ * If the contender is above the max value, the max value is returned.
+ */
+export var fitToRange = function (contender, min, max) {
+    if (contender > max) {
+        return max;
+    }
+    else if (contender < min) {
+        return min;
+    }
+    else {
+        return contender;
+    }
+};
+/**
+ * @hidden
+ *
+ * Checks whether either of the two provided tasks is a parent of the other.
+ */
+export var areParentChild = function (taskA, taskB) {
+    var parentChildRelationship = false;
+    var taskAParent = taskA;
+    while (isPresent(taskAParent) && isPresent(taskAParent.data)) {
+        if (taskAParent.data === taskB.data) {
+            parentChildRelationship = true;
+            break;
+        }
+        taskAParent = taskAParent.parent;
+    }
+    var taskBParent = taskB;
+    while (!parentChildRelationship && isPresent(taskBParent) && isPresent(taskBParent.data)) {
+        if (taskBParent.data === taskA.data) {
+            parentChildRelationship = true;
+            break;
+        }
+        taskBParent = taskBParent.parent;
+    }
+    return parentChildRelationship;
+};
+/**
+ * @hidden
+ *
+ * Extracts an element from the provided client coords.
+ * Using the `event.target` is not reliable under mobile devices with the current implementation of the draggable, so use this instead.
+ */
+export var elementFromPoint = function (clientX, clientY) {
+    if (!isDocumentAvailable()) {
+        return null;
+    }
+    return document.elementFromPoint(clientX, clientY);
+};

package/dist/es2015/common/touch-enabled.d.ts

@@ -0,0 +1,9 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { InjectionToken } from '@angular/core';
+/**
+ * @hidden
+ */
+export declare const TOUCH_ENABLED: InjectionToken<boolean>;

package/dist/es2015/common/touch-enabled.js

@@ -0,0 +1,9 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { InjectionToken } from '@angular/core';
+/**
+ * @hidden
+ */
+export const TOUCH_ENABLED = new InjectionToken('gantt-touch-enabled');

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

@@ -36,3 +36,18 @@ export declare const getElementRect: (element: HTMLElement, relativeContainer: H
  * @hidden
  */
 export declare const dependencyCoordinates: (from: Rectangle, to: Rectangle, rowHeight: number, type: DependencyType, minDistanceBeforeTurn: number, arrowSize: number) => Position[];
+/**
+ * @hidden
+ *
+ * Translates the provided client `left` and `top` coords to coords relative to the provided container.
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/CSSOM_View/Coordinate_systems#standard_cssom_coordinate_systems
+ */
+export declare const clientToOffsetCoords: (clientLeft: number, clientTop: number, offsetContainer: Element) => Position;
+/**
+ * @hidden
+ *
+ * Retrieves the `left` and `top` values of the center of the provided element.
+ * The retrieved values are relative to the current viewport (client values).
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/CSSOM_View/Coordinate_systems#standard_cssom_coordinate_systems
+ */
+export declare const getElementClientCenterCoords: (element: Element) => Position;

package/dist/es2015/dependencies/utils.js

@@ -13,6 +13,9 @@ export const getOffsetRelativeToParent = (element, targetParent) => {
         top: 0,
         left: 0
     };
+    if (!targetParent.contains(element)) {
+        return offset;
+    }
     let offsetParent = element;
     while (offsetParent && offsetParent !== targetParent) {
         offset.top += offsetParent.offsetTop;
@@ -162,4 +165,35 @@ const getArrowEast = (top, left, arrowSize) => {
     return points;
 };
 const ɵ2 = getArrowEast;
+/**
+ * @hidden
+ *
+ * Translates the provided client `left` and `top` coords to coords relative to the provided container.
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/CSSOM_View/Coordinate_systems#standard_cssom_coordinate_systems
+ */
+export const clientToOffsetCoords = (clientLeft, clientTop, offsetContainer) => {
+    // client (viewport) coordinates of the target container
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect#value
+    const offsetContainerClientRect = offsetContainer.getBoundingClientRect();
+    return {
+        left: clientLeft - offsetContainerClientRect.left + offsetContainer.scrollLeft,
+        top: clientTop - offsetContainerClientRect.top + offsetContainer.scrollTop
+    };
+};
+/**
+ * @hidden
+ *
+ * Retrieves the `left` and `top` values of the center of the provided element.
+ * The retrieved values are relative to the current viewport (client values).
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/CSSOM_View/Coordinate_systems#standard_cssom_coordinate_systems
+ */
+export const getElementClientCenterCoords = (element) => {
+    // client (viewport) coordinates of the targeted element
+    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect#value
+    const { left, top, width, height } = element.getBoundingClientRect();
+    return {
+        left: left + (width / 2),
+        top: top + (height / 2)
+    };
+};
 export { ɵ0, ɵ1, ɵ2 };

package/dist/es2015/dragging/dependency-drag-create.directive.d.ts

@@ -0,0 +1,72 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { AfterViewInit, NgZone, OnDestroy, Renderer2 } from '@angular/core';
+import { PopupService } from '@progress/kendo-angular-popup';
+import { GanttComponent } from '../gantt.component';
+import { MappingService } from '../common/mapping.service';
+import { TimelineScrollService } from '../scrolling/timeline-scroll.service';
+/**
+ * A directive which enables the creation of new dependencies via dragging.
+ */
+export declare class DependencyDragCreateDirective implements AfterViewInit, OnDestroy {
+    private gantt;
+    private zone;
+    private renderer;
+    private mapper;
+    private popupService;
+    private timelineScrollService;
+    /**
+     * Specifies whether the validation tooltip will be displayed during drag operations.
+     *
+     * @default true
+     */
+    displayValidationTooltip: boolean;
+    private readonly container;
+    private readonly polyline;
+    private readonly popupContainer;
+    /**
+     * Points to the drag clue where the dragging started (the FROM task).
+     * Used to attach/detach classes to the target element and its task wrapper parent element.
+     */
+    private fromTaskClue;
+    /**
+     * The drag start element coords will be the same through the enitre dragging session, so compute them on press and cache them.
+     */
+    private polylineStartCoords;
+    /**
+     * Stored during dragging to be consumed by the container scroll subscription.
+     * The scroll event doesn't expose the current pointer position, so it has to be stored separately.
+     */
+    private currentPointerClientCoords;
+    private scrollListenerDisposer;
+    private dragPopup;
+    private dragSubscriptions;
+    constructor(gantt: GanttComponent, zone: NgZone, renderer: Renderer2, mapper: MappingService, popupService: PopupService, timelineScrollService: TimelineScrollService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private subscribeDraggable;
+    private unsubscribeDraggable;
+    private handlePress;
+    private handleDrag;
+    private handleRelease;
+    private updatePolyline;
+    private clearPolyline;
+    private assignDragStartClasses;
+    private removeDragStartClasses;
+    private scrollPointIntoView;
+    private cancelScroll;
+    private addScrollListener;
+    private removeScrollListener;
+    private openDragPopup;
+    private updateDragPopup;
+    private closeDragPopup;
+    private extractTaskName;
+    private getTooltipContext;
+    /**
+     * Restricts the popup position to not go below the scroll height or width of the container.
+     * Flips the position of the popup when there's not enough vertical space in the visible part of the container to render the popup.
+     */
+    private normalizePopupPosition;
+}

package/dist/es2015/dragging/dependency-drag-create.directive.js

@@ -0,0 +1,324 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Directive, Input, NgZone, Renderer2 } from '@angular/core';
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
+import { PopupService } from '@progress/kendo-angular-popup';
+import { GanttComponent } from '../gantt.component';
+import { MappingService } from '../common/mapping.service';
+import { TimelineScrollService } from '../scrolling/timeline-scroll.service';
+import { DragValidationTooltipComponent } from './drag-validation-tooltip.component';
+import { clientToOffsetCoords, getElementClientCenterCoords } from '../dependencies/utils';
+import { isPresent, isDependencyDragClue, getClosestTaskWrapper, getDependencyTypeFromTargetTasks, getClosestTaskIndex, sameTaskClues, isTaskWrapper, fitToRange } from '../utils';
+import { elementFromPoint } from '../utils';
+/**
+ * When added to the .k-task-dot, the element will be kept with hover styles.
+ * Used for the drag clue from which the dragging has started.
+ */
+const DRAG_CLUE_HOVER_CLASS = 'k-state-hover';
+/**
+ * Add the selection disabling class to the enitre container.
+ * Otherwise existing selection on a given task text prevents dragging the clue even if the clue has `user-select: none` styles.
+ */
+const USER_SELECT_NONE_CLASS = 'k-user-select-none';
+/**
+ * When added to the .k-task-wrap, the containing .k-task-dot elements will be kept visible even when not hovered.
+ * Used for the drag clue from which the dragging has started.
+ */
+const TASK_WRAPPER_DRAG_CLASS = 'k-origin';
+/**
+ * Use 20px margin between the pointer and the popup.
+ * Could be made user-configurable if there's demand.
+ */
+const DEFAULT_POPUP_VERTICAL_MARGIN = 20;
+/**
+ * A directive which enables the creation of new dependencies via dragging.
+ */
+let DependencyDragCreateDirective = class DependencyDragCreateDirective {
+    constructor(gantt, zone, renderer, mapper, popupService, timelineScrollService) {
+        this.gantt = gantt;
+        this.zone = zone;
+        this.renderer = renderer;
+        this.mapper = mapper;
+        this.popupService = popupService;
+        this.timelineScrollService = timelineScrollService;
+        /**
+         * Specifies whether the validation tooltip will be displayed during drag operations.
+         *
+         * @default true
+         */
+        this.displayValidationTooltip = true;
+        this.gantt.renderDependencyDragClues = true;
+    }
+    get container() {
+        if (!isPresent(this.gantt.timeline) || !isPresent(this.gantt.timeline.timelineContent)) {
+            return null;
+        }
+        return this.gantt.timeline.timelineContent.nativeElement;
+    }
+    get polyline() {
+        if (!isPresent(this.gantt.timeline) || !isPresent(this.gantt.timeline.dependencyDragCreatePolyline)) {
+            return null;
+        }
+        return this.gantt.timeline.dependencyDragCreatePolyline.nativeElement;
+    }
+    get popupContainer() {
+        if (!isPresent(this.gantt.timeline) || !isPresent(this.gantt.timeline.dragPopupContainer)) {
+            return null;
+        }
+        return this.gantt.timeline.dragPopupContainer;
+    }
+    ngAfterViewInit() {
+        this.subscribeDraggable();
+        this.addScrollListener();
+    }
+    ngOnDestroy() {
+        this.unsubscribeDraggable();
+        this.removeScrollListener();
+        this.fromTaskClue = null;
+        this.cancelScroll();
+        this.closeDragPopup();
+    }
+    subscribeDraggable() {
+        this.dragSubscriptions = this.gantt.timeline.timelineContainerPress
+            .subscribe(this.handlePress.bind(this));
+        this.dragSubscriptions.add(this.gantt.timeline.timelineContainerDrag
+            .subscribe(this.handleDrag.bind(this)));
+        this.dragSubscriptions.add(this.gantt.timeline.timelineContainerRelease
+            .subscribe(this.handleRelease.bind(this)));
+    }
+    unsubscribeDraggable() {
+        if (isPresent(this.dragSubscriptions)) {
+            this.dragSubscriptions.unsubscribe();
+            this.dragSubscriptions = null;
+        }
+    }
+    handlePress({ clientX, clientY }) {
+        // using `originalEvent.target` is not reliable under mobile devices with the current implementation of the draggable, so use this instead
+        const target = elementFromPoint(clientX, clientY);
+        if (isDependencyDragClue(target)) {
+            this.fromTaskClue = target;
+            this.assignDragStartClasses(this.fromTaskClue);
+            // use the center of the target clue as polyline starting point
+            const dragClueCenterCoords = getElementClientCenterCoords(this.fromTaskClue);
+            // the polyline uses `position: aboslute`, so translate the client coordinates to offset coordinates (`left` and `top` relative to the timeline container)
+            this.polylineStartCoords = clientToOffsetCoords(dragClueCenterCoords.left, dragClueCenterCoords.top, this.container);
+        }
+    }
+    handleDrag({ clientX, clientY }) {
+        if (isPresent(this.fromTaskClue)) {
+            // the polyline uses `position: aboslute`, so translate the client coordinates to offset coordinates (`left` and `top` relative to the timeline container)
+            const pointerOffsetCoords = clientToOffsetCoords(clientX, clientY, this.container);
+            // the start coords are calculated just once per drag session in handlePress
+            // use the current drag coords as polyline end coords
+            this.updatePolyline(this.polylineStartCoords, pointerOffsetCoords);
+            this.currentPointerClientCoords = { left: clientX, top: clientY };
+            if (this.gantt.dragScrollSettings.enabled) {
+                // use client coordinates for scroll trigger
+                this.scrollPointIntoView(this.currentPointerClientCoords);
+            }
+            if (this.displayValidationTooltip) {
+                this.updateDragPopup(pointerOffsetCoords);
+            }
+        }
+    }
+    handleRelease({ clientX, clientY }) {
+        if (!isPresent(this.fromTaskClue)) {
+            return;
+        }
+        // using `originalEvent.target` is not reliable under mobile devices with the current implementation of the draggable, so use this instead
+        const target = elementFromPoint(clientX, clientY);
+        if (isDependencyDragClue(target) && !sameTaskClues(this.fromTaskClue, target, this.container)) {
+            this.zone.run(() => {
+                const fromTaskClue = this.fromTaskClue;
+                const toTaskClue = target;
+                const fromTask = this.gantt.renderedTreeListItems[getClosestTaskIndex(fromTaskClue, this.container)];
+                const toTask = this.gantt.renderedTreeListItems[getClosestTaskIndex(toTaskClue, this.container)];
+                const dependencyType = getDependencyTypeFromTargetTasks(fromTaskClue, toTaskClue);
+                const { fromId, toId, type } = this.mapper.dependencyFields;
+                this.gantt.dependencyAdd.emit({
+                    fromTask: fromTask,
+                    toTask: toTask,
+                    type: dependencyType,
+                    isValid: this.gantt.validateNewDependency({
+                        [fromId]: this.mapper.extractFromTask(fromTask, 'id'),
+                        [toId]: this.mapper.extractFromTask(toTask, 'id'),
+                        [type]: dependencyType
+                    })
+                });
+            });
+        }
+        this.clearPolyline();
+        this.removeDragStartClasses(this.fromTaskClue);
+        this.fromTaskClue = null;
+        this.cancelScroll();
+        this.closeDragPopup();
+    }
+    updatePolyline(start, end) {
+        const points = `${start.left},${start.top} ${end.left},${end.top}`;
+        this.renderer.setAttribute(this.polyline, 'points', points);
+    }
+    clearPolyline() {
+        this.renderer.removeAttribute(this.polyline, 'points');
+    }
+    assignDragStartClasses(dragClue) {
+        if (!isPresent(dragClue)) {
+            return;
+        }
+        this.renderer.addClass(this.container, USER_SELECT_NONE_CLASS);
+        this.renderer.addClass(dragClue, DRAG_CLUE_HOVER_CLASS);
+        const taskWrapper = getClosestTaskWrapper(dragClue, this.container);
+        if (isPresent(taskWrapper)) {
+            this.renderer.addClass(taskWrapper, TASK_WRAPPER_DRAG_CLASS);
+        }
+    }
+    removeDragStartClasses(dragClue) {
+        if (!isPresent(dragClue)) {
+            return;
+        }
+        this.renderer.removeClass(this.container, USER_SELECT_NONE_CLASS);
+        this.renderer.removeClass(dragClue, DRAG_CLUE_HOVER_CLASS);
+        const taskWrapper = getClosestTaskWrapper(dragClue, this.container);
+        if (isPresent(taskWrapper)) {
+            this.renderer.removeClass(taskWrapper, TASK_WRAPPER_DRAG_CLASS);
+        }
+    }
+    scrollPointIntoView({ left, top }) {
+        this.timelineScrollService.requestScrollCancel();
+        this.timelineScrollService.requestHorizontalScroll(left);
+        this.timelineScrollService.requestVerticalScroll(top);
+    }
+    cancelScroll() {
+        this.timelineScrollService.requestScrollCancel();
+    }
+    addScrollListener() {
+        if (!isDocumentAvailable()) {
+            return;
+        }
+        this.zone.runOutsideAngular(() => this.scrollListenerDisposer = this.renderer.listen(this.container, 'scroll', () => {
+            // update the polyline only if we're currently dragging
+            if (isPresent(this.fromTaskClue) && isPresent(this.currentPointerClientCoords)) {
+                const { left, top } = this.currentPointerClientCoords;
+                const pointerOffsetCoords = clientToOffsetCoords(left, top, this.container);
+                this.updatePolyline(this.polylineStartCoords, pointerOffsetCoords);
+                if (this.displayValidationTooltip) {
+                    this.updateDragPopup(pointerOffsetCoords);
+                }
+            }
+        }));
+    }
+    removeScrollListener() {
+        if (isPresent(this.scrollListenerDisposer)) {
+            this.scrollListenerDisposer();
+            this.scrollListenerDisposer = null;
+        }
+    }
+    openDragPopup() {
+        if (isPresent(this.dragPopup)) {
+            this.closeDragPopup();
+        }
+        this.dragPopup = this.popupService.open({
+            animate: false,
+            content: DragValidationTooltipComponent,
+            appendTo: this.popupContainer,
+            positionMode: 'absolute',
+            popupClass: 'k-popup-transparent'
+        });
+    }
+    updateDragPopup(pointerOffsetPosition) {
+        if (!isPresent(this.dragPopup)) {
+            this.openDragPopup();
+        }
+        const tooltip = this.dragPopup.content.instance;
+        const { fromTaskName, toTaskName, isValid, showValidityStatus } = this.getTooltipContext();
+        if (tooltip.fromTaskName !== fromTaskName ||
+            tooltip.toTaskName !== toTaskName ||
+            tooltip.isValid !== isValid ||
+            tooltip.showValidityStatus !== showValidityStatus) {
+            tooltip.fromTaskName = fromTaskName;
+            tooltip.toTaskName = toTaskName;
+            tooltip.isValid = isValid;
+            tooltip.showValidityStatus = showValidityStatus;
+            this.dragPopup.content.changeDetectorRef.detectChanges();
+        }
+        this.dragPopup.popup.instance.offset = this.normalizePopupPosition(pointerOffsetPosition);
+        this.dragPopup.popup.changeDetectorRef.detectChanges();
+    }
+    closeDragPopup() {
+        if (isPresent(this.dragPopup)) {
+            this.dragPopup.close();
+            this.dragPopup = null;
+        }
+    }
+    extractTaskName(target) {
+        if (!isTaskWrapper(target, this.container)) {
+            return null;
+        }
+        const taskIndex = getClosestTaskIndex(target, this.container);
+        const task = this.gantt.renderedTreeListItems[taskIndex];
+        const taskName = this.mapper.extractFromTask(task, 'title');
+        return taskName;
+    }
+    getTooltipContext() {
+        const fromTaskName = this.extractTaskName(this.fromTaskClue);
+        const currentPointerTarget = elementFromPoint(this.currentPointerClientCoords.left, this.currentPointerClientCoords.top);
+        const toTaskName = isTaskWrapper(currentPointerTarget, this.container) && !sameTaskClues(this.fromTaskClue, currentPointerTarget, this.container) ?
+            this.extractTaskName(currentPointerTarget) :
+            '';
+        const showValidityStatus = isDependencyDragClue(currentPointerTarget) && !sameTaskClues(this.fromTaskClue, currentPointerTarget, this.container);
+        const { fromId, toId, type } = this.mapper.dependencyFields;
+        return {
+            fromTaskName,
+            toTaskName,
+            showValidityStatus,
+            isValid: showValidityStatus && this.gantt.validateNewDependency({
+                [fromId]: this.mapper.extractFromTask(this.gantt.renderedTreeListItems[getClosestTaskIndex(this.fromTaskClue, this.container)], 'id'),
+                [toId]: this.mapper.extractFromTask(this.gantt.renderedTreeListItems[getClosestTaskIndex(currentPointerTarget, this.container)], 'id'),
+                [type]: getDependencyTypeFromTargetTasks(this.fromTaskClue, currentPointerTarget)
+            })
+        };
+    }
+    /**
+     * Restricts the popup position to not go below the scroll height or width of the container.
+     * Flips the position of the popup when there's not enough vertical space in the visible part of the container to render the popup.
+     */
+    normalizePopupPosition(pointerOffsetPosition) {
+        let top = pointerOffsetPosition.top + DEFAULT_POPUP_VERTICAL_MARGIN;
+        const containerClientBottom = this.container.clientHeight + this.container.scrollTop;
+        const popupHeight = this.dragPopup.popupElement.querySelector('.k-tooltip').clientHeight;
+        const enoughSpaceToRender = top < containerClientBottom - popupHeight;
+        // flip the popup above the pointer if there's not enough space in the bottom of the container
+        if (!enoughSpaceToRender) {
+            // margin * 2 to account for the already applied margin
+            top -= popupHeight + (DEFAULT_POPUP_VERTICAL_MARGIN * 2);
+        }
+        // center the popup horizontally according to the pointer position
+        const popupWidth = this.dragPopup.popupElement.querySelector('.k-tooltip').clientWidth;
+        const left = pointerOffsetPosition.left - popupWidth / 2;
+        // don't allow the popup to be cut out of the viewport
+        const minLeftTop = 0;
+        // restrict the popup from being positioned beyond or before the available scrollable space
+        return {
+            left: fitToRange(left, minLeftTop, this.container.scrollWidth - popupWidth),
+            top: fitToRange(top, minLeftTop, this.container.scrollHeight - popupHeight)
+        };
+    }
+};
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean)
+], DependencyDragCreateDirective.prototype, "displayValidationTooltip", void 0);
+DependencyDragCreateDirective = tslib_1.__decorate([
+    Directive({
+        selector: '[kendoGanttDependencyDragCreate]'
+    }),
+    tslib_1.__metadata("design:paramtypes", [GanttComponent,
+        NgZone,
+        Renderer2,
+        MappingService,
+        PopupService,
+        TimelineScrollService])
+], DependencyDragCreateDirective);
+export { DependencyDragCreateDirective };