@selfcommunity/react-core/lib/cjs/utils/validator.js

React Core Components useful for integrating UI Community components (react-ui).

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateOptions = exports.validOptions = exports.integrationsGeocodingOptions = exports.integrationsOpenAIOptions = exports.integrationsOptions = exports.voteOptions = exports.preferencesOptions = exports.notificationsMobileNativePushMessagingOptions = exports.notificationsWebPushMessagingOptions = exports.notificationsWebSocketOptions = exports.notificationsOptions = exports.localeOptions = exports.sessionOptions = exports.settingsOptions = exports.validateGeocodingApiKey = exports.validateOpenAISecretKey = exports.validateGeocoding = exports.validateOpenAI = exports.validateIntegrations = exports.validateVote = exports.validateReactions = exports.validatePreferences = exports.validateFeatures = exports.validateGlobalPreferences = exports.validateContextProviders = exports.validateHandleAnonymousAction = exports.validateTheme = exports.validateRouter = exports.validateLocale = exports.validateLocaleMessages = exports.validateLocaleDefault = exports.validatePortal = exports.validateMobileNativePushMessagingDisable = exports.validateMobileNativePushMessaging = exports.validateWebPushMessagingApplicationServerKey = exports.validateWebPushMessagingDisableToastMessage = exports.validateWebPushMessaging = exports.validateWebSocketPrefixPath = exports.validateWebSocketSecure = exports.validateWebSocketDisableToastMessage = exports.validateWebSocket = exports.validateNotifications = exports.validateHandleLogout = exports.validateHandleRefreshToken = exports.validateSessionAuthTokenOption = exports.validateSessionClientId = exports.validateSessionType = exports.validateSession = void 0;
const tslib_1 = require("tslib");
const Locale = tslib_1.__importStar(require("../constants/Locale"));
const utils_1 = require("@selfcommunity/utils");
const Session = tslib_1.__importStar(require("../constants/Session"));
const Errors_1 = require("../constants/Errors");
const errors_1 = require("./errors");
const ContextProviders_1 = require("../constants/ContextProviders");
const Notifications = tslib_1.__importStar(require("../constants/Notifications"));
const Theme = tslib_1.__importStar(require("../constants/Theme"));
const Routes_1 = require("../constants/Routes");
const Actions = tslib_1.__importStar(require("../constants/Actions"));
const Preferences = tslib_1.__importStar(require("../constants/Preferences"));
const Features = tslib_1.__importStar(require("../constants/Features"));
const Vote = tslib_1.__importStar(require("../constants/Vote"));
const Integrations = tslib_1.__importStar(require("../constants/Integrations"));
/**
 * Validate session option
 * @param v
 * @return {}
 */
function validateSession(v) {
    const errors = [];
    const warnings = [];
    if (!v || !(0, utils_1.isObject)(v)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_SESSION);
        return { errors, warnings, value: v };
    }
    const _options = Object.keys(exports.sessionOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.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 };
}
exports.validateSession = validateSession;
/**
 * Validate session type
 * @param value
 * @param session
 * @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_1.ValidationError.ERROR_INVALID_SESSION_TYPE);
    }
    return { errors, warnings, value };
};
exports.validateSessionType = validateSessionType;
/**
 * Validate session client id
 * @param value
 * @param session
 * @return {}
 */
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, utils_1.isString)(session[Session.SESSION_CLIENT_ID_OPTION]))) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_SESSION_CLIENT_ID);
        }
    }
    return { errors, warnings, value };
};
exports.validateSessionClientId = validateSessionClientId;
/**
 * Validate session auth token
 * @param value
 * @param session
 * @return {}
 */
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, utils_1.isObject)(session[Session.SESSION_AUTH_TOKEN_OPTION])) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_SESSION_AUTH_TOKEN);
        }
    }
    return { errors, warnings, value };
};
exports.validateSessionAuthTokenOption = validateSessionAuthTokenOption;
/**
 * Validate handleRefreshToken option
 * @param value
 * @param session
 * @return {}
 */
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_1.ValidationWarnings.WARNING_SESSION_REFRESH_TOKEN_CALLBACK_NOT_FOUND);
        }
        if (session.handleRefreshToken && !(0, utils_1.isFunc)(session.handleRefreshToken)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_SESSION_REFRESH_TOKEN_CALLBACK);
        }
    }
    return { errors, warnings, value };
};
exports.validateHandleRefreshToken = validateHandleRefreshToken;
/**
 * Validate handleLogout option
 * @param value
 * @param session
 * @return {}
 */
