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

package/esm2022/navigation/focus.service.mjs

@@ -1,202 +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 { ElementRef, Injectable, Renderer2, Optional, NgZone } from '@angular/core';
-import { Subscription } from 'rxjs';
-import { take } from 'rxjs/operators';
-import { DomEventsService } from '../views/common/dom-events.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../views/common/dom-events.service";
-/**
- * @hidden
- */
-export class FocusService {
-    renderer;
-    wrapper;
-    domEvents;
-    zone;
-    get activeElement() {
-        if (this.activeItem) {
-            return this.activeItem.element;
-        }
-    }
-    get focusableItems() {
-        return this.items;
-    }
-    activeItem;
-    focusedItem;
-    items = new Set();
-    elementMap = new WeakMap();
-    subs = new Subscription();
-    hasContentRendered = false;
-    constructor(renderer, wrapper, domEvents, zone) {
-        this.renderer = renderer;
-        this.wrapper = wrapper;
-        this.domEvents = domEvents;
-        this.zone = zone;
-        this.subs.add(this.domEvents.focus.subscribe(e => this.onFocusIn(e)));
-        this.subs.add(this.domEvents.focusOut.subscribe(() => this.onFocusOut()));
-    }
-    ngOnDestroy() {
-        this.subs.unsubscribe();
-    }
-    register(item) {
-        if (!this.activeItem) {
-            this.activeItem = item;
-            item.toggle(true);
-        }
-        const items = Array.from(this.focusableItems);
-        if (item.containerType !== 'content') {
-            this.items.add(item);
-        }
-        else {
-            const newContentIndex = items.map(item => item.containerType).lastIndexOf('content') + 1;
-            const hasFooter = items.find(item => item.containerType === 'footer');
-            if (newContentIndex > 0) {
-                // ensure that new events are positioned after the rest of the events for correct navigation sequence
-                items.splice(newContentIndex, 0, item);
-                this.items = new Set(items);
-            }
-            else if (hasFooter) {
-                // ensure that the first event is before the footer
-                items.splice(items.length - 1, 0, item);
-                this.items = new Set(items);
-            }
-            else {
-                this.items.add(item);
-            }
-            // activate the first content element if there is one; otherwise, keep the toolbar or footer active
-            if (!this.hasContentRendered) {
-                this.activeItem.toggle(false);
-                this.activeItem = item;
-                item.toggle(true);
-                this.hasContentRendered = true;
-            }
-        }
-        this.elementMap.set(item.element.nativeElement, item);
-        this.toggleWrapper();
-    }
-    unregister(item) {
-        if (item === this.activeItem) {
-            this.activateNext();
-        }
-        this.items.delete(item);
-        this.elementMap.delete(item.element.nativeElement);
-        this.toggleWrapper();
-    }
-    focus() {
-        if (this.activeItem) {
-            this.activeItem.focus();
-        }
-        else {
-            this.focusContent();
-        }
-    }
-    focusContent() {
-        const items = Array.from(this.focusableItems);
-        const activeItemContainer = this.activeItem?.containerType;
-        const focusableContent = activeItemContainer === 'content' ? this.activeItem : items.find(item => item.containerType === 'content');
-        const focusableTool = activeItemContainer === 'toolbar' ? this.activeItem : items.find(item => item.containerType === 'toolbar');
-        const itemToFocus = focusableContent || focusableTool;
-        itemToFocus.focus();
-        this.activeItem = itemToFocus;
-    }
-    focusToolbar() {
-        const items = Array.from(this.focusableItems);
-        const firstFocusableTool = items.find(item => item.containerType === 'toolbar');
-        // eslint-disable-next-line no-unused-expressions
-        firstFocusableTool && firstFocusableTool.focus();
-        this.activeItem = firstFocusableTool;
-    }
-    focusNext(options) {
-        const currentItem = this.activeItem;
-        this.activateNext(options);
-        if (this.activeItem) {
-            this.activeItem.focus();
-        }
-        return this.activeItem !== currentItem;
-    }
-    focusByIndex(index) {
-        const item = Array.from(this.items.values())[index];
-        if (!item) {
-            return;
-        }
-        this.activate(item);
-        this.focus();
-        this.zone.onStable.pipe(take(1)).subscribe(() => {
-            const itemToFocus = Array.from(this.items.values())[index];
-            if (!itemToFocus) {
-                return;
-            }
-        });
-    }
-    activate(next) {
-        this.items.forEach(item => {
-            item.toggle(item === next);
-        });
-        this.activeItem = next;
-    }
-    activateNext(position) {
-        const next = this.findNext(position);
-        this.activeItem = next;
-        this.activeItem?.focus();
-    }
-    findNext(position) {
-        const { offset, nowrap } = { nowrap: false, offset: 1, ...position };
-        const items = Array.from(this.items.values())
-            .filter(item => item.canFocus())
-            .sort((a, b) => a.focusIndex - b.focusIndex);
-        if (items.length === 0) {
-            return null;
-        }
-        if (!this.activeItem) {
-            return nowrap ? null : items[0];
-        }
-        const index = items.indexOf(this.activeItem);
-        let nextIndex = index + offset;
-        if (nowrap) {
-            nextIndex = Math.max(0, Math.min(items.length - 1, nextIndex));
-        }
-        else {
-            nextIndex = nextIndex % items.length;
-            if (nextIndex < 0) {
-                nextIndex = items.length - 1;
-            }
-        }
-        return items[nextIndex];
-    }
-    toggleWrapper() {
-        if (this.wrapper) {
-            this.renderer.setAttribute(this.wrapper.nativeElement, 'tabindex', this.activeItem ? '-1' : '0');
-        }
-    }
-    onFocusIn(e) {
-        const item = this.elementMap.get(e.target);
-        if (!item || item === this.focusedItem) {
-            return;
-        }
-        if (this.focusedItem) {
-            this.focusedItem.toggleFocus(false);
-        }
-        this.activate(item);
-        item.toggleFocus(true);
-        this.focusedItem = item;
-    }
-    onFocusOut() {
-        if (!this.focusedItem) {
-            return;
-        }
-        this.focusedItem.toggleFocus(false);
-        this.focusedItem = null;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusService, deps: [{ token: i0.Renderer2, optional: true }, { token: i0.ElementRef, optional: true }, { token: i1.DomEventsService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.Renderer2, decorators: [{
-                    type: Optional
-                }] }, { type: i0.ElementRef, decorators: [{
-                    type: Optional
-                }] }, { type: i1.DomEventsService }, { type: i0.NgZone }] });

