@event-calendar/core 1.1.1 → 1.2.0

package/src/Auxiliary.svelte

@@ -1,7 +1,7 @@
 <script>
     import {getContext} from 'svelte';
     import {is_function} from 'svelte/internal';
-    import {debounce, toISOString, toLocalDate, toViewWithLocalDates} from '@event-calendar/common';
+    import {debounce, toISOString, toLocalDate, toViewWithLocalDates} from './lib.js';
 
     let {datesSet, _auxiliary, _activeRange, _queue, _view} = getContext('state');
 

package/src/Buttons.svelte

@@ -1,6 +1,6 @@
 <script>
     import {getContext} from 'svelte';
-    import {createDate, cloneDate, subtractDay, addDuration, subtractDuration, setMidnight} from '@event-calendar/common';
+    import {createDate, cloneDate, subtractDay, addDuration, subtractDuration, setMidnight} from './lib.js';
 
     export let buttons;
 

package/src/Calendar.svelte

@@ -16,7 +16,7 @@
         getPayload,
         flushDebounce,
         hasYScroll
-    } from '@event-calendar/common';
+    } from './lib.js';
 
     export let plugins = [];
     export let options = {};

package/src/index.js

@@ -1,3 +1,4 @@
 import Calendar from './Calendar.svelte';
 
-export {Calendar as default};
+export {Calendar as default};
+export * from './lib.js';

package/src/lib/actions.js

@@ -0,0 +1,43 @@
+import {isObject} from './utils.js';
+
+export function setContent(node, content) {
+    let actions = {
+        update(content) {
+            while (node.firstChild) {
+                node.removeChild(node.lastChild);
+            }
+            if (!isObject(content)) {
+                node.innerText = content;
+            } else if (content.domNodes) {
+                for (let child of content.domNodes) {
+                    node.appendChild(child);
+                }
+            } else if (content.html) {
+                node.innerHTML = content.html;
+            }
+        }
+    };
+    actions.update(content);
+
+    return actions;
+}
+
+/** Dispatch event occurred outside of node */
+export function outsideEvent(node, type) {
+
+    const handlePointerDown = jsEvent => {
+        if (node && !node.contains(jsEvent.target)) {
+            node.dispatchEvent(
+                new CustomEvent(type + 'outside', {detail: {jsEvent}})
+            );
+        }
+    };
+
+    document.addEventListener(type, handlePointerDown, true);
+
+    return {
+        destroy() {
+            document.removeEventListener(type, handlePointerDown, true);
+        }
+    };
+}

package/src/lib/date.js

