@progress/kendo-angular-scheduler 3.0.3-dev.202204061046 → 4.0.0-dev.202204140813

package/dist/es2015/editing/edit-dialog.component.js

@@ -1,389 +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 { Component, Input, NgZone, ChangeDetectorRef, ViewChildren, QueryList, ElementRef } from '@angular/core';
-import { FormControl } from '@angular/forms';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { EditService } from './edit.service';
-import { fromEvent } from 'rxjs';
-import { isPresent } from '../common/util';
-import { EditDialogTemplateDirective } from './edit-dialog-template.directive';
-import { MultipleResourceEditorComponent } from './resource-multiple-editor.component';
-import { SingleResourceEditorComponent } from './resource-single-editor.component';
-import { Keys } from '@progress/kendo-angular-common';
-import { filter } from 'rxjs/operators';
-import { withModifiers, Modifiers } from '../common/modifiers';
-import { FocusService } from '../navigation';
-import { Day, ZonedDate, toLocalDate } from '@progress/kendo-date-math';
-import { toUTCDateTime, formValueOrDefault } from '../views/utils';
-/**
- * @hidden
- */
-let EditDialogComponent = class EditDialogComponent {
-    constructor(ngZone, editService, localization, changeDetector, element, focusService) {
-        this.ngZone = ngZone;
-        this.editService = editService;
-        this.localization = localization;
-        this.changeDetector = changeDetector;
-        this.element = element;
-        this.focusService = focusService;
-        this.resources = [];
-        this.timezone = 'Etc/UTC';
-        this.setTimeZone = false;
-        this.setSeparateStartEndTimeZones = false;
-        this.subs = this.editService.changed.subscribe(() => {
-            this.ngZone.run(() => { this.onChange(); });
-        });
-        this.subs.add(fromEvent(this.element.nativeElement, 'keydown')
-            .pipe(filter(() => this.isActive))
-            .subscribe((e) => {
-            if (e.keyCode === Keys.Escape) {
-                this.reset();
-            }
-            if (e.keyCode === Keys.Enter && (withModifiers(e, Modifiers.CtrlKey) || withModifiers(e, Modifiers.MetaKey))) {
-                this.onSave(e);
-            }
-            e.stopPropagation();
-        }));
-    }
-    get autoFocusedElement() {
-        if (this.editTemplate) {
-            return this.editTemplate.autoFocusedElement;
-        }
-        return '.k-edit-field input';
-    }
-    get isEditingSeries() {
-        return this.editMode === 2 /* Series */ && Boolean(this.formGroup.get(this.fields.recurrenceRule));
-    }
-    get eventTimezone() {
-        return formValueOrDefault(this.formGroup, this.fields.startTimezone, this.timezone);
-    }
-    get endTimezone() {
-        return formValueOrDefault(this.formGroup, this.fields.endTimezone, this.eventTimezone);
-    }
-    onChange() {
-        this.changeDetector.markForCheck();
-        if (this.editService.hasNewEvent) {
-            this.editMode = 2 /* Series */;
-            this.formGroup = this.editService.context.formGroup;
-            this.isNew = true;
-            this.applyLocalTimezone();
-        }
-        else if (this.editService.isEditing()) {
-            const { dataItem, mode } = this.editService.context;
-            this.formGroup = this.editService.context.formGroup;
-            this.isNew = false;
-            this.editedEvent = dataItem;
-            this.editMode = isPresent(mode) ? mode : 2 /* Series */;
-            this.applyLocalTimezone();
-        }
-        else {
-            this.reset();
-            return;
-        }
-        if (!this.editTemplate) {
-            this.addTimeZoneCheckboxesToFormGroup();
-            this.subscribeToFormGroupChanges();
-        }
-        if (isPresent(this.formGroup)) {
-            this.recurrenceStart = this.formGroup.get(this.fields.start).value;
-        }
-        this.isActive = true;
-    }
-    ngOnDestroy() {
-        if (this.subs) {
-            this.subs.unsubscribe();
-        }
-    }
-    onCancel(e) {
-        e.preventDefault();
-        this.onClose();
-        this.changeDetector.markForCheck();
-    }
-    onSave(e) {
-        e.preventDefault();
-        this.applyTimezone();
-        this.editService.save();
-        this.changeDetector.markForCheck();
-    }
-    onClose() {
-        this.editService.endEdit();
-        this.changeDetector.markForCheck();
-        this.focusService.focus();
-    }
-    get hasAllDay() {
-        return Boolean(this.formGroup.get(this.fields.isAllDay));
-    }
-    get hasStartTimeZone() {
-        return Boolean(this.formGroup.get(this.fields.startTimezone));
-    }
-    get isStartTimeZoneVisible() {
-        return this.formGroup && this.formGroup.get('startTimezoneCheckbox').value;
-    }
-    get hasEndTimeZone() {
-        return Boolean(this.formGroup.get(this.fields.endTimezone));
-    }
-    get isEndTimeZoneVisible() {
-        return this.formGroup && this.formGroup.get('endTimezoneCheckbox').value;
-    }
-    getFormValue(field) {
-        if (field) {
-            return this.formGroup.get(field);
-        }
-    }
-    textFor(key) {
-        return this.localization.get(key);
-    }
-    onResourceClick(resource) {
-        const resourceEditors = resource.multiple ? this.multipleResourceEditors : this.singleResourceEditors;
-        const currentEditor = resourceEditors.filter((editor) => editor.resource.field === resource.field).pop();
-        if (currentEditor) {
-            currentEditor.focus();
-        }
-    }
-    reset() {
-        this.isActive = false;
-        this.setTimeZone = false;
-        this.setSeparateStartEndTimeZones = false;
-        this.removeTimeZoneCheckboxesFromFormGroup();
-        this.focusService.focus();
-    }
-    addTimeZoneCheckboxesToFormGroup() {
-        if (isPresent(this.formGroup)) {
-            const startField = this.fields.startTimezone;
-            this.formGroup.addControl('startTimezoneCheckbox', new FormControl(this.formGroup.contains(startField) &&
-                this.formGroup.get(startField).value));
-            const endField = this.fields.endTimezone;
-            this.formGroup.addControl('endTimezoneCheckbox', new FormControl(this.formGroup.contains(endField) &&
-                this.formGroup.get(endField).value));
-        }
-    }
-    removeTimeZoneCheckboxesFromFormGroup() {
-        if (isPresent(this.formGroup)) {
-            this.formGroup.removeControl('startTimezoneCheckbox');
-            this.formGroup.removeControl('endTimezoneCheckbox');
-        }
-    }
-    subscribeToFormGroupChanges() {
-        if (isPresent(this.formGroup)) {
-            const fields = this.fields;
-            this.formGroup.get('startTimezoneCheckbox').valueChanges.subscribe(isTrue => {
-                if (!isTrue) {
-                    this.formGroup.get(fields.startTimezone).setValue(null, { emitEvent: false });
-                    this.formGroup.get(fields.endTimezone).setValue(null, { emitEvent: false });
-                    this.formGroup.get('endTimezoneCheckbox').setValue(false, { emitEvent: false });
-                }
-            });
-            this.formGroup.get('endTimezoneCheckbox').valueChanges.subscribe(isTrue => {
-                if (!isTrue) {
-                    this.formGroup.get(fields.endTimezone).setValue(null, { emitEvent: false });
-                }
-            });
-            this.formGroup.get(fields.start).valueChanges.subscribe((newStart) => {
-                this.recurrenceStart = newStart;
-            });
-        }
-    }
-    /**
-     * Converts the event dates to "display dates" that look like the original date in its time zone.
-     * The result does not represent the same moment in time and must be converted back to local dates.
-     */
-    applyLocalTimezone() {
-        const fields = this.fields;
-        const start = this.readDateAsLocal(fields.start, this.eventTimezone);
-        const end = this.readDateAsLocal(fields.end, this.endTimezone);
-        this.formGroup.get(fields.start).reset(start);
-        this.formGroup.get(fields.end).reset(end);
-    }
-    /**
-     * Converts the "display dates" used by the editors back to local dates that represent the true moment in time.
-     */
-    applyTimezone() {
-        const fields = this.fields;
-        const start = this.readDateWithTimezone(fields.start, this.eventTimezone);
-        const end = this.readDateWithTimezone(fields.end, this.endTimezone);
-        this.formGroup.get(fields.start).reset(start);
-        this.formGroup.get(fields.end).reset(end);
-    }
-    readDateWithTimezone(field, timezone) {
-        const value = this.formGroup.get(field).value;
-        return ZonedDate.fromUTCDate(toUTCDateTime(value), timezone).toLocalDate();
-    }
-    readDateAsLocal(field, timezone) {
-        const value = this.formGroup.get(field).value;
-        return toLocalDate(ZonedDate.fromLocalDate(value, timezone).toUTCDate());
-    }
-};
-tslib_1.__decorate([
-    ViewChildren(MultipleResourceEditorComponent),
-    tslib_1.__metadata("design:type", QueryList)
-], EditDialogComponent.prototype, "multipleResourceEditors", void 0);
-tslib_1.__decorate([
-    ViewChildren(SingleResourceEditorComponent),
-    tslib_1.__metadata("design:type", QueryList)
-], EditDialogComponent.prototype, "singleResourceEditors", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Array)
-], EditDialogComponent.prototype, "resources", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", String)
-], EditDialogComponent.prototype, "timezone", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Number)
-], EditDialogComponent.prototype, "weekStart", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", Object)
-], EditDialogComponent.prototype, "fields", void 0);
-tslib_1.__decorate([
-    Input(),
-    tslib_1.__metadata("design:type", EditDialogTemplateDirective)
-], EditDialogComponent.prototype, "editTemplate", void 0);
-EditDialogComponent = tslib_1.__decorate([
-    Component({
-        selector: 'kendo-scheduler-edit-dialog',
-        template: `
-        <kendo-dialog (close)='onClose()' [minWidth]='700' *ngIf='isActive' title='{{ textFor("editorTitle") }}' class='k-scheduler-edit-dialog' [autoFocusedElement]="autoFocusedElement">
-            <ng-container *ngIf='!editTemplate'>
-                <div class='k-scheduler-edit-form'>
-                    <div class='k-edit-form-container'>
-                        <form novalidate [formGroup]='formGroup'>
-                            <div class='k-edit-label'>
-                                <label for='k-event-title'>{{ textFor('editorEventTitle') }}</label>
-                            </div>
-                            <div class='k-edit-field'>
-                                <input #title id='k-event-title' kendoTextBox placeholder='Title' [formControl]='formGroup.get(fields.title)' />
-                            </div>
-
-                            <div class='k-edit-label'>
-                                <label (click)="startDateTimePicker.focus()">{{ textFor('editorEventStart') }}</label>
-                            </div>
-                            <div class='k-edit-field'>
-                                <kendo-scheduler-datetime-picker #startDateTimePicker [formControl]='formGroup.get(fields.start)'
-                                    [isAllDay]='getFormValue(fields.isAllDay)?.value'>
-                                </kendo-scheduler-datetime-picker>
-                            </div>
-
-                            <ng-container *ngIf="isStartTimeZoneVisible">
-                                <div class='k-edit-label'>
-                                    <label (click)="startTzPicker.focus()">{{ textFor('editorEventStartTimeZone') }}</label>
-                                </div>
-
-                                <div class='k-edit-field'>
-                                    <kendo-timezone-editor #startTzPicker [formControl]='formGroup.get(fields.startTimezone)'></kendo-timezone-editor>
-                                </div>
-                            </ng-container>
-
-                            <div class='k-edit-label'>
-                                <label (click)="endDateTimePicker.focus()">{{ textFor('editorEventEnd') }}</label>
-                            </div>
-                            <div class='k-edit-field'>
-                                <kendo-scheduler-datetime-picker #endDateTimePicker [formControl]='formGroup.get(fields.end)'
-                                    [isAllDay]='getFormValue(fields.isAllDay)?.value'>
-                                </kendo-scheduler-datetime-picker>
-                            </div>
-
-                            <ng-container *ngIf="isEndTimeZoneVisible">
-                                <div class='k-edit-label'>
-                                    <label (click)="endTzPicker.focus()">{{ textFor('editorEventEndTimeZone') }}</label>
-                                </div>
-
-                                <div class='k-edit-field'>
-                                    <kendo-timezone-editor #endTzPicker [formControl]='formGroup.get(fields.endTimezone)'></kendo-timezone-editor>
-                                </div>
-                            </ng-container>
-
-                            <div class='k-edit-field' *ngIf="hasAllDay">
-                                <input type='checkbox' id='k-is-allday-chkbox' kendoCheckBox [formControl]='formGroup.get(fields.isAllDay)' />
-                                <label class='k-checkbox-label' for='k-is-allday-chkbox'>{{ textFor('editorEventAllDay') }}</label>
-                            </div>
-
-                            <div class='k-edit-field' *ngIf="hasStartTimeZone">
-                                <input type='checkbox' id='k-set-timezone' kendoCheckBox
-                                formControlName='startTimezoneCheckbox' />
-                                <label class='k-checkbox-label' for='k-set-timezone'>{{ textFor('editorEventTimeZone') }}</label>
-
-                                <ng-container *ngIf="isStartTimeZoneVisible && hasEndTimeZone">
-                                    <input type='checkbox' id='k-use-separate' kendoCheckBox formControlName='endTimezoneCheckbox' />
-                                    <label class='k-checkbox-label' for='k-use-separate'>{{ textFor('editorEventSeparateTimeZones') }}</label>
-                                </ng-container>
-                            </div>
-
-                            <ng-container *ngIf="isEditingSeries">
-                                <kendo-recurrence-editor
-                                    [formControl]='formGroup.get(fields.recurrenceRule)'
-                                    [start]='recurrenceStart'
-                                    [timezone]='eventTimezone'
-                                    [weekStart]='weekStart'
-                                ></kendo-recurrence-editor>
-                            </ng-container>
-
-                            <ng-container *ngIf='getFormValue(fields.description)'>
-                                <div class='k-edit-label'>
-                                    <label for='k-event-description'>{{ textFor('editorEventDescription') }}</label>
-                                </div>
-                                <div class='k-edit-field'>
-                                    <textarea id='k-event-description' kendoTextArea [formControl]='formGroup.get(fields.description)'></textarea>
-                                </div>
-                            </ng-container>
-
-                            <ng-container *ngFor='let resource of resources'>
-                                <ng-container *ngIf='getFormValue(resource.field)'>
-                                    <div class='k-edit-label'>
-                                        <label (click)="onResourceClick(resource)">
-                                            {{ resource.name ? resource.name : resource.field }}
-                                        </label>
-                                    </div>
-                                    <div class='k-edit-field'>
-                                        <kendo-multiple-resource-editor
-                                            *ngIf='resource.multiple'
-                                            [formControl]='formGroup.get(resource.field)'
-                                            [resource]='resource'>
-                                        </kendo-multiple-resource-editor>
-                                        <kendo-single-resource-editor
-                                            *ngIf='!resource.multiple'
-                                            [formControl]='formGroup.get(resource.field)'
-                                            [resource]='resource'>
-                                        </kendo-single-resource-editor>
-                                    </div>
-                                </ng-container>
-                            </ng-container>
-                        </form>
-                    </div>
-                </div>
-            </ng-container>
-
-            <ng-container *ngIf='editTemplate'>
-                <form novalidate [formGroup]='formGroup'>
-                    <ng-container [ngTemplateOutlet]='editTemplate.templateRef'
-                        [ngTemplateOutletContext]="{
-                            $implicit: formGroup,
-                            formGroup: formGroup,
-                            dataItem: editedEvent,
-                            editMode: editMode,
-                            isNew: isNew
-                        }">
-                    </ng-container>
-                </form>
-            </ng-container>
-
-            <kendo-dialog-actions>
-                <button kendoButton (click)="onCancel($event)">{{ textFor('cancel') }}</button>
-                <button kendoButton themeColor="primary" (click)="onSave($event)" [disabled]="!formGroup.valid">{{ textFor('save') }}</button>
-            </kendo-dialog-actions>
-        </kendo-dialog>
-    `
-    }),
-    tslib_1.__metadata("design:paramtypes", [NgZone,
-        EditService,
-        LocalizationService,
-        ChangeDetectorRef,
-        ElementRef,
-        FocusService])
-], EditDialogComponent);
-export { EditDialogComponent };