package/esm2022/navigation/focusable-element.interface.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/navigation/focusable.directive.mjs

@@ -1,98 +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, ElementRef, Input, Renderer2 } from '@angular/core';
-import { isDocumentAvailable, isVisible } from '@progress/kendo-angular-common';
-import { FocusService } from './focus.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./focus.service";
-/**
- * @hidden
- */
-export class FocusableDirective {
-    element;
-    renderer;
-    focusService;
-    /**
-     * The order of the element with respect to the other focusable elements.
-     * If multiple elements share the same value, their relative to each other order follows their position in the component tree.
-     */
-    focusIndex = 0;
-    containerType = 'content';
-    get visible() {
-        return this.element.nativeElement.style.display !== 'none';
-    }
-    get enabled() {
-        return !this.element.nativeElement.disabled;
-    }
-    active;
-    constructor(element, renderer, focusService) {
-        this.element = element;
-        this.renderer = renderer;
-        this.focusService = focusService;
-        this.toggle(false);
-    }
-    ngAfterViewChecked() {
-        const element = this.element.nativeElement;
-        const isViewSelector = element.closest('.k-scheduler-views-wrapper');
-        if (!isViewSelector || !isDocumentAvailable()) {
-            return;
-        }
-        // eslint-disable-next-line no-unused-expressions
-        isVisible(element) ? this.focusService.register(this) : this.focusService.unregister(this);
-    }
-    ngOnInit() {
-        this.focusService.register(this);
-    }
-    ngOnDestroy() {
-        this.focusService.unregister(this);
-    }
-    toggle(active) {
-        if (active !== this.active) {
-            const index = active ? '0' : '-1';
-            this.renderer.setAttribute(this.element.nativeElement, 'tabIndex', index);
-            this.active = active;
-        }
-    }
-    canFocus() {
-        return this.visible && this.enabled;
-    }
-    focus() {
-        this.element.nativeElement.focus({ preventScroll: true });
-    }
-    toggleFocus(value) {
-        const element = this.element.nativeElement;
-        const focusedClass = element.matches('.k-button-group .k-button') ? 'k-focus' : 'k-selected';
-        const renderedEvents = this.element.nativeElement.ownerDocument.querySelectorAll('.k-event');
-        const method = value ? 'addClass' : 'removeClass';
-        this.renderer[method](element, focusedClass);
-        if (renderedEvents.length > 0) {
-            const ariaLabel = element.getAttribute('aria-label');
-            renderedEvents.forEach((event) => {
-                if (event.getAttribute('aria-label') === ariaLabel) {
-                    this.renderer[method](event, 'k-selected');
-                }
-            });
-        }
-        const selectable = element.matches('.k-scheduler-agendaview .k-scheduler-content .k-selected');
-        if (selectable) {
-            element.closest('.k-scheduler-agendaview').querySelector('[aria-selected="true"]')?.removeAttribute('aria-selected');
-            this.renderer.setAttribute(element, 'aria-selected', value.toString());
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.FocusService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: FocusableDirective, isStandalone: true, selector: "[kendoSchedulerFocusIndex]", inputs: { focusIndex: ["kendoSchedulerFocusIndex", "focusIndex"], containerType: "containerType" }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FocusableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoSchedulerFocusIndex]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.FocusService }], propDecorators: { focusIndex: [{
-                type: Input,
-                args: ['kendoSchedulerFocusIndex']
-            }], containerType: [{
-                type: Input
-            }] } });

