@syncfusion/ej2-schedule 31.1.17 → 31.1.20

package/dist/ts/schedule/exports/calendar-export.d.ts

@@ -1,16 +0,0 @@
-import { Schedule } from '../base/schedule';
-/**
- * ICalendar Export Module
- */
-export declare class ICalendarExport {
-    private parent;
-    constructor(parent: Schedule);
-    initializeCalendarExport(fileName: string, customData: Record<string, any>[]): void;
-    getCalendarString(fileName?: string, customData?: Record<string, any>[]): string;
-    private customFieldFilter;
-    private convertDateToString;
-    private download;
-    private filterEvents;
-    protected getModuleName(): string;
-    destroy(): void;
-}

package/dist/ts/schedule/exports/calendar-export.ts

@@ -1,160 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { extend } from '@syncfusion/ej2-base';
-import { EventFieldsMapping } from '../base/interface';
-import { getDateFromRecurrenceDateString, getRecurrenceStringFromDate } from '../../recurrence-editor/date-generator';
-import { Schedule } from '../base/schedule';
-
-/**
- * ICalendar Export Module
- */
-
-export class ICalendarExport {
-    private parent: Schedule;
-    constructor(parent: Schedule) {
-        this.parent = parent;
-    }
-
-    public initializeCalendarExport(fileName: string, customData: Record<string, any>[]): void {
-        const icsString: string = this.getCalendarString(fileName, customData);
-        this.download(icsString, fileName);
-    }
-
-    public getCalendarString(fileName?: string, customData?: Record<string, any>[]): string {
-        let eventsData: Record<string, any>[] = (customData) ? customData :
-            extend([], this.parent.eventsData, null, true) as Record<string, any>[];
-        eventsData = this.parent.eventBase.sortByTime(eventsData);
-        const SEPARATOR: string = (navigator.appVersion.indexOf('Win') !== -1) ? '\r\n' : '\n';
-        const iCalendarEvents: string[] = [];
-        const filterCollection: Record<string, any>[] = [];
-        const timeZone: string = this.parent.timezone || this.parent.tzModule.getLocalTimezoneName();
-        const fields: EventFieldsMapping = this.parent.eventFields;
-        eventsData.forEach((eventObj: Record<string, any>) => {
-            let uId: string = eventObj[fields.id] || eventObj.Guid || this.parent.eventBase.generateGuid();
-            const editedExDate: string[] = [];
-            if (eventObj[fields.recurrenceID]) {
-                const filter: Record<string, any>[] =
-                    this.filterEvents(filterCollection, fields.id, eventObj[fields.recurrenceID] as number);
-                uId = filter.length > 0 ? filter[0].UID as string : uId;
-            }
-            if (!eventObj[fields.recurrenceID] && eventObj[fields.recurrenceRule] && eventObj[fields.recurrenceException]) {
-                const exDate: string[] = ((eventObj[fields.recurrenceException]) as string).split(',');
-                const editedObj: Record<string, any>[] =
-                    this.filterEvents(eventsData, fields.recurrenceID, eventObj[fields.id] as number);
-                editedObj.forEach((edited: Record<string, any>) => {
-                    editedExDate.push(getRecurrenceStringFromDate(edited[fields.startTime] as Date));
-                });
-                const exceptionDateList: string[] = exDate.filter((value: string) => editedExDate.indexOf(value) === -1);
-                eventObj[fields.recurrenceException] = (exceptionDateList.length > 0) ? (exceptionDateList.join(',') + ',') : '';
-            }
-            const startZone: string = (eventObj[fields.startTimezone] || timeZone) as string;
-            const endZone: string = (eventObj[fields.endTimezone] || timeZone) as string;
-            const readonly: boolean = (eventObj[fields.isReadonly]) ? (eventObj[fields.isReadonly]) : false;
-            const calendarEvent: string[] = [
-                'BEGIN:VEVENT',
-                'LOCATION:' + (eventObj[fields.location] || ''),
-                'SUMMARY:' + (eventObj[fields.subject] || ''),
-                'UID:' + uId,
-                'DESCRIPTION:' + (eventObj[fields.description] || ''),
-                'ISREADONLY:' + readonly,
-                'END:VEVENT'
-            ];
-            if (eventObj[fields.isAllDay]) {
-                calendarEvent.splice(4, 0, 'DTEND;VALUE=DATE:' + this.convertDateToString(eventObj[fields.endTime] as Date, true));
-                calendarEvent.splice(4, 0, 'DTSTART;VALUE=DATE:' + this.convertDateToString(eventObj[fields.startTime] as Date, true));
-            } else if (!eventObj[fields.isAllDay] && !eventObj[fields.recurrenceRule]) {
-                calendarEvent.splice(4, 0, 'DTEND:' + this.convertDateToString(eventObj[fields.endTime] as Date));
-                calendarEvent.splice(4, 0, 'DTSTART:' + this.convertDateToString(eventObj[fields.startTime] as Date));
-            } else {
-                calendarEvent.splice(4, 0, 'DTEND;TZID="' + endZone + '":' + this.convertDateToString(eventObj[fields.endTime] as Date));
-                calendarEvent.splice(4, 0, 'DTSTART;TZID="' + startZone + '":'
-                    + this.convertDateToString(eventObj[fields.startTime] as Date));
-            }
-            if (eventObj[fields.recurrenceRule]) {
-                calendarEvent.splice(4, 0, 'RRULE:' + eventObj[fields.recurrenceRule]);
-            }
-            if (eventObj[fields.recurrenceException]) {
-                const exDate: string[] = (eventObj[fields.recurrenceException] as string).split(',');
-                for (let i: number = 0; i < exDate.length - 1; i++) {
-                    calendarEvent.splice(5, 0, 'EXDATE:' +
-                        this.convertDateToString(
-                            getDateFromRecurrenceDateString(exDate[parseInt(i.toString(), 10)]), eventObj[fields.isAllDay] as boolean));
-                }
-            }
-            if (eventObj[fields.recurrenceID]) {
-                calendarEvent.splice(4, 0, 'RECURRENCE-ID;TZID="' + startZone + '":'
-                    + this.convertDateToString(eventObj[fields.startTime] as Date, eventObj[fields.isAllDay] as boolean));
-            }
-            const customFields: string[] = this.customFieldFilter(eventObj, fields);
-            if (customFields.length > 0) {
-                customFields.forEach((customField: string) =>
-                    calendarEvent.splice(4, 0, customField + ':' + (eventObj[`${customField}`] || ''))
-                );
-            }
-            const app: Record<string, any> = <Record<string, any>>extend({}, eventObj);
-            app.UID = uId;
-            filterCollection.push(app);
-            iCalendarEvents.push(calendarEvent.join(SEPARATOR));
-
-        });
-        const iCalendar: string = [
-            'BEGIN:VCALENDAR',
-            'PRODID:-//Syncfusion Inc//Scheduler//EN',
-            'VERSION:2.0',
-            'CALSCALE:GREGORIAN',
-            'METHOD:PUBLISH',
-            'X-WR-CALNAME:' + (fileName || 'Calendar'),
-            'X-WR-TIMEZONE:' + timeZone
-        ].join(SEPARATOR);
-        const icsString: string = iCalendar + SEPARATOR + iCalendarEvents.join(SEPARATOR) + SEPARATOR + 'END:VCALENDAR';
-        return icsString;
-    }
-    private customFieldFilter(eventObj: Record<string, any>, fields: EventFieldsMapping): string[] {
-        const defaultFields: string[] = Object.keys(fields).map((key: string) => (fields as Record<string, any>)[`${key}`]) as string[];
-        const eventFields: string[] = Object.keys(eventObj);
-        return eventFields.filter((value: string) => (defaultFields.indexOf(value) === -1) && (value !== 'Guid'));
-    }
-
-    private convertDateToString(eventDate: Date, allDay?: boolean): string {
-        const year: string = ('0000' + (eventDate.getFullYear().toString())).slice(-4);
-        const month: string = ('00' + ((eventDate.getMonth() + 1).toString())).slice(-2);
-        const date: string = ('00' + ((eventDate.getDate()).toString())).slice(-2);
-        const hours: string = ('00' + (eventDate.getHours().toString())).slice(-2);
-        const minutes: string = ('00' + (eventDate.getMinutes().toString())).slice(-2);
-        const seconds: string = ('00' + (eventDate.getSeconds().toString())).slice(-2);
-        const timeString: string = (allDay) ? year + month + date : year + month + date + 'T' + hours + minutes + seconds;
-        return timeString;
-    }
-
-    private download(icsString: string, fileName: string): void {
-        const buffer: Blob = new Blob([icsString], { type: 'data:text/calendar;charset=utf8' });
-        fileName = (fileName || 'Calendar') + '.ics';
-        if (navigator.msSaveBlob) {
-            navigator.msSaveBlob(buffer, fileName);
-        } else {
-            const downloadLink: HTMLAnchorElement = document.createElementNS('http://www.w3.org/1999/xhtml', 'a') as HTMLAnchorElement;
-            downloadLink.download = fileName;
-            downloadLink.href = URL.createObjectURL(buffer);
-            const event: MouseEvent = document.createEvent('MouseEvent');
-            event.initEvent('click', true, true);
-            downloadLink.dispatchEvent(event);
-            setTimeout((): void => {
-                URL.revokeObjectURL(downloadLink.href);
-                downloadLink.href = undefined;
-            });
-        }
-    }
-
-    private filterEvents(data: Record<string, any>[], field: string, value: number): Record<string, any>[] {
-        return data.filter((e: Record<string, any>) => e[`${field}`] === value);
-    }
-
-    protected getModuleName(): string {
-        return 'iCalendarExport';
-    }
-
-    public destroy(): void {
-        if (!this.parent || this.parent && this.parent.isDestroyed) { return; }
-        this.parent = null;
-    }
-
-}

