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

package/esm2022/editing-directives/editing-directive-base.mjs

@@ -1,242 +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, Output, EventEmitter, Directive } from '@angular/core';
-import { SchedulerComponent } from '../scheduler.component';
-import { merge } from 'rxjs';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { LocalEditService } from './local-edit.service';
-import { DialogsService } from '../editing/dialogs.service';
-import { EditMode, CrudOperation } from '../types';
-import { AddEvent } from '../events';
-import { groupResources, assignValues, clone, setField, getField } from '../common/util';
-import { diff, areEqual, seriesDate, updateRecurrenceRule } from './utils';
-import { FocusService } from '../navigation';
-import * as i0 from "@angular/core";
-import * as i1 from "../scheduler.component";
-import * as i2 from "../editing/local-data-changes.service";
-import * as i3 from "../editing/dialogs.service";
-import * as i4 from "../navigation";
-/**
- * @hidden
- */
-export class EditingDirectiveBase {
-    scheduler;
-    localDataChangesService;
-    dialogsService;
-    focusService;
-    /**
-     * Fires before the editing directive renders the **Add** dialog.
-     */
-    add = new EventEmitter();
-    /**
-     * Fires before the editing directive renders the **Edit** dialog.
-     */
-    edit = new EventEmitter();
-    /**
-     * The edit service that will handle the editing operations.
-     */
-    set editService(value) {
-        this.userEditService = value;
-    }
-    get editService() {
-        return this.userEditService || this.defaultEditService;
-    }
-    defaultTitle = 'No title';
-    subscriptions;
-    defaultEditService;
-    userEditService;
-    constructor(scheduler, localDataChangesService, dialogsService, focusService) {
-        this.scheduler = scheduler;
-        this.localDataChangesService = localDataChangesService;
-        this.dialogsService = dialogsService;
-        this.focusService = focusService;
-        this.defaultEditService = this.createDefaultService();
-        this.scheduler.editable = true;
-    }
-    /**
-     * @hidden
-     */
-    ngOnInit() {
-        this.subscriptions = merge(this.scheduler.slotDblClick, this.scheduler.create).subscribe(this.addHandler.bind(this));
-        this.subscriptions.add(this.scheduler.removeConfirmed.subscribe(this.removeHandler.bind(this)));
-        this.subscriptions.add(this.scheduler.cancel.subscribe(this.cancelHandler.bind(this)));
-        this.subscriptions.add(this.scheduler.resizeEndConfirmed.subscribe(this.resizeEndHandler.bind(this)));
-        this.subscriptions.add(this.scheduler.dragEndConfirmed.subscribe(this.dragEndHandler.bind(this)));
-    }
-    /**
-     * @hidden
-     */
-    ngOnDestroy() {
-        this.subscriptions.unsubscribe();
-    }
-    createDefaultService() {
-        return new LocalEditService(this.scheduler, this.localDataChangesService);
-    }
-    addHandler(args) {
-        this.closeEditor();
-        if (!this.isEnabled('add')) {
-            return;
-        }
-        const fields = this.scheduler.modelFields;
-        const dataItem = {};
-        setField(dataItem, fields.start, args.start);
-        setField(dataItem, fields.end, args.end);
-        setField(dataItem, fields.isAllDay, args.isAllDay);
-        setField(dataItem, fields.title, args.title);
-        const resources = groupResources(this.scheduler.group, this.scheduler.resources);
-        const slotResources = args.resources;
-        for (let idx = 0; idx < resources.length; idx++) {
-            const resource = resources[idx];
-            const value = getField(slotResources[idx], resource.valueField);
-            setField(dataItem, resource.field, resource.multiple ? [value] : value);
-        }
-        const addArgs = new AddEvent(this.scheduler, { dataItem });
-        this.add.emit(addArgs);
-        if (!addArgs.isDefaultPrevented()) {
-            this.scheduler.addEvent(this.createModel({
-                action: 'add',
-                isNew: true,
-                dataItem,
-                sender: this.scheduler,
-            }));
-        }
-    }
-    removeHandler({ dataItem }) {
-        if (!this.isEnabled('remove')) {
-            return;
-        }
-        if (this.editService.isRecurring(dataItem)) {
-            this.dialogsService.openRecurringConfirmationDialog(CrudOperation.Remove)
-                .subscribe((editMode) => {
-                if (editMode !== undefined) {
-                    this.handleRemove(dataItem, editMode);
-                    this.focusService.focusContent();
-                }
-            });
-        }
-        else {
-            this.dialogsService.openRemoveConfirmationDialog()
-                .subscribe((shouldRemove) => {
-                if (shouldRemove) {
-                    this.handleRemove(dataItem, EditMode.Event);
-                    this.focusService.focusContent();
-                }
-            });
-        }
-    }
-    cancelHandler() {
-        this.closeEditor();
-    }
-    closeEditor() {
-        this.scheduler.closeEvent();
-    }
-    handleUpdate(item, value, mode) {
-        const svc = this.editService;
-        if (mode === EditMode.Occurrence) {
-            // eslint-disable-next-line no-unused-expressions
-            svc.isException(item) ?
-                svc.update(item, value) :
-                svc.createException(item, value);
-        }
-        else {
-            // Item is not recurring or we're editing the entire series
-            svc.update(item, value);
-        }
-    }
-    handleRemove(item, mode) {
-        const svc = this.editService;
-        if (mode === EditMode.Series) {
-            svc.removeSeries(item);
-        }
-        else if (mode === EditMode.Occurrence) {
-            svc.isException(item) ?
-                svc.remove(item) :
-                svc.removeOccurrence(item);
-        }
-        else {
-            // Item is not recurring
-            svc.remove(item);
-        }
-    }
-    resizeEndHandler({ event, start, end }) {
-        if (areEqual(start, event.start) && areEqual(end, event.end)) {
-            return;
-        }
-        const dataItem = event.dataItem;
-        const fields = this.scheduler.modelFields;
-        let value = {};
-        setField(value, fields.start, start);
-        setField(value, fields.end, end);
-        if (this.editService.isRecurring(dataItem)) {
-            this.dialogsService.openRecurringConfirmationDialog(CrudOperation.Edit)
-                .subscribe((result) => {
-                let target = dataItem;
-                if (result === EditMode.Series) {
-                    target = this.editService.findRecurrenceMaster(dataItem);
-                    setField(value, fields.start, seriesDate(target, dataItem, value, fields.start));
-                    setField(value, fields.end, seriesDate(target, dataItem, value, fields.end));
-                }
-                else if (result !== undefined) {
-                    value = assignValues(clone(dataItem), value);
-                }
-                this.handleUpdate(target, value, result);
-            });
-        }
-        else {
-            this.editService.update(dataItem, value);
-        }
-    }
-    dragEndHandler({ event: { dataItem }, start, end, resources, isAllDay }) {
-        const modelFields = this.scheduler.modelFields;
-        const resourceFields = groupResources(this.scheduler.group, this.scheduler.resources).map(r => r.field);
-        const fields = [modelFields.start, modelFields.end, modelFields.isAllDay].concat(resourceFields);
-        let value = clone(resources);
-        setField(value, modelFields.start, start);
-        setField(value, modelFields.end, end);
-        setField(value, modelFields.isAllDay, isAllDay);
-        if (!diff(dataItem, value, fields)) {
-            return;
-        }
-        if (this.editService.isRecurring(dataItem)) {
-            this.dialogsService.openRecurringConfirmationDialog(CrudOperation.Edit)
-                .subscribe((result) => {
-                let target = dataItem;
-                if (result === EditMode.Series) {
-                    target = this.editService.findRecurrenceMaster(dataItem);
-                    if (dataItem.recurrenceRule) {
-                        const newRecurrenceRule = updateRecurrenceRule(dataItem, value);
-                        if (newRecurrenceRule !== dataItem?.recurrenceRule) {
-                            setField(value, modelFields.recurrenceRule, newRecurrenceRule);
-                        }
-                    }
-                    setField(value, modelFields.start, seriesDate(target, dataItem, value, modelFields.start));
-                    setField(value, modelFields.end, seriesDate(target, dataItem, value, modelFields.end));
-                }
-                else if (result !== undefined) {
-                    value = assignValues(clone(dataItem), value);
-                }
-                this.handleUpdate(target, value, result);
-            });
-        }
-        else {
-            this.editService.update(dataItem, value);
-        }
-    }
-    isEnabled(action) {
-        const editable = this.scheduler.editable;
-        return editable && editable[action] !== false;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditingDirectiveBase, deps: [{ token: i1.SchedulerComponent }, { token: i2.LocalDataChangesService }, { token: i3.DialogsService }, { token: i4.FocusService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: EditingDirectiveBase, inputs: { editService: "editService" }, outputs: { add: "add", edit: "edit" }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditingDirectiveBase, decorators: [{
-            type: Directive
-        }], ctorParameters: () => [{ type: i1.SchedulerComponent }, { type: i2.LocalDataChangesService }, { type: i3.DialogsService }, { type: i4.FocusService }], propDecorators: { add: [{
-                type: Output
-            }], edit: [{
-                type: Output
-            }], editService: [{
-                type: Input
-            }] } });

package/esm2022/editing-directives/local-edit.service.mjs

@@ -1,122 +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 { isPresent, isRecurring, isException, readEvent, getField, setField, assignValues, clone } from '../common/util';
-import { isDevMode } from '@angular/core';
-import { guid } from '@progress/kendo-angular-common';
-const isRecurrenceMaster = (ev) => !!(ev.id && ev.recurrenceRule);
-/**
- * @hidden
- */
-export class LocalEditService {
-    scheduler;
-    localDataChangesService;
-    get fields() {
-        return this.scheduler.modelFields;
-    }
-    get hasLocalData() {
-        return isPresent(this.localDataChangesService.data);
-    }
-    get data() {
-        if (this.hasLocalData) {
-            return this.localDataChangesService.data;
-        }
-        return this.scheduler.events;
-    }
-    constructor(scheduler, localDataChangesService) {
-        this.scheduler = scheduler;
-        this.localDataChangesService = localDataChangesService;
-    }
-    create(item) {
-        const idField = this.fields.id;
-        const id = getField(item, idField);
-        if (!isPresent(id)) {
-            setField(item, idField, this.nextId());
-        }
-        this.data.push(item);
-        this.dataChanged();
-    }
-    createException(item, value) {
-        const exception = this.buildException(value);
-        this.removeOccurrenceInternal(item);
-        this.create(exception);
-    }
-    update(item, value) {
-        assignValues(item, value);
-        this.dataChanged();
-    }
-    remove(item) {
-        const idField = this.fields.id;
-        const itemId = getField(item, idField);
-        const data = this.data;
-        for (let idx = 0; idx < data.length; idx++) {
-            if (itemId === getField(data[idx], idField)) {
-                data.splice(idx, 1);
-                break;
-            }
-        }
-        this.dataChanged();
-    }
-    removeSeries(item) {
-        const event = readEvent(item, this.fields);
-        const isHead = isRecurrenceMaster(event);
-        this.removeItemAndExceptions(isHead ? event.id : event.recurrenceId);
-        this.dataChanged();
-    }
-    removeOccurrence(item) {
-        this.removeOccurrenceInternal(item);
-        this.dataChanged();
-    }
-    findRecurrenceMaster(item) {
-        const fields = this.scheduler.modelFields;
-        const event = readEvent(item, fields);
-        const headId = isRecurrenceMaster(event) ? event.id : event.recurrenceId;
-        return this.data.find((dataItem) => getField(dataItem, fields.id) === headId);
-    }
-    isRecurring(event) {
-        return isRecurring(event, this.scheduler.modelFields);
-    }
-    isException(event) {
-        return isException(event, this.scheduler.modelFields);
-    }
-    nextId() {
-        return guid();
-    }
-    buildException(item) {
-        const fields = this.fields;
-        const head = this.findRecurrenceMaster(item);
-        if (!head) {
-            if (isDevMode()) {
-                throw new Error('Unable to find recurrence head for event. Please check that recurrenceId is set and refers to an existing event.');
-            }
-            return;
-        }
-        const exception = clone(item);
-        setField(exception, fields.id, this.nextId());
-        setField(exception, fields.recurrenceId, getField(head, fields.id));
-        setField(exception, fields.recurrenceRule, null);
-        return exception;
-    }
-    removeItemAndExceptions(itemId) {
-        const data = this.data;
-        const fields = this.scheduler.modelFields;
-        for (let idx = data.length - 1; idx >= 0; idx--) {
-            if (itemId === getField(data[idx], fields.recurrenceId) || itemId === getField(data[idx], fields.id)) {
-                data.splice(idx, 1);
-            }
-        }
-    }
-    removeOccurrenceInternal(item) {
-        const fields = this.fields;
-        const head = this.findRecurrenceMaster(item);
-        const exceptionDate = getField(item, fields.start);
-        const currentExceptions = getField(head, fields.recurrenceExceptions) || [];
-        setField(head, fields.recurrenceExceptions, [...currentExceptions, exceptionDate]);
-    }
-    dataChanged() {
-        if (this.hasLocalData) {
-            this.localDataChangesService.changes.emit();
-        }
-    }
-}

package/esm2022/editing-directives/reactive-editing.directive.mjs

@@ -1,132 +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 } from "@angular/core";
-import { SchedulerComponent } from '../scheduler.component';
-import { EditingDirectiveBase } from './editing-directive-base';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { markAllAsTouched } from './utils';
-import { DialogsService } from '../editing/dialogs.service';
-import { CrudOperation } from '../types';
-import { EditMode } from '../types/edit-mode.enum';
-import { EditEvent } from '../events';
-import { filter } from 'rxjs/operators';
-import { FocusService } from "../navigation";
-import * as i0 from "@angular/core";
-import * as i1 from "../scheduler.component";
-import * as i2 from "../editing/local-data-changes.service";
-import * as i3 from "../editing/dialogs.service";
-import * as i4 from "../navigation";
-/**
- * A directive that encapsulates editing operations for the Scheduler using [Angular Reactive Forms](link:site.data.urls.angular['reactiveforms']) ([see example](slug:editing_scheduler)).
- *
- * Handles event editing, saving, and form validation logic for the Scheduler component.
- * Provides integration with custom form group creation and supports recurring event editing scenarios.
- *
- * @example
- * ```html
- * <kendo-scheduler
- *      [kendoSchedulerBinding]="events"
- *      [kendoSchedulerReactiveEditing]="createFormGroup">
- * </kendo-scheduler>
- * ```
- *
- * @remarks
- * Applied to: {@link SchedulerComponent}
- */
-export class ReactiveEditingDirective extends EditingDirectiveBase {
-    scheduler;
-    localDataChangesService;
-    dialogsService;
-    /**
-     * The function that creates the `FormGroup` for the edited model.
-     */
-    createFormGroup;
-    constructor(scheduler, localDataChangesService, dialogsService, focusService) {
-        super(scheduler, localDataChangesService, dialogsService, focusService);
-        this.scheduler = scheduler;
-        this.localDataChangesService = localDataChangesService;
-        this.dialogsService = dialogsService;
-    }
-    ngOnInit() {
-        super.ngOnInit();
-        this.subscriptions.add(this.scheduler.eventDblClick.subscribe(this.editHandler.bind(this)));
-        this.subscriptions.add(this.scheduler.save.subscribe(this.saveHandler.bind(this)));
-    }
-    editHandler(args) {
-        if (!this.isEnabled('edit')) {
-            return;
-        }
-        const editArgs = new EditEvent(this.scheduler, { dataItem: args.event.dataItem, event: args.event });
-        this.edit.emit(editArgs);
-        if (editArgs.isDefaultPrevented()) {
-            return;
-        }
-        let dataItem = args.event.dataItem;
-        if (this.editService.isRecurring(dataItem)) {
-            this.dialogsService.openRecurringConfirmationDialog(CrudOperation.Edit)
-                .pipe(filter(mode => mode !== undefined))
-                .subscribe((mode) => {
-                if (mode === EditMode.Series) {
-                    dataItem = this.editService.findRecurrenceMaster(dataItem);
-                }
-                const group = this.createModel({
-                    action: 'edit',
-                    isNew: false,
-                    mode,
-                    dataItem,
-                    sender: this.scheduler,
-                });
-                this.scheduler.editEvent(dataItem, { group, mode });
-            });
-        }
-        else {
-            const group = this.createModel({
-                action: 'edit',
-                isNew: false,
-                mode: EditMode.Event,
-                dataItem,
-                sender: this.scheduler,
-            });
-            this.scheduler.editEvent(dataItem, { group });
-        }
-    }
-    saveHandler(args) {
-        if (this.isFormValid(args)) {
-            const formValue = args.formGroup.getRawValue();
-            if (args.isNew) {
-                this.editService.create(formValue);
-            }
-            else {
-                this.handleUpdate(args.dataItem, formValue, args.mode);
-            }
-        }
-        this.closeEditor();
-    }
-    createModel(args) {
-        return this.createFormGroup(args);
-    }
-    isFormValid({ formGroup, isNew }) {
-        if (formGroup.valid) {
-            return true;
-        }
-        if (!formGroup.dirty && !isNew) {
-            return false;
-        }
-        markAllAsTouched(formGroup);
-        return false;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReactiveEditingDirective, deps: [{ token: i1.SchedulerComponent }, { token: i2.LocalDataChangesService }, { token: i3.DialogsService }, { token: i4.FocusService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ReactiveEditingDirective, isStandalone: true, selector: "[kendoSchedulerReactiveEditing]", inputs: { createFormGroup: ["kendoSchedulerReactiveEditing", "createFormGroup"] }, usesInheritance: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReactiveEditingDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoSchedulerReactiveEditing]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.SchedulerComponent }, { type: i2.LocalDataChangesService }, { type: i3.DialogsService }, { type: i4.FocusService }], propDecorators: { createFormGroup: [{
-                type: Input,
-                args: ['kendoSchedulerReactiveEditing']
-            }] } });

