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

package/esm2022/views/utils.mjs

@@ -1,373 +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 { isEqualDate } from '@progress/kendo-date-math';
-import { formatDate } from '@progress/kendo-angular-intl';
-import { isPresent, getField, isArray, isObject, isString } from '../common/util';
-import { hasClasses } from '../common/dom-queries';
-/**
- * @hidden
- */
-export const allDaysHidden = (days) => {
-    for (let day = 0; day <= 6; day++) {
-        if (!days?.includes(day)) {
-            return false;
-        }
-    }
-    return true;
-};
-/** @hidden */
-export const intersects = (startTime, endTime, periodStart, periodEnd) => (startTime < periodStart && endTime > periodEnd) ||
-    (periodStart <= startTime && startTime < periodEnd) ||
-    (periodStart < endTime && endTime <= periodEnd && startTime < endTime);
-/** @hidden */
-export const dateInRange = (date, start, end) => start.getTime() <= date.getTime() && date.getTime() <= end.getTime();
-/** @hidden */
-export const roundAllDayEnd = ({ start, end }) => {
-    const startDate = start.stripTime();
-    const endDate = end.stripTime();
-    return endDate.getTime() !== end.getTime() || startDate.getTime() === endDate.getTime() ? endDate.addDays(1) : endDate;
-};
-/** @hidden */
-export function toInvariantTime(date) {
-    const staticDate = new Date(1980, 0, 1, 0, 0, 0);
-    if (date) {
-        staticDate.setHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
-    }
-    return staticDate;
-}
-/**
- * @hidden
- * TODO Move to date-math
- */
-export const addUTCDays = (date, offset) => {
-    const newDate = new Date(date.getTime());
-    newDate.setUTCDate(newDate.getUTCDate() + offset);
-    return newDate;
-};
-/**
- * @hidden
- */
-export function timeOnDate(date, hours = 0, minutes = 0, seconds = 0, ms = 0) {
-    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours, minutes, seconds, ms);
-}
-// TODO: name? move to date-math
-/** @hidden */
-export function toUTCTime(localDate, localTime) {
-    return new Date(Date.UTC(localDate.getFullYear(), localDate.getMonth(), localDate.getDate(), localTime.getHours(), localTime.getMinutes(), localTime.getSeconds(), localTime.getMilliseconds()));
-}
-//  TODO: move to date-math
-/** @hidden */
-export function toUTCDate(localDate) {
-    return new Date(Date.UTC(localDate.getFullYear(), localDate.getMonth(), localDate.getDate()));
-}
-// TODO: move to date-math
-/** @hidden */
-export function getUTCDate(utcDate) {
-    return new Date(Date.UTC(utcDate.getUTCFullYear(), utcDate.getUTCMonth(), utcDate.getUTCDate()));
-}
-// TODO: move to date-math
-/** @hidden */
-export function toUTCDateTime(localDate) {
-    return new Date(Date.UTC(localDate.getFullYear(), localDate.getMonth(), localDate.getDate(), localDate.getHours(), localDate.getMinutes(), localDate.getSeconds(), localDate.getMilliseconds()));
-}
-/** @hidden */
-export function dateWithTime(target, time) {
-    return new Date(target.getFullYear(), target.getMonth(), target.getDate(), time.getHours(), time.getMinutes());
-}
-/**
- * @hidden
- * Flips the start and end values of a slot selection based on whether
- * the last dragged-over slot is before or after the slot where the selection began.
- */
-export function normaliseRangeStartAndEnd(selectionOrigin, currentSlot) {
-    let start;
-    let end;
-    if (currentSlot.end <= selectionOrigin.end) {
-        end = selectionOrigin.end;
-        start = currentSlot.start;
-    }
-    else {
-        start = selectionOrigin.start;
-        end = currentSlot.end;
-    }
-    return { start, end };
-}
-function getDataIdx(value, resource) {
-    const data = resource.data;
-    for (let dataIdx = 0; dataIdx < data.length; dataIdx++) {
-        if (getField(data[dataIdx], resource.valueField) === value) {
-            return dataIdx;
-        }
-    }
-    return -1;
-}
-function resourceItem(value, resource) {
-    const index = getDataIdx(value, resource);
-    return index >= 0 ? resource.data[index] : {};
-}
-function resourceItems(values, resource) {
-    return values.map(value => resourceItem(value, resource));
-}
-function cloneResources(arr) {
-    const result = [];
-    for (let idx = 0; idx < arr.length; idx++) {
-        const clone = Object.assign({}, arr[idx]);
-        clone.resources = clone.resources.slice(0);
-        result.push(clone);
-    }
-    return result;
-}
-/** @hidden */
-export function resourceItemByValue(event, resource) {
-    const value = getField(event, resource.field);
-    if (Array.isArray(value)) {
-        return resourceItems(value, resource);
-    }
-    return resourceItem(value, resource);
-}
-function addNotGroupedResources(event, resources, allResources) {
-    for (let resourceIdx = 0; resourceIdx < resources.length; resourceIdx++) {
-        const current = resources[resourceIdx];
-        for (let idx = 0; idx < allResources.length; idx++) {
-            const item = allResources[idx];
-            if (!current.resources[idx] && item.data) {
-                current.resources[idx] = resourceItemByValue(event, item);
-            }
-        }
-    }
-}
-/** @hidden */
-export function eventResources(event, { taskResources, hasGroups, spans, allResources = [] }) {
-    let resources = [];
-    for (let resourceIdx = 0; resourceIdx < taskResources.length; resourceIdx++) {
-        const resource = taskResources[resourceIdx];
-        if (!resource.data) {
-            resources = [{ leafIdx: 0, resources: [] }];
-            continue;
-        }
-        const resourceIndex = allResources.indexOf(resource);
-        let values = getField(event, resource.field);
-        if (!Array.isArray(values)) {
-            values = [values];
-        }
-        const expandedResources = [];
-        for (let valueIdx = 0; valueIdx < values.length; valueIdx++) {
-            const dataIdx = getDataIdx(values[valueIdx], resource);
-            if (dataIdx < 0) {
-                if (hasGroups) {
-                    // No match for this resource, but the event might still match other resources.
-                    continue;
-                }
-                return [{ leafIdx: 0, resources: [] }];
-            }
-            const item = resource.data[dataIdx];
-            // has groups - need all copies of the multiple resource
-            // no groups - just the first
-            if (resourceIdx === 0 && (hasGroups || valueIdx === 0)) {
-                const resourceItems = [];
-                resourceItems[resourceIndex] = resource.multiple && !hasGroups ? [item] : item;
-                resources.push({
-                    leafIdx: hasGroups ? dataIdx * spans[resourceIdx] : 0,
-                    color: getField(item, resource.colorField),
-                    resources: resourceItems
-                });
-            }
-            else if (hasGroups) { // don't create multiple resource groups if no groups for multiple resources
-                let currentResources = resources;
-                if (values.length > 1) {
-                    currentResources = cloneResources(resources);
-                    expandedResources.push(...currentResources);
-                }
-                for (let currentIdx = 0; currentIdx < currentResources.length; currentIdx++) {
-                    currentResources[currentIdx].leafIdx += dataIdx * spans[resourceIdx];
-                    currentResources[currentIdx].resources[resourceIndex] = item;
-                }
-            }
-            else if (valueIdx > 0) {
-                for (let idx = 0; idx < resources.length; idx++) {
-                    resources[idx].resources[resourceIndex].push(item);
-                }
-            }
-        }
-        if (expandedResources.length) {
-            resources = expandedResources;
-        }
-    }
-    addNotGroupedResources(event, resources, allResources);
-    return resources;
-}
-/** @hidden */
-export function assignTasksResources(tasks, options) {
-    for (let idx = 0; idx < tasks.length; idx++) {
-        const task = tasks[idx];
-        task.resources = eventResources(task.event, options);
-    }
-}
-/**
- * @hidden
- */
-export function isEmptyResource(resources) {
-    return Array.isArray(resources) && resources.length === 1 && resources[0] === undefined;
-}
-/**
- * @hidden
- */
-export function resourcesMatch(res1, res2, resourceConfigs) {
-    if (res1.length !== res2.length) {
-        return false;
-    }
-    if (isEmptyResource(res1) && isEmptyResource(res2)) {
-        return true;
-    }
-    // When resource configurations are provided, use their valueField to compare
-    if (resourceConfigs?.length > 0) {
-        return res1.every((r1, index) => {
-            const config = resourceConfigs[index];
-            if (!config?.valueField) {
-                return res2.some(r2 => r2.value === r1.value);
-            }
-            const value1 = getField(r1, config.valueField);
-            return res2.some(r2 => getField(r2, config.valueField) === value1);
-        });
-    }
-    return res1.every(r1 => res2.some(r2 => r2.value === r1.value));
-}
-/**
- * @hidden
- */
-export function isSameRange(range1, range2, resourceConfigs) {
-    return (range1.start.getTime() === range2.start.getTime() &&
-        range1.end.getTime() === range2.end.getTime() &&
-        range1.isAllDay === range2.isAllDay &&
-        resourcesMatch(range1.resources, range2.resources, resourceConfigs));
-}
-/** @hidden */
-export function findRowIndex(events, data) {
-    if (data.rowIndex !== undefined) {
-        return data.rowIndex;
-    }
-    for (let idx = 0; idx < events.length; idx++) {
-        if (!events[idx]) {
-            return idx;
-        }
-    }
-    return events.length;
-}
-/** @hidden */
-export function isRecurrence(task) {
-    return Boolean(task.event && task.event.recurrenceRule);
-}
-/** @hidden */
-export function isRecurrenceException(task) {
-    return task.event && isPresent(task.event.recurrenceId) && !task.event.recurrenceRule;
-}
-/** @hidden */
-export const rectContains = (rect, left, top, scaleX = 1) => rect.left * scaleX <= left && left <= rect.left * scaleX + rect.width * scaleX && rect.top * scaleX <= top && top <= rect.top * scaleX + rect.height * scaleX;
-/** @hidden */
-export const rectContainsX = (rect, left, scaleX = 1) => rect.left * scaleX <= left && left <= rect.left * scaleX + rect.width * scaleX;
-/** @hidden */
-export const toPx = value => `${value}px`;
-/** @hidden */
-export const elementOffset = (element) => {
-    if (!element) {
-        return null;
-    }
-    const box = element.getBoundingClientRect();
-    const documentElement = document.documentElement;
-    return {
-        top: box.top + (window.pageYOffset || documentElement.scrollTop) - (documentElement.clientTop || 0),
-        left: box.left + (window.pageXOffset || documentElement.scrollLeft) - (documentElement.clientLeft || 0),
-        width: box.width,
-        height: box.height
-    };
-};
-/** @hidden */
-export const pointDistance = (x1, y1, x2, y2) => Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
-/** @hidden */
-export const ignoreContentChild = child => child.nodeName === 'KENDO-RESIZE-SENSOR' || hasClasses(child, 'k-loading-mask');
-/** @hidden */
-export const setCoordinates = (element, coordinates) => {
-    for (const field in coordinates) {
-        if (coordinates.hasOwnProperty(field)) {
-            element.style[field] = toPx(coordinates[field]);
-        }
-    }
-};
-/** @hidden */
-export const convertNgClassBindings = (bindingValues) => {
-    const result = [];
-    if (isString(bindingValues)) {
-        result.push(bindingValues);
-    }
-    else if (isArray(bindingValues)) {
-        result.push(...bindingValues);
-    }
-    else if (isObject(bindingValues)) {
-        for (const field in bindingValues) {
-            if (bindingValues.hasOwnProperty(field) && bindingValues[field]) {
-                result.push(field);
-            }
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export function formatEventTime(start, end, isAllDay, localeId) {
-    const dateFormat = { skeleton: 'yMMMMEEEEd' };
-    const timeFormat = 't';
-    const startFormat = formatEventStart(start, dateFormat, timeFormat, isAllDay, localeId);
-    const endFormat = formatEventEnd(start, end, dateFormat, timeFormat, localeId);
-    return isAllDay ?
-        `${startFormat}` :
-        `${startFormat}-${endFormat}`;
-}
-/**
- * @hidden
- */
-export function formValueOrDefault(group, field, defaultValue) {
-    const control = group.get(field);
-    if (!control) {
-        return defaultValue;
-    }
-    return control.value || defaultValue;
-}
-/**
- * @hidden
- */
-export const isWorkWeekDay = (day, start, end) => {
-    if (end < start) {
-        return day <= end || start <= day;
-    }
-    return start <= day && day <= end;
-};
-/**
- * @hidden
- */
-export const alwaysFalse = () => false;
-/**
- * @hidden
- */
-const formatEventStart = (start, dateFormat, timeFormat, isAllDay, localeId) => {
-    let startFormat = `${formatDate(start, dateFormat, localeId)}`;
-    // the time is relevant only when the event isn't an all day event
-    if (!isAllDay) {
-        startFormat += `, ${formatDate(start, timeFormat, localeId)}`;
-    }
-    return startFormat;
-};
-/**
- * @hidden
- */
-const formatEventEnd = (start, end, dateFormat, timeFormat, localeId) => {
-    let endFormat = '';
-    // the end date is relevant only when the event ends on a different day from when it starts
-    if (!isEqualDate(start, end)) {
-        endFormat = `${formatDate(end, dateFormat, localeId)}, `;
-    }
-    endFormat += `${formatDate(end, timeFormat, localeId)}`;
-    return endFormat;
-};

package/esm2022/views/view-context.service.mjs

@@ -1,111 +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 { Injectable } from '@angular/core';
-import { BehaviorSubject, Subject } from 'rxjs';
-import * as i0 from "@angular/core";
-/**
- * A service which publishes information from the Scheduler to the views.
- * Views subscribe to changes in the context (selected date, event, and resource data) through this service.
- */
-export class ViewContextService {
-    /**
-     * Represents a stream that publishes navigation actions to the view.
-     */
-    action;
-    /**
-     * Represents a stream that executes methods from the view.
-     */
-    execute;
-    /**
-     * Represents a stream of items (events) to be displayed in the view.
-     */
-    items;
-    /**
-     * Represents a stream with the selected date to be displayed in the view.
-     */
-    selectedDate;
-    /**
-     * Emits when the Scheduler element is resized.
-     */
-    resize;
-    /**
-     * Emits when the Scheduler options change.
-     */
-    optionsChange;
-    actionSource = new Subject();
-    itemsSource = new BehaviorSubject([]);
-    selectedDateSource = new BehaviorSubject(null);
-    resizeSource = new Subject();
-    optionsChangeSource = new BehaviorSubject({});
-    executeSource = new Subject();
-    constructor() {
-        this.action = this.actionSource.asObservable();
-        this.items = this.itemsSource.asObservable();
-        this.selectedDate = this.selectedDateSource.asObservable();
-        this.resize = this.resizeSource.asObservable();
-        this.optionsChange = this.optionsChangeSource.asObservable();
-        this.execute = this.executeSource.asObservable();
-    }
-    /**
-     * An internal method which is used by the Scheduler to publish unhandled navigation actions.
-     *
-     * @hidden
-     */
-    notifyAction(action) {
-        this.actionSource.next(action);
-    }
-    /**
-     * An internal method which is used by the Scheduler to publish the current set of items.
-     *
-     * @hidden
-     */
-    notifyItems(items) {
-        this.itemsSource.next(items);
-    }
-    /**
-     * An internal method which is used by the Scheduler to publish the currently selected date.
-     *
-     * @hidden
-     */
-    notifySelectedDate(date) {
-        this.selectedDateSource.next(date);
-    }
-    /**
-     * An internal method which is used by the Scheduler to notify that the size changed.
-     *
-     * @hidden
-     */
-    notifyResize() {
-        this.resizeSource.next();
-    }
-    /**
-     * An internal method which is used by the Scheduler to notify that the options changed.
-     *
-     * @hidden
-     */
-    notifyOptionsChange(changes) {
-        this.optionsChangeSource.next(changes);
-    }
-    /**
-     * An internal method which is used by the Scheduler to execute a view method.
-     *
-     * @hidden
-     */
-    executeMethod(name, args) {
-        let result;
-        this.executeSource.next({ name, args, result: (r) => {
-                result = r;
-            } });
-        return result;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ViewContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ViewContextService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ViewContextService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [] });

package/esm2022/views/view-items/base-slot.directive.mjs

@@ -1,104 +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 { Input, HostBinding, ElementRef, Directive } from '@angular/core';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { BaseSlotService } from './base-slot.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./base-slot.service";
-import * as i2 from "@progress/kendo-angular-l10n";
-/**
- * @hidden
- */
-export class BaseSlotDirective {
-    element;
-    slotService;
-    localization;
-    id;
-    get slotIndex() {
-        return this.key;
-    }
-    get start() {
-        return this._start;
-    }
-    set start(value) {
-        this._start = value;
-    }
-    get end() {
-        return this._end;
-    }
-    set end(value) {
-        this._end = value;
-    }
-    _rect = null;
-    _start;
-    _end;
-    constructor(element, slotService, localization) {
-        this.element = element;
-        this.slotService = slotService;
-        this.localization = localization;
-    }
-    get rect() {
-        if (this._rect) {
-            return this._rect;
-        }
-        const el = this.nativeElement;
-        this._rect = {
-            left: !this.localization.rtl ? el.offsetLeft : this.slotService.containerSize - (el.offsetLeft + el.clientWidth),
-            top: el.offsetTop,
-            width: el.clientWidth,
-            height: el.clientHeight
-        };
-        return this._rect;
-    }
-    get top() {
-        return this.element ? this.nativeElement.offsetTop : 0;
-    }
-    get padding() {
-        if (!this.element || !isDocumentAvailable()) {
-            return 0;
-        }
-        return parseInt(window.getComputedStyle(this.nativeElement).paddingTop, 10) * 2;
-    }
-    get height() {
-        return this.element ? this.nativeElement.offsetHeight : 0;
-    }
-    set height(value) {
-        if (this.element) {
-            this.nativeElement.style.height = `${value}px`;
-        }
-        if (this._rect) {
-            this._rect.height = value;
-        }
-    }
-    get width() {
-        return this.element ? this.nativeElement.offsetWidth : 0;
-    }
-    get key() {
-        return `${this.id.resourceIndex}:${this.id.rangeIndex}:${this.id.index}`;
-    }
-    get nativeElement() {
-        return this.element.nativeElement;
-    }
-    ngOnInit() {
-        this.slotService.registerSlot(this);
-    }
-    ngOnDestroy() {
-        this.slotService.unregisterSlot(this);
-    }
-    invalidate() {
-        this._rect = null;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BaseSlotDirective, deps: [{ token: i0.ElementRef }, { token: i1.BaseSlotService }, { token: i2.LocalizationService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: BaseSlotDirective, inputs: { id: "id" }, host: { properties: { "attr.data-slot-index": "this.slotIndex" } }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BaseSlotDirective, decorators: [{
-            type: Directive
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.BaseSlotService }, { type: i2.LocalizationService }], propDecorators: { id: [{
-                type: Input
-            }], slotIndex: [{
-                type: HostBinding,
-                args: ['attr.data-slot-index']
-            }] } });

package/esm2022/views/view-items/base-slot.service.mjs

@@ -1,82 +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 { EventEmitter } from '@angular/core';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-/**
- * @hidden
- */
-export class BaseSlotService {
-    containerSize = 0;
-    slotsChange = new EventEmitter();
-    groups = [];
-    registerItem(component) {
-        const group = this.itemGroup(component);
-        group.registerItem(component);
-    }
-    unregisterItem(component, id) {
-        id = id || {
-            index: component.index,
-            resourceIndex: component.resourceIndex,
-            rangeIndex: component.rangeIndex
-        };
-        const group = this.groups[id.resourceIndex];
-        if (group) {
-            group.unregisterItem(component, id);
-        }
-    }
-    registerSlot(slot) {
-        const group = this.slotGroup(slot);
-        group.registerSlot(slot);
-    }
-    unregisterSlot(slot) {
-        const group = this.groups[slot.id.resourceIndex];
-        if (group) {
-            group.unregisterSlot(slot);
-        }
-    }
-    invalidate() {
-        this.clearEmptyGroups();
-        this.cleanRanges();
-        this.slotsChange.emit();
-        this.forEachSlot(slot => {
-            slot.invalidate();
-        });
-    }
-    cleanRanges() {
-        this.groups.forEach(group => {
-            group.cleanRanges();
-        });
-    }
-    clearEmptyGroups() {
-        const groups = this.groups;
-        let index = this.groups.length - 1;
-        while (index > 0 && !groups[index].hasSlots) {
-            groups.splice(index, 1);
-            index--;
-        }
-    }
-    itemGroup(item) {
-        const index = item.resourceIndex;
-        if (!this.groups[index]) {
-            this.groups[index] = this.createGroup(index);
-        }
-        return this.groups[index];
-    }
-    slotGroup(slot) {
-        const index = slot.id.resourceIndex;
-        if (!this.groups[index]) {
-            this.groups[index] = this.createGroup(index);
-        }
-        return this.groups[index];
-    }
-    calculateScaleX() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        const schedulerEl = document.querySelector('.k-scheduler');
-        const scaleX = schedulerEl.getBoundingClientRect().width / schedulerEl.offsetWidth;
-        return scaleX;
-    }
-}