const validateHandleLogout = (value, session) => {
    const errors = [];
    const warnings = [];
    if (session.handleLogout && !(0, utils_1.isFunc)(session.handleLogout)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_SESSION_LOGOUT_CALLBACK);
    }
    return { errors, warnings, value };
};
exports.validateHandleLogout = validateHandleLogout;
/**
 * Validate notifications option
 * @param v
 * @return {}
 */
function validateNotifications(v) {
    const errors = [];
    const warnings = [];
    if (!v || !(0, utils_1.isObject)(v)) {
        return { errors, warnings, value: Notifications.DEFAULT_NOTIFICATIONS };
    }
    const _options = Object.keys(exports.notificationsOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.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(Object.assign({}, Notifications.DEFAULT_NOTIFICATIONS), value) };
}
exports.validateNotifications = validateNotifications;
/**
 * Validate webSocket
 * @param v
 */
const validateWebSocket = (v) => {
    const errors = [];
    const warnings = [];
    if (v && !(0, utils_1.isObject)(v)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET);
        return { errors, warnings, v };
    }
    const _options = Object.keys(exports.notificationsWebSocketOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.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 };
};
exports.validateWebSocket = validateWebSocket;
/**
 * Validate default disableToastMessage (webSocket)
 * @param value
 */
const validateWebSocketDisableToastMessage = (value) => {
    const errors = [];
    const warnings = [];
    if (value) {
        if (!(typeof value === 'boolean')) {
            errors.push(errors_1.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 };
};
exports.validateWebSocketDisableToastMessage = validateWebSocketDisableToastMessage;
/**
 * Validate default secure (webSocket)
 * @param value
 */
const validateWebSocketSecure = (value) => {
    const errors = [];
    const warnings = [];
    if ((value === null || value === void 0 ? void 0 : value.toString()) !== undefined) {
        if (!(typeof value === 'boolean')) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET_SECURE);
        }
    }
    else {
        return {
            errors,
            warnings,
            value: Notifications.DEFAULT_NOTIFICATIONS[Notifications.NOTIFICATIONS_WEB_SOCKET_OPTION][Notifications.NOTIFICATIONS_WEBSOCKET_SECURE_OPTION],
        };
    }
    return { errors, warnings, value };
};
exports.validateWebSocketSecure = validateWebSocketSecure;
/**
 * Validate prefixPath (webSocket)
 * @param value
 */
const validateWebSocketPrefixPath = (value) => {
    const errors = [];
    const warnings = [];
    if (!value || !(0, utils_1.isString)(value)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEBSOCKET_PREFIX_PATH);
    }
    return { errors, warnings, value };
};
exports.validateWebSocketPrefixPath = validateWebSocketPrefixPath;
/**
 * Validate webPushMessaging
 * @param v
 */
const validateWebPushMessaging = (v) => {
    const errors = [];
    const warnings = [];
    if (v && !(0, utils_1.isObject)(v)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING);
        return { errors, warnings, v };
    }
    const _options = Object.keys(exports.notificationsWebPushMessagingOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.notificationsWebPushMessagingOptions[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 };
};
exports.validateWebPushMessaging = validateWebPushMessaging;
/**
 * Validate default disableToastMessage (webPushMessaging)
 * @param value
 */