@@ -0,0 +1,219 @@
+export const DAY_IN_SECONDS = 86400;
+
+export function createDate(input = undefined) {
+    if (input !== undefined) {
+        return input instanceof Date ? _fromLocalDate(input) : _fromISOString(input);
+    }
+
+    return _fromLocalDate(new Date());
+}
+
+export function createDuration(input) {
+    if (typeof input === 'number') {
+        input = {seconds: input};
+    } else if (typeof input === 'string') {
+        // Expected format hh[:mm[:ss]]
+        let seconds = 0, exp = 2;
+        for (let part of input.split(':', 3)) {
+            seconds += parseInt(part, 10) * Math.pow(60, exp--);
+        }
+        input = {seconds};
+    } else if (input instanceof Date) {
+        input = {hours: input.getUTCHours(), minutes: input.getUTCMinutes(), seconds: input.getUTCSeconds()};
+    }
+
+    let weeks = input.weeks || input.week || 0;
+
+    return {
+        years: input.years || input.year || 0,
+        months: input.months || input.month || 0,
+        days: weeks * 7 + (input.days || input.day || 0),
+        seconds: (input.hours || input.hour || 0) * 60 * 60 +
+            (input.minutes || input.minute || 0) * 60 +
+            (input.seconds || input.second || 0),
+        inWeeks: !!weeks
+    };
+}
+
+export function cloneDate(date) {
+    return new Date(date.getTime());
+}
+
+export function addDuration(date, duration, x = 1) {
+    date.setUTCFullYear(date.getUTCFullYear() + x * duration.years);
+    let month = date.getUTCMonth() + x * duration.months;
+    date.setUTCMonth(month);
+    month %= 12;
+    if (month < 0) {
+        month += 12;
+    }
+    while (date.getUTCMonth() !== month) {
+        subtractDay(date);
+    }
+    date.setUTCDate(date.getUTCDate() + x * duration.days);
+    date.setUTCSeconds(date.getUTCSeconds() + x * duration.seconds);
+
+    return date;
+}
+
+export function subtractDuration(date, duration, x = 1) {
+    return addDuration(date, duration, -x);
+}
+
+export function addDay(date, x = 1) {
+    date.setUTCDate(date.getUTCDate() + x);
+
+    return date;
+}
+
+export function subtractDay(date, x = 1) {
+    return addDay(date, -x);
+}
+
+export function setMidnight(date) {
+    date.setUTCHours(0, 0, 0, 0);
+
+    return date;
+}
+
+export function toLocalDate(date) {
+    return new Date(
+        date.getUTCFullYear(),
+        date.getUTCMonth(),
+        date.getUTCDate(),
+        date.getUTCHours(),
+        date.getUTCMinutes(),
+        date.getUTCSeconds()
+    );
+}
+
+export function toISOString(date) {
+    return date.toISOString().substring(0, 19);
+}
+
+export function formatRange(start, end, intl) {
+    if (start.getFullYear() !== end.getFullYear()) {
+        return intl.format(start) + ' - ' + intl.format(end);
+    }
+
+    let diff = [];
+    if (start.getMonth() !== end.getMonth()) {
+        diff.push('month');
+    }
+    if (start.getDate() !== end.getDate()) {
+        diff.push('day');
+    }
+
+    if (!diff.length) {
+        return intl.format(start);
+    }
+
+    let opts1 = intl.resolvedOptions();
+    let opts2 = {};
+    for (let key of diff) {
+        opts2[key] = opts1[key];
+    }
+    let intl2 = new Intl.DateTimeFormat(opts1.locale, opts2);
+
+    let full1 = intl.format(start);
+    let full2 = intl.format(end);
+    let part1 = intl2.format(start);
+    let part2 = intl2.format(end);
+
+    let common = _commonChunks(full1, part1, full2, part2);
+    if (common) {
+        return common.head + part1 + ' - ' + part2 + common.tail;
+    }
+
+    return full1 + ' - ' + full2;
+}
+
+export function datesEqual(date1, ...dates2) {
+    return dates2.every(date2 => date1.getTime() === date2.getTime());
+}
+
+export function nextClosestDay(date, day) {
+    let diff = day - date.getUTCDay();
+    date.setUTCDate(date.getUTCDate() + (diff >= 0 ? diff : diff + 7));
+    return date;
+}
+
+export function prevClosestDay(date, day) {
+    let diff = day - date.getUTCDay();
+    date.setUTCDate(date.getUTCDate() + (diff <= 0 ? diff : diff - 7));
+    return date;
+}
+
+/**
+ * Check whether given date is string which contains no time part
+  */
+export function noTimePart(date) {
+    return typeof date === 'string' && date.length <= 10;
+}
+
+/**
+ * Private functions
+ */
+
+function _fromLocalDate(date) {
+    return new Date(Date.UTC(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        date.getHours(),
+        date.getMinutes(),
+        date.getSeconds()
+    ));
+}
+
+function _fromISOString(str) {
+    const parts = str.match(/\d+/g);
+    return new Date(Date.UTC(
+        Number(parts[0]),
+        Number(parts[1]) - 1,
+        Number(parts[2]),
+        Number(parts[3] || 0),
+        Number(parts[4] || 0),
+        Number(parts[5] || 0)
+    ));
+}
+
+function _commonChunks(str1, substr1, str2, substr2) {
+    let i = 0;
+    while (i < str1.length) {
+        let res1;
+        [i, res1] = _cut(str1, substr1, i);
+        if (!res1) {
+            break;
+        }
+
+        let j = 0;
+        while (j < str2.length) {
+            let res2;
+            [j, res2] = _cut(str2, substr2, j);
+            if (!res2) {
+                break;
+            }
+
+            if (res1.head === res2.head && res1.tail === res2.tail) {
+                return res1;
+            }
+        }
+    }
+
+    return null
+}
+
+function _cut(str, substr, from) {
+    let start = str.indexOf(substr, from);
+    if (start >= 0) {
+        let end = start + substr.length;
+
+        return [end, {
+            head: str.substr(0, start),
+            tail: str.substr(end)
+        }];
+    }
+
+    return [-1, null];
+}