package/dist/ts/schedule/exports/calendar-import.d.ts

@@ -1,18 +0,0 @@
-import { Schedule } from '../base/schedule';
-/**
- * ICalendar Import Module
- */
-export declare class ICalendarImport {
-    private parent;
-    private allDay;
-    constructor(parent: Schedule);
-    initializeCalendarImport(fileContent: Blob | string): void;
-    private iCalendarParser;
-    private updateEventData;
-    private processOccurrence;
-    private getExcludeDateString;
-    private getFormattedString;
-    private dateParsing;
-    protected getModuleName(): string;
-    destroy(): void;
-}

package/dist/ts/schedule/exports/calendar-import.ts

@@ -1,277 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { isNullOrUndefined, extend } from '@syncfusion/ej2-base';
-import { Schedule } from '../base/schedule';
-import { EventFieldsMapping } from '../base/interface';
-import { getRecurrenceStringFromDate } from '../../recurrence-editor/date-generator';
-
-/**
- * ICalendar Import Module
- */
-
-export class ICalendarImport {
-    private parent: Schedule;
-    private allDay: boolean = false;
-    constructor(parent: Schedule) {
-        this.parent = parent;
-    }
-
-    public initializeCalendarImport(fileContent: Blob | string): void {
-        if (fileContent && fileContent instanceof Blob) {
-            const fileReader: FileReader = new FileReader();
-            fileReader.onload = () => {
-                const iCalString: string = fileReader.result as string;
-                this.iCalendarParser(iCalString);
-            };
-            fileReader.readAsText(fileContent as Blob, 'UTF-8');
-        } else if (fileContent && typeof fileContent === 'string') {
-            this.iCalendarParser(fileContent);
-        }
-    }
-
-    private iCalendarParser(iCalString: string): void {
-        let iCalData: Record<string, any> = {
-            isEvent: false,
-            curEvent: null,
-            id: this.parent.eventBase.getEventMaxID(),
-            count: 0,
-            events: [],
-            key: null
-        };
-        const iStringLength: number = iCalString.length;
-        let lastPosition: number = iCalString.search(/[^ \t]/);
-        let position: number = lastPosition;
-        let iString: string;
-        let newlineOffset: number;
-        do {
-            position = iCalString.indexOf('\n', lastPosition) + 1;
-            if (position === 0) {
-                position = iStringLength;
-                newlineOffset = 0;
-            } else if (position > 1 && iCalString[position - 2] === '\r') {
-                newlineOffset = 2;
-            } else {
-                newlineOffset = 1;
-            }
-            const firstChar: string = iCalString.charAt(lastPosition);
-            if (firstChar === ' ' || firstChar === '\n' || firstChar === '\t') {
-                iString += iCalString.slice(lastPosition + 1, position - newlineOffset);
-            } else {
-                if (iString) {
-                    iCalData = this.updateEventData(iString, iCalData);
-                }
-                iString = iCalString.slice(lastPosition, position - newlineOffset);
-            }
-            lastPosition = position;
-        } while (position !== iStringLength);
-        iString = iString.trim();
-        if (iString.length) {
-            iCalData = this.updateEventData(iString, iCalData);
-        }
-        const app: Record<string, any>[] = <Record<string, any>[]>extend([], iCalData.events, null, true);
-        this.parent.addEvent(this.processOccurrence(app, iCalData.id));
-    }
-
-    private updateEventData(iString: string, iCalData: Record<string, any>): Record<string, any> {
-        const fields: EventFieldsMapping = this.parent.eventFields;
-        const SEPARATOR: string = '\r\n';
-        const id: number | string = iCalData.id;
-        const events: Array<Record<string, any>> = iCalData.events;
-        let isEvent: boolean = iCalData.isEvent;
-        let count: number = iCalData.count;
-        let curEvent: Record<string, any> = iCalData.curEvent;
-        let key: string = iCalData.key;
-        if (!isEvent && iString === 'BEGIN:VEVENT') {
-            isEvent = true;
-            curEvent = {};
-        }
-        if (isEvent && iString === 'END:VEVENT') {
-            isEvent = false;
-            events.push(curEvent);
-            curEvent = null;
-        }
-        if (isEvent) {
-            const index: number = iString.indexOf(':');
-            let type: string = iString.substring(0, index).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
-            let value: string = iString.substring(index + 1, iString.length).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
-            if (iString.indexOf('SUMMARY') !== -1) {
-                type = 'SUMMARY';
-            }
-            if (iString.indexOf('DTSTART') !== -1) {
-                curEvent[fields.startTime] = this.dateParsing(iString);
-                curEvent[fields.isAllDay] = this.allDay;
-                this.allDay = false;
-            } else if (iString.indexOf('DTEND') !== -1) {
-                curEvent[fields.endTime] = this.dateParsing(iString);
-            } else if (iString.indexOf('EXDATE') !== -1) {
-                value = getRecurrenceStringFromDate(this.dateParsing(iString));
-                curEvent[fields.recurrenceException] = isNullOrUndefined(curEvent[fields.recurrenceException]) ?
-                    value : curEvent[fields.recurrenceException] + ',' + value;
-            } else if (iString.indexOf('RECURRENCE-ID') !== -1) {
-                value = getRecurrenceStringFromDate(this.dateParsing(iString));
-                curEvent[fields.recurrenceException] = value;
-                curEvent[fields.recurrenceID] = value;
-            } else {
-                key = type || key;
-                switch (key) {
-                case 'BEGIN':
-                    break;
-                case 'UID':
-                    curEvent[`${type}`] = value;
-                    if (typeof (id) == 'number') {
-                        curEvent[fields.id] = parseInt(value, 10);
-                        if (isNaN(curEvent[fields.id])) {
-                            curEvent[fields.id] = id + count;
-                            count++;
-                        }
-                    } else {
-                        curEvent[fields.id] = value;
-                    }
-                    break;
-                case 'SUMMARY':
-                    curEvent[fields.subject] = this.getFormattedString(value);
-                    break;
-                case 'LOCATION':
-                    curEvent[fields.location] = this.getFormattedString(value);
-                    break;
-                case 'DESCRIPTION':
-                    if (curEvent[fields.description]) {
-                        curEvent[fields.description] = this.getFormattedString(curEvent[fields.description] + SEPARATOR + value);
-                    } else {
-                        curEvent[fields.description] = this.getFormattedString(value);
-                    }
-                    break;
-                case 'ISREADONLY':
-                    curEvent[fields.isReadonly] = (value.indexOf('true') > -1);
-                    break;
-                case 'RRULE':
-                    curEvent[fields.recurrenceRule] = value;
-                    break;
-                default:
-                    if (this.parent.resourceCollection.length > 0) {
-                        const resData: Record<string, any>[] =
-                                this.parent.resourceCollection.filter((data: Record<string, any>) => data.field === type);
-                        curEvent[`${type}`] = (resData.length > 0 && (typeof (resData[0].dataSource[0][resData[0].idField]) == 'number')) ? parseInt(value, 10) : value;
-                    } else {
-                        curEvent[`${type}`] = value;
-                    }
-                }
-            }
-        }
-        return { isEvent, curEvent, id, count, events, key };
-    }
-
-    private processOccurrence(app: Record<string, any>[], maxId: number | string): Record<string, any>[] {
-        const appoint: Record<string, any>[] = [];
-        const uId: string = 'UID';
-        const fields: EventFieldsMapping = this.parent.eventFields;
-        const appointmentIds: number[] = [];
-        this.parent.eventsData.forEach((eventObj: Record<string, any>) => {
-            appointmentIds.push(eventObj[fields.id]);
-        });
-        app.forEach((eventObj: Record<string, any>) => {
-            let parentObj: Record<string, any>;
-            let id: number | string;
-            // eslint-disable-next-line no-prototype-builtins
-            if (!eventObj.hasOwnProperty(fields.recurrenceID)) {
-                parentObj = eventObj;
-                id = eventObj[fields.id] as string;
-            }
-            if (appointmentIds.indexOf(eventObj[fields.id]) < 0) {
-                const data: Record<string, any>[] = app.filter((data: Record<string, any>) => data.UID === eventObj[`${uId}`]);
-                if (data.length > 1 && isNullOrUndefined(eventObj[fields.recurrenceID])) {
-                    id = typeof (maxId) === 'number' ? maxId++ : id;
-                    for (let i: number = 0; i < data.length; i++) {
-                        // eslint-disable-next-line no-prototype-builtins
-                        if (data[parseInt(i.toString(), 10)].hasOwnProperty(fields.recurrenceID)) {
-                            const exdate: string = data[parseInt(i.toString(), 10)][fields.recurrenceID] as string;
-                            data[parseInt(i.toString(), 10)][fields.id] = typeof (maxId) === 'number' ? maxId++ : this.parent.eventBase.generateGuid();
-                            data[parseInt(i.toString(), 10)][fields.recurrenceID] = id;
-                            data[parseInt(i.toString(), 10)][fields.recurrenceException] = null;
-                            parentObj[fields.recurrenceException] =
-                                this.getExcludeDateString(parentObj[fields.recurrenceException], exdate);
-                            delete data[parseInt(i.toString(), 10)][`${uId}`];
-                            appoint.push(data[parseInt(i.toString(), 10)]);
-                        }
-                    }
-                    delete parentObj[`${uId}`];
-                    parentObj[fields.id] = id;
-                    appoint.push(parentObj);
-                    // eslint-disable-next-line no-prototype-builtins
-                } else if (!eventObj.hasOwnProperty(fields.recurrenceID)) {
-                    delete eventObj[`${uId}`];
-                    eventObj[fields.id] = typeof (maxId) === 'number' ? maxId++ : id;
-                    appoint.push(eventObj);
-                }
-            }
-        });
-        return appoint;
-    }
-
-    private getExcludeDateString(parentException: string, occurrenceException: string): string {
-        if (isNullOrUndefined(parentException)) {
-            return occurrenceException;
-        } else if (isNullOrUndefined(occurrenceException)) {
-            return parentException;
-        }
-        const parentExDate: string[] = parentException.split(',').map((x: string) => x.split('T')[0]);
-        const childExDate: string[] = occurrenceException.split(',').map((x: string) => x.split('T')[0]);
-        const exDate: string[] = parentExDate.filter((x: string) => childExDate.indexOf(x) > -1);
-        if (exDate.length > 0) {
-            return parentException;
-        }
-        return parentException + ',' + occurrenceException;
-    }
-
-    private getFormattedString(value: string): string {
-        value = value || '';
-        // eslint-disable-next-line no-useless-escape
-        return (value.replace(/\\\,/g, ',').replace(/\\\;/g, ';').replace(/\\[nN]/g, '\n').replace(/\\\\/g, '\\'));
-    }
-
-    private dateParsing(element: string): Date {
-        const split: string[] = element.split(':');
-        const value: string = split[split.length - 1];
-        let newDate: Date = new Date(this.getFormattedString(value));
-        if (element && (element.indexOf('VALUE=DATE') > -1 || element.indexOf('RECURRENCE-ID;TZID') > -1)) {
-            const data: string[] = /^(\d{4})(\d{2})(\d{2})$/.exec(value);
-            if (data !== null) {
-                newDate = new Date(parseInt(data[1], 10), parseInt(data[2], 10) - 1, parseInt(data[3], 10));
-            }
-            if (element.indexOf('DTSTART') > -1) {
-                this.allDay = true;
-            }
-        }
-        const data: string[] = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(Z)?$/.exec(value);
-        if (data !== null) {
-            if (data[7] === 'Z') {
-                newDate = new Date(Date.UTC(
-                    parseInt(data[1], 10),
-                    parseInt(data[2], 10) - 1,
-                    parseInt(data[3], 10),
-                    parseInt(data[4], 10),
-                    parseInt(data[5], 10),
-                    parseInt(data[6], 10)
-                ));
-            } else {
-                newDate = new Date(
-                    parseInt(data[1], 10),
-                    parseInt(data[2], 10) - 1,
-                    parseInt(data[3], 10),
-                    parseInt(data[4], 10),
-                    parseInt(data[5], 10),
-                    parseInt(data[6], 10)
-                );
-            }
-        }
-        return newDate;
-    }
-
-    protected getModuleName(): string {
-        return 'iCalendarImport';
-    }
-
-    public destroy(): void {
-        if (!this.parent || this.parent && this.parent.isDestroyed) { return; }
-    }
-
-}

