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

package/dist/es2015/editing-directives/editing-directive-base.d.ts

@@ -1,56 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { OnInit, OnDestroy, EventEmitter } from '@angular/core';
-import { SchedulerComponent } from '../scheduler.component';
-import { Subscription } from 'rxjs';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { EditService } from './edit-service.interface';
-import { DialogsService } from '../editing/dialogs.service';
-import { EditMode } from '../types';
-import { AddEvent, EditEvent } from '../events';
-/**
- * @hidden
- */
-export declare abstract class EditingDirectiveBase implements OnInit, OnDestroy {
-    protected scheduler: SchedulerComponent;
-    protected localDataChangesService: LocalDataChangesService;
-    protected dialogsService: DialogsService;
-    /**
-     * Fires before the editing directive renders the **Add** dialog.
-     */
-    add: EventEmitter<AddEvent>;
-    /**
-     * Fires before the editing directive renders the **Edit** dialog.
-     */
-    edit: EventEmitter<EditEvent>;
-    /**
-     * The edit service that will handle the editing operations.
-     */
-    editService: EditService<any>;
-    protected defaultTitle: string;
-    protected subscriptions: Subscription;
-    protected defaultEditService: EditService<any>;
-    protected userEditService: EditService<any>;
-    protected abstract createModel(args: any): any;
-    constructor(scheduler: SchedulerComponent, localDataChangesService: LocalDataChangesService, dialogsService: DialogsService);
-    /**
-     * @hidden
-     */
-    ngOnInit(): void;
-    /**
-     * @hidden
-     */
-    ngOnDestroy(): void;
-    protected createDefaultService(): EditService<any>;
-    protected addHandler(args: any): void;
-    protected removeHandler({ dataItem }: any): void;
-    protected cancelHandler(): void;
-    protected closeEditor(): void;
-    protected handleUpdate(item: any, value: any, mode: EditMode): void;
-    protected handleRemove(item: any, mode: EditMode): void;
-    protected resizeEndHandler({ event, start, end }: any): void;
-    protected dragEndHandler({ event: { dataItem }, start, end, resources, isAllDay }: any): void;
-    protected isEnabled(action: string): boolean;
-}

package/dist/es2015/editing-directives/editing-directive-base.js

