@selfcommunity/react-core 0.1.2-alpha.0

package/lib/cjs/themes/theme.js

@@ -0,0 +1,165 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _styles = require("@mui/material/styles");
+
+var _object = require("../utils/object");
+
+var _validateColor = _interopRequireDefault(require("validate-color"));
+
+var _Preferences = require("../constants/Preferences");
+
+var _string = require("../utils/string");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * check if colorProp is a valid color
+ * @param preferences
+ * @param colorProp
+ * @param tFunc: type func validator
+ * @return {boolean|(function(*=): boolean)}
+ */
+const isValidPreference = (preferences, prop, tFunc) => {
+  // eslint-disable-next-line no-prototype-builtins
+  if (preferences.hasOwnProperty(prop) && preferences[prop].hasOwnProperty('value')) {
+    return tFunc(preferences[prop].value);
+  }
+
+  return false;
+};
+/**
+ * Overrides theme properties
+ * @param options: store.settings.theme
+ * @param preferences: community global preferences
+ * @return {Theme}
+ */
+
+
+const getTheme = (options, preferences) => {
+  const defaultOptions = preferences ? {
+    palette: Object.assign({}, isValidPreference(preferences, _Preferences.COLORS_COLORBACK, _validateColor.default) && {
+      background: {
+        default: preferences[_Preferences.COLORS_COLORBACK].value
+      }
+    }, isValidPreference(preferences, _Preferences.COLORS_COLORFONT, _validateColor.default) && {
+      text: {
+        primary: preferences[_Preferences.COLORS_COLORFONT].value
+      }
+    }, isValidPreference(preferences, _Preferences.COLORS_COLORPRIMARY, _validateColor.default) && {
+      primary: {
+        main: preferences[_Preferences.COLORS_COLORPRIMARY].value
+      }
+    }, isValidPreference(preferences, _Preferences.COLORS_COLORSECONDARY, _validateColor.default) && {
+      secondary: {
+        main: preferences[_Preferences.COLORS_COLORSECONDARY].value
+      }
+    }),
+    typography: Object.assign({}, isValidPreference(preferences, _Preferences.FONT_FAMILY, _string.isString) && {
+      fontFamily: preferences[_Preferences.FONT_FAMILY].value
+    }, {
+      body1: {
+        fontSize: '0.9rem'
+      },
+      body2: {
+        fontSize: '0.8rem'
+      }
+    }),
+    components: {
+      MuiPaper: {// styleOverrides: {
+        //   rounded: {
+        //     borderRadius: 3,
+        //   },
+        // },
+      },
+      SCWidget: {// variants: [
+        //   {
+        //     props: {elevation: 0},
+        //     style: {
+        //       border: 0,
+        //       boxShadow: 'none',
+        //       marginBottom: '0 !important',
+        //     },
+        //   },
+        //   {
+        //     props: {variant: 'outlined'},
+        //     style: {
+        //       border: '1px solid rgba(0, 0, 0, 0.12)',
+        //       boxShadow: 'none',
+        //     },
+        //   },
+        // ],
+        // styleOverrides: {
+        //   root: {
+        //     border: '0 none',
+        //     boxShadow: '0px 5px 20px rgba(0, 0, 0, 0.1)',
+        //     borderRadius: '15px',
+        //   },
+        // },
+      },
+      MuiDivider: {
+        styleOverrides: {
+          root: {
+            borderWidth: '1px'
+          }
+        }
+      },
+      SCFeedObject: {
+        styleOverrides: {
+          root: {}
+        }
+      },
+      SCTrendingFeed: {
+        styleOverrides: {
+          root: {
+            '& .MuiIcon-root': {
+              marginBottom: '0.5px'
+            }
+          }
+        }
+      },
+      SCNotificationItem: {// styleOverrides: {
+        //   root: {
+        //     '&.SCNotificationItem-new-snippet': {
+        //       '&::before': {
+        //         backgroundColor: 'yellow',
+        //       },
+        //     },
+        //   },
+        // },
+      },
+      SCSnippetNotifications: {
+        styleOverrides: {
+          root: {
+            '& .SCSnippetNotifications-notifications-list': {// wrap notifications list (ul)
+            },
+            '& .SCSnippetNotifications-notification-item': {// single notification item (li)
+            },
+            ['& .SCUserFollowNotification-username, .SCUserFollowNotification-username, .SCCommentNotification-username,' + 'SCContributionFollowNotification-username, .SCContributionFollowNotification-username, .SCUserNotificationMention-username,' + '.SCUserNotificationMention-username, .SCUserNotificationPrivateMessage-message-sender, .SCVoteUpNotification-username']: {// username for notification types: user follow, comment/nested comment,
+              // follow contribution, mention, private message, vote up
+            },
+            ['& .SCUserFollowNotification-list-item-snippet-new, .SCVoteUpNotification-list-item-snippet-new, ' + '.SCUserBlockedNotification-list-item-snippet-new, .SCUndeletedForNotification-list-item-snippet-new, ' + '.SCUserNotificationPrivateMessage-list-item-snippet-new, .SCUserNotificationMention-list-item-snippet-new,' + '.SCKindlyNoticeForNotification-list-item-snippet-new, .SCKindlyNoticeFlagNotification-list-item-snippet-new,' + '.SCIncubatorApprovedNotification-list-item-snippet-new, .SCDeletedForNotification-list-item-snippet-new,' + '.SCContributionFollowNotification-list-item-snippet-new, .SCCommentNotification-list-item-snippet-new,' + '.SCCollapsedForNotification-list-item-snippet-new']: {// border left indicate new notification of various type
+            }
+          }
+        }
+      },
+      SCPlatform: {
+        styleOverrides: {
+          root: {
+            '& .MuiIcon-root': {
+              fontSize: '18px',
+              marginLeft: '2px',
+              marginBottom: '-3px'
+            }
+          }
+        }
+      }
+    }
+  } : {};
+  return (0, _styles.createTheme)((0, _object.mergeDeep)(defaultOptions, options));
+};
+
+var _default = getTheme;
+exports.default = _default;

