update fullcalendar

1 files changed, 225 insertions, 0 deletions

diff --git a/library/fullcalendar/packages/icalendar/index.global.js b/library/fullcalendar/packages/icalendar/index.global.js
new file mode 100644
index 000000000..c92e09e54
--- /dev/null
+++ b/library/fullcalendar/packages/icalendar/index.global.js
@@ -0,0 +1,225 @@
+/*!
+FullCalendar iCalendar Plugin v6.0.3
+Docs & License: https://fullcalendar.io/docs/icalendar
+(c) 2022 Adam Shaw
+*/
+FullCalendar.ICalendar = (function (exports, core, internal, ICAL) {
+    'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return n;
+    }
+
+    var ICAL__namespace = /*#__PURE__*/_interopNamespace(ICAL);
+
+    /* eslint-disable */
+    class IcalExpander {
+        constructor(opts) {
+            this.maxIterations = opts.maxIterations != null ? opts.maxIterations : 1000;
+            this.skipInvalidDates = opts.skipInvalidDates != null ? opts.skipInvalidDates : false;
+            this.jCalData = ICAL__namespace.parse(opts.ics);
+            this.component = new ICAL__namespace.Component(this.jCalData);
+            this.events = this.component.getAllSubcomponents('vevent').map(vevent => new ICAL__namespace.Event(vevent));
+            if (this.skipInvalidDates) {
+                this.events = this.events.filter((evt) => {
+                    try {
+                        evt.startDate.toJSDate();
+                        evt.endDate.toJSDate();
+                        return true;
+                    }
+                    catch (err) {
+                        // skipping events with invalid time
+                        return false;
+                    }
+                });
+            }
+        }
+        between(after, before) {
+            function isEventWithinRange(startTime, endTime) {
+                return (!after || endTime >= after.getTime()) &&
+                    (!before || startTime <= before.getTime());
+            }
+            function getTimes(eventOrOccurrence) {
+                const startTime = eventOrOccurrence.startDate.toJSDate().getTime();
+                let endTime = eventOrOccurrence.endDate.toJSDate().getTime();
+                // If it is an all day event, the end date is set to 00:00 of the next day
+                // So we need to make it be 23:59:59 to compare correctly with the given range
+                if (eventOrOccurrence.endDate.isDate && (endTime > startTime)) {
+                    endTime -= 1;
+                }
+                return { startTime, endTime };
+            }
+            const exceptions = [];
+            this.events.forEach((event) => {
+                if (event.isRecurrenceException())
+                    exceptions.push(event);
+            });
+            const ret = {
+                events: [],
+                occurrences: [],
+            };
+            this.events.filter(e => !e.isRecurrenceException()).forEach((event) => {
+                const exdates = [];
+                event.component.getAllProperties('exdate').forEach((exdateProp) => {
+                    const exdate = exdateProp.getFirstValue();
+                    exdates.push(exdate.toJSDate().getTime());
+                });
+                // Recurring event is handled differently
+                if (event.isRecurring()) {
+                    const iterator = event.iterator();
+                    let next;
+                    let i = 0;
+                    do {
+                        i += 1;
+                        next = iterator.next();
+                        if (next) {
+                            const occurrence = event.getOccurrenceDetails(next);
+                            const { startTime, endTime } = getTimes(occurrence);
+                            const isOccurrenceExcluded = exdates.indexOf(startTime) !== -1;
+                            // TODO check that within same day?
+                            const exception = exceptions.find(ex => ex.uid === event.uid && ex.recurrenceId.toJSDate().getTime() === occurrence.startDate.toJSDate().getTime());
+                            // We have passed the max date, stop
+                            if (before && startTime > before.getTime())
+                                break;
+                            // Check that we are within our range
+                            if (isEventWithinRange(startTime, endTime)) {
+                                if (exception) {
+                                    ret.events.push(exception);
+                                }
+                                else if (!isOccurrenceExcluded) {
+                                    ret.occurrences.push(occurrence);
+                                }
+                            }
+                        }
+                    } while (next && (!this.maxIterations || i < this.maxIterations));
+                    return;
+                }
+                // Non-recurring event:
+                const { startTime, endTime } = getTimes(event);
+                if (isEventWithinRange(startTime, endTime))
+                    ret.events.push(event);
+            });
+            return ret;
+        }
+        before(before) {
+            return this.between(undefined, before);
+        }
+        after(after) {
+            return this.between(after);
+        }
+        all() {
+            return this.between();
+        }
+    }
+
+    const eventSourceDef = {
+        parseMeta(refined) {
+            if (refined.url && refined.format === 'ics') {
+                return {
+                    url: refined.url,
+                    format: 'ics',
+                };
+            }
+            return null;
+        },
+        fetch(arg, successCallback, errorCallback) {
+            let meta = arg.eventSource.meta;
+            let { internalState } = meta;
+            /*
+            NOTE: isRefetch is a HACK. we would do the recurring-expanding in a separate plugin hook,
+            but we couldn't leverage built-in allDay-guessing, among other things.
+            */
+            if (!internalState || arg.isRefetch) {
+                internalState = meta.internalState = {
+                    response: null,
+                    iCalExpanderPromise: fetch(meta.url, { method: 'GET' }).then((response) => {
+                        return response.text().then((icsText) => {
+                            internalState.response = response;
+                            return new IcalExpander({
+                                ics: icsText,
+                                skipInvalidDates: true,
+                            });
+                        });
+                    }),
+                };
+            }
+            internalState.iCalExpanderPromise.then((iCalExpander) => {
+                successCallback({
+                    rawEvents: expandICalEvents(iCalExpander, arg.range),
+                    response: internalState.response,
+                });
+            }, errorCallback);
+        },
+    };
+    function expandICalEvents(iCalExpander, range) {
+        // expand the range. because our `range` is timeZone-agnostic UTC
+        // or maybe because ical.js always produces dates in local time? i forget
+        let rangeStart = internal.addDays(range.start, -1);
+        let rangeEnd = internal.addDays(range.end, 1);
+        let iCalRes = iCalExpander.between(rangeStart, rangeEnd); // end inclusive. will give extra results
+        let expanded = [];
+        // TODO: instead of using startDate/endDate.toString to communicate allDay,
+        // we can query startDate/endDate.isDate. More efficient to avoid formatting/reparsing.
+        // single events
+        for (let iCalEvent of iCalRes.events) {
+            expanded.push(Object.assign(Object.assign({}, buildNonDateProps(iCalEvent)), { start: iCalEvent.startDate.toString(), end: (specifiesEnd(iCalEvent) && iCalEvent.endDate)
+                    ? iCalEvent.endDate.toString()
+                    : null }));
+        }
+        // recurring event instances
+        for (let iCalOccurence of iCalRes.occurrences) {
+            let iCalEvent = iCalOccurence.item;
+            expanded.push(Object.assign(Object.assign({}, buildNonDateProps(iCalEvent)), { start: iCalOccurence.startDate.toString(), end: (specifiesEnd(iCalEvent) && iCalOccurence.endDate)
+                    ? iCalOccurence.endDate.toString()
+                    : null }));
+        }
+        return expanded;
+    }
+    function buildNonDateProps(iCalEvent) {
+        return {
+            title: iCalEvent.summary,
+            url: extractEventUrl(iCalEvent),
+            extendedProps: {
+                location: iCalEvent.location,
+                organizer: iCalEvent.organizer,
+                description: iCalEvent.description,
+            },
+        };
+    }
+    function extractEventUrl(iCalEvent) {
+        let urlProp = iCalEvent.component.getFirstProperty('url');
+        return urlProp ? urlProp.getFirstValue() : '';
+    }
+    function specifiesEnd(iCalEvent) {
+        return Boolean(iCalEvent.component.getFirstProperty('dtend')) ||
+            Boolean(iCalEvent.component.getFirstProperty('duration'));
+    }
+
+    var plugin = core.createPlugin({
+        name: '@fullcalendar/icalendar',
+        eventSourceDefs: [eventSourceDef],
+    });
+
+    core.globalPlugins.push(plugin);
+
+    exports["default"] = plugin;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
+
+})({}, FullCalendar, FullCalendar.Internal, ICAL);