@progress/kendo-angular-scheduler 21.4.1-develop.1 → 22.0.0-develop.1

package/esm2022/views/agenda/agenda-view.component.mjs

@@ -1,130 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 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, ChangeDetectorRef } from '@angular/core';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { ConfigurationViewBase } from '../common/configuration-view-base';
-import { SchedulerView } from '../../types';
-import { ViewContextService } from '../view-context.service';
-import { ViewStateService } from '../view-state.service';
-import { AgendaTimeTemplateDirective, AgendaDateTemplateDirective } from '../templates';
-import { AgendaViewInternalComponent } from './agenda-view-internal.component';
-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";
-/**
- * Represents the component that renders the **Agenda** view in the Scheduler.
- *
- * @example
- * ```html
- * <kendo-scheduler>
- *     <kendo-scheduler-agenda-view></kendo-scheduler-agenda-view>
- * </kendo-scheduler>
- * ```
- */
-export class AgendaViewComponent extends ConfigurationViewBase {
-    /**
-     * @hidden
-     */
-    get title() {
-        return this.localization.get('agendaViewTitle');
-    }
-    /**
-     * Sets the long-date format for the selected date in the Scheduler toolbar.
-     * Defaults to `'{0:D} - {1:D}'`, where `0` is the start and `1` is the end date.
-     * For more information, see [Parsing and Formatting Dates and Numbers](slug:parsingandformatting_intl#date-formatting).
-     * @default '{0:D} - {1:D}'
-     */
-    selectedDateFormat = '{0:D} - {1:D}';
-    /**
-     * Sets the short-date format for the selected date in the Scheduler toolbar.
-     * Defaults to `'{0:d} - {1:d}'`, where `0` is the start and `1` is the end date.
-     * For more information, see [Parsing and Formatting Dates and Numbers](slug:parsingandformatting_intl#date-formatting).
-     * @default '{0:d} - {1:d}'
-     */
-    selectedShortDateFormat = '{0:d} - {1:d}';
-    /**
-     * Specifies the number of days that the view will render.
-     * @default 7
-     */
-    numberOfDays = 7;
-    /**
-     * @hidden
-     */
-    agendaTimeTemplate;
-    /**
-     * @hidden
-     */
-    agendaDateTemplate;
-    /**
-     * The invariant name for this view (`agenda`).
-     * @default 'agenda'
-     */
-    name = 'agenda';
-    constructor(localization, changeDetector, viewContext, viewState) {
-        super(localization, changeDetector, viewContext, viewState);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AgendaViewComponent, deps: [{ token: i1.LocalizationService }, { token: i0.ChangeDetectorRef }, { token: i2.ViewContextService }, { token: i3.ViewStateService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AgendaViewComponent, isStandalone: true, selector: "kendo-scheduler-agenda-view", inputs: { selectedDateFormat: "selectedDateFormat", selectedShortDateFormat: "selectedShortDateFormat", numberOfDays: "numberOfDays" }, providers: [{
-                provide: SchedulerView,
-                useExisting: forwardRef(() => AgendaViewComponent)
-            }], queries: [{ 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"
-                [hiddenDays]="viewHiddenDays"
-                [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, dependencies: [{ kind: "component", type: AgendaViewInternalComponent, selector: "agenda-view-internal", inputs: ["hiddenDays", "eventTemplate", "slotClass", "eventClass", "eventStyles", "agendaTimeTemplate", "agendaDateTemplate", "selectedDateFormat", "selectedShortDateFormat", "numberOfDays"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", 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"
-                [hiddenDays]="viewHiddenDays"
-                [eventTemplate]="eventTemplate?.templateRef"
-                [slotClass]="viewSlotClass"
-                [eventClass]="viewEventClass"
-                [eventStyles]="viewEventStyles"
-                [agendaTimeTemplate]="agendaTimeTemplate?.templateRef"
-                [agendaDateTemplate]="agendaDateTemplate?.templateRef"
-                [selectedDateFormat]="selectedDateFormat"
-                [selectedShortDateFormat]="selectedShortDateFormat">
-            </agenda-view-internal>
-        </ng-template>
-    `,
-                    standalone: true,
-                    imports: [AgendaViewInternalComponent]
-                }]
-        }], ctorParameters: () => [{ type: i1.LocalizationService }, { type: i0.ChangeDetectorRef }, { type: i2.ViewContextService }, { type: i3.ViewStateService }], propDecorators: { selectedDateFormat: [{
-                type: Input
-            }], selectedShortDateFormat: [{
-                type: Input
-            }], numberOfDays: [{
-                type: Input
-            }], agendaTimeTemplate: [{
-                type: ContentChild,
-                args: [AgendaTimeTemplateDirective, { static: false }]
-            }], agendaDateTemplate: [{
-                type: ContentChild,
-                args: [AgendaDateTemplateDirective, { static: false }]
-            }] } });

package/esm2022/views/agenda/tasks.collection.mjs

@@ -1,96 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 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 flattenGroupsAndAddIds(scope) {
-    return function* flattenGroups(groups) {
-        for (let index = 0; index < groups.length; index++) {
-            const groupItem = groups[index];
-            const dayOfWeek = groupItem.items[0]?.startDate?.getDay();
-            if (scope.hiddenDays?.includes(dayOfWeek)) {
-                continue;
-            }
-            yield {
-                type: "group",
-                dataItem: groupItem,
-                rowSpan: groupItem.items.length,
-                elementId: `k-scheduler-${scope.counter}-${index}`
-            };
-            for (let itemIndex = 1; itemIndex < groupItem.items.length; itemIndex++) {
-                const item = groupItem.items[itemIndex];
-                yield {
-                    type: "event",
-                    dataItem: item,
-                    elementId: `k-scheduler-${scope.counter}-${index}-item-${itemIndex}`
-                };
-            }
-        }
-    };
-}
-/** @hidden */
-export class EmptyIterator {
-    [iterator]() {
-        return {
-            next: () => ({ done: true, value: null })
-        };
-    }
-    toString() {
-        return "Empty Iterator";
-    }
-}
-let seed = 0;
-/**
- * @hidden
- */
-export class TaskCollection {
-    start;
-    end;
-    events;
-    counter; // used to give unique ids to event elements
-    hiddenDays;
-    static empty() {
-        return (new EmptyIterator());
-    }
-    constructor(start, end, events, hiddenDays) {
-        this.start = start;
-        this.end = end;
-        this.events = events;
-        this.hiddenDays = hiddenDays || [];
-        this.counter = seed;
-        seed++;
-        this.createIterator = compose(flattenGroupsAndAddIds(this), processEvents(this.start, this.end));
-    }
-    createIterator;
-    [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/esm2022/views/agenda/utils.mjs

@@ -1,176 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 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, toLocalDate } 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 && duration > 0 && !endsAtMidnight(end)) {
-        return duration + 1;
-    }
-    return duration;
-};
-const endsAtMidnight = (end) => {
-    end = toLocalDate(end);
-    return (end.getHours() === 0 && end.getMinutes() === 0 && end.getSeconds() === 0 && end.getMilliseconds() === 0);
-};
-const curry = fn => {
-    const len = fn.length;
-    return (...args) => len === args.length
-        ? fn(...args)
-        : curry(fn.bind(null, ...args));
-};
-const range = num => Array.from(new Array(num).keys());
-const cloneTask = (eventStart, eventEnd) => task => ({
-    ...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++) {
-        const task = { ...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({ ...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, hiddenDays }) {
-    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 || []), hiddenDays);
-    return groups;
-}