@event-calendar/core 5.2.4 → 5.3.1

package/src/storage/effects.js

@@ -1,91 +1,140 @@
 import {getAbortSignal, tick, untrack} from 'svelte';
 import {
-    assign, cloneDate, createDate, createEvents, datesEqual, isFunction, setMidnight, toISOString, toLocalDate,
-    toViewWithLocalDates
+    assign, cloneDate, createDate, createEvents, createResources, datesEqual, empty, isArray, isFunction, setMidnight,
+    toISOString, toLocalDate, toViewWithLocalDates
 } from '#lib';
 
-export function loadEvents(mainState) {
-    let fetching = 0;
+export function loadEvents(mainState, loadingInvoker) {
     return () => {
         // Dependencies
-        let {activeRange, fetchedRange, viewDates, options: {events, eventSources, lazyFetching, loading}} = mainState;
+        let {activeRange, fetchedRange: {events: fetchedRange}, viewDates,
+            options: {events, eventSources, lazyFetching}} = mainState;
 
         untrack(() => {
-            if (!viewDates.length) {
-                return;
-            }
-            if (!eventSources.length) {
-                mainState.events = events;
-            }
-            // Do not fetch if new range is within the previous one
-            if (
-                !fetchedRange.start ||
-                fetchedRange.start > activeRange.start ||
-                fetchedRange.end < activeRange.end ||
-                !lazyFetching
-            ) {
-                // Call loading hook
-                if (isFunction(loading) && !fetching) {
-                    loading(true);
+            load(
+                eventSources.map(source => isFunction(source.events) ? source.events : source),
+                events,
+                createEvents,
+                result => mainState.events = result,
+                activeRange,
+                fetchedRange,
+                viewDates,
+                true,
+                lazyFetching,
+                loadingInvoker
+            );
+        });
+    };
+}
+
+export function loadResources(mainState, loadingInvoker) {
+    return () => {
+        // Dependencies
+        let {activeRange, fetchedRange: {resources: fetchedRange}, viewDates,
+            options: {lazyFetching, refetchResourcesOnNavigate, resources}} = mainState;
+
+        untrack(() => {
+            load(
+                isArray(resources) ? [] : [resources],
+                resources,
+                createResources,
+                result => mainState.resources = result,
+                activeRange,
+                fetchedRange,
+                viewDates,
+                refetchResourcesOnNavigate,
+                lazyFetching,
+                loadingInvoker
+            );
+        });
+    };
+}
+
+function load(sources, defaultResult, parseResult, applyResult, activeRange, fetchedRange, viewDates, refetchOnNavigate, lazyFetching, loading) {
+    if (empty(viewDates)) {
+        return;
+    }
+    if (empty(sources)) {
+        applyResult(defaultResult);
+        return;
+    }
+    // Do not fetch if new range is within the previous one
+    if (
+        (refetchOnNavigate || !fetchedRange.start) &&
+        (
+            !lazyFetching ||
+            !fetchedRange.start ||
+            fetchedRange.start > activeRange.start ||
+            fetchedRange.end < activeRange.end
+        )
+    ) {
+        let result = [];
+        // Prepare handlers
+        let failure = e => loading.stop();
+        let success = data => {
+            result = result.concat(parseResult(data));
+            applyResult(result);
+            loading.stop();
+        };
+        // Prepare other stuff
+        let startStr = toISOString(activeRange.start)
+        let endStr = toISOString(activeRange.end);
+        // Loop over event sources
+        for (let source of sources) {
+            loading.start();
+            if (isFunction(source)) {
+                // Source as a function
+                let result = source(refetchOnNavigate ? {
+                    start: toLocalDate(activeRange.start),
+                    end: toLocalDate(activeRange.end),
+                    startStr,
+                    endStr
+                } : {}, success, failure);
+                if (result !== undefined) {
+                    Promise.resolve(result).then(success, failure);
                 }
-                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));
-                    mainState.events = 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: getAbortSignal(), credentials: 'same-origin'
-                        })
-                            .then(response => response.json())
-                            .then(success)
-                            .catch(failure);
-                    }
-                    ++fetching;
+            } else {
+                // Source as a JSON feed
+                // Prepare params
+                let params = isFunction(source.extraParams) ? source.extraParams() : assign({}, source.extraParams);
+                if (refetchOnNavigate) {
+                    params.start = startStr;
+                    params.end = endStr;
                 }
-                // Save current range for future requests
-                assign(fetchedRange, activeRange);
+                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: getAbortSignal(), credentials: 'same-origin'
+                })
+                    .then(response => response.json())
+                    .then(success)
+                    .catch(failure);
             }
