@selfcommunity/react-core 0.4.55 → 0.5.0-alpha.0

package/lib/esm/constants/Preferences.js

@@ -130,6 +130,9 @@ export const CONFIGURATIONS_CUSTOM_NAVBAR_ITEM_IMAGE = `${SCPreferenceSection.CO
 export const CONFIGURATIONS_GROUPS_ONLY_STAFF_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.GROUPS_ONLY_STAFF_ENABLED}`;
 export const CONFIGURATIONS_GROUPS_VISIBILITY_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.GROUPS_VISIBILITY_ENABLED}`;
 export const CONFIGURATIONS_GROUPS_PRIVATE_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.GROUPS_PRIVATE_ENABLED}`;
+export const CONFIGURATIONS_EVENTS_ONLY_STAFF_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.EVENTS_ONLY_STAFF_ENABLED}`;
+export const CONFIGURATIONS_EVENTS_VISIBILITY_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.EVENTS_VISIBILITY_ENABLED}`;
+export const CONFIGURATIONS_EVENTS_PRIVATE_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.EVENTS_PRIVATE_ENABLED}`;
 /**
  * PROVIDERS
  */
@@ -266,6 +269,9 @@ export const DATA_TYPES = {
     [CONFIGURATIONS_CUSTOM_NAVBAR_ITEM_TEXT]: stringType,
     [CONFIGURATIONS_CUSTOM_NAVBAR_ITEM_URL]: stringType,
     [CONFIGURATIONS_CUSTOM_NAVBAR_ITEM_IMAGE]: stringType,
+    [CONFIGURATIONS_EVENTS_ONLY_STAFF_ENABLED]: booleanType,
+    [CONFIGURATIONS_EVENTS_VISIBILITY_ENABLED]: booleanType,
+    [CONFIGURATIONS_EVENTS_PRIVATE_ENABLED]: booleanType,
     [CONFIGURATIONS_GROUPS_ONLY_STAFF_ENABLED]: booleanType,
     [CONFIGURATIONS_GROUPS_VISIBILITY_ENABLED]: booleanType,
     [CONFIGURATIONS_GROUPS_PRIVATE_ENABLED]: booleanType,

package/lib/esm/constants/Routes.d.ts

@@ -36,6 +36,11 @@ export declare const GROUP_MEMBERS_ROUTE_NAME = "group_members";
 export declare const GROUP_MESSAGES_ROUTE_NAME = "group_messages";
 export declare const GROUPS_ROUTE_NAME = "groups";
 export declare const GROUPS_SUBSCRIBED_ROUTE_NAME = "groups_subscribed";
+export declare const EVENT_ROUTE_NAME = "event";
+export declare const EVENTS_ROUTE_NAME = "events";
+export declare const EVENTS_SUGGESTED_ROUTE_NAME = "events_suggested";
+export declare const EVENTS_SUBSCRIBED_ROUTE_NAME = "events_subscribed";
+export declare const EVENTS_HIGHLIGHT_ROUTE_NAME = "events_highlight";
 /**
  * Default Routes
  * @type {{[p: string]: string, '[POST_ROUTE_NAME]': string, '[INCUBATOR_ROUTE_NAME]': string, '[LOYALTY_ROUTE_NAME]': string, '[USER_NOTIFICATION_ROUTE_NAME]': string, '[USER_PRIVATE_MESSAGES_ROUTE_NAME]': string, '[COMMENT_ROUTE_NAME]': string, '[DISCUSSION_ROUTE_NAME]': string, '[CATEGORIES_ROUTE_NAME]': string, '[USER_PROFILE_ROUTE_NAME]': string, '[CATEGORY_ROUTE_NAME]': string, '[USER_PROFILE_SETTINGS_ROUTE_NAME]': string, '[STATUS_ROUTE_NAME]': string}}

package/lib/esm/constants/Routes.js

@@ -36,6 +36,11 @@ export const GROUP_MEMBERS_ROUTE_NAME = 'group_members';
 export const GROUP_MESSAGES_ROUTE_NAME = 'group_messages';
 export const GROUPS_ROUTE_NAME = 'groups';
 export const GROUPS_SUBSCRIBED_ROUTE_NAME = 'groups_subscribed';
+export const EVENT_ROUTE_NAME = 'event';
+export const EVENTS_ROUTE_NAME = 'events';
+export const EVENTS_SUGGESTED_ROUTE_NAME = 'events_suggested';
+export const EVENTS_SUBSCRIBED_ROUTE_NAME = 'events_subscribed';
+export const EVENTS_HIGHLIGHT_ROUTE_NAME = 'events_highlight';
 /**
  * Default Routes
  * @type {{[p: string]: string, '[POST_ROUTE_NAME]': string, '[INCUBATOR_ROUTE_NAME]': string, '[LOYALTY_ROUTE_NAME]': string, '[USER_NOTIFICATION_ROUTE_NAME]': string, '[USER_PRIVATE_MESSAGES_ROUTE_NAME]': string, '[COMMENT_ROUTE_NAME]': string, '[DISCUSSION_ROUTE_NAME]': string, '[CATEGORIES_ROUTE_NAME]': string, '[USER_PROFILE_ROUTE_NAME]': string, '[CATEGORY_ROUTE_NAME]': string, '[USER_PROFILE_SETTINGS_ROUTE_NAME]': string, '[STATUS_ROUTE_NAME]': string}}
@@ -74,4 +79,9 @@ export const defaultRoutes = {
     [GROUP_MESSAGES_ROUTE_NAME]: '/group/:id/:slug/messages/',
     [GROUPS_ROUTE_NAME]: '/groups/',
     [GROUPS_SUBSCRIBED_ROUTE_NAME]: '/groups/subscribed/',
+    [EVENTS_ROUTE_NAME]: '/events/',
+    [EVENTS_SUGGESTED_ROUTE_NAME]: '/events/suggested',
+    [EVENT_ROUTE_NAME]: '/event/:id/:slug/',
+    [EVENTS_SUBSCRIBED_ROUTE_NAME]: '/events/subscribed/',
+    [EVENTS_HIGHLIGHT_ROUTE_NAME]: '/events/highlight/',
 };

package/lib/esm/hooks/useSCFetchEvent.d.ts

@@ -0,0 +1,22 @@
+import { SCEventType } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch an event object.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.event
+ * @param object.autosubscribe
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchEvent({ id, event, autoSubscribe, cacheStrategy, }: {
+    id?: number | string;
+    event?: SCEventType;
+    autoSubscribe?: boolean;
+    cacheStrategy?: CacheStrategies;
+}): {
+    scEvent: SCEventType;
+    setSCEvent: (event: SCEventType) => void;
+    error: string;
+};

package/lib/esm/hooks/useSCFetchEvent.js

@@ -0,0 +1,84 @@
+import { useEffect, useMemo, useState } from 'react';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+import { SCEventPrivacyType, SCEventSubscriptionStatusType } from '@selfcommunity/types';
+import { Endpoints, EventService, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache, objectWithoutProperties } from '@selfcommunity/utils';
+import { getEventObjectCacheKey } from '../constants/Cache';
+import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
+import { useSCUser } from '../components/provider/SCUserProvider';
+/**
+ :::info
+ This custom hook is used to fetch an event object.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.event
+ * @param object.autosubscribe
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchEvent({ id = null, event = null, autoSubscribe = true, cacheStrategy = CacheStrategies.CACHE_FIRST, }) {
+    const __eventId = event ? event.id : id;
+    // CONTEXT
+    const scUserContext = useSCUser();
+    const authUserId = scUserContext.user ? scUserContext.user.id : null;
+    // CACHE
+    const __eventCacheKey = getEventObjectCacheKey(__eventId);
+    const __event = authUserId ? event : objectWithoutProperties(event, ['subscription_status']);
+    const [scEvent, setScEvent] = useState(cacheStrategy !== CacheStrategies.NETWORK_ONLY ? LRUCache.get(__eventCacheKey, __event) : null);
+    const [error, setError] = useState(null);
+    const setSCEvent = (event) => {
+        const _e = authUserId ? event : objectWithoutProperties(event, ['subscription_status']);
+        setScEvent(_e);
+        LRUCache.set(__eventCacheKey, _e);
+    };
+    /**
+     * Memoized fetchTag
+     */
+    const fetchEvent = useMemo(() => () => {
+        return http
+            .request({
+            url: Endpoints.GetEventInfo.url({ id: __eventId }),
+            method: Endpoints.GetEventInfo.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, [__eventId]);
+    /**
+     * If id attempt to get the event by id
+     */
+    useEffect(() => {
+        if (__eventId && scUserContext.user !== undefined && (!scEvent || (scEvent && __eventId !== scEvent.id))) {
+            fetchEvent()
+                .then((event) => {
+                if (autoSubscribe &&
+                    authUserId !== null &&
+                    ((event.privacy === SCEventPrivacyType.PUBLIC && !event.subscription_status) || event.subscription_status === SCEventSubscriptionStatusType.INVITED)) {
+                    // Auto subscribe to the event
+                    EventService.subscribeToEvent(event.id).then(() => {
+                        const updatedEvent = Object.assign(Object.assign({}, event), { subscription_status: SCEventSubscriptionStatusType.SUBSCRIBED });
+                        setSCEvent(updatedEvent);
+                    });
+                }
+                else {
+                    setSCEvent(event);
+                }
+            })
+                .catch((err) => {
+                LRUCache.delete(__eventCacheKey);
+                setError(`Event with id ${id} not found`);
+                Logger.error(SCOPE_SC_CORE, `Event with id ${id} not found`);
+                Logger.error(SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [__eventId, authUserId, scUserContext.user]);
+    useDeepCompareEffectNoCheck(() => {
+        if (event) {
+            setSCEvent(event);
+        }
+    }, [event, authUserId]);
+    return { scEvent, setSCEvent, error };
+}

package/lib/esm/hooks/useSCFetchEvents.d.ts

@@ -0,0 +1,22 @@
+import { SCEventType } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch events.
+ @param object.cacheStrategy
+
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {events, isLoading} = useSCFetchEvents();
+ ```
+ :::
+ * @param props
+ */
+declare const useSCFetchEvents: (props?: {
+    cacheStrategy?: CacheStrategies;
+}) => {
+    events: SCEventType[];
+    isLoading: boolean;
+};
+export default useSCFetchEvents;