@@ -1,217 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Input, Output, EventEmitter } from '@angular/core';
-import { merge } from 'rxjs';
-import { LocalEditService } from './local-edit.service';
-import { AddEvent } from '../events';
-import { groupResources, assignValues, clone, setField, getField } from '../common/util';
-import { diff, areEqual, seriesDate } from './utils';
-/**
- * @hidden
- */
-export class EditingDirectiveBase {
-    constructor(scheduler, localDataChangesService, dialogsService) {
-        this.scheduler = scheduler;
-        this.localDataChangesService = localDataChangesService;
-        this.dialogsService = dialogsService;
-        /**
-         * Fires before the editing directive renders the **Add** dialog.
-         */
-        this.add = new EventEmitter();
-        /**
-         * Fires before the editing directive renders the **Edit** dialog.
-         */
-        this.edit = new EventEmitter();
-        this.defaultTitle = 'No title';
-        this.defaultEditService = this.createDefaultService();
-        this.scheduler.editable = true;
-    }
-    /**
-     * The edit service that will handle the editing operations.
-     */
-    set editService(value) {
-        this.userEditService = value;
-    }
-    get editService() {
-        return this.userEditService || this.defaultEditService;
-    }
-    /**
-     * @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
-            }));
-        }
-    }
-    removeHandler({ dataItem }) {
-        if (!this.isEnabled('remove')) {
-            return;
-        }
-        if (this.editService.isRecurring(dataItem)) {
-            this.dialogsService.openRecurringConfirmationDialog(1 /* Remove */)
-                .subscribe((editMode) => {
-                if (editMode !== undefined) {
-                    this.handleRemove(dataItem, editMode);
-                }
-            });
-        }
-        else {
-            this.dialogsService.openRemoveConfirmationDialog()
-                .subscribe((shouldRemove) => {
-                if (shouldRemove) {
-                    this.handleRemove(dataItem, 0 /* Event */);
-                }
-            });
-        }
-    }
-    cancelHandler() {
-        this.closeEditor();
-    }
-    closeEditor() {
-        this.scheduler.closeEvent();
-    }
-    handleUpdate(item, value, mode) {
-        const svc = this.editService;
-        if (mode === 1 /* Occurrence */) {
-            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 === 2 /* Series */) {
-            svc.removeSeries(item);
-        }
-        else if (mode === 1 /* 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(0 /* Edit */)
-                .subscribe((result) => {
-                let target = dataItem;
-                if (result === 2 /* 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(0 /* Edit */)
-                .subscribe((result) => {
-                let target = dataItem;
-                if (result === 2 /* Series */) {
-                    target = this.editService.findRecurrenceMaster(dataItem);
-                    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;
-    }
-}
-tslib_1.__decorate([
-    Output(),
-    tslib_1.__metadata("design:type", EventEmitter)
-], EditingDirectiveBase.prototype, "add", void 0);
-tslib_1.__decorate([
-    Output(),
-    tslib_1.__metadata("design:type", EventEmitter)
-], EditingDirectiveBase.prototype, "edit", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Object),
-    tslib_1.__metadata("design:paramtypes", [Object])
-], EditingDirectiveBase.prototype, "editService", null);

package/dist/es2015/editing-directives/local-edit.service.d.ts

@@ -1,33 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { SchedulerModelFields } from '../types/scheduler-model-fields.interface';
-import { SchedulerComponent } from '../scheduler.component';
-import { EditService } from './edit-service.interface';
-/**
- * @hidden
- */
-export declare class LocalEditService implements EditService<any> {
-    private scheduler;
-    private localDataChangesService;
-    readonly fields: SchedulerModelFields;
-    private readonly hasLocalData;
-    private readonly data;
-    constructor(scheduler: SchedulerComponent, localDataChangesService: LocalDataChangesService);
-    create(item: any): void;
-    createException(item: any, value: any): void;
-    update(item: any, value: any): void;
-    remove(item: any): void;
-    removeSeries(item: any): void;
-    removeOccurrence(item: any): void;
-    findRecurrenceMaster(item: any): any;
-    isRecurring(event: any): boolean;
-    isException(event: any): boolean;
-    private nextId;
-    private buildException;
-    private removeItemAndExceptions;
-    private removeOccurrenceInternal;
-    private dataChanged;
-}

package/dist/es2015/editing-directives/local-edit.service.js

@@ -1,122 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 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);
-const ɵ0 = isRecurrenceMaster;
-/**
- * @hidden
- */
-export class LocalEditService {
-    constructor(scheduler, localDataChangesService) {
-        this.scheduler = scheduler;
-        this.localDataChangesService = 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;
-    }
-    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();
-        }
-    }
-}
-export { ɵ0 };

package/dist/es2015/editing-directives/reactive-editing.directive.d.ts

@@ -1,29 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { FormGroup } from '@angular/forms';
-import { SchedulerComponent } from '../scheduler.component';
-import { EditingDirectiveBase } from './editing-directive-base';
-import { CreateFormGroupArgs } from '../types/create-form-group-args.interface';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { DialogsService } from '../editing/dialogs.service';
-/**
- * A directive which encapsulates the editing operations when the Scheduler
- * uses the [Reactive Angular Forms]({{ site.data.urls.angular['reactiveforms'] }}).
- */
-export declare class ReactiveEditingDirective extends EditingDirectiveBase {
-    protected scheduler: SchedulerComponent;
-    protected localDataChangesService: LocalDataChangesService;
-    protected dialogsService: DialogsService;
-    /**
-     * The function that creates the `FormGroup` for the edited model.
-     */
-    createFormGroup: (args: CreateFormGroupArgs) => FormGroup;
-    constructor(scheduler: SchedulerComponent, localDataChangesService: LocalDataChangesService, dialogsService: DialogsService);
-    ngOnInit(): void;
-    protected editHandler(args: any): void;
-    protected saveHandler(args: any): void;
-    protected createModel(args: any): any;
-    protected isFormValid({ formGroup, isNew }: any): boolean;
-}

package/dist/es2015/editing-directives/reactive-editing.directive.js

