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

package/esm2015/navigation/focus.service.js

@@ -0,0 +1,128 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, Optional } from '@angular/core';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../views/common/dom-events.service";
+/**
+ * @hidden
+ */
+export class FocusService {
+    constructor(renderer, wrapper, domEvents) {
+        this.renderer = renderer;
+        this.wrapper = wrapper;
+        this.domEvents = domEvents;
+        this.items = new Set();
+        this.elementMap = new WeakMap();
+        this.subs = new Subscription();
+        this.subs.add(this.domEvents.focus.subscribe(e => this.onFocusIn(e)));
+        this.subs.add(this.domEvents.focusOut.subscribe(() => this.onFocusOut()));
+    }
+    get activeElement() {
+        if (this.activeItem) {
+            return this.activeItem.element;
+        }
+    }
+    ngOnDestroy() {
+        this.subs.unsubscribe();
+    }
+    register(item) {
+        if (!this.activeItem) {
+            this.activeItem = item;
+            item.toggle(true);
+        }
+        this.items.add(item);
+        this.elementMap.set(item.element.nativeElement, item);
+        this.toggleWrapper();
+    }
+    unregister(item) {
+        this.items.delete(item);
+        this.elementMap.delete(item.element.nativeElement);
+        if (item === this.activeItem) {
+            this.activateNext();
+        }
+        this.toggleWrapper();
+    }
+    focus() {
+        if (this.activeItem) {
+            this.activeItem.focus();
+        }
+        else {
+            this.wrapper.nativeElement.focus();
+        }
+    }
+    focusNext(options) {
+        const currentItem = this.activeItem;
+        this.activateNext(options);
+        if (this.activeItem) {
+            this.activeItem.focus();
+        }
+        return this.activeItem !== currentItem;
+    }
+    activate(next) {
+        this.items.forEach(item => item.toggle(item === next));
+        this.activeItem = next;
+    }
+    activateNext(position) {
+        this.activeItem = this.findNext(position);
+    }
+    findNext(position) {
+        const { offset, nowrap } = Object.assign({ 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;
+    }
+}
+FocusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FocusService, deps: [{ token: i0.Renderer2, optional: true }, { token: i0.ElementRef, optional: true }, { token: i1.DomEventsService }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FocusService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FocusService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Renderer2, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Optional
+                }] }, { type: i1.DomEventsService }]; } });

package/esm2015/navigation/focusable-element.interface.js

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

package/esm2015/navigation/focusable.directive.js

@@ -0,0 +1,68 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 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 * as i0 from "@angular/core";
+import * as i1 from "./focus.service";
+/**
+ * @hidden
+ */
+export class FocusableDirective {
+    constructor(element, renderer, focusService) {
+        this.element = element;
+        this.renderer = renderer;
+        this.focusService = 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.
+         */
+        this.focusIndex = 0;
+        this.toggle(false);
+        this.focusService.register(this);
+    }
+    get visible() {
+        return this.element.nativeElement.style.display !== 'none';
+    }
+    get enabled() {
+        return !this.element.nativeElement.disabled;
+    }
+    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();
+    }
+    toggleFocus(value) {
+        const focusedClass = 'k-state-selected';
+        const element = this.element.nativeElement;
+        if (value) {
+            this.renderer.addClass(element, focusedClass);
+        }
+        else {
+            this.renderer.removeClass(element, focusedClass);
+        }
+        this.renderer.setAttribute(element, 'aria-selected', value.toString());
+    }
+}
+FocusableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FocusableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.FocusService }], target: i0.ɵɵFactoryTarget.Directive });
+FocusableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: FocusableDirective, selector: "[kendoSchedulerFocusIndex]", inputs: { focusIndex: ["kendoSchedulerFocusIndex", "focusIndex"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FocusableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoSchedulerFocusIndex]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.FocusService }]; }, propDecorators: { focusIndex: [{
+                type: Input,
+                args: ['kendoSchedulerFocusIndex']
+            }] } });

package/esm2015/navigation/shortcuts.directive.js

