@event-calendar/core 5.0.6 → 5.1.0

package/src/plugins/resource-timeline/Label.svelte

@@ -1,38 +0,0 @@
-<script>
-    import {getContext, onMount} from 'svelte';
-    import {contentFrom, toLocalDate, isFunction} from '#lib';
-
-    let {resource, date = undefined} = $props();
-
-    let {resourceLabelContent, resourceLabelDidMount} = getContext('state');
-
-    let el = $state();
-    // Content
-    let content = $derived.by(() => {
-        if ($resourceLabelContent) {
-            return isFunction($resourceLabelContent)
-                ? $resourceLabelContent({
-                    resource,
-                    date: date ? toLocalDate(date) : undefined,
-                })
-                : $resourceLabelContent;
-        } else {
-            return resource.title;
-        }
-    });
-
-    onMount(() => {
-        if (isFunction($resourceLabelDidMount)) {
-            $resourceLabelDidMount({
-                resource,
-                date: date ? toLocalDate(date) : undefined,
-                el
-            });
-        }
-    });
-</script>
-
-<span
-    bind:this={el}
-    {@attach contentFrom(content)}
-></span>

package/src/plugins/resource-timeline/stores.js

@@ -1,48 +0,0 @@
-import {derived} from 'svelte/store';
-import {createSlotTimeLimits, createSlots, getPayload, toSeconds} from '#lib';
-
-// slotTimeLimits per day
-export function dayTimeLimits(state) {
-    return derived(
-        [state.slotMinTime, state.slotMaxTime, state.flexibleSlotTimeLimits, state._viewDates, state._filteredEvents],
-        ([$slotMinTime, $slotMaxTime, $flexibleSlotTimeLimits, $_viewDates, $_filteredEvents]) => {
-            let dayTimeLimits = {};
-            for (let date of $_viewDates) {
-                dayTimeLimits[date.getTime()] = createSlotTimeLimits(
-                    $slotMinTime,
-                    $slotMaxTime,
-                    $flexibleSlotTimeLimits,
-                    [date],
-                    $_filteredEvents
-                );
-            }
-
-            return dayTimeLimits;
-        }
-    );
-}
-
-export function daySlots(state) {
-    return derived(
-        [state._viewDates, state.slotDuration, state._slotLabelPeriodicity, state._dayTimeLimits, state._intlSlotLabel],
-        ([$_viewDates, $slotDuration, $_slotLabelPeriodicity, $_dayTimeLimits, $_intlSlotLabel]) => {
-            let dayTimes = {};
-            for (let date of $_viewDates) {
-                let key = date.getTime();
-                dayTimes[key] = key in $_dayTimeLimits
-                    ? createSlots(date, $slotDuration, $_slotLabelPeriodicity, $_dayTimeLimits[key], $_intlSlotLabel)
-                    : [];
-            }
-
-            return dayTimes;
-        }
-    );
-}
-
-export function nestedResources(state) {
-    return derived(state.resources, $resources => $resources.some(resource => getPayload(resource).children.length));
-}
-
-export function monthView(state) {
-    return derived(state.slotDuration, $slotDuration => !toSeconds($slotDuration));
-}

package/src/plugins/time-grid/stores.js

@@ -1,49 +0,0 @@
-import {derived, writable} from 'svelte/store';
-import {ceil, createDate, createSlotTimeLimits, createSlots, intl, setMidnight, toSeconds} from '#lib';
-
-function slotTimeLimits(state) {
-    return derived(
-        [state.slotMinTime, state.slotMaxTime, state.flexibleSlotTimeLimits, state._viewDates, state._filteredEvents],
-        args => createSlotTimeLimits(...args)
-    );
-}
-
-function slotLabelPeriodicity(state) {
-    return derived(
-        [state.slotDuration, state.slotLabelInterval],
-        ([$slotDuration, $slotLabelInterval]) => {
-            if ($slotLabelInterval === undefined) {
-                return toSeconds($slotDuration) < 3600 ? 2 : 1;
-            }
-            return ceil(toSeconds($slotLabelInterval) / toSeconds($slotDuration)) || 1;
-        }
-    );
-}
-
-function slots(state) {
-    return derived(
-        [state.slotDuration, state._slotLabelPeriodicity, state._slotTimeLimits, state._intlSlotLabel],
-        args => createSlots(setMidnight(createDate()), ...args)
-    );
-}
-
-/**
- * TimeGrid + ResourceTimeGrid + ResourceTimeline
- */
-export function createTRRStores(state) {
-    if (!('_sidebarWidth' in state)) {
-        state._intlSlotLabel = intl(state.locale, state.slotLabelFormat);
-        state._slotLabelPeriodicity = slotLabelPeriodicity(state);
-        state._sidebarWidth = writable(0);
-    }
-}
-
-/**
- * TimeGrid + ResourceTimeGrid
- */
-export function createTRStores(state) {
-    if (!('_slots' in state)) {
-        state._slotTimeLimits = slotTimeLimits(state);  // flexible limits
-        state._slots = slots(state);
-    }
-}

