@koine/react 2.0.0-beta.2 → 2.0.0-beta.5

package/Calendar/utils.js

@@ -1,215 +1,252 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processEventsInView = exports.addCalendarEvents = exports.mergeCalendarEvents = exports.isTodayInView = exports.getNextDate = exports.getPrevDate = exports.getEndDate = exports.getStartDate = exports.getDisplayTime = exports.getEventTimestamp = void 0;
-var tslib_1 = require("tslib");
-var isWithinInterval_1 = tslib_1.__importDefault(require("date-fns/isWithinInterval"));
-var endOfMonth_1 = tslib_1.__importDefault(require("date-fns/endOfMonth"));
-var startOfWeek_1 = tslib_1.__importDefault(require("date-fns/startOfWeek"));
-var endOfWeek_1 = tslib_1.__importDefault(require("date-fns/endOfWeek"));
-var subMonths_1 = tslib_1.__importDefault(require("date-fns/subMonths"));
-var addMonths_1 = tslib_1.__importDefault(require("date-fns/addMonths"));
-var subWeeks_1 = tslib_1.__importDefault(require("date-fns/subWeeks"));
-var addWeeks_1 = tslib_1.__importDefault(require("date-fns/addWeeks"));
-var addDays_1 = tslib_1.__importDefault(require("date-fns/addDays"));
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getEventTimestamp: function() {
+        return getEventTimestamp;
+    },
+    getDisplayTime: function() {
+        return getDisplayTime;
+    },
+    getStartDate: function() {
+        return getStartDate;
+    },
+    getEndDate: function() {
+        return getEndDate;
+    },
+    getPrevDate: function() {
+        return getPrevDate;
+    },
+    getNextDate: function() {
+        return getNextDate;
+    },
+    isTodayInView: function() {
+        return isTodayInView;
+    },
+    mergeCalendarEvents: function() {
+        return mergeCalendarEvents;
+    },
+    addCalendarEvents: function() {
+        return addCalendarEvents;
+    },
+    processEventsInView: function() {
+        return processEventsInView;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _addDays = /*#__PURE__*/ _interop_require_default._(require("date-fns/addDays"));
+const _addMonths = /*#__PURE__*/ _interop_require_default._(require("date-fns/addMonths"));
+const _addWeeks = /*#__PURE__*/ _interop_require_default._(require("date-fns/addWeeks"));
+const _endOfMonth = /*#__PURE__*/ _interop_require_default._(require("date-fns/endOfMonth"));
+const _endOfWeek = /*#__PURE__*/ _interop_require_default._(require("date-fns/endOfWeek"));
+const _isWithinInterval = /*#__PURE__*/ _interop_require_default._(require("date-fns/isWithinInterval"));
+const _startOfWeek = /*#__PURE__*/ _interop_require_default._(require("date-fns/startOfWeek"));
+const _subMonths = /*#__PURE__*/ _interop_require_default._(require("date-fns/subMonths"));
+const _subWeeks = /*#__PURE__*/ _interop_require_default._(require("date-fns/subWeeks"));
 function getEventTimestamp(dateLike) {
-    var date = new Date(dateLike);
+    const date = new Date(dateLike);
     date.setHours(0, 0, 0, 0);
     return date.valueOf() / 1000;
 }
-exports.getEventTimestamp = getEventTimestamp;
 function getDisplayTime(date) {
-    return (date.getHours() +
-        ":" +
-        "0".repeat(2 - date.getMinutes().toString().length) +
-        date.getMinutes());
+    return date.getHours() + ":" + "0".repeat(2 - date.getMinutes().toString().length) + date.getMinutes();
 }
-exports.getDisplayTime = getDisplayTime;
 function getStartDate(date, view) {
     date.setHours(0, 0, 0);
     if (view === "month") {
         date.setDate(1);
-    }
-    else if (view === "week") {
-        date = (0, startOfWeek_1.default)(date, { weekStartsOn: 1 });
+    } else if (view === "week") {
+        date = (0, _startOfWeek.default)(date, {
+            weekStartsOn: 1
+        });
     }
     return date;
 }
-exports.getStartDate = getStartDate;
 function getEndDate(start, view) {
-    var end = start;
+    let end = start;
     if (view === "month") {
-        end = (0, endOfMonth_1.default)(start);
-    }
-    else if (view === "week") {
-        end = (0, endOfWeek_1.default)(start, { weekStartsOn: 1 });
+        end = (0, _endOfMonth.default)(start);
+    } else if (view === "week") {
+        end = (0, _endOfWeek.default)(start, {
+            weekStartsOn: 1
+        });
     }
     end.setHours(23, 59, 59);
     return end;
 }
-exports.getEndDate = getEndDate;
 function getPrevDate(date, view) {
     if (view === "month") {
-        return (0, subMonths_1.default)(date, 1);
+        return (0, _subMonths.default)(date, 1);
     }
-    return (0, subWeeks_1.default)(date, 1);
+    return (0, _subWeeks.default)(date, 1);
 }
-exports.getPrevDate = getPrevDate;
 function getNextDate(date, view) {
     if (view === "month") {
-        return (0, addMonths_1.default)(date, 1);
+        return (0, _addMonths.default)(date, 1);
     }
-    return (0, addWeeks_1.default)(date, 1);
+    return (0, _addWeeks.default)(date, 1);
 }
-exports.getNextDate = getNextDate;
 function isTodayInView(start, end) {
-    return (0, isWithinInterval_1.default)(new Date(), { start: start, end: end });
+    return (0, _isWithinInterval.default)(new Date(), {
+        start,
+        end
+    });
 }
-exports.isTodayInView = isTodayInView;
 function mergeCalendarEvents(first, second) {
-    var all = {};
+    const all = {};
     addCalendarEvents(first, all);
     addCalendarEvents(second, all);
     return all;
 }
-exports.mergeCalendarEvents = mergeCalendarEvents;
 function addCalendarEvents(toAdd, toExtend) {
-    for (var id in toAdd) {
-        var event_1 = toAdd[id];
-        toExtend[id] = event_1;
+    for(const id in toAdd){
+        const event = toAdd[id];
+        toExtend[id] = event;
     }
     return toExtend;
 }
-exports.addCalendarEvents = addCalendarEvents;
 function getEventsByTimestamp(events) {
-    var output = {};
-    var _loop_1 = function (uid) {
-        var event_2 = events[uid];
-        event_2.days.forEach(function (timestamp) {
-            output[timestamp] = (output[timestamp] || {});
-            output[timestamp][uid] = event_2;
+    const output = {};
+    for(const uid in events){
+        const event = events[uid];
+        event.days.forEach((timestamp)=>{
+            output[timestamp] = output[timestamp] || {};
+            output[timestamp][uid] = event;
         });
-    };
-    for (var uid in events) {
-        _loop_1(uid);
     }
     return output;
 }
 function getSortedEvents(events) {
-    var output = [];
-    for (var uid in events) {
+    const output = [];
+    for(const uid in events){
         output.push(events[uid]);
     }
     // sort events first multi, then all day then by start then by created date
-    output.sort(function (a, b) {
-        var multi = Number(b.multi) - Number(a.multi);
-        var allDay = Number(b.allDay) - Number(a.allDay);
-        var start = a.start.getTime() - b.start.getTime();
-        var created = a.created.getTime() - b.created.getTime();
+    output.sort((a, b)=>{
+        const multi = Number(b.multi) - Number(a.multi);
+        const allDay = Number(b.allDay) - Number(a.allDay);
+        const start = a.start.getTime() - b.start.getTime();
+        const created = a.created.getTime() - b.created.getTime();
         return multi || allDay || start || created;
     });
     return output;
 }
-var FREE_SLOT = 0;
-var BUSY_SLOT = 1;
+const FREE_SLOT = 0;
+const BUSY_SLOT = 1;
 function processEventsInView(eventsMap, calendarView, month, weeks) {
-    var eventsByTimestamp = getEventsByTimestamp(eventsMap);
-    var eventsList = getSortedEvents(eventsMap);
-    var todayDate = new Date();
-    var todayTimestamp = getEventTimestamp(todayDate);
-    var startedAtTopMap = {};
-    var viewWeeks = [];
-    var _loop_2 = function (weekIdx) {
-        var viewWeek = {
-            props: { key: "week.".concat(weekIdx) },
-            days: [],
+    const eventsByTimestamp = getEventsByTimestamp(eventsMap);
+    const eventsList = getSortedEvents(eventsMap);
+    const todayDate = new Date();
+    const todayTimestamp = getEventTimestamp(todayDate);
+    const startedAtTopMap = {};
+    const viewWeeks = [];
+    for(let weekIdx = 0; weekIdx < weeks.length; weekIdx++){
+        const viewWeek = {
+            props: {
+                key: `week.${weekIdx}`
+            },
+            days: []
         };
-        var weekStartDate = weeks[weekIdx];
-        var weekStartDay = weekStartDate.getDate();
-        var weekStartTimestamp = getEventTimestamp(new Date(weekStartDate));
-        var weekEndTimestamp = getEventTimestamp((0, addDays_1.default)(new Date(weekStartDate), 6));
-        for (var dayNumber = 0; dayNumber < 7; dayNumber++) {
-            var dayDate = new Date(new Date(weekStartDate).setDate(weekStartDay + dayNumber));
-            var dayTimestamp = getEventTimestamp(dayDate);
-            var $isToday = todayTimestamp === dayTimestamp;
-            var $isOutOfRange = calendarView === "month" && dayDate.getMonth() !== month;
-            var contextualProps = {
-                $isToday: $isToday,
-                $isOutOfRange: $isOutOfRange,
+        const weekStartDate = weeks[weekIdx];
+        const weekStartDay = weekStartDate.getDate();
+        const weekStartTimestamp = getEventTimestamp(new Date(weekStartDate));
+        const weekEndTimestamp = getEventTimestamp((0, _addDays.default)(new Date(weekStartDate), 6));
+        for(let dayNumber = 0; dayNumber < 7; dayNumber++){
+            const dayDate = new Date(new Date(weekStartDate).setDate(weekStartDay + dayNumber));
+            const dayTimestamp = getEventTimestamp(dayDate);
+            const $isToday = todayTimestamp === dayTimestamp;
+            const $isOutOfRange = calendarView === "month" && dayDate.getMonth() !== month;
+            const contextualProps = {
+                $isToday,
+                $isOutOfRange
             };
-            var viewDay = {
-                props: tslib_1.__assign({ key: "day.".concat(dayTimestamp) }, contextualProps),
+            const viewDay = {
+                props: {
+                    key: `day.${dayTimestamp}`,
+                    ...contextualProps
+                },
                 timestamp: dayTimestamp + "",
                 label: dayDate.getDate() + "",
-                events: [],
+                events: []
             };
             // check that we have events in this day
-            if (eventsByTimestamp === null || eventsByTimestamp === void 0 ? void 0 : eventsByTimestamp[dayTimestamp]) {
-                var verticalSlots = Object.keys(eventsByTimestamp[dayTimestamp]).map(function () { return FREE_SLOT; });
-                for (var eventIdx = 0; eventIdx < eventsList.length; eventIdx++) {
-                    var event_3 = eventsList[eventIdx];
-                    var width = 1;
-                    var top_1 = 0;
-                    var firstOfMulti = void 0;
-                    if (!event_3.daysMap[dayTimestamp]) {
+            if (eventsByTimestamp?.[dayTimestamp]) {
+                const verticalSlots = Object.keys(eventsByTimestamp[dayTimestamp]).map(()=>FREE_SLOT);
+                for(let eventIdx = 0; eventIdx < eventsList.length; eventIdx++){
+                    const event = eventsList[eventIdx];
+                    let width = 1;
+                    let top = 0;
+                    let firstOfMulti;
+                    if (!event.daysMap[dayTimestamp]) {
                         continue;
                     }
                     // only for multi days events:
-                    if (event_3.multi) {
+                    if (event.multi) {
                         // filter out the days outside of the current week view to avoid
                         // making a multi-days event chip wider than the week row or shorter
                         // than it should be (when event spans across weeks)
-                        width = event_3.days.filter(function (t) { return t >= weekStartTimestamp && t <= weekEndTimestamp; }).length;
+                        width = event.days.filter((t)=>t >= weekStartTimestamp && t <= weekEndTimestamp).length;
                         // flag the first day of multi-days events, consider that an event
                         // might start in a day earlier (hence outside) of the current
                         // week/month view, so we always check for Mondays (dayNumber === 0)
-                        if (event_3.days.indexOf(dayTimestamp) === 0 || dayNumber === 0) {
+                        if (event.days.indexOf(dayTimestamp) === 0 || dayNumber === 0) {
                             firstOfMulti = true;
                         }
                     }
                     // if we already have the information on when the event has been
                     // vertically positioned use that index
-                    if (startedAtTopMap[event_3.uid]) {
-                        top_1 = startedAtTopMap[event_3.uid];
-                    }
-                    else {
+                    if (startedAtTopMap[event.uid]) {
+                        top = startedAtTopMap[event.uid];
+                    } else {
                         // now look for a free slot and use its index as `top`
-                        for (var verticalIdx = 0; verticalIdx < verticalSlots.length; verticalIdx++) {
-                            var freeOrBusy = verticalSlots[verticalIdx];
+                        for(let verticalIdx = 0; verticalIdx < verticalSlots.length; verticalIdx++){
+                            const freeOrBusy = verticalSlots[verticalIdx];
                             if (freeOrBusy !== BUSY_SLOT) {
-                                top_1 = verticalIdx;
+                                top = verticalIdx;
                                 break;
                             }
                         }
                     }
                     // now mark the slot as busy
-                    verticalSlots[top_1] = BUSY_SLOT;
+                    verticalSlots[top] = BUSY_SLOT;
                     // store the slot vertical position consistently for multi-days events
                     if (firstOfMulti) {
-                        startedAtTopMap[event_3.uid] = top_1;
+                        startedAtTopMap[event.uid] = top;
                     }
                     // push the event, they will be sorted later
-                    viewDay.events.push(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({ key: "event.".concat(dayTimestamp, "-").concat(top_1) }, contextualProps), event_3), { isPast: todayDate > event_3.end, firstOfMulti: firstOfMulti, top: top_1, width: width }));
+                    viewDay.events.push({
+                        key: `event.${dayTimestamp}-${top}`,
+                        ...contextualProps,
+                        ...event,
+                        isPast: todayDate > event.end,
+                        firstOfMulti,
+                        top,
+                        width
+                    });
                 }
                 // fill the empty slots with events' placeholders
-                for (var i = 0; i < verticalSlots.length; i++) {
+                for(let i = 0; i < verticalSlots.length; i++){
                     if (verticalSlots[i] !== BUSY_SLOT) {
                         viewDay.events.push({
-                            key: "event.".concat(dayTimestamp, "-").concat(i, "}"),
+                            key: `event.${dayTimestamp}-${i}}`,
                             placeholder: true,
-                            top: i,
+                            top: i
                         });
                     }
                 }
                 // sort events and events placeholders by top position
-                viewDay.events.sort(function (a, b) { return a.top - b.top; });
+                viewDay.events.sort((a, b)=>a.top - b.top);
             }
             viewWeek.days.push(viewDay);
         }
         viewWeeks.push(viewWeek);
-    };
-    for (var weekIdx = 0; weekIdx < weeks.length; weekIdx++) {
-        _loop_2(weekIdx);
     }
     return viewWeeks;
 }
-exports.processEventsInView = processEventsInView;