@@ -0,0 +1,151 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive } from '@angular/core';
+import { Keys } from '@progress/kendo-angular-common';
+import { ZonedDate } from '@progress/kendo-date-math';
+import { Subscription } from 'rxjs';
+import { Modifiers, noModifiers, withModifiers } from '../common/modifiers';
+import { groupResources } from '../common/util';
+import { take } from 'rxjs/operators';
+import { hasClasses } from '../common/dom-queries';
+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');
+/**
+ * @hidden
+ */
+export class ShortcutsDirective {
+    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.shortcuts = [{
+                match: e => e.keyCode === 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 => e.keyCode >= Keys.Digit1 && e.keyCode <= Keys.Digit9 && withModifiers(e, Modifiers.AltKey),
+                action: e => {
+                    const scheduler = this.scheduler;
+                    const viewIndex = e.keyCode - Keys.Digit0 - 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.keyCode === Keys.KeyT && noModifiers(e),
+                action: () => {
+                    this.zone.run(() => {
+                        this.scheduler.onNavigationAction({ type: 'today' });
+                        this.focusWait();
+                    });
+                }
+            }, {
+                match: (e) => (e.keyCode === Keys.ArrowLeft || e.keyCode === Keys.ArrowRight) && withModifiers(e, Modifiers.ShiftKey),
+                action: (e) => {
+                    const type = e.keyCode === Keys.ArrowLeft ? 'prev' : 'next';
+                    this.zone.run(() => {
+                        this.scheduler.onNavigationAction({ type });
+                        this.focusWait();
+                    });
+                }
+            }, {
+                match: e => (e.keyCode === Keys.ArrowUp || e.keyCode === Keys.ArrowLeft) && noModifiers(e) && !isContentWrapper(e.target),
+                action: e => {
+                    const prevented = this.scheduler.onNavigationAction({ type: 'focus-prev' });
+                    if (!prevented) {
+                        this.focusService.focusNext({ offset: -1 });
+                        e.preventDefault();
+                    }
+                }
+            }, {
+                match: e => (e.keyCode === Keys.ArrowDown || e.keyCode === Keys.ArrowRight) && noModifiers(e) && !isContentWrapper(e.target),
+                action: e => {
+                    const prevented = this.scheduler.onNavigationAction({ type: 'focus-next' });
+                    if (!prevented) {
+                        this.focusService.focusNext({ offset: 1 });
+                        e.preventDefault();
+                    }
+                }
+            }];
+        this.taskShortcuts = [{
+                match: e => (e.keyCode === Keys.Delete || e.keyCode === Keys.Backspace) && noModifiers(e),
+                action: (e, event) => {
+                    this.viewState.emitEvent('remove', { event: event, dataItem: event.dataItem });
+                    e.preventDefault();
+                }
+            }, {
+                match: e => e.keyCode === Keys.Enter && noModifiers(e),
+                action: (e, event) => {
+                    this.viewState.emitEvent('eventDblClick', { type: 'dblclick', event: event, originalEvent: e });
+                    e.preventDefault();
+                }
+            }];
+        this.subs = new Subscription();
+        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());
+    }
+}
+ShortcutsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", 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 });
+ShortcutsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: ShortcutsDirective, selector: "kendo-scheduler", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ShortcutsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'kendo-scheduler'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SchedulerComponent }, { type: i2.DomEventsService }, { type: i3.FocusService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i4.ViewStateService }, { type: i5.DialogsService }]; } });

package/esm2015/package-metadata.js

@@ -0,0 +1,15 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 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',
+    productCodes: ['KENDOUIANGULAR', 'KENDOUICOMPLETE'],
+    publishDate: 1649923912,
+    version: '',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/?utm_medium=product&utm_source=kendoangular&utm_campaign=kendo-ui-angular-purchase-license-keys-warning'
+};

package/esm2015/pdf/pdf-command.directive.js