package/lib/cjs/types/context.js

@@ -0,0 +1,3 @@
+"use strict";
+
+exports.__esModule = true;

package/lib/cjs/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+
+var _context = require("./context");
+
+exports.SCUserContextType = _context.SCUserContextType;
+exports.SCFollowedManagerType = _context.SCFollowedManagerType;
+exports.SCFollowedCategoriesManagerType = _context.SCFollowedCategoriesManagerType;
+exports.SCSubscribedIncubatorsManagerType = _context.SCSubscribedIncubatorsManagerType;
+exports.SCConnectionsManagerType = _context.SCConnectionsManagerType;
+exports.SCContextProviderType = _context.SCContextProviderType;
+exports.SCContextType = _context.SCContextType;
+exports.SCSettingsType = _context.SCSettingsType;
+exports.SCSessionType = _context.SCSessionType;
+exports.SCPreferencesContextType = _context.SCPreferencesContextType;
+exports.SCNotificationContextType = _context.SCNotificationContextType;
+exports.SCLocaleType = _context.SCLocaleType;
+exports.SCThemeContextType = _context.SCThemeContextType;
+exports.SCRoutingContextType = _context.SCRoutingContextType;
+exports.SCLocaleContextType = _context.SCLocaleContextType;
+exports.SCAlertMessagesContextType = _context.SCAlertMessagesContextType;

package/lib/cjs/utils/errors.js