package/lib/esm/hooks/useSCFetchEvents.js

@@ -0,0 +1,81 @@
+import { __awaiter } from "tslib";
+import { useEffect, useState } from 'react';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache } from '@selfcommunity/utils';
+import { getEventObjectCacheKey, getEventsObjectCacheKey } from '../constants/Cache';
+const init = { events: [], isLoading: true };
+// HYDRATE the cache
+const hydrate = (ids) => {
+    if (!ids) {
+        return null;
+    }
+    const events = ids.map((id) => {
+        const __eventCacheKey = getEventObjectCacheKey(id);
+        return LRUCache.get(__eventCacheKey);
+    });
+    if (events.filter((c) => !c).length > 0) {
+        // REVALIDATE CACHE
+        return null;
+    }
+    return events;
+};
+/**
+ :::info
+ This custom hook is used to fetch events.
+ @param object.cacheStrategy
+
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {events, isLoading} = useSCFetchEvents();
+ ```
+ :::
+ * @param props
+ */
+const useSCFetchEvents = (props) => {
+    // PROPS
+    const { cacheStrategy = CacheStrategies.CACHE_FIRST } = props || {};
+    // CACHE
+    const __eventsCacheKey = getEventsObjectCacheKey();
+    // STATE
+    const events = cacheStrategy !== CacheStrategies.NETWORK_ONLY ? hydrate(LRUCache.get(__eventsCacheKey, null)) : null;
+    const [data, setData] = useState(events !== null ? { events, isLoading: false } : init);
+    /**
+     * Fetch events
+     */
+    const fetchEvents = (next = Endpoints.GetUserEvents.url()) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield http.request({
+            url: next,
+            method: Endpoints.GetUserEvents.method,
+        });
+        const data = response.data;
+        if (data.next) {
+            return data.results.concat(yield fetchEvents(data.next));
+        }
+        return data.results;
+    });
+    /**
+     * Get events
+     */
+    useEffect(() => {
+        if (cacheStrategy === CacheStrategies.CACHE_FIRST && events) {
+            return;
+        }
+        fetchEvents()
+            .then((data) => {
+            setData({ events: data, isLoading: false });
+            LRUCache.set(__eventsCacheKey, data.map((event) => {
+                const __eventCacheKey = getEventObjectCacheKey(event.id);
+                LRUCache.set(__eventCacheKey, event);
+                return event.id;
+            }));
+        })
+            .catch((error) => {
+            console.log(error);
+            Logger.error(SCOPE_SC_CORE, 'Unable to retrieve events');
+        });
+    }, []);
+    return data;
+};
+export default useSCFetchEvents;

