@selfcommunity/react-core 0.4.50-alpha.1 → 0.4.50-events.100

package/lib/esm/components/provider/SCUserProvider/index.js

@@ -1,8 +1,9 @@
-import React, { createContext, useContext, useEffect, useMemo, useRef } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useRef } from 'react';
 import { UserService } from '@selfcommunity/api-services';
 import { SCContext } from '../SCContextProvider';
 import useSCAuth, { userActionTypes } from '../../../hooks/useSCAuth';
-import { isClientSideRendering, Logger } from '@selfcommunity/utils';
+import { Logger } from '@selfcommunity/utils';
 import PubSub from 'pubsub-js';
 import { SCOPE_SC_CORE } from '../../../constants/Errors';
 import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
@@ -16,6 +17,7 @@ import useSCSubscribedIncubatorsManager from '../../../hooks/useSCSubscribedIncu
 import useSCBlockedUsersManager from '../../../hooks/useSCBlockedUsersManager';
 import * as Session from '../../../constants/Session';
 import useSCSubscribedGroupsManager from '../../../hooks/useSCSubscribedGroupsManager';
+import useSCSubscribedEventsManager from '../../../hooks/useSCSubscribedEventsManager';
 /**
  * SCUserContext (Authentication Context)
  *
@@ -68,6 +70,7 @@ export default function SCUserProvider({ children }) {
     const categoriesManager = useSCFollowedCategoriesManager(state.user, updateUser);
     const blockedUsersManager = useSCBlockedUsersManager(state.user);
     const subscribedGroupsManager = useSCSubscribedGroupsManager(state.user);
+    const subscribedEventsManager = useSCSubscribedEventsManager(state.user);
     /**
      * Ref notifications subscribers: BLOCKED_USER, UNBLOCKED_USER
      */
@@ -100,17 +103,17 @@ export default function SCUserProvider({ children }) {
      * and document is in foreground refresh the cache
      */
     useEffect(() => {
-        typeof window !== 'undefined' && window.document.addEventListener('visibilitychange', handleVisibilityChange);
+        window.document.addEventListener('visibilitychange', handleVisibilityChange);
         return () => {
-            typeof window !== 'undefined' && window.document.removeEventListener('visibilitychange', handleVisibilityChange);
+            window.document.removeEventListener('visibilitychange', handleVisibilityChange);
         };
-    });
+    }, []);
     /**
      * handler handleVisibilityChange for this provider
      * Refresh followed categories, users, etc..
      */
     function handleVisibilityChange() {
-        if (isClientSideRendering() && !window.document.hidden && state.user) {
+        if (!window.document.hidden && state.user) {
             settingsManager.refresh && settingsManager.refresh();
             refreshCounters();
             categoriesManager.refresh && categoriesManager.refresh();
@@ -119,6 +122,7 @@ export default function SCUserProvider({ children }) {
             subscribedIncubatorsManager.refresh && subscribedIncubatorsManager.refresh();
             blockedUsersManager.refresh && blockedUsersManager.refresh();
             subscribedGroupsManager.refresh && subscribedGroupsManager.refresh();
+            subscribedEventsManager.refresh && subscribedEventsManager.refresh();
         }
     }
     /**
@@ -215,6 +219,7 @@ export default function SCUserProvider({ children }) {
             incubators: subscribedIncubatorsManager,
             blockedUsers: blockedUsersManager,
             groups: subscribedGroupsManager,
+            events: subscribedEventsManager,
         },
     }), [
         state,
@@ -233,12 +238,14 @@ export default function SCUserProvider({ children }) {
         subscribedIncubatorsManager.incubators,
         subscribedGroupsManager.loading,
         subscribedGroupsManager.groups,
+        subscribedEventsManager.loading,
+        subscribedEventsManager.events,
     ]);
     /**
      * We only want to render the underlying app after we
      * assert for the presence of a current user.
      */
-    return React.createElement(SCUserContext.Provider, { value: contextValue }, children);
+    return _jsx(SCUserContext.Provider, Object.assign({ value: contextValue }, { children: children }));
 }
 /**
  * Let's only export the `useSCUser` hook instead of the context.

package/lib/esm/components/provider/SCVoteProvider/index.js

@@ -1,4 +1,5 @@
-import React, { createContext, useCallback, useContext, useEffect, useState } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useState } from 'react';
 import { ReactionService } from '@selfcommunity/api-services';
 import { Logger } from '@selfcommunity/utils';
 import { SCOPE_SC_CORE } from '../../../constants/Errors';
@@ -78,7 +79,7 @@ export default function SCVoteProvider({ children = null }) {
      * Nesting all necessary providers
      * All child components will use help contexts to works
      */
-    return React.createElement(SCVoteContext.Provider, { value: { reactions, isLoading, refreshReactions } }, initialized && children);
+    return _jsx(SCVoteContext.Provider, Object.assign({ value: { reactions, isLoading, refreshReactions } }, { children: initialized && children }));
 }
 /**
  * Let's only export the `useSCPreferences` hook instead of the context.

package/lib/esm/components/router/index.js

@@ -1,4 +1,5 @@
 import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useContext } from 'react';
 import { SCRoutingContext } from '../provider/SCRoutingProvider';
 /**
@@ -19,10 +20,10 @@ const Link = (_a, ref) => {
     const scRoutingContext = useContext(SCRoutingContext);
     if (scRoutingContext.routerLink) {
         const ComponentLink = scRoutingContext.routerLink;
-        return (React.createElement(ComponentLink, Object.assign({}, other, { ref: ref }), children));
+        return (_jsx(ComponentLink, Object.assign({}, other, { ref: ref }, { children: children })));
     }
     const { to } = other, rest = __rest(other, ["to"]);
-    return (React.createElement("a", Object.assign({ href: to }, rest, { ref: ref }), children));
+    return (_jsx("a", Object.assign({ href: to }, rest, { ref: ref }, { children: children })));
 };
 /**
  :::info

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

@@ -17,6 +17,12 @@ export declare const getCategoriesObjectCacheKey: () => string;
 /** CATEGORY OBJECT **/
 export declare const CATEGORY_OBJECT_CACHE_PREFIX_KEY = "_ca_";
 export declare const getCategoryObjectCacheKey: (id: any) => string;
