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

package/esm2022/views/day-time/day-time-view.component.mjs

@@ -1,437 +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, TemplateRef, ViewChildren, QueryList, ElementRef, ChangeDetectorRef, NgZone, Renderer2, Component } from '@angular/core';
-import { isChanged, isDocumentAvailable, ScrollbarWidthService } from '@progress/kendo-angular-common';
-import { addDays, getDate, ZonedDate } from '@progress/kendo-date-math';
-import { fromEvent } from 'rxjs';
-import { toInvariantTime, dateInRange, setCoordinates, dateWithTime, toUTCTime, toUTCDateTime, allDaysHidden } from '../utils';
-import { createTimeSlots } from './utils';
-import { DayTimeSlotService } from './day-time-slot.service';
-import { ViewContextService } from '../view-context.service';
-import { ViewStateService } from '../view-state.service';
-import { IntlService } from '@progress/kendo-angular-intl';
-import { PDFService } from '../../pdf/pdf.service';
-import { BaseView } from '../common/base-view';
-import { MIDNIGHT_INVARIANT, MS_PER_MINUTE, ONGOING_EVENT_CSS_CLASS } from '../constants';
-import { fromClick, fromDoubleClick, isNumber, isPresent } from '../../common/util';
-import { rtlScrollPosition, hasClasses } from '../../common/dom-queries';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { DayTimeViewItemComponent } from './day-time-view-item.component';
-import * as i0 from "@angular/core";
-import * as i1 from "../view-context.service";
-import * as i2 from "../view-state.service";
-import * as i3 from "@progress/kendo-angular-intl";
-import * as i4 from "./day-time-slot.service";
-import * as i5 from "../../pdf/pdf.service";
-import * as i6 from "@progress/kendo-angular-l10n";
-import * as i7 from "@progress/kendo-angular-common";
-const getStartDate = date => getDate(date);
-const getEndDate = (start, numberOfDays) => getDate(addDays(start, numberOfDays || 1));
-const getNextDate = (date, count, numberOfDays) => getDate(addDays(date, numberOfDays * count));
-/**
- * @hidden
- */
-export class DayTimeViewComponent extends BaseView {
-    changeDetector;
-    timeSlotTemplate;
-    dateHeaderTemplate;
-    majorTimeHeaderTemplate;
-    minorTimeHeaderTemplate;
-    numberOfDays = 1;
-    scrollTime;
-    startTime = '00:00';
-    endTime = '00:00';
-    workDayStart = '08:00';
-    workDayEnd = '17:00';
-    workWeekStart = 1;
-    workWeekEnd = 5;
-    slotDuration = 60;
-    slotDivisions = 2;
-    showWorkHours = false;
-    getStartDate = getStartDate;
-    getEndDate = getEndDate;
-    getNextDate = getNextDate;
-    currentTimeMarker;
-    highlightOngoingEvents;
-    currentTimeElements;
-    eventElements;
-    currentTimeArrows;
-    name;
-    workDayStartTime;
-    workDayEndTime;
-    daySlots = [];
-    timeSlots = [];
-    resizeHintFormat = 't';
-    showCurrentTime = false;
-    get classNames() {
-        return `k-scheduler-${this.name}view`;
-    }
-    get timeSlotTemplateRef() {
-        return this.timeSlotTemplate || (this.schedulerTimeSlotTemplate || {}).templateRef;
-    }
-    get dateHeaderTemplateRef() {
-        return this.dateHeaderTemplate || (this.schedulerDateHeaderTemplate || {}).templateRef;
-    }
-    get majorTimeHeaderTemplateRef() {
-        return this.majorTimeHeaderTemplate || (this.schedulerMajorTimeHeaderTemplate || {}).templateRef;
-    }
-    get minorTimeHeaderTemplateRef() {
-        return this.minorTimeHeaderTemplate || (this.schedulerMinorTimeHeaderTemplate || {}).templateRef;
-    }
-    schedulerTimeSlotTemplate;
-    schedulerDateHeaderTemplate;
-    schedulerMajorTimeHeaderTemplate;
-    schedulerMinorTimeHeaderTemplate;
-    currentTimeTimeout;
-    ongoingEventsTimeout;
-    currentDate;
-    verticalTime = true;
-    initialUpdate = true;
-    dates = [];
-    constructor(changeDetector, viewContext, viewState, intl, slotService, zone, renderer, element, pdfService, localization, scrollBarWidthService) {
-        super(viewContext, viewState, intl, slotService, zone, renderer, element, pdfService, localization, changeDetector, scrollBarWidthService);
-        this.changeDetector = changeDetector;
-        this.updateCurrentTime = this.updateCurrentTime.bind(this);
-        this.toggleOngoingClass = this.toggleOngoingClass.bind(this);
-        this.updateOngoingEvents = this.updateOngoingEvents.bind(this);
-    }
-    ngOnChanges(changes) {
-        if (changes.startTime || changes.endTime || changes.showWorkHours || changes.workDayStart || changes.workDayEnd ||
-            changes.workWeekStart || changes.workWeekEnd || changes.slotDivisions || changes.slotDuration) {
-            this.timeSlots = this.createTimeSlots();
-            this.initWorkDay();
-            this.changes.next(null);
-        }
-        if (isChanged('currentTimeMarker', changes)) {
-            this.showCurrentTime = this.enableCurrentTime();
-        }
-        if (isChanged('weekStart', changes)) {
-            this.onSelectDate(this.selectedDate);
-        }
-        super.ngOnChanges(changes);
-    }
-    ngOnDestroy() {
-        super.ngOnDestroy();
-        clearTimeout(this.currentTimeTimeout);
-        clearTimeout(this.ongoingEventsTimeout);
-    }
-    verticalItem(leafIndex, resourceIndex) {
-        const data = this.verticalResources[resourceIndex].data || [];
-        const resources = this.verticalResources;
-        let result = 1;
-        for (let idx = resourceIndex + 1; idx < resources.length; idx++) {
-            result *= ((resources[idx].data || []).length || 1);
-        }
-        return data[(leafIndex / result) % data.length];
-    }
-    timeSlotClass(slot, date, resourceIndex) {
-        if (this.slotClass) {
-            return this.slotClass({
-                start: dateWithTime(date, slot.start),
-                end: dateWithTime(date, slot.end),
-                resources: this.resourcesByIndex(resourceIndex),
-                isAllDay: false
-            });
-        }
-    }
-    toggleOngoingClass() {
-        const now = this.currentTime();
-        const cssClass = isPresent(this.highlightOngoingEvents.cssClass) ? this.highlightOngoingEvents.cssClass : ONGOING_EVENT_CSS_CLASS;
-        this.eventElements.forEach((event) => {
-            const isOngoing = dateInRange(now, event.item.start, event.item.end);
-            this.renderer[isOngoing ? 'addClass' : 'removeClass'](event.nativeElement, cssClass);
-        });
-    }
-    scrollToTime(time = this.scrollTime) {
-        let date;
-        if (typeof time === 'string') {
-            const scrollDate = this.intl.parseDate(time);
-            if (!(scrollDate && this.daySlots[0]?.start)) {
-                return;
-            }
-            date = toUTCTime(this.daySlots[0].start, scrollDate);
-        }
-        else {
-            date = toUTCDateTime(time);
-        }
-        const position = this.slotService.timePosition(date, 0, this.verticalTime);
-        if (isNumber(position)) {
-            const contentElement = this.content.nativeElement;
-            contentElement[this.verticalTime ? 'scrollTop' : 'scrollLeft'] =
-                (this.localization.rtl && !this.verticalTime) ? rtlScrollPosition(contentElement, position) : position;
-        }
-    }
-    optionsChange(options) {
-        this.schedulerTimeSlotTemplate = options.timeSlotTemplate;
-        this.schedulerDateHeaderTemplate = options.dateHeaderTemplate;
-        this.schedulerMajorTimeHeaderTemplate = options.majorTimeHeaderTemplate;
-        this.schedulerMinorTimeHeaderTemplate = options.minorTimeHeaderTemplate;
-        super.optionsChange(options);
-    }
-    updateView() {
-        super.updateView();
-        this.updateCurrentTime();
-        this.updateOngoingEvents();
-        if (this.initialUpdate) {
-            this.scrollToTime();
-            this.initialUpdate = false;
-        }
-    }
-    enableCurrentTime() {
-        if (!this.currentTimeMarker || this.currentTimeMarker.enabled === false || !this.selectedDate) {
-            return false;
-        }
-        const dateRange = this.dateRange();
-        this.currentDate = ZonedDate.fromLocalDate(this.currentTime(), this.currentTimeMarker.localTimezone !== false ? '' : this.timezone);
-        const localTime = this.currentDate.toLocalDate();
-        const invariantTime = toInvariantTime(localTime);
-        const timeSlots = this.timeSlots;
-        const inDateRange = dateInRange(localTime, dateRange.start, dateRange.end);
-        const inTimeRange = timeSlots.length && dateInRange(invariantTime, timeSlots[0].start, timeSlots[timeSlots.length - 1].end);
-        return inDateRange && inTimeRange;
-    }
-    currentTime() {
-        return new Date();
-    }
-    updateCurrentTime() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        const enable = this.enableCurrentTime();
-        if (enable !== this.showCurrentTime) {
-            this.showCurrentTime = enable;
-            this.changeDetector.detectChanges();
-        }
-        clearTimeout(this.currentTimeTimeout);
-        if (enable) {
-            this.zone.runOutsideAngular(() => {
-                this.currentTimeTimeout = setTimeout(this.updateCurrentTime, this.currentTimeMarker.updateInterval || MS_PER_MINUTE);
-            });
-            this.positionCurrentTime();
-        }
-    }
-    updateOngoingEvents() {
-        const disabled = !this.highlightOngoingEvents || this.highlightOngoingEvents.enabled === false;
-        if (!isDocumentAvailable() || disabled) {
-            return;
-        }
-        clearTimeout(this.ongoingEventsTimeout);
-        this.zone.runOutsideAngular(() => {
-            this.ongoingEventsTimeout = setTimeout(this.updateOngoingEvents, this.highlightOngoingEvents.updateInterval || MS_PER_MINUTE);
-        });
-        this.toggleOngoingClass();
-    }
-    positionCurrentTime() {
-        if (this.currentTimeElements && this.currentTimeElements.length) {
-            const date = this.currentDate.toUTCDate();
-            const currentTimeArrows = this.currentTimeArrows ? this.currentTimeArrows.toArray() : [];
-            const arrowOffset = currentTimeArrows.length ? this.currentTimeArrowOffset() : 0;
-            const arrowMid = currentTimeArrows.length ? (currentTimeArrows[0].nativeElement.offsetHeight / 2) : 4;
-            const tableWidth = this.contentTable.nativeElement.clientWidth;
-            const tableHeight = this.contentTable.nativeElement.clientHeight;
-            const vertical = this.verticalTime;
-            this.currentTimeElements.forEach((element, index) => {
-                const position = this.slotService.timePosition(date, index, vertical);
-                if (position !== undefined) {
-                    const line = element.nativeElement;
-                    if (currentTimeArrows[index]) {
-                        const arrow = currentTimeArrows[index].nativeElement;
-                        const origin = vertical ? arrowOffset : position - arrowMid;
-                        setCoordinates(arrow, {
-                            top: vertical ? position - arrowMid : arrowOffset,
-                            left: origin,
-                            right: origin
-                        });
-                    }
-                    const origin = vertical ? 0 : position;
-                    setCoordinates(line, {
-                        top: vertical ? position : 0,
-                        left: origin,
-                        right: origin,
-                        width: vertical ? tableWidth : 1,
-                        height: vertical ? 1 : tableHeight
-                    });
-                }
-            });
-        }
-    }
-    bindEvents() {
-        super.bindEvents();
-        this.zone.runOutsideAngular(() => {
-            this.subs.add(fromClick(this.headerWrap.nativeElement)
-                .subscribe(e => this.onHeaderClick(e)));
-            this.subs.add(fromEvent(this.headerWrap.nativeElement, 'contextmenu')
-                .subscribe(e => this.onClick(e)));
-            this.subs.add(fromDoubleClick(this.headerWrap.nativeElement)
-                .subscribe(e => this.onClick(e, 'dblclick')));
-        });
-    }
-    onHeaderClick(e) {
-        this.onClick(e);
-        if (this.daySlots.length <= 1) {
-            return;
-        }
-        const daySlotIndex = e.target.getAttribute('data-dayslot-index');
-        if (daySlotIndex) {
-            const slot = this.daySlots[parseInt(daySlotIndex, 10)];
-            this.zone.run(() => {
-                this.viewState.navigateTo({ viewName: 'day', date: slot.start });
-            });
-        }
-    }
-    slotByIndex(slotIndex, args) {
-        return this.slotService.slotByIndex(slotIndex, args.target.hasAttribute('data-day-slot'));
-    }
-    onSelectDate(date) {
-        this.selectedDate = date;
-        this.daySlots = this.createDaySlots();
-        this.showCurrentTime = this.enableCurrentTime();
-        this.viewState.notifyDateRange(this.dateRange());
-    }
-    onAction(e) {
-        const now = getDate(this.selectedDate);
-        if (e.type === 'next') {
-            const next = this.getNextDate(now, 1, this.numberOfDays);
-            if (this.isInRange(next)) {
-                this.viewState.notifyNextDate(next);
-            }
-        }
-        if (e.type === 'prev') {
-            const next = this.getNextDate(now, -1, this.numberOfDays);
-            if (this.isInRange(next)) {
-                this.viewState.notifyNextDate(next);
-            }
-        }
-        if (e.type === 'scroll-time') {
-            this.scrollToTime(e.time);
-        }
-    }
-    dateRange(date = this.selectedDate) {
-        const start = this.getStartDate(date);
-        const end = this.getEndDate(start, this.numberOfDays);
-        const rangeEnd = this.getEndDate(start, this.numberOfDays - 1);
-        const text = this.intl.format(this.selectedDateFormat, start, rangeEnd);
-        const shortText = this.intl.format(this.selectedShortDateFormat, start, rangeEnd);
-        return { start, end, text, shortText };
-    }
-    createDaySlots(multiDayEnd) {
-        if (!multiDayEnd) {
-            this.dates = [];
-        }
-        let current = this.getStartDate(this.selectedDate);
-        const end = multiDayEnd || this.getEndDate(current, this.numberOfDays);
-        const hiddenDays = this.slotService.hiddenDays;
-        while (current < end) {
-            const next = addDays(current, 1);
-            const isTimelineView = this.name === 'timelineWeek' || this.name === 'timelineMonth';
-            const isDisplayedDay = hiddenDays.indexOf(current.getDay()) === -1;
-            const hasSpace = isTimelineView || this.dates.length < this.numberOfDays;
-            if (isDisplayedDay && hasSpace) {
-                this.dates.push({
-                    start: current,
-                    end: next
-                });
-            }
-            current = next;
-        }
-        if (this.name === 'multiDay' && !allDaysHidden(hiddenDays) && this.dates.length < this.numberOfDays) {
-            const updatedEnd = addDays(end, this.numberOfDays - this.dates.length);
-            return this.createDaySlots(updatedEnd);
-        }
-        return this.dates;
-    }
-    createTimeSlots() {
-        return createTimeSlots(this.intl, {
-            showWorkHours: this.showWorkHours,
-            startTime: this.startTime,
-            endTime: this.endTime,
-            workDayStart: this.workDayStart,
-            workDayEnd: this.workDayEnd,
-            slotDivisions: this.slotDivisions,
-            slotDuration: this.slotDuration
-        });
-    }
-    initWorkDay() {
-        const startDate = this.intl.parseDate(this.workDayStart);
-        this.workDayStartTime = toInvariantTime(startDate);
-        const endDate = this.intl.parseDate(this.workDayEnd);
-        if (endDate <= startDate) {
-            this.workDayEndTime = addDays(MIDNIGHT_INVARIANT, 1);
-        }
-        else {
-            this.workDayEndTime = toInvariantTime(endDate);
-        }
-    }
-    slotByPosition(x, y, container) {
-        const isDaySlot = container ? hasClasses(container.parentNode, 'k-scheduler-header-wrap') : y < 0;
-        return this.slotService.slotByPosition(x, y, isDaySlot, Boolean(this.verticalResources.length));
-    }
-    slotFields(slot) {
-        const fields = super.slotFields(slot);
-        if (slot.isDaySlot) {
-            fields.isAllDay = true;
-        }
-        else {
-            fields.start = this.convertDate(slot.start);
-            fields.end = this.convertDate(slot.end);
-        }
-        return fields;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DayTimeViewComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.ViewContextService }, { token: i2.ViewStateService }, { token: i3.IntlService }, { token: i4.DayTimeSlotService }, { token: i0.NgZone }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i5.PDFService }, { token: i6.LocalizationService }, { token: i7.ScrollbarWidthService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DayTimeViewComponent, selector: "kendo-day-time-view", inputs: { timeSlotTemplate: "timeSlotTemplate", dateHeaderTemplate: "dateHeaderTemplate", majorTimeHeaderTemplate: "majorTimeHeaderTemplate", minorTimeHeaderTemplate: "minorTimeHeaderTemplate", numberOfDays: "numberOfDays", scrollTime: "scrollTime", startTime: "startTime", endTime: "endTime", workDayStart: "workDayStart", workDayEnd: "workDayEnd", workWeekStart: "workWeekStart", workWeekEnd: "workWeekEnd", slotDuration: "slotDuration", slotDivisions: "slotDivisions", showWorkHours: "showWorkHours", getStartDate: "getStartDate", getEndDate: "getEndDate", getNextDate: "getNextDate", currentTimeMarker: "currentTimeMarker", highlightOngoingEvents: "highlightOngoingEvents" }, viewQueries: [{ propertyName: "currentTimeElements", predicate: ["currentTimeMarker"], descendants: true }, { propertyName: "eventElements", predicate: DayTimeViewItemComponent, descendants: true }, { propertyName: "currentTimeArrows", predicate: ["currentTimeArrow"], descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DayTimeViewComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'kendo-day-time-view', template: '' }]
-        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.ViewContextService }, { type: i2.ViewStateService }, { type: i3.IntlService }, { type: i4.DayTimeSlotService }, { type: i0.NgZone }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i5.PDFService }, { type: i6.LocalizationService }, { type: i7.ScrollbarWidthService }], propDecorators: { timeSlotTemplate: [{
-                type: Input
-            }], dateHeaderTemplate: [{
-                type: Input
-            }], majorTimeHeaderTemplate: [{
-                type: Input
-            }], minorTimeHeaderTemplate: [{
-                type: Input
-            }], numberOfDays: [{
-                type: Input
-            }], scrollTime: [{
-                type: Input
-            }], startTime: [{
-                type: Input
-            }], endTime: [{
-                type: Input
-            }], workDayStart: [{
-                type: Input
-            }], workDayEnd: [{
-                type: Input
-            }], workWeekStart: [{
-                type: Input
-            }], workWeekEnd: [{
-                type: Input
-            }], slotDuration: [{
-                type: Input
-            }], slotDivisions: [{
-                type: Input
-            }], showWorkHours: [{
-                type: Input
-            }], getStartDate: [{
-                type: Input
-            }], getEndDate: [{
-                type: Input
-            }], getNextDate: [{
-                type: Input
-            }], currentTimeMarker: [{
-                type: Input
-            }], highlightOngoingEvents: [{
-                type: Input
-            }], currentTimeElements: [{
-                type: ViewChildren,
-                args: ['currentTimeMarker']
-            }], eventElements: [{
-                type: ViewChildren,
-                args: [DayTimeViewItemComponent]
-            }], currentTimeArrows: [{
-                type: ViewChildren,
-                args: ['currentTimeArrow']
-            }] } });

