@selfcommunity/react-core 0.7.0-alpha.2 → 0.7.0-alpha.20

package/lib/esm/hooks/useSCJoinedCoursesManager.js

@@ -1,3 +1,4 @@
+import { __awaiter } from "tslib";
 import { useEffect, useMemo, useRef } from 'react';
 import { Endpoints, http } from '@selfcommunity/api-services';
 import { SCFeatureName, SCCoursePrivacyType, SCCourseJoinStatusType, SCNotificationTopicType, SCNotificationTypologyType, } from '@selfcommunity/types';
@@ -33,21 +34,15 @@ export default function useSCJoinedCoursesManager(user) {
         CONFIGURATIONS_COURSES_ENABLED in preferences &&
         preferences[CONFIGURATIONS_COURSES_ENABLED].value, [preferences, features]);
     const notificationInvitedToJoinCourse = useRef(null);
-    const notificationRequestedToJoinCourse = useRef(null);
-    const notificationAcceptedToJoinCourse = useRef(null);
     const notificationAddedToCourse = useRef(null);
     /**
      * Subscribe to notification types user_follow, user_unfollow
      */
     useDeepCompareEffectNoCheck(() => {
         notificationInvitedToJoinCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_INVITED_TO_JOIN_COURSE}`, notificationSubscriber);
-        notificationRequestedToJoinCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_COURSE}`, notificationSubscriber);
-        notificationAcceptedToJoinCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_COURSE}`, notificationSubscriber);
         notificationAddedToCourse.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ADDED_TO_COURSE}`, notificationSubscriber);
         return () => {
             PubSub.unsubscribe(notificationInvitedToJoinCourse.current);
-            PubSub.unsubscribe(notificationRequestedToJoinCourse.current);
-            PubSub.unsubscribe(notificationAcceptedToJoinCourse.current);
             PubSub.unsubscribe(notificationAddedToCourse.current);
         };
     }, [data]);