const validateWebPushMessagingDisableToastMessage = (value) => {
    const errors = [];
    const warnings = [];
    if (value !== undefined) {
        if (!(typeof value === 'boolean')) {
            errors.push(errors_1.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 };
};
exports.validateWebPushMessagingDisableToastMessage = validateWebPushMessagingDisableToastMessage;
/**
 * Validate default applicationServerKey (webPushMessaging)
 * @param value
 */
const validateWebPushMessagingApplicationServerKey = (value) => {
    const errors = [];
    const warnings = [];
    if (value) {
        if (!(0, utils_1.isString)(value)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_WEB_PUSH_MESSAGING_APPLICATION_SERVER_KEY);
        }
    }
    return { errors, warnings, value };
};
exports.validateWebPushMessagingApplicationServerKey = validateWebPushMessagingApplicationServerKey;
/**
 * Validate mobile native
 * @param v
 */
const validateMobileNativePushMessaging = (v) => {
    const errors = [];
    const warnings = [];
    if (v && !(0, utils_1.isObject)(v)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_MOBILE_NATIVE_PUSH_MESSAGING);
        return { errors, warnings, v };
    }
    const _options = Object.keys(exports.notificationsMobileNativePushMessagingOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.notificationsMobileNativePushMessagingOptions[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 };
};
exports.validateMobileNativePushMessaging = validateMobileNativePushMessaging;
/**
 * Validate default disable (mobileNativePushMessaging)
 * @param value
 */
const validateMobileNativePushMessagingDisable = (value) => {
    const errors = [];
    const warnings = [];
    if (value !== undefined) {
        if (!(typeof value === 'boolean')) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_NOTIFICATIONS_MOBILE_PUSH_MESSAGING_DISABLE);
        }
    }
    else {
        return {
            errors,
            warnings,
            value: Notifications.DEFAULT_NOTIFICATIONS[Notifications.NOTIFICATIONS_MOBILE_NATIVE_DISABLE_OPTION][Notifications.NOTIFICATIONS_MOBILE_NATIVE_DISABLE_OPTION],
        };
    }
    return { errors, warnings, value };
};
exports.validateMobileNativePushMessagingDisable = validateMobileNativePushMessagingDisable;
/**
 * Validate portal option
 * @param value
 * @return {}
 */
const validatePortal = (value) => {
    const errors = [];
    const warnings = [];
    if (!value || !(0, utils_1.isString)(value) || !(0, utils_1.isValidUrl)(value)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_PORTAL);
    }
    return { errors, warnings, value };
};
exports.validatePortal = validatePortal;
/**
 * Validate default locale
 * @param value
 * @param locale
 */
const validateLocaleDefault = (value, locale) => {
    const errors = [];
    const warnings = [];
    if (locale.default) {
        if (!(0, utils_1.isString)(value) || (!locale[Locale.LOCALE_MESSAGES_OPTION] && !Locale.LOCALES.includes(value))) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_LOCALE);
        }
    }
    else {
        warnings.push(errors_1.ValidationWarnings.WARNING_LOCALE_FALLBACK);
    }
    return { errors, warnings, value };
};
exports.validateLocaleDefault = validateLocaleDefault;
/**
 * Validate default locale
 * @param value
 */
const validateLocaleMessages = (value) => {
    const errors = [];
    const warnings = [];
    if (value.messages && !(0, utils_1.isObject)(value.messages)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_TRANSLATIONS);
    }
    return { errors, warnings, value };
};
exports.validateLocaleMessages = validateLocaleMessages;
/**
 * Validate locale option
 * @param v
 * @return {}
 */
const validateLocale = (v) => {
    const errors = [];
    const warnings = [];
    if (!v || !(0, utils_1.isObject)(v) || ((0, utils_1.isObject)(v) && !v.messages && !v.default)) {
        warnings.push(errors_1.ValidationWarnings.WARNING_LOCALE_FALLBACK);
        return { errors, warnings, v };
    }
    const _options = Object.keys(exports.localeOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.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 };
};
exports.validateLocale = validateLocale;
/**
 * Validate router option
 * @param value
 * @return {}
 */
const validateRouter = (value) => {
    const errors = [];
    const warnings = [];
    if (value) {
        if (!(0, utils_1.isObject)(value)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_ROUTER);
        }
        else {
            if ((value.routes && !(0, utils_1.isObject)(value.routes)) || (value.handleRoute && !(0, utils_1.isFunc)(value.handleRoute))) {
                errors.push(errors_1.ValidationError.ERROR_INVALID_ROUTER);
            }
        }
    }
    else {
        warnings.push(errors_1.ValidationWarnings.WARNING_ROUTER_FALLBACK);
    }
    return { errors, warnings, value };
};
exports.validateRouter = validateRouter;
/**
 * Validate theme option
 * @param value
 * @return {}
 */