package/esm2022/views/day-time/event-slot.directive.mjs

@@ -1,138 +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 { Directive, Input, ElementRef, HostBinding } from '@angular/core';
-import { BaseSlotDirective } from '../view-items/base-slot.directive';
-import { addUTCDays, toUTCTime, toUTCDate, dateWithTime, isWorkWeekDay } from '../utils';
-import { DayTimeSlotService } from './day-time-slot.service';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { INVARIANT_END } from '../constants';
-import * as i0 from "@angular/core";
-import * as i1 from "./day-time-slot.service";
-import * as i2 from "@progress/kendo-angular-l10n";
-/**
- * @hidden
- */
-export class TimeSlotDirective extends BaseSlotDirective {
-    invariantStart;
-    invariantEnd;
-    workDayStart;
-    workDayEnd;
-    workWeekStart;
-    workWeekEnd;
-    date;
-    get nonWorkHour() {
-        const date = this.date.getDay();
-        return this.invariantStart < this.workDayStart || this.workDayEnd < this.invariantEnd || !isWorkWeekDay(date, this.workWeekStart, this.workWeekEnd);
-    }
-    isDaySlot = false;
-    get startLocalTime() {
-        if (!this.date || !this.invariantStart) {
-            return null;
-        }
-        return dateWithTime(this.date, this.invariantStart);
-    }
-    get endLocalTime() {
-        if (!this.date || !this.invariantEnd) {
-            return null;
-        }
-        return dateWithTime(this.date, this.invariantEnd);
-    }
-    get start() {
-        if (!this.date || !this.invariantStart) {
-            return null;
-        }
-        return toUTCTime(this.date, this.invariantStart);
-    }
-    get end() {
-        if (!this.date || !this.invariantEnd) {
-            return null;
-        }
-        const localEnd = toUTCTime(this.date, this.invariantEnd);
-        if (INVARIANT_END.getTime() <= this.invariantEnd.getTime()) {
-            return addUTCDays(localEnd, 1);
-        }
-        return localEnd;
-    }
-    constructor(element, slotService, localization) {
-        super(element, slotService, localization);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TimeSlotDirective, deps: [{ token: i0.ElementRef }, { token: i1.DayTimeSlotService }, { token: i2.LocalizationService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TimeSlotDirective, isStandalone: true, selector: "[timeSlot]", inputs: { invariantStart: "invariantStart", invariantEnd: "invariantEnd", workDayStart: "workDayStart", workDayEnd: "workDayEnd", workWeekStart: "workWeekStart", workWeekEnd: "workWeekEnd", date: "date" }, host: { properties: { "class.k-nonwork-hour": "this.nonWorkHour" } }, exportAs: ["timeSlot"], usesInheritance: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TimeSlotDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: '[timeSlot]',
-                    exportAs: 'timeSlot',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.DayTimeSlotService }, { type: i2.LocalizationService }], propDecorators: { invariantStart: [{
-                type: Input
-            }], invariantEnd: [{
-                type: Input
-            }], workDayStart: [{
-                type: Input
-            }], workDayEnd: [{
-                type: Input
-            }], workWeekStart: [{
-                type: Input
-            }], workWeekEnd: [{
-                type: Input
-            }], date: [{
-                type: Input
-            }], nonWorkHour: [{
-                type: HostBinding,
-                args: ['class.k-nonwork-hour']
-            }] } });
-/**
- * @hidden
- */
-export class DaySlotDirective extends BaseSlotDirective {
-    set start(value) {
-        this.startDate = value;
-    }
-    get start() {
-        if (!this.startDate) {
-            return null;
-        }
-        return toUTCDate(this.startDate);
-    }
-    set end(value) {
-        this.endDate = value;
-    }
-    get end() {
-        if (!this.endDate) {
-            return null;
-        }
-        return toUTCDate(this.endDate);
-    }
-    get daySlot() {
-        return true;
-    }
-    isDaySlot = true;
-    startDate;
-    endDate;
-    constructor(element, slotService, localization) {
-        super(element, slotService, localization);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DaySlotDirective, deps: [{ token: i0.ElementRef }, { token: i1.DayTimeSlotService }, { token: i2.LocalizationService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DaySlotDirective, isStandalone: true, selector: "[daySlot]", inputs: { start: "start", end: "end" }, host: { properties: { "attr.data-day-slot": "this.daySlot" } }, usesInheritance: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DaySlotDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // eslint-disable-next-line @angular-eslint/directive-selector
-                    selector: '[daySlot]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.DayTimeSlotService }, { type: i2.LocalizationService }], propDecorators: { start: [{
-                type: Input
-            }], end: [{
-                type: Input
-            }], daySlot: [{
-                type: HostBinding,
-                args: ['attr.data-day-slot']
-            }] } });

package/esm2022/views/day-time/utils.mjs

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