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

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

@@ -1,47 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* 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

@@ -1,20 +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 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/scroll-sync.service.d.ts

@@ -1,30 +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 { NgZone, OnDestroy } from '@angular/core';
-import { Subject } from 'rxjs';
-declare type ScrollSyncEvent = {
-    scrollLeft?: number;
-    scrollTop?: number;
-    sourceType: string;
-};
-declare type SourceType = 'treelist' | 'header' | 'timeline';
-/**
- * @hidden
- */
-export declare class ScrollSyncService implements OnDestroy {
-    private ngZone;
-    changes: Subject<ScrollSyncEvent>;
-    private elements;
-    private subscriptions;
-    private syncingTimeline;
-    private syncingTreeList;
-    constructor(ngZone: NgZone);
-    registerElement(el: any, sourceType: SourceType): void;
-    ngOnDestroy(): void;
-    syncScrollTop(sourceType: SourceType, targetType: SourceType): void;
-    resetTimelineScrollLeft(): void;
-    private scroll;
-}
-export {};

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

@@ -1,80 +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 { Injectable, NgZone } from '@angular/core';
-import { Subscription, Subject, fromEvent } from 'rxjs';
-import { distinctUntilChanged, map, take } from 'rxjs/operators';
-/**
- * @hidden
- */
-let ScrollSyncService = class ScrollSyncService {
-    constructor(ngZone) {
-        this.ngZone = ngZone;
-        this.changes = new Subject();
-        this.elements = [];
-        this.subscriptions = new Subscription();
-        this.subscriptions.add(this.changes.subscribe(args => {
-            this.scroll(args);
-        }));
-    }
-    registerElement(el, sourceType) {
-        this.elements.push({ element: el, sourceType });
-        if (sourceType === "timeline" || sourceType === "treelist") {
-            this.ngZone.runOutsideAngular(() => {
-                const obs = fromEvent(el, 'scroll').pipe(map(({ target: { scrollTop, scrollLeft } }) => ({
-                    scrollTop,
-                    scrollLeft,
-                    sourceType
-                })));
-                const comparisonFn = sourceType === 'timeline' ?
-                    (x, y) => (x.scrollTop === y.scrollTop) && (x.scrollLeft === y.scrollLeft) :
-                    (x, y) => (x.scrollTop === y.scrollTop);
-                this.subscriptions.add(obs.pipe(distinctUntilChanged(comparisonFn))
-                    .subscribe((event) => this.changes.next(event)));
-            });
-        }
-    }
-    ngOnDestroy() {
-        this.subscriptions.unsubscribe();
-        this.elements = null;
-    }
-    syncScrollTop(sourceType, targetType) {
-        const source = this.elements.find(element => element.sourceType === sourceType);
-        const target = this.elements.find(element => element.sourceType === targetType);
-        // Need to wait for the splitter pane's content to be rendered
-        this.ngZone.onStable.pipe(take(1)).subscribe(() => target.element.scrollTop = source.element.scrollTop);
-    }
-    resetTimelineScrollLeft() {
-        const source = this.elements.find(element => element.sourceType === 'timeline');
-        source.element.scrollLeft = 0;
-    }
-    scroll({ scrollTop, scrollLeft, sourceType }) {
-        this.ngZone.runOutsideAngular(() => {
-            if (sourceType === 'timeline') {
-                const header = this.elements.find(element => element.sourceType === 'header').element;
-                header.scrollLeft = scrollLeft;
-                if (!this.syncingTimeline) {
-                    this.syncingTreeList = true;
-                    const treelist = this.elements.find(element => element.sourceType === 'treelist').element;
-                    treelist.scrollTop = scrollTop;
-                }
-                this.syncingTimeline = false;
-            }
-            if (sourceType === 'treelist') {
-                if (!this.syncingTreeList) {
-                    this.syncingTimeline = true;
-                    const timeline = this.elements.find(element => element.sourceType === 'timeline').element;
-                    timeline.scrollTop = scrollTop;
-                }
-                this.syncingTreeList = false;
-            }
-        });
-    }
-};
-ScrollSyncService = tslib_1.__decorate([
-    Injectable(),
-    tslib_1.__metadata("design:paramtypes", [NgZone])
-], ScrollSyncService);
-export { ScrollSyncService };

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