package/esm2022/navigation/shortcuts.directive.mjs

@@ -1,239 +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 { ChangeDetectorRef, Directive, NgZone } from '@angular/core';
-import { Keys, normalizeKeys } from '@progress/kendo-angular-common';
-import { ZonedDate } from '@progress/kendo-date-math';
-import { Subscription } from 'rxjs';
-import { FocusService } from './focus.service';
-import { Modifiers, noModifiers, withModifiers } from '../common/modifiers';
-import { groupResources } from '../common/util';
-import { SchedulerComponent } from '../scheduler.component';
-import { DomEventsService } from '../views/common/dom-events.service';
-import { take } from 'rxjs/operators';
-import { ViewStateService } from '../views/view-state.service';
-import { hasClasses } from '../common/dom-queries';
-import { DialogsService } from '../editing/dialogs.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../scheduler.component";
-import * as i2 from "../views/common/dom-events.service";
-import * as i3 from "./focus.service";
-import * as i4 from "../views/view-state.service";
-import * as i5 from "../editing/dialogs.service";
-const isContentWrapper = element => hasClasses(element, 'k-scheduler-content');
-const CALENDAR_TAG = 'KENDO-CALENDAR-HORIZONTAL';
-/**
- * @hidden
- */
-export class ShortcutsDirective {
-    scheduler;
-    domEvents;
-    focusService;
-    zone;
-    changeDetector;
-    viewState;
-    dialogsService;
-    shortcuts = [{
-            match: e => normalizeKeys(e) === Keys.KeyC && noModifiers(e),
-            action: e => {
-                const scheduler = this.scheduler;
-                const hours = new Date().getHours();
-                const selected = scheduler.selectedDate;
-                const start = new Date(selected.getFullYear(), selected.getMonth(), selected.getDate(), hours + 1);
-                const end = new Date(selected.getFullYear(), selected.getMonth(), selected.getDate(), hours + 2);
-                let firstResource;
-                if (scheduler.group) {
-                    const resources = scheduler.resources || [];
-                    const group = scheduler.group || {};
-                    const grouped = groupResources(group, resources);
-                    if (grouped.length > 0) {
-                        firstResource = grouped[0].data[0];
-                    }
-                }
-                scheduler.create.emit({
-                    start: ZonedDate.fromLocalDate(start, scheduler.timezone).toLocalDate(),
-                    end: ZonedDate.fromLocalDate(end, scheduler.timezone).toLocalDate(),
-                    isAllDay: false,
-                    resources: [firstResource],
-                    originalEvent: e,
-                    sender: scheduler
-                });
-            }
-        }, {
-            match: e => {
-                const code = normalizeKeys(e);
-                return (code.startsWith('Digit') || code.startsWith('Numpad')) && withModifiers(e, Modifiers.AltKey);
-            },
-            action: e => {
-                const scheduler = this.scheduler;
-                const code = normalizeKeys(e);
-                const viewIndex = this.digitToNumber(code, code.startsWith('Digit') ? 'Digit' : 'Numpad') - 1;
-                const views = scheduler.views.toArray();
-                const view = views[viewIndex];
-                if (view) {
-                    this.zone.run(() => {
-                        const prevented = scheduler.onNavigationAction({ type: 'view-change', view });
-                        if (!prevented) {
-                            this.changeDetector.markForCheck();
-                            this.focusWait();
-                        }
-                    });
-                }
-            }
-        }, {
-            match: e => e.code === Keys.F10 && noModifiers(e),
-            action: (e) => {
-                this.zone.run(() => {
-                    e.preventDefault();
-                    this.scheduler.onNavigationAction({ type: 'focus-toolbar' });
-                    this.focusWait();
-                });
-            }
-        }, {
-            match: e => normalizeKeys(e) === Keys.KeyT && noModifiers(e),
-            action: () => {
-                this.zone.run(() => {
-                    this.scheduler.onNavigationAction({ type: 'today' });
-                    this.focusWait();
-                });
-            }
-        }, {
-            match: e => normalizeKeys(e) === Keys.KeyB && noModifiers(e),
-            action: () => {
-                this.zone.run(() => {
-                    this.scheduler.onNavigationAction({ type: 'toggle-business-hours' });
-                    this.focusWait();
-                });
-            }
-        }, {
-            match: (e) => {
-                const code = normalizeKeys(e);
-                return (code === Keys.ArrowLeft || code === Keys.ArrowRight) && withModifiers(e, Modifiers.ShiftKey);
-            },
-            action: (e) => {
-                const code = normalizeKeys(e);
-                const type = code === Keys.ArrowLeft ? 'prev' : 'next';
-                this.zone.run(() => {
-                    this.scheduler.onNavigationAction({ type });
-                    this.focusWait();
-                });
-            }
-        }, {
-            match: e => {
-                const code = normalizeKeys(e);
-                return (code === Keys.ArrowUp || code === Keys.ArrowLeft) && noModifiers(e) && !isContentWrapper(e.target);
-            },
-            action: e => {
-                //use the MultiViewCalendar navigation for Year View
-                if (e.target.tagName === CALENDAR_TAG) {
-                    return;
-                }
-                // do nothing if the shortcut is executed on an element inside the kendoSchedulerToolbarTemplate
-                if (this.isInToolbarTemplate(e.target)) {
-                    return;
-                }
-                const prevented = this.scheduler.onNavigationAction({ type: 'focus-prev' });
-                if (!prevented) {
-                    const item = this.focusService.activeItem;
-                    const isFirstEvent = item.containerType === 'content' && item.element.nativeElement.matches(':first-of-type');
-                    const code = normalizeKeys(e);
-                    const isUpArrow = code === Keys.ArrowUp;
-                    // eslint-disable-next-line no-unused-expressions
-                    isFirstEvent && isUpArrow ? this.focusService.focusToolbar() : this.focusService.focusNext({ offset: -1 });
-                    e.preventDefault();
-                }
-            }
-        }, {
-            match: e => {
-                const code = normalizeKeys(e);
-                return (code === Keys.ArrowDown || code === Keys.ArrowRight) && noModifiers(e) && !isContentWrapper(e.target);
-            },
-            action: e => {
-                //use the MultiViewCalendar navigation for Year View
-                if (e.target.tagName === CALENDAR_TAG) {
-                    return;
-                }
-                // do nothing if the shortcut is executed on an element inside the kendoSchedulerToolbarTemplate
-                if (this.isInToolbarTemplate(e.target)) {
-                    return;
-                }
-                const prevented = this.scheduler.onNavigationAction({ type: 'focus-next' });
-                if (!prevented) {
-                    const isInToolbar = this.focusService.activeItem.containerType === 'toolbar';
-                    const offset = 1;
-                    const code = normalizeKeys(e);
-                    if (code === Keys.ArrowDown && isInToolbar) {
-                        const focusableElementsArray = Array.from(this.focusService.focusableItems);
-                        const firstFocusableContentElementIndex = focusableElementsArray.findIndex(item => item.containerType === 'content');
-                        if (firstFocusableContentElementIndex > -1) {
-                            this.focusService.focusByIndex(firstFocusableContentElementIndex);
-                            e.preventDefault();
-                            return;
-                        }
-                    }
-                    this.focusService.focusNext({ offset });
-                    e.preventDefault();
-                }
-            }
-        }];
-    taskShortcuts = [{
-            match: e => (e.code === Keys.Delete || e.code === Keys.Backspace) && noModifiers(e),
-            action: (e, event) => {
-                this.viewState.emitEvent('remove', { event: event, dataItem: event.dataItem });
-                e.preventDefault();
-            }
-        }, {
-            match: e => (e.code === Keys.Enter || e.code === Keys.NumpadEnter) && noModifiers(e),
-            action: (e, event) => {
-                this.viewState.emitEvent('eventDblClick', { type: 'dblclick', event: event, originalEvent: e });
-                e.preventDefault();
-            }
-        }];
-    subs = new Subscription();
-    constructor(scheduler, domEvents, focusService, zone, changeDetector, viewState, dialogsService) {
-        this.scheduler = scheduler;
-        this.domEvents = domEvents;
-        this.focusService = focusService;
-        this.zone = zone;
-        this.changeDetector = changeDetector;
-        this.viewState = viewState;
-        this.dialogsService = dialogsService;
-        this.subs.add(this.domEvents.keydown.subscribe(e => this.onKeydown(e)));
-        this.subs.add(this.scheduler.eventKeydown.subscribe(e => this.onEventKeydown(e)));
-    }
-    onKeydown(e) {
-        const match = this.shortcuts.find(shortcut => shortcut.match(e));
-        if (match && !this.dialogsService.isOpen) {
-            match.action(e);
-        }
-    }
-    onEventKeydown(e) {
-        const match = this.taskShortcuts.find(shortcut => shortcut.match(e.originalEvent));
-        if (match && !this.dialogsService.isOpen) {
-            match.action(e.originalEvent, e.event);
-        }
-    }
-    focusWait() {
-        this.viewState.layoutEnd.pipe(take(1)).subscribe(() => this.focusService.focus());
-    }
-    isInToolbarTemplate(element) {
-        const isInToolbar = element.closest('.k-scheduler-toolbar');
-        const isInBuiltInElement = element.closest('.k-toolbar-group') ||
-            element.closest('.k-scheduler-views') ||
-            element.closest('.k-views-dropdown');
-        return isInToolbar && !isInBuiltInElement;
-    }
-    digitToNumber(code, keyType) {
-        return parseInt(code.replace(keyType, ''), 10);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ShortcutsDirective, deps: [{ token: i1.SchedulerComponent }, { token: i2.DomEventsService }, { token: i3.FocusService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i4.ViewStateService }, { token: i5.DialogsService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ShortcutsDirective, isStandalone: true, selector: "kendo-scheduler", ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ShortcutsDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'kendo-scheduler',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.SchedulerComponent }, { type: i2.DomEventsService }, { type: i3.FocusService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i4.ViewStateService }, { type: i5.DialogsService }] });