+/** EVENT OBJECT **/
+export declare const EVENT_OBJECT_CACHE_PREFIX_KEY = "_evt_";
+export declare const getEventObjectCacheKey: (id: any) => string;
+/** EVENTS OBJECT **/
+export declare const EVENTS_OBJECT_CACHE_PREFIX_KEY = "_evts_";
+export declare const getEventsObjectCacheKey: () => string;
 /** GROUP OBJECT **/
 export declare const GROUP_OBJECT_CACHE_PREFIX_KEY = "_grp_";
 export declare const getGroupObjectCacheKey: (id: any) => string;
@@ -58,6 +64,11 @@ export declare const CATEGORIES_SUGGESTION_TOOLS_STATE_CACHE_PREFIX_KEY = "_cSug
 export declare const CATEGORIES_POPULAR_TOOLS_STATE_CACHE_PREFIX_KEY = "_cPopWidget_";
 export declare const USER_FOLLOWERS_TOOLS_STATE_CACHE_PREFIX_KEY = "_uFolWidget_";
 export declare const USER_FOLLOWED_TOOLS_STATE_CACHE_PREFIX_KEY = "_uFoldWidget_";
+export declare const USER_EVENTS_STATE_CACHE_PREFIX_KEY = "_uEvents_";
+export declare const USER_OTHER_EVENTS_STATE_CACHE_PREFIX_KEY = "_uOtherEvents_";
+export declare const USER_PARTECIPANTS_EVENTS_STATE_CACHE_PREFIX_KEY = "_uPartecipantsEvents_";
+export declare const USER_INVITED_EVENTS_STATE_CACHE_PREFIX_KEY = "_uInvitedEvents_";
+export declare const USER_REQUESTS_EVENTS_STATE_CACHE_PREFIX_KEY = "_uRequestsEvents_";
 export declare const USER_CONNECTIONS_TOOLS_STATE_CACHE_PREFIX_KEY = "_uConWidget_";
 export declare const USER_CONNECTIONS_REQUESTS_TOOLS_STATE_CACHE_PREFIX_KEY = "_uConReqWidget_";
 export declare const USER_CONNECTIONS_REQUESTS_SENT_TOOLS_STATE_CACHE_PREFIX_KEY = "_uConReqSentWidget_";

