@stylable/core/cjs/state-validators.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.systemValidators = void 0;
const validationErrors = {
    string: {
        STRING_TYPE_VALIDATION_FAILED: (actualParam) => `"${actualParam}" should be of type string`,
        REGEX_VALIDATION_FAILED: (regex, actualParam) => `expected "${actualParam}" to match regex "${regex}"`,
        CONTAINS_VALIDATION_FAILED: (shouldContain, actualParam) => `expected "${actualParam}" to contain string "${shouldContain}"`,
        MIN_LENGTH_VALIDATION_FAILED: (length, actualParam) => `expected "${actualParam}" to be of length longer than or equal to ${length}`,
        MAX_LENGTH_VALIDATION_FAILED: (length, actualParam) => `expected "${actualParam}" to be of length shorter than or equal to ${length}`,
        UKNOWN_VALIDATOR: (name) => `encountered unknown string validator "${name}"`,
    },
    number: {
        NUMBER_TYPE_VALIDATION_FAILED: (actualParam) => `expected "${actualParam}" to be of type number`,
        MIN_VALIDATION_FAILED: (actualParam, min) => `expected "${actualParam}" to be larger than or equal to ${min}`,
        MAX_VALIDATION_FAILED: (actualParam, max) => `expected "${actualParam}" to be lesser then or equal to ${max}`,
        MULTIPLE_OF_VALIDATION_FAILED: (actualParam, multipleOf) => `expected "${actualParam}" to be a multiple of ${multipleOf}`,
        UKNOWN_VALIDATOR: (name) => `encountered unknown number validator "${name}"`,
    },
    enum: {
        ENUM_TYPE_VALIDATION_FAILED: (actualParam, options) => `expected "${actualParam}" to be one of the options: "${options.join(', ')}"`,
        NO_OPTIONS_DEFINED: () => `expected enum to be defined with one option or more`,
    },
    tag: {
        NO_SPACES_ALLOWED: (actualParam) => `expected "${actualParam}" to be a single value with no spaces`,
    },
};
exports.systemValidators = {
    string: {
        validate(value, validators, resolveParam, validateDefinition, validateValue) {
            const res = value;
            const errors = [];
            if (validateValue && typeof value !== 'string') {
                errors.push(validationErrors.string.STRING_TYPE_VALIDATION_FAILED(value));
            }
            if (validators.length > 0) {
                validators.forEach((validatorMeta) => {
                    if (typeof validatorMeta === 'object') {
                        if (this.subValidators && this.subValidators[validatorMeta.name]) {
                            const subValidator = this.subValidators[validatorMeta.name];
                            const validationRes = subValidator(value, resolveParam(validatorMeta.args[0]));
                            if (validateValue && validationRes.errors) {
                                errors.push(...validationRes.errors);
                            }
                        }
                        else if (validateDefinition) {
                            errors.push(validationErrors.string.UKNOWN_VALIDATOR(validatorMeta.name));
                        }
                    }
                });
            }
            return { res, errors: errors.length ? errors : null };
        },
        subValidators: {
            regex: (value, regex) => {
                const r = new RegExp(regex);
                const valid = r.test(value);
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [validationErrors.string.REGEX_VALIDATION_FAILED(regex, value)],
                };
            },
            contains: (value, checkedValue) => {
                const valid = !!~value.indexOf(checkedValue);
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [validationErrors.string.CONTAINS_VALIDATION_FAILED(checkedValue, value)],
                };
            },
            minLength: (value, length) => {
                const valid = value.length > Number(length);
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [validationErrors.string.MIN_LENGTH_VALIDATION_FAILED(length, value)],
                };
            },
            maxLength: (value, length) => {
                const valid = value.length < Number(length);
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [validationErrors.string.MAX_LENGTH_VALIDATION_FAILED(length, value)],
                };
            },
        },
    },
    number: {
        validate(value, validators, resolveParam, validateDefinition, validateValue) {
            const res = value;
            const errors = [];
            if (isNaN(value)) {
                if (validateValue) {
                    errors.push(validationErrors.number.NUMBER_TYPE_VALIDATION_FAILED(value));
                }
            }
            else if (validators.length > 0) {
                validators.forEach((validatorMeta) => {
                    if (typeof validatorMeta === 'object') {
                        if (this.subValidators && this.subValidators[validatorMeta.name]) {
                            const subValidator = this.subValidators[validatorMeta.name];
                            const validationRes = subValidator(value, resolveParam(validatorMeta.args[0]));
                            if (validateValue && validationRes.errors) {
                                errors.push(...validationRes.errors);
                            }
                        }
                        else if (validateDefinition) {
                            errors.push(validationErrors.number.UKNOWN_VALIDATOR(validatorMeta.name));
                        }
                    }
                });
            }
            return { res, errors: errors.length ? errors : null };
        },
        subValidators: {
            min: (value, minValue) => {
                const valid = Number(value) > Number(minValue);
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [validationErrors.number.MIN_VALIDATION_FAILED(value, minValue)],
                };
            },
            max: (value, maxValue) => {
                const valid = Number(value) < Number(maxValue);
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [validationErrors.number.MAX_VALIDATION_FAILED(value, maxValue)],
                };
            },
            multipleOf: (value, multipleOf) => {
                const valid = Number(value) % Number(multipleOf) === 0;
                return {
                    res: value,
                    errors: valid
                        ? null
                        : [
                            validationErrors.number.MULTIPLE_OF_VALIDATION_FAILED(value, multipleOf),
                        ],
                };
            },
        },
    },
    enum: {
        validate(value, options, resolveParam, validateDefinition, validateValue) {
            const res = value;
            const errors = [];
            const stringOptions = [];
            if (options.length) {
                const isOneOf = options.some((option) => {
                    if (typeof option === 'string') {
                        stringOptions.push(option);
                        return resolveParam(option) === value;
                    }
                    return true;
                });
                if (validateValue && !isOneOf) {
                    errors.push(validationErrors.enum.ENUM_TYPE_VALIDATION_FAILED(value, stringOptions));
                }
            }
            else if (validateDefinition) {
                errors.push(validationErrors.enum.NO_OPTIONS_DEFINED());
            }
            return { res, errors: errors.length ? errors : null };
        },
    },
    tag: {
        validate(value, _options, _resolveParam, _validateDefinition, validateValue) {
            const errors = [];
            if (validateValue && ~value.indexOf(' ')) {
                errors.push(validationErrors.tag.NO_SPACES_ALLOWED(value));
            }
            return { res: value, errors: errors.length ? errors : null };
        },
    },
};
//# sourceMappingURL=state-validators.js.map