package/esm2022/navigation.mjs

@@ -1,6 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export { FocusService } from './navigation/focus.service';
-export { FocusableDirective } from './navigation/focusable.directive';

package/esm2022/package-metadata.mjs

@@ -1,16 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export const packageMetadata = {
-    name: '@progress/kendo-angular-scheduler',
-    productName: 'Kendo UI for Angular',
-    productCode: 'KENDOUIANGULAR',
-    productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1768386630,
-    version: '21.4.1-develop.1',
-    licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/'
-};

package/esm2022/pdf/pdf-command.directive.mjs

@@ -1,96 +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 { Component, HostListener, ElementRef, Renderer2, NgZone } from '@angular/core';
-import { Button } from '@progress/kendo-angular-buttons';
-import { LocalizationService } from '@progress/kendo-angular-l10n';
-import { PDFService } from './pdf.service';
-import { filePdfIcon } from '@progress/kendo-svg-icons';
-import { IconWrapperComponent } from '@progress/kendo-angular-icons';
-import { NgClass } from '@angular/common';
-import * as i0 from "@angular/core";
-import * as i1 from "./pdf.service";
-import * as i2 from "@progress/kendo-angular-l10n";
-/**
- * Represents the `export-to-PDF` command for the Scheduler.
- *
- * You can apply this directive to any `button` element inside a [`ToolbarTemplate`](slug:toolbar_scheduler).
- * When a user clicks a button associated with this directive, the [`pdfExport`](slug:api_scheduler_schedulercomponent#toc-pdfexport) event fires
- * ([see example](slug:pdfexport_scheduler)).
- *
- * @example
- * ```html
- * <kendo-scheduler>
- *   <ng-template kendoSchedulerToolbarTemplate>
- *     <button kendoSchedulerPDFCommand>Export to PDF</button>
- *   </ng-template>
- *   <kendo-scheduler-pdf fileName="Scheduler.pdf">
- *   </kendo-scheduler-pdf>
- * </kendo-scheduler>
- * ```
- */
-export class PDFCommandDirective extends Button {
-    pdfService;
-    /**
-     * @hidden
-     */
-    onClick(e) {
-        e.preventDefault();
-        this.pdfService.exportClick.emit();
-    }
-    constructor(pdfService, element, renderer, localization, ngZone) {
-        super(element, renderer, null, localization, ngZone);
-        this.pdfService = pdfService;
-    }
-    ngOnInit() {
-        this.icon = 'pdf';
-        this.svgIcon = filePdfIcon;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PDFCommandDirective, deps: [{ token: i1.PDFService }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i2.LocalizationService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PDFCommandDirective, isStandalone: true, selector: "[kendoSchedulerPDFCommand]", host: { listeners: { "click": "onClick($event)" } }, usesInheritance: true, ngImport: i0, template: `
-        @if (icon || svgIcon) {
-          <kendo-icon-wrapper
-            innerCssClass="k-button-icon"
-            [name]="icon"
-          [svgIcon]="svgIcon"></kendo-icon-wrapper>
-        }
-        @if (imageUrl) {
-          <span class="k-button-icon k-icon">
-            <img [src]="imageUrl" class="k-image" role="presentation" />
-          </span>
-        }
-        @if (iconClass) {
-          <span class="k-button-icon" [ngClass]="iconClass"></span>
-        }
-        <span class="k-button-text"><ng-content></ng-content></span>
-        `, isInline: true, dependencies: [{ kind: "component", type: IconWrapperComponent, selector: "kendo-icon-wrapper", inputs: ["name", "svgIcon", "innerCssClass", "customFontClass", "size"], exportAs: ["kendoIconWrapper"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PDFCommandDirective, decorators: [{
-            type: Component,
-            args: [{
-                    selector: '[kendoSchedulerPDFCommand]',
-                    template: `
-        @if (icon || svgIcon) {
-          <kendo-icon-wrapper
-            innerCssClass="k-button-icon"
-            [name]="icon"
-          [svgIcon]="svgIcon"></kendo-icon-wrapper>
-        }
-        @if (imageUrl) {
-          <span class="k-button-icon k-icon">
-            <img [src]="imageUrl" class="k-image" role="presentation" />
-          </span>
-        }
-        @if (iconClass) {
-          <span class="k-button-icon" [ngClass]="iconClass"></span>
-        }
-        <span class="k-button-text"><ng-content></ng-content></span>
-        `,
-                    standalone: true,
-                    imports: [IconWrapperComponent, NgClass]
-                }]
-        }], ctorParameters: () => [{ type: i1.PDFService }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i2.LocalizationService }, { type: i0.NgZone }], propDecorators: { onClick: [{
-                type: HostListener,
-                args: ['click', ['$event']]
-            }] } });