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

package/lib/cjs/hooks/useSCFetchPaymentOrder.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_services_1 = require("@selfcommunity/api-services");
+const utils_1 = require("@selfcommunity/utils");
+const react_1 = require("react");
+const use_deep_compare_effect_1 = require("use-deep-compare-effect");
+const SCUserProvider_1 = require("../components/provider/SCUserProvider");
+const Cache_1 = require("../constants/Cache");
+const Errors_1 = require("../constants/Errors");
+/**
+ :::info
+ This custom hook is used to fetch a payment order.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentOrder
+ * @param object.cacheStrategy
+ */
+function useSCFetchPaymentOrder({ id = null, paymentOrder = null, cacheStrategy = utils_1.CacheStrategies.NETWORK_ONLY, }) {
+    const __paymentOrderId = (0, react_1.useMemo)(() => (paymentOrder === null || paymentOrder === void 0 ? void 0 : paymentOrder.id) || id, [paymentOrder, id]);
+    // CONTEXT
+    const scUserContext = (0, SCUserProvider_1.useSCUser)();
+    const authUserId = (0, react_1.useMemo)(() => { var _a; return ((_a = scUserContext.user) === null || _a === void 0 ? void 0 : _a.id) || null; }, [scUserContext.user]);
+    // CACHE
+    const __paymentOrderCacheKey = (0, react_1.useMemo)(() => (0, Cache_1.getPaymentOrderObjectCacheKey)(__paymentOrderId), [__paymentOrderId]);
+    const [scPaymentOrder, setScPaymentOrder] = (0, react_1.useState)(cacheStrategy !== utils_1.CacheStrategies.NETWORK_ONLY ? utils_1.LRUCache.get(__paymentOrderCacheKey, paymentOrder) : null);
+    const [error, setError] = (0, react_1.useState)(null);
+    const setSCPaymentOrder = (0, react_1.useCallback)((c) => {
+        setScPaymentOrder(c);
+        utils_1.LRUCache.set(__paymentOrderCacheKey, c);
+    }, [setScPaymentOrder, __paymentOrderCacheKey]);
+    /**
+     * Memoized fetch order
+     */
+    const fetchPaymentOrder = (0, react_1.useMemo)(() => (id) => {
+        return api_services_1.http
+            .request({
+            url: api_services_1.Endpoints.GetPaymentOrder.url({ id }),
+            method: api_services_1.Endpoints.GetPaymentOrder.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, []);
+    /**
+     * If id attempt to get the course by id
+     */
+    (0, react_1.useEffect)(() => {
+        if (id !== null && id !== undefined && !paymentOrder) {
+            fetchPaymentOrder(id)
+                .then((e) => {
+                setSCPaymentOrder(e);
+            })
+                .catch((err) => {
+                utils_1.LRUCache.delete(__paymentOrderCacheKey);
+                utils_1.Logger.error(Errors_1.SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [id, paymentOrder, authUserId]);
+    (0, use_deep_compare_effect_1.useDeepCompareEffectNoCheck)(() => {
+        if (paymentOrder) {
+            setSCPaymentOrder(paymentOrder);
+        }
+    }, [paymentOrder, authUserId]);
+    return { scPaymentOrder, setSCPaymentOrder, error };
+}
+exports.default = useSCFetchPaymentOrder;

package/lib/cjs/hooks/useSCFetchPaymentProduct.d.ts

@@ -0,0 +1,20 @@
+import { SCPaymentProduct } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch a payment product.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentProduct
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentProduct({ id, paymentProduct, cacheStrategy, }: {
+    id?: number | string;
+    paymentProduct?: SCPaymentProduct;
+    cacheStrategy?: CacheStrategies;
+}): {
+    scPaymentProduct: SCPaymentProduct;
+    setSCPaymentProduct: (c: SCPaymentProduct) => void;
+    error: string;
+};

package/lib/cjs/hooks/useSCFetchPaymentProduct.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_services_1 = require("@selfcommunity/api-services");
+const utils_1 = require("@selfcommunity/utils");
+const react_1 = require("react");
+const use_deep_compare_effect_1 = require("use-deep-compare-effect");
+const SCUserProvider_1 = require("../components/provider/SCUserProvider");
+const Cache_1 = require("../constants/Cache");
+const Errors_1 = require("../constants/Errors");
+/**
+ :::info
+ This custom hook is used to fetch a payment product.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentProduct
+ * @param object.cacheStrategy
+ */
+function useSCFetchPaymentProduct({ id = null, paymentProduct = null, cacheStrategy = utils_1.CacheStrategies.NETWORK_ONLY, }) {
+    const __paymentProductId = (0, react_1.useMemo)(() => (paymentProduct === null || paymentProduct === void 0 ? void 0 : paymentProduct.id) || id, [paymentProduct, id]);
+    // CONTEXT
+    const scUserContext = (0, SCUserProvider_1.useSCUser)();
+    const authUserId = (0, react_1.useMemo)(() => { var _a; return ((_a = scUserContext.user) === null || _a === void 0 ? void 0 : _a.id) || null; }, [scUserContext.user]);
+    // CACHE
+    const __paymentProductCacheKey = (0, react_1.useMemo)(() => (0, Cache_1.getPaymentProductObjectCacheKey)(__paymentProductId), [__paymentProductId]);
+    const [scPaymentProduct, setScPaymentProduct] = (0, react_1.useState)(cacheStrategy !== utils_1.CacheStrategies.NETWORK_ONLY ? utils_1.LRUCache.get(__paymentProductCacheKey, paymentProduct) : null);
+    const [error, setError] = (0, react_1.useState)(null);
+    const setSCPaymentProduct = (0, react_1.useCallback)((c) => {
+        setScPaymentProduct(c);
+        utils_1.LRUCache.set(__paymentProductCacheKey, c);
+    }, [setScPaymentProduct, __paymentProductCacheKey]);
+    /**
+     * Memoized fetch product
+     */
+    const fetchPaymentProduct = (0, react_1.useMemo)(() => (id) => {
+        return api_services_1.http
+            .request({
+            url: api_services_1.Endpoints.GetPaymentProduct.url({ id }),
+            method: api_services_1.Endpoints.GetPaymentProduct.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, []);
+    /**
+     * If id attempt to get the course by id
+     */
+    (0, react_1.useEffect)(() => {
+        if (id !== null && id !== undefined && !paymentProduct) {
+            fetchPaymentProduct(id)
+                .then((e) => {
+                setSCPaymentProduct(e);
+            })
+                .catch((err) => {
+                utils_1.LRUCache.delete(__paymentProductCacheKey);
+                utils_1.Logger.error(Errors_1.SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [id, paymentProduct, authUserId]);
+    (0, use_deep_compare_effect_1.useDeepCompareEffectNoCheck)(() => {
+        if (paymentProduct) {
+            setSCPaymentProduct(paymentProduct);
+        }
+    }, [paymentProduct, authUserId]);
+    return { scPaymentProduct, setSCPaymentProduct, error };
+}
+exports.default = useSCFetchPaymentProduct;

package/lib/cjs/hooks/useSCFetchUsers.d.ts

@@ -0,0 +1,21 @@
+import { SCUserAutocompleteType } from '@selfcommunity/types';
+/**
+ :::info
+ This custom hook is used to fetch users.
+   
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {users, isLoading} = useSCFetchUsers();
+ ```
+ :::
+ * @param props
+ */
+declare const useSCFetchUsers: (props?: {
+    search: string;
+    exclude?: string;
+}) => {
+    users: SCUserAutocompleteType[];
+    isLoading: boolean;
+};
+export default useSCFetchUsers;

package/lib/cjs/hooks/useSCFetchUsers.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const react_1 = require("react");
+const Errors_1 = require("../constants/Errors");
+const api_services_1 = require("@selfcommunity/api-services");
+const utils_1 = require("@selfcommunity/utils");
+/**
+ :::info
+ This custom hook is used to fetch users.
+   
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {users, isLoading} = useSCFetchUsers();
+ ```
+ :::
+ * @param props
+ */
+const useSCFetchUsers = (props) => {
+    const { search = '', exclude = '' } = props || {};
+    const [data, setData] = (0, react_1.useState)({ users: [], isLoading: false });
+    const fetchUsers = (next = api_services_1.Endpoints.UserAutocomplete.url(), searchParam, excludeParam) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const response = yield api_services_1.http.request({
+            url: next,
+            method: api_services_1.Endpoints.UserAutocomplete.method,
+            params: Object.assign({ search: searchParam }, (excludeParam && { exclude: excludeParam })),
+        });
+        const result = response.data;
+        if (result.next) {
+            return result.results.concat(yield fetchUsers(result.next, searchParam, excludeParam));
+        }
+        return result.results;
+    });
+    (0, react_1.useEffect)(() => {
+        if (!search)
+            return;
+        fetchUsers(undefined, search, exclude)
+            .then((users) => {
+            setData({ users, isLoading: false });
+        })
+            .catch((error) => {
+            console.error(error);
+            utils_1.Logger.error(Errors_1.SCOPE_SC_CORE, 'Unable to retrieve users');
+            setData((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false })));
+        });
+    }, [search, exclude]);
+    return data;
+};
+exports.default = useSCFetchUsers;

package/lib/cjs/hooks/useSCJoinedCoursesManager.d.ts

@@ -30,7 +30,7 @@ export default function useSCJoinedCoursesManager(user?: SCUserType): {
     isLoading: (v: number | {
         id: number;
     }) => boolean;
-    join: (course: SCCourseType, userId?: number) => Promise<any>;
+    join: (course: SCCourseType) => Promise<any>;
     leave: (course: SCCourseType) => Promise<any>;
     joinStatus: (course: SCCourseType) => string;
     refresh: () => void;

package/lib/cjs/hooks/useSCJoinedCoursesManager.js

@@ -36,21 +36,15 @@ function useSCJoinedCoursesManager(user) {
         Preferences_1.CONFIGURATIONS_COURSES_ENABLED in preferences &&
         preferences[Preferences_1.CONFIGURATIONS_COURSES_ENABLED].value, [preferences, features]);
     const notificationInvitedToJoinCourse = (0, react_1.useRef)(null);
-    const notificationRequestedToJoinCourse = (0, react_1.useRef)(null);
-    const notificationAcceptedToJoinCourse = (0, react_1.useRef)(null);
     const notificationAddedToCourse = (0, react_1.useRef)(null);
     /**
      * Subscribe to notification types user_follow, user_unfollow
      */
     (0, use_deep_compare_effect_1.useDeepCompareEffectNoCheck)(() => {
         notificationInvitedToJoinCourse.current = pubsub_js_1.default.subscribe(`${types_1.SCNotificationTopicType.INTERACTION}.${types_1.SCNotificationTypologyType.USER_INVITED_TO_JOIN_COURSE}`, notificationSubscriber);
-        notificationRequestedToJoinCourse.current = pubsub_js_1.default.subscribe(`${types_1.SCNotificationTopicType.INTERACTION}.${types_1.SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_COURSE}`, notificationSubscriber);
-        notificationAcceptedToJoinCourse.current = pubsub_js_1.default.subscribe(`${types_1.SCNotificationTopicType.INTERACTION}.${types_1.SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_COURSE}`, notificationSubscriber);
         notificationAddedToCourse.current = pubsub_js_1.default.subscribe(`${types_1.SCNotificationTopicType.INTERACTION}.${types_1.SCNotificationTypologyType.USER_ADDED_TO_COURSE}`, notificationSubscriber);
         return () => {
             pubsub_js_1.default.unsubscribe(notificationInvitedToJoinCourse.current);
-            pubsub_js_1.default.unsubscribe(notificationRequestedToJoinCourse.current);
-            pubsub_js_1.default.unsubscribe(notificationAcceptedToJoinCourse.current);
             pubsub_js_1.default.unsubscribe(notificationAddedToCourse.current);
         };
     }, [data]);
@@ -60,20 +54,20 @@ function useSCJoinedCoursesManager(user) {
      * @param dataMsg
      */
     const notificationSubscriber = (msg, dataMsg) => {
+        var _a;
         if (dataMsg.data.course !== undefined) {
             let _status;
             switch (Notification_1.SCNotificationMapping[dataMsg.data.activity_type]) {
                 case types_1.SCNotificationTypologyType.USER_INVITED_TO_JOIN_COURSE:
                     _status = types_1.SCCourseJoinStatusType.INVITED;
                     break;
-                case types_1.SCNotificationTypologyType.USER_REQUESTED_TO_JOIN_COURSE:
-                    _status = types_1.SCCourseJoinStatusType.REQUESTED;
-                    break;
-                case types_1.SCNotificationTypologyType.USER_ACCEPTED_TO_JOIN_COURSE:
-                    _status = types_1.SCCourseJoinStatusType.JOINED;
-                    break;
                 case types_1.SCNotificationTypologyType.USER_ADDED_TO_COURSE:
-                    _status = types_1.SCCourseJoinStatusType.JOINED;
+                    if (dataMsg.data.notification_obj.course && ((_a = dataMsg.data.notification_obj.course.paywalls) === null || _a === void 0 ? void 0 : _a.length)) {
+                        _status = types_1.SCCourseJoinStatusType.PAYMENT_WAITING;
+                    }
+                    else {
+                        _status = types_1.SCCourseJoinStatusType.JOINED;
+                    }
                     break;
             }
             updateCache([dataMsg.data.course]);
@@ -92,8 +86,8 @@ function useSCJoinedCoursesManager(user) {
             // Only if user is authenticated
             api_services_1.http
                 .request({
-                url: api_services_1.Endpoints.GetJoinedCourses.url(),
-                method: api_services_1.Endpoints.GetJoinedCourses.method,
+                url: api_services_1.Endpoints.GetUserJoinedCourses.url({ id: user.id }),
+                method: api_services_1.Endpoints.GetUserJoinedCourses.method,
             })
                 .then((res) => {
                 if (res.status >= 300) {
@@ -114,67 +108,42 @@ function useSCJoinedCoursesManager(user) {
      * Memoized join Course
      * Toggle action
      */
-    const join = (0, react_1.useMemo)(() => (course, userId) => {
+    const join = (0, react_1.useMemo)(() => (course) => tslib_1.__awaiter(this, void 0, void 0, function* () {
         setLoading(course.id);
-        if (userId) {
-            return api_services_1.http
-                .request({
-                url: api_services_1.Endpoints.InviteOrAcceptUsersToCourse.url({ id: course.id }),
-                method: api_services_1.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, types_1.SCCourseJoinStatusType.JOINED));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
-            });
-        }
-        else {
-            return api_services_1.http
-                .request({
-                url: api_services_1.Endpoints.JoinOrAcceptInviteToCourse.url({ id: course.id }),
-                method: api_services_1.Endpoints.JoinOrAcceptInviteToCourse.method,
-            })
-                .then((res) => {
-                if (res.status >= 300) {
-                    return Promise.reject(res);
-                }
-                updateCache([course.id]);
-                setData((prev) => getDataUpdated(prev, course.id, course.privacy === types_1.SCCoursePrivacyType.PRIVATE && course.join_status !== types_1.SCCourseJoinStatusType.INVITED
-                    ? types_1.SCCourseJoinStatusType.REQUESTED
-                    : types_1.SCCourseJoinStatusType.JOINED));
-                setUnLoading(course.id);
-                return Promise.resolve(res.data);
-            });
+        const res = yield api_services_1.http.request({
+            url: api_services_1.Endpoints.JoinOrAcceptInviteToCourse.url({ id: course.id }),
+            method: api_services_1.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 === types_1.SCCoursePrivacyType.PRIVATE && course.join_status !== types_1.SCCourseJoinStatusType.INVITED
+            ? types_1.SCCourseJoinStatusType.REQUESTED
+            : types_1.SCCourseJoinStatusType.JOINED));
+        setUnLoading(course.id);
+        return yield Promise.resolve(res.data);
+    }), [data, loading, cache]);
     /**
      * Memoized leave Course
      * Toggle action
      */
-    const leave = (0, react_1.useMemo)(() => (course) => {
-        if (course.join_status !== types_1.SCCourseJoinStatusType.REQUESTED) {
+    const leave = (0, react_1.useMemo)(() => (course) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (data[course.id] !== types_1.SCCourseJoinStatusType.REQUESTED) {
             setLoading(course.id);
-            return api_services_1.http
-                .request({
+            const res = yield api_services_1.http.request({
                 url: api_services_1.Endpoints.LeaveOrRemoveCourseRequest.url({ id: course.id }),
                 method: api_services_1.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
@@ -250,7 +219,7 @@ function useSCJoinedCoursesManager(user) {
         if (cache.includes(course.id)) {
             return getCurrentCourseCacheStatus(course);
         }
-        if (authUserId) {
+        if (authUserId && course) {
             if ('join_status' in course) {
                 return getJoinStatus(course);
             }
@@ -259,7 +228,7 @@ function useSCJoinedCoursesManager(user) {
             }
         }
         return null;
-    }, [loading, cache, authUserId]);
+    }, [loading, cache, authUserId, getJoinStatus, getCurrentCourseCacheStatus]);
     /**
      * Empty cache on logout
      */

package/lib/cjs/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/cjs/hooks/useSCPaymentsEnabled.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const react_1 = require("react");
+const types_1 = require("@selfcommunity/types");
+const SCPreferencesProvider_1 = require("../components/provider/SCPreferencesProvider");
+const SCPreferences = tslib_1.__importStar(require("../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();
+ ```
+ :::
+ */
+function useSCPaymentsEnabled() {
+    // CONTEXT
+    const { preferences, features } = (0, SCPreferencesProvider_1.useSCPreferences)();
+    const isPaymentsEnabled = (0, react_1.useMemo)(() => preferences &&
+        features &&
+        features.includes(types_1.SCFeatureName.PAYMENTS) &&
+        SCPreferences.CONFIGURATIONS_PAYMENTS_ENABLED in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_PAYMENTS_ENABLED].value, [preferences]);
+    const stripePublicKey = (0, react_1.useMemo)(() => preferences && SCPreferences.STATIC_STRIPE_PUBLIC_KEY in preferences && preferences[SCPreferences.STATIC_STRIPE_PUBLIC_KEY].value, [preferences]);
+    const stripeConnectedAccountId = (0, react_1.useMemo)(() => preferences &&
+        SCPreferences.CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID in preferences &&
+        preferences[SCPreferences.CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID].value, [preferences]);
+    return { isPaymentsEnabled, stripePublicKey, stripeConnectedAccountId };
+}
+exports.default = useSCPaymentsEnabled;

package/lib/cjs/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/cjs/hooks/useSCPreference.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSCPreferencesEnabled = exports.useSCPreferenceEnabled = void 0;
+const react_1 = require("react");
+const SCPreferencesProvider_1 = require("../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 } = (0, SCPreferencesProvider_1.useSCPreferences)();
+    return (0, react_1.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;
+}
+exports.useSCPreferenceEnabled = useSCPreferenceEnabled;
+/**
+ * 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 } = (0, SCPreferencesProvider_1.useSCPreferences)();
+    return (0, react_1.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]);
+}
+exports.useSCPreferencesEnabled = useSCPreferencesEnabled;
+exports.default = useSCPreference;

package/lib/cjs/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/cjs/hooks/useSCPreferencesAndFeaturesEnabled.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const SCPreferencesProvider_1 = require("../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]
+ *   );
+ */
+function useSCPreferencesAndFeaturesEnabled(preferences, features = []) {
+    const { preferences: preferencesContext, features: featuresContext } = (0, SCPreferencesProvider_1.useSCPreferences)();
+    return (0, react_1.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]);
+}
+exports.default = useSCPreferencesAndFeaturesEnabled;