package/src/lib/debounce.js

@@ -0,0 +1,10 @@
+import {run_all} from 'svelte/internal';
+
+export function debounce(fn, handle, queueStore) {
+    queueStore.update(queue => queue.set(handle, fn));
+}
+
+export function flushDebounce(queue) {
+    run_all(queue);
+    queue.clear();
+}

package/src/lib/dom.js

@@ -0,0 +1,53 @@
+import {symbol} from './utils.js';
+
+export function createElement(tag, className, html, text) {
+    let el = document.createElement(tag);
+    el.className = className;
+    if (html) {
+        el.innerHTML = html;
+    } else if (text) {
+        el.innerText = text;
+    }
+    return el;
+}
+
+export function hasYScroll(el) {
+    return el.scrollHeight > el.clientHeight;
+}
+
+export function rect(el) {
+    return el.getBoundingClientRect();
+}
+
+export function ancestor(el, up) {
+    while (up--) {
+        el = el.parentElement;
+    }
+    return el;
+}
+
+export function height(el) {
+    return rect(el).height;
+}
+
+let payloadProp = symbol();
+export function setPayload(el, payload) {
+    el[payloadProp] = payload;
+}
+
+export function hasPayload(el) {
+    return !!el?.[payloadProp];
+}
+
+export function getPayload(el) {
+    return el[payloadProp];
+}
+
+export function getElementWithPayload(x, y) {
+    for (let el of document.elementsFromPoint(x, y)) {
+        if (hasPayload(el)) {
+            return el;
+        }
+    }
+    return null;
+}

package/src/lib/events.js

