@stylable/core
Version:
CSS for Components
186 lines • 8.53 kB
JavaScript
;
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