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

package/esm2015/views/agenda/agenda-view-list.component.js

@@ -0,0 +1,170 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, HostBinding, Input } from '@angular/core';
+import { toLocalDate } from '@progress/kendo-date-math';
+import { convertNgClassBindings } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-intl";
+import * as i2 from "@progress/kendo-angular-l10n";
+import * as i3 from "./agenda-header-item.component";
+import * as i4 from "./agenda-task-item.component";
+import * as i5 from "@angular/common";
+import * as i6 from "../../navigation/focusable.directive";
+/**
+ * @hidden
+ */
+export class AgendaListComponent {
+    constructor(intlService, localization) {
+        this.intlService = intlService;
+        this.localization = localization;
+        this.classes = true;
+    }
+    extractDataItem(item) {
+        return item.type === "group" ? item.dataItem.items[0] : item.dataItem;
+    }
+    formatTime(dataItem) {
+        if (dataItem.isAllDay) {
+            return this.localization.get('allDay');
+        }
+        let format = "{0:t}-{1:t}";
+        if (dataItem.head) {
+            format = "{0:t}";
+        }
+        else if (dataItem.tail) {
+            format = "{1:t}";
+        }
+        return this.intlService.format(format, toLocalDate(dataItem.start), toLocalDate(dataItem.end));
+    }
+    trackByFn(index, _item) {
+        return index;
+    }
+    cellClasses(item) {
+        const task = this.extractDataItem(item);
+        let result = [];
+        if (this.slotClass) {
+            result = result.concat(convertNgClassBindings(this.slotClass({
+                start: task.start,
+                end: task.end,
+                resources: task.resources,
+                event: task.event
+            })));
+        }
+        if (this.eventClass) {
+            result = result.concat(convertNgClassBindings(this.eventClass({
+                event: task.event,
+                resources: task.resources
+            })));
+        }
+        return result;
+    }
+    getEventStyles(item) {
+        if (this.eventStyles) {
+            const task = this.extractDataItem(item);
+            return this.eventStyles({
+                event: task.event,
+                resources: task.resources
+            });
+        }
+    }
+}
+AgendaListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaListComponent, deps: [{ token: i1.IntlService }, { token: i2.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+AgendaListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: AgendaListComponent, selector: "[kendoSchedulerAgendaList]", inputs: { tasks: "tasks", eventTemplate: "eventTemplate", slotClass: "slotClass", eventClass: "eventClass", eventStyles: "eventStyles", agendaTimeTemplate: "agendaTimeTemplate", agendaDateTemplate: "agendaDateTemplate", editable: "editable" }, host: { properties: { "class.k-scheduler-content": "this.classes" } }, ngImport: i0, template: `
+        <table class="k-scheduler-table" role="presentation">
+            <tbody>
+                <ng-container *ngFor="let group of tasks; let groupIndex = index;">
+                    <tr *ngFor="let item of group.tasks;let index = index; trackBy: trackByFn">
+                        <ng-container *ngFor="let resource of group.resources;let resourceIndex = index">
+                            <td *ngIf="group.spans[resourceIndex] && index === 0" class="k-scheduler-groupcolumn" [attr.rowspan]="group.spans[resourceIndex]">
+                                {{ resource }}
+                            </td>
+                        </ng-container>
+                        <td *ngIf="item.type === 'group'"
+                            [kendoSchedulerAgendaHeaderItem]="item"
+                            [agendaDateTemplate]="agendaDateTemplate">
+                        </td>
+                        <td class="k-scheduler-timecolumn">
+                            <div *ngIf="!agendaTimeTemplate">
+                                <span class="k-icon k-i-arrow-60-left" *ngIf="extractDataItem(item).tail"></span>
+                                {{formatTime(extractDataItem(item)) }}
+                                <span class="k-icon k-i-arrow-60-right" *ngIf="extractDataItem(item).head"></span>
+                            </div>
+                            <ng-container *ngIf="agendaTimeTemplate" [ngTemplateOutlet]="agendaTimeTemplate"
+                                [ngTemplateOutletContext]="extractDataItem(item)">
+                            </ng-container>
+                        </td>
+                        <td [attr.data-group-index]="groupIndex" [attr.data-task-index]="index"
+                            [ngClass]="cellClasses(item)" [ngStyle]="getEventStyles(item)"
+                            [kendoSchedulerFocusIndex]="groupIndex"
+                            [kendoSchedulerAgendaTaskItem]="extractDataItem(item)"
+                                [editable]="editable"
+                                [eventTemplate]="eventTemplate"
+                        ></td>
+                    </tr>
+                </ng-container>
+            </tbody>
+        </table>
+    `, isInline: true, components: [{ type: i3.AgendaHeaderItemComponent, selector: "[kendoSchedulerAgendaHeaderItem]", inputs: ["kendoSchedulerAgendaHeaderItem", "agendaDateTemplate"] }, { type: i4.AgendaTaskItemComponent, selector: "[kendoSchedulerAgendaTaskItem]", inputs: ["kendoSchedulerAgendaTaskItem", "color", "eventTemplate", "editable"] }], directives: [{ type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i5.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i6.FocusableDirective, selector: "[kendoSchedulerFocusIndex]", inputs: ["kendoSchedulerFocusIndex"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: '[kendoSchedulerAgendaList]',
+                    template: `
+        <table class="k-scheduler-table" role="presentation">
+            <tbody>
+                <ng-container *ngFor="let group of tasks; let groupIndex = index;">
+                    <tr *ngFor="let item of group.tasks;let index = index; trackBy: trackByFn">
+                        <ng-container *ngFor="let resource of group.resources;let resourceIndex = index">
+                            <td *ngIf="group.spans[resourceIndex] && index === 0" class="k-scheduler-groupcolumn" [attr.rowspan]="group.spans[resourceIndex]">
+                                {{ resource }}
+                            </td>
+                        </ng-container>
+                        <td *ngIf="item.type === 'group'"
+                            [kendoSchedulerAgendaHeaderItem]="item"
+                            [agendaDateTemplate]="agendaDateTemplate">
+                        </td>
+                        <td class="k-scheduler-timecolumn">
+                            <div *ngIf="!agendaTimeTemplate">
+                                <span class="k-icon k-i-arrow-60-left" *ngIf="extractDataItem(item).tail"></span>
+                                {{formatTime(extractDataItem(item)) }}
+                                <span class="k-icon k-i-arrow-60-right" *ngIf="extractDataItem(item).head"></span>
+                            </div>
+                            <ng-container *ngIf="agendaTimeTemplate" [ngTemplateOutlet]="agendaTimeTemplate"
+                                [ngTemplateOutletContext]="extractDataItem(item)">
+                            </ng-container>
+                        </td>
+                        <td [attr.data-group-index]="groupIndex" [attr.data-task-index]="index"
+                            [ngClass]="cellClasses(item)" [ngStyle]="getEventStyles(item)"
+                            [kendoSchedulerFocusIndex]="groupIndex"
+                            [kendoSchedulerAgendaTaskItem]="extractDataItem(item)"
+                                [editable]="editable"
+                                [eventTemplate]="eventTemplate"
+                        ></td>
+                    </tr>
+                </ng-container>
+            </tbody>
+        </table>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IntlService }, { type: i2.LocalizationService }]; }, propDecorators: { classes: [{
+                type: HostBinding,
+                args: ['class.k-scheduler-content']
+            }], tasks: [{
+                type: Input
+            }], eventTemplate: [{
+                type: Input
+            }], slotClass: [{
+                type: Input
+            }], eventClass: [{
+                type: Input
+            }], eventStyles: [{
+                type: Input
+            }], agendaTimeTemplate: [{
+                type: Input
+            }], agendaDateTemplate: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }] } });

package/esm2015/views/agenda/agenda-view.component.js

@@ -0,0 +1,112 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef, Input, ContentChild, ChangeDetectionStrategy } from '@angular/core';
+import { ConfigurationViewBase } from '../common/configuration-view-base';
+import { SchedulerView } from '../../types';
+import { EventTemplateDirective, AgendaTimeTemplateDirective, AgendaDateTemplateDirective } from '../templates';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+import * as i2 from "../view-context.service";
+import * as i3 from "../view-state.service";
+import * as i4 from "./agenda-view-internal.component";
+/**
+ * The component for rendering the **Agenda** view.
+ */
+export class AgendaViewComponent extends ConfigurationViewBase {
+    constructor(localization, changeDetector, viewContext, viewState) {
+        super(localization, changeDetector, viewContext, viewState);
+        /**
+         * The long-date format for displaying the
+         * selected date in the Scheduler toolbar.
+         * Defaults to `{0:D} - {1:D}`,
+         * where `0` is the start and `1` is the end date
+         * ([more information]({% slug parsingandformatting_intl %}#toc-date-formatting)).
+         */
+        this.selectedDateFormat = '{0:D} - {1:D}';
+        /**
+         * The short-date format for displaying the
+         * selected date in the Scheduler toolbar.
+         * Defaults to `{0:d} - {1:d}`,
+         * where `0` is the start and `1` is the end date
+         * ([more information]({% slug parsingandformatting_intl %}#toc-date-formatting)).
+         */
+        this.selectedShortDateFormat = '{0:d} - {1:d}';
+        /**
+         * Specifies the number of days that the view will render.
+         * Defaults to `7`.
+         */
+        this.numberOfDays = 7;
+        /**
+         * The invariant name for this view (`agenda`).
+         */
+        this.name = 'agenda';
+    }
+    /**
+     * @hidden
+     */
+    get title() {
+        return this.localization.get('agendaViewTitle');
+    }
+}
+AgendaViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaViewComponent, deps: [{ token: i1.LocalizationService }, { token: i0.ChangeDetectorRef }, { token: i2.ViewContextService }, { token: i3.ViewStateService }], target: i0.ɵɵFactoryTarget.Component });
+AgendaViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: AgendaViewComponent, selector: "kendo-scheduler-agenda-view", inputs: { selectedDateFormat: "selectedDateFormat", selectedShortDateFormat: "selectedShortDateFormat", numberOfDays: "numberOfDays" }, providers: [{
+            provide: SchedulerView,
+            useExisting: forwardRef(() => AgendaViewComponent)
+        }], queries: [{ propertyName: "eventTemplate", first: true, predicate: EventTemplateDirective, descendants: true }, { propertyName: "agendaTimeTemplate", first: true, predicate: AgendaTimeTemplateDirective, descendants: true }, { propertyName: "agendaDateTemplate", first: true, predicate: AgendaDateTemplateDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+        <ng-template #content>
+            <agenda-view-internal
+                [numberOfDays]="numberOfDays"
+                [eventTemplate]="eventTemplate?.templateRef"
+                [slotClass]="viewSlotClass"
+                [eventClass]="viewEventClass"
+                [eventStyles]="viewEventStyles"
+                [agendaTimeTemplate]="agendaTimeTemplate?.templateRef"
+                [agendaDateTemplate]="agendaDateTemplate?.templateRef"
+                [selectedDateFormat]="selectedDateFormat"
+                [selectedShortDateFormat]="selectedShortDateFormat">
+            </agenda-view-internal>
+        </ng-template>
+    `, isInline: true, components: [{ type: i4.AgendaViewInternalComponent, selector: "agenda-view-internal", inputs: ["eventTemplate", "slotClass", "eventClass", "eventStyles", "agendaTimeTemplate", "agendaDateTemplate", "selectedDateFormat", "selectedShortDateFormat", "numberOfDays"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    selector: 'kendo-scheduler-agenda-view',
+                    providers: [{
+                            provide: SchedulerView,
+                            useExisting: forwardRef(() => AgendaViewComponent)
+                        }],
+                    template: `
+        <ng-template #content>
+            <agenda-view-internal
+                [numberOfDays]="numberOfDays"
+                [eventTemplate]="eventTemplate?.templateRef"
+                [slotClass]="viewSlotClass"
+                [eventClass]="viewEventClass"
+                [eventStyles]="viewEventStyles"
+                [agendaTimeTemplate]="agendaTimeTemplate?.templateRef"
+                [agendaDateTemplate]="agendaDateTemplate?.templateRef"
+                [selectedDateFormat]="selectedDateFormat"
+                [selectedShortDateFormat]="selectedShortDateFormat">
+            </agenda-view-internal>
+        </ng-template>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }, { type: i0.ChangeDetectorRef }, { type: i2.ViewContextService }, { type: i3.ViewStateService }]; }, propDecorators: { selectedDateFormat: [{
+                type: Input
+            }], selectedShortDateFormat: [{
+                type: Input
+            }], numberOfDays: [{
+                type: Input
+            }], eventTemplate: [{
+                type: ContentChild,
+                args: [EventTemplateDirective, { static: false }]
+            }], agendaTimeTemplate: [{
+                type: ContentChild,
+                args: [AgendaTimeTemplateDirective, { static: false }]
+            }], agendaDateTemplate: [{
+                type: ContentChild,
+                args: [AgendaDateTemplateDirective, { static: false }]
+            }] } });

package/esm2015/views/agenda/agenda-view.module.js

@@ -0,0 +1,44 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { IntlModule } from '@progress/kendo-angular-intl';
+import { AgendaHeaderItemComponent } from './agenda-header-item.component';
+import { AgendaHeaderComponent } from './agenda-header.component';
+import { AgendaTaskItemComponent } from './agenda-task-item.component';
+import { AgendaListComponent } from './agenda-view-list.component';
+import { AgendaViewComponent } from './agenda-view.component';
+import { AgendaViewInternalComponent } from './agenda-view-internal.component';
+import { SharedModule } from '../../shared.module';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    AgendaHeaderComponent,
+    AgendaHeaderItemComponent,
+    AgendaListComponent,
+    AgendaTaskItemComponent,
+    AgendaViewComponent,
+    AgendaViewInternalComponent
+];
+/**
+ * @hidden
+ */
+export class AgendaViewModule {
+}
+AgendaViewModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AgendaViewModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaViewModule, declarations: [AgendaHeaderComponent,
+        AgendaHeaderItemComponent,
+        AgendaListComponent,
+        AgendaTaskItemComponent,
+        AgendaViewComponent,
+        AgendaViewInternalComponent], imports: [CommonModule, IntlModule, SharedModule], exports: [AgendaViewComponent] });
+AgendaViewModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaViewModule, imports: [[CommonModule, IntlModule, SharedModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AgendaViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, IntlModule, SharedModule],
+                    exports: [AgendaViewComponent],
+                    declarations: [COMPONENTS]
+                }]
+        }] });

package/esm2015/views/agenda/tasks.collection.js

@@ -0,0 +1,78 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { groupBy, orderBy } from '@progress/kendo-data-query';
+import { iterator } from '../../common/util';
+const flip = fn => a => b => fn(b, a);
+const sort = flip(orderBy);
+const group = flip(groupBy);
+/**
+ * @hidden
+ */
+export const compose = (...args) => (data) => args.reduceRight((acc, curr) => curr(acc), data);
+/**
+ * @hidden
+ */
+export const processEvents = (_start, _end) => compose(group([{ field: "startDate" }]), sort([{ field: "start", dir: "asc" }, { field: "end", dir: "asc" }]));
+function* flattenGroups(groups) {
+    for (let index = 0; index < groups.length; index++) {
+        const groupItem = groups[index];
+        yield {
+            type: "group",
+            dataItem: groupItem,
+            rowSpan: groupItem.items.length
+        };
+        for (let itemIndex = 1; itemIndex < groupItem.items.length; itemIndex++) {
+            const item = groupItem.items[itemIndex];
+            yield {
+                type: "event",
+                dataItem: item
+            };
+        }
+    }
+}
+/** @hidden */
+export class EmptyIterator {
+    [iterator]() {
+        return {
+            next: () => ({ done: true, value: null })
+        };
+    }
+    toString() {
+        return "Empty Iterator";
+    }
+}
+/**
+ * @hidden
+ */
+export class TaskCollection {
+    constructor(start, end, events) {
+        this.start = start;
+        this.end = end;
+        this.events = events;
+        this.createIterator = compose(flattenGroups, processEvents(this.start, this.end));
+    }
+    static empty() {
+        return (new EmptyIterator());
+    }
+    [iterator]() {
+        return this.createIterator(this.events);
+    }
+    itemAt(index) {
+        const taskIterator = this.createIterator(this.events);
+        let idx = 0;
+        let item;
+        do {
+            item = taskIterator.next();
+            if (item && idx === index) {
+                const value = item.value;
+                return value.type === 'group' ? value.dataItem.items[0] : value.dataItem;
+            }
+            idx++;
+        } while (item);
+    }
+    toString() {
+        return this.events.toString();
+    }
+}

package/esm2015/views/agenda/utils.js

@@ -0,0 +1,167 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { TaskCollection, compose } from './tasks.collection';
+import { MS_PER_DAY } from '@progress/kendo-date-math';
+import { intersects, eventResources, toUTCDate, addUTCDays, getUTCDate } from '../utils';
+import { getField } from '../../common/util';
+/**
+ * @hidden
+ */
+export function createResourceGroups(groupedResources) {
+    let result = [];
+    const firstResource = groupedResources[0];
+    const firstResourceData = firstResource.data;
+    for (let dataIdx = 0; dataIdx < firstResourceData.length; dataIdx++) {
+        const item = firstResourceData[dataIdx];
+        result.push({ resources: [getField(item, firstResource.textField)] });
+    }
+    for (let idx = 1; idx < groupedResources.length; idx++) {
+        const resource = groupedResources[idx];
+        const data = resource.data;
+        const current = [];
+        for (let resourceIdx = 0; resourceIdx < result.length; resourceIdx++) {
+            const resourceItem = result[resourceIdx];
+            for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
+                const item = data[dataIdx];
+                current.push({ resources: resourceItem.resources.concat(getField(item, resource.textField)) });
+            }
+        }
+        result = current;
+    }
+    return result;
+}
+function createTask(item, resourceIdx, resources, color) {
+    const event = item.event;
+    return {
+        event,
+        start: item.start.toUTCDate(),
+        end: item.end.toUTCDate(),
+        title: event.title,
+        isAllDay: event.isAllDay,
+        color,
+        resourceIdx,
+        resources
+    };
+}
+const durationInDays = ({ start, end, isAllDay = false }) => {
+    const eventEnd = isAllDay ? getUTCDate(end) : end;
+    const duration = Math.ceil((eventEnd - +getUTCDate(start)) / MS_PER_DAY);
+    if (isAllDay) {
+        return duration + 1;
+    }
+    return duration;
+};
+const curry = fn => {
+    const len = fn.length;
+    return (...args) => len === args.length
+        ? fn.apply(null, args)
+        : curry(fn.bind(null, ...args));
+};
+const range = num => Array.from(new Array(num).keys());
+const cloneTask = (eventStart, eventEnd) => task => (Object.assign(Object.assign({}, task), { start: getUTCDate(eventStart), end: task.tail && !task.isAllDay ? eventEnd : addUTCDays(eventStart, 1), startDate: getUTCDate(eventStart) }));
+const previousEventEnd = (start, events) => events.length
+    ? events[events.length - 1].end
+    : start;
+const markAsTail = isLast => task => {
+    if (isLast) {
+        task.tail = true;
+    }
+    return task;
+};
+const markAsMid = task => {
+    if (!task.tail) {
+        task.mid = true;
+    }
+    return task;
+};
+const addTaskPart = (task, start) => (tasks, _, day, days) => tasks.concat(compose(markAsMid, cloneTask(previousEventEnd(start, tasks), task.end), markAsTail(day === days.length - 1))(task));
+const splitMultiDayTask = (task, start) => range(durationInDays(task) - 1)
+    .reduce(addTaskPart(task, start), []);
+/**
+ * @hidden
+ */
+export const splitTasks = curry((periodStart, periodEnd, tasks) => {
+    const result = [];
+    for (let index = 0; index < tasks.length; index++) {
+        let task = Object.assign({}, tasks[index]);
+        task.startDate = getUTCDate(task.start);
+        if (task.start >= periodStart && task.start <= periodEnd) {
+            result.push(task);
+        }
+        if (durationInDays(task) > 1) {
+            task.end = addUTCDays(task.startDate, 1);
+            task.head = true;
+            result.push(...splitMultiDayTask(Object.assign({}, tasks[index]), task.end)
+                .filter(tsk => getUTCDate(tsk.end) <= periodEnd && tsk.start >= periodStart));
+        }
+    }
+    return result;
+});
+function groupByResource(groupedResources, resourceGroups, dateRange) {
+    const groups = resourceGroups.filter(group => group.tasks && group.tasks.length);
+    if (!groups.length) {
+        return [];
+    }
+    const values = groups[0].resources.map(resource => ({ value: resource, span: 0, groupIdx: 0 }));
+    const periodStart = toUTCDate(dateRange.start);
+    const periodEnd = toUTCDate(dateRange.end);
+    for (let groupIdx = 0; groupIdx < groups.length; groupIdx++) {
+        const group = groups[groupIdx];
+        group.tasks = splitTasks(periodStart, periodEnd, group.tasks);
+        const count = group.tasks.length;
+        group.tasks = new TaskCollection(periodStart, periodEnd, group.tasks);
+        let invalidate = false;
+        for (let resourceIdx = 0; resourceIdx < groupedResources.length; resourceIdx++) {
+            const resourceValue = values[resourceIdx];
+            if (resourceValue.value !== group.resources[resourceIdx] || invalidate) {
+                resourceValue.value = group.resources[resourceIdx];
+                const spanGroup = groups[resourceValue.groupIdx];
+                spanGroup.spans = spanGroup.spans || [];
+                spanGroup.spans[resourceIdx] = resourceValue.span;
+                resourceValue.span = count;
+                resourceValue.groupIdx = groupIdx;
+                invalidate = true;
+            }
+            else {
+                resourceValue.span += count;
+            }
+        }
+    }
+    values.forEach((value, index) => {
+        const group = groups[value.groupIdx];
+        group.spans = group.spans || [];
+        group.spans[index] = value.span;
+    });
+    return groups;
+}
+/**
+ * @hidden
+ */
+export function groupEvents(items, { taskResources, resourceGroups, spans, allResources, dateRange }) {
+    const groups = resourceGroups || [{}];
+    const periodStart = toUTCDate(dateRange.start);
+    const periodEnd = toUTCDate(dateRange.end);
+    for (let idx = 0; idx < items.length; idx++) {
+        const item = items[idx];
+        const event = item.event;
+        if (!intersects(item.start.toUTCDate(), item.end.toUTCDate(), periodStart, periodEnd)) {
+            continue;
+        }
+        const resources = eventResources(event, { taskResources, hasGroups: resourceGroups && resourceGroups.length > 0, spans, allResources });
+        if (resources.length && resources[0].leafIdx >= 0) {
+            for (let resourceIdx = 0; resourceIdx < resources.length; resourceIdx++) {
+                const current = resources[resourceIdx];
+                const task = createTask(item, current.leafIdx, current.resources, current.color);
+                const tasks = groups[current.leafIdx].tasks = groups[current.leafIdx].tasks || [];
+                tasks.push(task);
+            }
+        }
+    }
+    if (resourceGroups) {
+        return groupByResource(taskResources, groups, dateRange);
+    }
+    groups[0].tasks = new TaskCollection(periodStart, periodEnd, splitTasks(periodStart, periodEnd, groups[0].tasks || []));
+    return groups;
+}