@@ -0,0 +1,196 @@
+"use strict";
+
+exports.__esModule = true;
+exports.ValidationWarnings = exports.ValidationResult = exports.ValidationError = void 0;
+exports.isFunc = isFunc;
+
+var _Locale = require("../constants/Locale");
+
+var Session = _interopRequireWildcard(require("../constants/Session"));
+
+var _logger = require("./logger");
+
+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; }
+
+/**
+ * Manage Validation Error
+ * Used to check the initial configurations
+ */
+class ValidationError {
+  constructor(errorCode, errorData, errorMessage = ValidationError.defaultErrorMessageMap[errorCode]) {
+    this.errorCode = null;
+    this.errorData = null;
+    this.errorMessage = null;
+    this.errorCode = errorCode;
+    this.errorData = errorData;
+    this.errorMessage = errorMessage;
+  }
+
+}
+/**
+ * Manage Validation Warnings
+ * Used to check the initial configurations
+ */
+
+
+exports.ValidationError = ValidationError;
+ValidationError.ERROR_INVALID_CONF = 3100;
+ValidationError.ERROR_INVALID_SESSION = 4100;
+ValidationError.ERROR_INVALID_SESSION_TYPE = 4101;
+ValidationError.ERROR_INVALID_SESSION_AUTH_TOKEN = 4102;
+ValidationError.ERROR_INVALID_SESSION_CLIENT_ID = 4103;
+ValidationError.ERROR_INVALID_SESSION_REFRESH_TOKEN_CALLBACK = 4104;
+ValidationError.ERROR_INVALID_PORTAL = 4200;
+ValidationError.ERROR_INVALID_LOCALE = 4300;
+ValidationError.ERROR_INVALID_TRANSLATIONS = 4400;
+ValidationError.ERROR_INVALID_THEME = 4500;
+ValidationError.ERROR_INVALID_ROUTER = 4600;
+ValidationError.ERROR_INVALID_PROVIDERS = 4700;
+ValidationError.ERROR_INVALID_HANDLE_ANONYMOUS_ACTION = 4800;
+ValidationError.ERROR_INVALID_NOTIFICATIONS = 4900;
+ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET = 4901;
+ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET_DISABLE_TOAST_MESSAGE = 4902;
+ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING = 4921;
+ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_DISABLE_TOAST_MESSAGE = 4922;
+ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_APPLICATION_SERVER_KEY = 4923;
+ValidationError.defaultErrorMessageMap = {
+  [ValidationError.ERROR_INVALID_CONF]: 'Invalid or missing library configuration. Check the configuration that is passed to the SCContextProvider.',
+  [ValidationError.ERROR_INVALID_SESSION]: 'Invalid session format.',
+  [ValidationError.ERROR_INVALID_SESSION_TYPE]: `Invalid sessionType. Available options are ${Session.sessionTypes.join(', ')}.`,
+  [ValidationError.ERROR_INVALID_SESSION_AUTH_TOKEN]: 'Invalid auth token format',
+  [ValidationError.ERROR_INVALID_SESSION_CLIENT_ID]: 'Invalid clientId in the initial configuration.',
+  [ValidationError.ERROR_INVALID_SESSION_REFRESH_TOKEN_CALLBACK]: 'Invalid refresh token callback',
+  [ValidationError.ERROR_INVALID_PORTAL]: `Invalid portal. Check if the url format is valid.`,
+  [ValidationError.ERROR_INVALID_LOCALE]: `Invalid locale. Available options are ${_Locale.LOCALES.join(', ')}.`,
+  [ValidationError.ERROR_INVALID_TRANSLATIONS]: `Invalid locale messages(translations) options.`,
+  [ValidationError.ERROR_INVALID_THEME]: 'Invalid theme options.',
+  [ValidationError.ERROR_INVALID_ROUTER]: 'Invalid router configuration',
+  [ValidationError.ERROR_INVALID_PROVIDERS]: `Invalid providers. Check if the list of providers is valid.`,
+  [ValidationError.ERROR_INVALID_HANDLE_ANONYMOUS_ACTION]: 'Invalid handle anonymous action callback',
+  [ValidationError.ERROR_INVALID_NOTIFICATIONS]: 'Invalid notifications conf.',
+  [ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET]: 'Invalid notifications (websocket) option.',
+  [ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET_DISABLE_TOAST_MESSAGE]: 'Invalid notifications websocket conf: disableToastMessage must be a boolean value.',
+  [ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING]: 'Invalid notifications (web push messaging) option.',
+  [ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_DISABLE_TOAST_MESSAGE]: "Invalid notifications web push messaging option. 'disableToastMessage' must be a boolean value.",
+  [ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_APPLICATION_SERVER_KEY]: "Invalid notifications web push messaging option. 'applicationServerKey' must be a string value."
+};
+
+class ValidationWarnings {
+  constructor(warningCode, warningData, warningMessage = ValidationWarnings.defaultErrorMessageMap[warningCode]) {
+    this.warningCode = null;
+    this.warningData = null;
+    this.warningMessage = null;
+    this.warningCode = warningCode;
+    this.warningData = warningData;
+    this.warningMessage = warningMessage;
+  }
+
+}
+/**
+ * /**
+ * Manage Validation Error/Warnings
+ * of the initial configuration
+ */
+
+
+exports.ValidationWarnings = ValidationWarnings;
+ValidationWarnings.WARNING_SESSION_REFRESH_TOKEN_CALLBACK_NOT_FOUND = 3100;
+ValidationWarnings.WARNING_LOCALE_FALLBACK = 3300;
+ValidationWarnings.WARNING_ROUTER_FALLBACK = 3500;
+ValidationWarnings.WARNING_HANDLE_ANONYMOUS_ACTION_FALLBACK = 3700;
+ValidationWarnings.defaultErrorMessageMap = {
+  [ValidationWarnings.WARNING_SESSION_REFRESH_TOKEN_CALLBACK_NOT_FOUND]: "The 'handleRefreshToken' is not defined in initial conf. When the token expires it will not be renewed and the user session will be lost.",
+  [ValidationWarnings.WARNING_LOCALE_FALLBACK]: `The 'locale' is not defined in initial conf, fallback to the default ${_Locale.DEFAULT_LANGUAGE_UI}.`,
+  [ValidationWarnings.WARNING_ROUTER_FALLBACK]: "The 'router' is not defined in initial conf, fallback to the default configurations.",
+  [ValidationWarnings.WARNING_HANDLE_ANONYMOUS_ACTION_FALLBACK]: "The 'handleAnonymousAction' is not defined in initial conf, fallback to the default configurations."
+};
+
+class ValidationResult {
+  constructor(scope = '[Report Error]') {
+    this.errors = [];
+    this.warnings = [];
+    this.scope = '';
+    this.scope = scope;
+  }
+  /**
+   * Add an error
+   * @param errorCode
+   * @param errorData
+   */
+
+
+  addError(errorCode, errorData) {
+    this.errors.push(new ValidationError(errorCode, errorData));
+    return this.errors;
+  }
+  /**
+   * Add a warning
+   * @param errorCode
+   * @param errorData
+   */
+
+
+  addWarnings(warningCode, warningData) {
+    this.warnings.push(new ValidationWarnings(warningCode, warningData));
+    return this.errors;
+  }
+  /**
+   * Check if contains errors
+   */
+
+
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  /**
+   * Check if contains warnings
+   */
+
+
+  hasWarnings() {
+    return this.warnings.length > 0;
+  }
+  /**
+   * Emit in console all the errors
+   */
+
+
+  emitErrors() {
+    if (this.hasErrors()) {
+      this.errors.map(e => _logger.Logger.error(this.scope, e.errorMessage));
+    }
+  }
+  /**
+   * Emit in console all the warnings
+   */
+
+
+  emitWarnings() {
+    if (this.hasWarnings()) {
+      this.warnings.map(w => _logger.Logger.warn(this.scope, w.warningMessage));
+    }
+  }
+  /**
+   * Emit in console errors/warnings
+   */
+
+
+  emit() {
+    this.emitErrors();
+    this.emitWarnings();
+  }
+
+}
+/**
+ * Check if v is a func
+ * @param v
+ */
+
+
+exports.ValidationResult = ValidationResult;
+
+function isFunc(v) {
+  return typeof v === 'function';
+}