package/dist/es2015/editing/edit.service.d.ts

@@ -1,54 +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 { EventEmitter, NgZone } from '@angular/core';
-import { FormGroup } from '@angular/forms';
-import { Observable } from 'rxjs';
-import { EditMode } from '../types';
-/**
- * @hidden
- */
-export declare type CommandAction = 'edit' | 'remove' | 'cancel' | 'save' | 'add';
-/**
- * @hidden
- */
-export declare type CommandEvent = {
-    action: CommandAction;
-    dataItem?: any;
-    formGroup?: FormGroup;
-    isNew?: boolean;
-    mode?: EditMode;
-};
-/**
- * @hidden
- */
-export declare type Entity = {
-    dataItem: any;
-    formGroup: any;
-    mode?: EditMode;
-};
-/**
- * @hidden
- */
-export declare class EditService {
-    ngZone: NgZone;
-    changes: EventEmitter<CommandEvent>;
-    changed: Observable<any>;
-    editedEvent: Entity;
-    newEventGroup: any;
-    private changedSource;
-    constructor(ngZone: NgZone);
-    endEdit(): void;
-    removeEvent(dataItem: any): void;
-    addEvent(formGroup: FormGroup): void;
-    editEvent(dataItem: any, formGroup?: FormGroup, mode?: EditMode): void;
-    close(): void;
-    save(): void;
-    isEditing(): boolean;
-    readonly occurrenceEditMode: EditMode;
-    readonly hasNewEvent: boolean;
-    readonly newEvent: any;
-    readonly context: Entity;
-    private onChanged;
-}