@@ -57,20 +52,20 @@ export default function useSCJoinedCoursesManager(user) {
      * @param dataMsg
      */
     const notificationSubscriber = (msg, dataMsg) => {
+        var _a;
         if (dataMsg.data.course !== undefined) {
             let _status;
             switch (SCNotificationMapping[dataMsg.data.activity_type]) {
                 case SCNotificationTypologyType.USER_INVITED_TO_JOIN_COURSE:
                     _status = SCCourseJoinStatusType.INVITED;
                     break;
-                case SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_COURSE:
-                    _status = SCCourseJoinStatusType.REQUESTED;
-                    break;
-                case SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_COURSE:
-                    _status = SCCourseJoinStatusType.JOINED;
-                    break;
                 case SCNotificationTypologyType.USER_ADDED_TO_COURSE:
-                    _status = SCCourseJoinStatusType.JOINED;
+                    if (dataMsg.data.notification_obj.course && ((_a = dataMsg.data.notification_obj.course.paywalls) === null || _a === void 0 ? void 0 : _a.length)) {
+                        _status = SCCourseJoinStatusType.PAYMENT_WAITING;
+                    }
+                    else {
+                        _status = SCCourseJoinStatusType.JOINED;
+                    }
                     break;
             }
             updateCache([dataMsg.data.course]);
@@ -89,8 +84,8 @@ export default function useSCJoinedCoursesManager(user) {
             // Only if user is authenticated
             http
                 .request({
-                url: Endpoints.GetJoinedCourses.url(),
-                method: Endpoints.GetJoinedCourses.method,
+                url: Endpoints.GetUserJoinedCourses.url({ id: user.id }),
+                method: Endpoints.GetUserJoinedCourses.method,
             })
                 .then((res) => {
                 if (res.status >= 300) {
@@ -111,67 +106,42 @@ export default function useSCJoinedCoursesManager(user) {
      * Memoized join Course
      * Toggle action
      */
-    const join = useMemo(() => (course, userId) => {
+    const join = useMemo(() => (course) => __awaiter(this, void 0, void 0, function* () {
         setLoading(course.id);
-        if (userId) {
-            return http
-                .request({
-                url: Endpoints.InviteOrAcceptUsersToCourse.url({ id: course.id }),
-                method: Endpoints.InviteOrAcceptUsersToCourse.method,
-                data: { users: [userId] },
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, SCCourseJoinStatusType.JOINED));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
-            });
-        }
-        else {
-            return http
-                .request({
-                url: Endpoints.JoinOrAcceptInviteToCourse.url({ id: course.id }),
-                method: Endpoints.JoinOrAcceptInviteToCourse.method,
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, course.privacy === SCCoursePrivacyType.PRIVATE && course.join_status !== SCCourseJoinStatusType.INVITED
-                    ? SCCourseJoinStatusType.REQUESTED
-                    : SCCourseJoinStatusType.JOINED));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
-            });
+        const res = yield http.request({
+            url: Endpoints.JoinOrAcceptInviteToCourse.url({ id: course.id }),
+            method: Endpoints.JoinOrAcceptInviteToCourse.method,
+        });
+        if (res.status >= 300) {
+            return Promise.reject(res);
         }
-    }, [data, loading, cache]);
+        updateCache([course.id]);
+        setData((prev) => getDataUpdated(prev, course.id, course.privacy === SCCoursePrivacyType.PRIVATE && course.join_status !== SCCourseJoinStatusType.INVITED
+            ? SCCourseJoinStatusType.REQUESTED
+            : SCCourseJoinStatusType.JOINED));
+        setUnLoading(course.id);
+        return yield Promise.resolve(res.data);
+    }), [data, loading, cache]);
     /**
      * Memoized leave Course
      * Toggle action
      */
-    const leave = useMemo(() => (course) => {
-        if (course.join_status !== SCCourseJoinStatusType.REQUESTED) {
+    const leave = useMemo(() => (course) => __awaiter(this, void 0, void 0, function* () {
+        if (data[course.id] !== SCCourseJoinStatusType.REQUESTED) {
             setLoading(course.id);
-            return http
-                .request({
+            const res = yield http.request({
                 url: Endpoints.LeaveOrRemoveCourseRequest.url({ id: course.id }),
                 method: Endpoints.LeaveOrRemoveCourseRequest.method,
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, null));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
             });
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            updateCache([course.id]);
+            setData((prev) => getDataUpdated(prev, course.id, null));
+            setUnLoading(course.id);
+            return yield Promise.resolve(res.data);
         }
-    }, [data, loading, cache]);
+    }), [data, loading, cache]);
     /**
      * Check the authenticated user subscription status to the course
      * Update the courses cached
@@ -247,7 +217,7 @@ export default function useSCJoinedCoursesManager(user) {
         if (cache.includes(course.id)) {
             return getCurrentCourseCacheStatus(course);
         }
-        if (authUserId) {
+        if (authUserId && course) {
             if ('join_status' in course) {
                 return getJoinStatus(course);
             }
@@ -256,7 +226,7 @@ export default function useSCJoinedCoursesManager(user) {
             }
         }
         return null;
-    }, [loading, cache, authUserId]);
+    }, [loading, cache, authUserId, getJoinStatus, getCurrentCourseCacheStatus]);
     /**
      * Empty cache on logout
      */

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

@@ -0,0 +1,18 @@
+/**
+ :::info
+ This custom hook is used to check if the payments are enabled
+ :::
+ :::tip How to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. import useSCPaymentsEnabled from '@selfcommunity/react-core';
+ 2.	const {isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId} = useSCPaymentsEnabled();
+ ```
+ :::
+ */
+export default function useSCPaymentsEnabled(): {
+    isPaymentsEnabled: any;
+    stripePublicKey: any;
+    stripeConnectedAccountId: any;
+};

package/lib/esm/hooks/useSCPaymentsEnabled.js

@@ -0,0 +1,31 @@
+import { useMemo } from 'react';
+import { SCFeatureName } from '@selfcommunity/types';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+import * as SCPreferences from '../constants/Preferences';
+/**
+ :::info
+ This custom hook is used to check if the payments are enabled
+ :::
+ :::tip How to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. import useSCPaymentsEnabled from '@selfcommunity/react-core';
+ 2.	const {isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId} = useSCPaymentsEnabled();
+ ```
+ :::
+ */
+export default function useSCPaymentsEnabled() {
+    // CONTEXT
+    const { preferences, features } = useSCPreferences();
+    const isPaymentsEnabled = useMemo(() => preferences &&
+        features &&
+        features.includes(SCFeatureName.PAYMENTS) &&
+        SCPreferences.CONFIGURATIONS_PAYMENTS_ENABLED in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_PAYMENTS_ENABLED].value, [preferences]);
+    const stripePublicKey = useMemo(() => preferences && SCPreferences.STATIC_STRIPE_PUBLIC_KEY in preferences && preferences[SCPreferences.STATIC_STRIPE_PUBLIC_KEY].value, [preferences]);
+    const stripeConnectedAccountId = useMemo(() => preferences &&
+        SCPreferences.CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID].value, [preferences]);
+    return { isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId };
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Custom hook to recover a given preference.
+ * @param preferenceKey - full preference key (e.g., 'section.name')
+ * @param defaultValue - default returned value
+ * @returns the preference value or undefined/defaultValue if doesn't exist
+ *
+ * Ex.
+ * const customValue = useSCPreference<string>(SCPreferences.CUSTOM_SETTING);
+ * const numericValue = useSCPreference<number>(SCPreferences.CUSTOM_SETTING, 0);
+ */
+declare function useSCPreference<T = any>(preferenceKey: string, defaultValue?: T): T | undefined;
+/**
+ * Custom hook to check if a given preference is present and has a value.
+ * @param preferenceKey - full preference key (e.g., 'section.name')
+ * @param defaultValue - default returned value (default=false)
+ * @returns boolean
+ *
+ * Ex.
+ * const isEnabled = useSCPreferenceEnabled(SCPreferences.CONFIGURATIONS_CONNECTION_ENABLED);
+ **/
+declare function useSCPreferenceEnabled(preferenceKey: string, defaultValue?: boolean): boolean;
+/**
+ * Custom hook to check if all specified preferences are enabled
+ * @param preferenceKeys - Array of preference keys to check
+ * @param defaultValue - Default value if a preference doesn't exist
+ * @returns boolean - true if all preferences are enabled
+ *
+ * Ex.
+ * const arePreferencesEnabled = useSCPreferencesEnabled([
+ *   SCPreferences.CONFIGURATIONS_POST_USER_ADDRESSING_ENABLED,
+ *   SCPreferences.CONFIGURATIONS_SCHEDULED_POSTS_ENABLED
+ * ]);
+ */
+declare function useSCPreferencesEnabled(preferenceKeys: string[], defaultValue?: boolean): boolean;
+export { useSCPreferenceEnabled, useSCPreferencesEnabled };
+export default useSCPreference;

package/lib/esm/hooks/useSCPreference.js

@@ -0,0 +1,65 @@
+import { useMemo } from 'react';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+/**
+ * Custom hook to recover a given preference.
+ * @param preferenceKey - full preference key (e.g., 'section.name')
+ * @param defaultValue - default returned value
+ * @returns the preference value or undefined/defaultValue if doesn't exist
+ *
+ * Ex.
+ * const customValue = useSCPreference<string>(SCPreferences.CUSTOM_SETTING);
+ * const numericValue = useSCPreference<number>(SCPreferences.CUSTOM_SETTING, 0);
+ */
+function useSCPreference(preferenceKey, defaultValue) {
+    const { preferences } = useSCPreferences();
+    return useMemo(() => {
+        if (!preferences || !(preferenceKey in preferences)) {
+            return defaultValue;
+        }
+        const pref = preferences[preferenceKey];
+        return pref.value;
+    }, [preferences, preferenceKey, defaultValue]);
+}
+/**
+ * Custom hook to check if a given preference is present and has a value.
+ * @param preferenceKey - full preference key (e.g., 'section.name')
+ * @param defaultValue - default returned value (default=false)
+ * @returns boolean
+ *
+ * Ex.
+ * const isEnabled = useSCPreferenceEnabled(SCPreferences.CONFIGURATIONS_CONNECTION_ENABLED);
+ **/
+function useSCPreferenceEnabled(preferenceKey, defaultValue = false) {
+    const value = useSCPreference(preferenceKey, defaultValue);
+    return value !== null && value !== void 0 ? value : defaultValue;
+}
+/**
+ * Custom hook to check if all specified preferences are enabled
+ * @param preferenceKeys - Array of preference keys to check
+ * @param defaultValue - Default value if a preference doesn't exist
+ * @returns boolean - true if all preferences are enabled
+ *
+ * Ex.
+ * const arePreferencesEnabled = useSCPreferencesEnabled([
+ *   SCPreferences.CONFIGURATIONS_POST_USER_ADDRESSING_ENABLED,
+ *   SCPreferences.CONFIGURATIONS_SCHEDULED_POSTS_ENABLED
+ * ]);
+ */
+function useSCPreferencesEnabled(preferenceKeys, defaultValue = false) {
+    const { preferences } = useSCPreferences();
+    return useMemo(() => {
+        // Se non ci sono preferences o non è stato passato nessun preferenceKey, ritorna il valore di default
+        if (!preferences || !preferenceKeys.length) {
+            return defaultValue;
+        }
+        // Verifica che tutte le preferenze siano presenti e abbiano value = true
+        return preferenceKeys.every((key) => {
+            if (!(key in preferences)) {
+                return defaultValue;
+            }
+            return preferences[key].value;
+        });
+    }, [preferences, preferenceKeys, defaultValue]);
+}
+export { useSCPreferenceEnabled, useSCPreferencesEnabled };
+export default useSCPreference;

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

@@ -0,0 +1,17 @@
+import { SCFeatureName } from '@selfcommunity/types';
+/**
+ * Custom hook preferences and features at the same time
+ * @param preferences - array of preference keys
+ * @param features - array of feature keys
+ * @returns boolean - true only if all preferences and features are enabled
+ *
+ * Ex.
+ * const isEnabled = useSCPreferencesAndFeaturesEnabled(
+ *     [
+ *       SCPreferences.CONFIGURATIONS_POST_USER_ADDRESSING_ENABLED,
+ *       SCPreferences.CONFIGURATIONS_SCHEDULED_POSTS_ENABLED
+ *     ],
+ *     [SCFeatureName.TAGGING]
+ *   );
+ */
+export default function useSCPreferencesAndFeaturesEnabled(preferences: string[], features?: SCFeatureName[]): boolean;

package/lib/esm/hooks/useSCPreferencesAndFeaturesEnabled.js

@@ -0,0 +1,32 @@
+import { useMemo } from 'react';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+/**
+ * Custom hook preferences and features at the same time
+ * @param preferences - array of preference keys
+ * @param features - array of feature keys
+ * @returns boolean - true only if all preferences and features are enabled
+ *
+ * Ex.
+ * const isEnabled = useSCPreferencesAndFeaturesEnabled(
+ *     [
+ *       SCPreferences.CONFIGURATIONS_POST_USER_ADDRESSING_ENABLED,
+ *       SCPreferences.CONFIGURATIONS_SCHEDULED_POSTS_ENABLED
+ *     ],
+ *     [SCFeatureName.TAGGING]
+ *   );
+ */
+export default function useSCPreferencesAndFeaturesEnabled(preferences, features = []) {
+    const { preferences: preferencesContext, features: featuresContext } = useSCPreferences();
+    return useMemo(() => {
+        // Check available context
+        if (!preferencesContext || !featuresContext) {
+            return false;
+        }
+        // Check every preferences
+        const preferencesEnabled = preferences.every((key) => key in preferencesContext && preferencesContext[key].value);
+        // Check every features
+        const featuresEnabled = features.every((feature) => featuresContext.includes(feature));
+        // Return true only if all preferences and features are enabled
+        return preferencesEnabled && featuresEnabled;
+    }, [preferencesContext, featuresContext, preferences, features]);
+}

package/lib/esm/hooks/useSCSubscribedEventsManager.js

@@ -34,21 +34,17 @@ export default function useSCSubscribedEventsManager(user) {
         CONFIGURATIONS_EVENTS_ENABLED in preferences &&
         preferences[CONFIGURATIONS_EVENTS_ENABLED].value, [preferences, features]);
     const notificationInvitedToJoinEvent = useRef(null);
-    const notificationRequestedToJoinEvent = useRef(null);
-    const notificationAcceptedToJoinEvent = 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]);
@@ -64,12 +60,6 @@ export default function useSCSubscribedEventsManager(user) {
                 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;
@@ -90,8 +80,8 @@ export default function useSCSubscribedEventsManager(user) {
             // Only if user is authenticated
             http
                 .request({
-                url: Endpoints.GetUserEvents.url(),
-                method: Endpoints.GetUserEvents.method,
+                url: Endpoints.GetUserSubscribedEvents.url({ id: user.id }),
+                method: Endpoints.GetUserSubscribedEvents.method,
             })
                 .then((res) => {
                 if (res.status >= 300) {

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

@@ -30,7 +30,7 @@ export default function useSCSubscribedGroupsManager(user?: SCUserType): {
     isLoading: (v: number | {
         id: number;
     }) => boolean;
-    subscribe: (group: SCGroupType, userId?: number) => Promise<any>;
+    subscribe: (group: SCGroupType) => Promise<any>;
     unsubscribe: (group: SCGroupType) => Promise<any>;
     subscriptionStatus: (group: SCGroupType) => string;
     refresh: () => void;

package/lib/esm/hooks/useSCSubscribedGroupsManager.js

@@ -34,21 +34,15 @@ export default function useSCSubscribedGroupsManager(user) {
         CONFIGURATIONS_GROUPS_ENABLED in preferences &&
         preferences[CONFIGURATIONS_GROUPS_ENABLED].value, [preferences, features]);
     const notificationInvitedToJoinGroup = useRef(null);
-    const notificationRequestedToJoinGroup = useRef(null);
-    const notificationAcceptedToJoinGroup = useRef(null);
     const notificationAddedToGroup = useRef(null);
     /**
      * Subscribe to notification types user_follow, user_unfollow
      */
     useDeepCompareEffectNoCheck(() => {
         notificationInvitedToJoinGroup.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_INVITED_TO_JOIN_GROUP}`, notificationSubscriber);
-        notificationRequestedToJoinGroup.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_GROUP}`, notificationSubscriber);
-        notificationAcceptedToJoinGroup.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_GROUP}`, notificationSubscriber);
         notificationAddedToGroup.current = PubSub.subscribe(`${SCNotificationTopicType.INTERACTION}.${SCNotificationTypologyType.USER_ADDED_TO_GROUP}`, notificationSubscriber);
         return () => {
             PubSub.unsubscribe(notificationInvitedToJoinGroup.current);
-            PubSub.unsubscribe(notificationRequestedToJoinGroup.current);
-            PubSub.unsubscribe(notificationAcceptedToJoinGroup.current);
             PubSub.unsubscribe(notificationAddedToGroup.current);
         };
     }, [data]);
@@ -58,20 +52,20 @@ export default function useSCSubscribedGroupsManager(user) {
      * @param dataMsg
      */
     const notificationSubscriber = (msg, dataMsg) => {
+        var _a;
         if (dataMsg.data.group !== undefined) {
             let _status;
             switch (SCNotificationMapping[dataMsg.data.activity_type]) {
                 case SCNotificationTypologyType.USER_INVITED_TO_JOIN_GROUP:
                     _status = SCGroupSubscriptionStatusType.INVITED;
                     break;
-                case SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_GROUP:
-                    _status = SCGroupSubscriptionStatusType.REQUESTED;
-                    break;
-                case SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_GROUP:
-                    _status = SCGroupSubscriptionStatusType.SUBSCRIBED;
-                    break;
                 case SCNotificationTypologyType.USER_ADDED_TO_GROUP:
-                    _status = SCGroupSubscriptionStatusType.SUBSCRIBED;
+                    if (dataMsg.data.notification_obj.group && ((_a = dataMsg.data.notification_obj.group.paywalls) === null || _a === void 0 ? void 0 : _a.length)) {
+                        _status = SCGroupSubscriptionStatusType.PAYMENT_WAITING;
+                    }
+                    else {
+                        _status = SCGroupSubscriptionStatusType.SUBSCRIBED;
+                    }
                     break;
             }
             updateCache([dataMsg.data.group]);
@@ -90,8 +84,8 @@ export default function useSCSubscribedGroupsManager(user) {
             // Only if user is authenticated
             http
                 .request({
-                url: Endpoints.GetUserGroups.url(),
-                method: Endpoints.GetUserGroups.method,
+                url: Endpoints.GetUserSubscribedGroups.url({ id: user.id }),
+                method: Endpoints.GetUserSubscribedGroups.method,
             })
                 .then((res) => {
                 if (res.status >= 300) {
@@ -112,50 +106,31 @@ export default function useSCSubscribedGroupsManager(user) {
      * Memoized subscribe Group
      * Toggle action
      */
-    const subscribe = useMemo(() => (group, userId) => {
+    const subscribe = useMemo(() => (group) => {
         setLoading(group.id);
-        if (userId) {
-            return http
-                .request({
-                url: Endpoints.InviteOrAcceptGroupRequest.url({ id: group.id }),
-                method: Endpoints.InviteOrAcceptGroupRequest.method,
-                data: { users: [userId] },
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([group.id]);
-                setData((prev) => getDataUpdated(prev, group.id, SCGroupSubscriptionStatusType.SUBSCRIBED));
-                setUnLoading(group.id);
-                return Promise.resolve(res.data);
-            });
-        }
-        else {
-            return http
-                .request({
-                url: Endpoints.SubscribeToGroup.url({ id: group.id }),
-                method: Endpoints.SubscribeToGroup.method,
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([group.id]);
-                setData((prev) => getDataUpdated(prev, group.id, group.privacy === SCGroupPrivacyType.PRIVATE && group.subscription_status !== SCGroupSubscriptionStatusType.INVITED
-                    ? SCGroupSubscriptionStatusType.REQUESTED
-                    : SCGroupSubscriptionStatusType.SUBSCRIBED));
-                setUnLoading(group.id);
-                return Promise.resolve(res.data);
-            });
-        }
+        return http
+            .request({
+            url: Endpoints.SubscribeToGroup.url({ id: group.id }),
+            method: Endpoints.SubscribeToGroup.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            updateCache([group.id]);
+            setData((prev) => getDataUpdated(prev, group.id, group.privacy === SCGroupPrivacyType.PRIVATE && group.subscription_status !== SCGroupSubscriptionStatusType.INVITED
+                ? SCGroupSubscriptionStatusType.REQUESTED
+                : SCGroupSubscriptionStatusType.SUBSCRIBED));
+            setUnLoading(group.id);
+            return Promise.resolve(res.data);
+        });
     }, [data, loading, cache]);
     /**
      * Memoized subscribe Group
      * Toggle action
      */
     const unsubscribe = useMemo(() => (group) => {
-        if (group.subscription_status !== SCGroupSubscriptionStatusType.REQUESTED) {
+        if (data[group.id] !== SCGroupSubscriptionStatusType.REQUESTED) {
             setLoading(group.id);
             return http
                 .request({
@@ -248,7 +223,7 @@ export default function useSCSubscribedGroupsManager(user) {
         if (cache.includes(group.id)) {
             return getCurrentGroupCacheStatus(group);
         }
-        if (authUserId) {
+        if (authUserId && group) {
             if ('subscription_status' in group) {
                 return getSubscriptionStatus(group);
             }
@@ -257,7 +232,7 @@ export default function useSCSubscribedGroupsManager(user) {
             }
         }
         return null;
-    }, [loading, cache, authUserId]);
+    }, [loading, cache, authUserId, getSubscriptionStatus, getCurrentGroupCacheStatus]);
     /**
      * Empty cache on logout
      */

package/lib/esm/index.d.ts

@@ -42,6 +42,7 @@ import * as SCCache from './constants/Cache';
  * Custom Hooks
  */
 import useSCFetchUser from './hooks/useSCFetchUser';
+import useSCFetchUsers from './hooks/useSCFetchUsers';
 import useSCFetchUserProviders from './hooks/useSCFetchUserProviders';
 import useSCFetchVote from './hooks/useSCFetchVote';
 import useSCFetchFeedObject from './hooks/useSCFetchFeedObject';
@@ -71,6 +72,13 @@ import useSCGoogleApiLoader from './hooks/useSCGoogleApiLoader';
 import useSCFetchCourse from './hooks/useSCFetchCourse';
 import useSCFetchCourses from './hooks/useSCFetchCourses';
 import useSCFetchLesson from './hooks/useSCFetchLesson';
+import useSCPaymentsEnabled from './hooks/useSCPaymentsEnabled';
+import useSCFetchPaymentProduct from './hooks/useSCFetchPaymentProduct';
+import useSCFetchPaymentOrder from './hooks/useSCFetchPaymentOrder';
+import useFetchMenuFooter from './hooks/useFetchMenuFooter';
+import useSCPreference, { useSCPreferenceEnabled, useSCPreferencesEnabled } from './hooks/useSCPreference';
+import { useSCFeatureEnabled, useSCFeaturesEnabled } from './hooks/useSCFeature';
+import useSCPreferencesAndFeaturesEnabled from './hooks/useSCPreferencesAndFeaturesEnabled';
 /**
  * Routing component
  */
@@ -82,7 +90,7 @@ import * as SCRoutes from './constants/Routes';
  */
 import * as UserUtils from './utils/user';
 import getTheme from './themes/theme';
-import { useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect, usePageVisibility } from './utils/hooks';
+import { useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect, usePageVisibility, useResizeObserver } from './utils/hooks';
 import { getEventStatus } from './utils/event';
 /**
  * Constants:
@@ -93,4 +101,4 @@ 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, SCSubscribedEventsManagerType, SCJoinedCoursesManagerType, 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, useSCFetchLessonCommentObject, useSCFetchLessonCommentObjects, useSCFetchCustomAdv, useSCFetchTag, useSCFetchAddressingTagList, useSCFetchCategory, useSCFetchCategories, useSCFetchIncubator, useSCMediaClick, useSCFetchContributors, useSCFetchFeed, useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect, usePageVisibility, useSCFetchPrivateMessageSnippets, useSCFetchBroadcastMessages, useSCFetchUserBlockedBy, useSCUserIsBlocked, useSCFetchGroup, useSCFetchGroups, useSCFetchEvent, useSCFetchEvents, useSCFetchLiveStream, useSCGoogleApiLoader, useSCFetchCourse, useSCFetchCourses, useSCFetchLesson, };
+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, SCJoinedCoursesManagerType, 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, useSCFetchUsers, useSCFetchUserProviders, useSCFetchVote, useSCFetchFeedObject, useSCFetchCommentObject, useSCFetchCommentObjects, useSCFetchLessonCommentObject, useSCFetchLessonCommentObjects, useSCFetchCustomAdv, useSCFetchTag, useSCFetchAddressingTagList, useSCFetchCategory, useSCFetchCategories, useSCFetchIncubator, useSCMediaClick, useSCFetchContributors, useSCFetchFeed, useIsComponentMountedRef, usePreviousValue, useIsomorphicLayoutEffect, useEffectOnce, useNoInitialEffect, usePageVisibility, useResizeObserver, useSCFetchPrivateMessageSnippets, useSCFetchBroadcastMessages, useSCFetchUserBlockedBy, useSCUserIsBlocked, useSCFetchGroup, useSCFetchGroups, useSCFetchEvent, useSCFetchEvents, useSCFetchLiveStream, useSCGoogleApiLoader, useSCFetchCourse, useSCFetchCourses, useSCFetchLesson, useSCPaymentsEnabled, useSCFetchPaymentProduct, useSCFetchPaymentOrder, useFetchMenuFooter, useSCPreference, useSCPreferenceEnabled, useSCPreferencesEnabled, useSCFeatureEnabled, useSCFeaturesEnabled, useSCPreferencesAndFeaturesEnabled, };