npm - @event-calendar/core - Versions diffs - 1.1.1 → 1.2.0 - Mend

@event-calendar/core 1.1.1 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/README.md CHANGED Viewed

@@ -193,8 +193,8 @@ import '@event-calendar/core/index.css';
 ### Pre-built browser ready bundle
 Include the following lines of code in the `<head>` section of your page:
 ```html
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@event-calendar/build@1.1.1/event-calendar.min.css">
-<script src="https://cdn.jsdelivr.net/npm/@event-calendar/build@1.1.1/event-calendar.min.js"></script>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@event-calendar/build@1.2.0/event-calendar.min.css">
+<script src="https://cdn.jsdelivr.net/npm/@event-calendar/build@1.2.0/event-calendar.min.js"></script>
 ```
 <details>

package/index.js CHANGED Viewed

@@ -1,7 +1,645 @@
-import { is_function, noop, identity, tick, SvelteComponent, init, safe_not_equal, empty, insert, destroy_each, detach, component_subscribe, set_store_value, element, text, attr, append, listen, set_data, transition_in, group_outros, check_outros, transition_out, space, create_component, mount_component, destroy_component, construct_svelte_component, set_style, get_current_component } from 'svelte/internal';
+import { run_all, is_function, noop, identity, tick, SvelteComponent, init, safe_not_equal, empty, insert, destroy_each, detach, component_subscribe, set_store_value, element, text, attr, append, listen, set_data, transition_in, group_outros, check_outros, transition_out, space, create_component, mount_component, destroy_component, construct_svelte_component, set_style, get_current_component } from 'svelte/internal';
 import { getContext, setContext, beforeUpdate } from 'svelte';