package/lib/cjs/utils/locale.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+exports.loadLocaleData = loadLocaleData;
+
+var _Locale = require("../constants/Locale");
+
+var _reactI18n = _interopRequireDefault(require("@selfcommunity/react-i18n"));
+
+var _reactIntl = require("react-intl");
+
+var _logger = require("./logger");
+
+var _Errors = require("../constants/Errors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Load Locale Data
+ */
+function loadLocaleData(locale, settings) {
+  let _locale = locale;
+  let locales = settings.locale && settings.locale.messages ? settings.locale.messages : _reactI18n.default;
+
+  if (!locales[_locale]) {
+    _locale = _Locale.DEFAULT_LANGUAGE_UI;
+
+    if (settings.messages) {
+      _logger.Logger.warn(_Errors.SCOPE_SC_CORE, `Locale ${_locale} not found in messages configuration. Fallback to 'en'.`);
+    } else {
+      _logger.Logger.warn(_Errors.SCOPE_SC_CORE, `Locale ${_locale} not found in sc-i18n package. Fallback to 'en'.`);
+    }
+  }
+
+  try {
+    return {
+      messages: locales[_locale],
+      locale: _locale
+    };
+  } catch (e) {
+    if (settings.messages) {
+      locales = _reactI18n.default;
+
+      _logger.Logger.error(_Errors.SCOPE_SC_CORE, `Configuration Locale.messages doesn't contains ${_locale}. Fallback to 'en' of 'sc-i18n'`);
+    }
+
+    return {
+      messages: locales[_Locale.LOCALE_EN],
+      locale: _Locale.DEFAULT_LANGUAGE_UI
+    };
+  }
+}
+
+var _default = _reactIntl.createIntl;
+exports.default = _default;

package/lib/cjs/utils/logger.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports.Logger = void 0;
+
+/**
+ * Emit styled message
+ */
+class Logger {
+  static info(scope, message) {
+    console.info(`%c[${scope}]`, 'color:#008080', ` ${message}`);
+  }
+
+  static warn(scope, message) {
+    console.warn(`%c[${scope}]`, 'color:#008080', ` ${message}`);
+  }
+
+  static error(scope, message) {
+    console.error(`%c[${scope}]`, 'color:#008080', ` ${message}`);
+  }
+
+  static log(scope, message) {
+    console.log(`%c[${scope}]`, 'color:#008080', ` ${message}`);
+  }
+
+  static debug(scope, message) {
+    console.debug(`%c[${scope}]`, 'color:#008080', ` ${message}`);
+  }
+
+}
+
+exports.Logger = Logger;

package/lib/cjs/utils/object.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isObject = isObject;
+exports.mergeDeep = mergeDeep;
+
+/**
+ * Check if v is an object
+ * @param v
+ */
+function isObject(v) {
+  return typeof v === 'object' && !Array.isArray(v) && v !== null;
+}
+/**
+ * Perfrom deep merge of two objects (not a shallow merge)
+ * @param target
+ * @param source
+ * @return {*}
+ */
+
+
+function mergeDeep(target, source) {
+  let output = Object.assign({}, target);
+
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach(key => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, {
+            [key]: source[key]
+          });
+        } else {
+          output[key] = mergeDeep(target[key], source[key]);
+        }
+      } else {
+        Object.assign(output, {
+          [key]: source[key]
+        });
+      }
+    });
+  }
+
+  return output;
+}

