@mintplayer/ng-bootstrap 13.1.23 → 13.1.27

package/esm2020/lib/components/scheduler/components/scheduler/scheduler.component.mjs

@@ -0,0 +1,364 @@
+import { Component, EventEmitter, HostListener, Input, Output, QueryList, ViewChildren } from '@angular/core';
+import { BehaviorSubject, combineLatest, filter, map, Subject, take, takeUntil } from 'rxjs';
+import { BsCalendarMonthService } from '../../../../services/calendar-month/calendar-month.service';
+import { EDragOperation } from '../../enums/drag-operation';
+import { BsTimelineService } from '../../services/timeline/timeline.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../services/calendar-month/calendar-month.service";
+import * as i2 from "../../services/timeline/timeline.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../../pipes/bs-seconds-today-offset/bs-seconds-today-offset.pipe";
+import * as i5 from "../../pipes/bs-seconds-timespan.pipe/bs-seconds-timespan.pipe";
+import * as i6 from "../../pipes/day-of-week/day-of-week.pipe";
+export class BsSchedulerComponent {
+    constructor(calendarMonthService, timelineService) {
+        this.calendarMonthService = calendarMonthService;
+        this.timelineService = timelineService;
+        this.events$ = new BehaviorSubject([]);
+        this.previewEvent$ = new BehaviorSubject(null);
+        this.timeSlotDuration$ = new BehaviorSubject(1800);
+        this.timeSlots$ = new BehaviorSubject([]);
+        // timeSlots$: Observable<TimeSlot[][]>;
+        this.mouseState$ = new BehaviorSubject(false);
+        this.hoveredTimeSlot$ = new BehaviorSubject(null);
+        this.destroyed$ = new Subject();
+        //#region UnitHeight
+        this.unitHeight$ = new BehaviorSubject(40);
+        this.unitHeightChange = new EventEmitter();
+        this.operation = null;
+        this.dragStartTimeslot = null;
+        const monday = this.calendarMonthService.getMondayBefore(new Date());
+        this.currentWeek$ = new BehaviorSubject(monday);
+        this.daysOfWeek$ = this.currentWeek$.pipe(map((weekMonday) => {
+            weekMonday.setHours(0);
+            weekMonday.setMinutes(0);
+            weekMonday.setSeconds(0);
+            weekMonday.setMilliseconds(0);
+            return Array.from(Array(7).keys()).map((x) => this.addDays(weekMonday, x));
+        }));
+        this.daysOfWeekWithTimestamps$ = this.daysOfWeek$
+            .pipe(map((daysOfWeek) => {
+            return { start: daysOfWeek[0].getTime(), end: daysOfWeek[daysOfWeek.length - 1].getTime() + 24 * 60 * 60 * 1000 };
+        }));
+        this.eventParts$ = this.events$.pipe(map((events) => events.map((ev) => this.timelineService.splitInParts(ev))));
+        this.eventPartsForThisWeek$ = combineLatest([
+            this.daysOfWeekWithTimestamps$,
+            this.eventParts$
+                .pipe(map(eventParts => eventParts.map(evp => evp.parts)))
+                .pipe(map(jaggedParts => {
+                return jaggedParts.reduce((flat, toFlatten) => flat.concat(toFlatten), []);
+            }))
+        ])
+            .pipe(map(([startAndEnd, eventParts]) => {
+            return eventParts.filter(eventPart => {
+                return !((eventPart.end.getTime() <= startAndEnd.start) || (eventPart.start.getTime() >= startAndEnd.end));
+            });
+        }));
+        this.previewEventParts$ = this.previewEvent$.pipe(map((event) => {
+            if (event) {
+                return this.timelineService.splitInParts(event);
+            }
+            else {
+                return null;
+            }
+        }));
+        this.previewEventPartsForThisWeek$ = combineLatest([this.daysOfWeekWithTimestamps$, this.previewEventParts$])
+            .pipe(map(([startAndEnd, previewEventParts]) => {
+            if (previewEventParts) {
+                return previewEventParts.parts.filter(eventPart => {
+                    return !((eventPart.end.getTime() <= startAndEnd.start) || (eventPart.start.getTime() >= startAndEnd.end));
+                });
+            }
+            else {
+                return [];
+            }
+        }));
+        this.timelinedEventPartsForThisWeek$ = this.eventPartsForThisWeek$
+            .pipe(map(eventParts => {
+            // We'll only use the events for this week
+            const events = eventParts.map(ep => ep.event)
+                .filter((e, i, list) => list.indexOf(e) === i)
+                .filter((e) => !!e)
+                .map((e) => e);
+            const timeline = this.timelineService.getTimeline(events);
+            const result = timeline.map(track => {
+                return track.events.map(ev => {
+                    return { event: ev, index: track.index };
+                });
+            })
+                .reduce((flat, toFlatten) => flat.concat(toFlatten), [])
+                .map((evi) => eventParts.filter(p => p.event === evi.event).map(p => {
+                return { part: p, index: evi.index };
+            }))
+                .reduce((flat, toFlatten) => flat.concat(toFlatten), []);
+            return {
+                total: timeline.length,
+                parts: result
+            };
+        }));
+        // this.timeSlots$ = 
+        combineLatest([this.daysOfWeek$, this.timeSlotDuration$])
+            .pipe(map(([daysOfWeek, duration]) => {
+            const timeSlotsPerDay = Math.floor((60 * 60 * 24) / duration);
+            return Array.from(Array(timeSlotsPerDay).keys()).map((index) => {
+                const timeSlotStart = new Date(daysOfWeek[0]);
+                timeSlotStart.setTime(+timeSlotStart.getTime() + index * duration * 1000);
+                const timeSlotEnd = new Date(timeSlotStart);
+                timeSlotEnd.setTime(+timeSlotEnd.getTime() + duration * 1000);
+                return daysOfWeek.map((day) => {
+                    const start = new Date(day);
+                    start.setHours(timeSlotStart.getHours());
+                    start.setMinutes(timeSlotStart.getMinutes());
+                    start.setSeconds(timeSlotStart.getSeconds());
+                    start.setMilliseconds(timeSlotStart.getMilliseconds());
+                    const end = new Date(day);
+                    end.setHours(timeSlotEnd.getHours());
+                    end.setMinutes(timeSlotEnd.getMinutes());
+                    end.setSeconds(timeSlotEnd.getSeconds());
+                    end.setMilliseconds(timeSlotEnd.getMilliseconds());
+                    end.setDate(end.getDate() + timeSlotEnd.getDate() - timeSlotStart.getDate());
+                    return { start, end };
+                });
+            });
+        }))
+            .subscribe((timeslots) => {
+            // For performance reasons, we're not using an observable here, but persist the timeslots in a BehaviorSubject.
+            this.timeSlots$.next(timeslots);
+        });
+        this.unitHeight$
+            .pipe(takeUntil(this.destroyed$))
+            .subscribe((unitHeight) => {
+            this.unitHeightChange.emit(unitHeight);
+        });
+    }
+    get unitHeight() {
+        return this.unitHeight$.value;
+    }
+    set unitHeight(value) {
+        this.unitHeight$.next(value);
+    }
+    //#endregion
+    addDays(date, days) {
+        const result = new Date(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+    onPreviousWeek() {
+        this.currentWeek$
+            .pipe(map((w) => this.addDays(w, -7)), take(1))
+            .subscribe((w) => this.currentWeek$.next(w));
+    }
+    onNextWeek() {
+        this.currentWeek$
+            .pipe(map((w) => this.addDays(w, 7)), take(1))
+            .subscribe((w) => this.currentWeek$.next(w));
+    }
+    onCreateEvent(ev, slot) {
+        ev.preventDefault();
+        this.mouseState$.next(true);
+        this.dragStartTimeslot = slot;
+        this.operation = {
+            operation: EDragOperation.createEvent,
+            event: {
+                start: slot.start,
+                end: slot.end,
+                color: '#F00',
+                description: 'Test event',
+            }
+        };
+        this.previewEvent$.next({ start: slot.start, end: slot.end });
+    }
+    randomColor() {
+        const brightness = 128;
+        return '#' + this.randomChannel(brightness) + this.randomChannel(brightness) + this.randomChannel(brightness);
+    }
+    randomChannel(brightness) {
+        const r = 255 - brightness;
+        const n = 0 | ((Math.random() * r) + brightness);
+        const s = n.toString(16);
+        return (s.length == 1) ? '0' + s : s;
+    }
+    onStartDragEvent(eventPart, ev) {
+        ev.preventDefault();
+        this.hoveredTimeSlot$.pipe(take(1)).subscribe((hoveredTimeSlot) => {
+            if (eventPart.event) {
+                this.dragStartTimeslot = hoveredTimeSlot;
+                this.operation = {
+                    operation: EDragOperation.moveEvent,
+                    event: eventPart.event,
+                };
+                this.previewEvent$.next({ start: eventPart.event.start, end: eventPart.event.end });
+            }
+        });
+    }
+    //#region hoveredTimeslot$
+    getHoveredTimeslot(ev, timeSlots) {
+        const hoveredSlots = this.timeSlotElements.filter((el) => {
+            const rct = el.nativeElement.getBoundingClientRect();
+            if (rct.left <= ev.x && ev.x <= rct.right && rct.top <= ev.y && ev.y <= rct.bottom) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+        if (!hoveredSlots || hoveredSlots.length === 0) {
+            return null;
+        }
+        const slotElement = hoveredSlots[0].nativeElement;
+        const strRow = slotElement.getAttribute('data-row');
+        if (!strRow) {
+            return null;
+        }
+        const row = parseInt(strRow);
+        const strColumn = slotElement.getAttribute('data-column');
+        if (!strColumn) {
+            return null;
+        }
+        const column = parseInt(strColumn);
+        const slot = timeSlots[row][column];
+        return slot;
+    }
+    onMousemove(ev) {
+        this.timeSlots$.pipe(take(1)).subscribe((timeSlots) => {
+            const hovered = this.getHoveredTimeslot(ev, timeSlots);
+            this.hoveredTimeSlot$.next(hovered);
+            if (this.operation) {
+                switch (this.operation.operation) {
+                    case EDragOperation.createEvent:
+                        {
+                            if (this.operation.event && this.dragStartTimeslot && hovered && (this.operation.event.end.getTime() != hovered.end.getTime())) {
+                                if (this.dragStartTimeslot.start.getTime() === hovered.start.getTime()) {
+                                    // 1 slot
+                                }
+                                else if (this.dragStartTimeslot.start.getTime() < hovered.start.getTime()) {
+                                    // Drag down
+                                    this.previewEvent$
+                                        .pipe(filter((ev) => !!ev && !!this.dragStartTimeslot))
+                                        .pipe(map((ev) => {
+                                        if (ev && this.dragStartTimeslot) {
+                                            ev.start = this.dragStartTimeslot.start;
+                                            ev.end = hovered.end;
+                                        }
+                                        return ev;
+                                    }))
+                                        .pipe(take(1))
+                                        .subscribe((ev) => this.previewEvent$.next(ev));
+                                }
+                                else if (this.dragStartTimeslot.start.getTime() > hovered.start.getTime()) {
+                                    // Drag up
+                                    this.previewEvent$
+                                        .pipe(filter((ev) => !!ev && !!this.dragStartTimeslot))
+                                        .pipe(map((ev) => {
+                                        if (ev && this.dragStartTimeslot) {
+                                            ev.start = hovered.start;
+                                            ev.end = this.dragStartTimeslot.end;
+                                        }
+                                        return ev;
+                                    }))
+                                        .pipe(take(1))
+                                        .subscribe((ev) => this.previewEvent$.next(ev));
+                                }
+                            }
+                        }
+                        break;
+                    case EDragOperation.moveEvent:
+                        {
+                            if (hovered && this.dragStartTimeslot) {
+                                // this.operation.event.start.setTime(this.operation.event.start.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime());
+                                // this.operation.event.end.setTime(this.operation.event.end.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime());
+                                // this.dragStartTimeslot = hovered;
+                                // // this.events$.next(this.events$.value);
+                                this.previewEvent$
+                                    .pipe(filter((ev) => !!ev && !!this.dragStartTimeslot))
+                                    .pipe(map((ev) => {
+                                    if (ev && this.dragStartTimeslot) {
+                                        const result = {
+                                            start: new Date(ev.start.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime()),
+                                            end: new Date(ev.end.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime())
+                                        };
+                                        this.dragStartTimeslot = hovered;
+                                        return result;
+                                    }
+                                    else {
+                                        return ev;
+                                    }
+                                }))
+                                    .pipe(take(1))
+                                    .subscribe((ev) => {
+                                    this.previewEvent$.next(ev);
+                                });
+                            }
+                        }
+                        break;
+                }
+            }
+        });
+    }
+    //#endregion
+    onMouseUp(ev) {
+        if (this.operation) {
+            switch (this.operation.operation) {
+                case EDragOperation.createEvent:
+                    {
+                        combineLatest([this.previewEvent$])
+                            .pipe(take(1))
+                            .subscribe(([previewEvent]) => {
+                            if (previewEvent) {
+                                this.operation = null;
+                                this.dragStartTimeslot = null;
+                                this.events$.next([...this.events$.value, {
+                                        start: previewEvent.start,
+                                        end: previewEvent.end,
+                                        color: this.randomColor(),
+                                        description: 'New event'
+                                    }]);
+                                this.previewEvent$.next(null);
+                            }
+                        });
+                    }
+                    break;
+                case EDragOperation.moveEvent:
+                    {
+                        this.previewEvent$
+                            .pipe(filter((ev) => !!ev))
+                            .pipe(take(1))
+                            .subscribe((previewEvent) => {
+                            if (this.operation && this.operation.event && previewEvent) {
+                                this.operation.event.start = previewEvent.start;
+                                this.operation.event.end = previewEvent.end;
+                                this.operation = null;
+                                this.dragStartTimeslot = null;
+                                this.events$.next(this.events$.value);
+                                this.previewEvent$.next(null);
+                            }
+                        });
+                    }
+                    break;
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next(true);
+    }
+}
+BsSchedulerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSchedulerComponent, deps: [{ token: i1.BsCalendarMonthService }, { token: i2.BsTimelineService }], target: i0.ɵɵFactoryTarget.Component });
+BsSchedulerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: BsSchedulerComponent, selector: "bs-scheduler", inputs: { unitHeight: "unitHeight" }, outputs: { unitHeightChange: "unitHeightChange" }, host: { listeners: { "document:mousemove": "onMousemove($event)", "document:mouseup": "onMouseUp($event)" } }, viewQueries: [{ propertyName: "timeSlotElements", predicate: ["slot"], descendants: true }], ngImport: i0, template: "<div class=\"table d-flex w-100 overflow-y-auto\" [style.max-height.px]=\"null\">\n    <div class=\"calendar-head\">\n        <div class=\"w-100 d-flex flex-row\">\n            <div class=\"d-flex calendar-left justify-content-between\">\n                <button class=\"btn btn-default flex-start\" (click)=\"onPreviousWeek()\">&lt;</button>\n                <button class=\"btn btn-default flex-end\" (click)=\"onNextWeek()\">&gt;</button>\n            </div>\n            <div class=\"flex-grow-1\" *ngFor=\"let day of (daysOfWeek$ | async)\">\n                <span class=\"d-block col-form-label text-center\">\n                    {{ day | date: 'dd-MM-yyyy' }}\n                </span>\n            </div>\n        </div>\n    </div>\n    <div class=\"calendar-body\">\n        <div class=\"position-relative\">\n            <!-- Timeslots -->\n            <div *ngFor=\"let timeslots of (timeSlots$ | async); let i = index\" class=\"d-flex flex-row p-0 timeslot\" [style.height.px]=\"unitHeight$ | async\">\n                <div class=\"calendar-cell calendar-left align-top py-0\">{{ timeslots[0].start | date: 'HH:mm:ss' }}</div>\n                <div class=\"calendar-cell flex-grow-1\" *ngFor=\"let slot of timeslots; let j = index\" #slot (mousedown)=\"onCreateEvent($event, slot)\" [attr.data-row]=\"i\" [attr.data-column]=\"j\"></div>\n            </div>\n            \n            <!-- Events -->\n            <ng-container *ngIf=\"(timeSlotDuration$ | async) as timeSlotDuration\">\n                <ng-container *ngIf=\"(unitHeight$ | async) as unitHeight\">\n                    <ng-container *ngIf=\"(timelinedEventPartsForThisWeek$ | async) as partData\">\n                        <div *ngFor=\"let eventPart of partData.parts\" class=\"event p-0\"\n                            [style.top.px]=\"(eventPart.part | bsSecondsTodayOffset) / timeSlotDuration * unitHeight\"\n                            [style.height.px]=\"(eventPart.part | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                            [style.left]=\"'calc(90px + ((100% - 90px) / 7 * ' + ((eventPart.part | dayOfWeek) - 1) + '))'\">\n                            <div class=\"event-inner\"\n                                [style.width]=\"'calc(100% / ' + partData.total + ')'\"\n                                [style.height.px]=\"(eventPart.part | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                                [style.margin-left]=\"'calc(100% / ' + partData.total + ' * ' + eventPart.index + ')'\"\n                                (mousedown)=\"onStartDragEvent(eventPart.part, $event)\">\n                                <div class=\"event-border\"></div>\n                                <ng-container *ngIf=\"eventPart.part.event\">\n                                    <div class=\"event-bg\" [style.background-color]=\"eventPart.part.event.color\"></div>\n                                    <div class=\"event-label\">{{ eventPart.part.event.description }}</div>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </ng-container>\n                    <ng-container *ngIf=\"(previewEventPartsForThisWeek$ | async) as previewPartData\">\n                        <div *ngFor=\"let eventPart of previewPartData\" class=\"event preview p-0\"\n                            [style.top.px]=\"(eventPart | bsSecondsTodayOffset) / timeSlotDuration * unitHeight\"\n                            [style.height.px]=\"(eventPart | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                            [style.left]=\"'calc(90px + ((100% - 90px) / 7 * ' + ((eventPart | dayOfWeek) - 1) + '))'\">\n                            <div class=\"event-inner w-100\" [style.height.px]=\"(eventPart | bsSecondsTimespan) / timeSlotDuration * unitHeight\"></div>\n                        </div>\n                    </ng-container>\n                </ng-container>\n            </ng-container>\n        </div>\n    </div>\n</div>", styles: [":host{display:block}.table{flex-flow:column}.table .calendar-head{flex:0 0 auto}.table .calendar-head>div{padding-right:18px}.table .calendar-body{flex:1 1 auto;display:block;overflow-y:visible;overflow-x:hidden}.table .calendar-body .calendar-cell{border-right:1px solid #DEE2E6;border-bottom:1px solid #DEE2E6;cursor:default}.table .calendar-body .calendar-cell.hover{border-top-width:3px}.table .calendar-left{width:90px}.event{z-index:5;width:calc((100% - 90px) / 7);height:100px;overflow:hidden;position:absolute;-webkit-user-select:none;user-select:none;pointer-events:none}.event.preview{background:#666;opacity:.6}.event .event-border{background:black;top:0;left:0;bottom:3px;width:3px;position:absolute;z-index:10;opacity:.3}.event .event-inner{position:relative;left:0px;right:5px;top:0px;bottom:5px;cursor:move;pointer-events:all;overflow-x:hidden}.event .event-inner .event-bg{opacity:.5;width:calc(100% - 2px);margin:1px auto 1px 0;height:calc(100% - 3px);transition:opacity .15s ease-in-out}.event .event-inner .event-label{position:absolute;top:0;font-size:12px;font-weight:600;padding:4px}.event .event-inner:hover .event-bg{opacity:.7}\n"], directives: [{ type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i3.AsyncPipe, "date": i3.DatePipe, "bsSecondsTodayOffset": i4.BsSecondsTodayOffsetPipe, "bsSecondsTimespan": i5.BsSecondsTimespanPipe, "dayOfWeek": i6.DayOfWeekPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSchedulerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-scheduler', template: "<div class=\"table d-flex w-100 overflow-y-auto\" [style.max-height.px]=\"null\">\n    <div class=\"calendar-head\">\n        <div class=\"w-100 d-flex flex-row\">\n            <div class=\"d-flex calendar-left justify-content-between\">\n                <button class=\"btn btn-default flex-start\" (click)=\"onPreviousWeek()\">&lt;</button>\n                <button class=\"btn btn-default flex-end\" (click)=\"onNextWeek()\">&gt;</button>\n            </div>\n            <div class=\"flex-grow-1\" *ngFor=\"let day of (daysOfWeek$ | async)\">\n                <span class=\"d-block col-form-label text-center\">\n                    {{ day | date: 'dd-MM-yyyy' }}\n                </span>\n            </div>\n        </div>\n    </div>\n    <div class=\"calendar-body\">\n        <div class=\"position-relative\">\n            <!-- Timeslots -->\n            <div *ngFor=\"let timeslots of (timeSlots$ | async); let i = index\" class=\"d-flex flex-row p-0 timeslot\" [style.height.px]=\"unitHeight$ | async\">\n                <div class=\"calendar-cell calendar-left align-top py-0\">{{ timeslots[0].start | date: 'HH:mm:ss' }}</div>\n                <div class=\"calendar-cell flex-grow-1\" *ngFor=\"let slot of timeslots; let j = index\" #slot (mousedown)=\"onCreateEvent($event, slot)\" [attr.data-row]=\"i\" [attr.data-column]=\"j\"></div>\n            </div>\n            \n            <!-- Events -->\n            <ng-container *ngIf=\"(timeSlotDuration$ | async) as timeSlotDuration\">\n                <ng-container *ngIf=\"(unitHeight$ | async) as unitHeight\">\n                    <ng-container *ngIf=\"(timelinedEventPartsForThisWeek$ | async) as partData\">\n                        <div *ngFor=\"let eventPart of partData.parts\" class=\"event p-0\"\n                            [style.top.px]=\"(eventPart.part | bsSecondsTodayOffset) / timeSlotDuration * unitHeight\"\n                            [style.height.px]=\"(eventPart.part | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                            [style.left]=\"'calc(90px + ((100% - 90px) / 7 * ' + ((eventPart.part | dayOfWeek) - 1) + '))'\">\n                            <div class=\"event-inner\"\n                                [style.width]=\"'calc(100% / ' + partData.total + ')'\"\n                                [style.height.px]=\"(eventPart.part | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                                [style.margin-left]=\"'calc(100% / ' + partData.total + ' * ' + eventPart.index + ')'\"\n                                (mousedown)=\"onStartDragEvent(eventPart.part, $event)\">\n                                <div class=\"event-border\"></div>\n                                <ng-container *ngIf=\"eventPart.part.event\">\n                                    <div class=\"event-bg\" [style.background-color]=\"eventPart.part.event.color\"></div>\n                                    <div class=\"event-label\">{{ eventPart.part.event.description }}</div>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </ng-container>\n                    <ng-container *ngIf=\"(previewEventPartsForThisWeek$ | async) as previewPartData\">\n                        <div *ngFor=\"let eventPart of previewPartData\" class=\"event preview p-0\"\n                            [style.top.px]=\"(eventPart | bsSecondsTodayOffset) / timeSlotDuration * unitHeight\"\n                            [style.height.px]=\"(eventPart | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                            [style.left]=\"'calc(90px + ((100% - 90px) / 7 * ' + ((eventPart | dayOfWeek) - 1) + '))'\">\n                            <div class=\"event-inner w-100\" [style.height.px]=\"(eventPart | bsSecondsTimespan) / timeSlotDuration * unitHeight\"></div>\n                        </div>\n                    </ng-container>\n                </ng-container>\n            </ng-container>\n        </div>\n    </div>\n</div>", styles: [":host{display:block}.table{flex-flow:column}.table .calendar-head{flex:0 0 auto}.table .calendar-head>div{padding-right:18px}.table .calendar-body{flex:1 1 auto;display:block;overflow-y:visible;overflow-x:hidden}.table .calendar-body .calendar-cell{border-right:1px solid #DEE2E6;border-bottom:1px solid #DEE2E6;cursor:default}.table .calendar-body .calendar-cell.hover{border-top-width:3px}.table .calendar-left{width:90px}.event{z-index:5;width:calc((100% - 90px) / 7);height:100px;overflow:hidden;position:absolute;-webkit-user-select:none;user-select:none;pointer-events:none}.event.preview{background:#666;opacity:.6}.event .event-border{background:black;top:0;left:0;bottom:3px;width:3px;position:absolute;z-index:10;opacity:.3}.event .event-inner{position:relative;left:0px;right:5px;top:0px;bottom:5px;cursor:move;pointer-events:all;overflow-x:hidden}.event .event-inner .event-bg{opacity:.5;width:calc(100% - 2px);margin:1px auto 1px 0;height:calc(100% - 3px);transition:opacity .15s ease-in-out}.event .event-inner .event-label{position:absolute;top:0;font-size:12px;font-weight:600;padding:4px}.event .event-inner:hover .event-bg{opacity:.7}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.BsCalendarMonthService }, { type: i2.BsTimelineService }]; }, propDecorators: { timeSlotElements: [{
+                type: ViewChildren,
+                args: ['slot']
+            }], unitHeightChange: [{
+                type: Output
+            }], unitHeight: [{
+                type: Input
+            }], onMousemove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['document:mouseup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/mintplayer-ng-bootstrap/src/lib/components/scheduler/components/scheduler/scheduler.component.ts","../../../../../../../../../libs/mintplayer-ng-bootstrap/src/lib/components/scheduler/components/scheduler/scheduler.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, HostListener, Input, OnDestroy, Output, QueryList, ViewChildren } from '@angular/core';\nimport { BehaviorSubject, combineLatest, filter, map, Observable, Subject, take, takeUntil, tap } from 'rxjs';\nimport { BsCalendarMonthService } from '../../../../services/calendar-month/calendar-month.service';\nimport { EDragOperation } from '../../enums/drag-operation';\nimport { DragOperation } from '../../interfaces/drag-operation';\nimport { PreviewEvent } from '../../interfaces/preview-event';\nimport { SchedulerEvent } from '../../interfaces/scheduler-event';\nimport { SchedulerEventPart } from '../../interfaces/scheduler-event-part';\nimport { SchedulerEventWithParts } from '../../interfaces/scheduler-event-with-parts';\nimport { TimeSlot } from '../../interfaces/time-slot';\nimport { BsTimelineService } from '../../services/timeline/timeline.service';\n\n@Component({\n  selector: 'bs-scheduler',\n  templateUrl: './scheduler.component.html',\n  styleUrls: ['./scheduler.component.scss'],\n})\nexport class BsSchedulerComponent implements OnDestroy {\n  constructor(private calendarMonthService: BsCalendarMonthService, private timelineService: BsTimelineService) {\n    const monday = this.calendarMonthService.getMondayBefore(new Date());\n    this.currentWeek$ = new BehaviorSubject<Date>(monday);\n\n    this.daysOfWeek$ = this.currentWeek$.pipe(\n      map((weekMonday) => {\n        weekMonday.setHours(0);\n        weekMonday.setMinutes(0);\n        weekMonday.setSeconds(0);\n        weekMonday.setMilliseconds(0);\n        return Array.from(Array(7).keys()).map((x) => this.addDays(weekMonday, x));\n      })\n    );\n\n    this.daysOfWeekWithTimestamps$ = this.daysOfWeek$\n      .pipe(map((daysOfWeek) => {\n        return { start: daysOfWeek[0].getTime(), end: daysOfWeek[daysOfWeek.length - 1].getTime() + 24 * 60 * 60 * 1000 };\n      }));\n\n    this.eventParts$ = this.events$.pipe(\n      map((events) =>  events.map((ev) => this.timelineService.splitInParts(ev)))\n    );\n\n    this.eventPartsForThisWeek$ = combineLatest([\n      this.daysOfWeekWithTimestamps$,\n      this.eventParts$\n        .pipe(map(eventParts => eventParts.map(evp => evp.parts)))\n        .pipe(map(jaggedParts => {\n          return jaggedParts.reduce((flat, toFlatten) => flat.concat(toFlatten), []);\n        }))\n      ])\n      .pipe(map(([startAndEnd, eventParts]) => {\n        return eventParts.filter(eventPart => {\n          return !((eventPart.end.getTime() <= startAndEnd.start) || (eventPart.start.getTime() >= startAndEnd.end));\n        });\n      }));\n\n    this.previewEventParts$ = this.previewEvent$.pipe(\n      map((event) => {\n        if (event) {\n          return this.timelineService.splitInParts(event)\n        } else {\n          return null;\n        }\n      })\n    );\n    this.previewEventPartsForThisWeek$ = combineLatest([this.daysOfWeekWithTimestamps$, this.previewEventParts$])\n      .pipe(map(([startAndEnd, previewEventParts]) => {\n        if (previewEventParts) {\n          return previewEventParts.parts.filter(eventPart => {\n            return !((eventPart.end.getTime() <= startAndEnd.start) || (eventPart.start.getTime() >= startAndEnd.end));\n          });\n        } else {\n          return [];\n        }\n      }));\n\n    this.timelinedEventPartsForThisWeek$ = this.eventPartsForThisWeek$\n      .pipe(map(eventParts => {\n        // We'll only use the events for this week\n        const events = eventParts.map(ep => ep.event)\n          .filter((e, i, list) => list.indexOf(e) === i)\n          .filter((e) => !!e)\n          .map((e) => <SchedulerEvent>e);\n        const timeline = this.timelineService.getTimeline(events);\n\n        const result = timeline.map(track => {\n          return track.events.map(ev => {\n            return { event: ev, index: track.index };\n          });\n        })\n        .reduce((flat, toFlatten) => flat.concat(toFlatten), [])\n        .map((evi) => eventParts.filter(p => p.event === evi.event).map(p => {\n            return { part: p, index: evi.index };\n          })\n        )\n        .reduce((flat, toFlatten) => flat.concat(toFlatten), []);\n\n        return {\n          total: timeline.length,\n          parts: result\n        };\n      }))\n\n    // this.timeSlots$ = \n    combineLatest([this.daysOfWeek$, this.timeSlotDuration$])\n      .pipe(map(([daysOfWeek, duration]) => {\n        const timeSlotsPerDay = Math.floor((60 * 60 * 24) / duration);\n        return Array.from(Array(timeSlotsPerDay).keys()).map((index) => {\n          const timeSlotStart = new Date(daysOfWeek[0]);\n          timeSlotStart.setTime(+timeSlotStart.getTime() + index * duration * 1000);\n          const timeSlotEnd = new Date(timeSlotStart);\n          timeSlotEnd.setTime(+timeSlotEnd.getTime() + duration * 1000);\n\n          return daysOfWeek.map((day) => {\n            const start = new Date(day);\n            start.setHours(timeSlotStart.getHours());\n            start.setMinutes(timeSlotStart.getMinutes());\n            start.setSeconds(timeSlotStart.getSeconds());\n            start.setMilliseconds(timeSlotStart.getMilliseconds());\n\n            const end = new Date(day);\n            end.setHours(timeSlotEnd.getHours());\n            end.setMinutes(timeSlotEnd.getMinutes());\n            end.setSeconds(timeSlotEnd.getSeconds());\n            end.setMilliseconds(timeSlotEnd.getMilliseconds());\n            end.setDate(end.getDate() + timeSlotEnd.getDate() - timeSlotStart.getDate());\n\n            return <TimeSlot>{ start, end };\n          });\n        });\n      }))\n      .subscribe((timeslots) => {\n        // For performance reasons, we're not using an observable here, but persist the timeslots in a BehaviorSubject.\n        this.timeSlots$.next(timeslots);\n      });\n    \n    this.unitHeight$\n      .pipe(takeUntil(this.destroyed$))\n      .subscribe((unitHeight) => {\n        this.unitHeightChange.emit(unitHeight);\n      })\n  }\n\n  events$ = new BehaviorSubject<SchedulerEvent[]>([]);\n  eventParts$: Observable<SchedulerEventWithParts[]>;\n  eventPartsForThisWeek$: Observable<SchedulerEventPart[]>;\n  timelinedEventPartsForThisWeek$: Observable<{ total: number, parts: { part: SchedulerEventPart, index: number}[] }>;\n  \n  previewEvent$ = new BehaviorSubject<PreviewEvent | null>(null);\n  previewEventParts$: Observable<SchedulerEventWithParts | null>;\n  previewEventPartsForThisWeek$: Observable<SchedulerEventPart[]>;\n  \n  currentWeek$: BehaviorSubject<Date>;\n  daysOfWeek$: Observable<Date[]>;\n  daysOfWeekWithTimestamps$: Observable<{start: number, end: number}>;\n  timeSlotDuration$ = new BehaviorSubject<number>(1800);\n  timeSlots$ = new BehaviorSubject<TimeSlot[][]>([]);\n  // timeSlots$: Observable<TimeSlot[][]>;\n  mouseState$ = new BehaviorSubject<boolean>(false);\n  hoveredTimeSlot$ = new BehaviorSubject<TimeSlot | null>(null);\n  destroyed$ = new Subject();\n\n  @ViewChildren('slot') timeSlotElements!: QueryList<ElementRef<HTMLDivElement>>;\n\n  //#region UnitHeight\n  unitHeight$ = new BehaviorSubject<number>(40);\n  @Output() public unitHeightChange = new EventEmitter<number>();\n  public get unitHeight() {\n    return this.unitHeight$.value;\n  }\n  @Input() public set unitHeight(value: number) {\n    this.unitHeight$.next(value);\n  }\n  //#endregion\n\n  private addDays(date: Date, days: number) {\n    const result = new Date(date);\n    result.setDate(result.getDate() + days);\n    return result;\n  }\n\n  onPreviousWeek() {\n    this.currentWeek$\n      .pipe(map((w) => this.addDays(w, -7)), take(1))\n      .subscribe((w) => this.currentWeek$.next(w));\n  }\n\n  onNextWeek() {\n    this.currentWeek$\n      .pipe(map((w) => this.addDays(w, 7)), take(1))\n      .subscribe((w) => this.currentWeek$.next(w));\n  }\n\n  operation: DragOperation | null = null;\n  dragStartTimeslot: TimeSlot | null = null;\n  onCreateEvent(ev: MouseEvent, slot: TimeSlot) {\n    ev.preventDefault();\n    this.mouseState$.next(true);\n    this.dragStartTimeslot = slot;\n    this.operation = {\n      operation: EDragOperation.createEvent,\n      event: {\n        start: slot.start,\n        end: slot.end,\n        color: '#F00',\n        description: 'Test event',\n      }\n    };\n    this.previewEvent$.next({ start: slot.start, end: slot.end });\n  }\n\n  randomColor() {\n    const brightness = 128;\n    return '#' + this.randomChannel(brightness) + this.randomChannel(brightness) + this.randomChannel(brightness);\n  }\n  randomChannel(brightness: number){\n    const r = 255-brightness;\n    const n = 0|((Math.random() * r) + brightness);\n    const s = n.toString(16);\n    return (s.length==1) ? '0'+s : s;\n  }\n\n  onStartDragEvent(eventPart: SchedulerEventPart, ev: MouseEvent) {\n    ev.preventDefault();\n    this.hoveredTimeSlot$.pipe(take(1)).subscribe((hoveredTimeSlot) => {\n      if (eventPart.event) {\n        this.dragStartTimeslot = hoveredTimeSlot;\n        this.operation = {\n          operation: EDragOperation.moveEvent,\n          event: eventPart.event,\n        };\n        this.previewEvent$.next({ start: eventPart.event.start, end: eventPart.event.end });\n      }\n    });\n  }\n\n  //#region hoveredTimeslot$\n  private getHoveredTimeslot(ev: MouseEvent, timeSlots: TimeSlot[][]) {\n    const hoveredSlots = this.timeSlotElements.filter((el) => {\n      const rct = el.nativeElement.getBoundingClientRect();\n      if (rct.left <= ev.x && ev.x <= rct.right && rct.top <= ev.y && ev.y <= rct.bottom) {\n        return true;\n      } else {\n        return false;\n      }\n    });\n\n    if (!hoveredSlots || hoveredSlots.length === 0) {\n      return null;\n    }\n\n    const slotElement = hoveredSlots[0].nativeElement;\n\n    const strRow = slotElement.getAttribute('data-row');\n    if (!strRow) {\n      return null;\n    }\n    const row = parseInt(strRow);\n\n    const strColumn = slotElement.getAttribute('data-column');\n    if (!strColumn) {\n      return null;\n    }\n    const column = parseInt(strColumn);\n\n    const slot = timeSlots[row][column];\n    return slot;\n  }\n\n  @HostListener('document:mousemove', ['$event'])\n  onMousemove(ev: MouseEvent) {\n    this.timeSlots$.pipe(take(1)).subscribe((timeSlots) => {\n      const hovered = this.getHoveredTimeslot(ev, timeSlots);\n      this.hoveredTimeSlot$.next(hovered);\n\n      if (this.operation) {\n        switch (this.operation.operation) {\n          case EDragOperation.createEvent: {\n            if (this.operation.event && this.dragStartTimeslot && hovered && (this.operation.event.end.getTime() != hovered.end.getTime())) {\n              if (this.dragStartTimeslot.start.getTime() === hovered.start.getTime()) {\n                // 1 slot\n              } else if (this.dragStartTimeslot.start.getTime() < hovered.start.getTime()) {\n                // Drag down\n                this.previewEvent$\n                  .pipe(filter((ev) => !!ev && !!this.dragStartTimeslot))\n                  .pipe(map((ev) => {\n                    if (ev && this.dragStartTimeslot) {\n                      ev.start = this.dragStartTimeslot.start;\n                      ev.end = hovered.end;\n                    }\n                    return ev;\n                  }))\n                  .pipe(take(1))\n                  .subscribe((ev) => this.previewEvent$.next(ev));\n              } else if (this.dragStartTimeslot.start.getTime() > hovered.start.getTime()) {\n                // Drag up\n                this.previewEvent$\n                  .pipe(filter((ev) => !!ev && !!this.dragStartTimeslot))\n                  .pipe(map((ev) => {\n                    if (ev && this.dragStartTimeslot) {\n                      ev.start = hovered.start;\n                      ev.end = this.dragStartTimeslot.end;\n                    }\n                    return ev;\n                  }))\n                  .pipe(take(1))\n                  .subscribe((ev) => this.previewEvent$.next(ev));\n              }\n            }\n          } break;\n          case EDragOperation.moveEvent: {\n            if (hovered && this.dragStartTimeslot) {\n              // this.operation.event.start.setTime(this.operation.event.start.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime());\n              // this.operation.event.end.setTime(this.operation.event.end.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime());\n              // this.dragStartTimeslot = hovered;\n              // // this.events$.next(this.events$.value);\n\n              this.previewEvent$\n                .pipe(filter((ev) => !!ev && !!this.dragStartTimeslot))\n                .pipe(map((ev) => {\n                  if (ev && this.dragStartTimeslot) {\n                    const result =  <PreviewEvent>{\n                      start: new Date(ev.start.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime()),\n                      end: new Date(ev.end.getTime() + hovered.start.getTime() - this.dragStartTimeslot.start.getTime())\n                    };\n                    \n                    this.dragStartTimeslot = hovered;\n\n                    return result;\n                  } else {\n                    return ev;\n                  }\n                }))\n                .pipe(take(1))\n                .subscribe((ev) => {\n                  this.previewEvent$.next(ev);\n                });\n            }\n          } break;\n        }\n      }\n\n    });\n  }\n  //#endregion\n\n  @HostListener('document:mouseup', ['$event'])\n  onMouseUp(ev: MouseEvent) {\n    if (this.operation) {\n      switch (this.operation.operation) {\n        case EDragOperation.createEvent: {\n          combineLatest([this.previewEvent$])\n            .pipe(take(1))\n            .subscribe(([previewEvent]) => {\n              if (previewEvent) {\n                this.operation = null;\n                this.dragStartTimeslot = null;\n                this.events$.next([...this.events$.value, {\n                  start: previewEvent.start,\n                  end: previewEvent.end,\n                  color: this.randomColor(),\n                  description: 'New event'\n                }]);\n                this.previewEvent$.next(null);\n              }\n            });\n        } break;\n        case EDragOperation.moveEvent: {\n          this.previewEvent$\n            .pipe(filter((ev) => !!ev))\n            .pipe(take(1))\n            .subscribe((previewEvent) => {\n              if (this.operation && this.operation.event && previewEvent) {\n                this.operation.event.start = previewEvent.start;\n                this.operation.event.end = previewEvent.end;\n                this.operation = null;\n                this.dragStartTimeslot = null;\n                this.events$.next(this.events$.value);\n                this.previewEvent$.next(null);\n              }\n            });\n        } break;\n      }\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroyed$.next(true);\n  }\n}\n","<div class=\"table d-flex w-100 overflow-y-auto\" [style.max-height.px]=\"null\">\n    <div class=\"calendar-head\">\n        <div class=\"w-100 d-flex flex-row\">\n            <div class=\"d-flex calendar-left justify-content-between\">\n                <button class=\"btn btn-default flex-start\" (click)=\"onPreviousWeek()\">&lt;</button>\n                <button class=\"btn btn-default flex-end\" (click)=\"onNextWeek()\">&gt;</button>\n            </div>\n            <div class=\"flex-grow-1\" *ngFor=\"let day of (daysOfWeek$ | async)\">\n                <span class=\"d-block col-form-label text-center\">\n                    {{ day | date: 'dd-MM-yyyy' }}\n                </span>\n            </div>\n        </div>\n    </div>\n    <div class=\"calendar-body\">\n        <div class=\"position-relative\">\n            <!-- Timeslots -->\n            <div *ngFor=\"let timeslots of (timeSlots$ | async); let i = index\" class=\"d-flex flex-row p-0 timeslot\" [style.height.px]=\"unitHeight$ | async\">\n                <div class=\"calendar-cell calendar-left align-top py-0\">{{ timeslots[0].start | date: 'HH:mm:ss' }}</div>\n                <div class=\"calendar-cell flex-grow-1\" *ngFor=\"let slot of timeslots; let j = index\" #slot (mousedown)=\"onCreateEvent($event, slot)\" [attr.data-row]=\"i\" [attr.data-column]=\"j\"></div>\n            </div>\n            \n            <!-- Events -->\n            <ng-container *ngIf=\"(timeSlotDuration$ | async) as timeSlotDuration\">\n                <ng-container *ngIf=\"(unitHeight$ | async) as unitHeight\">\n                    <ng-container *ngIf=\"(timelinedEventPartsForThisWeek$ | async) as partData\">\n                        <div *ngFor=\"let eventPart of partData.parts\" class=\"event p-0\"\n                            [style.top.px]=\"(eventPart.part | bsSecondsTodayOffset) / timeSlotDuration * unitHeight\"\n                            [style.height.px]=\"(eventPart.part | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                            [style.left]=\"'calc(90px + ((100% - 90px) / 7 * ' + ((eventPart.part | dayOfWeek) - 1) + '))'\">\n                            <div class=\"event-inner\"\n                                [style.width]=\"'calc(100% / ' + partData.total + ')'\"\n                                [style.height.px]=\"(eventPart.part | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                                [style.margin-left]=\"'calc(100% / ' + partData.total + ' * ' + eventPart.index + ')'\"\n                                (mousedown)=\"onStartDragEvent(eventPart.part, $event)\">\n                                <div class=\"event-border\"></div>\n                                <ng-container *ngIf=\"eventPart.part.event\">\n                                    <div class=\"event-bg\" [style.background-color]=\"eventPart.part.event.color\"></div>\n                                    <div class=\"event-label\">{{ eventPart.part.event.description }}</div>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </ng-container>\n                    <ng-container *ngIf=\"(previewEventPartsForThisWeek$ | async) as previewPartData\">\n                        <div *ngFor=\"let eventPart of previewPartData\" class=\"event preview p-0\"\n                            [style.top.px]=\"(eventPart | bsSecondsTodayOffset) / timeSlotDuration * unitHeight\"\n                            [style.height.px]=\"(eventPart | bsSecondsTimespan) / timeSlotDuration * unitHeight\"\n                            [style.left]=\"'calc(90px + ((100% - 90px) / 7 * ' + ((eventPart | dayOfWeek) - 1) + '))'\">\n                            <div class=\"event-inner w-100\" [style.height.px]=\"(eventPart | bsSecondsTimespan) / timeSlotDuration * unitHeight\"></div>\n                        </div>\n                    </ng-container>\n                </ng-container>\n            </ng-container>\n        </div>\n    </div>\n</div>"]}

package/esm2020/lib/components/scheduler/enums/drag-operation.mjs

@@ -0,0 +1,8 @@
+export var EDragOperation;
+(function (EDragOperation) {
+    EDragOperation[EDragOperation["none"] = 0] = "none";
+    EDragOperation[EDragOperation["createEvent"] = 1] = "createEvent";
+    EDragOperation[EDragOperation["resizeEvent"] = 2] = "resizeEvent";
+    EDragOperation[EDragOperation["moveEvent"] = 3] = "moveEvent";
+})(EDragOperation || (EDragOperation = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1vcGVyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL3NyYy9saWIvY29tcG9uZW50cy9zY2hlZHVsZXIvZW51bXMvZHJhZy1vcGVyYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksY0FLWDtBQUxELFdBQVksY0FBYztJQUN0QixtREFBSSxDQUFBO0lBQ0osaUVBQVcsQ0FBQTtJQUNYLGlFQUFXLENBQUE7SUFDWCw2REFBUyxDQUFBO0FBQ2IsQ0FBQyxFQUxXLGNBQWMsS0FBZCxjQUFjLFFBS3pCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gRURyYWdPcGVyYXRpb24ge1xuICAgIG5vbmUsXG4gICAgY3JlYXRlRXZlbnQsXG4gICAgcmVzaXplRXZlbnQsXG4gICAgbW92ZUV2ZW50LFxufSJdfQ==

package/esm2020/lib/components/scheduler/index.mjs

@@ -0,0 +1,3 @@
+export * from './components';
+export * from './scheduler.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL3NyYy9saWIvY29tcG9uZW50cy9zY2hlZHVsZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL3NjaGVkdWxlci5tb2R1bGUnOyJdfQ==

package/esm2020/lib/components/scheduler/interfaces/drag-operation.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1vcGVyYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL3NyYy9saWIvY29tcG9uZW50cy9zY2hlZHVsZXIvaW50ZXJmYWNlcy9kcmFnLW9wZXJhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRURyYWdPcGVyYXRpb24gfSBmcm9tIFwiLi4vZW51bXMvZHJhZy1vcGVyYXRpb25cIjtcbmltcG9ydCB7IFNjaGVkdWxlckV2ZW50IH0gZnJvbSBcIi4vc2NoZWR1bGVyLWV2ZW50XCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRHJhZ09wZXJhdGlvbiB7XG4gICAgb3BlcmF0aW9uOiBFRHJhZ09wZXJhdGlvbjtcbiAgICBldmVudDogU2NoZWR1bGVyRXZlbnQ7XG59Il19

package/esm2020/lib/components/scheduler/interfaces/preview-event.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmlldy1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbWludHBsYXllci1uZy1ib290c3RyYXAvc3JjL2xpYi9jb21wb25lbnRzL3NjaGVkdWxlci9pbnRlcmZhY2VzL3ByZXZpZXctZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUHJldmlld0V2ZW50IHtcbiAgICBzdGFydDogRGF0ZTtcbiAgICBlbmQ6IERhdGU7XG59Il19

package/esm2020/lib/components/scheduler/interfaces/scheduler-event-part.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVyLWV2ZW50LXBhcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL3NyYy9saWIvY29tcG9uZW50cy9zY2hlZHVsZXIvaW50ZXJmYWNlcy9zY2hlZHVsZXItZXZlbnQtcGFydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NoZWR1bGVyRXZlbnQgfSBmcm9tIFwiLi9zY2hlZHVsZXItZXZlbnRcIjtcblxuZXhwb3J0IGludGVyZmFjZSBTY2hlZHVsZXJFdmVudFBhcnQge1xuICAgIHN0YXJ0OiBEYXRlO1xuICAgIGVuZDogRGF0ZTtcbiAgICBldmVudDogU2NoZWR1bGVyRXZlbnQgfCBudWxsO1xufSJdfQ==

package/esm2020/lib/components/scheduler/interfaces/scheduler-event-with-parts.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVyLWV2ZW50LXdpdGgtcGFydHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL3NyYy9saWIvY29tcG9uZW50cy9zY2hlZHVsZXIvaW50ZXJmYWNlcy9zY2hlZHVsZXItZXZlbnQtd2l0aC1wYXJ0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NoZWR1bGVyRXZlbnQgfSBmcm9tIFwiLi9zY2hlZHVsZXItZXZlbnRcIjtcbmltcG9ydCB7IFNjaGVkdWxlckV2ZW50UGFydCB9IGZyb20gXCIuL3NjaGVkdWxlci1ldmVudC1wYXJ0XCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2NoZWR1bGVyRXZlbnRXaXRoUGFydHMge1xuICAgIGV2ZW50OiBTY2hlZHVsZXJFdmVudDtcbiAgICBwYXJ0czogU2NoZWR1bGVyRXZlbnRQYXJ0W107XG59Il19

package/esm2020/lib/components/scheduler/interfaces/scheduler-event.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVyLWV2ZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9taW50cGxheWVyLW5nLWJvb3RzdHJhcC9zcmMvbGliL2NvbXBvbmVudHMvc2NoZWR1bGVyL2ludGVyZmFjZXMvc2NoZWR1bGVyLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVkdWxlckV2ZW50IHtcbiAgICBzdGFydDogRGF0ZTtcbiAgICBlbmQ6IERhdGU7XG4gICAgY29sb3I6IHN0cmluZztcbiAgICBkZXNjcmlwdGlvbjogc3RyaW5nO1xufSJdfQ==

package/esm2020/lib/components/scheduler/interfaces/time-slot.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZS1zbG90LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9taW50cGxheWVyLW5nLWJvb3RzdHJhcC9zcmMvbGliL2NvbXBvbmVudHMvc2NoZWR1bGVyL2ludGVyZmFjZXMvdGltZS1zbG90LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFRpbWVTbG90IHtcbiAgICBzdGFydDogRGF0ZTtcbiAgICBlbmQ6IERhdGU7XG59Il19

package/esm2020/lib/components/scheduler/interfaces/timeline-track.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZWxpbmUtdHJhY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL3NyYy9saWIvY29tcG9uZW50cy9zY2hlZHVsZXIvaW50ZXJmYWNlcy90aW1lbGluZS10cmFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NoZWR1bGVyRXZlbnQgfSBmcm9tIFwiLi9zY2hlZHVsZXItZXZlbnRcIjtcblxuZXhwb3J0IGludGVyZmFjZSBUaW1lbGluZVRyYWNrIHtcbiAgICBpbmRleDogbnVtYmVyO1xuICAgIGV2ZW50czogU2NoZWR1bGVyRXZlbnRbXTtcbn0iXX0=

package/esm2020/lib/components/scheduler/pipes/bs-seconds-timespan.pipe/bs-seconds-timespan.pipe.mjs

@@ -0,0 +1,16 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BsSecondsTimespanPipe {
+    transform(value) {
+        return (value.end.getTime() - value.start.getTime()) / 1000;
+    }
+}
+BsSecondsTimespanPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSecondsTimespanPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+BsSecondsTimespanPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSecondsTimespanPipe, name: "bsSecondsTimespan" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSecondsTimespanPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'bsSecondsTimespan'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtc2Vjb25kcy10aW1lc3Bhbi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9taW50cGxheWVyLW5nLWJvb3RzdHJhcC9zcmMvbGliL2NvbXBvbmVudHMvc2NoZWR1bGVyL3BpcGVzL2JzLXNlY29uZHMtdGltZXNwYW4ucGlwZS9icy1zZWNvbmRzLXRpbWVzcGFuLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBT3BELE1BQU0sT0FBTyxxQkFBcUI7SUFFaEMsU0FBUyxDQUFDLEtBQTBDO1FBQ2xELE9BQU8sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUM7SUFDOUQsQ0FBQzs7a0hBSlUscUJBQXFCO2dIQUFyQixxQkFBcUI7MkZBQXJCLHFCQUFxQjtrQkFIakMsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsbUJBQW1CO2lCQUMxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFNjaGVkdWxlckV2ZW50IH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcy9zY2hlZHVsZXItZXZlbnQnO1xuaW1wb3J0IHsgU2NoZWR1bGVyRXZlbnRQYXJ0IH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcy9zY2hlZHVsZXItZXZlbnQtcGFydCc7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2JzU2Vjb25kc1RpbWVzcGFuJ1xufSlcbmV4cG9ydCBjbGFzcyBCc1NlY29uZHNUaW1lc3BhblBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcblxuICB0cmFuc2Zvcm0odmFsdWU6IFNjaGVkdWxlckV2ZW50UGFydCB8IFNjaGVkdWxlckV2ZW50KSB7XG4gICAgcmV0dXJuICh2YWx1ZS5lbmQuZ2V0VGltZSgpIC0gdmFsdWUuc3RhcnQuZ2V0VGltZSgpKSAvIDEwMDA7XG4gIH1cblxufVxuIl19

package/esm2020/lib/components/scheduler/pipes/bs-seconds-today-offset/bs-seconds-today-offset.pipe.mjs

@@ -0,0 +1,20 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BsSecondsTodayOffsetPipe {
+    transform(value) {
+        const today = new Date(value.start);
+        today.setHours(0);
+        today.setMinutes(0);
+        today.setSeconds(0);
+        return (value.start.getTime() - today.getTime()) / 1000;
+    }
+}
+BsSecondsTodayOffsetPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSecondsTodayOffsetPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+BsSecondsTodayOffsetPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSecondsTodayOffsetPipe, name: "bsSecondsTodayOffset" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsSecondsTodayOffsetPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'bsSecondsTodayOffset'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtc2Vjb25kcy10b2RheS1vZmZzZXQucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbWludHBsYXllci1uZy1ib290c3RyYXAvc3JjL2xpYi9jb21wb25lbnRzL3NjaGVkdWxlci9waXBlcy9icy1zZWNvbmRzLXRvZGF5LW9mZnNldC9icy1zZWNvbmRzLXRvZGF5LW9mZnNldC5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQU9wRCxNQUFNLE9BQU8sd0JBQXdCO0lBRW5DLFNBQVMsQ0FBQyxLQUEwQztRQUNsRCxNQUFNLEtBQUssR0FBRyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDcEMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBRTVELE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxHQUFHLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQztJQUMxRCxDQUFDOztxSEFQVSx3QkFBd0I7bUhBQXhCLHdCQUF3QjsyRkFBeEIsd0JBQXdCO2tCQUhwQyxJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxzQkFBc0I7aUJBQzdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU2NoZWR1bGVyRXZlbnQgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzL3NjaGVkdWxlci1ldmVudCc7XG5pbXBvcnQgeyBTY2hlZHVsZXJFdmVudFBhcnQgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzL3NjaGVkdWxlci1ldmVudC1wYXJ0JztcblxuQFBpcGUoe1xuICBuYW1lOiAnYnNTZWNvbmRzVG9kYXlPZmZzZXQnXG59KVxuZXhwb3J0IGNsYXNzIEJzU2Vjb25kc1RvZGF5T2Zmc2V0UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gIHRyYW5zZm9ybSh2YWx1ZTogU2NoZWR1bGVyRXZlbnRQYXJ0IHwgU2NoZWR1bGVyRXZlbnQpIHtcbiAgICBjb25zdCB0b2RheSA9IG5ldyBEYXRlKHZhbHVlLnN0YXJ0KTtcbiAgICB0b2RheS5zZXRIb3VycygwKTsgdG9kYXkuc2V0TWludXRlcygwKTsgdG9kYXkuc2V0U2Vjb25kcygwKTtcblxuICAgIHJldHVybiAodmFsdWUuc3RhcnQuZ2V0VGltZSgpIC0gdG9kYXkuZ2V0VGltZSgpKSAvIDEwMDA7XG4gIH1cblxufVxuIl19

package/esm2020/lib/components/scheduler/pipes/date-offset/date-offset.pipe.mjs

@@ -0,0 +1,20 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DateOffsetPipe {
+    transform(value) {
+        const today = new Date(value.start);
+        today.setHours(0);
+        today.setMinutes(0);
+        today.setSeconds(0);
+        return (value.start.getTime() - today.getTime()) / 1000;
+    }
+}
+DateOffsetPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DateOffsetPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DateOffsetPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DateOffsetPipe, name: "dateOffset" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: DateOffsetPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateOffset'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1vZmZzZXQucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbWludHBsYXllci1uZy1ib290c3RyYXAvc3JjL2xpYi9jb21wb25lbnRzL3NjaGVkdWxlci9waXBlcy9kYXRlLW9mZnNldC9kYXRlLW9mZnNldC5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQU1wRCxNQUFNLE9BQU8sY0FBYztJQUV6QixTQUFTLENBQUMsS0FBeUI7UUFDakMsTUFBTSxLQUFLLEdBQUcsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3BDLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUU1RCxPQUFPLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsR0FBRyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUM7SUFDMUQsQ0FBQzs7MkdBUFUsY0FBYzt5R0FBZCxjQUFjOzJGQUFkLGNBQWM7a0JBSDFCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLFlBQVk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU2NoZWR1bGVyRXZlbnRQYXJ0IH0gZnJvbSAnLi4vLi4vaW50ZXJmYWNlcy9zY2hlZHVsZXItZXZlbnQtcGFydCc7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2RhdGVPZmZzZXQnXG59KVxuZXhwb3J0IGNsYXNzIERhdGVPZmZzZXRQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgdHJhbnNmb3JtKHZhbHVlOiBTY2hlZHVsZXJFdmVudFBhcnQpIHtcbiAgICBjb25zdCB0b2RheSA9IG5ldyBEYXRlKHZhbHVlLnN0YXJ0KTtcbiAgICB0b2RheS5zZXRIb3VycygwKTsgdG9kYXkuc2V0TWludXRlcygwKTsgdG9kYXkuc2V0U2Vjb25kcygwKTtcblxuICAgIHJldHVybiAodmFsdWUuc3RhcnQuZ2V0VGltZSgpIC0gdG9kYXkuZ2V0VGltZSgpKSAvIDEwMDA7XG4gIH1cblxufVxuIl19