@progress/kendo-angular-gantt 1.0.1 → 2.0.0-next.202204011501

package/dist/es2015/dependencies/utils.js

@@ -1,199 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { DependencyType } from '../models/dependency-type.enum';
-/**
- * @hidden
- *
- * Gets the offset (top and left values) relative to a target element.
- */
-export const getOffsetRelativeToParent = (element, targetParent) => {
-    let offset = {
-        top: 0,
-        left: 0
-    };
-    if (!targetParent.contains(element)) {
-        return offset;
-    }
-    let offsetParent = element;
-    while (offsetParent && offsetParent !== targetParent) {
-        offset.top += offsetParent.offsetTop;
-        offset.left += offsetParent.offsetLeft;
-        offsetParent = offsetParent.offsetParent;
-    }
-    return offset;
-};
-/**
- * @hidden
- */
-export const getElementRect = (element, relativeContainer) => {
-    const { top, left } = getOffsetRelativeToParent(element, relativeContainer);
-    return {
-        top: top + element.offsetHeight / 2,
-        left: left,
-        right: left + element.offsetWidth
-    };
-};
-/**
- * @hidden
- */
-export const dependencyCoordinates = (from, to, rowHeight, type, minDistanceBeforeTurn, arrowSize) => {
-    const points = [];
-    const minTurnHeight = Math.floor(rowHeight / 2);
-    const drawingDown = from.top < to.top;
-    let top, left;
-    // FF and SS are composed of 4 connected polyline points (not counting the arrow)
-    /*
-        [[[]]]-       -[[[]]]
-              |       |
-        [[[]]]-       -[[[]]]
-     */
-    if (type === DependencyType.FF || type === DependencyType.SS) {
-        // polyline start from first task
-        const dir = type === DependencyType.SS ? 'left' : 'right';
-        top = from.top;
-        left = from[dir];
-        points.push({ top, left });
-        // first turn point
-        left = Math[dir === 'left' ? 'min' : 'max'](from[dir], to[dir]);
-        left = dir === 'left' ? left - minDistanceBeforeTurn : left + minDistanceBeforeTurn;
-        points.push({ top, left });
-        // second turn point
-        top = to.top;
-        points.push({ top, left });
-        // second task reached
-        left = dir === 'left' ? to[dir] - arrowSize : to[dir] + arrowSize;
-        points.push({ top, left });
-        // arrow pointing to the second task
-        points.push(...getArrow(top, left, dir !== 'left', arrowSize));
-    }
-    else {
-        // FS and SF are composed of 4 or 6 connected polyline points (not counting the arrow), depending on the position of the tasks
-        /*
-            [[[]]]-               [[[]]]-
-                  |                     |
-                  -[[[]]]           -----
-                                    |
-                                    -[[[]]]
-        */
-        const startDir = type === DependencyType.SF ? 'left' : 'right';
-        const endDir = type === DependencyType.SF ? 'right' : 'left';
-        const additionalTurn = type === DependencyType.SF
-            ? from[startDir] - minDistanceBeforeTurn * 2 < to[endDir]
-            : from[startDir] + minDistanceBeforeTurn * 2 > to[endDir];
-        // polyline start from first task
-        top = from.top;
-        left = from[startDir];
-        points.push({ top, left });
-        // first turn point
-        left = startDir === 'left'
-            ? left - minDistanceBeforeTurn
-            : left + minDistanceBeforeTurn;
-        points.push({ top, left });
-        // if second task start is before the first task end in FS
-        // if second task end is after the first task start in SF
-        if (additionalTurn) {
-            // additional turn start
-            top = drawingDown
-                ? top + minTurnHeight
-                : top - minTurnHeight;
-            points.push({ top, left });
-            // additional turn end
-            left = startDir === 'left'
-                ? to[endDir] + minDistanceBeforeTurn
-                : to[endDir] - minDistanceBeforeTurn;
-            points.push({ top, left });
-        }
-        // second task level reached
-        top = to.top;
-        points.push({ top, left });
-        // second task element reached
-        left = endDir === 'left' ? to[endDir] - arrowSize : to[endDir] + arrowSize;
-        points.push({ top, left });
-        // arrow pointing to the second task
-        points.push(...getArrow(top, left, endDir !== 'left', arrowSize));
-    }
-    return points;
-};
-const getArrow = (top, left, isArrowWest, arrowSize) => {
-    const points = isArrowWest
-        ? getArrowWest(top, left, arrowSize)
-        : getArrowEast(top, left, arrowSize);
-    return points;
-};
-const ɵ0 = getArrow;
-const getArrowWest = (top, left, arrowSize) => {
-    const points = [];
-    points.push({
-        top: top - arrowSize / 2,
-        left
-    });
-    points.push({
-        top,
-        left: left - arrowSize + 1
-    });
-    points.push({
-        top: top + arrowSize / 2,
-        left
-    });
-    points.push({
-        top,
-        left
-    });
-    return points;
-};
-const ɵ1 = getArrowWest;
-const getArrowEast = (top, left, arrowSize) => {
-    const points = [];
-    points.push({
-        top: top + arrowSize / 2,
-        left
-    });
-    points.push({
-        top,
-        left: left + arrowSize - 1
-    });
-    points.push({
-        top: top - arrowSize / 2,
-        left
-    });
-    points.push({
-        top,
-        left
-    });
-    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

@@ -1,72 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { 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

@@ -1,324 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { 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 };

package/dist/es2015/dragging/drag-validation-tooltip.component.d.ts

@@ -1,29 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export declare class DragValidationTooltipComponent {
-    /**
-     * Sets the status class of the attempted operation.
-     * Note that the status will be ignored and the `neutral` status class will be rendered,
-     * if the any of the fromTaskName or toTaskName are not populated.
-     */
-    isValid: boolean;
-    /**
-     * The name of the task where the dragging has started.
-     */
-    fromTaskName: string;
-    /**
-     * The name of the task which is being currently hovered.
-     */
-    toTaskName: string;
-    /**
-     * Specifies whether the valid/invalid validity classes should be rendered or not.
-     * Prevents the validity classes being rendered when e.g. the same task is hovered during drag,
-     * or when a task body is hovered and not an actual drag clue.
-     */
-    showValidityStatus: boolean;
-}