@syncfusion/ej2-angular-schedule 22.1.34-ngcc → 22.1.34

package/esm2020/src/schedule/schedule-all.module.mjs

@@ -0,0 +1,74 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ScheduleModule } from './schedule.module';
+import { Day, Week, WorkWeek, Month, Year, Agenda, MonthAgenda, TimelineViews, TimelineMonth, TimelineYear, Resize, DragAndDrop, ExcelExport, ICalendarExport, ICalendarImport, Print } from '@syncfusion/ej2-schedule';
+import * as i0 from "@angular/core";
+export const DayService = { provide: 'ScheduleDay', useValue: Day };
+export const WeekService = { provide: 'ScheduleWeek', useValue: Week };
+export const WorkWeekService = { provide: 'ScheduleWorkWeek', useValue: WorkWeek };
+export const MonthService = { provide: 'ScheduleMonth', useValue: Month };
+export const YearService = { provide: 'ScheduleYear', useValue: Year };
+export const AgendaService = { provide: 'ScheduleAgenda', useValue: Agenda };
+export const MonthAgendaService = { provide: 'ScheduleMonthAgenda', useValue: MonthAgenda };
+export const TimelineViewsService = { provide: 'ScheduleTimelineViews', useValue: TimelineViews };
+export const TimelineMonthService = { provide: 'ScheduleTimelineMonth', useValue: TimelineMonth };
+export const TimelineYearService = { provide: 'ScheduleTimelineYear', useValue: TimelineYear };
+export const ResizeService = { provide: 'ScheduleResize', useValue: Resize };
+export const DragAndDropService = { provide: 'ScheduleDragAndDrop', useValue: DragAndDrop };
+export const ExcelExportService = { provide: 'ScheduleExcelExport', useValue: ExcelExport };
+export const ICalendarExportService = { provide: 'ScheduleICalendarExport', useValue: ICalendarExport };
+export const ICalendarImportService = { provide: 'ScheduleICalendarImport', useValue: ICalendarImport };
+export const PrintService = { provide: 'SchedulePrint', useValue: Print };
+/**
+ * NgModule definition for the Schedule component with providers.
+ */
+export class ScheduleAllModule {
+}
+ScheduleAllModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleAllModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ScheduleAllModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleAllModule, imports: [CommonModule, ScheduleModule], exports: [ScheduleModule] });
+ScheduleAllModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleAllModule, providers: [
+        DayService,
+        WeekService,
+        WorkWeekService,
+        MonthService,
+        YearService,
+        AgendaService,
+        MonthAgendaService,
+        TimelineViewsService,
+        TimelineMonthService,
+        TimelineYearService,
+        ResizeService,
+        DragAndDropService,
+        ExcelExportService,
+        ICalendarExportService,
+        ICalendarImportService,
+        PrintService
+    ], imports: [[CommonModule, ScheduleModule], ScheduleModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleAllModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ScheduleModule],
+                    exports: [
+                        ScheduleModule
+                    ],
+                    providers: [
+                        DayService,
+                        WeekService,
+                        WorkWeekService,
+                        MonthService,
+                        YearService,
+                        AgendaService,
+                        MonthAgendaService,
+                        TimelineViewsService,
+                        TimelineMonthService,
+                        TimelineYearService,
+                        ResizeService,
+                        DragAndDropService,
+                        ExcelExportService,
+                        ICalendarExportService,
+                        ICalendarImportService,
+                        PrintService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/schedule/schedule.component.mjs

@@ -0,0 +1,283 @@
+import { __decorate } from "tslib";
+import { Component, ChangeDetectionStrategy, ContentChild } from '@angular/core';
+import { ComponentBase, ComponentMixins, setValue } from '@syncfusion/ej2-angular-base';
+import { Schedule } from '@syncfusion/ej2-schedule';
+import { Template } from '@syncfusion/ej2-angular-base';
+import { ViewsDirective } from './views.directive';
+import { ResourcesDirective } from './resources.directive';
+import { HeaderRowsDirective } from './headerrows.directive';
+import * as i0 from "@angular/core";
+export const inputs = ['agendaDaysCount', 'allowDragAndDrop', 'allowInline', 'allowKeyboardInteraction', 'allowMultiCellSelection', 'allowMultiDrag', 'allowMultiRowSelection', 'allowResizing', 'calendarMode', 'cellHeaderTemplate', 'cellTemplate', 'cssClass', 'currentView', 'dateFormat', 'dateHeaderTemplate', 'dayHeaderTemplate', 'editorTemplate', 'enableAdaptiveUI', 'enableAllDayScroll', 'enablePersistence', 'enableRecurrenceValidation', 'enableRtl', 'endHour', 'eventDragArea', 'eventSettings', 'firstDayOfWeek', 'firstMonthOfYear', 'group', 'headerIndentTemplate', 'headerRows', 'height', 'hideEmptyAgendaDays', 'locale', 'maxDate', 'minDate', 'monthHeaderTemplate', 'monthsCount', 'quickInfoOnSelectionEnd', 'quickInfoTemplates', 'readonly', 'resourceHeaderTemplate', 'resources', 'rowAutoHeight', 'selectedDate', 'showHeaderBar', 'showQuickInfo', 'showTimeIndicator', 'showWeekNumber', 'showWeekend', 'startHour', 'timeFormat', 'timeScale', 'timezone', 'timezoneDataSource', 'views', 'weekRule', 'width', 'workDays', 'workHours'];
+export const outputs = ['actionBegin', 'actionComplete', 'actionFailure', 'cellClick', 'cellDoubleClick', 'created', 'dataBinding', 'dataBound', 'destroyed', 'drag', 'dragStart', 'dragStop', 'eventClick', 'eventRendered', 'hover', 'moreEventsClick', 'navigating', 'popupClose', 'popupOpen', 'renderCell', 'resizeStart', 'resizeStop', 'resizing', 'select', 'currentViewChange', 'selectedDateChange'];
+export const twoWays = ['currentView', 'selectedDate'];
+/**
+ * `ej-schedule` represents the Angular Schedule Component.
+ * ```html
+ * <ejs-schedule></ejs-schedule>
+ * ```
+ */
+let ScheduleComponent = class ScheduleComponent extends Schedule {
+    constructor(ngEle, srenderer, viewContainerRef, injector) {
+        super();
+        this.ngEle = ngEle;
+        this.srenderer = srenderer;
+        this.viewContainerRef = viewContainerRef;
+        this.injector = injector;
+        this.tags = ['views', 'resources', 'headerRows'];
+        this.element = this.ngEle.nativeElement;
+        this.injectedModules = this.injectedModules || [];
+        try {
+            let mod = this.injector.get('ScheduleDay');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleWeek');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleWorkWeek');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleMonth');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleYear');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleAgenda');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleMonthAgenda');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleTimelineViews');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleTimelineMonth');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleTimelineYear');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleResize');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleDragAndDrop');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleExcelExport');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleICalendarExport');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('ScheduleICalendarImport');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('SchedulePrint');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        this.registerEvents(outputs);
+        this.addTwoWay.call(this, twoWays);
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.context = new ComponentBase();
+    }
+    ngOnInit() {
+        this.context.ngOnInit(this);
+    }
+    ngAfterViewInit() {
+        this.context.ngAfterViewInit(this);
+    }
+    ngOnDestroy() {
+        this.context.ngOnDestroy(this);
+    }
+    ngAfterContentChecked() {
+        this.tagObjects[0].instance = this.childViews;
+        if (this.childResources) {
+            this.tagObjects[1].instance = this.childResources;
+        }
+        if (this.childHeaderRows) {
+            this.tagObjects[2].instance = this.childHeaderRows;
+        }
+        this.context.ngAfterContentChecked(this);
+    }
+};
+ScheduleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+ScheduleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: ScheduleComponent, selector: "ejs-schedule", inputs: { agendaDaysCount: "agendaDaysCount", allowDragAndDrop: "allowDragAndDrop", allowInline: "allowInline", allowKeyboardInteraction: "allowKeyboardInteraction", allowMultiCellSelection: "allowMultiCellSelection", allowMultiDrag: "allowMultiDrag", allowMultiRowSelection: "allowMultiRowSelection", allowResizing: "allowResizing", calendarMode: "calendarMode", cellHeaderTemplate: "cellHeaderTemplate", cellTemplate: "cellTemplate", cssClass: "cssClass", currentView: "currentView", dateFormat: "dateFormat", dateHeaderTemplate: "dateHeaderTemplate", dayHeaderTemplate: "dayHeaderTemplate", editorTemplate: "editorTemplate", enableAdaptiveUI: "enableAdaptiveUI", enableAllDayScroll: "enableAllDayScroll", enablePersistence: "enablePersistence", enableRecurrenceValidation: "enableRecurrenceValidation", enableRtl: "enableRtl", endHour: "endHour", eventDragArea: "eventDragArea", eventSettings: "eventSettings", firstDayOfWeek: "firstDayOfWeek", firstMonthOfYear: "firstMonthOfYear", group: "group", headerIndentTemplate: "headerIndentTemplate", headerRows: "headerRows", height: "height", hideEmptyAgendaDays: "hideEmptyAgendaDays", locale: "locale", maxDate: "maxDate", minDate: "minDate", monthHeaderTemplate: "monthHeaderTemplate", monthsCount: "monthsCount", quickInfoOnSelectionEnd: "quickInfoOnSelectionEnd", quickInfoTemplates: "quickInfoTemplates", readonly: "readonly", resourceHeaderTemplate: "resourceHeaderTemplate", resources: "resources", rowAutoHeight: "rowAutoHeight", selectedDate: "selectedDate", showHeaderBar: "showHeaderBar", showQuickInfo: "showQuickInfo", showTimeIndicator: "showTimeIndicator", showWeekNumber: "showWeekNumber", showWeekend: "showWeekend", startHour: "startHour", timeFormat: "timeFormat", timeScale: "timeScale", timezone: "timezone", timezoneDataSource: "timezoneDataSource", views: "views", weekRule: "weekRule", width: "width", workDays: "workDays", workHours: "workHours" }, outputs: { actionBegin: "actionBegin", actionComplete: "actionComplete", actionFailure: "actionFailure", cellClick: "cellClick", cellDoubleClick: "cellDoubleClick", created: "created", dataBinding: "dataBinding", dataBound: "dataBound", destroyed: "destroyed", drag: "drag", dragStart: "dragStart", dragStop: "dragStop", eventClick: "eventClick", eventRendered: "eventRendered", hover: "hover", moreEventsClick: "moreEventsClick", navigating: "navigating", popupClose: "popupClose", popupOpen: "popupOpen", renderCell: "renderCell", resizeStart: "resizeStart", resizeStop: "resizeStop", resizing: "resizing", select: "select", currentViewChange: "currentViewChange", selectedDateChange: "selectedDateChange" }, queries: [{ propertyName: "dateHeaderTemplate", first: true, predicate: ["dateHeaderTemplate"], descendants: true }, { propertyName: "dayHeaderTemplate", first: true, predicate: ["dayHeaderTemplate"], descendants: true }, { propertyName: "cellTemplate", first: true, predicate: ["cellTemplate"], descendants: true }, { propertyName: "cellHeaderTemplate", first: true, predicate: ["cellHeaderTemplate"], descendants: true }, { propertyName: "eventSettings_tooltipTemplate", first: true, predicate: ["eventSettingsTooltipTemplate"], descendants: true }, { propertyName: "eventSettings_template", first: true, predicate: ["eventSettingsTemplate"], descendants: true }, { propertyName: "editorTemplate", first: true, predicate: ["editorTemplate"], descendants: true }, { propertyName: "monthHeaderTemplate", first: true, predicate: ["monthHeaderTemplate"], descendants: true }, { propertyName: "timeScale_minorSlotTemplate", first: true, predicate: ["timeScaleMinorSlotTemplate"], descendants: true }, { propertyName: "timeScale_majorSlotTemplate", first: true, predicate: ["timeScaleMajorSlotTemplate"], descendants: true }, { propertyName: "resourceHeaderTemplate", first: true, predicate: ["resourceHeaderTemplate"], descendants: true }, { propertyName: "headerIndentTemplate", first: true, predicate: ["headerIndentTemplate"], descendants: true }, { propertyName: "quickInfoTemplates_header", first: true, predicate: ["quickInfoTemplatesHeader"], descendants: true }, { propertyName: "quickInfoTemplates_content", first: true, predicate: ["quickInfoTemplatesContent"], descendants: true }, { propertyName: "quickInfoTemplates_footer", first: true, predicate: ["quickInfoTemplatesFooter"], descendants: true }, { propertyName: "group_headerTooltipTemplate", first: true, predicate: ["groupHeaderTooltipTemplate"], descendants: true }, { propertyName: "childViews", first: true, predicate: ViewsDirective, descendants: true }, { propertyName: "childResources", first: true, predicate: ResourcesDirective, descendants: true }, { propertyName: "childHeaderRows", first: true, predicate: HeaderRowsDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "dateHeaderTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "dayHeaderTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "cellTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "cellHeaderTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "eventSettings_tooltipTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "eventSettings_template", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "editorTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "monthHeaderTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "timeScale_minorSlotTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "timeScale_majorSlotTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "resourceHeaderTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "headerIndentTemplate", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "quickInfoTemplates_header", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "quickInfoTemplates_content", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "quickInfoTemplates_footer", void 0);
+__decorate([
+    Template()
+], ScheduleComponent.prototype, "group_headerTooltipTemplate", void 0);
+ScheduleComponent = __decorate([
+    ComponentMixins([ComponentBase])
+], ScheduleComponent);
+export { ScheduleComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ejs-schedule',
+                    inputs: inputs,
+                    outputs: outputs,
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    queries: {
+                        childViews: new ContentChild(ViewsDirective),
+                        childResources: new ContentChild(ResourcesDirective),
+                        childHeaderRows: new ContentChild(HeaderRowsDirective)
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.Injector }]; }, propDecorators: { dateHeaderTemplate: [{
+                type: ContentChild,
+                args: ['dateHeaderTemplate']
+            }], dayHeaderTemplate: [{
+                type: ContentChild,
+                args: ['dayHeaderTemplate']
+            }], cellTemplate: [{
+                type: ContentChild,
+                args: ['cellTemplate']
+            }], cellHeaderTemplate: [{
+                type: ContentChild,
+                args: ['cellHeaderTemplate']
+            }], eventSettings_tooltipTemplate: [{
+                type: ContentChild,
+                args: ['eventSettingsTooltipTemplate']
+            }], eventSettings_template: [{
+                type: ContentChild,
+                args: ['eventSettingsTemplate']
+            }], editorTemplate: [{
+                type: ContentChild,
+                args: ['editorTemplate']
+            }], monthHeaderTemplate: [{
+                type: ContentChild,
+                args: ['monthHeaderTemplate']
+            }], timeScale_minorSlotTemplate: [{
+                type: ContentChild,
+                args: ['timeScaleMinorSlotTemplate']
+            }], timeScale_majorSlotTemplate: [{
+                type: ContentChild,
+                args: ['timeScaleMajorSlotTemplate']
+            }], resourceHeaderTemplate: [{
+                type: ContentChild,
+                args: ['resourceHeaderTemplate']
+            }], headerIndentTemplate: [{
+                type: ContentChild,
+                args: ['headerIndentTemplate']
+            }], quickInfoTemplates_header: [{
+                type: ContentChild,
+                args: ['quickInfoTemplatesHeader']
+            }], quickInfoTemplates_content: [{
+                type: ContentChild,
+                args: ['quickInfoTemplatesContent']
+            }], quickInfoTemplates_footer: [{
+                type: ContentChild,
+                args: ['quickInfoTemplatesFooter']
+            }], group_headerTooltipTemplate: [{
+                type: ContentChild,
+                args: ['groupHeaderTooltipTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schedule.component.js","sourceRoot":"","sources":["../../../../src/schedule/schedule.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewContainerRef, ChangeDetectionStrategy, QueryList, Renderer2, Injector, ValueProvider, ContentChild } from '@angular/core';\nimport { ComponentBase, IComponentBase, applyMixins, ComponentMixins, PropertyCollectionInfo, setValue } from '@syncfusion/ej2-angular-base';\nimport { Schedule } from '@syncfusion/ej2-schedule';\nimport { Template } from '@syncfusion/ej2-angular-base';\nimport { ViewsDirective } from './views.directive';\nimport { ResourcesDirective } from './resources.directive';\nimport { HeaderRowsDirective } from './headerrows.directive';\n\nexport const inputs: string[] = ['agendaDaysCount','allowDragAndDrop','allowInline','allowKeyboardInteraction','allowMultiCellSelection','allowMultiDrag','allowMultiRowSelection','allowResizing','calendarMode','cellHeaderTemplate','cellTemplate','cssClass','currentView','dateFormat','dateHeaderTemplate','dayHeaderTemplate','editorTemplate','enableAdaptiveUI','enableAllDayScroll','enablePersistence','enableRecurrenceValidation','enableRtl','endHour','eventDragArea','eventSettings','firstDayOfWeek','firstMonthOfYear','group','headerIndentTemplate','headerRows','height','hideEmptyAgendaDays','locale','maxDate','minDate','monthHeaderTemplate','monthsCount','quickInfoOnSelectionEnd','quickInfoTemplates','readonly','resourceHeaderTemplate','resources','rowAutoHeight','selectedDate','showHeaderBar','showQuickInfo','showTimeIndicator','showWeekNumber','showWeekend','startHour','timeFormat','timeScale','timezone','timezoneDataSource','views','weekRule','width','workDays','workHours'];\nexport const outputs: string[] = ['actionBegin','actionComplete','actionFailure','cellClick','cellDoubleClick','created','dataBinding','dataBound','destroyed','drag','dragStart','dragStop','eventClick','eventRendered','hover','moreEventsClick','navigating','popupClose','popupOpen','renderCell','resizeStart','resizeStop','resizing','select','currentViewChange','selectedDateChange'];\nexport const twoWays: string[] = ['currentView', 'selectedDate'];\n\n/**\n * `ej-schedule` represents the Angular Schedule Component.\n * ```html\n * <ejs-schedule></ejs-schedule>\n * ```\n */\n@Component({\n    selector: 'ejs-schedule',\n    inputs: inputs,\n    outputs: outputs,\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    queries: {\n        childViews: new ContentChild(ViewsDirective), \n        childResources: new ContentChild(ResourcesDirective), \n        childHeaderRows: new ContentChild(HeaderRowsDirective)\n    }\n})\n@ComponentMixins([ComponentBase])\nexport class ScheduleComponent extends Schedule implements IComponentBase {\n    public context : any;\n    public tagObjects: any;\n\tactionBegin: any;\n\tactionComplete: any;\n\tactionFailure: any;\n\tcellClick: any;\n\tcellDoubleClick: any;\n\tcreated: any;\n\tdataBinding: any;\n\tdataBound: any;\n\tdestroyed: any;\n\tdrag: any;\n\tdragStart: any;\n\tdragStop: any;\n\teventClick: any;\n\teventRendered: any;\n\thover: any;\n\tmoreEventsClick: any;\n\tnavigating: any;\n\tpopupClose: any;\n\tpopupOpen: any;\n\trenderCell: any;\n\tresizeStart: any;\n\tresizeStop: any;\n\tresizing: any;\n\tselect: any;\n\tcurrentViewChange: any;\n\tpublic selectedDateChange: any;\n    public childViews: QueryList<ViewsDirective>;\n    public childResources: QueryList<ResourcesDirective>;\n    public childHeaderRows: QueryList<HeaderRowsDirective>;\n    public tags: string[] = ['views', 'resources', 'headerRows'];\n    /** \n     * It accepts either the string or HTMLElement as template design content and parse it appropriately before displaying it onto \n     * the date header cells. The field that can be accessed via this template is `date`.\n     * \n     * {% codeBlock src='schedule/dateHeaderTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('dateHeaderTemplate')\n    @Template()\n    public dateHeaderTemplate: any;\n    /** \n     * It accepts either the string or HTMLElement as template design content and parse it appropriately before displaying it onto \n     * the day header cells. This template is only applicable for year view header cells.\n     * \n     * {% codeBlock src='schedule/dayHeaderTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('dayHeaderTemplate')\n    @Template()\n    public dayHeaderTemplate: any;\n    /** \n     * The template option which is used to render the customized work cells on the Schedule. Here, the template accepts either \n     *  the string or HTMLElement as template design and then the parsed design is displayed onto the work cells. \n     *  The fields accessible via template are as follows. \n     * * date \n     * * groupIndex \n     * * type\n     * \n     * Refer to the below code snippet.\n     *\n     *{% codeBlock src='schedule/cellTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('cellTemplate')\n    @Template()\n    public cellTemplate: any;\n    /** \n     * It accepts either the string or HTMLElement as template design content and parse it appropriately before displaying it onto \n     * the month date cells. This template is only applicable for month view day cells.\n     * \n     * {% codeBlock src='schedule/cellHeaderTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('cellHeaderTemplate')\n    @Template()\n    public cellHeaderTemplate: any;\n    @ContentChild('eventSettingsTooltipTemplate')\n    @Template()\n    public eventSettings_tooltipTemplate: any;\n    @ContentChild('eventSettingsTemplate')\n    @Template()\n    public eventSettings_template: any;\n    /** \n     * The template option to render the customized editor window. The form elements defined within this template should be accompanied \n     *  with `e-field` class, so as to fetch and process it from internally.\n     * \n     * {% codeBlock src='schedule/editorTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('editorTemplate')\n    @Template()\n    public editorTemplate: any;\n    /** \n     * It accepts either the string or HTMLElement as template design content and parse it appropriately before displaying it onto \n     * the month header cells. This template is only applicable for year view header cells.\n     * \n     * {% codeBlock src='schedule/monthHeaderTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('monthHeaderTemplate')\n    @Template()\n    public monthHeaderTemplate: any;\n    @ContentChild('timeScaleMinorSlotTemplate')\n    @Template()\n    public timeScale_minorSlotTemplate: any;\n    @ContentChild('timeScaleMajorSlotTemplate')\n    @Template()\n    public timeScale_majorSlotTemplate: any;\n    /** \n     * Template option to customize the resource header bar. Here, the template accepts either \n     *  the string or HTMLElement as template design and then the parsed design is displayed onto the resource header cells. \n     * The following can be accessible via template. \n     * * resource - All the resource fields. \n     * * resourceData - object collection of current resource.\n     * \n     * Refer to the below code snippet.\n     *\n     *{% codeBlock src='schedule/resourceHeaderTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('resourceHeaderTemplate')\n    @Template()\n    public resourceHeaderTemplate: any;\n    /** \n     * Template option to customize the header indent bar. Here, the template accepts either \n     *  the string or HTMLElement as template design and then the parsed design is displayed onto the header indent cell.\n     * \n     * Refer to the below code snippet.\n     *\n     *{% codeBlock src='schedule/headerIndentTemplate/index.md' %}{% endcodeBlock %}\n     *     \n     * @default null\n     */\n    @ContentChild('headerIndentTemplate')\n    @Template()\n    public headerIndentTemplate: any;\n    @ContentChild('quickInfoTemplatesHeader')\n    @Template()\n    public quickInfoTemplates_header: any;\n    @ContentChild('quickInfoTemplatesContent')\n    @Template()\n    public quickInfoTemplates_content: any;\n    @ContentChild('quickInfoTemplatesFooter')\n    @Template()\n    public quickInfoTemplates_footer: any;\n    @ContentChild('groupHeaderTooltipTemplate')\n    @Template()\n    public group_headerTooltipTemplate: any;\n\n    constructor(private ngEle: ElementRef, private srenderer: Renderer2, private viewContainerRef:ViewContainerRef, private injector: Injector) {\n        super();\n        this.element = this.ngEle.nativeElement;\n        this.injectedModules = this.injectedModules || [];\n        try {\n                let mod = this.injector.get('ScheduleDay');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleWeek');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleWorkWeek');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleMonth');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleYear');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleAgenda');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleMonthAgenda');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleTimelineViews');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleTimelineMonth');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleTimelineYear');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleResize');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleDragAndDrop');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleExcelExport');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleICalendarExport');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('ScheduleICalendarImport');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('SchedulePrint');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r\n        this.registerEvents(outputs);\n        this.addTwoWay.call(this, twoWays);\n        setValue('currentInstance', this, this.viewContainerRef);\n        this.context  = new ComponentBase();\n    }\n\n    public ngOnInit() {\n        this.context.ngOnInit(this);\n    }\n\n    public ngAfterViewInit(): void {\n        this.context.ngAfterViewInit(this);\n    }\n\n    public ngOnDestroy(): void {\n        this.context.ngOnDestroy(this);\n    }\n\n    public ngAfterContentChecked(): void {\n        this.tagObjects[0].instance = this.childViews;\n        \n\t    if (this.childResources) {\n            this.tagObjects[1].instance = this.childResources;\n        }\n        \n\t    if (this.childHeaderRows) {\n            this.tagObjects[2].instance = this.childHeaderRows;\n        }\n        this.context.ngAfterContentChecked(this);\n    }\n\n    public registerEvents: (eventList: string[]) => void;\n    public addTwoWay: (propList: string[]) => void;\n}\n\n"]}