package/dist/es2015/editing/edit.service.js

@@ -1,99 +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 { Injectable, EventEmitter, NgZone } from '@angular/core';
-import { Subject } from 'rxjs';
-import { debounceTime } from 'rxjs/operators';
-import { isPresent } from '../common/util';
-// const toSimilarDate = (date: ZonedDate): Date => new Date(
-//     date.getFullYear(), date.getMonth(), date.getDay(),
-//     date.getHours(), date.getMinutes(), date.getSeconds(),
-//     date.getMilliseconds()
-//   );
-// const toUTCDateTime = (localDate: Date): Date => new Date(Date.UTC(
-//       localDate.getFullYear(),
-//       localDate.getMonth(),
-//       localDate.getDate(),
-//       localDate.getHours(),
-//       localDate.getMinutes(),
-//       localDate.getSeconds(),
-//       localDate.getMilliseconds()
-//     ));
-/**
- * @hidden
- */
-let EditService = class EditService {
-    constructor(ngZone) {
-        this.ngZone = ngZone;
-        this.changes = new EventEmitter();
-        this.changedSource = new Subject();
-        this.changed = this.changedSource.asObservable().pipe(debounceTime(0));
-    }
-    endEdit() {
-        const formGroup = this.hasNewEvent ? this.newEventGroup.group : this.editedEvent.formGroup;
-        this.changes.emit({ action: 'cancel', formGroup });
-    }
-    removeEvent(dataItem) {
-        this.changes.emit({ action: 'remove', dataItem });
-    }
-    addEvent(formGroup) {
-        this.newEventGroup = { formGroup };
-        this.onChanged();
-    }
-    editEvent(dataItem, formGroup = undefined, mode) {
-        this.editedEvent = { dataItem, formGroup, mode };
-        this.onChanged();
-    }
-    close() {
-        this.newEventGroup = this.editedEvent = null;
-        this.onChanged();
-    }
-    save() {
-        const { dataItem, formGroup } = this.context;
-        this.changes.emit({
-            action: 'save',
-            dataItem,
-            formGroup,
-            isNew: this.hasNewEvent,
-            mode: this.occurrenceEditMode
-        });
-    }
-    isEditing() {
-        return isPresent(this.context);
-    }
-    get occurrenceEditMode() {
-        if (this.hasNewEvent) {
-            return 2 /* Series */;
-        }
-        else {
-            return this.editedEvent.mode || 0 /* Event */;
-        }
-    }
-    get hasNewEvent() {
-        return isPresent(this.newEventGroup);
-    }
-    get newEvent() {
-        if (this.hasNewEvent) {
-            return this.newEventGroup.group.value;
-        }
-        return {};
-    }
-    get context() {
-        if (this.hasNewEvent) {
-            return this.newEventGroup;
-        }
-        return this.editedEvent;
-    }
-    onChanged() {
-        this.ngZone.runOutsideAngular(() => {
-            this.changedSource.next();
-        });
-    }
-};
-EditService = tslib_1.__decorate([
-    Injectable(),
-    tslib_1.__metadata("design:paramtypes", [NgZone])
-], EditService);
-export { EditService };