package/lib/cjs/utils/session.js

@@ -0,0 +1,17 @@
+"use strict";
+
+exports.__esModule = true;
+exports.parseJwt = parseJwt;
+
+/**
+ * Extract from a jwt token payload
+ * @param token
+ */
+function parseJwt(token) {
+  let base64Url = token.split('.')[1];
+  let base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+  let jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
+    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+  }).join(''));
+  return JSON.parse(jsonPayload);
+}

package/lib/cjs/utils/string.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.__esModule = true;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
+exports.isString = isString;
+exports.stripHtml = stripHtml;
+
+/**
+ * Check if v is a string
+ * @param v
+ */
+function isString(v) {
+  return typeof v === 'string' || v instanceof String;
+}
+/**
+ * Capitalize a string
+ * @param str
+ */
+
+
+function capitalize(str) {
+  let strVal = '';
+  let strArr = str.split(' ');
+
+  for (let chr = 0; chr < strArr.length; chr++) {
+    strVal += strArr[chr].substring(0, 1).toUpperCase() + strArr[chr].substring(1, strArr[chr].length);
+  }
+
+  return strVal;
+}
+/**
+ * CamelCase a string
+ * @param str
+ */
+
+
+function camelCase(str) {
+  // Lower cases the string
+  return str.toLowerCase() // Replaces any - or _ characters with a space
+  .replace(/[-_]+/g, ' ') // Removes any non alphanumeric characters
+  .replace(/[^\w\s]/g, '') // Uppercases the first character in each group immediately following a space
+  // (delimited by spaces)
+  .replace(/ (.)/g, $1 => {
+    return $1.toUpperCase();
+  }) // Removes spaces
+  .replace(/ /g, '');
+}
+/**
+ * Stripe html tags from a string
+ * @param str
+ */
+
+
+function stripHtml(str) {
+  return str.replace(/<[^>]*>?/gm, '').trim();
+}

package/lib/cjs/utils/url.js

@@ -0,0 +1,70 @@
+"use strict";
+
+exports.__esModule = true;
+exports.urlReplacer = exports.isValidUrls = exports.isValidUrl = exports.getDomain = void 0;
+
+/**
+ * Utility Url Replacer
+ * @param path
+ */
+const urlReplacer = path => {
+  const replacer = function replacer(tpl, data) {
+    const re = /\$\(([^)]+)?\)/g;
+    let match = re.exec(tpl);
+
+    while (match) {
+      tpl = tpl.replace(match[0], data[match[1]]);
+      re.lastIndex = 0;
+      match = re.exec(tpl);
+    }
+
+    return tpl;
+  };
+
+  return params => replacer(path, params);
+};
+/**
+ * Get domain
+ * @param url
+ */
+
+
+exports.urlReplacer = urlReplacer;
+
+const getDomain = url => {
+  // eslint-disable-next-line no-useless-escape,@typescript-eslint/prefer-regexp-exec
+  const matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
+
+  if (matches && matches[1]) {
+    return matches[1];
+  }
+
+  return '';
+};
+/**
+ * Check a str is a valid url pattern
+ * @param url
+ */
+
+
+exports.getDomain = getDomain;
+
+const isValidUrl = url => {
+  const regexp = /(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-/]))?/;
+  return regexp.test(url);
+};
+/**
+ * Check a str is a valid list of urls separated by delimiter
+ * @param value
+ * @param delimiter
+ */
+
+
+exports.isValidUrl = isValidUrl;
+
+const isValidUrls = (value, delimiter) => {
+  const urls = value.trim().split(delimiter);
+  return urls.every(isValidUrl);
+};
+
+exports.isValidUrls = isValidUrls;