package/src/storage/options.js

@@ -1,136 +0,0 @@
-import {
-    createDate, createDuration, createEvents, createEventSources, createResources, createDateRange, keys, setMidnight
-} from '#lib';
-
-// Options where initial value is passed to the function
-export const specialOptions = ['buttonText', 'customButtons', 'theme'];
-
-export function createOptions(plugins) {
-    let options = {
-        buttonText: {
-            today: 'today',
-        },
-        customButtons: {},
-        date: new Date(),
-        datesSet: undefined,
-        dayHeaderFormat: {
-            weekday: 'short',
-            month: 'numeric',
-            day: 'numeric'
-        },
-        dayHeaderAriaLabelFormat: {
-            dateStyle: 'full'
-        },
-        displayEventEnd: true,
-        duration: {weeks: 1},
-        events: [],
-        eventAllUpdated: undefined,
-        eventBackgroundColor: undefined,
-        eventClassNames: undefined,
-        eventClick: undefined,
-        eventColor: undefined,
-        eventContent: undefined,
-        eventDidMount: undefined,
-        eventFilter: undefined,    // ec option
-        eventMouseEnter: undefined,
-        eventMouseLeave: undefined,
-        eventOrder: undefined,
-        eventSources: [],
-        eventTextColor: undefined,
-        eventTimeFormat: {
-            hour: 'numeric',
-            minute: '2-digit'
-        },
-        filterEventsWithResources: false,
-        firstDay: 0,
-        headerToolbar: {
-            start: 'title',
-            center: '',
-            end: 'today prev,next'
-        },
-        height: undefined,
-        hiddenDays: [],
-        highlightedDates: [],  // ec option
-        lazyFetching: true,
-        loading: undefined,
-        locale: undefined,
-        resources: [],
-        selectable: false,
-        theme: {
-            allDay: 'ec-all-day',
-            active: 'ec-active',
-            bgEvent: 'ec-bg-event',
-            bgEvents: 'ec-bg-events',
-            body: 'ec-body',
-            button: 'ec-button',
-            buttonGroup: 'ec-button-group',
-            calendar: 'ec',
-            colHead: 'ec-col-head',
-            day: 'ec-day',
-            dayHead: 'ec-day-head',
-            disabled: 'ec-disabled',
-            event: 'ec-event',
-            eventBody: 'ec-event-body',
-            eventTime: 'ec-event-time',
-            eventTitle: 'ec-event-title',
-            events: 'ec-events',
-            grid: 'ec-grid',
-            header: 'ec-header',
-            hidden: 'ec-hidden',
-            highlight: 'ec-highlight',
-            icon: 'ec-icon',
-            main: 'ec-main',
-            noBeb: 'ec-no-beb',  // no block end border
-            noIeb: 'ec-no-ieb',  // no inline end border
-            today: 'ec-today',
-            title: 'ec-title',
-            toolbar: 'ec-toolbar',
-            view: '',
-            weekdays: ['ec-sun', 'ec-mon', 'ec-tue', 'ec-wed', 'ec-thu', 'ec-fri', 'ec-sat'],
-        },
-        titleFormat: {
-            year: 'numeric',
-            month: 'short',
-            day: 'numeric'
-        },
-        validRange: undefined,
-        view: undefined,
-        viewDidMount: undefined,
-        views: {}
-    };
-
-    for (let plugin of plugins) {
-        plugin.createOptions?.(options);
-    }
-
-    return options;
-}
-
-export function createParsers(plugins) {
-    let parsers = {
-        date: date => setMidnight(createDate(date)),
-        duration: createDuration,
-        events: createEvents,
-        eventSources: createEventSources,
-        hiddenDays: days => [...new Set(days)],
-        highlightedDates: dates => dates.map(date => setMidnight(createDate(date))),
-        resources: createResources,
-        validRange: createDateRange
-    };
-
-    for (let plugin of plugins) {
-        plugin.createParsers?.(parsers);
-    }
-
-    return parsers;
-}
-
-export function diff(options, prevOptions) {
-    let diff = [];
-    for (let key of keys(options)) {
-        if (options[key] !== prevOptions[key]) {
-            diff.push([key, options[key]]);
-        }
-    }
-    return diff;
-}