package/lib/esm/hooks/useSCSubscribedEventsManager.d.ts

@@ -0,0 +1,38 @@
+import { SCEventType, SCUserType } from '@selfcommunity/types';
+/**
+ :::info
+ This custom hook is used to manage the events followed.
+ :::
+
+ :::tip How to use it:
+ Follow these steps:
+ ```jsx
+ 1. const scUserContext: SCUserContextType = useSCUser();
+ 2. const scSubscribedEventsManager: SCSubscribedEventsManagerType = scUserContext.manager.events;
+ 3. scSubscribedEventsManager.isSubscribed(event)
+ ```
+ :::
+ */
+export default function useSCSubscribedEventsManager(user?: SCUserType): {
+    events: any[];
+    loading: any[];
+    isLoading: (v: number | {
+        id: number;
+    }) => boolean;
+    toggleEventAttendance?: undefined;
+    toggleEventNonattendance?: undefined;
+    subscriptionStatus?: undefined;
+    refresh?: undefined;
+    emptyCache?: undefined;
+} | {
+    events: any[];
+    loading: any[];
+    isLoading: (v: number | {
+        id: number;
+    }) => boolean;
+    toggleEventAttendance: (event: SCEventType, userId?: number) => Promise<any>;
+    toggleEventNonattendance: (event: SCEventType) => Promise<any>;
+    subscriptionStatus: (event?: SCEventType) => string;
+    refresh: () => void;
+    emptyCache: () => void;
+};