package/esm2020/src/schedule/schedule.module.mjs

@@ -0,0 +1,52 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ViewDirective, ViewsDirective } from './views.directive';
+import { ResourceDirective, ResourcesDirective } from './resources.directive';
+import { HeaderRowDirective, HeaderRowsDirective } from './headerrows.directive';
+import { ScheduleComponent } from './schedule.component';
+import * as i0 from "@angular/core";
+/**
+ * NgModule definition for the Schedule component.
+ */
+export class ScheduleModule {
+}
+ScheduleModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ScheduleModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleModule, declarations: [ScheduleComponent,
+        ViewDirective,
+        ViewsDirective,
+        ResourceDirective,
+        ResourcesDirective,
+        HeaderRowDirective,
+        HeaderRowsDirective], imports: [CommonModule], exports: [ScheduleComponent,
+        ViewDirective,
+        ViewsDirective,
+        ResourceDirective,
+        ResourcesDirective,
+        HeaderRowDirective,
+        HeaderRowsDirective] });
+ScheduleModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ScheduleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        ScheduleComponent,
+                        ViewDirective,
+                        ViewsDirective,
+                        ResourceDirective,
+                        ResourcesDirective,
+                        HeaderRowDirective,
+                        HeaderRowsDirective
+                    ],
+                    exports: [
+                        ScheduleComponent,
+                        ViewDirective,
+                        ViewsDirective,
+                        ResourceDirective,
+                        ResourcesDirective,
+                        HeaderRowDirective,
+                        HeaderRowsDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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