package/esm2022/editing-directives/utils.mjs

@@ -1,107 +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 { getField } from '../common/util';
-import { parseRule, serializeRule } from '@progress/kendo-recurrence';
-/**
- * @hidden
- */
-export const markAllAsTouched = (control) => {
-    control.markAsTouched();
-    if (control.hasOwnProperty('controls')) {
-        const controls = control.controls;
-        for (const inner in controls) {
-            if (controls.hasOwnProperty(inner)) {
-                markAllAsTouched(controls[inner]);
-            }
-        }
-    }
-};
-/**
- * @hidden
- */
-export function diff(obj1, obj2, fields) {
-    for (let idx = 0; idx < fields.length; idx++) {
-        const field = fields[idx];
-        if (!areEqual(getField(obj1, field), getField(obj2, field))) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * @hidden
- */
-export function areEqual(value1, value2) {
-    if (value1 && value1.getTime && value2 && value2.getTime) {
-        return value1.getTime() === value2.getTime();
-    }
-    else if (Array.isArray(value1)) {
-        if (!Array.isArray(value2) || value1.length !== value2.length) {
-            return false;
-        }
-        for (let idx = 0; idx < value1.length; idx++) {
-            if (value1[idx] !== value2[idx]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return value1 == value2;
-}
-const DATE_ACCESSORS = ['getFullYear', 'getMonth', 'getDate', 'getHours', 'getMinutes', 'getSeconds', 'getMilliseconds'];
-/**
- * @hidden
- */
-export function seriesDate(head, occurrence, current, field) {
-    const values = [];
-    const headDate = getField(head, field);
-    const occurrenceDate = getField(occurrence, field);
-    const currentDate = getField(current, field);
-    DATE_ACCESSORS.forEach(accessor => {
-        values.push(occurrenceDate[accessor]() === currentDate[accessor]() ? headDate[accessor]() : currentDate[accessor]());
-    });
-    return new Date(...values);
-}
-/**
- * @hidden
- */
-export function updateRecurrenceRule(valueSrc, valueGoal) {
-    const rrule = parseRule({ recurrenceRule: valueSrc.recurrenceRule });
-    // parseRule sets weekStart to 0 if not present which then adds it to the serialized rule
-    if (!valueSrc.recurrenceRule.includes("WKST")) {
-        rrule.weekStart = undefined;
-    }
-    if (valueSrc.start?.getDate() !== valueGoal.start?.getDate()) {
-        if (rrule.byYearDay?.length > 0) {
-            // when the event is recurring on more than one day of the year
-            const itemIndex = rrule.byYearDay.findIndex(yearDay => yearDay === valueSrc.start?.getDate());
-            if (itemIndex !== -1) {
-                rrule.byYearDay[itemIndex] = valueGoal.start?.getDate();
-            }
-        }
-        if (rrule.byMonthDay?.length > 0) {
-            // when the event is recurring on more than one day of the month
-            const itemIndex = rrule.byMonthDay.findIndex(monthDay => monthDay === valueSrc.start?.getDate());
-            if (itemIndex !== -1) {
-                rrule.byMonthDay[itemIndex] = valueGoal.start?.getDate();
-            }
-        }
-    }
-    if (valueSrc.start?.getDay() !== valueGoal.start?.getDay() && rrule.byWeekDay?.length > 0) {
-        // when the event is recurring on more than one day of the week
-        const itemIndex = rrule.byWeekDay.findIndex(weekDayRule => weekDayRule.day === valueSrc.start?.getDay());
-        if (itemIndex !== -1) {
-            rrule.byWeekDay[itemIndex].day = valueGoal.start?.getDay();
-        }
-    }
-    if (valueSrc.start?.getMonth() !== valueGoal.start?.getMonth() && rrule.byMonth?.length > 0) {
-        // when the event is recurring on more than one month of the year
-        const itemIndex = rrule.byMonth.findIndex(month => month === valueSrc.start?.getMonth());
-        if (itemIndex !== -1) {
-            rrule.byMonth[itemIndex] = valueGoal.start?.getMonth();
-        }
-    }
-    return serializeRule(rrule);
-}

package/esm2022/events/add-event.mjs

@@ -1,26 +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 { PreventableEvent } from './preventable-event';
-/**
- * Represents the arguments for the `add` event of the editing directives.
- */
-export class AddEvent extends PreventableEvent {
-    /**
-     * Provides the data for binding the **Add** dialog.
-     */
-    dataItem;
-    /**
-     * Provides a reference to the Scheduler instance that triggered the event.
-     */
-    sender;
-    /**
-     * @hidden
-     */
-    constructor(sender, args) {
-        super();
-        this.sender = sender;
-        Object.assign(this, args);
-    }
-}

package/esm2022/events/cancel-event.mjs

@@ -1,14 +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 { EditEventBase } from './edit-event-base';
-/**
- * Represents the arguments for the `cancel` event.
- */
-export class CancelEvent extends EditEventBase {
-    /**
-     * Provides the edited `formGroup` instance.
-     */
-    formGroup;
-}

package/esm2022/events/create-event.mjs

@@ -1,40 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * Represents the arguments for the `create` event.
- */
-export class CreateEvent {
-    /**
-     * Provides the start date of the slot.
-     */
-    start;
-    /**
-     * Provides the end date of the slot.
-     */
-    end;
-    /**
-     * Indicates if the slot is all-day.
-     */
-    isAllDay;
-    /**
-     * Provides the resources of the slot.
-     */
-    resources;
-    /**
-     * Provides the original DOM event.
-     */
-    originalEvent;
-    /**
-     * Provides a reference to the Scheduler instance that triggered the event.
-     */
-    sender;
-    /**
-     * @hidden
-     */
-    constructor(sender, args) {
-        this.sender = sender;
-        Object.assign(this, args);
-    }
-}