package/lib/esm/hooks/useSCSubscribedEventsManager.js

@@ -0,0 +1,293 @@
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { SCEventSubscriptionStatusType, SCFeatureName, SCNotificationTopicType, SCNotificationTypologyType, } from '@selfcommunity/types';
+import { Logger } from '@selfcommunity/utils';
+import PubSub from 'pubsub-js';
+import { useEffect, useMemo, useRef } from 'react';
+import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+import { SCNotificationMapping } from '../constants/Notification';
+import useSCCachingManager from './useSCCachingManager';
+import { getEventStatus } from '../utils/event';
+/**
+ :::info
+ This custom hook is used to manage the events followed.
+ :::
+
+ :::tip How to use it:
+ Follow these steps:
+ ```jsx
+ 1. const scUserContext: SCUserContextType = useSCUser();
+ 2. const scSubscribedEventsManager: SCSubscribedEventsManagerType = scUserContext.manager.events;
+ 3. scSubscribedEventsManager.isSubscribed(event)
+ ```
+ :::
+ */
+export default function useSCSubscribedEventsManager(user) {
+    const { cache, updateCache, emptyCache, data, setData, loading, setLoading, setUnLoading, isLoading } = useSCCachingManager();
+    const { features } = useSCPreferences();
+    const authUserId = user ? user.id : null;
+    const eventsEnabled = useMemo(() => features && features.includes(SCFeatureName.EVENT) && features.includes(SCFeatureName.TAGGING), [features]);
+    const notificationInvitedToJoinEvent = useRef(null);
+    const notificationRequestedToJoinEvent = useRef(null);
+    const notificationAcceptedToJoinEvent = useRef(null);
+    const notificationAddedToEvent = useRef(null);
+    /**
+     * Subscribe to notification types user_follow, user_unfollow
+     */
+    useDeepCompareEffectNoCheck(() => {
+        notificationInvitedToJoinEvent.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_INVITED_TO_JOIN_EVENT}`, notificationSubscriber);
+        notificationRequestedToJoinEvent.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_EVENT}`, notificationSubscriber);
+        notificationAcceptedToJoinEvent.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_EVENT}`, notificationSubscriber);
+        notificationAddedToEvent.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ADDED_TO_EVENT}`, notificationSubscriber);
+        return () => {
+            PubSub.unsubscribe(notificationInvitedToJoinEvent.current);
+            PubSub.unsubscribe(notificationRequestedToJoinEvent.current);
+            PubSub.unsubscribe(notificationAcceptedToJoinEvent.current);
+            PubSub.unsubscribe(notificationAddedToEvent.current);
+        };
+    }, [data]);
+    /**
+     * Notification subscriber handler
+     * @param msg
+     * @param dataMsg
+     */
+    const notificationSubscriber = (msg, dataMsg) => {
+        if (dataMsg.data.event !== undefined) {
+            let _status;
+            switch (SCNotificationMapping[dataMsg.data.activity_type]) {
+                case SCNotificationTypologyType.USER_INVITED_TO_JOIN_EVENT:
+                    _status = SCEventSubscriptionStatusType.INVITED;
+                    break;
+                case SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_EVENT:
+                    _status = SCEventSubscriptionStatusType.REQUESTED;
+                    break;
+                case SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_EVENT:
+                    _status = SCEventSubscriptionStatusType.SUBSCRIBED;
+                    break;
+                case SCNotificationTypologyType.USER_ADDED_TO_EVENT:
+                    _status = SCEventSubscriptionStatusType.SUBSCRIBED;
+                    break;
+            }
+            updateCache([dataMsg.data.event.id]);
+            setData((prev) => getDataUpdated(prev, dataMsg.data.event.id, _status));
+        }
+    };
+    /**
+     * Memoized refresh all events
+     * It makes a single request to the server and retrieves
+     * all the events followed by the user in a single solution
+     * It might be useful for multi-tab sync
+     */
+    const refresh = useMemo(() => () => {
+        emptyCache();
+        if (user) {
+            // Only if user is authenticated
+            http
+                .request({
+                url: Endpoints.GetUserEvents.url(),
+                method: Endpoints.GetUserEvents.method,
+            })
+                .then((res) => {
+                if (res.status >= 300) {
+                    return Promise.reject(res);
+                }
+                const eventsIds = res.data.results.map((e) => e.id);
+                updateCache(eventsIds);
+                setData(res.data.results.map((e) => ({ [e.id]: e.subscription_status })));
+                return Promise.resolve(res.data);
+            })
+                .catch((e) => {
+                Logger.error(SCOPE_SC_CORE, 'Unable to refresh the authenticated user events.');
+                Logger.error(SCOPE_SC_CORE, e);
+            });
+        }
+    }, [data, user, cache]);
+    /**
+     * Memoized toggleEventAttendance Event
+     * Toggle action
+     */
+    const toggleEventAttendance = useMemo(() => (event, userId) => {
+        setLoading(event.id);
+        if (userId) {
+            return http
+                .request({
+                url: Endpoints.InviteOrAcceptEventRequest.url({ id: event.id }),
+                method: Endpoints.InviteOrAcceptEventRequest.method,
+                data: { users: [userId] },
+            })
+                .then((res) => {
+                if (res.status >= 300) {
+                    return Promise.reject(res);
+                }
+                updateCache([event.id]);
+                setData((prev) => getDataUpdated(prev, event.id, SCEventSubscriptionStatusType.SUBSCRIBED));
+                setUnLoading(event.id);
+                return Promise.resolve(res.data);
+            });
+        }
+        else {
+            const requestConfig = !event.subscription_status || event.subscription_status === SCEventSubscriptionStatusType.INVITED
+                ? {
+                    url: Endpoints.SubscribeToEvent.url({ id: event.id }),
+                    method: Endpoints.SubscribeToEvent.method,
+                }
+                : event.subscription_status === SCEventSubscriptionStatusType.GOING
+                    ? {
+                        url: Endpoints.RemoveGoingToEvent.url({ id: event.id }),
+                        method: Endpoints.RemoveGoingToEvent.method,
+                    }
+                    : {
+                        url: Endpoints.GoToEvent.url({ id: event.id }),
+                        method: Endpoints.GoToEvent.method,
+                    };
+            return http.request(requestConfig).then((res) => {
+                if (res.status >= 300) {
+                    return Promise.reject(res);
+                }
+                updateCache([event.id]);
+                setData((prev) => getDataUpdated(prev, event.id, getEventStatus(event, true)));
+                setUnLoading(event.id);
+                return Promise.resolve(res.data);
+            });
+        }
+    }, [data, loading, cache]);
+    /**
+     * Memoized toggleEventNonattendance Event
+     * Toggle action
+     */
+    const toggleEventNonattendance = useMemo(() => (event) => {
+        if (event.subscription_status !== SCEventSubscriptionStatusType.REQUESTED) {
+            setLoading(event.id);
+            const requestConfig = event.subscription_status === SCEventSubscriptionStatusType.NOT_GOING
+                ? {
+                    url: Endpoints.RemoveNotGoingToEvent.url({ id: event.id }),
+                    method: Endpoints.RemoveNotGoingToEvent.method,
+                }
+                : {
+                    url: Endpoints.NotGoingToEvent.url({ id: event.id }),
+                    method: Endpoints.NotGoingToEvent.method,
+                };
+            return http.request(requestConfig).then((res) => {
+                if (res.status >= 300) {
+                    return Promise.reject(res);
+                }
+                updateCache([event.id]);
+                setData((prev) => getDataUpdated(prev, event.id, getEventStatus(event, false)));
+                setUnLoading(event.id);
+                return Promise.resolve(res.data);
+            });
+        }
+        else {
+            setLoading(event.id);
+            return http
+                .request({ url: Endpoints.UnsubscribeFromEvent.url({ id: event.id }), method: Endpoints.UnsubscribeFromEvent.method })
+                .then((res) => {
+                if (res.status >= 300) {
+                    return Promise.reject(res);
+                }
+                updateCache([event.id]);
+                setData((prev) => getDataUpdated(prev, event.id, null));
+                setUnLoading(event.id);
+                return Promise.resolve(res.data);
+            });
+        }
+    }, [data, loading, cache]);
+    /**
+     * Check the authenticated user subscription status to the event
+     * Update the events cached
+     * Update events subscription statuses
+     * @param event
+     */
+    const checkEventSubscriptionStatus = (event) => {
+        setLoading(event.id);
+        return http
+            .request({
+            url: Endpoints.GetEventSubscriptionStatus.url({ id: event.id }),
+            method: Endpoints.GetEventSubscriptionStatus.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            setData((prev) => getDataUpdated(prev, event.id, res.data.status));
+            updateCache([event.id]);
+            setUnLoading(event.id);
+            return Promise.resolve(res.data);
+        })
+            .catch((e) => {
+            setUnLoading(event.id);
+            return Promise.reject(e);
+        });
+    };
+    /**
+     * Get updated data
+     * @param data
+     * @param eventId
+     * @param subscriptionStatus
+     */
+    const getDataUpdated = (data, eventId, subscriptionStatus) => {
+        const _index = data.findIndex((k) => parseInt(Object.keys(k)[0]) === eventId);
+        let _data;
+        if (_index < 0) {
+            _data = [...data, ...[{ [eventId]: subscriptionStatus }]];
+        }
+        else {
+            _data = data.map((k, i) => {
+                if (parseInt(Object.keys(k)[0]) === eventId) {
+                    return { [Object.keys(k)[0]]: subscriptionStatus };
+                }
+                return { [Object.keys(k)[0]]: data[i][Object.keys(k)[0]] };
+            });
+        }
+        return _data;
+    };
+    /**
+     * Return current event subscription status if exists,
+     * otherwise return null
+     */
+    const getCurrentEventCacheStatus = useMemo(() => (event) => {
+        const d = data.filter((k) => parseInt(Object.keys(k)[0]) === event.id);
+        return d.length ? d[0][event.id] : !data.length ? event.subscription_status : null;
+    }, [data]);
+    /**
+     * Bypass remote check if the event is subscribed
+     */
+    const getSubscriptionStatus = useMemo(() => (event) => {
+        updateCache([event.id]);
+        setData((prev) => getDataUpdated(prev, event.id, event.subscription_status));
+        return event.subscription_status;
+    }, [data, cache]);
+    /**
+     * Memoized subscriptionStatus
+     * If event is already in cache -> check if the event is in events,
+     * otherwise, check if user toggleEventAttendance the event
+     */
+    const subscriptionStatus = useMemo(() => (event) => {
+        // Cache is valid also for anonymous user
+        if (cache.includes(event === null || event === void 0 ? void 0 : event.id)) {
+            return getCurrentEventCacheStatus(event);
+        }
+        if (authUserId && event) {
+            if ('subscription_status' in event) {
+                return getSubscriptionStatus(event);
+            }
+            if (!isLoading(event)) {
+                checkEventSubscriptionStatus(event);
+            }
+        }
+        return null;
+    }, [loading, cache, authUserId]);
+    /**
+     * Empty cache on logout
+     */
+    useEffect(() => {
+        if (!authUserId) {
+            emptyCache();
+        }
+    }, [authUserId]);
+    if (!eventsEnabled || !user) {
+        return { events: data, loading, isLoading };
+    }
+    return { events: data, loading, isLoading, toggleEventAttendance, toggleEventNonattendance, subscriptionStatus, refresh, emptyCache };
+}