-        });
+        }
+        // Save current range for future requests
+        assign(fetchedRange, activeRange);
+    }
+}
+
+export function createLoadingInvoker(options) {
+    let counter = 0;
+    function invoke(value) {
+        let {loading} = options;
+        if (isFunction(loading)) {
+            loading(value);
+        }
+    }
+    return {
+        start: () => ++counter === 1 && invoke(true),
+        stop: () => --counter === 0 && invoke(false)
     };
 }
 

package/src/storage/options.svelte.js

@@ -1,6 +1,6 @@
 import {untrack} from 'svelte';
 import {
-    createDate, createDateRange, createDuration, createEvents, createEventSources, createResources, entries,
+    createDate, createDateRange, createDuration, createEvents, createEventSources, createResources, entries, isArray,
     isFunction, keys, setMidnight
 } from '#lib';
 import {SvelteMap} from "svelte/reactivity";
@@ -55,6 +55,7 @@ function createOptions(plugins) {
         lazyFetching: true,
         loading: undefined,
         locale: undefined,
+        refetchResourcesOnNavigate: false,
         resources: [],
         selectable: false,
         theme: {
@@ -110,13 +111,13 @@ function createOptions(plugins) {
 
 function createParsers(plugins) {
     let parsers = {
-        date: date => setMidnight(createDate(date)),
+        date: input => setMidnight(createDate(input)),
         duration: createDuration,
         events: createEvents,
         eventSources: createEventSources,
-        hiddenDays: days => [...new Set(days)],
-        highlightedDates: dates => dates.map(date => setMidnight(createDate(date))),
-        resources: createResources,
+        hiddenDays: input => [...new Set(input)],
+        highlightedDates: input => input.map(item => setMidnight(createDate(item))),
+        resources: input => isArray(input) ? createResources(input) : input,
         validRange: createDateRange
     };
 

package/src/storage/state.svelte.js

@@ -1,7 +1,9 @@
 import {SvelteMap} from 'svelte/reactivity';
 import {createDate, identity, intl, intlRange, setMidnight} from '#lib';
 import {optionsState} from './options.svelte.js';
-import {loadEvents, runDatesSet, runEventAllUpdated, runViewDidMount, setNowAndToday} from './effects.js';
+import {
+    createLoadingInvoker, loadEvents, loadResources, runDatesSet, runEventAllUpdated, runViewDidMount, setNowAndToday
+} from './effects.js';
 import {activeRange, currentRange, filteredEvents, view, viewDates, viewTitle} from './derived.js';
 
 export default class State {
@@ -18,11 +20,12 @@ export default class State {
         this.auxComponents = $state([]);
         this.currentRange = $derived.by(currentRange(this));
         this.activeRange = $derived.by(activeRange(this));
-        this.fetchedRange = $state.raw({start: undefined, end: undefined});
+        this.fetchedRange = $state({events: {}, resources: {}});
         this.events = $state.raw([]);
         this.filteredEvents = $derived.by(filteredEvents(this));
         this.mainEl = $state();
         this.now = $state(createDate());
+        this.resources = $state.raw([]);
         this.today = $state(setMidnight(createDate()));
         this.intlEventTime = $derived.by(intlRange(this, 'eventTimeFormat'));
         this.intlDayHeader = $derived.by(intl(this, 'dayHeaderFormat'));
@@ -50,8 +53,10 @@ export default class State {
     }
 
     #initEffects() {
+        let loading = createLoadingInvoker(this.options);
         $effect.pre(setNowAndToday(this));
-        $effect(loadEvents(this));
+        $effect(loadEvents(this, loading));
+        $effect(loadResources(this, loading));
         $effect(runDatesSet(this));
         $effect(runEventAllUpdated(this));
         $effect(runViewDidMount(this));