package/src/storage/state.js

@@ -1,168 +0,0 @@
-import {get, writable} from 'svelte/store';
-import {tick} from 'svelte';
-import {createOptions, createParsers, specialOptions} from './options.js';
-import {activeRange, currentRange, dayGrid, events, now, today, view as view2, viewDates, viewTitle, filteredEvents} from './stores.js';
-import {identity, intl, intlRange, isFunction, keys, toViewWithLocalDates} from '#lib';
-
-export default class {
-    constructor(plugins, input) {
-        plugins = plugins || [];
-
-        // Create options
-        let options = createOptions(plugins);
-        let parsers = createParsers(plugins);
-
-        // Parse options
-        options = parseOpts(options, parsers);
-        input = parseOpts(input, parsers);
-
-        // Create stores for options
-        for (let [option, value] of Object.entries(options)) {
-            this[option] = writable(value);
-        }
-
-        // Private stores
-        this._queue = writable(new Map());  // debounce queue (beforeUpdate)
-        this._tasks = new Map();  // timeout IDs for tasks
-        this._auxiliary = writable([]);  // auxiliary components
-        this._dayGrid = dayGrid(this);
-        this._currentRange = currentRange(this);
-        this._activeRangeExt = writable(identity);
-        this._activeRange = activeRange(this);
-        this._fetchedRange = writable({start: undefined, end: undefined});
-        this._events = events(this);
-        this._mainEl = writable(undefined);
-        this._now = now();
-        this._today = today(this);
-        this._intlEventTime = intlRange(this.locale, this.eventTimeFormat);
-        this._intlDayHeader = intl(this.locale, this.dayHeaderFormat);
-        this._intlDayHeaderAL = intl(this.locale, this.dayHeaderAriaLabelFormat);
-        this._intlTitle = intlRange(this.locale, this.titleFormat);
-        this._viewTitle = viewTitle(this);
-        this._viewDates = viewDates(this);
-        this._view = view2(this);
-        this._viewComponent = writable(undefined);
-        this._filteredEvents = filteredEvents(this);
-        // Interaction
-        this._interaction = writable({});
-        this._iEvents = writable([null, null]);  // interaction events: [drag/resize, pointer]
-        this._iClasses = writable(identity);  // interaction event css classes
-        this._iClass = writable(undefined);  // interaction css class for entire calendar
-
-        // Set & Get
-        this._set = (key, value) => {
-            if (validKey(key, this)) {
-                if (parsers[key]) {
-                    value = parsers[key](value);
-                }
-                this[key].set(value);
-            }
-        };
-        this._get = key => validKey(key, this) ? get(this[key]) : undefined;
-
-        // Let plugins create their private stores
-        for (let plugin of plugins) {
-            plugin.createStores?.(this);
-        }
-
-        if (input.view) {
-            // Set initial view based on input
-            this.view.set(input.view);
-        }
-
-        // Set options for each view
-        let views = new Set([...keys(options.views), ...keys(input.views ?? {})]);
-        for (let view of views) {
-            let defOpts = mergeOpts(options, options.views[view] ?? {});
-            let opts = mergeOpts(defOpts, input, input.views?.[view] ?? {});
-            let component = opts.component;
-            // Make sure we deal with valid opts from now on
-            filterOpts(opts, this);
-            // Process options
-            for (let key of keys(opts)) {
-                let {set, _set = set, ...rest} = this[key];
-
-                this[key] = {
-                    // Set value in all views
-                    set: specialOptions.includes(key)
-                        ? value => {
-                            if (isFunction(value)) {
-                                let result = value(defOpts[key]);
-                                opts[key] = result;
-                                set(set === _set ? result : value);
-                            } else {
-                                opts[key] = value;
-                                set(value);
-                            }
-                        }
-                        : value => {
-                            opts[key] = value;
-                            set(value);
-                        },
-                    _set,
-                    ...rest
-                };
-            }
-            // When view changes...
-            this.view.subscribe(newView => {
-                if (newView === view) {
-                    // switch view component
-                    this._viewComponent.set(component);
-                    if (isFunction(opts.viewDidMount)) {
-                        tick().then(() => opts.viewDidMount({
-                            view: toViewWithLocalDates(get(this._view))
-                        }));
-                    }
-                    // update store values
-                    for (let key of keys(opts)) {
-                        this[key]._set(opts[key]);
-                    }
-                }
-            });
-        }
-    }
-}
-
-function parseOpts(opts, parsers) {
-    let result = {...opts};
-    for (let key of keys(parsers)) {
-        if (key in result) {
-            result[key] = parsers[key](result[key]);
-        }
-    }
-    if (opts.views) {
-        result.views = {};
-        for (let view of keys(opts.views)) {
-            result.views[view] = parseOpts(opts.views[view], parsers);
-        }
-    }
-    return result;
-}
-
-function mergeOpts(...args) {
-    let result = {};
-    for (let opts of args) {
-        let override = {};
-        for (let key of specialOptions) {
-            if (isFunction(opts[key])) {
-                override[key] = opts[key](result[key]);
-            }
-        }
-        result = {
-            ...result,
-            ...opts,
-            ...override
-        };
-    }
-    return result;
-}
-
-function filterOpts(opts, state) {
-    keys(opts)
-        .filter(key => !validKey(key, state) || key === 'view')
-        .forEach(key => delete opts[key]);
-}
-
-function validKey(key, state) {
-    return state.hasOwnProperty(key) && key[0] !== '_';
-}