package/dist/ts/schedule/exports/excel-export.d.ts

@@ -1,14 +0,0 @@
-import { Schedule } from '../base/schedule';
-import { ExportOptions } from '../base/interface';
-/**
- * Excel Export Module
- */
-export declare class ExcelExport {
-    private parent;
-    constructor(parent: Schedule);
-    initializeExcelExport(excelExportOptions?: ExportOptions): void;
-    private processWorkbook;
-    private getExportColumns;
-    protected getModuleName(): string;
-    destroy(): void;
-}

package/dist/ts/schedule/exports/excel-export.ts

@@ -1,89 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Workbook, Worksheet, Worksheets, Column } from '@syncfusion/ej2-excel-export';
-import { Schedule } from '../base/schedule';
-import { ExcelFormat } from '../base/type';
-import { ExcelExportEventArgs, ExportFieldInfo, ExportOptions } from '../base/interface';
-import { extend, isNullOrUndefined } from '@syncfusion/ej2-base';
-import * as events from '../base/constant';
-
-/**
- * Excel Export Module
- */
-
-export class ExcelExport {
-    private parent: Schedule;
-
-    constructor(parent: Schedule) {
-        this.parent = parent;
-    }
-
-    public initializeExcelExport(excelExportOptions: ExportOptions = {}): void {
-        const exportColumns: ExportFieldInfo[] = this.getExportColumns(excelExportOptions);
-        const exportName: string = excelExportOptions.fileName || 'Schedule';
-        const exportType: ExcelFormat = excelExportOptions.exportType || 'xlsx';
-        const isIncludeOccurrences: boolean = excelExportOptions.includeOccurrences || false;
-        let separator: string;
-        if (!isNullOrUndefined(excelExportOptions.separator) && excelExportOptions.separator !== ',') {
-            separator = excelExportOptions.separator;
-        }
-        let eventCollection: Record<string, any>[];
-        if (excelExportOptions.customData) {
-            eventCollection = !isIncludeOccurrences ? excelExportOptions.customData :
-                this.parent.eventBase.getProcessedEvents(excelExportOptions.customData);
-        } else {
-            eventCollection = !isIncludeOccurrences ? this.parent.eventsData : this.parent.eventsProcessed;
-        }
-        this.processWorkbook(exportColumns, exportName, exportType, eventCollection, separator);
-    }
-
-    private processWorkbook(fields: ExportFieldInfo[], name: string, type: ExcelFormat, eventCollection: Record<string, any>[],
-                            separator: string): void {
-        const columns: Column[] = [];
-        const rows: Record<string, any>[] = [];
-        const columnHeader: Record<string, any>[] = [];
-        fields.forEach((field: ExportFieldInfo, i: number) => { columns.push({ index: i + 1, width: (field.name === 'Id' ? 50 : 150) }); });
-        const style: Record<string, any> = { fontSize: 12, borders: { color: '#E0E0E0' }, bold: true };
-        fields.forEach((field: ExportFieldInfo, i: number) => { columnHeader.push({ index: i + 1, value: field.text, style: style }); });
-        rows.push({ index: 1, cells: columnHeader });
-        eventCollection.forEach((event: Record<string, any>, i: number) => {
-            const columnData: Record<string, any>[] = [];
-            fields.forEach((field: ExportFieldInfo, n: number) => {
-                let columnRule: Record<string, any> = { index: n + 1, value: event[field.name] || '' };
-                if (field.name === this.parent.eventFields.startTime || field.name === this.parent.eventFields.endTime) {
-                    const styleRule: Record<string, any> = { fontSize: 12, numberFormat: 'm/d/yyyy h:mm a' };
-                    columnRule = extend({}, columnRule, { style: styleRule }, true) as Record<string, any>;
-                }
-                columnData.push(columnRule);
-            });
-            rows.push({ index: i + 2, cells: columnData });
-        });
-        const workSheet: Worksheets = [{ columns: columns, rows: rows } as Worksheet];
-        const args: ExcelExportEventArgs = { cancel: false, worksheets: workSheet };
-        this.parent.trigger(events.excelExport, args, (args: ExcelExportEventArgs) => {
-            if (args.cancel) {
-                return;
-            }
-            const book: Workbook = new Workbook({ worksheets: args.worksheets }, type, this.parent.locale, undefined, separator);
-            book.save(name + '.' + type);
-        });
-    }
-
-    private getExportColumns(exportOptions: ExportOptions): ExportFieldInfo[] {
-        const exportColumns: ExportFieldInfo[] = exportOptions.fieldsInfo || [];
-        if (exportColumns.length === 0) {
-            const fields: string[] = exportOptions.fields || Object.keys(this.parent.eventFields).map((field: string) =>
-                (<Record<string, any>>this.parent.eventFields)[`${field}`]) as string[];
-            fields.forEach((field: string) => { exportColumns.push({ name: field, text: field }); });
-        }
-        return exportColumns;
-    }
-
-    protected getModuleName(): string {
-        return 'excelExport';
-    }
-
-    public destroy(): void {
-        this.parent = null;
-    }
-
-}

package/dist/ts/schedule/exports/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Exporting modules
- */
-export * from './calendar-export';
-export * from './calendar-import';
-export * from './excel-export';
-export * from './print';

package/dist/ts/schedule/exports/index.ts

@@ -1,7 +0,0 @@
-/**
- * Exporting modules
- */
-export * from './calendar-export';
-export * from './calendar-import';
-export * from './excel-export';
-export * from './print';

package/dist/ts/schedule/exports/print.d.ts

@@ -1,20 +0,0 @@
-import { Schedule } from '../base/schedule';
-import { ScheduleModel } from '../base/schedule-model';
-/**
- * Print Module
- */
-export declare class Print {
-    private parent;
-    private printInstance;
-    private printWindow;
-    constructor(parent: Schedule);
-    print(printOptions?: ScheduleModel): void;
-    private printScheduler;
-    private printSchedulerWithModel;
-    private getPrintScheduleModel;
-    private contentReady;
-    private closePrintWindow;
-    private printCleanup;
-    protected getModuleName(): string;
-    destroy(): void;
-}