@selfcommunity/react-core 0.1.2-alpha.0

package/lib/esm/utils/validator.js

@@ -0,0 +1,771 @@
+"use strict";
+
+exports.__esModule = true;
+exports.validateLocaleMessages = exports.validateLocaleDefault = exports.validateLocale = exports.validateHandleRefreshToken = exports.validateHandleAnonymousAction = exports.validateContextProviders = exports.validOptions = exports.settingsOptions = exports.sessionOptions = exports.notificationsWebSocketOptions = exports.notificationsWebSPushMessagingOptions = exports.notificationsOptions = exports.localeOptions = void 0;
+exports.validateNotifications = validateNotifications;
+exports.validateRouter = exports.validatePortal = exports.validateOptions = void 0;
+exports.validateSession = validateSession;
+exports.validateWebSocketDisableToastMessage = exports.validateWebSocket = exports.validateWebPushMessagingDisableToastMessage = exports.validateWebPushMessagingApplicationServerKey = exports.validateWebPushMessaging = exports.validateTheme = exports.validateSessionType = exports.validateSessionClientId = exports.validateSessionAuthTokenOption = void 0;
+
+var Locale = _interopRequireWildcard(require("../constants/Locale"));
+
+var _url = require("./url");
+
+var Session = _interopRequireWildcard(require("../constants/Session"));
+
+var _Errors = require("../constants/Errors");
+
+var _errors = require("./errors");
+
+var _object = require("./object");
+
+var _string = require("./string");
+
+var _ContextProviders = require("../constants/ContextProviders");
+
+var _logger = require("./logger");
+
+var Notifications = _interopRequireWildcard(require("../constants/Notifications"));
+
+var Theme = _interopRequireWildcard(require("../constants/Theme"));
+
+var _Routes = require("../constants/Routes");
+
+var Actions = _interopRequireWildcard(require("../constants/Actions"));
+
+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; }
+
+/**
+ * Validate session option
+ * @param session
+ * @return {}
+ */
+function validateSession(v) {
+  const errors = [];
+  const warnings = [];
+
+  if (!v || !(0, _object.isObject)(v)) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_SESSION);
+    return {
+      errors,
+      warnings,
+      value: v
+    };
+  }
+
+  const _options = Object.keys(sessionOptions);
+
+  const value = Object.keys(v).filter(key => _options.includes(key)).reduce((obj, key) => {
+    const res = sessionOptions[key].validator(v[key], v);
+    res.errors.map(error => errors.push(error));
+    res.warnings.map(warning => warnings.push(warning));
+    obj[key] = res.value;
+    return obj;
+  }, {});
+  return {
+    errors,
+    warnings,
+    value
+  };
+}
+/**
+ * Validate session type
+ * @param value
+ * @return {}
+ */
+
+
+const validateSessionType = (value, session) => {
+  const errors = [];
+  const warnings = [];
+
+  if (!session[Session.SESSION_TYPE_OPTION] || !Session.sessionTypes.includes(session[Session.SESSION_TYPE_OPTION])) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_SESSION_TYPE);
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate session client id
+ * @param value
+ * @return {}
+ */
+
+
+exports.validateSessionType = validateSessionType;
+
+const validateSessionClientId = (value, session) => {
+  const errors = [];
+  const warnings = [];
+
+  if (session[Session.SESSION_TYPE_OPTION] && (session[Session.SESSION_TYPE_OPTION] === Session.OAUTH_SESSION || session[Session.SESSION_TYPE_OPTION] === Session.OAUTH_SESSION)) {
+    if (session[Session.SESSION_TYPE_OPTION] === Session.OAUTH_SESSION && (!session[Session.SESSION_CLIENT_ID_OPTION] || !(0, _string.isString)(session[Session.SESSION_CLIENT_ID_OPTION]))) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_SESSION_CLIENT_ID);
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate session auth token
+ * @param value
+ * @return {}
+ */
+
+
+exports.validateSessionClientId = validateSessionClientId;
+
+const validateSessionAuthTokenOption = (value, session) => {
+  const errors = [];
+  const warnings = [];
+
+  if (session[Session.SESSION_TYPE_OPTION] && (session[Session.SESSION_TYPE_OPTION] === Session.OAUTH_SESSION || session[Session.SESSION_TYPE_OPTION] === Session.JWT_SESSION)) {
+    if (session[Session.SESSION_AUTH_TOKEN_OPTION] && !(0, _object.isObject)(session[Session.SESSION_AUTH_TOKEN_OPTION])) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_SESSION_AUTH_TOKEN);
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate handleRefreshToken option
+ * @param value
+ * @return {}
+ */
+
+
+exports.validateSessionAuthTokenOption = validateSessionAuthTokenOption;
+
+const validateHandleRefreshToken = (value, session) => {
+  const errors = [];
+  const warnings = [];
+
+  if (session[Session.SESSION_TYPE_OPTION] && (session[Session.SESSION_TYPE_OPTION] === Session.OAUTH_SESSION || session[Session.SESSION_TYPE_OPTION] === Session.JWT_SESSION)) {
+    if (session.authToken && !session.handleRefreshToken) {
+      warnings.push(_errors.ValidationWarnings.WARNING_SESSION_REFRESH_TOKEN_CALLBACK_NOT_FOUND);
+    }
+
+    if (session.handleRefreshToken && !(0, _errors.isFunc)(session.handleRefreshToken)) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_SESSION_REFRESH_TOKEN_CALLBACK);
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate notifications option
+ * @param notifications
+ * @return {}
+ */
+
+
+exports.validateHandleRefreshToken = validateHandleRefreshToken;
+
+function validateNotifications(v) {
+  const errors = [];
+  const warnings = [];
+
+  if (!v || !(0, _object.isObject)(v)) {
+    return {
+      errors,
+      warnings,
+      value: Notifications.DEFAULT_NOTIFICATIONS
+    };
+  }
+
+  const _options = Object.keys(notificationsOptions);
+
+  const value = Object.keys(v).filter(key => _options.includes(key)).reduce((obj, key) => {
+    const res = notificationsOptions[key].validator(v[key], v);
+    res.errors.map(error => errors.push(error));
+    res.warnings.map(warning => warnings.push(warning));
+    obj[key] = res.value;
+    return obj;
+  }, {});
+  return {
+    errors,
+    warnings,
+    value: Object.assign({}, Notifications.DEFAULT_NOTIFICATIONS, v)
+  };
+}
+/**
+ * Validate webSocket
+ * @param value
+ * @param {}
+ */
+
+
+const validateWebSocket = v => {
+  const errors = [];
+  const warnings = [];
+
+  if (v && !(0, _object.isObject)(v)) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET);
+    return {
+      errors,
+      warnings,
+      v
+    };
+  }
+
+  const _options = Object.keys(notificationsWebSocketOptions);
+
+  const value = Object.keys(v).filter(key => _options.includes(key)).reduce((obj, key) => {
+    const res = notificationsWebSocketOptions[key].validator(v[key], v);
+    res.errors.map(error => errors.push(error));
+    res.warnings.map(warning => warnings.push(warning));
+    obj[key] = res.value;
+    return obj;
+  }, {});
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate default disableToastMessage (webSocket)
+ * @param value
+ * @param {}
+ */
+
+
+exports.validateWebSocket = validateWebSocket;
+
+const validateWebSocketDisableToastMessage = (value, notifications) => {
+  const errors = [];
+  const warnings = [];
+
+  if (value) {
+    if (!(typeof value === 'boolean')) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET_DISABLE_TOAST_MESSAGE);
+    }
+  } else {
+    return {
+      errors,
+      warnings,
+      value: Notifications.DEFAULT_NOTIFICATIONS[Notifications.NOTIFICATIONS_WEB_SOCKET_OPTION][Notifications.NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION]
+    };
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate webPushMessaging
+ * @param value
+ * @param {}
+ */
+
+
+exports.validateWebSocketDisableToastMessage = validateWebSocketDisableToastMessage;
+
+const validateWebPushMessaging = v => {
+  const errors = [];
+  const warnings = [];
+
+  if (v && !(0, _object.isObject)(v)) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING);
+    return {
+      errors,
+      warnings,
+      v
+    };
+  }
+
+  const _options = Object.keys(notificationsWebSPushMessagingOptions);
+
+  const value = Object.keys(v).filter(key => _options.includes(key)).reduce((obj, key) => {
+    const res = notificationsWebSPushMessagingOptions[key].validator(v[key], v);
+    res.errors.map(error => errors.push(error));
+    res.warnings.map(warning => warnings.push(warning));
+    obj[key] = res.value;
+    return obj;
+  }, {});
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate default disableToastMessage (webPushMessaging)
+ * @param value
+ * @param {}
+ */
+
+
+exports.validateWebPushMessaging = validateWebPushMessaging;
+
+const validateWebPushMessagingDisableToastMessage = (value, notifications) => {
+  const errors = [];
+  const warnings = [];
+
+  if (value !== undefined) {
+    if (!(typeof value === 'boolean')) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_DISABLE_TOAST_MESSAGE);
+    }
+  } else {
+    return {
+      errors,
+      warnings,
+      value: Notifications.DEFAULT_NOTIFICATIONS[Notifications.NOTIFICATIONS_WEB_PUSH_MESSAGING_OPTION][Notifications.NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION]
+    };
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate default applicationServerKey (webPushMessaging)
+ * @param value
+ * @param {}
+ */
+
+
+exports.validateWebPushMessagingDisableToastMessage = validateWebPushMessagingDisableToastMessage;
+
+const validateWebPushMessagingApplicationServerKey = (value, notifications) => {
+  const errors = [];
+  const warnings = [];
+
+  if (value) {
+    if (!(0, _string.isString)(value)) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_APPLICATION_SERVER_KEY);
+    }
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate portal option
+ * @param portal
+ * @return {}
+ */
+
+
+exports.validateWebPushMessagingApplicationServerKey = validateWebPushMessagingApplicationServerKey;
+
+const validatePortal = value => {
+  const errors = [];
+  const warnings = [];
+
+  if (!value || !(0, _string.isString)(value) || !(0, _url.isValidUrl)(value)) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_PORTAL);
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate default locale
+ * @param value
+ * @param {}
+ */
+
+
+exports.validatePortal = validatePortal;
+
+const validateLocaleDefault = (value, locale) => {
+  const errors = [];
+  const warnings = [];
+
+  if (locale.default) {
+    if (!(0, _string.isString)(value) || !locale[Locale.LOCALE_MESSAGES_OPTION] && !Locale.LOCALES.includes(value)) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_LOCALE);
+    }
+  } else {
+    warnings.push(_errors.ValidationWarnings.WARNING_LOCALE_FALLBACK);
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate default locale
+ * @param value
+ * @param {}
+ */
+
+
+exports.validateLocaleDefault = validateLocaleDefault;
+
+const validateLocaleMessages = value => {
+  const errors = [];
+  const warnings = [];
+
+  if (value.messages && !(0, _object.isObject)(value.messages)) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_TRANSLATIONS);
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate locale option
+ * @param locale
+ * @return {}
+ */
+
+
+exports.validateLocaleMessages = validateLocaleMessages;
+
+const validateLocale = v => {
+  const errors = [];
+  const warnings = [];
+
+  if (!v || !(0, _object.isObject)(v) || (0, _object.isObject)(v) && !v.messages && !v.default) {
+    warnings.push(_errors.ValidationWarnings.WARNING_LOCALE_FALLBACK);
+    return {
+      errors,
+      warnings,
+      v
+    };
+  }
+
+  const _options = Object.keys(localeOptions);
+
+  const value = Object.keys(v).filter(key => _options.includes(key)).reduce((obj, key) => {
+    const res = localeOptions[key].validator(v[key], v);
+    res.errors.map(error => errors.push(error));
+    res.warnings.map(warning => warnings.push(warning));
+    obj[key] = res.value;
+    return obj;
+  }, {});
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate router option
+ * @param router
+ * @return {}
+ */
+
+
+exports.validateLocale = validateLocale;
+
+const validateRouter = value => {
+  const errors = [];
+  const warnings = [];
+
+  if (value) {
+    if (!(0, _object.isObject)(value)) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_ROUTER);
+    } else {
+      if (value.routes && !(0, _object.isObject)(value.routes) || value.handleRoute && !(0, _errors.isFunc)(value.handleRoute)) {
+        errors.push(_errors.ValidationError.ERROR_INVALID_ROUTER);
+      }
+    }
+  } else {
+    warnings.push(_errors.ValidationWarnings.WARNING_ROUTER_FALLBACK);
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate theme option
+ * @param theme
+ * @return {}
+ */
+
+
+exports.validateRouter = validateRouter;
+
+const validateTheme = value => {
+  const errors = [];
+  const warnings = [];
+
+  if (value && !(0, _object.isObject)(value)) {
+    errors.push(_errors.ValidationError.ERROR_INVALID_THEME);
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Validate handleAnonymousAction option
+ * @param handleAnonymousAction
+ * @return {}
+ */
+
+
+exports.validateTheme = validateTheme;
+
+const validateHandleAnonymousAction = v => {
+  const errors = [];
+  const warnings = [];
+
+  if (v) {
+    if (!(0, _errors.isFunc)(v)) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_HANDLE_ANONYMOUS_ACTION);
+    }
+  } else {
+    warnings.push(_errors.ValidationWarnings.WARNING_HANDLE_ANONYMOUS_ACTION_FALLBACK);
+    return {
+      errors,
+      warnings,
+      value: () => {
+        _logger.Logger.info(_Errors.SCOPE_SC_CORE, 'Attempting to perform an action that requires a logged user.');
+      }
+    };
+  }
+
+  return {
+    errors,
+    warnings,
+    value: v
+  };
+};
+/**
+ * Validate contextProviders option
+ * @param contextProviders
+ * @return [...contextProviders]
+ */
+
+
+exports.validateHandleAnonymousAction = validateHandleAnonymousAction;
+
+const validateContextProviders = value => {
+  const errors = [];
+  const warnings = [];
+
+  if (value) {
+    if (!Array.isArray(value)) {
+      errors.push(_errors.ValidationError.ERROR_INVALID_PROVIDERS);
+    } else {
+      const _providers = value.filter(c => !_ContextProviders.DEFAULT_CONTEXT_PROVIDERS.includes(c));
+
+      if (_providers.length > 0) {
+        errors.push(_errors.ValidationError.ERROR_INVALID_PROVIDERS);
+      }
+    }
+  } else {
+    return {
+      errors,
+      warnings,
+      value: _ContextProviders.DEFAULT_CONTEXT_PROVIDERS
+    };
+  }
+
+  return {
+    errors,
+    warnings,
+    value
+  };
+};
+/**
+ * Components Widget
+ */
+
+
+exports.validateContextProviders = validateContextProviders;
+const PortalOption = {
+  name: _Routes.PORTAL_OPTION,
+  validator: validatePortal
+};
+const LocaleOption = {
+  name: Locale.LOCALE_OPTION,
+  validator: validateLocale
+};
+const ThemeOption = {
+  name: Theme.THEME_OPTION,
+  validator: validateTheme
+};
+const RouterOption = {
+  name: _Routes.ROUTER_OPTION,
+  validator: validateRouter
+};
+const NotificationsOption = {
+  name: Notifications.NOTIFICATIONS_OPTION,
+  validator: validateNotifications
+};
+const SessionOption = {
+  name: Session.SESSION_OPTION,
+  validator: validateSession
+};
+const HandleAnonymousActionOption = {
+  name: Actions.HANDLE_ANONYMOUS_ACTION_OPTION,
+  validator: validateHandleAnonymousAction
+};
+const ContextProvidersOption = {
+  name: _ContextProviders.CONTEXT_PROVIDERS_OPTION,
+  validator: validateContextProviders
+};
+/**
+ * Session options
+ */
+
+const SessionTypeOption = {
+  name: Session.SESSION_TYPE_OPTION,
+  validator: validateSessionType
+};
+const SessionClientIdOption = {
+  name: Session.SESSION_CLIENT_ID_OPTION,
+  validator: validateSessionClientId
+};
+const SessionAuthTokenOption = {
+  name: Session.SESSION_AUTH_TOKEN_OPTION,
+  validator: validateSessionAuthTokenOption
+};
+const SessionHandleRefreshTokenOption = {
+  name: Session.SESSION_HANDLE_REFRESH_TOKEN_OPTION,
+  validator: validateHandleRefreshToken
+};
+const LocaleDefaultOption = {
+  name: Locale.LOCALE_DEFAULT_OPTION,
+  validator: validateLocaleDefault
+};
+const LocaleMessagesOption = {
+  name: Locale.LOCALE_MESSAGES_OPTION,
+  validator: validateLocaleMessages
+};
+const NotificationsWebSocketOption = {
+  name: Notifications.NOTIFICATIONS_WEB_SOCKET_OPTION,
+  validator: validateWebSocket
+};
+const NotificationsWebPushMessagingOption = {
+  name: Notifications.NOTIFICATIONS_WEB_PUSH_MESSAGING_OPTION,
+  validator: validateWebPushMessaging
+};
+const NotificationsWebSocketDisableToastMessageOption = {
+  name: Notifications.NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION,
+  validator: validateWebSocketDisableToastMessage
+};
+const NotificationsWebPushMessagingDisableToastMessageOption = {
+  name: Notifications.NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION,
+  validator: validateWebPushMessagingDisableToastMessage
+};
+const NotificationsWebPushMessagingApplicationServerKeyOption = {
+  name: Notifications.NOTIFICATIONS_APPLICATION_SERVER_KEY_OPTION,
+  validator: validateWebPushMessagingApplicationServerKey
+};
+/**
+ * Valid options
+ * @type {{}}
+ */
+
+const settingsOptions = {
+  [PortalOption.name]: PortalOption,
+  [LocaleOption.name]: LocaleOption,
+  [ThemeOption.name]: ThemeOption,
+  [NotificationsOption.name]: NotificationsOption,
+  [RouterOption.name]: RouterOption,
+  [SessionOption.name]: SessionOption,
+  [HandleAnonymousActionOption.name]: HandleAnonymousActionOption,
+  [ContextProvidersOption.name]: ContextProvidersOption
+};
+exports.settingsOptions = settingsOptions;
+const sessionOptions = {
+  [SessionTypeOption.name]: SessionTypeOption,
+  [SessionClientIdOption.name]: SessionClientIdOption,
+  [SessionAuthTokenOption.name]: SessionAuthTokenOption,
+  [SessionHandleRefreshTokenOption.name]: SessionHandleRefreshTokenOption
+};
+exports.sessionOptions = sessionOptions;
+const localeOptions = {
+  [LocaleDefaultOption.name]: LocaleDefaultOption,
+  [LocaleMessagesOption.name]: LocaleMessagesOption
+};
+exports.localeOptions = localeOptions;
+const notificationsOptions = {
+  [NotificationsWebSocketOption.name]: NotificationsWebSocketOption,
+  [NotificationsWebPushMessagingOption.name]: NotificationsWebPushMessagingOption
+};
+exports.notificationsOptions = notificationsOptions;
+const notificationsWebSocketOptions = {
+  [NotificationsWebSocketDisableToastMessageOption.name]: NotificationsWebSocketDisableToastMessageOption
+};
+exports.notificationsWebSocketOptions = notificationsWebSocketOptions;
+const notificationsWebSPushMessagingOptions = {
+  [NotificationsWebPushMessagingDisableToastMessageOption.name]: NotificationsWebPushMessagingDisableToastMessageOption,
+  [NotificationsWebPushMessagingApplicationServerKeyOption.name]: NotificationsWebPushMessagingApplicationServerKeyOption
+};
+exports.notificationsWebSPushMessagingOptions = notificationsWebSPushMessagingOptions;
+const validOptions = Object.assign({}, settingsOptions);
+/**
+ * Validate all options by type
+ * @param options
+ * @return {options hydrated}
+ */
+
+exports.validOptions = validOptions;
+
+const validateOptions = (values, schemaOptions) => {
+  const validationResult = new _errors.ValidationResult(_Errors.SCOPE_SC_CORE);
+
+  if (!values) {
+    validationResult.addError(_errors.ValidationError.ERROR_INVALID_CONF, values);
+    return {
+      validationResult,
+      values
+    };
+  }
+
+  const _options = Object.keys(schemaOptions);
+
+  const _data = Object.assign({}, values, Object.keys(schemaOptions).reduce((obj, key) => {
+    obj[key] = null;
+    return obj;
+  }, {}));
+
+  const settings = Object.keys(_data).filter(key => _options.includes(key)).reduce((obj, key) => {
+    const res = schemaOptions[key].validator(values[key]);
+    res.errors.map(error => validationResult.addError(error, res.value));
+    res.warnings.map(warning => validationResult.addWarnings(warning, res.value));
+    obj[key] = res.value;
+    return obj;
+  }, {});
+  return {
+    validationResult,
+    settings
+  };
+};
+
+exports.validateOptions = validateOptions;