@@ -0,0 +1,224 @@
+import {addDay, datesEqual, createDate, cloneDate, setMidnight, toLocalDate, noTimePart} from './date';
+import {createElement} from './dom';
+import {assign} from './utils';
+import {toViewWithLocalDates} from './view';
+import {is_function} from 'svelte/internal';
+
+let eventId = 1;
+export function createEvents(input) {
+    return input.map(event => ({
+        id: 'id' in event ? String(event.id) : `{generated-${eventId++}}`,
+        resourceIds: Array.isArray(event.resourceIds)
+            ? event.resourceIds.map(String)
+            : ('resourceId' in event ? [String(event.resourceId)] : []),
+        allDay: event.allDay ?? (noTimePart(event.start) && noTimePart(event.end)),
+        start: createDate(event.start),
+        end: createDate(event.end),
+        title: event.title || '',
+        titleHTML: event.titleHTML || '',
+        editable: event.editable,
+        startEditable: event.startEditable,
+        durationEditable: event.durationEditable,
+        display: event.display || 'auto',
+        extendedProps: event.extendedProps || {},
+        backgroundColor: event.backgroundColor || event.color,
+        textColor: event.textColor
+    }));
+}
+
+export function createEventSources(input) {
+    return input.map(source => ({
+        events: source.events,
+        url: (source.url && source.url.trimEnd('&')) || '',
+        method: (source.method && source.method.toUpperCase()) || 'GET',
+        extraParams: source.extraParams || {}
+    }));
+}
+
+export function createEventChunk(event, start, end) {
+    return {
+        start: event.start > start ? event.start : start,
+        end: event.end < end ? event.end : end,
+        event
+    };
+}
+
+export function sortEventChunks(chunks) {
+    // Sort by start date
+    chunks.sort((a, b) => {
+        if (a.start < b.start) {
+            return -1;
+        }
+        if (a.start > b.start) {
+            return 1;
+        }
+        return 0;
+    });
+}
+
+/**
+ * Prepare event chunks for month view and all-day slot in week view
+ */
+export function prepareEventChunks(chunks, hiddenDays) {
+    let longChunks = {};
+
+    if (chunks.length) {
+        sortEventChunks(chunks);
+
+        let prevChunk;
+        for (let chunk of chunks) {
+            let dates = [];
+            let date = setMidnight(cloneDate(chunk.start));
+            while (chunk.end > date) {
+                if (!hiddenDays.includes(date.getUTCDay())) {
+                    dates.push(cloneDate(date));
+                    if (dates.length > 1) {
+                        let key = date.getTime();
+                        if (longChunks[key]) {
+                            longChunks[key].chunks.push(chunk);
+                        } else {
+                            longChunks[key] = {
+                                sorted: false,
+                                chunks: [chunk]
+                            };
+                        }
+                    }
+                }
+                addDay(date);
+            }
+            if (dates.length) {
+                chunk.date = dates[0];
+                chunk.days = dates.length;
+                chunk.dates = dates;
+                if (chunk.start < dates[0]) {
+                    chunk.start = dates[0];
+                }
+                if (setMidnight(cloneDate(chunk.end)) > dates[dates.length - 1]) {
+                    chunk.end = dates[dates.length - 1];
+                }
+            } else {
+                chunk.date = setMidnight(cloneDate(chunk.start));
+                chunk.days = 1;
+                chunk.dates = [chunk.date];
+            }
+
+            if (prevChunk && datesEqual(prevChunk.date, chunk.date)) {
+                chunk.prev = prevChunk;
+            }
+            prevChunk = chunk;
+        }
+    }
+
+    return longChunks;
+}
+
+export function repositionEvent(chunk, longChunks, height) {
+    chunk.top = 0;
+    if (chunk.prev) {
+        chunk.top = chunk.prev.bottom + 1;
+    }
+    chunk.bottom = chunk.top + height;
+    let margin = 1;
+    let key = chunk.date.getTime();
+    if (longChunks[key]) {
+        if (!longChunks[key].sorted) {
+            longChunks[key].chunks.sort((a, b) => a.top - b.top);
+            longChunks[key].sorted = true;
+        }
+        for (let longChunk of longChunks[key].chunks) {
+            if (chunk.top < longChunk.bottom && chunk.bottom > longChunk.top) {
+                let offset = longChunk.bottom - chunk.top + 1;
+                margin += offset;
+                chunk.top += offset;
+                chunk.bottom += offset;
+            }
+        }
+    }
+
+    return margin;
+}
+
+export function createEventContent(chunk, displayEventEnd, eventContent, theme, _intlEventTime, _view) {
+    let timeText = _intlEventTime.format(chunk.start), content;
+    if (displayEventEnd && chunk.event.display !== 'pointer') {
+        timeText += ` - ${_intlEventTime.format(chunk.end)}`;
+    }
+    if (eventContent) {
+        content = is_function(eventContent)
+            ? eventContent({
+                event: toEventWithLocalDates(chunk.event),
+                timeText,
+                view: toViewWithLocalDates(_view)
+            })
+            : eventContent;
+    } else {
+        switch (chunk.event.display) {
+            case 'background':
+                content = '';
+                break;
+            case 'pointer':
+                content = {
+                    domNodes: [createElement('div', theme.eventTime, null, timeText)]
+                };
+                break;
+            default:
+                content = {
+                    domNodes: [
+                        createElement('div', theme.eventTime, null, timeText),
+                        createElement('div', theme.eventTitle, chunk.event.titleHTML, chunk.event.title)
+                    ]
+                };
+        }
+    }
+
+    return [timeText, content];
+}
+
+export function toEventWithLocalDates(event) {
+    return _cloneEvent(event, toLocalDate);
+}
+
+export function cloneEvent(event) {
+    return _cloneEvent(event, cloneDate);
+}
+
+function _cloneEvent(event, dateFn) {
+    event = assign({}, event);
+    event.start = dateFn(event.start);
+    event.end = dateFn(event.end);
+
+    return event;
+}
+
+/**
+ * Check whether the event intersects with the given date range and resource
+ * @param event
+ * @param start
+ * @param end
+ * @param [resource]
+ * @param [timeMode]  Zero-length events should be allowed (@see https://github.com/vkurko/calendar/issues/50), except in time mode
+ * @return boolean
+ */
+export function eventIntersects(event, start, end, resource, timeMode) {
+    return (
+        event.start < end && event.end > start || !timeMode && datesEqual(event.start, event.end, start)
+    ) && (
+        resource === undefined || event.resourceIds.includes(resource.id)
+    );
+}
+
+export function helperEvent(display) {
+    return display === 'preview' || display === 'ghost' || display === 'pointer';
+}
+
+export function bgEvent(display) {
+    return display === 'background';
+}
+
+export function previewEvent(display) {
+    return display === 'preview';
+}
+
+export function ghostEvent(display) {
+    return display === 'ghost';
+}

