@selfcommunity/react-core 0.1.2-alpha.0

package/lib/cjs/components/provider/SCRoutingProvider/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+exports.__esModule = true;
+exports.SCRoutingContext = void 0;
+exports.default = SCRoutingProvider;
+exports.useSCRouting = useSCRouting;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _SCContextProvider = require("../SCContextProvider");
+
+var _SCPreferencesProvider = require("../SCPreferencesProvider");
+
+var SCPreferences = _interopRequireWildcard(require("../../../constants/Preferences"));
+
+var _Routes = require("../../../constants/Routes");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Creates Global Context
+ *
+ :::tipContext can be consumed in one of the following ways:
+
+
+ ```jsx
+ 1. <SCRoutingContext.Consumer>{(routerLink, routes, url) => (...)}</SCRoutingContext.Consumer>
+ ```
+ ```jsx
+ 2. const scRoutingContext: SCRoutingContextType = useContext(SCRoutingContext);
+ ```
+ ```jsx
+ 3. const scRoutingContext: SCRoutingContextType = useSCRouting();
+ ````
+
+ :::
+ */
+const SCRoutingContext = /*#__PURE__*/(0, _react.createContext)({});
+/**
+ * #### Description:
+ * This component provides routing context.
+ * @param children
+ * @return
+ * ```jsx
+ * <SCRoutingContext.Provider value={contextValue}>{children}</SCRoutingContext.Provider>
+ * ```
+ */
+
+exports.SCRoutingContext = SCRoutingContext;
+
+function SCRoutingProvider({
+  children = null
+}) {
+  const scPreferencesContext = (0, _react.useContext)(_SCPreferencesProvider.SCPreferencesContext);
+  const scContext = (0, _SCContextProvider.useSCContext)();
+  const router = scContext.settings.router ? scContext.settings.router : {};
+  const routerLink = router.routerLink ? router.routerLink : null;
+
+  const _routes = Object.assign(getPreferencesRoutes(), _Routes.defaultRoutes);
+
+  const routes = router.routes ? Object.assign({}, _routes, router.routes) : _Routes.defaultRoutes;
+  /**
+   * Normalize template url (preferences)
+   */
+
+  function normalizeUrl(url) {
+    let tpl = url;
+    const re = /\{([^/]+)?\}/g;
+    let match = re.exec(url);
+
+    while (match) {
+      tpl = tpl.replace(match[0], `:${match[1]}`);
+      re.lastIndex = 0;
+      match = re.exec(tpl);
+    }
+
+    return tpl;
+  }
+  /**
+   * Get override routes from community preferences
+   */
+
+
+  function getPreferencesRoutes() {
+    return {
+      [_Routes.POST_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_POST].value),
+      [_Routes.DISCUSSION_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_DISCUSSION].value),
+      [_Routes.STATUS_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_STATUS].value),
+      [_Routes.COMMENT_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_COMMENT].value),
+      [_Routes.CATEGORY_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_CATEGORY].value),
+      [_Routes.CATEGORIES_LIST_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_CATEGORIES_LIST].value),
+      [_Routes.USER_PROFILE_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_USER_PROFILE].value),
+      [_Routes.USER_PROFILE_SETTINGS_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_USER_PROFILE_SETTINGS].value),
+      [_Routes.USER_NOTIFICATIONS_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_USER_NOTIFICATIONS].value),
+      [_Routes.USER_PRIVATE_MESSAGES_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_USER_PRIVATE_MESSAGES].value),
+      [_Routes.INCUBATOR_ROUTE_NAME]: normalizeUrl(scPreferencesContext.preferences[SCPreferences.CONFIGURATIONS_URL_TEMPLATE_INCUBATOR].value)
+    };
+  }
+  /**
+   * Generate path
+   */
+
+
+  function url(name = '', params = {}) {
+    const replacer = (tpl, data) => {
+      const re = /:([^/|^?|^#]+)?/g;
+      let _tpl = tpl;
+      let match = re.exec(tpl);
+
+      while (match) {
+        _tpl = _tpl.replace(match[0], data[match[1]]);
+        re.lastIndex = 0;
+        match = re.exec(_tpl);
+      }
+
+      if (router.handleRoute) {
+        // Handle override url
+        return router.handleRoute(name, _tpl, params, tpl);
+      }
+
+      return _tpl;
+    };
+
+    return replacer(routes[name], params);
+  }
+
+  const contextValue = (0, _react.useMemo)(() => ({
+    routerLink,
+    routes,
+    url
+  }), [routerLink, routes]);
+  return /*#__PURE__*/_react.default.createElement(SCRoutingContext.Provider, {
+    value: contextValue
+  }, children);
+}
+/**
+ * Let's only export the `useSCTheme` hook instead of the context.
+ * We only want to use the hook directly and never the context component.
+ */
+
+
+function useSCRouting() {
+  return (0, _react.useContext)(SCRoutingContext);
+}

package/lib/cjs/components/provider/SCThemeProvider/index.js

@@ -0,0 +1,123 @@
+"use strict";
+
+exports.__esModule = true;
+exports.SCThemeContext = void 0;
+exports.default = SCThemeProvider;
+exports.useSCTheme = useSCTheme;
+exports.withSCTheme = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styles = require("@mui/material/styles");
+
+var _theme = _interopRequireDefault(require("../../../themes/theme"));
+
+var _SCContextProvider = require("../SCContextProvider");
+
+var _SCPreferencesProvider = require("../SCPreferencesProvider");
+
+var _useDeepCompareEffect = require("use-deep-compare-effect");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+/**
+ * Creates Global Context
+ *
+ :::tipContext can be consumed in one of the following ways:
+
+ ```jsx
+ 1. <SCThemeContext.Consumer>{(theme,) => (...)}</SCThemeContext.Consumer>
+ ```
+ ```jsx
+ 2. const scThemeContext: SCThemeContextType = useContext(SCThemeContext);
+ ```
+ ```jsx
+ 3. const scThemeContext: SCThemeContextType = useSCTheme();
+ ````
+
+ :::
+
+ */
+const SCThemeContext = /*#__PURE__*/(0, _react.createContext)({});
+/**
+ * #### Description:
+ * This component makes the `theme` available down the React tree.
+ * It should preferably be used at **the root of your component tree**.
+ * See: https://mui.com/system/styled/
+ *
+ * @param children
+ * @return
+ * ```jsx
+ * <SCThemeContext.Provider value={{theme, setTheme: setCustomTheme}}>
+ * <ThemeProvider theme={theme}>{children}</ThemeProvider>
+ * </SCThemeContext.Provider>
+ * ```
+ */
+
+exports.SCThemeContext = SCThemeContext;
+
+function SCThemeProvider({
+  children = null
+}) {
+  const scContext = (0, _SCContextProvider.useSCContext)();
+  const scPreferencesContext = (0, _SCPreferencesProvider.useSCPreferences)();
+  const [theme, setTheme] = (0, _react.useState)((0, _theme.default)(scContext.settings.theme, scPreferencesContext.preferences));
+  /**
+   * Set custom theme
+   * Merge with scPreferencesContext.preferences
+   * @param theme
+   */
+
+  const setCustomTheme = theme => {
+    setTheme((0, _theme.default)(theme, scPreferencesContext.preferences));
+  };
+  /**
+   * Update theme if initial conf changes
+   */
+
+
+  (0, _useDeepCompareEffect.useDeepCompareEffectNoCheck)(() => {
+    setCustomTheme(theme);
+  }, [scContext.settings.theme]);
+  return /*#__PURE__*/_react.default.createElement(_styles.StyledEngineProvider, {
+    injectFirst: true
+  }, /*#__PURE__*/_react.default.createElement(SCThemeContext.Provider, {
+    value: {
+      theme,
+      setTheme: setCustomTheme
+    }
+  }, /*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+    theme: theme
+  }, children)));
+}
+/**
+ * Export hoc to inject the base theme to components
+ * @param Component
+ */
+
+
+const withSCTheme = Component => props => {
+  const scThemeContext = (0, _react.useContext)(SCThemeContext);
+  return /*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+    theme: scThemeContext.theme
+  }, /*#__PURE__*/_react.default.createElement(Component, _extends({
+    setTheme: scThemeContext.setTheme
+  }, props)));
+};
+/**
+ * Let's only export the `useSCTheme` hook instead of the context.
+ * We only want to use the hook directly and never the context component.
+ */
+
+
+exports.withSCTheme = withSCTheme;
+
+function useSCTheme() {
+  return (0, _react.useContext)(SCThemeContext);
+}

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

@@ -0,0 +1,310 @@
+"use strict";
+
+exports.__esModule = true;
+exports.SCUserContext = void 0;
+exports.default = SCUserProvider;
+exports.useSCUser = useSCUser;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _SCContextProvider = require("../SCContextProvider");
+
+var _useSCAuth = _interopRequireWildcard(require("../../../hooks/useSCAuth"));
+
+var _logger = require("../../../utils/logger");
+
+var _pubsubJs = _interopRequireDefault(require("pubsub-js"));
+
+var _Errors = require("../../../constants/Errors");
+
+var _useDeepCompareEffect = _interopRequireDefault(require("use-deep-compare-effect"));
+
+var _useSCFollowedCategoriesManager = _interopRequireDefault(require("../../../hooks/useSCFollowedCategoriesManager"));
+
+var _useSCFollowersManager = _interopRequireDefault(require("../../../hooks/useSCFollowersManager"));
+
+var _useSCConnectionsManager = _interopRequireDefault(require("../../../hooks/useSCConnectionsManager"));
+
+var _types = require("@selfcommunity/types");
+
+var _useSCSubscribedIncubatorsManager = _interopRequireDefault(require("../../../hooks/useSCSubscribedIncubatorsManager"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * SCUserContext (Authentication Context)
+ *
+ :::tipContext can be consumed in one of the following ways:
+
+
+ ```jsx
+ 1. <SCUserContext.Consumer>{(user, session, error, loading, logout) => (...)}</SCUserContext.Consumer>
+ ```
+ ```jsx
+ 2. const scUserContext: SCUserContextType = useContext(SCUserContext);
+ ```
+ ```jsx
+ 3. const scUserContext: SCUserContextType = useSCUser();
+ ````
+ :::
+ */
+const SCUserContext = /*#__PURE__*/(0, _react.createContext)({});
+/**
+ * #### Description:
+ * This component keeps current user logged and session; it is exported as we need to wrap the entire app with it
+ * @param children
+ * @return
+ * ```jsx
+ * <SCUserContext.Provider value={contextValue}>{!state.loading && children}</SCUserContext.Provider>
+ * ```
+ */
+
+exports.SCUserContext = SCUserContext;
+
+function SCUserProvider({
+  children
+}) {
+  const scContext = (0, _react.useContext)(_SCContextProvider.SCContext);
+  /**
+   * Manage user session
+   * Refresh token if necessary
+   */
+
+  const initialSession = scContext.settings.session;
+  const {
+    state,
+    dispatch,
+    helpers
+  } = (0, _useSCAuth.default)(initialSession);
+  /**
+   * Managers followed, categories
+   */
+
+  const followedManager = (0, _useSCFollowersManager.default)(state.user);
+  const subscribedIncubatorsManager = (0, _useSCSubscribedIncubatorsManager.default)(state.user);
+  const connectionsManager = (0, _useSCConnectionsManager.default)(state.user);
+  const categoriesManager = (0, _useSCFollowedCategoriesManager.default)(state.user);
+  /**
+   * Ref notifications subscribers: BLOCKED_USER, UNBLOCKED_USER
+   */
+
+  const notificationUserBlockedSubscription = (0, _react.useRef)(null);
+  const notificationUserUnBlockedSubscription = (0, _react.useRef)(null);
+  /**
+   * Check if there is a currently active session
+   * when the provider is mounted for the first time.
+   * If there is an error, it means there is no session.
+   */
+
+  (0, _useDeepCompareEffect.default)(() => {
+    if (state.session.authToken && state.session.authToken.accessToken) {
+      dispatch({
+        type: _useSCAuth.userActionTypes.LOGIN_LOADING
+      });
+
+      _apiServices.UserService.getCurrentUser().then(user => {
+        dispatch({
+          type: _useSCAuth.userActionTypes.LOGIN_SUCCESS,
+          payload: {
+            user
+          }
+        });
+      }).catch(error => {
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, 'Unable to retrieve the authenticated user.');
+
+        dispatch({
+          type: _useSCAuth.userActionTypes.LOGIN_FAILURE,
+          payload: {
+            error
+          }
+        });
+      });
+    }
+  }, [state.session]);
+  /**
+   * Controls caching of follow categories, users, etc...
+   * To avoid multi-tab problems (only for client side), on visibility change
+   * and document is in foreground refresh the cache
+   */
+
+  (0, _react.useEffect)(() => {
+    typeof window !== 'undefined' && document.addEventListener('visibilitychange', handleVisibilityChange);
+    return () => {
+      typeof window !== 'undefined' && document.removeEventListener('visibilitychange', handleVisibilityChange);
+    };
+  });
+  /**
+   * handler handleVisibilityChange for this provider
+   * Refresh followed categories, users, etc..
+   */
+
+  function handleVisibilityChange() {
+    if (typeof window !== 'undefined' && !window.document.hidden && state.user) {
+      categoriesManager.refresh && categoriesManager.refresh();
+      followedManager.refresh && followedManager.refresh();
+      connectionsManager.refresh && connectionsManager.refresh();
+      subscribedIncubatorsManager.refresh && subscribedIncubatorsManager.refresh();
+    }
+  }
+  /**
+   * Subscribes to handle notifications of type BLOCKED_USER, UNBLOCKED_USER.
+   * When receive this type of notifications, the user.status must be update.
+   */
+
+
+  (0, _react.useEffect)(() => {
+    notificationUserBlockedSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.BLOCKED_USER}`, () => {
+      dispatch({
+        type: _useSCAuth.userActionTypes.UPDATE_USER,
+        payload: {
+          status: _types.SCUserStatus.BLOCKED
+        }
+      });
+    });
+    notificationUserUnBlockedSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.UNBLOCKED_USER}`, () => {
+      dispatch({
+        type: _useSCAuth.userActionTypes.UPDATE_USER,
+        payload: {
+          status: _types.SCUserStatus.APPROVED
+        }
+      });
+    });
+    return () => {
+      _pubsubJs.default.unsubscribe(notificationUserBlockedSubscription.current);
+
+      _pubsubJs.default.unsubscribe(notificationUserUnBlockedSubscription.current);
+    };
+  }, []);
+  /**
+   * Handle change user
+   */
+
+  function updateUser(info) {
+    dispatch({
+      type: _useSCAuth.userActionTypes.UPDATE_USER,
+      payload: info
+    });
+  }
+  /**
+   * Handle change unseen interactions counter
+   */
+
+
+  function setUnseenInteractionsCounter(counter) {
+    dispatch({
+      type: _useSCAuth.userActionTypes.UPDATE_USER,
+      payload: {
+        unseen_interactions_counter: counter
+      }
+    });
+  }
+  /**
+   * Handle change unseen notification banners counter
+   */
+
+
+  function setUnseenNotificationBannersCounter(counter) {
+    dispatch({
+      type: _useSCAuth.userActionTypes.UPDATE_USER,
+      payload: {
+        unseen_notification_banners_counter: counter
+      }
+    });
+  }
+  /**
+   * Helper to refresh the session
+   */
+
+
+  function refreshSession() {
+    return helpers.refreshSession();
+  }
+  /**
+   * Helper to refresh the notification counter
+   * Use getCurrentUser service since the notification counters
+   * have been inserted into the serialized user object
+   */
+
+
+  const refreshNotificationCounters = (0, _react.useMemo)(() => () => {
+    if (state.user) {
+      return _apiServices.UserService.getCurrentUser().then(user => {
+        dispatch({
+          type: _useSCAuth.userActionTypes.UPDATE_USER,
+          payload: {
+            unseen_interactions_counter: user.unseen_interactions_counter,
+            unseen_notification_banners_counter: user.unseen_notification_banners_counter
+          }
+        });
+      }).catch(error => {
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, `Unable to refresh notification counters. Error: ${error.response.toString()}`);
+      });
+    }
+
+    return Promise.reject();
+  }, [state.user]);
+  /**
+   * Call the logout endpoint and then remove the user
+   * from the state.
+   */
+
+  function logout() {
+    dispatch({
+      type: _useSCAuth.userActionTypes.LOGOUT
+    });
+  }
+  /**
+   * Make the provider update only when it should.
+   * We only want to force re-renders if the user, session,
+   * loading or error states change.
+   *
+   * Whenever the `value` passed into a provider changes,
+   * the whole tree under the provider re-renders, and
+   * that can be very costly! Even in this case, where
+   * you only get re-renders when logging in and out
+   * we want to keep things very performant.
+   */
+
+
+  const contextValue = (0, _react.useMemo)(() => ({
+    user: state.user,
+    session: state.session,
+    loading: state.loading,
+    error: state.error,
+    updateUser,
+    setUnseenInteractionsCounter,
+    setUnseenNotificationBannersCounter,
+    refreshNotificationCounters,
+    logout,
+    refreshSession,
+    managers: {
+      categories: categoriesManager,
+      followed: followedManager,
+      connections: connectionsManager,
+      incubators: subscribedIncubatorsManager
+    }
+  }), [state, categoriesManager.loading, categoriesManager.categories, followedManager.loading, followedManager.followed, connectionsManager.loading, connectionsManager.connections, subscribedIncubatorsManager.loading, subscribedIncubatorsManager.incubators]);
+  /**
+   * We only want to render the underlying app after we
+   * assert for the presence of a current user.
+   */
+
+  return /*#__PURE__*/_react.default.createElement(SCUserContext.Provider, {
+    value: contextValue
+  }, children);
+}
+/**
+ * Let's only export the `useSCUser` hook instead of the context.
+ * We only want to use the hook directly and never the context component.
+ */
+
+
+function useSCUser() {
+  return (0, _react.useContext)(SCUserContext);
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _SCRoutingProvider = require("../provider/SCRoutingProvider");
+
+const _excluded = ["children"],
+      _excluded2 = ["to"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+/**
+ *
+ * Import this components:
+ * import {SCRoutingContextType, useSCRouting, Link, SCRoutes} from '@selfcommunity/react-core';
+ *
+ * Example:
+ *    const scRoutingContext: SCRoutingContextType = useSCRouting();
+ *    `<Button component={Link} to={scRoutingContext.url(SCRoutes.USER_PROFILE_ROUTE_NAME, {id: user.id})}>Go to profile</Button>`
+ * or
+ *    const scRoutingContext: SCRoutingContextType = useSCRouting();
+ *    `<Link to={scRoutingContext.url('profile', {id: user.id})}>Go to profile</Link>`
+ *
+ */
+const Link = (_ref, ref) => {
+  let {
+    children
+  } = _ref,
+      other = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+  const scRoutingContext = (0, _react.useContext)(_SCRoutingProvider.SCRoutingContext);
+
+  if (scRoutingContext.routerLink) {
+    const ComponentLink = scRoutingContext.routerLink;
+    return /*#__PURE__*/_react.default.createElement(ComponentLink, _extends({}, other, {
+      ref: ref
+    }), children);
+  }
+
+  const {
+    to
+  } = other,
+        rest = _objectWithoutPropertiesLoose(other, _excluded2);
+
+  return /*#__PURE__*/_react.default.createElement("a", _extends({
+    href: to
+  }, rest, {
+    ref: ref
+  }), children);
+};
+/**
+ :::info
+ This component is used to navigate through the application.
+ :::
+
+ ## Usage
+
+ In order to use router you need to import this components first:
+
+ ```jsx
+ import {SCRoutingContextType, useSCRouting, Link, SCRoutes} from '@selfcommunity/react-core';
+ ````
+ :::tipUsage Example:
+
+ ```jsx
+ const scRoutingContext: SCRoutingContextType = useSCRouting();
+ <Button component={Link} to={scRoutingContext.url(SCRoutes.USER_PROFILE_ROUTE_NAME, {id: user.id})>Go to profile</Button>
+````
+ **or**
+
+```jsx
+const scRoutingContext: SCRoutingContextType = useSCRouting();
+<Link to={scRoutingContext.url('profile', {id: user.id})}>Go to profile</Link>
+````
+
+:::
+ */
+
+
+var _default = /*#__PURE__*/_react.default.forwardRef(Link);
+
+exports.default = _default;

package/lib/cjs/constants/Actions.js

@@ -0,0 +1,6 @@
+"use strict";
+
+exports.__esModule = true;
+exports.HANDLE_ANONYMOUS_ACTION_OPTION = void 0;
+const HANDLE_ANONYMOUS_ACTION_OPTION = 'handleAnonymousAction';
+exports.HANDLE_ANONYMOUS_ACTION_OPTION = HANDLE_ANONYMOUS_ACTION_OPTION;