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

package/dist/es2015/rendering/gantt-task-base.js

@@ -38,29 +38,18 @@ export class GanttTaskBase {
     get slotWidth() {
         return this.viewService.options.slotWidth;
     }
-    ngOnChanges(changes) {
-        if (isPresent(changes.dataItem)) {
-            if (isPresent(changes.dataItem.previousValue)) {
-                this.dependencyDomService.unregisterTask(changes.dataItem.previousValue);
-            }
-            this.dependencyDomService.registerTask(this.dataItem, this.taskElement.nativeElement);
-        }
-        else if (isPresent(changes.activeView)) {
-            this.dependencyDomService.notifyChanges();
-        }
-    }
-    ngOnDestroy() {
-        if (isPresent(this.dataItem)) {
-            this.dependencyDomService.unregisterTask(this.dataItem);
-        }
-        this.viewChangesSubscription.unsubscribe();
-    }
     get taskWidth() {
         const itemDuration = this.mapper.extractFromTask(this.dataItem, 'end') - this.mapper.extractFromTask(this.dataItem, 'start');
         const durationInSlotUnits = itemDuration / this.slotUnitDuration;
         const width = durationInSlotUnits * this.slotWidth;
         return width;
     }
+    /**
+     * The `left` style prop has to be applied to the host element (.k-task-wrap), as the drag clue elements are displayed on .k-task-wrap hover.
+     * Applying the `left` offset to the inner .k-task element leaves the .k-task-wrap element rendered with an offset of 0 somewhere on the left
+     * and hovering just the .k-task element doesn't expose the drag clues.
+     * Additionally, positioning the entire container takes care of positioning the hints as well.
+     */
     get taskOffset() {
         const timeAfterViewStart = this.mapper.extractFromTask(this.dataItem, 'start') - this.viewService.viewStart;
         const offsetInSlotUnits = timeAfterViewStart / this.slotUnitDuration;
@@ -72,6 +61,23 @@ export class GanttTaskBase {
         // fall-back to 0 in case no completionRatio is provided
         return isNumber(overlayWidth) ? overlayWidth : 0;
     }
+    ngOnChanges(changes) {
+        if (isPresent(changes.dataItem)) {
+            if (isPresent(changes.dataItem.previousValue)) {
+                this.dependencyDomService.unregisterTask(changes.dataItem.previousValue);
+            }
+            this.dependencyDomService.registerTask(this.dataItem, this.taskElement.nativeElement);
+        }
+        else if (isPresent(changes.activeView)) {
+            this.dependencyDomService.notifyChanges();
+        }
+    }
+    ngOnDestroy() {
+        if (isPresent(this.dataItem)) {
+            this.dependencyDomService.unregisterTask(this.dataItem);
+        }
+        this.viewChangesSubscription.unsubscribe();
+    }
 }
 tslib_1.__decorate([
     HostBinding('class.k-task-wrap'),
@@ -87,8 +93,8 @@ tslib_1.__decorate([
 ], GanttTaskBase.prototype, "dataItem", void 0);
 tslib_1.__decorate([
     Input(),
-    tslib_1.__metadata("design:type", Number)
-], GanttTaskBase.prototype, "index", void 0);
+    tslib_1.__metadata("design:type", Boolean)
+], GanttTaskBase.prototype, "renderDependencyDragClues", void 0);
 tslib_1.__decorate([
     Input(),
     tslib_1.__metadata("design:type", Function)
@@ -101,3 +107,8 @@ tslib_1.__decorate([
     Input(),
     tslib_1.__metadata("design:type", Function)
 ], GanttTaskBase.prototype, "taskClass", void 0);
+tslib_1.__decorate([
+    HostBinding('style.left.px'),
+    tslib_1.__metadata("design:type", Number),
+    tslib_1.__metadata("design:paramtypes", [])
+], GanttTaskBase.prototype, "taskOffset", null);

package/dist/es2015/rendering/gantt-task.component.d.ts

@@ -14,8 +14,9 @@ import { EditService } from '../editing/edit.service';
  */
 export declare class GanttTaskComponent extends GanttTaskBase {
     private editService;
+    touchEnabled: boolean;
     taskContentTemplate: TemplateRef<any>;
     taskTemplate: TemplateRef<any>;
-    constructor(mapper: MappingService, timelineViewService: TimelineViewService, dependencyDomService: DependencyDomService, optionChangesService: OptionChangesService, cdr: ChangeDetectorRef, editService: EditService);
+    constructor(editService: EditService, touchEnabled: boolean, mapper: MappingService, timelineViewService: TimelineViewService, dependencyDomService: DependencyDomService, optionChangesService: OptionChangesService, cdr: ChangeDetectorRef);
     onTaskDelete(): void;
 }

package/dist/es2015/rendering/gantt-task.component.js

@@ -4,8 +4,9 @@
 *-------------------------------------------------------------------------------------------*/
 import * as tslib_1 from "tslib";
 var GanttTaskComponent_1;
-import { ChangeDetectorRef, Component, forwardRef, Input, TemplateRef } from '@angular/core';
+import { ChangeDetectorRef, Component, forwardRef, Inject, Input, TemplateRef } from '@angular/core';
 import { MappingService } from '../common/mapping.service';
+import { TOUCH_ENABLED } from '../common/touch-enabled';
 import { DependencyDomService } from '../dependencies/dependency-dom.service';
 import { OptionChangesService } from '../common/option-changes.service';
 import { TimelineViewService } from './../timeline/timeline-view.service';
@@ -15,9 +16,10 @@ import { EditService } from '../editing/edit.service';
  * @hidden
  */
 let GanttTaskComponent = GanttTaskComponent_1 = class GanttTaskComponent extends GanttTaskBase {
-    constructor(mapper, timelineViewService, dependencyDomService, optionChangesService, cdr, editService) {
+    constructor(editService, touchEnabled, mapper, timelineViewService, dependencyDomService, optionChangesService, cdr) {
         super(mapper, timelineViewService, dependencyDomService, optionChangesService, cdr);
         this.editService = editService;
+        this.touchEnabled = touchEnabled;
     }
     onTaskDelete() {
         this.editService.dataItem = this.dataItem;
@@ -47,9 +49,7 @@ GanttTaskComponent = GanttTaskComponent_1 = tslib_1.__decorate([
             class="k-task k-task-single"
             [ngClass]="taskClass(dataItem)"
             [style.width.px]="taskWidth"
-            [style.left.px]="taskOffset"
             [attr.title]="mapper.extractFromTask(dataItem, 'title')"
-            [attr.data-task-index]="index"
             [class.k-state-selected]="isSelected(dataItem)"
         >
             <ng-container *ngIf="!taskTemplate">
@@ -89,13 +89,25 @@ GanttTaskComponent = GanttTaskComponent_1 = tslib_1.__decorate([
             >
             </ng-template>
         </div>
+        <ng-container *ngIf="renderDependencyDragClues">
+            <div
+                class="k-task-dot k-task-start k-touch-action-none"
+                [class.k-display-block]="touchEnabled"
+            >
+            </div>
+            <div
+                class="k-task-dot k-task-end k-touch-action-none"
+                [class.k-display-block]="touchEnabled"
+            >
+            </div>
+        </ng-container>
     `
     }),
-    tslib_1.__metadata("design:paramtypes", [MappingService,
+    tslib_1.__param(1, Inject(TOUCH_ENABLED)),
+    tslib_1.__metadata("design:paramtypes", [EditService, Boolean, MappingService,
         TimelineViewService,
         DependencyDomService,
         OptionChangesService,
-        ChangeDetectorRef,
-        EditService])
+        ChangeDetectorRef])
 ], GanttTaskComponent);
 export { GanttTaskComponent };

package/dist/es2015/rendering/gantt-tasks-table-body.component.d.ts

@@ -22,6 +22,7 @@ export declare class GanttTasksTableBodyComponent {
     taskClass: TaskClassFn;
     hasChildren: (item: object) => boolean;
     isTaskSelected: (item: object) => boolean;
+    renderDependencyDragClues: boolean;
     constructor(dependencyDomService: DependencyDomService, mapper: MappingService);
     isMileStone(task: any): boolean;
 }

package/dist/es2015/rendering/gantt-tasks-table-body.component.js

@@ -64,6 +64,10 @@ tslib_1.__decorate([
     Input(),
     tslib_1.__metadata("design:type", Function)
 ], GanttTasksTableBodyComponent.prototype, "isTaskSelected", void 0);
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Boolean)
+], GanttTasksTableBodyComponent.prototype, "renderDependencyDragClues", void 0);
 GanttTasksTableBodyComponent = tslib_1.__decorate([
     Component({
         selector: '[kendoGanttTasksTableBody]',
@@ -76,7 +80,8 @@ GanttTasksTableBodyComponent = tslib_1.__decorate([
                     [activeView]="activeView"
                     [taskClass]="taskClass"
                     [isSelected]="isTaskSelected"
-                    [index]="index"
+                    [attr.data-task-index]="index"
+                    [renderDependencyDragClues]="renderDependencyDragClues"
                 >
                 </kendo-gantt-milestone-task>
                 <ng-template #task>
@@ -87,7 +92,8 @@ GanttTasksTableBodyComponent = tslib_1.__decorate([
                         [activeView]="activeView"
                         [taskClass]="taskClass"
                         [isSelected]="isTaskSelected"
-                        [index]="index"
+                        [attr.data-task-index]="index"
+                        [renderDependencyDragClues]="renderDependencyDragClues"
                     >
                     </kendo-gantt-summary-task>
                     <kendo-gantt-task
@@ -98,7 +104,8 @@ GanttTasksTableBodyComponent = tslib_1.__decorate([
                         [activeView]="activeView"
                         [taskClass]="taskClass"
                         [isSelected]="isTaskSelected"
-                        [index]="index"
+                        [attr.data-task-index]="index"
+                        [renderDependencyDragClues]="renderDependencyDragClues"
                     >
                     </kendo-gantt-task>
                 </ng-template>

package/dist/es2015/scrolling/drag-scroll-settings.d.ts

@@ -0,0 +1,47 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * Specifies the settings for auto-scrolling during drag editing operations.
+ */
+export interface DragScrollSettings {
+    /**
+     * Specifies whether auto-scrolling during drag editing operations is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Specifies the scrolling step in pixels.
+     *
+     * @default: 3
+     */
+    step?: number;
+    /**
+     * Specifies the scrolling interval in milliseconds.
+     *
+     * @default: 1
+     */
+    interval?: number;
+    /**
+     * Specifies the threshold (in pixels) at each end of the scrollable container which when reached will trigger scrolling.
+     *
+     * @default: 10
+     */
+    threshold?: number;
+}
+/**
+ * @hidden
+ */
+export declare enum ScrollDirection {
+    Backwards = -1,
+    Forward = 1
+}
+/**
+ * @hidden
+ */
+export declare enum ScrollAxis {
+    Vertical = "scrollTop",
+    Horizontal = "scrollLeft"
+}

package/dist/es2015/scrolling/drag-scroll-settings.js

@@ -0,0 +1,20 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection[ScrollDirection["Backwards"] = -1] = "Backwards";
+    ScrollDirection[ScrollDirection["Forward"] = 1] = "Forward";
+})(ScrollDirection || (ScrollDirection = {}));
+/**
+ * @hidden
+ */
+export var ScrollAxis;
+(function (ScrollAxis) {
+    ScrollAxis["Vertical"] = "scrollTop";
+    ScrollAxis["Horizontal"] = "scrollLeft";
+})(ScrollAxis || (ScrollAxis = {}));

package/dist/es2015/scrolling/timeline-scroll.directive.d.ts

@@ -0,0 +1,24 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ElementRef, NgZone } from '@angular/core';
+import { DragScrollSettings } from './drag-scroll-settings';
+import { TimelineScrollService } from './timeline-scroll.service';
+/**
+ * @hidden
+ */
+export declare class TimelineScrollableDirective {
+    private timelineScrollableContainer;
+    private scrollService;
+    private zone;
+    scrollSettings: DragScrollSettings;
+    private subscriptions;
+    private verticalScrollInterval;
+    private horizontalScrollInterval;
+    constructor(timelineScrollableContainer: ElementRef<Element>, scrollService: TimelineScrollService, zone: NgZone);
+    ngOnDestroy(): void;
+    private scrollHorizontallyTo;
+    private scrollVerticallyTo;
+    private cancelScroll;
+}

package/dist/es2015/scrolling/timeline-scroll.directive.js

@@ -0,0 +1,78 @@
+/**-----------------------------------------------------------------------------------------
+* 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, ElementRef, Input, NgZone } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { isPresent } from '../utils';
+import { ScrollAxis, ScrollDirection } from './drag-scroll-settings';
+import { TimelineScrollService } from './timeline-scroll.service';
+import { getViewportBoundaries, scrollElement } from './utils';
+/**
+ * @hidden
+ */
+let TimelineScrollableDirective = class TimelineScrollableDirective {
+    constructor(timelineScrollableContainer, scrollService, zone) {
+        this.timelineScrollableContainer = timelineScrollableContainer;
+        this.scrollService = scrollService;
+        this.zone = zone;
+        this.subscriptions = new Subscription();
+        this.subscriptions.add(this.scrollService.horizontalScroll
+            .subscribe(this.scrollHorizontallyTo.bind(this)));
+        this.subscriptions.add(this.scrollService.verticalScroll
+            .subscribe(this.scrollVerticallyTo.bind(this)));
+        this.subscriptions.add(this.scrollService.scrollCancel
+            .subscribe(this.cancelScroll.bind(this)));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    scrollHorizontallyTo(left) {
+        this.zone.runOutsideAngular(() => {
+            const container = this.timelineScrollableContainer.nativeElement;
+            const visibleBoundaries = getViewportBoundaries(container);
+            if (left < visibleBoundaries.left + this.scrollSettings.threshold) {
+                this.horizontalScrollInterval = setInterval(() => scrollElement(container, this.scrollSettings.step, ScrollDirection.Backwards, ScrollAxis.Horizontal), this.scrollSettings.interval);
+            }
+            else if (left > visibleBoundaries.right - this.scrollSettings.threshold) {
+                this.horizontalScrollInterval = setInterval(() => scrollElement(container, this.scrollSettings.step, ScrollDirection.Forward, ScrollAxis.Horizontal), this.scrollSettings.interval);
+            }
+        });
+    }
+    scrollVerticallyTo(top) {
+        this.zone.runOutsideAngular(() => {
+            const container = this.timelineScrollableContainer.nativeElement;
+            const visibleBoundaries = getViewportBoundaries(container);
+            if (top < visibleBoundaries.top + this.scrollSettings.threshold) {
+                this.verticalScrollInterval = setInterval(() => scrollElement(container, this.scrollSettings.step, ScrollDirection.Backwards, ScrollAxis.Vertical), this.scrollSettings.interval);
+            }
+            else if (top > visibleBoundaries.bottom - this.scrollSettings.threshold) {
+                this.verticalScrollInterval = setInterval(() => scrollElement(container, this.scrollSettings.step, ScrollDirection.Forward, ScrollAxis.Vertical), this.scrollSettings.interval);
+            }
+        });
+    }
+    cancelScroll() {
+        if (isPresent(this.verticalScrollInterval)) {
+            clearInterval(this.verticalScrollInterval);
+            this.verticalScrollInterval = null;
+        }
+        if (isPresent(this.horizontalScrollInterval)) {
+            clearInterval(this.horizontalScrollInterval);
+            this.horizontalScrollInterval = null;
+        }
+    }
+};
+tslib_1.__decorate([
+    Input(),
+    tslib_1.__metadata("design:type", Object)
+], TimelineScrollableDirective.prototype, "scrollSettings", void 0);
+TimelineScrollableDirective = tslib_1.__decorate([
+    Directive({
+        selector: '[kendoGanttTimelineScrollable]'
+    }),
+    tslib_1.__metadata("design:paramtypes", [ElementRef,
+        TimelineScrollService,
+        NgZone])
+], TimelineScrollableDirective);
+export { TimelineScrollableDirective };

package/dist/es2015/scrolling/timeline-scroll.service.d.ts

@@ -0,0 +1,20 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Subject } from 'rxjs';
+/**
+ * @hidden
+ *
+ * Notifies the timeline-scroll.directive to scroll into view to requested coordinates.
+ * The scrolling is performed based on client (viewport) coordinates.
+ */
+export declare class TimelineScrollService {
+    readonly horizontalScroll: Subject<number>;
+    readonly verticalScroll: Subject<number>;
+    readonly scrollCancel: Subject<any>;
+    ngOnDestroy(): void;
+    requestHorizontalScroll(clientTop: number): void;
+    requestVerticalScroll(clientLeft: number): void;
+    requestScrollCancel(): void;
+}

package/dist/es2015/scrolling/timeline-scroll.service.js

@@ -0,0 +1,44 @@
+/**-----------------------------------------------------------------------------------------
+* 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 { Subject } from 'rxjs';
+/**
+ * @hidden
+ *
+ * Notifies the timeline-scroll.directive to scroll into view to requested coordinates.
+ * The scrolling is performed based on client (viewport) coordinates.
+ */
+let TimelineScrollService = class TimelineScrollService {
+    /**
+     * @hidden
+     *
+     * Notifies the timeline-scroll.directive to scroll into view to requested coordinates.
+     * The scrolling is performed based on client (viewport) coordinates.
+     */
+    constructor() {
+        this.horizontalScroll = new Subject();
+        this.verticalScroll = new Subject();
+        this.scrollCancel = new Subject();
+    }
+    ngOnDestroy() {
+        this.horizontalScroll.complete();
+        this.verticalScroll.complete();
+        this.scrollCancel.complete();
+    }
+    requestHorizontalScroll(clientTop) {
+        this.horizontalScroll.next(clientTop);
+    }
+    requestVerticalScroll(clientLeft) {
+        this.verticalScroll.next(clientLeft);
+    }
+    requestScrollCancel() {
+        this.scrollCancel.next();
+    }
+};
+TimelineScrollService = tslib_1.__decorate([
+    Injectable()
+], TimelineScrollService);
+export { TimelineScrollService };

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

@@ -0,0 +1,29 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ScrollAxis, ScrollDirection } from './drag-scroll-settings';
+/**
+ * @hidden
+ *
+ * Scrolls the element in the given direction by the provided step in the provided scroll axis.
+ *
+ * If the targeted scroll incrementation doesn't yield any result due to device pixel ratio issues (https://github.com/dimitar-pechev/RenderingIndependentScrollOffsets#readme),
+ * increments the step with 1px and again attempts to change the scrollTop of the element, until the content is actually scrolled.
+ *
+ * Cuts the operation short after 20 unsuccessful attempts to prevent infinite loops in possible corner-case scenarios.
+ */
+export declare const scrollElement: (element: Element, step: number, direction: ScrollDirection, scrollAxis: ScrollAxis) => void;
+/**
+ * @hidden
+ *
+ * As client coordinates are not restricted to the range 0px - {viewportSize}px, but can have negative starting values or ending values greater than the viewport size,
+ * this function extracts the visible boundaries of the provided element - fall-backing to 0 when the top/left are below 0,
+ * and fall-backing to the actual visible size of the container for bottom/right.
+ */
+export declare const getViewportBoundaries: (element: Element) => {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};

package/dist/es2015/scrolling/utils.js

@@ -0,0 +1,80 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
+import { ScrollAxis, ScrollDirection } from './drag-scroll-settings';
+import { isPresent } from '../utils';
+/**
+ * @hidden
+ *
+ * Checks if the beginning of the scrollable element is reached (top/left).
+ * Floors the top value.
+ */
+const isUpperLimitReached = (element, axis) => Math.floor(element[axis]) <= 0;
+const ɵ0 = isUpperLimitReached;
+/**
+ * @hidden
+ *
+ * Checks if the end of the scrollable element is reached (bottom/right).
+ * Ceils the top value.
+ */
+const isBottomLimitReached = (element, axis) => {
+    const elementSize = axis === ScrollAxis.Horizontal ?
+        element.scrollWidth - element.clientWidth :
+        element.scrollHeight - element.clientHeight;
+    return Math.ceil(element[axis]) >= elementSize;
+};
+const ɵ1 = isBottomLimitReached;
+/**
+ * @hidden
+ *
+ * Scrolls the element in the given direction by the provided step in the provided scroll axis.
+ *
+ * If the targeted scroll incrementation doesn't yield any result due to device pixel ratio issues (https://github.com/dimitar-pechev/RenderingIndependentScrollOffsets#readme),
+ * increments the step with 1px and again attempts to change the scrollTop of the element, until the content is actually scrolled.
+ *
+ * Cuts the operation short after 20 unsuccessful attempts to prevent infinite loops in possible corner-case scenarios.
+ */
+export const scrollElement = (element, step, direction, scrollAxis) => {
+    if (!(isPresent(element) && isDocumentAvailable())) {
+        return;
+    }
+    const initialScrollPosition = element[scrollAxis];
+    let currentStep = step;
+    let iterations = 0;
+    while (initialScrollPosition === element[scrollAxis] &&
+        !(direction === ScrollDirection.Backwards && isUpperLimitReached(element, scrollAxis)) &&
+        !(direction === ScrollDirection.Forward && isBottomLimitReached(element, scrollAxis)) &&
+        iterations < 20 // cut the operation short in 20 attempts - in case of a wild corner case
+    ) {
+        element[scrollAxis] += (currentStep * direction);
+        // try with a larger step if the current one doesn't update the scroll position successfully
+        currentStep += 1;
+        iterations += 1;
+    }
+};
+/**
+ * @hidden
+ *
+ * As client coordinates are not restricted to the range 0px - {viewportSize}px, but can have negative starting values or ending values greater than the viewport size,
+ * this function extracts the visible boundaries of the provided element - fall-backing to 0 when the top/left are below 0,
+ * and fall-backing to the actual visible size of the container for bottom/right.
+ */
+export const getViewportBoundaries = (element) => {
+    const elementRect = element.getBoundingClientRect();
+    // if the beginning of the scrollable container is above/before the current viewport, fall-back to 0
+    const topLimit = Math.max(elementRect.top, 0);
+    const leftLimit = Math.max(elementRect.left, 0);
+    // if the end of the scrollable container is beneath/after the current viewport, fall-back to its client height
+    // add the distance from the start of the viewport to the beginning of the container to ensure scrolling bottom begins when the actual end of the container is reached
+    const bottomLimit = topLimit + Math.min(elementRect.bottom, element.clientHeight);
+    const rightLimit = leftLimit + Math.min(elementRect.right, element.clientWidth);
+    return {
+        top: topLimit,
+        bottom: bottomLimit,
+        left: leftLimit,
+        right: rightLimit
+    };
+};
+export { ɵ0, ɵ1 };

package/dist/es2015/timeline/gantt-timeline.component.d.ts

@@ -2,10 +2,10 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import { AfterViewInit, ElementRef, NgZone, Renderer2, TemplateRef } from '@angular/core';
+import { AfterViewInit, ElementRef, EventEmitter, NgZone, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';
 import { ScrollSyncService } from '../scrolling/scroll-sync.service';
 import { DependencyDomService } from '../dependencies/dependency-dom.service';
-import { TimelineViewType, TaskClassFn } from '../models/models';
+import { TimelineViewType, TaskClassFn, DragScrollSettings } from '../models/models';
 /**
  * @hidden
  */
@@ -14,10 +14,24 @@ export declare class GanttTimelineComponent implements AfterViewInit {
     private dependencyDomService;
     private renderer;
     private zone;
+    /**
+     * Represents the scrollable container of the timeline content.
+     * Used externally by the DependencyDragCreateDirective.
+     */
     timelineContent: ElementRef<HTMLElement>;
     timelineColumns: ElementRef<HTMLElement>;
     timelineHeaderWrap: ElementRef<HTMLElement>;
     tasksContainer: ElementRef<HTMLElement>;
+    /**
+     * Represents the view container ref used for rendering the dependency drag popop.
+     * Used externally by the DependencyDragCreateDirective.
+     */
+    dragPopupContainer: ViewContainerRef;
+    /**
+     * Represents the polyline element used for rendering the dependency drag editing interaction.
+     * Used externally by the DependencyDragCreateDirective.
+     */
+    dependencyDragCreatePolyline: ElementRef<SVGPolylineElement>;
     hostClass: boolean;
     rows: any[];
     slots: any[];
@@ -29,8 +43,17 @@ export declare class GanttTimelineComponent implements AfterViewInit {
     summaryTaskTemplate: TemplateRef<any>;
     taskClass: TaskClassFn;
     isTaskSelected: (item: object) => boolean;
+    renderDependencyDragClues: boolean;
+    dragScrollSettings: DragScrollSettings;
     hasChildren: (item: object) => boolean;
     dependencies: any[];
+    timelineContainerPress: EventEmitter<any>;
+    timelineContainerDrag: EventEmitter<any>;
+    timelineContainerRelease: EventEmitter<any>;
+    /**
+     * Specifies whether the draggable will attach or detach its pointer event listeners.
+     */
+    readonly draggableEnabled: boolean;
     private subscriptions;
     constructor(scrollSyncService: ScrollSyncService, dependencyDomService: DependencyDomService, renderer: Renderer2, zone: NgZone);
     ngAfterViewInit(): void;