@@ -1,106 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-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 { EditEvent } from '../events';
-import { filter } from 'rxjs/operators';
-/**
- * A directive which encapsulates the editing operations when the Scheduler
- * uses the [Reactive Angular Forms]({{ site.data.urls.angular['reactiveforms'] }}).
- */
-let ReactiveEditingDirective = class ReactiveEditingDirective extends EditingDirectiveBase {
-    constructor(scheduler, localDataChangesService, dialogsService) {
-        super(scheduler, localDataChangesService, dialogsService);
-        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(0 /* Edit */)
-                .pipe(filter(mode => mode !== undefined))
-                .subscribe((mode) => {
-                if (mode === 2 /* Series */) {
-                    dataItem = this.editService.findRecurrenceMaster(dataItem);
-                }
-                const group = this.createModel({
-                    action: 'edit',
-                    isNew: false,
-                    mode,
-                    dataItem
-                });
-                this.scheduler.editEvent(dataItem, { group, mode });
-            });
-        }
-        else {
-            const group = this.createModel({
-                action: 'edit',
-                isNew: false,
-                mode: 0 /* Event */,
-                dataItem
-            });
-            this.scheduler.editEvent(dataItem, { group });
-        }
-    }
-    saveHandler(args) {
-        if (this.isFormValid(args)) {
-            const formValue = args.formGroup.value;
-            if (args.isNew) {
-                this.editService.create(formValue);
-            }
-            else {
-                this.handleUpdate(args.dataItem, formValue, args.mode);
-            }
-        }
-        this.closeEditor();
-    }
-    createModel(args) {
-        // Alias `event` for backwards compatibility.
-        args.event = args.dataItem;
-        return this.createFormGroup(args);
-    }
-    isFormValid({ formGroup, isNew }) {
-        if (formGroup.valid) {
-            return true;
-        }
-        if (!formGroup.dirty && !isNew) {
-            return false;
-        }
-        markAllAsTouched(formGroup);
-        return false;
-    }
-};
-tslib_1.__decorate([
-    Input('kendoSchedulerReactiveEditing'),
-    tslib_1.__metadata("design:type", Function)
-], ReactiveEditingDirective.prototype, "createFormGroup", void 0);
-ReactiveEditingDirective = tslib_1.__decorate([
-    Directive({
-        selector: '[kendoSchedulerReactiveEditing]'
-    }),
-    tslib_1.__metadata("design:paramtypes", [SchedulerComponent,
-        LocalDataChangesService,
-        DialogsService])
-], ReactiveEditingDirective);
-export { ReactiveEditingDirective };

package/dist/es2015/editing-directives/utils.js

@@ -1,66 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 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';
-/**
- * @hidden
- */
-export const markAllAsTouched = (control) => {
-    control.markAsTouched();
-    if (control.hasOwnProperty('controls')) {
-        let controls = control.controls;
-        for (let 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;
-    }
-    // tslint:disable-next-line:triple-equals
-    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);
-}

package/dist/es2015/events.js

@@ -1,25 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export { DateChangeEvent } from './events/date-change-event';
-export { NavigateEvent } from './events/navigate-event';
-export { SlotClickEvent } from './events/slot-click-event';
-export { EventClickEvent } from './events/event-click-event';
-export { EventKeydownEvent } from './events/event-keydown-event';
-export { VIEW_EVENT_MAP } from './events/view-event-map';
-export { CancelEvent } from './events/cancel-event';
-export { EditEventBase } from './events/edit-event-base';
-export { RemoveEvent } from './events/remove-event';
-export { SaveEvent } from './events/save-event';
-export { ResizeStartEvent } from './events/resize-start-event';
-export { ResizeEvent } from './events/resize-event';
-export { ResizeEndEvent } from './events/resize-end-event';
-export { DragStartEvent } from './events/drag-start-event';
-export { DragEvent } from './events/drag-event';
-export { DragEndEvent } from './events/drag-end-event';
-export { EditEvent } from './events/edit-event';
-export { AddEvent } from './events/add-event';
-export { SlotDragStartEvent } from './events/slot-drag-start-event';
-export { SlotDragEvent } from './events/slot-drag-event';
-export { SlotDragEndEvent } from './events/slot-drag-end-event';