package/lib/esm/constants/Cache.js

@@ -17,6 +17,12 @@ export const getCategoriesObjectCacheKey = () => `${CATEGORIES_OBJECT_CACHE_PREF
 /** CATEGORY OBJECT **/
 export const CATEGORY_OBJECT_CACHE_PREFIX_KEY = '_ca_';
 export const getCategoryObjectCacheKey = (id) => `${CATEGORY_OBJECT_CACHE_PREFIX_KEY}${id}`;
+/** EVENT OBJECT **/
+export const EVENT_OBJECT_CACHE_PREFIX_KEY = '_evt_';
+export const getEventObjectCacheKey = (id) => `${EVENT_OBJECT_CACHE_PREFIX_KEY}${id}`;
+/** EVENTS OBJECT **/
+export const EVENTS_OBJECT_CACHE_PREFIX_KEY = '_evts_';
+export const getEventsObjectCacheKey = () => `${EVENTS_OBJECT_CACHE_PREFIX_KEY}`;
 /** GROUP OBJECT **/
 export const GROUP_OBJECT_CACHE_PREFIX_KEY = '_grp_';
 export const getGroupObjectCacheKey = (id) => `${GROUP_OBJECT_CACHE_PREFIX_KEY}${id}`;
@@ -62,6 +68,11 @@ export const CATEGORIES_SUGGESTION_TOOLS_STATE_CACHE_PREFIX_KEY = '_cSugWidget_'
 export const CATEGORIES_POPULAR_TOOLS_STATE_CACHE_PREFIX_KEY = '_cPopWidget_';
 export const USER_FOLLOWERS_TOOLS_STATE_CACHE_PREFIX_KEY = '_uFolWidget_';
 export const USER_FOLLOWED_TOOLS_STATE_CACHE_PREFIX_KEY = '_uFoldWidget_';
+export const USER_EVENTS_STATE_CACHE_PREFIX_KEY = '_uEvents_';
+export const USER_OTHER_EVENTS_STATE_CACHE_PREFIX_KEY = '_uOtherEvents_';
+export const USER_PARTECIPANTS_EVENTS_STATE_CACHE_PREFIX_KEY = '_uPartecipantsEvents_';
+export const USER_INVITED_EVENTS_STATE_CACHE_PREFIX_KEY = '_uInvitedEvents_';
+export const USER_REQUESTS_EVENTS_STATE_CACHE_PREFIX_KEY = '_uRequestsEvents_';
 export const USER_CONNECTIONS_TOOLS_STATE_CACHE_PREFIX_KEY = '_uConWidget_';
 export const USER_CONNECTIONS_REQUESTS_TOOLS_STATE_CACHE_PREFIX_KEY = '_uConReqWidget_';
 export const USER_CONNECTIONS_REQUESTS_SENT_TOOLS_STATE_CACHE_PREFIX_KEY = '_uConReqSentWidget_';

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

@@ -0,0 +1,13 @@
+export declare const INTEGRATIONS_OPTION = "integrations";
+export declare const INTEGRATIONS_OPENAI_OPTION = "openai";
+export declare const INTEGRATIONS_OPENAI_SECRETKEY_OPTION = "secretKey";
+export declare const INTEGRATIONS_GEOCODING_OPTION = "geocoding";
+export declare const INTEGRATIONS_GEOCODING_APIKEY_OPTION = "apiKey";
+export declare const DEFAULT_INTEGRATIONS_OPTION: {
+    openai: {
+        secretKey: any;
+    };
+    geocoding: {
+        apiKey: any;
+    };
+};

package/lib/esm/constants/Integrations.js

@@ -0,0 +1,14 @@
+// integrations
+export const INTEGRATIONS_OPTION = 'integrations';
+export const INTEGRATIONS_OPENAI_OPTION = 'openai';
+export const INTEGRATIONS_OPENAI_SECRETKEY_OPTION = 'secretKey';
+export const INTEGRATIONS_GEOCODING_OPTION = 'geocoding';
+export const INTEGRATIONS_GEOCODING_APIKEY_OPTION = 'apiKey';
+export const DEFAULT_INTEGRATIONS_OPTION = {
+    [INTEGRATIONS_OPENAI_OPTION]: {
+        [INTEGRATIONS_OPENAI_SECRETKEY_OPTION]: null,
+    },
+    [INTEGRATIONS_GEOCODING_OPTION]: {
+        [INTEGRATIONS_GEOCODING_APIKEY_OPTION]: null,
+    },
+};

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

@@ -9,6 +9,7 @@ export declare const NOTIFICATIONS_MOBILE_NATIVE_PUSH_MESSAGING_OPTION = "mobile
 export declare const NOTIFICATIONS_WEB_PUSH_MESSAGING_DIALOG_COOKIE = "wpnDialogDisabled";
 export declare const NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION = "disableToastMessage";
 export declare const NOTIFICATIONS_MOBILE_NATIVE_DISABLE_OPTION = "disable";
-export declare const NOTIFICATIONS_SECURE_OPTION = "secure";
+export declare const NOTIFICATIONS_WEBSOCKET_SECURE_OPTION = "secure";
+export declare const NOTIFICATIONS_WEBSOCKET_PREFIX_PATH_OPTION = "prefixPath";
 export declare const NOTIFICATIONS_APPLICATION_SERVER_KEY_OPTION = "applicationServerKey";
 export declare const DEFAULT_NOTIFICATIONS: SCNotificationsType;

package/lib/esm/constants/Notifications.js

@@ -5,12 +5,13 @@ export const NOTIFICATIONS_MOBILE_NATIVE_PUSH_MESSAGING_OPTION = 'mobileNativePu
 export const NOTIFICATIONS_WEB_PUSH_MESSAGING_DIALOG_COOKIE = 'wpnDialogDisabled';
 export const NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION = 'disableToastMessage';
 export const NOTIFICATIONS_MOBILE_NATIVE_DISABLE_OPTION = 'disable';
-export const NOTIFICATIONS_SECURE_OPTION = 'secure';
+export const NOTIFICATIONS_WEBSOCKET_SECURE_OPTION = 'secure';
+export const NOTIFICATIONS_WEBSOCKET_PREFIX_PATH_OPTION = 'prefixPath';
 export const NOTIFICATIONS_APPLICATION_SERVER_KEY_OPTION = 'applicationServerKey';
 export const DEFAULT_NOTIFICATIONS = {
     [NOTIFICATIONS_WEB_SOCKET_OPTION]: {
         [NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION]: false,
-        [NOTIFICATIONS_SECURE_OPTION]: true,
+        [NOTIFICATIONS_WEBSOCKET_SECURE_OPTION]: true,
     },
     [NOTIFICATIONS_WEB_PUSH_MESSAGING_OPTION]: {
         [NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION]: true,

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

@@ -129,6 +129,9 @@ export declare const CONFIGURATIONS_CUSTOM_NAVBAR_ITEM_IMAGE: string;
 export declare const CONFIGURATIONS_GROUPS_ONLY_STAFF_ENABLED: string;
 export declare const CONFIGURATIONS_GROUPS_VISIBILITY_ENABLED: string;
 export declare const CONFIGURATIONS_GROUPS_PRIVATE_ENABLED: string;
+export declare const CONFIGURATIONS_EVENTS_ONLY_STAFF_ENABLED: string;
+export declare const CONFIGURATIONS_EVENTS_VISIBILITY_ENABLED: string;
+export declare const CONFIGURATIONS_EVENTS_PRIVATE_ENABLED: string;
 /**
  * PROVIDERS
  */

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.privacy === SCEventPrivacyType.PRIVATE && event.subscription_status === SCEventSubscriptionStatusType.INVITED))) {
+                    // Auto subscribe to the event
+                    EventService.subscribeToEvent(event.id).then(() => {
+                        setSCEvent(event);
+                    });
+                }
+                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;
+};