@@ -0,0 +1,58 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, HostListener } from '@angular/core';
+import { Button } from '@progress/kendo-angular-buttons';
+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 of the Scheduler.
+ * You can apply this directive to any `button` element inside a
+ * [`ToolbarTemplate`]({% slug toolbar_scheduler %}).
+ * When the user clicks a button that is associated with the directive, the
+ * [`pdfExport`]({% slug api_scheduler_schedulercomponent %}#toc-pdfexport) event
+ * fires ([see example]({% slug pdfexport_scheduler %})).
+ *
+ * @example
+ * ```html-no-run
+ * <kendo-scheduler>
+ *      <ng-template kendoSchedulerToolbarTemplate>
+ *          <button kendoSchedulerPDFCommand>Export PDF</button>
+ *          <div kendoSchedulerToolbarNavigation></div>
+ *          <span class="k-spacer"></span>
+ *          <div kendoSchedulerToolbarViewSelector></div>
+ *      </ng-template>
+ *      <kendo-scheduler-pdf fileName="Scheduler.pdf">
+ *      </kendo-scheduler-pdf>
+ * </kendo-scheduler>
+ * ```
+ */
+export class PDFCommandDirective extends Button {
+    constructor(pdfService, element, renderer, localization, ngZone) {
+        super(element, renderer, null, localization, ngZone);
+        this.pdfService = pdfService;
+    }
+    /**
+     * @hidden
+     */
+    onClick(e) {
+        e.preventDefault();
+        this.pdfService.exportClick.emit();
+    }
+    ngOnInit() {
+        this.icon = 'pdf';
+    }
+}
+PDFCommandDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFCommandDirective, deps: [{ token: i1.PDFService }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i2.LocalizationService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+PDFCommandDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: PDFCommandDirective, selector: "[kendoSchedulerPDFCommand]", host: { listeners: { "click": "onClick($event)" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFCommandDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoSchedulerPDFCommand]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PDFService }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i2.LocalizationService }, { type: i0.NgZone }]; }, propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });

package/esm2015/pdf/pdf.component.js

@@ -0,0 +1,143 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, Input } from '@angular/core';
+import { drawDOM, exportPDF } from '@progress/kendo-drawing';
+import { saveAs } from '@progress/kendo-file-saver';
+import * as i0 from "@angular/core";
+import * as i1 from "./pdf.service";
+const createElement = (tagName, className) => {
+    const element = document.createElement(tagName);
+    if (className) {
+        element.className = className;
+    }
+    return element;
+};
+const createDiv = (className) => createElement('div', className);
+/**
+ * Configures the settings for the export of Scheduler in PDF ([see example]({% slug pdfexport_scheduler %})).
+ */
+export class PDFComponent {
+    constructor(pdfService, ngZone) {
+        this.pdfService = pdfService;
+        this.ngZone = ngZone;
+        /**
+         * The creator of the PDF document.
+         * Defaults to `Kendo UI PDF Generator`.
+         */
+        this.creator = 'Kendo UI PDF Generator';
+        this.subscriptions = this.pdfService.elementReady.subscribe(this.createElement.bind(this));
+        this.saveDataUri = this.saveDataUri.bind(this);
+        this.exportGroup = this.exportGroup.bind(this);
+        this.done = this.done.bind(this);
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    get drawOptions() {
+        return {
+            _destructive: true,
+            avoidLinks: this.avoidLinks,
+            margin: this.margin,
+            scale: this.scale
+        };
+    }
+    get pdfOptions() {
+        return {
+            author: this.author,
+            creator: this.creator,
+            date: this.date,
+            imgDPI: this.imageResolution,
+            keywords: this.keywords,
+            margin: this.margin,
+            producer: this.producer,
+            subject: this.subject,
+            title: this.title
+        };
+    }
+    get saveOptions() {
+        return {
+            forceProxy: this.forceProxy,
+            proxyData: this.proxyData,
+            proxyTarget: this.proxyTarget,
+            proxyURL: this.proxyURL
+        };
+    }
+    createElement(args) {
+        this.ngZone.runOutsideAngular(() => {
+            const container = this.container = createDiv();
+            container.style.top = container.style.left = '-10000px';
+            container.style.position = 'absolute';
+            const wrapper = createDiv('k-widget k-scheduler k-floatwrap');
+            wrapper.style.position = 'relative';
+            wrapper.appendChild(args.element);
+            container.appendChild(wrapper);
+            document.body.appendChild(container);
+            this.save(wrapper);
+        });
+    }
+    save(element) {
+        this.drawElement(element, this.drawOptions)
+            .then(this.exportGroup)
+            .then(this.saveDataUri)
+            .then(this.done, this.done);
+    }
+    drawElement(element, options) {
+        return drawDOM(element, options);
+    }
+    exportGroup(group) {
+        return exportPDF(group, this.pdfOptions);
+    }
+    saveDataUri(dataUri) {
+        saveAs(dataUri, this.fileName, this.saveOptions);
+    }
+    done() {
+        if (this.container) {
+            document.body.removeChild(this.container);
+            this.container = null;
+        }
+        this.pdfService.done.emit();
+    }
+}
+PDFComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFComponent, deps: [{ token: i1.PDFService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+PDFComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: PDFComponent, selector: "kendo-scheduler-pdf", inputs: { author: "author", avoidLinks: "avoidLinks", creator: "creator", date: "date", imageResolution: "imageResolution", fileName: "fileName", forceProxy: "forceProxy", keywords: "keywords", margin: "margin", scale: "scale", proxyData: "proxyData", proxyURL: "proxyURL", proxyTarget: "proxyTarget", producer: "producer", subject: "subject", title: "title" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-scheduler-pdf',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PDFService }, { type: i0.NgZone }]; }, propDecorators: { author: [{
+                type: Input
+            }], avoidLinks: [{
+                type: Input
+            }], creator: [{
+                type: Input
+            }], date: [{
+                type: Input
+            }], imageResolution: [{
+                type: Input
+            }], fileName: [{
+                type: Input
+            }], forceProxy: [{
+                type: Input
+            }], keywords: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], proxyData: [{
+                type: Input
+            }], proxyURL: [{
+                type: Input
+            }], proxyTarget: [{
+                type: Input
+            }], producer: [{
+                type: Input
+            }], subject: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }] } });