const validateTheme = (value) => {
    const errors = [];
    const warnings = [];
    if (value && !(0, utils_1.isObject)(value)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_THEME);
    }
    return { errors, warnings, value };
};
exports.validateTheme = validateTheme;
/**
 * Validate handleAnonymousAction option
 * @param v
 * @return {}
 */
const validateHandleAnonymousAction = (v) => {
    const errors = [];
    const warnings = [];
    if (v) {
        if (!(0, utils_1.isFunc)(v)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_HANDLE_ANONYMOUS_ACTION);
        }
    }
    else {
        warnings.push(errors_1.ValidationWarnings.WARNING_HANDLE_ANONYMOUS_ACTION_FALLBACK);
        return {
            errors,
            warnings,
            value: () => {
                utils_1.Logger.info(Errors_1.SCOPE_SC_CORE, 'Attempting to perform an action that requires a logged user.');
            },
        };
    }
    return { errors, warnings, value: v };
};
exports.validateHandleAnonymousAction = validateHandleAnonymousAction;
/**
 * Validate contextProviders option
 * @param value
 * @return [...contextProviders]
 */
const validateContextProviders = (value) => {
    const errors = [];
    const warnings = [];
    if (value) {
        if (!Array.isArray(value)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_PROVIDERS);
        }
        else {
            const _providers = value.filter((c) => !ContextProviders_1.DEFAULT_CONTEXT_PROVIDERS.includes(c));
            if (_providers.length > 0) {
                errors.push(errors_1.ValidationError.ERROR_INVALID_PROVIDERS);
            }
        }
    }
    else {
        return { errors, warnings, value: ContextProviders_1.DEFAULT_CONTEXT_PROVIDERS };
    }
    return { errors, warnings, value };
};
exports.validateContextProviders = validateContextProviders;
/**
 * Validate global preferences
 * @param value
 * @param preferences
 */
const validateGlobalPreferences = (value, preferences) => {
    const errors = [];
    const warnings = [];
    if (preferences[Preferences.GLOBAL_PREFERENCES_OPTION]) {
        if (!(0, utils_1.isObject)(value)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_GLOBAL_PREFERENCES);
        }
        else {
            const isValidKeys = Object.keys(value).every((key) => /[a-zA-Z]+.[a-zA-Z]+/g.test(key));
            if (!isValidKeys) {
                errors.push(errors_1.ValidationError.ERROR_INVALID_GLOBAL_PREFERENCES);
            }
        }
    }
    return { errors, warnings, value };
};
exports.validateGlobalPreferences = validateGlobalPreferences;
/**
 * Validate features
 * @param value
 * @param preferences
 */
const validateFeatures = (value, preferences) => {
    const errors = [];
    const warnings = [];
    if (preferences[Features.FEATURES_OPTION]) {
        if (!Array.isArray(value)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_PREFERENCES_FEATURES);
        }
    }
    return { errors, warnings, value };
};
exports.validateFeatures = validateFeatures;
/**
 * Validate preferences option
 * @param v
 */
function validatePreferences(v) {
    const errors = [];
    const warnings = [];
    const defaultValue = {
        [Preferences.GLOBAL_PREFERENCES_OPTION]: Preferences.DEFAULT_GLOBAL_PREFERENCES_OPTION,
        [Features.FEATURES_OPTION]: Features.DEFAULT_FEATURES_OPTION,
    };
    if (v) {
        if (!(0, utils_1.isObject)(v)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_PREFERENCES);
            return { errors, warnings, value: v };
        }
        else {
            const _options = Object.keys(exports.preferencesOptions);
            const value = Object.keys(v)
                .filter((key) => _options.includes(key))
                .reduce((obj, key) => {
                const res = exports.preferencesOptions[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(Object.assign({}, defaultValue), value) };
        }
    }
    return { errors, warnings, value: defaultValue };
}
exports.validatePreferences = validatePreferences;
/**
 * Validate reactions
 * @param value
 * @param vote
 */
const validateReactions = (value, vote) => {
    const errors = [];
    const warnings = [];
    if (vote[Vote.VOTE_REACTIONS_OPTION]) {
        if (!Array.isArray(value)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_VOTE_REACTIONS);
        }
        if (Array.isArray(value) && value.length > 0) {
            let _validValuesCounts = value.filter((e) => e.id !== null && e.label !== null && e.sentiment !== null && e.image && e.active !== null).length;
            if (_validValuesCounts < value.length) {
                errors.push(errors_1.ValidationError.ERROR_INVALID_VOTE_REACTIONS_STRUCTURE);
            }
        }
    }
    return { errors, warnings, value };
};
exports.validateReactions = validateReactions;
/**
 * Validate vote option
 * @param v
 */