package/src/lib/stores.js

@@ -0,0 +1,54 @@
+import {derived, writable, get} from 'svelte/store';
+import {is_function} from 'svelte/internal';
+import {toLocalDate, formatRange} from './date';
+
+export function writable2(value, parser, start) {
+    return {
+        ...writable(parser ? parser(value) : value, start),
+        parse: parser
+    };
+}
+
+export function derived2(stores, fn, initValue) {
+    let storeValue = initValue;
+    let hasSubscribers = false;
+    let auto = fn.length < 2;
+    let fn2 = (_, set) => {
+        hasSubscribers = true;
+        if (auto) {
+            storeValue = fn(_, set);
+            set(storeValue);
+        } else {
+            fn(_, value => {storeValue = value; set(value);});
+        }
+        return () => {hasSubscribers = false;};
+    };
+    let store = derived(stores, fn2, storeValue);
+    return {
+        ...store,
+        get: () => hasSubscribers ? storeValue : get(store)
+    };
+}
+
+export function intl(locale, format) {
+    return derived([locale, format], ([$locale, $format]) => {
+        let intl = is_function($format)
+            ? {format: $format}
+            : new Intl.DateTimeFormat($locale, $format);
+        return {
+            format: date => intl.format(toLocalDate(date))
+        };
+    });
+}
+
+export function intlRange(locale, format) {
+    return derived([locale, format], ([$locale, $format]) => {
+        if (is_function($format)) {
+            return {format: (start, end) => $format(toLocalDate(start), toLocalDate(end))};
+        }
+        let intl = new Intl.DateTimeFormat($locale, $format);
+        return {
+            format: (start, end) => formatRange(toLocalDate(start), toLocalDate(end), intl)
+        };
+    });
+}

package/src/lib/utils.js

@@ -0,0 +1,23 @@
+export function assign(...args) {
+    return Object.assign(...args);
+}
+
+export function floor(value) {
+    return Math.floor(value);
+}
+
+export function min(...args) {
+    return Math.min(...args);
+}
+
+export function max(...args) {
+    return Math.max(...args);
+}
+
+export function isObject(test) {
+    return typeof test === 'object' && test !== null;
+}
+
+export function symbol() {
+    return Symbol('ec');
+}

package/src/lib/view.js

@@ -0,0 +1,24 @@
+import {assign} from './utils';
+import {toLocalDate} from './date';
+
+export function createView(view, _viewTitle, _currentRange, _activeRange) {
+    return {
+        type: view,
+        title: _viewTitle,
+        currentStart: _currentRange.start,
+        currentEnd: _currentRange.end,
+        activeStart: _activeRange.start,
+        activeEnd: _activeRange.end,
+        calendar: undefined
+    };
+}
+
+export function toViewWithLocalDates(view) {
+    view = assign({}, view);
+    view.currentStart = toLocalDate(view.currentStart);
+    view.currentEnd = toLocalDate(view.currentEnd);
+    view.activeStart = toLocalDate(view.activeStart);
+    view.activeEnd = toLocalDate(view.activeEnd);
+
+    return view;
+}

package/src/lib.js

@@ -0,0 +1,8 @@
+export * from './lib/actions';
+export * from './lib/date';
+export * from './lib/debounce';
+export * from './lib/dom';
+export * from './lib/events';
+export * from './lib/stores';
+export * from './lib/utils';
+export * from './lib/view';