@progress/kendo-angular-dateinputs 6.0.4-dev.202203211102 → 7.0.0-dev.202204150726

package/dist/es/daterange/date-range-popup.component.js

@@ -1,403 +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 { Component, ContentChild, ContentChildren, ChangeDetectorRef, ElementRef, EventEmitter, TemplateRef, NgZone, Input, Output, ViewChild, ViewChildren, ViewContainerRef, Inject, QueryList, Optional } from '@angular/core';
-import { RTL } from '@progress/kendo-angular-l10n';
-import { PopupService } from '@progress/kendo-angular-popup';
-import { DateRangePopupTemplateDirective } from './date-range-popup-template.directive';
-import { DateRangeService } from './date-range.service';
-import { MultiViewCalendarComponent } from '../calendar/multiview-calendar.component';
-import { PreventableEvent } from '../preventable-event';
-import { isDocumentAvailable, guid, Keys, hasObservers } from '@progress/kendo-angular-common';
-import { Subscription, fromEvent, merge } from 'rxjs';
-import { filter, map } from 'rxjs/operators';
-import { isWindowAvailable } from '../util';
-import { isPresent } from '../common/utils';
-/**
- * Represents the Kendo UI DateRangePopup component for Angular.
- *
- * @example
- * ```ts
- * import { DateInputsModule, DateRangeService } from '@progress/kendo-angular-dateinputs';
- *
- * _@Component({
- * providers: [DateRangeService],
- * selector: 'my-app',
- * template: `
- *  <button #anchor (click)="popup.toggle()">Toggle</button>
- *  <kendo-daterange-popup [anchor]="anchor" #popup></kendo-daterange-popup>
- * `
- * })
- * export class AppComponent {
- * }
- * ```
- */
-var DateRangePopupComponent = /** @class */ (function () {
-    function DateRangePopupComponent(popupService, dateRangeService, ref, zone, rtl) {
-        this.popupService = popupService;
-        this.dateRangeService = dateRangeService;
-        this.ref = ref;
-        this.zone = zone;
-        this.rtl = rtl;
-        /**
-         * Controls the popup animation.
-         * By default, the opening and closing animations are enabled.
-         * For more information about controlling the popup animations,
-         * refer to the article on [animations]({% slug animations_popup %}).
-         */
-        this.animate = true;
-        /**
-         * Configures the collision behavior of the popup.
-         * For more information, refer to the article on
-         * [viewport boundary detection]({% slug viewportboundarydetection_popup %}).
-         */
-        this.collision = { horizontal: 'fit', vertical: 'flip' };
-        /**
-         * Fires each time the popup is about to open.
-         * This event is preventable. If you cancel the event, the popup will remain closed.
-         * For more information, refer to the section on
-         * [events]({% slug overview_datepicker %}#toc-events).
-         */
-        this.open = new EventEmitter();
-        /**
-         * Fires each time the popup is about to close.
-         * This event is preventable. If you cancel the event, the popup will remain open.
-         * For more information, refer to the section on
-         * [events]({% slug overview_datepicker %}#toc-events).
-         */
-        this.close = new EventEmitter();
-        /**
-         * Fires each time the calendar element is blurred.
-         */
-        this.onBlur = new EventEmitter(); //tslint:disable-line:no-output-rename
-        /**
-         * Fires each time the calendar element is focused.
-         */
-        this.onFocus = new EventEmitter(); //tslint:disable-line:no-output-rename
-        /**
-         * Fires each time the popup is closed either on `ESC` keypress or on leaving the viewport.
-         */
-        this.cancel = new EventEmitter();
-        /**
-         * @hidden
-         */
-        this.popupUID = guid();
-        this.calendarSubscriptions = new Subscription();
-        this.popupSubscriptions = new Subscription();
-        this.resolvedPromise = Promise.resolve();
-    }
-    Object.defineProperty(DateRangePopupComponent.prototype, "calendar", {
-        /**
-         * The active calendar that is visible in the popup.
-         *
-         * > When the popup is closed, the property returns `null`.
-         */
-        get: function () {
-            return this._calendar;
-        },
-        set: function (calendar) {
-            this._calendar = calendar;
-            this.subscribeFocusBlur(calendar);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DateRangePopupComponent.prototype, "isActive", {
-        /**
-         * Gets the active state of the component.
-         * When the opened calendar is active, returns `true`.
-         */
-        get: function () {
-            return this.calendar && this.calendar.isActive;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DateRangePopupComponent.prototype, "show", {
-        get: function () {
-            return this._show;
-        },
-        /**
-         * Gets or sets the visibility state of the component.
-         */
-        set: function (show) {
-            if (this._show === show) {
-                return;
-            }
-            var event = new PreventableEvent();
-            if (show) {
-                this.open.emit(event);
-            }
-            else {
-                this.close.emit(event);
-            }
-            if (event.isDefaultPrevented()) {
-                return;
-            }
-            this._toggle(show);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    DateRangePopupComponent.prototype.ngOnInit = function () {
-        this.dateRangeService.registerPopup(this);
-    };
-    DateRangePopupComponent.prototype.ngAfterViewInit = function () {
-        var _this = this;
-        this.calendarSubscriptions.add(this.contentCalendar.changes.subscribe(function (changes) { return _this.calendar = changes.first; }));
-        this.calendarSubscriptions.add(this.viewCalendar.changes.subscribe(function (changes) { return _this.calendar = changes.first; }));
-        if (isWindowAvailable()) {
-            this.zone.runOutsideAngular(function () {
-                return _this.windowBlurSubscription = fromEvent(window, 'blur').subscribe(_this.handleWindowBlur.bind(_this));
-            });
-        }
-    };
-    DateRangePopupComponent.prototype.ngOnDestroy = function () {
-        this.destroyPopup();
-        this.calendarSubscriptions.unsubscribe();
-        if (this.activateSubscription) {
-            this.activateSubscription.unsubscribe();
-        }
-        if (this.blurSubscription) {
-            this.blurSubscription.unsubscribe();
-            this.focusSubscription.unsubscribe();
-        }
-        if (this.windowBlurSubscription) {
-            this.windowBlurSubscription.unsubscribe();
-        }
-    };
-    /**
-     *  Opens the popup component and focuses the calendar.
-     */
-    DateRangePopupComponent.prototype.activate = function () {
-        var _this = this;
-        if (this.show === true) {
-            return;
-        }
-        if (this.activateSubscription) {
-            this.activateSubscription.unsubscribe();
-        }
-        this.show = true;
-        this.ref.markForCheck();
-        this.zone.runOutsideAngular(function () {
-            _this.activateSubscription = merge(_this.contentCalendar.changes, _this.viewCalendar.changes)
-                .pipe(filter(function (changes) { return changes && changes.first; }), map(function (changes) { return changes.first; }))
-                .subscribe(function (calendar) { return setTimeout(function () { return calendar.focus(); }); });
-        });
-    };
-    /**
-     *  Focuses the calendar (if available).
-     */
-    DateRangePopupComponent.prototype.focus = function () {
-        if (this.calendar) {
-            this.calendar.focus();
-        }
-    };
-    /**
-     * Checks if a focused element ids placed inside the popup.
-     *
-     * @return boolean;
-     */
-    DateRangePopupComponent.prototype.hasActiveContent = function () {
-        if (!isDocumentAvailable() || !this.popupRef) {
-            return false;
-        }
-        return this.popupRef.popupElement.contains(document.activeElement);
-    };
-    /**
-     * Toggles the visibility of the popup.
-     * If you use the `toggle` method to show or hide the popup,
-     * the `open` and `close` events do not fire.
-     *
-     * @param show The state of the popup.
-     */
-    DateRangePopupComponent.prototype.toggle = function (show) {
-        var _this = this;
-        this.resolvedPromise.then(function () {
-            _this._toggle((show === undefined) ? !_this.show : show);
-        });
-    };
-    /**
-     * @hidden
-     *
-     * Closes the popup and triggers the `cancel` event.
-     */
-    DateRangePopupComponent.prototype.cancelPopup = function () {
-        this.show = false;
-        this.cancel.emit();
-    };
-    DateRangePopupComponent.prototype.handleWindowBlur = function () {
-        var _this = this;
-        if (!this.show) {
-            return;
-        }
-        if (hasObservers(this.close)) {
-            this.zone.run(function () { return _this.show = false; });
-        }
-        else {
-            this.show = false;
-        }
-    };
-    DateRangePopupComponent.prototype.handleMouseLeave = function () {
-        this.dateRangeService.setRange(this.dateRangeService.selectionRange);
-    };
-    DateRangePopupComponent.prototype.handleKeydown = function (event) {
-        var _this = this;
-        var altKey = event.altKey, keyCode = event.keyCode;
-        if (keyCode === Keys.Escape || (altKey && keyCode === Keys.ArrowUp)) {
-            this.zone.run(function () { return _this.cancelPopup(); });
-        }
-    };
-    DateRangePopupComponent.prototype.subscribeFocusBlur = function (calendar) {
-        var _this = this;
-        if (this.blurSubscription) {
-            this.blurSubscription.unsubscribe();
-            this.focusSubscription.unsubscribe();
-        }
-        if (!calendar) {
-            return;
-        }
-        var nativeElement = calendar.element.nativeElement;
-        this.blurSubscription = fromEvent(nativeElement, 'blur').subscribe(function () { return _this.onBlur.emit(); });
-        this.focusSubscription = fromEvent(nativeElement, 'focus').subscribe(function () { return _this.onFocus.emit(); });
-    };
-    DateRangePopupComponent.prototype.addPopupSubscriptions = function () {
-        var _this = this;
-        var subscriptions = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            subscriptions[_i] = arguments[_i];
-        }
-        if (!isPresent(this.popupSubscriptions)) {
-            this.popupSubscriptions = new Subscription();
-        }
-        subscriptions.map(function (s) { return _this.popupSubscriptions.add(s); });
-    };
-    Object.defineProperty(DateRangePopupComponent.prototype, "_appendTo", {
-        get: function () {
-            var appendTo = this.appendTo;
-            if (!appendTo || appendTo === 'root') {
-                return undefined;
-            }
-            return appendTo === 'component' ? this.container : appendTo;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    DateRangePopupComponent.prototype._toggle = function (show) {
-        var _this = this;
-        this._show = show;
-        if (this.popupRef) {
-            this.destroyPopup();
-        }
-        if (this._show) {
-            var direction = this.rtl ? 'right' : 'left';
-            this.popupRef = this.popupService.open({
-                anchor: this.anchor,
-                anchorAlign: this.anchorAlign || { vertical: 'bottom', horizontal: direction },
-                animate: this.animate,
-                appendTo: this._appendTo,
-                collision: this.collision,
-                content: (this.contentTemplate || {}).templateRef || this.defaultTemplate,
-                margin: this.margin,
-                popupAlign: this.popupAlign || { vertical: 'top', horizontal: direction },
-                positionMode: 'absolute'
-            });
-            var _a = this.popupRef, popupElement_1 = _a.popupElement, popupAnchorViewportLeave = _a.popupAnchorViewportLeave;
-            popupElement_1.setAttribute('id', this.popupUID);
-            this.addPopupSubscriptions(this.zone.runOutsideAngular(function () { return fromEvent(popupElement_1, 'keydown').subscribe(_this.handleKeydown.bind(_this)); }), fromEvent(popupElement_1, 'mouseleave').subscribe(this.handleMouseLeave.bind(this)), popupAnchorViewportLeave.subscribe(function () { return _this.cancelPopup(); }));
-        }
-    };
-    DateRangePopupComponent.prototype.destroyPopup = function () {
-        if (isPresent(this.popupRef)) {
-            this.popupRef.close();
-            this.popupRef = null;
-        }
-        if (isPresent(this.popupSubscriptions)) {
-            this.popupSubscriptions.unsubscribe();
-        }
-    };
-    tslib_1.__decorate([
-        ViewChild('container', { read: ViewContainerRef, static: false }),
-        tslib_1.__metadata("design:type", ViewContainerRef)
-    ], DateRangePopupComponent.prototype, "container", void 0);
-    tslib_1.__decorate([
-        ViewChild('defaultTemplate', { static: false }),
-        tslib_1.__metadata("design:type", TemplateRef)
-    ], DateRangePopupComponent.prototype, "defaultTemplate", void 0);
-    tslib_1.__decorate([
-        ContentChild(DateRangePopupTemplateDirective, { static: false }),
-        tslib_1.__metadata("design:type", DateRangePopupTemplateDirective)
-    ], DateRangePopupComponent.prototype, "contentTemplate", void 0);
-    tslib_1.__decorate([
-        ViewChildren(MultiViewCalendarComponent),
-        tslib_1.__metadata("design:type", QueryList)
-    ], DateRangePopupComponent.prototype, "viewCalendar", void 0);
-    tslib_1.__decorate([
-        ContentChildren(MultiViewCalendarComponent),
-        tslib_1.__metadata("design:type", QueryList)
-    ], DateRangePopupComponent.prototype, "contentCalendar", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DateRangePopupComponent.prototype, "animate", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", ElementRef)
-    ], DateRangePopupComponent.prototype, "anchor", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DateRangePopupComponent.prototype, "anchorAlign", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DateRangePopupComponent.prototype, "appendTo", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DateRangePopupComponent.prototype, "collision", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DateRangePopupComponent.prototype, "popupAlign", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object)
-    ], DateRangePopupComponent.prototype, "margin", void 0);
-    tslib_1.__decorate([
-        Output(),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangePopupComponent.prototype, "open", void 0);
-    tslib_1.__decorate([
-        Output(),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangePopupComponent.prototype, "close", void 0);
-    tslib_1.__decorate([
-        Output('blur'),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangePopupComponent.prototype, "onBlur", void 0);
-    tslib_1.__decorate([
-        Output('focus'),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangePopupComponent.prototype, "onFocus", void 0);
-    tslib_1.__decorate([
-        Output(),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangePopupComponent.prototype, "cancel", void 0);
-    DateRangePopupComponent = tslib_1.__decorate([
-        Component({
-            exportAs: 'kendo-daterange-popup',
-            selector: 'kendo-daterange-popup',
-            template: "\n        <ng-container #container></ng-container>\n        <ng-template #defaultTemplate>\n            <kendo-multiviewcalendar kendoDateRangeSelection></kendo-multiviewcalendar>\n        </ng-template>\n    "
-        }),
-        tslib_1.__param(4, Optional()), tslib_1.__param(4, Inject(RTL)),
-        tslib_1.__metadata("design:paramtypes", [PopupService,
-            DateRangeService,
-            ChangeDetectorRef,
-            NgZone, Boolean])
-    ], DateRangePopupComponent);
-    return DateRangePopupComponent;
-}());
-export { DateRangePopupComponent };

package/dist/es/daterange/date-range-selection.directive.js

@@ -1,230 +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 { ChangeDetectorRef, Directive, ElementRef, EventEmitter, Optional, Input, Output, Renderer2 } from '@angular/core';
-import { Subscription, fromEvent } from 'rxjs';
-import { DateRangeService } from './date-range.service';
-import { MultiViewCalendarComponent } from '../calendar/multiview-calendar.component';
-import { EMPTY_SELECTIONRANGE } from '../calendar/models/selection-range.interface';
-import { isEqual } from '@progress/kendo-date-math';
-import { clampRange, either, isEqualRange } from '../util';
-/**
- * A directive which manages the MultiViewCalendar range selection.
- */
-var DateRangeSelectionDirective = /** @class */ (function () {
-    function DateRangeSelectionDirective(calendar, cdr, element, renderer, dateRangeService) {
-        this.calendar = calendar;
-        this.cdr = cdr;
-        this.element = element;
-        this.dateRangeService = dateRangeService;
-        /**
-         * Specifies the auto-correction behavior. If the start date is greater than the end date,
-         * the directive fixes the date range to a single date either on input change or on blur
-         * ([see example]({% slug autocorrect_daterange %}#toc-configuring-the-calendar-selection-directive)).
-         *
-         * By default, the auto-correction is triggered on change.
-         * To disable this behavior, set the `autoCorrectOn` property to `none`.
-         */
-        this.autoCorrectOn = 'change';
-        /**
-         * Fires when the active range end is changed. For more information, refer to
-         * the section on [events]({% slug overview_multiviewcalendar %}#toc-events).
-         */
-        this.activeRangeEndChange = new EventEmitter();
-        /**
-         * Fires when the selection range is changed. For more information, refer to
-         * the section on [events]({% slug overview_multiviewcalendar %}#toc-events).
-         */
-        this.selectionRangeChange = new EventEmitter();
-        this.calendarSubscriptions = new Subscription();
-        this.dateRangeService = this.dateRangeService || new DateRangeService();
-        renderer.setAttribute(element.nativeElement, 'aria-multiselectable', 'true');
-    }
-    Object.defineProperty(DateRangeSelectionDirective.prototype, "selectionRange", {
-        /**
-         * Gets or sets the selection range of the calendar. When a new range is set,
-         * the connected DateRangeService notifies all related parties.
-         */
-        get: function () {
-            return this.calendar ? this.calendar.selectionRange : null;
-        },
-        set: function (range) {
-            if (!this.isEqualCalendarRange(range)) {
-                this.setSelectionRange(range);
-            }
-            if (!isEqualRange(this.dateRangeService.selectionRange, range)) {
-                this.dateRangeService.setRange(range);
-            }
-            this.updateFocusedDate(range);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DateRangeSelectionDirective.prototype, "activeRangeEnd", {
-        /**
-         * Gets or sets the active end of the selection range. This option determines which range end will be updated on
-         * user interaction. When a new active end is set, the connected DateRangeService notifies all related parties.
-         */
-        /**
-         * Specifies which end of the selection range will be marked as active. The active end gets modified upon user
-         * interaction. When a new active end is set, the wired DateRangeService notifies all related components. For
-         * example, the start and end DateInput components.
-         *
-         * > If the selection range is undefined, the value is ignored.
-         */
-        get: function () {
-            return this.calendar.activeRangeEnd;
-        },
-        set: function (activeRange) {
-            if (this.dateRangeService.activeRangeEnd === activeRange) {
-                return;
-            }
-            this.calendar.activeRangeEnd = activeRange;
-            this.dateRangeService.setActiveRangeEnd(activeRange);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DateRangeSelectionDirective.prototype, "calendarRange", {
-        get: function () {
-            return this.selectionRange || EMPTY_SELECTIONRANGE;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    DateRangeSelectionDirective.prototype.ngOnInit = function () {
-        var _this = this;
-        var calendar = this.calendar;
-        var dateRangeService = this.dateRangeService;
-        calendar.min = either(dateRangeService.min, calendar.min);
-        calendar.max = either(dateRangeService.max, calendar.max);
-        this.addSubscriptions(calendar.cellEnter.subscribe(function (value) { return _this.handleHover(value); }), calendar.valueChange.subscribe(function (value) { return _this.handleChange(value); }), dateRangeService.focusedDate$.subscribe(function (focusedDate) {
-            if (!isEqual(calendar.focusedDate, focusedDate)) {
-                calendar.focusedDate = focusedDate;
-            }
-        }), dateRangeService.activeRangeEnd$.subscribe(function (rangeEnd) {
-            if (calendar.activeRangeEnd === rangeEnd) {
-                return;
-            }
-            calendar.activeRangeEnd = rangeEnd;
-            _this.activeRangeEndChange.emit(rangeEnd);
-            _this.cdr.markForCheck();
-        }), dateRangeService.range$.subscribe(function (range) {
-            if (!_this.isEqualCalendarRange(range)) {
-                _this.acceptAndEmit(range);
-            }
-            _this.updateFocusedDate(range);
-        }), fromEvent(this.element.nativeElement, 'blur').subscribe(function () { return _this.handleBlur(); }));
-    };
-    DateRangeSelectionDirective.prototype.ngOnDestroy = function () {
-        this.calendarSubscriptions.unsubscribe();
-    };
-    DateRangeSelectionDirective.prototype.addSubscriptions = function () {
-        var _this = this;
-        var subscriptions = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            subscriptions[_i] = arguments[_i];
-        }
-        subscriptions.map(function (s) { return _this.calendarSubscriptions.add(s); });
-    };
-    DateRangeSelectionDirective.prototype.isEqualCalendarRange = function (range) {
-        return isEqualRange(this.calendar.selectionRange, range);
-    };
-    DateRangeSelectionDirective.prototype.handleBlur = function () {
-        var _a = this.calendarRange, start = _a.start, end = _a.end;
-        var autoCorrect = this.autoCorrectOn === 'blur' && start !== null && end !== null && end < start;
-        if (autoCorrect) {
-            this.dateRangeService.setRange(clampRange(start));
-        }
-    };
-    DateRangeSelectionDirective.prototype.handleChange = function (value) {
-        var service = this.dateRangeService;
-        var autoCorrect = this.autoCorrectOn === 'change' && this.shouldAutoCorrect(value);
-        var activeEnd = this.calendar.activeRangeEnd !== 'end' ? 'end' : (autoCorrect ? 'end' : 'start');
-        var range = autoCorrect ? clampRange(value) : this.updateRange(value);
-        if (!isEqualRange(service.selectionRange, range)) {
-            this.acceptAndEmit(range);
-            service.setActiveRangeEnd(activeEnd);
-            service.setRange(range);
-        }
-    };
-    DateRangeSelectionDirective.prototype.handleHover = function (value) {
-        if (this.hasCompleteRange()) {
-            return;
-        }
-        var _a = this.calendarRange, start = _a.start, end = _a.end;
-        var activeRangeEnd = this.calendar.activeRangeEnd;
-        var updateRange = (start && activeRangeEnd === 'end') || (end && activeRangeEnd === 'start');
-        if (updateRange) {
-            this.setSelectionRange(this.updateRange(value));
-        }
-    };
-    DateRangeSelectionDirective.prototype.hasCompleteRange = function () {
-        var _a = this.dateRangeService.selectionRange || EMPTY_SELECTIONRANGE, start = _a.start, end = _a.end;
-        return Boolean(start) && Boolean(end);
-    };
-    DateRangeSelectionDirective.prototype.shouldAutoCorrect = function (value) {
-        var _a = this.calendarRange, end = _a.end, start = _a.start;
-        if (this.calendar.activeRangeEnd !== 'end') {
-            return end !== null && value > end;
-        }
-        else {
-            return start !== null && value < start;
-        }
-    };
-    DateRangeSelectionDirective.prototype.updateFocusedDate = function (range) {
-        if (!range || this.dateRangeService.focusedDate) {
-            return;
-        }
-        this.dateRangeService.setFocusedDate(range.start || range.end);
-    };
-    DateRangeSelectionDirective.prototype.updateRange = function (value) {
-        var _a = this.calendarRange, end = _a.end, start = _a.start;
-        return this.calendar.activeRangeEnd !== 'end' ? ({ start: value, end: end }) : ({ start: start, end: value });
-    };
-    DateRangeSelectionDirective.prototype.setSelectionRange = function (range) {
-        this.calendar.selectionRange = range;
-        this.calendar.writeValue(null);
-    };
-    DateRangeSelectionDirective.prototype.acceptAndEmit = function (range) {
-        this.setSelectionRange(range);
-        this.selectionRangeChange.emit(range);
-    };
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", String)
-    ], DateRangeSelectionDirective.prototype, "autoCorrectOn", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Object),
-        tslib_1.__metadata("design:paramtypes", [Object])
-    ], DateRangeSelectionDirective.prototype, "selectionRange", null);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", String),
-        tslib_1.__metadata("design:paramtypes", [String])
-    ], DateRangeSelectionDirective.prototype, "activeRangeEnd", null);
-    tslib_1.__decorate([
-        Output(),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangeSelectionDirective.prototype, "activeRangeEndChange", void 0);
-    tslib_1.__decorate([
-        Output(),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], DateRangeSelectionDirective.prototype, "selectionRangeChange", void 0);
-    DateRangeSelectionDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoDateRangeSelection]'
-        }),
-        tslib_1.__param(4, Optional()),
-        tslib_1.__metadata("design:paramtypes", [MultiViewCalendarComponent,
-            ChangeDetectorRef,
-            ElementRef,
-            Renderer2,
-            DateRangeService])
-    ], DateRangeSelectionDirective);
-    return DateRangeSelectionDirective;
-}());
-export { DateRangeSelectionDirective };