package/esm2015/pdf/pdf.module.js

@@ -0,0 +1,57 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NgModule } from '@angular/core';
+import { PDFComponent } from './pdf.component';
+import { PDFCommandDirective } from './pdf-command.directive';
+import * as i0 from "@angular/core";
+const declarations = [
+    PDFComponent,
+    PDFCommandDirective
+];
+/**
+ * Represents the [NgModule](https://angular.io/api/core/NgModule)
+ * definition for the Scheduler PDF component.
+ *
+ * @example
+ *
+ * ```ts-no-run
+ * // Import the Scheduler and PDF modules
+ * import { SchedulerModule, PDFModule } from '@progress/kendo-angular-scheduler';
+ *
+ * // The browser platform with a compiler
+ * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+ *
+ * import { NgModule } from '@angular/core';
+ *
+ * // Import the app component
+ * import { AppComponent } from './app.component';
+ *
+ * // Define the app module
+ * _@NgModule({
+ *     declarations: [AppComponent], // declare app component
+ *     imports:      [BrowserModule, SchedulerModule, PDFModule], // import Scheduler and PDF modules
+ *     bootstrap:    [AppComponent]
+ * })
+ * export class AppModule {}
+ *
+ * // Compile and launch the module
+ * platformBrowserDynamic().bootstrapModule(AppModule);
+ *
+ * ```
+ */
+export class PDFModule {
+}
+PDFModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PDFModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFModule, declarations: [PDFComponent,
+        PDFCommandDirective], exports: [PDFComponent,
+        PDFCommandDirective] });
+PDFModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [declarations],
+                    exports: [declarations]
+                }]
+        }] });

package/esm2015/pdf/pdf.service.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { EventEmitter, Injectable, isDevMode } from '@angular/core';
+import { hasObservers } from '@progress/kendo-angular-common';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class PDFService {
+    constructor() {
+        this.createElement = new EventEmitter();
+        this.exportClick = new EventEmitter();
+        this.done = new EventEmitter();
+        this.elementReady = new EventEmitter();
+    }
+    save() {
+        if (!hasObservers(this.elementReady)) {
+            if (isDevMode()) {
+                throw new Error('Creating PDF requires including the PDFModule and adding the <kendo-scheduler-pdf> component.');
+            }
+            return;
+        }
+        if (!hasObservers(this.createElement)) {
+            if (isDevMode()) {
+                throw new Error('No active Scheduler view to export.');
+            }
+            return;
+        }
+        this.createElement.emit();
+    }
+}
+PDFService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PDFService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: PDFService, decorators: [{
+            type: Injectable
+        }] });