function validateVote(v) {
    const errors = [];
    const warnings = [];
    const defaultValue = {
        [Vote.VOTE_REACTIONS_OPTION]: Vote.DEFAULT_VOTE_REACTIONS_OPTION,
    };
    if (v) {
        if (!(0, utils_1.isObject)(v)) {
            errors.push(errors_1.ValidationError.ERROR_INVALID_VOTE);
            return { errors, warnings, value: v };
        }
        else {
            const _options = Object.keys(exports.voteOptions);
            const value = Object.keys(v)
                .filter((key) => _options.includes(key))
                .reduce((obj, key) => {
                const res = exports.voteOptions[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(Object.assign({}, defaultValue), value) };
        }
    }
    return { errors, warnings, value: defaultValue };
}
exports.validateVote = validateVote;
/**
 * Validate integrations option
 * @param v
 * @return {}
 */
function validateIntegrations(v) {
    const errors = [];
    const warnings = [];
    if (!v || !(0, utils_1.isObject)(v)) {
        return { errors, warnings, value: Integrations.DEFAULT_INTEGRATIONS_OPTION };
    }
    const _options = Object.keys(exports.integrationsOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.integrationsOptions[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(Object.assign({}, Integrations.DEFAULT_INTEGRATIONS_OPTION), value) };
}
exports.validateIntegrations = validateIntegrations;
/**
 * Validate OpenAI Option
 * @param v
 */
const validateOpenAI = (v) => {
    const errors = [];
    const warnings = [];
    if (v && !(0, utils_1.isObject)(v)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_INTEGRATIONS_OPENAI);
        return { errors, warnings, v };
    }
    const _options = Object.keys(exports.integrationsOpenAIOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.integrationsOpenAIOptions[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 };
};
exports.validateOpenAI = validateOpenAI;
/**
 * Validate Geocoding Option
 * @param v
 */
const validateGeocoding = (v) => {
    const errors = [];
    const warnings = [];
    if (v && !(0, utils_1.isObject)(v)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_INTEGRATIONS_GEOCODING);
        return { errors, warnings, v };
    }
    const _options = Object.keys(exports.integrationsGeocodingOptions);
    const value = Object.keys(v)
        .filter((key) => _options.includes(key))
        .reduce((obj, key) => {
        const res = exports.integrationsGeocodingOptions[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 };
};
exports.validateGeocoding = validateGeocoding;
/**
 * Validate OpenAI secret key option
 * @param value
 * @return {}
 */
const validateOpenAISecretKey = (value) => {
    const errors = [];
    const warnings = [];
    if (!value || !(0, utils_1.isString)(value)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_INTEGRATIONS_OPENAI_SECRETKEY);
    }
    return { errors, warnings, value };
};
exports.validateOpenAISecretKey = validateOpenAISecretKey;
/**
 * Validate Geocoding api key option
 * @param value
 * @return {}
 */
const validateGeocodingApiKey = (value) => {
    const errors = [];
    const warnings = [];
    if (!value || !(0, utils_1.isString)(value)) {
        errors.push(errors_1.ValidationError.ERROR_INVALID_INTEGRATIONS_GEOCODING_APIKEY);
    }
    return { errors, warnings, value };
};
exports.validateGeocodingApiKey = validateGeocodingApiKey;
/**
 * Components Widget
 */
const PortalOption = {
    name: Routes_1.PORTAL_OPTION,
    validator: exports.validatePortal,
};
const LocaleOption = {
    name: Locale.LOCALE_OPTION,
    validator: exports.validateLocale,
};
const ThemeOption = {
    name: Theme.THEME_OPTION,
    validator: exports.validateTheme,
};
const RouterOption = {
    name: Routes_1.ROUTER_OPTION,
    validator: exports.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: exports.validateHandleAnonymousAction,
};
const ContextProvidersOption = {
    name: ContextProviders_1.CONTEXT_PROVIDERS_OPTION,
    validator: exports.validateContextProviders,
};
const PreferencesOption = {
    name: Preferences.PREFERENCES_OPTION,
    validator: validatePreferences,
};
const VoteOption = {
    name: Vote.VOTE_OPTION,
    validator: validateVote,
};
const IntegrationsOption = {
    name: Integrations.INTEGRATIONS_OPTION,
    validator: validateIntegrations,
};
/**
 * Session options
 */
const SessionTypeOption = {
    name: Session.SESSION_TYPE_OPTION,
    validator: exports.validateSessionType,
};
const SessionClientIdOption = {
    name: Session.SESSION_CLIENT_ID_OPTION,
    validator: exports.validateSessionClientId,
};
const SessionAuthTokenOption = {
    name: Session.SESSION_AUTH_TOKEN_OPTION,
    validator: exports.validateSessionAuthTokenOption,
};
const SessionHandleRefreshTokenOption = {
    name: Session.SESSION_HANDLE_REFRESH_TOKEN_OPTION,
    validator: exports.validateHandleRefreshToken,
};
const SessionHandleLogoutOption = {
    name: Session.SESSION_HANDLE_LOGOUT_OPTION,
    validator: exports.validateHandleLogout,
};
const LocaleDefaultOption = {
    name: Locale.LOCALE_DEFAULT_OPTION,
    validator: exports.validateLocaleDefault,
};
const LocaleMessagesOption = {
    name: Locale.LOCALE_MESSAGES_OPTION,
    validator: exports.validateLocaleMessages,
};
const GlobalPreferencesOption = {
    name: Preferences.GLOBAL_PREFERENCES_OPTION,
    validator: exports.validateGlobalPreferences,
};
const FeaturesOption = {
    name: Features.FEATURES_OPTION,
    validator: exports.validateFeatures,
};
const NotificationsWebSocketOption = {
    name: Notifications.NOTIFICATIONS_WEB_SOCKET_OPTION,
    validator: exports.validateWebSocket,
};
const NotificationsWebPushMessagingOption = {
    name: Notifications.NOTIFICATIONS_WEB_PUSH_MESSAGING_OPTION,
    validator: exports.validateWebPushMessaging,
};
const NotificationsMobileNativePushMessagingOption = {
    name: Notifications.NOTIFICATIONS_MOBILE_NATIVE_PUSH_MESSAGING_OPTION,
    validator: exports.validateMobileNativePushMessaging,
};
const NotificationsWebSocketDisableToastMessageOption = {
    name: Notifications.NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION,
    validator: exports.validateWebSocketDisableToastMessage,
};
const NotificationsWebSocketSecureOption = {
    name: Notifications.NOTIFICATIONS_WEBSOCKET_SECURE_OPTION,
    validator: exports.validateWebSocketSecure,
};
const NotificationsWebSocketPrefixPathOption = {
    name: Notifications.NOTIFICATIONS_WEBSOCKET_PREFIX_PATH_OPTION,
    validator: exports.validateWebSocketPrefixPath,
};
const NotificationsWebPushMessagingDisableToastMessageOption = {
    name: Notifications.NOTIFICATIONS_DISABLE_TOAST_MESSAGE_OPTION,
    validator: exports.validateWebPushMessagingDisableToastMessage,
};
const NotificationsWebPushMessagingApplicationServerKeyOption = {
    name: Notifications.NOTIFICATIONS_APPLICATION_SERVER_KEY_OPTION,
    validator: exports.validateWebPushMessagingApplicationServerKey,
};
const NotificationsMobileNativePushMessagingDisableOption = {
    name: Notifications.NOTIFICATIONS_MOBILE_NATIVE_DISABLE_OPTION,
    validator: exports.validateMobileNativePushMessagingDisable,
};
const ReactionsOption = {
    name: Vote.VOTE_REACTIONS_OPTION,
    validator: exports.validateReactions,
};
const IntegrationOpenAIOption = {
    name: Integrations.INTEGRATIONS_OPENAI_OPTION,
    validator: exports.validateOpenAI,
};
const IntegrationOpenAISecretKeyOption = {
    name: Integrations.INTEGRATIONS_OPENAI_SECRETKEY_OPTION,
    validator: exports.validateOpenAISecretKey,
};
const IntegrationGeocodingOption = {
    name: Integrations.INTEGRATIONS_GEOCODING_OPTION,
    validator: exports.validateGeocoding,
};
const IntegrationGeocodingApiKeyOption = {
    name: Integrations.INTEGRATIONS_GEOCODING_APIKEY_OPTION,
    validator: exports.validateGeocodingApiKey,
};
/**
 * Valid options
 * @type {{}}
 */
exports.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,
    [PreferencesOption.name]: PreferencesOption,
    [VoteOption.name]: VoteOption,
    [IntegrationsOption.name]: IntegrationsOption,
};
exports.sessionOptions = {
    [SessionTypeOption.name]: SessionTypeOption,
    [SessionClientIdOption.name]: SessionClientIdOption,
    [SessionAuthTokenOption.name]: SessionAuthTokenOption,
    [SessionHandleRefreshTokenOption.name]: SessionHandleRefreshTokenOption,
    [SessionHandleLogoutOption.name]: SessionHandleLogoutOption,
};
exports.localeOptions = {
    [LocaleDefaultOption.name]: LocaleDefaultOption,
    [LocaleMessagesOption.name]: LocaleMessagesOption,
};
exports.notificationsOptions = {
    [NotificationsWebSocketOption.name]: NotificationsWebSocketOption,
    [NotificationsWebPushMessagingOption.name]: NotificationsWebPushMessagingOption,
    [NotificationsMobileNativePushMessagingOption.name]: NotificationsMobileNativePushMessagingOption,
};
exports.notificationsWebSocketOptions = {
    [NotificationsWebSocketDisableToastMessageOption.name]: NotificationsWebSocketDisableToastMessageOption,
    [NotificationsWebSocketSecureOption.name]: NotificationsWebSocketSecureOption,
    [NotificationsWebSocketPrefixPathOption.name]: NotificationsWebSocketPrefixPathOption,
};
exports.notificationsWebPushMessagingOptions = {
    [NotificationsWebPushMessagingDisableToastMessageOption.name]: NotificationsWebPushMessagingDisableToastMessageOption,
    [NotificationsWebPushMessagingApplicationServerKeyOption.name]: NotificationsWebPushMessagingApplicationServerKeyOption,
};
exports.notificationsMobileNativePushMessagingOptions = {
    [NotificationsMobileNativePushMessagingDisableOption.name]: NotificationsMobileNativePushMessagingDisableOption,
};
exports.preferencesOptions = {
    [GlobalPreferencesOption.name]: GlobalPreferencesOption,
    [FeaturesOption.name]: FeaturesOption,
};
exports.voteOptions = {
    [ReactionsOption.name]: ReactionsOption,
};
exports.integrationsOptions = {
    [IntegrationOpenAIOption.name]: IntegrationOpenAIOption,
    [IntegrationGeocodingOption.name]: IntegrationGeocodingOption,
};
exports.integrationsOpenAIOptions = {
    [IntegrationOpenAISecretKeyOption.name]: IntegrationOpenAISecretKeyOption,
};
exports.integrationsGeocodingOptions = {
    [IntegrationGeocodingApiKeyOption.name]: IntegrationGeocodingApiKeyOption,
};
exports.validOptions = Object.assign({}, exports.settingsOptions);
/**
 * Validate all options by type
 * @param values
 * @param schemaOptions
 * @return {options hydrated}
 */
const validateOptions = (values, schemaOptions) => {
    const validationResult = new errors_1.ValidationResult(Errors_1.SCOPE_SC_CORE);
    if (!values) {
        validationResult.addError(errors_1.ValidationError.ERROR_INVALID_CONF, values);
        return { validationResult, values };
    }
    const _options = Object.keys(schemaOptions);
    const _data = Object.assign(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;