-import { derived, writable, readable, get } from 'svelte/store';
-import { assign, setMidnight, createDate, createDuration, createEvents, createEventSources, cloneDate, prevClosestDay, nextClosestDay, DAY_IN_SECONDS, addDuration, subtractDay, derived2, addDay, createView, debounce, toISOString, toLocalDate, writable2, intl, intlRange, subtractDuration, toViewWithLocalDates, flushDebounce, hasYScroll, toEventWithLocalDates, getElementWithPayload, getPayload } from '@event-calendar/common';
+import { writable, derived, get, readable } from 'svelte/store';
+function assign(...args) {
+    return Object.assign(...args);
+}
+function floor(value) {
+    return Math.floor(value);
+}
+function min(...args) {
+    return Math.min(...args);
+}
+function max(...args) {
+    return Math.max(...args);
+}
+function isObject(test) {
+    return typeof test === 'object' && test !== null;
+}
+function symbol() {
+    return Symbol('ec');
+}
+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 */
+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);
+        }
+    };
+}
+const DAY_IN_SECONDS = 86400;
+function createDate(input = undefined) {
+    if (input !== undefined) {
+        return input instanceof Date ? _fromLocalDate(input) : _fromISOString(input);
+    }
+    return _fromLocalDate(new Date());
+}
+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
+    };
+}
+function cloneDate(date) {
+    return new Date(date.getTime());
+}
+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;
+}
+function subtractDuration(date, duration, x = 1) {
+    return addDuration(date, duration, -x);
+}
+function addDay(date, x = 1) {
+    date.setUTCDate(date.getUTCDate() + x);
+    return date;
+}
+function subtractDay(date, x = 1) {
+    return addDay(date, -x);
+}
+function setMidnight(date) {
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+}
+function toLocalDate(date) {
+    return new Date(
+        date.getUTCFullYear(),
+        date.getUTCMonth(),
+        date.getUTCDate(),
+        date.getUTCHours(),
+        date.getUTCMinutes(),
+        date.getUTCSeconds()
+    );
+}
+function toISOString(date) {
+    return date.toISOString().substring(0, 19);
+}
+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;
+}
+function datesEqual(date1, ...dates2) {
+    return dates2.every(date2 => date1.getTime() === date2.getTime());
+}
+function nextClosestDay(date, day) {
+    let diff = day - date.getUTCDay();
+    date.setUTCDate(date.getUTCDate() + (diff >= 0 ? diff : diff + 7));
+    return date;
+}
+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
+  */
+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];
+}
+function debounce(fn, handle, queueStore) {
+    queueStore.update(queue => queue.set(handle, fn));
+}
+function flushDebounce(queue) {
+    run_all(queue);
+    queue.clear();
+}
+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;
+}
+function hasYScroll(el) {
+    return el.scrollHeight > el.clientHeight;
+}
+function rect(el) {
+    return el.getBoundingClientRect();
+}
+function ancestor(el, up) {
+    while (up--) {
+        el = el.parentElement;
+    }
+    return el;
+}
+function height(el) {
+    return rect(el).height;
+}
+let payloadProp = symbol();
+function setPayload(el, payload) {
+    el[payloadProp] = payload;
+}
+function hasPayload(el) {
+    return !!el?.[payloadProp];
+}
+function getPayload(el) {
+    return el[payloadProp];
+}
+function getElementWithPayload(x, y) {
+    for (let el of document.elementsFromPoint(x, y)) {
+        if (hasPayload(el)) {
+            return el;
+        }
+    }
+    return null;
+}
+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
+    };
+}
+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;
+}
+let eventId = 1;
+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
+    }));
+}
+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 || {}
+    }));
+}
+function createEventChunk(event, start, end) {
+    return {
+        start: event.start > start ? event.start : start,
+        end: event.end < end ? event.end : end,
+        event
+    };
+}
+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
+ */
+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;
+}
+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;
+}
+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];
+}
+function toEventWithLocalDates(event) {
+    return _cloneEvent(event, toLocalDate);
+}
+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
+ */
+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)
+    );
+}
+function helperEvent(display) {
+    return display === 'preview' || display === 'ghost' || display === 'pointer';
+}
+function bgEvent(display) {
+    return display === 'background';
+}
+function previewEvent(display) {
+    return display === 'preview';
+}
+function ghostEvent(display) {
+    return display === 'ghost';
+}
+function writable2(value, parser, start) {
+    return {
+        ...writable(parser ? parser(value) : value, start),
+        parse: parser
+    };
+}
+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)
+    };
+}
+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))
+        };
+    });
+}
+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)
+        };
+    });
+}
 function createOptions(plugins) {
     let options = {
@@ -455,7 +1093,7 @@ function parseOpts(opts, state) {
     }
 }
-/* packages/core/src/Buttons.svelte generated by Svelte v3.58.0 */
+/* packages/core/src/Buttons.svelte generated by Svelte v3.59.1 */
 function get_each_context$2(ctx, list, i) {
 	const child_ctx = ctx.slice();
@@ -860,7 +1498,7 @@ class Buttons extends SvelteComponent {
 	}
 }
-/* packages/core/src/Toolbar.svelte generated by Svelte v3.58.0 */
+/* packages/core/src/Toolbar.svelte generated by Svelte v3.59.1 */
 function get_each_context$1(ctx, list, i) {
 	const child_ctx = ctx.slice();
@@ -1234,7 +1872,7 @@ class Toolbar extends SvelteComponent {
 	}
 }
-/* packages/core/src/Auxiliary.svelte generated by Svelte v3.58.0 */
+/* packages/core/src/Auxiliary.svelte generated by Svelte v3.59.1 */
 function get_each_context(ctx, list, i) {
 	const child_ctx = ctx.slice();
@@ -1436,7 +2074,7 @@ class Auxiliary extends SvelteComponent {
 	}
 }
-/* packages/core/src/Calendar.svelte generated by Svelte v3.58.0 */
+/* packages/core/src/Calendar.svelte generated by Svelte v3.59.1 */
 function create_fragment(ctx) {
 	let div;
@@ -1824,4 +2462,4 @@ class Calendar extends SvelteComponent {
 	}
 }
-export { Calendar as default };
+export { DAY_IN_SECONDS, addDay, addDuration, ancestor, assign, bgEvent, cloneDate, cloneEvent, createDate, createDuration, createElement, createEventChunk, createEventContent, createEventSources, createEvents, createView, datesEqual, debounce, Calendar as default, derived2, eventIntersects, floor, flushDebounce, formatRange, getElementWithPayload, getPayload, ghostEvent, hasPayload, hasYScroll, height, helperEvent, intl, intlRange, isObject, max, min, nextClosestDay, noTimePart, outsideEvent, prepareEventChunks, prevClosestDay, previewEvent, rect, repositionEvent, setContent, setMidnight, setPayload, sortEventChunks, subtractDay, subtractDuration, symbol, toEventWithLocalDates, toISOString, toLocalDate, toViewWithLocalDates, writable2 };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@event-calendar/core",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "title": "Event Calendar Core package",
   "description": "Full-sized drag & drop event calendar with resource view",
   "keywords": [
@@ -27,7 +27,6 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@event-calendar/common": "~1.1.1",
-    "svelte": "^3.55.1"
+    "svelte": "^3.59.1"
   }
 }