package/src/storage/stores.js

@@ -1,234 +0,0 @@
-import {derived, get, readable, writable} from 'svelte/store';
-import {
-    addDay, addDuration, assign, cloneDate, createDate, createEvents, createView, datesEqual, DAY_IN_SECONDS, debounce,
-    isFunction, nextClosestDay, prevClosestDay, setMidnight, subtractDay, toEventWithLocalDates, toISOString,
-    toLocalDate
-} from '#lib';
-
-export function dayGrid(state) {
-    return derived(state.view, $view => $view?.startsWith('dayGrid'));
-}
-
-export function activeRange(state) {
-    return derived(
-        [state._currentRange, state._activeRangeExt],
-        ([$_currentRange, $_activeRangeExt]) => {
-            return $_activeRangeExt({start: cloneDate($_currentRange.start), end: cloneDate($_currentRange.end)});
-        }
-    );
-}
-
-export function currentRange(state) {
-    return derived(
-        [state.date, state.duration, state.firstDay],
-        ([$date, $duration, $firstDay]) => {
-            let start = cloneDate($date), end;
-            if ($duration.months) {
-                start.setUTCDate(1);
-            } else if ($duration.inWeeks) {
-                // First day of week
-                prevClosestDay(start, $firstDay);
-            }
-            end = addDuration(cloneDate(start), $duration);
-
-            return {start, end};
-        }
-    );
-}
-
-export function viewDates(state) {
-    return derived([state._activeRange, state.hiddenDays], ([$_activeRange, $hiddenDays]) => {
-        let dates = [];
-        let date = setMidnight(cloneDate($_activeRange.start));
-        let end = setMidnight(cloneDate($_activeRange.end));
-        while (date < end) {
-            if (!$hiddenDays.includes(date.getUTCDay())) {
-                dates.push(cloneDate(date));
-            }
-            addDay(date);
-        }
-        if (!dates.length && $hiddenDays.length && $hiddenDays.length < 7) {
-            // Try to move the date
-            state.date.update(date => {
-                while ($hiddenDays.includes(date.getUTCDay())) {
-                    addDay(date);
-                }
-                return date;
-            });
-            dates = get(state._viewDates);
-        }
-
-        return dates;
-    });
-}
-
-export function viewTitle(state) {
-    return derived(
-        [state.date, state._activeRange, state._intlTitle, state._dayGrid],
-        ([$date, $_activeRange, $_intlTitle, $_dayGrid]) => {
-            return $_dayGrid
-                ? $_intlTitle.formatRange($date, $date)
-                : $_intlTitle.formatRange($_activeRange.start, subtractDay(cloneDate($_activeRange.end)));
-        }
-    );
-}
-
-export function view(state) {
-    return derived([state.view, state._viewTitle, state._currentRange, state._activeRange], args => createView(...args));
-}
-
-export function events(state) {
-    let _events = writable([]);
-    let abortController;
-    let fetching = 0;
-    let debounceHandle = {};
-    derived(
-        [state.events, state.eventSources, state._activeRange, state._fetchedRange, state.lazyFetching, state.loading],
-        (values, set) => debounce(() => {
-            let [$events, $eventSources, $_activeRange, $_fetchedRange, $lazyFetching, $loading] = values;
-            if (!$eventSources.length) {
-                set($events);
-                return;
-            }
-            // Do not fetch if new range is within the previous one
-            if (!$_fetchedRange.start || $_fetchedRange.start > $_activeRange.start || $_fetchedRange.end < $_activeRange.end || !$lazyFetching) {
-                if (abortController) {
-                    // Abort previous request
-                    abortController.abort();
-                }
-                // Create new abort controller
-                abortController = new AbortController();
-                // Call loading hook
-                if (isFunction($loading) && !fetching) {
-                    $loading(true);
-                }
-                let stopLoading = () => {
-                    if (--fetching === 0 && isFunction($loading)) {
-                        $loading(false);
-                    }
-                };
-                let events = [];
-                // Prepare handlers
-                let failure = e => stopLoading();
-                let success = data => {
-                    events = events.concat(createEvents(data));
-                    set(events);
-                    stopLoading();
-                };
-                // Prepare other stuff
-                let startStr = toISOString($_activeRange.start)
-                let endStr = toISOString($_activeRange.end);
-                // Loop over event sources
-                for (let source of $eventSources) {
-                    if (isFunction(source.events)) {
-                        // Events as a function
-                        let result = source.events({
-                            start: toLocalDate($_activeRange.start),
-                            end: toLocalDate($_activeRange.end),
-                            startStr,
-                            endStr
-                        }, success, failure);
-                        if (result !== undefined) {
-                            Promise.resolve(result).then(success, failure);
-                        }
-                    } else {
-                        // Events as a JSON feed
-                        // Prepare params
-                        let params = isFunction(source.extraParams) ? source.extraParams() : assign({}, source.extraParams);
-                        params.start = startStr;
-                        params.end = endStr;
-                        params = new URLSearchParams(params);
-                        // Prepare fetch
-                        let url = source.url, headers = {}, body;
-                        if (['GET', 'HEAD'].includes(source.method)) {
-                            url += (url.includes('?') ? '&' : '?') + params;
-                        } else {
-                            headers['content-type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
-                            body = String(params);  // Safari 10.1 doesn't convert to string automatically
-                        }
-                        // Do the fetch
-                        fetch(url, {method: source.method, headers, body, signal: abortController.signal, credentials: 'same-origin'})
-                            .then(response => response.json())
-                            .then(success)
-                            .catch(failure);
-                    }
-                    ++fetching;
-                }
-                // Save current range for future requests
-                $_fetchedRange.start = $_activeRange.start;
-                $_fetchedRange.end = $_activeRange.end;
-            }
-        }, debounceHandle, state._queue),
-        []
-    ).subscribe(_events.set);
-
-    return _events;
-}
-
-export function filteredEvents(state){
-    let view;
-    state._view.subscribe($_view => view = $_view);
-    let debounceHandle = {};
-    return derived(
-        [state._events, state.eventFilter, state.eventOrder, state.filterEventsWithResources, state.resources],
-        (values, set) => debounce(() => {
-            let [$_events, $eventFilter, $eventOrder, $filterEventsWithResources, $resources] = values;
-
-            let result = [...$_events];
-
-            // Filter events
-            if (isFunction($eventFilter)) {
-                let events = $_events.map(toEventWithLocalDates);
-                result = result
-                    .filter((event, index) => $eventFilter({
-                        event: toEventWithLocalDates(event),
-                        index,
-                        events,
-                        view
-                    }));
-            }
-            if ($filterEventsWithResources) {
-                result = result.filter(event => $resources.some(resource => event.resourceIds.includes(resource.id)));
-            }
-
-            // Sort events
-            if (isFunction($eventOrder)) {
-                result.sort((a, b) => $eventOrder(
-                    toEventWithLocalDates(a),
-                    toEventWithLocalDates(b)
-                ));
-            } else {
-                // Sort by start date (all-day events always on top)
-                result.sort((a, b) => a.start - b.start || b.allDay - a.allDay);
-            }
-
-            set(result);
-
-        }, debounceHandle, state._queue),
-        []
-    );
-}
-
-export function now() {
-    return readable(createDate(), set => {
-        let interval = setInterval(() => {
-            set(createDate());
-        }, 1000);
-
-        return () => clearInterval(interval);
-    });
-}
-
-export function today(state) {
-    let $today = setMidnight(createDate());
-    let today = writable($today);
-    state._now.subscribe($_now => {
-        let newToday = setMidnight(cloneDate($_now));
-        if (!datesEqual($today, newToday)) {
-            $today = newToday;
-            today.set(newToday);
-        }
-    });
-
-    return today;
-}