package/dist/es2015/editing/local-data-changes.service.d.ts

@@ -1,12 +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 { EventEmitter } from '@angular/core';
-/**
- * @hidden
- */
-export declare class LocalDataChangesService {
-    changes: EventEmitter<any>;
-    data: any[];
-}

package/dist/es2015/editing/local-data-changes.service.js

@@ -1,21 +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 { Injectable, EventEmitter } from '@angular/core';
-/**
- * @hidden
- */
-let LocalDataChangesService = class LocalDataChangesService {
-    /**
-     * @hidden
-     */
-    constructor() {
-        this.changes = new EventEmitter();
-    }
-};
-LocalDataChangesService = tslib_1.__decorate([
-    Injectable()
-], LocalDataChangesService);
-export { LocalDataChangesService };

package/dist/es2015/editing/recurrence/end-rule-radio-button.directive.d.ts

@@ -1,28 +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 { AfterContentChecked, OnInit, OnDestroy, Renderer2, ElementRef, ChangeDetectorRef } from "@angular/core";
-import { RecurrenceService } from './recurrence.service';
-/**
- * @hidden
- */
-export declare class EndRuleRadioButtonDirective implements OnInit, AfterContentChecked, OnDestroy {
-    private el;
-    private renderer;
-    private recurrence;
-    private changeDetector;
-    type: string;
-    radioClass: boolean;
-    radioSizeClass: boolean;
-    endRuleId: string;
-    private destroyChange;
-    private endRule;
-    constructor(el: ElementRef, renderer: Renderer2, recurrence: RecurrenceService, changeDetector: ChangeDetectorRef);
-    ngOnInit(): void;
-    ngAfterContentChecked(): void;
-    ngOnDestroy(): void;
-    onChange(): void;
-    private setCheckedState;
-    readonly elem: any;
-}