@@ -1,24 +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 { 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

@@ -1,78 +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, 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

@@ -1,20 +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 { 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

@@ -1,44 +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 { 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

@@ -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
-*-------------------------------------------------------------------------------------------*/
-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

@@ -1,80 +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 { 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/selection/selectable.directive.d.ts

@@ -1,42 +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 { OnDestroy, EventEmitter } from '@angular/core';
-import { GanttComponent } from '../gantt.component';
-/**
- * A directive which handles the [`selectionChange`]({% slug api_gantt_ganttcomponent %}#toc-selectionchange) event of the Gantt
- * ([see example]({% slug selection_gantt %}#toc-built-in-directive))
- */
-export declare class SelectableDirective implements OnDestroy {
-    private gantt;
-    /**
-     * @hidden
-     */
-    selectable: boolean;
-    /**
-     * Sets the selected keys.
-     */
-    selectedKeys: any[];
-    /**
-     * Fires when the selected keys are changed.
-     */
-    selectedKeysChange: EventEmitter<any[]>;
-    /**
-     * The field name or a function that specifies the data item unique key identifier.
-     * By default, the string field `id` is used.
-     */
-    itemKey: string | ((dataItem: any) => any);
-    private readonly keyGetter;
-    private selectionSubscription;
-    private state;
-    private lastChange;
-    private _keyGetter;
-    constructor(gantt: GanttComponent);
-    ngOnDestroy(): void;
-    private isSelected;
-    private selectionChange;
-    private emitSelectedItemsChange;
-    private subscribeSelection;
-    private unsubscribeSelection;
-}

package/dist/es2015/selection/selectable.directive.js

@@ -1,122 +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, Output, EventEmitter } from '@angular/core';
-import { getter } from '@progress/kendo-common';
-import { GanttComponent } from '../gantt.component';
-import { isPresent, isString } from '../utils';
-/**
- * A directive which handles the [`selectionChange`]({% slug api_gantt_ganttcomponent %}#toc-selectionchange) event of the Gantt
- * ([see example]({% slug selection_gantt %}#toc-built-in-directive))
- */
-let SelectableDirective = class SelectableDirective {
-    constructor(gantt) {
-        this.gantt = gantt;
-        /**
-         * Fires when the selected keys are changed.
-         */
-        this.selectedKeysChange = new EventEmitter();
-        this.state = new Set();
-        this.isSelected = this.isSelected.bind(this);
-        this.selectionChange = this.selectionChange.bind(this);
-        this.selectable = true;
-    }
-    /**
-     * @hidden
-     */
-    set selectable(value) {
-        if (value) {
-            this.gantt.isSelected = this.isSelected;
-            this.subscribeSelection();
-        }
-        else {
-            this.gantt.isSelected = () => false;
-            this.unsubscribeSelection();
-        }
-        this.gantt.selectable = value;
-        this.gantt.updateView();
-    }
-    /**
-     * Sets the selected keys.
-     */
-    set selectedKeys(value) {
-        if (isPresent(value) && value === this.lastChange) {
-            return;
-        }
-        // prevent multiple items displayed as selected as multiple selection still not supported fully
-        const keys = (value || []).slice(0, 1);
-        this.state = new Set(keys);
-        this.gantt.updateView();
-    }
-    /**
-     * The field name or a function that specifies the data item unique key identifier.
-     * By default, the string field `id` is used.
-     */
-    set itemKey(value) {
-        if (isString(value)) {
-            this._keyGetter = getter(value);
-        }
-        else {
-            this._keyGetter = value;
-        }
-    }
-    get keyGetter() {
-        return this._keyGetter || this.gantt.idGetter;
-    }
-    ngOnDestroy() {
-        this.unsubscribeSelection();
-    }
-    isSelected(dataItem) {
-        return this.state.has(this.keyGetter(dataItem));
-    }
-    selectionChange({ action, items }) {
-        this.state.clear();
-        if (action === 'select') {
-            items.forEach(item => this.state.add(this.keyGetter(item)));
-        }
-        this.emitSelectedItemsChange();
-    }
-    emitSelectedItemsChange() {
-        this.lastChange = Array.from(this.state);
-        this.selectedKeysChange.emit(this.lastChange);
-    }
-    subscribeSelection() {
-        this.unsubscribeSelection();
-        this.selectionSubscription = this.gantt.selectionChange.subscribe(this.selectionChange);
-    }
-    unsubscribeSelection() {
-        if (this.selectionSubscription) {
-            this.selectionSubscription.unsubscribe();
-            this.selectionSubscription = null;
-        }
-    }
-};
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Boolean),
-    tslib_1.__metadata("design:paramtypes", [Boolean])
-], SelectableDirective.prototype, "selectable", null);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Array),
-    tslib_1.__metadata("design:paramtypes", [Array])
-], SelectableDirective.prototype, "selectedKeys", null);
-tslib_1.__decorate([
-    Output(),
-    tslib_1.__metadata("design:type", EventEmitter)
-], SelectableDirective.prototype, "selectedKeysChange", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Object),
-    tslib_1.__metadata("design:paramtypes", [Object])
-], SelectableDirective.prototype, "itemKey", null);
-SelectableDirective = tslib_1.__decorate([
-    Directive({
-        exportAs: 'kendoGanttSelectable',
-        selector: '[kendoGanttSelectable]'
-    }),
-    tslib_1.__metadata("design:paramtypes", [GanttComponent])
-], SelectableDirective);
-export { SelectableDirective };

package/dist/es2015/selection/selection-change-event.d.ts

@@ -1,25 +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 { GanttComponent } from '../gantt.component';
-/**
- * Arguments for the Gantt [`selectionChange`]({% slug api_gantt_ganttcomponent %}#toc-selectionchange) event.
- */
-export interface SelectionChangeEvent {
-    /**
-     * Specifies how was the selection changed.
-     *
-     * - `select` - All specified `items` should be selected, all other persisted ones should be removed.
-     * - `remove` - Only the specified `items` should be removed, all others should be left untouched.
-     */
-    action: 'select' | 'remove';
-    /**
-     * Specifies which items were changed.
-     */
-    items: any[];
-    /**
-     * The Gantt component that triggered the event.
-     */
-    sender: GanttComponent;
-}

package/dist/es2015/selection/selection-change-event.js

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