@progress/kendo-angular-scheduler 3.0.3-dev.202204061046 → 4.0.0-dev.202204140813

package/dist/es/views/day-time/day-time.module.js

@@ -1,32 +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 { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { SharedModule } from '../../shared.module';
-import { TimeSlotDirective, DaySlotDirective } from './event-slot.directive';
-import { DayTimeViewItemComponent } from './day-time-view-item.component';
-import { ViewsSharedModule } from '../common/views-shared.module';
-var DIRECTIVES = [TimeSlotDirective, DaySlotDirective, DayTimeViewItemComponent];
-/**
- * @hidden
- */
-var DayTimeModule = /** @class */ (function () {
-    function DayTimeModule() {
-    }
-    DayTimeModule = tslib_1.__decorate([
-        NgModule({
-            imports: [CommonModule, SharedModule, ViewsSharedModule],
-            exports: [
-                DIRECTIVES
-            ],
-            declarations: [
-                DIRECTIVES
-            ]
-        })
-    ], DayTimeModule);
-    return DayTimeModule;
-}());
-export { DayTimeModule };

package/dist/es/views/day-time/event-slot.directive.js

@@ -1,189 +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, ElementRef, HostBinding } from '@angular/core';
-import { BaseSlotDirective } from '../view-items/base-slot.directive';
-import { addUTCDays, toUTCTime, toUTCDate, dateWithTime, isWorkWeekDay } from '../utils';
-import { DayTimeSlotService } from './day-time-slot.service';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { INVARIANT_END } from '../constants';
-/**
- * @hidden
- */
-var TimeSlotDirective = /** @class */ (function (_super) {
-    tslib_1.__extends(TimeSlotDirective, _super);
-    function TimeSlotDirective(element, slotService, localization) {
-        var _this = _super.call(this, element, slotService, localization) || this;
-        _this.isDaySlot = false;
-        return _this;
-    }
-    Object.defineProperty(TimeSlotDirective.prototype, "nonWorkHour", {
-        get: function () {
-            var date = this.date.getDay();
-            return this.invariantStart < this.workDayStart || this.workDayEnd < this.invariantEnd || !isWorkWeekDay(date, this.workWeekStart, this.workWeekEnd);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TimeSlotDirective.prototype, "startLocalTime", {
-        get: function () {
-            if (!this.date || !this.invariantStart) {
-                return null;
-            }
-            return dateWithTime(this.date, this.invariantStart);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TimeSlotDirective.prototype, "endLocalTime", {
-        get: function () {
-            if (!this.date || !this.invariantEnd) {
-                return null;
-            }
-            return dateWithTime(this.date, this.invariantEnd);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TimeSlotDirective.prototype, "start", {
-        get: function () {
-            if (!this.date || !this.invariantStart) {
-                return null;
-            }
-            return toUTCTime(this.date, this.invariantStart);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TimeSlotDirective.prototype, "end", {
-        get: function () {
-            if (!this.date || !this.invariantEnd) {
-                return null;
-            }
-            var localEnd = toUTCTime(this.date, this.invariantEnd);
-            if (INVARIANT_END.getTime() <= this.invariantEnd.getTime()) {
-                return addUTCDays(localEnd, 1);
-            }
-            return localEnd;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date)
-    ], TimeSlotDirective.prototype, "invariantStart", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date)
-    ], TimeSlotDirective.prototype, "invariantEnd", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date)
-    ], TimeSlotDirective.prototype, "workDayStart", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date)
-    ], TimeSlotDirective.prototype, "workDayEnd", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Number)
-    ], TimeSlotDirective.prototype, "workWeekStart", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Number)
-    ], TimeSlotDirective.prototype, "workWeekEnd", void 0);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date)
-    ], TimeSlotDirective.prototype, "date", void 0);
-    tslib_1.__decorate([
-        HostBinding('class.k-nonwork-hour'),
-        tslib_1.__metadata("design:type", Boolean),
-        tslib_1.__metadata("design:paramtypes", [])
-    ], TimeSlotDirective.prototype, "nonWorkHour", null);
-    TimeSlotDirective = tslib_1.__decorate([
-        Directive({
-            // tslint:disable-next-line:directive-selector
-            selector: '[timeSlot]',
-            exportAs: 'timeSlot'
-        }),
-        tslib_1.__metadata("design:paramtypes", [ElementRef,
-            DayTimeSlotService,
-            LocalizationService])
-    ], TimeSlotDirective);
-    return TimeSlotDirective;
-}(BaseSlotDirective));
-export { TimeSlotDirective };
-/**
- * @hidden
- */
-var DaySlotDirective = /** @class */ (function (_super) {
-    tslib_1.__extends(DaySlotDirective, _super);
-    function DaySlotDirective(element, slotService, localization) {
-        var _this = _super.call(this, element, slotService, localization) || this;
-        _this.isDaySlot = true;
-        return _this;
-    }
-    Object.defineProperty(DaySlotDirective.prototype, "start", {
-        get: function () {
-            if (!this.startDate) {
-                return null;
-            }
-            return toUTCDate(this.startDate);
-        },
-        set: function (value) {
-            this.startDate = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DaySlotDirective.prototype, "end", {
-        get: function () {
-            if (!this.endDate) {
-                return null;
-            }
-            return toUTCDate(this.endDate);
-        },
-        set: function (value) {
-            this.endDate = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DaySlotDirective.prototype, "daySlot", {
-        get: function () {
-            return true;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date),
-        tslib_1.__metadata("design:paramtypes", [Date])
-    ], DaySlotDirective.prototype, "start", null);
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date),
-        tslib_1.__metadata("design:paramtypes", [Date])
-    ], DaySlotDirective.prototype, "end", null);
-    tslib_1.__decorate([
-        HostBinding('attr.data-day-slot'),
-        tslib_1.__metadata("design:type", Boolean),
-        tslib_1.__metadata("design:paramtypes", [])
-    ], DaySlotDirective.prototype, "daySlot", null);
-    DaySlotDirective = tslib_1.__decorate([
-        Directive({
-            // tslint:disable-next-line:directive-selector
-            selector: '[daySlot]'
-        }),
-        tslib_1.__metadata("design:paramtypes", [ElementRef,
-            DayTimeSlotService,
-            LocalizationService])
-    ], DaySlotDirective);
-    return DaySlotDirective;
-}(BaseSlotDirective));
-export { DaySlotDirective };

package/dist/es/views/day-time/utils.js

@@ -1,33 +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 { toInvariantTime } from '../utils';
-import { MIDNIGHT_INVARIANT, MS_PER_DAY, MS_PER_MINUTE } from '../constants';
-/**
- * @hidden
- */
-export function createTimeSlots(intlService, _a) {
-    var showWorkHours = _a.showWorkHours, startTime = _a.startTime, endTime = _a.endTime, workDayStart = _a.workDayStart, workDayEnd = _a.workDayEnd, slotDivisions = _a.slotDivisions, slotDuration = _a.slotDuration;
-    var startDate = intlService.parseDate(showWorkHours ? workDayStart : startTime);
-    var start = toInvariantTime(startDate).getTime();
-    var endDate = intlService.parseDate(showWorkHours ? workDayEnd : endTime);
-    var end = toInvariantTime(endDate).getTime();
-    if (end <= start) {
-        end = toInvariantTime(MIDNIGHT_INVARIANT).getTime() + MS_PER_DAY;
-    }
-    var slots = [];
-    var duration = Math.round((slotDuration / slotDivisions) * MS_PER_MINUTE);
-    var slotTime = start;
-    var index = 0;
-    while (slotTime < end) {
-        slots.push({
-            start: new Date(slotTime),
-            end: new Date(slotTime + duration),
-            isMajor: index % slotDivisions === 0
-        });
-        index++;
-        slotTime += duration;
-    }
-    return slots;
-}

package/dist/es/views/month/month-slot.directive.js

@@ -1,96 +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, ElementRef } from '@angular/core';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { BaseSlotDirective } from '../view-items/base-slot.directive';
-import { MonthSlotService } from './month-slot.service';
-import { firstElementChild } from '../../common/dom-queries';
-import { addUTCDays, toUTCDate } from '../utils';
-/**
- * @hidden
- */
-var MonthSlotDirective = /** @class */ (function (_super) {
-    tslib_1.__extends(MonthSlotDirective, _super);
-    function MonthSlotDirective(element, slotService, localization) {
-        var _this = _super.call(this, element, slotService, localization) || this;
-        _this.isDaySlot = true;
-        _this._linkHeight = null;
-        return _this;
-    }
-    Object.defineProperty(MonthSlotDirective.prototype, "start", {
-        get: function () {
-            return this.startDate;
-        },
-        set: function (value) {
-            this.startDate = toUTCDate(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(MonthSlotDirective.prototype, "end", {
-        get: function () {
-            return addUTCDays(this.start, 1);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(MonthSlotDirective.prototype, "linkHeight", {
-        get: function () {
-            if (this._linkHeight === null) {
-                var element = firstElementChild(this.nativeElement);
-                this._linkHeight = element ? element.offsetHeight + element.offsetTop : 0;
-            }
-            return this._linkHeight;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    MonthSlotDirective.prototype.ngOnDestroy = function () {
-        _super.prototype.ngOnDestroy.call(this);
-        this.removeShowMore();
-    };
-    MonthSlotDirective.prototype.showMore = function (rect) {
-        if (!this.showMoreElement) {
-            var element = this.showMoreElement = document.createElement('div');
-            element.innerHTML = '<span class="k-icon k-i-more-horizontal"></span>';
-            element.className = 'k-more-events k-button';
-            element.style.width = rect.width + "px";
-            element.style.left = rect.left + "px";
-            element.style.top = rect.top + "px";
-            this.nativeElement.appendChild(element);
-        }
-    };
-    MonthSlotDirective.prototype.hideMore = function () {
-        this.removeShowMore();
-    };
-    MonthSlotDirective.prototype.invalidate = function () {
-        _super.prototype.invalidate.call(this);
-        this._linkHeight = null;
-        this.removeShowMore();
-    };
-    MonthSlotDirective.prototype.removeShowMore = function () {
-        if (this.showMoreElement) {
-            this.showMoreElement.parentNode.removeChild(this.showMoreElement);
-            this.showMoreElement = null;
-        }
-    };
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", Date),
-        tslib_1.__metadata("design:paramtypes", [Date])
-    ], MonthSlotDirective.prototype, "start", null);
-    MonthSlotDirective = tslib_1.__decorate([
-        Directive({
-            // tslint:disable-next-line:directive-selector
-            selector: '[monthSlot]'
-        }),
-        tslib_1.__metadata("design:paramtypes", [ElementRef,
-            MonthSlotService,
-            LocalizationService])
-    ], MonthSlotDirective);
-    return MonthSlotDirective;
-}(BaseSlotDirective));
-export { MonthSlotDirective };

package/dist/es/views/month/month-slot.service.js

@@ -1,322 +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 { orderBy } from '@progress/kendo-data-query';
-import { intersects, findRowIndex, addUTCDays, rectContains, dateWithTime } from '../utils';
-import { ItemMap } from '../view-items/item-map';
-import { BaseSlotService } from '../view-items/base-slot.service';
-import { BORDER_WIDTH } from '../constants';
-//better try to measure this one
-var MORE_BUTTON_HEIGHT = 13;
-var EVENT_OFFSET = 2;
-/**
- * @hidden
- */
-var SlotRange = /** @class */ (function () {
-    function SlotRange(index) {
-        this.index = index;
-        this.slotMap = new ItemMap();
-        this.itemMap = new ItemMap();
-    }
-    Object.defineProperty(SlotRange.prototype, "slots", {
-        get: function () {
-            return this.slotMap.toArray();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "items", {
-        get: function () {
-            return this.itemMap.toArray();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "start", {
-        get: function () {
-            var first = this.slotMap.first;
-            if (!first) {
-                return null;
-            }
-            return first.start;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "end", {
-        get: function () {
-            var last = this.slotMap.last;
-            if (!last) {
-                return null;
-            }
-            return addUTCDays(last.end, 1);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "hasSlots", {
-        get: function () {
-            return this.slotMap.count > 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "hasItems", {
-        get: function () {
-            return this.itemMap.count > 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "firstSlot", {
-        get: function () {
-            return this.slotMap.first;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "lastSlot", {
-        get: function () {
-            return this.slotMap.last;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SlotRange.prototype, "rect", {
-        get: function () {
-            var first = this.firstSlot.rect;
-            var last = this.lastSlot.rect;
-            return {
-                left: first.left,
-                top: first.top,
-                width: last.left - first.left + last.width,
-                height: last.top - first.top + last.height
-            };
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SlotRange.prototype.registerItem = function (component) {
-        this.itemMap.addItem(component.item.index, component);
-    };
-    SlotRange.prototype.unregisterItem = function (component, index) {
-        this.itemMap.removeItem(index, component);
-    };
-    SlotRange.prototype.registerSlot = function (slot) {
-        this.slotMap.addItem(slot.id.index, slot);
-    };
-    SlotRange.prototype.unregisterSlot = function (slot) {
-        this.slotMap.removeItem(slot.id.index, slot);
-    };
-    SlotRange.prototype.layout = function (eventHeight) {
-        if (!this.hasItems) {
-            return;
-        }
-        var items = this.items;
-        var sorted = orderBy(items, [{ field: "item.startTime", dir: "asc" }, { field: "item.endTime", dir: "desc" }]);
-        var slotItems = {};
-        var slots = this.slots;
-        sorted.forEach(function (event) { return slots
-            .filter(function (slot) { return intersects(event.item.startTime, event.item.endTime, slot.start, slot.end); })
-            .forEach(function (slot) {
-            var value = slotItems[slot.key] = slotItems[slot.key] || { events: [], height: slot.linkHeight };
-            value.slot = slot;
-            var rect = slot.rect;
-            var data = event.item.data[event.resourceIndex];
-            data.rowIndex = findRowIndex(value.events, data);
-            if (value.height + eventHeight + EVENT_OFFSET + MORE_BUTTON_HEIGHT > rect.height || data.hidden) {
-                data.hidden = true;
-                slot.showMore({ width: rect.width, left: rect.left, top: rect.top + slot.linkHeight + ((data.rowIndex) * (eventHeight + EVENT_OFFSET)) });
-            }
-            else {
-                value.events[data.rowIndex] = event;
-                if (!event.rect) {
-                    event.rect = {
-                        top: rect.top + slot.linkHeight + (data.rowIndex * (eventHeight + EVENT_OFFSET)),
-                        left: rect.left,
-                        height: eventHeight,
-                        width: 0
-                    };
-                }
-                event.rect.width += rect.width + BORDER_WIDTH;
-                value.height += eventHeight + EVENT_OFFSET;
-            }
-        }); });
-        sorted.forEach(function (event) {
-            if (event.rect) {
-                event.rect.width -= BORDER_WIDTH;
-            }
-            event.reflow();
-        });
-    };
-    return SlotRange;
-}());
-export { SlotRange };
-/**
- * @hidden
- */
-var MonthResourceGroup = /** @class */ (function () {
-    function MonthResourceGroup(index) {
-        this.index = index;
-        this.dayRanges = [];
-    }
-    Object.defineProperty(MonthResourceGroup.prototype, "hasSlots", {
-        get: function () {
-            return Boolean(this.dayRanges.find(function (range) { return range && range.hasSlots; }));
-        },
-        enumerable: true,
-        configurable: true
-    });
-    MonthResourceGroup.prototype.registerSlot = function (slot) {
-        var range = this.slotRange(slot);
-        range.registerSlot(slot);
-    };
-    MonthResourceGroup.prototype.unregisterSlot = function (slot) {
-        var range = this.dayRanges[slot.id.rangeIndex];
-        range.unregisterSlot(slot);
-        if (!range.hasSlots) {
-            delete this.dayRanges[slot.id.rangeIndex];
-        }
-    };
-    MonthResourceGroup.prototype.registerItem = function (component) {
-        var range = this.dayRanges[component.rangeIndex];
-        range.registerItem(component);
-    };
-    MonthResourceGroup.prototype.unregisterItem = function (component, id) {
-        var range = this.dayRanges[id.rangeIndex];
-        if (range) {
-            range.unregisterItem(component, id.index);
-        }
-    };
-    MonthResourceGroup.prototype.slotRange = function (slot) {
-        var ranges = this.dayRanges;
-        var rangeIndex = slot.id.rangeIndex;
-        if (!ranges[rangeIndex]) {
-            ranges[rangeIndex] = new SlotRange(rangeIndex);
-        }
-        return ranges[rangeIndex];
-    };
-    MonthResourceGroup.prototype.forEachRange = function (callback) {
-        for (var i = 0; i < this.dayRanges.length; i++) {
-            callback(this.dayRanges[i]);
-        }
-    };
-    MonthResourceGroup.prototype.cleanRanges = function () {
-        this.dayRanges = this.dayRanges.filter(function (r) { return Boolean(r); });
-    };
-    return MonthResourceGroup;
-}());
-export { MonthResourceGroup };
-/**
- * @hidden
- */
-var MonthSlotService = /** @class */ (function (_super) {
-    tslib_1.__extends(MonthSlotService, _super);
-    function MonthSlotService() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MonthSlotService.prototype.layout = function (eventHeight) {
-        this.groups.forEach(function (group) {
-            return group.forEachRange(function (range) { return range.layout(eventHeight); });
-        });
-    };
-    MonthSlotService.prototype.slotByIndex = function (slotIndex) {
-        var _a = slotIndex.split(':').map(function (part) { return parseInt(part, 10); }), resourceIndex = _a[0], rangeIndex = _a[1], index = _a[2];
-        return this.groups[resourceIndex].dayRanges[rangeIndex].slots[index];
-    };
-    MonthSlotService.prototype.forEachSlot = function (callback) {
-        this.groups.forEach(function (group) {
-            group.dayRanges.forEach(function (range) {
-                range.slots.forEach(function (slot) { return callback(slot); });
-            });
-        });
-    };
-    MonthSlotService.prototype.forEachItem = function (callback) {
-        this.groups.forEach(function (group) {
-            group.dayRanges.forEach(function (range) {
-                range.items.forEach(function (viewItem) { return callback(viewItem); });
-            });
-        });
-    };
-    MonthSlotService.prototype.createGroup = function (index) {
-        return new MonthResourceGroup(index);
-    };
-    MonthSlotService.prototype.invalidate = function () {
-        _super.prototype.invalidate.call(this);
-        this.forEachItem(function (viewItem) {
-            var data = viewItem.item.data;
-            Object.keys(data).forEach(function (resourceIndex) {
-                data[resourceIndex].hidden = false;
-            });
-        });
-    };
-    MonthSlotService.prototype.slotByPosition = function (x, y) {
-        var range;
-        this.groups.find(function (group) {
-            range = group.dayRanges.find(function (r) { return rectContains(r.rect, x, y); });
-            return range;
-        });
-        if (range) {
-            return range.slots.find(function (slot) { return rectContains(slot.rect, x, y); });
-        }
-    };
-    MonthSlotService.prototype.dragRanges = function (currentSlot, offset) {
-        var start = new Date(currentSlot.start.getTime() - offset.start);
-        var end = new Date(currentSlot.start.getTime() + offset.end);
-        var group = this.groups[currentSlot.id.resourceIndex];
-        var ranges = [];
-        group.dayRanges.forEach(function (range) {
-            var slots = range.slots.filter(function (s) { return intersects(start, end, s.start, s.end); });
-            if (slots.length) {
-                ranges.push(slots);
-            }
-        });
-        return {
-            start: start,
-            end: end,
-            ranges: ranges
-        };
-    };
-    MonthSlotService.prototype.groupSlotByPosition = function (currentSlot, x, y) {
-        var range = this.groups[currentSlot.id.resourceIndex].dayRanges.find(function (r) { return rectContains(r.rect, x, y); });
-        if (range) {
-            return range.slots.find(function (slot) { return rectContains(slot.rect, x, y); });
-        }
-    };
-    MonthSlotService.prototype.resizeRanges = function (currentSlot, task, resizeStart, offset) {
-        var group = this.groups[task.resources[0].leafIdx];
-        var ranges = [];
-        var startDate = task.start.toUTCDate();
-        var endDate = task.end.toUTCDate();
-        var start, end;
-        if (resizeStart) {
-            start = currentSlot.start.getTime() + offset.start;
-            if (start > endDate.getTime()) {
-                start = new Date(Math.min(dateWithTime(endDate, startDate).getTime(), endDate.getTime()));
-            }
-            end = endDate;
-        }
-        else {
-            start = startDate;
-            end = currentSlot.start.getTime() + offset.end;
-            if (end < start.getTime()) {
-                end = new Date(Math.max(dateWithTime(startDate, endDate).getTime(), start.getTime()));
-            }
-        }
-        group.dayRanges.forEach(function (range) {
-            var slots = range.slots.filter(function (s) { return intersects(start, end, s.start, s.end); });
-            if (slots.length) {
-                ranges.push(slots);
-            }
-        });
-        return {
-            start: new Date(start),
-            end: new Date(end),
-            ranges: ranges
-        };
-    };
-    return MonthSlotService;
-}(BaseSlotService));
-export { MonthSlotService };