package/dist/es2015/editing/recurrence/end-rule-radio-button.directive.js

@@ -1,74 +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, HostBinding, Renderer2, ElementRef, ChangeDetectorRef } from "@angular/core";
-import { RecurrenceService } from './recurrence.service';
-/**
- * @hidden
- */
-let EndRuleRadioButtonDirective = class EndRuleRadioButtonDirective {
-    constructor(el, renderer, recurrence, changeDetector) {
-        this.el = el;
-        this.renderer = renderer;
-        this.recurrence = recurrence;
-        this.changeDetector = changeDetector;
-        this.type = 'radio';
-        this.radioClass = true;
-        this.radioSizeClass = true;
-        this.destroyChange = this.renderer.listen(this.elem, 'change', this.onChange.bind(this));
-    }
-    ngOnInit() {
-        this.endRule = this.endRuleId.split('-')[2];
-        this.renderer.setAttribute(this.elem, 'id', this.endRuleId);
-        this.renderer.setAttribute(this.elem, 'name', `end-${this.endRuleId.split('-').pop()}`);
-    }
-    ngAfterContentChecked() {
-        this.setCheckedState();
-    }
-    ngOnDestroy() {
-        if (this.destroyChange) {
-            this.destroyChange();
-        }
-    }
-    onChange() {
-        if (this.elem.checked) {
-            this.recurrence.endRule = this.endRule;
-            this.changeDetector.markForCheck();
-        }
-    }
-    setCheckedState() {
-        const isChecked = this.endRule === this.recurrence.endRule;
-        this.renderer.setProperty(this.elem, 'checked', isChecked);
-    }
-    get elem() {
-        return this.el.nativeElement;
-    }
-};
-tslib_1.__decorate([
-    HostBinding('attr.type'),
-    tslib_1.__metadata("design:type", String)
-], EndRuleRadioButtonDirective.prototype, "type", void 0);
-tslib_1.__decorate([
-    HostBinding('class.k-radio'),
-    tslib_1.__metadata("design:type", Boolean)
-], EndRuleRadioButtonDirective.prototype, "radioClass", void 0);
-tslib_1.__decorate([
-    HostBinding('class.k-radio-md'),
-    tslib_1.__metadata("design:type", Boolean)
-], EndRuleRadioButtonDirective.prototype, "radioSizeClass", void 0);
-tslib_1.__decorate([
-    Input("kendoRecurrenceEndRuleRadioButton"),
-    tslib_1.__metadata("design:type", String)
-], EndRuleRadioButtonDirective.prototype, "endRuleId", void 0);
-EndRuleRadioButtonDirective = tslib_1.__decorate([
-    Directive({
-        selector: '[kendoRecurrenceEndRuleRadioButton]'
-    }),
-    tslib_1.__metadata("design:paramtypes", [ElementRef,
-        Renderer2,
-        RecurrenceService,
-        ChangeDetectorRef])
-], EndRuleRadioButtonDirective);
-export { EndRuleRadioButtonDirective };