package/lib/esm/hooks/useSCWebPushMessaging.js

@@ -1,4 +1,5 @@
-import React, { useContext, useEffect, useRef, useState } from 'react';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useEffect, useRef, useState } from 'react';
 import { useSCContext } from '../components/provider/SCContextProvider';
 import { useSCUser } from '../components/provider/SCUserProvider';
 import { Logger } from '@selfcommunity/utils';
@@ -56,9 +57,7 @@ export default function useSCWebPushMessaging() {
     const showCustomRequestNotificationSnackbar = () => {
         if (!Cookies.get(NOTIFICATIONS_WEB_PUSH_MESSAGING_DIALOG_COOKIE)) {
             enqueueSnackbar(intl.formatMessage({ id: 'ui.webPushNotification.requestPermission', defaultMessage: 'ui.webPushNotification.requestPermission' }), {
-                action: (snackbarId) => (React.createElement(React.Fragment, null,
-                    React.createElement(Button, { size: "small", sx: { color: '#FFF' }, onClick: () => requestNotificationPermission(snackbarId) }, intl.formatMessage({ id: 'ui.webPushNotification.allow', defaultMessage: 'ui.webPushNotification.allow' })),
-                    React.createElement(Button, { size: "small", sx: { color: '#FFF' }, onClick: () => closeRequestNotificationSnackbar(snackbarId) }, intl.formatMessage({ id: 'ui.webPushNotification.block', defaultMessage: 'ui.webPushNotification.block' })))),
+                action: (snackbarId) => (_jsxs(_Fragment, { children: [_jsx(Button, Object.assign({ size: "small", sx: { color: '#FFF' }, onClick: () => requestNotificationPermission(snackbarId) }, { children: intl.formatMessage({ id: 'ui.webPushNotification.allow', defaultMessage: 'ui.webPushNotification.allow' }) })), _jsx(Button, Object.assign({ size: "small", sx: { color: '#FFF' }, onClick: () => closeRequestNotificationSnackbar(snackbarId) }, { children: intl.formatMessage({ id: 'ui.webPushNotification.block', defaultMessage: 'ui.webPushNotification.block' }) }))] })),
                 variant: 'default',
                 anchorOrigin: { horizontal: 'center', vertical: 'bottom' },
                 preventDuplicate: true,

package/lib/esm/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Types
  */
-import { SCUserContextType, SCFollowedCategoriesManagerType, SCContextProviderType, SCContextType, SCSettingsType, SCSessionType, SCFollowedManagerType, SCFollowersManagerType, SCSettingsManagerType, SCConnectionsManagerType, SCSubscribedIncubatorsManagerType, SCLocaleType, SCNotificationContextType, SCPreferencesContextType, SCThemeContextType, SCRoutingContextType, SCLocaleContextType, SCAlertMessagesContextType, SCThemeAvatarVariableType, SCThemeCategoryIconVariableType, SCThemeCategoryVariableType, SCThemeVariablesType, SCThemeType, SCSubscribedGroupsManagerType } from './types';
+import { SCUserContextType, SCFollowedCategoriesManagerType, SCContextProviderType, SCContextType, SCSettingsType, SCSessionType, SCFollowedManagerType, SCFollowersManagerType, SCSettingsManagerType, SCConnectionsManagerType, SCSubscribedIncubatorsManagerType, SCLocaleType, SCNotificationContextType, SCPreferencesContextType, SCThemeContextType, SCRoutingContextType, SCLocaleContextType, SCAlertMessagesContextType, SCThemeAvatarVariableType, SCThemeCategoryIconVariableType, SCThemeCategoryVariableType, SCThemeVariablesType, SCThemeType, SCSubscribedGroupsManagerType, SCSubscribedEventsManagerType } from './types';
 /**
  * ContextProvider component
  */
@@ -62,6 +62,8 @@ import useSCFetchUserBlockedBy from './hooks/useSCFetchUserBlockedBy';
 import useSCUserIsBlocked from './hooks/useSCUserIsBlocked';
 import useSCFetchGroup from './hooks/useSCFetchGroup';
 import useSCFetchGroups from './hooks/useSCFetchGroups';
+import useSCFetchEvent from './hooks/useSCFetchEvent';
+import useSCFetchEvents from './hooks/useSCFetchEvents';
 /**
  * Routing component
  */
@@ -72,13 +74,16 @@ import * as SCRoutes from './constants/Routes';
  * User, hooks (useIsComponentMountedRef)
  */
 import * as UserUtils from './utils/user';
+import getTheme from './themes/theme';
 import { useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect } from './utils/hooks';
+import { getEventStatus } from './utils/event';
 /**
  * Constants:
- * Locale
+ * Locale, Preferences
  */
 import * as Locale from './constants/Locale';
+import * as Preferences from './constants/Preferences';
 /**
  * List all exports
  */
-export { SCUserContextType, SCFollowedCategoriesManagerType, SCContextProviderType, SCContextType, SCSettingsType, SCSessionType, SCSettingsManagerType, SCFollowedManagerType, SCFollowersManagerType, SCConnectionsManagerType, SCSubscribedIncubatorsManagerType, SCLocaleType, SCNotificationContextType, SCPreferencesContextType, SCThemeContextType, SCRoutingContextType, SCLocaleContextType, SCAlertMessagesContextType, SCThemeAvatarVariableType, SCThemeCategoryIconVariableType, SCThemeCategoryVariableType, SCThemeVariablesType, SCThemeType, SCSubscribedGroupsManagerType, SCContext, SCUserContext, SCThemeContext, SCRoutingContext, SCLocaleContext, SCPreferencesContext, useSCContext, SCContextProvider, SCUserProvider, useSCUser, useSCPreferences, SCThemeProvider, useSCTheme, withSCTheme, SCRoutingProvider, useSCRouting, SCLocaleProvider, useSCLocale, withSCLocale, SCPreferencesProvider, SCPreferences, SCFeatures, SCNotification, SCNotificationProvider, SCNotificationContext, useSCNotification, SCAlertMessagesProvider, SCAlertMessagesContext, useSCAlertMessages, Link, SCRoutes, SCCache, UserUtils, Locale, useSCFetchUser, useSCFetchUserProviders, useSCFetchVote, useSCFetchFeedObject, useSCFetchCommentObject, useSCFetchCommentObjects, useSCFetchCustomAdv, useSCFetchTag, useSCFetchAddressingTagList, useSCFetchCategory, useSCFetchCategories, useSCFetchIncubator, useSCMediaClick, useSCFetchContributors, useSCFetchFeed, useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect, useSCFetchPrivateMessageSnippets, useSCFetchBroadcastMessages, useSCFetchUserBlockedBy, useSCUserIsBlocked, useSCFetchGroup, useSCFetchGroups, };
+export { SCUserContextType, SCFollowedCategoriesManagerType, SCContextProviderType, SCContextType, SCSettingsType, SCSessionType, SCSettingsManagerType, SCFollowedManagerType, SCFollowersManagerType, SCConnectionsManagerType, SCSubscribedIncubatorsManagerType, SCLocaleType, SCNotificationContextType, SCPreferencesContextType, SCThemeContextType, SCRoutingContextType, SCLocaleContextType, SCAlertMessagesContextType, SCThemeAvatarVariableType, SCThemeCategoryIconVariableType, SCThemeCategoryVariableType, SCThemeVariablesType, SCThemeType, SCSubscribedGroupsManagerType, SCSubscribedEventsManagerType, SCContext, SCUserContext, SCThemeContext, SCRoutingContext, SCLocaleContext, SCPreferencesContext, useSCContext, SCContextProvider, SCUserProvider, useSCUser, useSCPreferences, SCThemeProvider, useSCTheme, withSCTheme, getTheme, SCRoutingProvider, useSCRouting, SCLocaleProvider, useSCLocale, withSCLocale, SCPreferencesProvider, SCPreferences, SCFeatures, SCNotification, SCNotificationProvider, SCNotificationContext, useSCNotification, SCAlertMessagesProvider, SCAlertMessagesContext, useSCAlertMessages, Link, SCRoutes, SCCache, UserUtils, getEventStatus, Locale, Preferences, useSCFetchUser, useSCFetchUserProviders, useSCFetchVote, useSCFetchFeedObject, useSCFetchCommentObject, useSCFetchCommentObjects, useSCFetchCustomAdv, useSCFetchTag, useSCFetchAddressingTagList, useSCFetchCategory, useSCFetchCategories, useSCFetchIncubator, useSCMediaClick, useSCFetchContributors, useSCFetchFeed, useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect, useSCFetchPrivateMessageSnippets, useSCFetchBroadcastMessages, useSCFetchUserBlockedBy, useSCUserIsBlocked, useSCFetchGroup, useSCFetchGroups, useSCFetchEvent, useSCFetchEvents, };