im-angular-validators
Version:
This library will help you with lots of already written mostly used validators for Angular 2+ applications.
608 lines (580 loc) • 28.1 kB
JavaScript
import * as moment from 'moment';
/**
* Here are all European countries with the USA
* Countries are taken from:
* https://en.wikipedia.org/wiki/List_of_European_countries_by_area
*/
var IMCountryEnum;
(function (IMCountryEnum) {
IMCountryEnum[IMCountryEnum["Albania"] = 1] = "Albania";
IMCountryEnum[IMCountryEnum["Andorra"] = 2] = "Andorra";
IMCountryEnum[IMCountryEnum["Armenia"] = 3] = "Armenia";
IMCountryEnum[IMCountryEnum["Austria"] = 4] = "Austria";
IMCountryEnum[IMCountryEnum["Azerbaijan"] = 5] = "Azerbaijan";
IMCountryEnum[IMCountryEnum["Belarus"] = 6] = "Belarus";
IMCountryEnum[IMCountryEnum["Belgium"] = 7] = "Belgium";
IMCountryEnum[IMCountryEnum["BosniaAndHerzegovina"] = 8] = "BosniaAndHerzegovina";
IMCountryEnum[IMCountryEnum["Bulgaria"] = 9] = "Bulgaria";
IMCountryEnum[IMCountryEnum["Croatia"] = 10] = "Croatia";
IMCountryEnum[IMCountryEnum["Cyprus"] = 11] = "Cyprus";
IMCountryEnum[IMCountryEnum["CzechRepublic"] = 12] = "CzechRepublic";
IMCountryEnum[IMCountryEnum["Denmark"] = 13] = "Denmark";
IMCountryEnum[IMCountryEnum["Estonia"] = 14] = "Estonia";
IMCountryEnum[IMCountryEnum["Finland"] = 15] = "Finland";
IMCountryEnum[IMCountryEnum["France"] = 16] = "France";
IMCountryEnum[IMCountryEnum["Georgia"] = 17] = "Georgia";
IMCountryEnum[IMCountryEnum["Germany"] = 18] = "Germany";
IMCountryEnum[IMCountryEnum["Greece"] = 19] = "Greece";
IMCountryEnum[IMCountryEnum["Hungary"] = 20] = "Hungary";
IMCountryEnum[IMCountryEnum["Iceland"] = 21] = "Iceland";
IMCountryEnum[IMCountryEnum["Ireland"] = 22] = "Ireland";
IMCountryEnum[IMCountryEnum["Italy"] = 23] = "Italy";
IMCountryEnum[IMCountryEnum["Kazakhstan"] = 24] = "Kazakhstan";
IMCountryEnum[IMCountryEnum["Kosovo"] = 25] = "Kosovo";
IMCountryEnum[IMCountryEnum["Latvia"] = 26] = "Latvia";
IMCountryEnum[IMCountryEnum["Liechtenstein"] = 27] = "Liechtenstein";
IMCountryEnum[IMCountryEnum["Lithuania"] = 28] = "Lithuania";
IMCountryEnum[IMCountryEnum["Luxembourg"] = 29] = "Luxembourg";
IMCountryEnum[IMCountryEnum["Malta"] = 30] = "Malta";
IMCountryEnum[IMCountryEnum["Moldova"] = 31] = "Moldova";
IMCountryEnum[IMCountryEnum["Monaco"] = 32] = "Monaco";
IMCountryEnum[IMCountryEnum["Montenegro"] = 33] = "Montenegro";
IMCountryEnum[IMCountryEnum["Netherlands"] = 34] = "Netherlands";
IMCountryEnum[IMCountryEnum["NorthMacedonia"] = 35] = "NorthMacedonia";
IMCountryEnum[IMCountryEnum["Norway"] = 36] = "Norway";
IMCountryEnum[IMCountryEnum["Poland"] = 37] = "Poland";
IMCountryEnum[IMCountryEnum["Portugal"] = 38] = "Portugal";
IMCountryEnum[IMCountryEnum["Romania"] = 39] = "Romania";
IMCountryEnum[IMCountryEnum["Russia"] = 40] = "Russia";
IMCountryEnum[IMCountryEnum["SanMarino"] = 41] = "SanMarino";
IMCountryEnum[IMCountryEnum["Serbia"] = 42] = "Serbia";
IMCountryEnum[IMCountryEnum["Slovakia"] = 43] = "Slovakia";
IMCountryEnum[IMCountryEnum["Slovenia"] = 44] = "Slovenia";
IMCountryEnum[IMCountryEnum["Spain"] = 45] = "Spain";
IMCountryEnum[IMCountryEnum["Sweden"] = 46] = "Sweden";
IMCountryEnum[IMCountryEnum["Switzerland"] = 47] = "Switzerland";
IMCountryEnum[IMCountryEnum["Turkey"] = 48] = "Turkey";
IMCountryEnum[IMCountryEnum["Ukraine"] = 49] = "Ukraine";
IMCountryEnum[IMCountryEnum["UnitedKingdom"] = 50] = "UnitedKingdom";
IMCountryEnum[IMCountryEnum["VaticanCity"] = 51] = "VaticanCity";
IMCountryEnum[IMCountryEnum["USA"] = 52] = "USA";
})(IMCountryEnum || (IMCountryEnum = {}));
// List of European countries by area: https://en.wikipedia.org/wiki/List_of_European_countries_by_area
// List of codes by area: https://en.wikipedia.org/wiki/List_of_postal_codes
const IMCountryConfigurations = [
{
countryName: 'Albania',
country: IMCountryEnum.Albania,
iso: 'AL',
capital: 'Tirana',
phoneNumber: {
callingCode: 355,
afterCodeNumbersLength: 9,
example: 355123456789
},
postCodePattern: `^[0-9]{${4}}$`,
postCodeExample: 1000
},
{
countryName: 'Andorra',
country: IMCountryEnum.Andorra,
iso: 'AD',
capital: 'Andorra la Vella',
phoneNumber: {
callingCode: 376,
afterCodeNumbersLength: 9,
example: 376123456789
},
postCodePattern: `^(?:AD)[0-9]{${3}}$`,
postCodeExample: 'AD123'
},
{
countryName: 'Germany',
country: IMCountryEnum.Germany,
iso: 'DE',
capital: 'Berlin',
phoneNumber: {
callingCode: 49,
afterCodeNumbersLength: 9,
example: 49152901820
},
postCodePattern: `^[0-9]{${5}}$`,
postCodeExample: 45678
},
{
countryName: 'Ukraine',
country: IMCountryEnum.Ukraine,
iso: 'UA',
capital: 'Kyiv',
phoneNumber: {
callingCode: 380,
afterCodeNumbersLength: 9,
example: 380971617271
},
postCodePattern: `^[0-9]{${5}}$`,
postCodeExample: 81616
},
{
countryName: 'Russia',
country: IMCountryEnum.Russia,
iso: 'RU',
capital: 'Moskva',
phoneNumber: {
callingCode: 7,
afterCodeNumbersLength: 10,
example: 79585122113
},
postCodePattern: `^[0-9]{${6}}$`,
postCodeExample: 123345
},
{
countryName: 'France',
country: IMCountryEnum.France,
iso: 'FR',
capital: 'Paris',
phoneNumber: {
callingCode: 33,
afterCodeNumbersLength: 9,
example: 33564576787
},
postCodePattern: `^[0-9]{${5}}$`,
postCodeExample: 77300
},
{
countryName: 'United States of America',
country: IMCountryEnum.USA,
iso: 'US',
capital: 'Washington',
phoneNumber: {
callingCode: 1,
afterCodeNumbersLength: 10,
example: 17148408242
},
postCodePattern: `^[0-9]{${5}}$`,
postCodeExample: 99999
}
];
const IMEmailValidator = (scale = 3, fixed = false) => {
const scaling = fixed ? `${scale}` : `1,${scale}`;
const regexp = new RegExp(`^[a-z0-9A-Z._%+-]+@[a-z0-9A-Z-]+\.[a-zA-Z]{${scaling}}$`);
return (control) => {
if (control.value && !regexp.test(control.value)) {
return { isEmailInvalid: true };
}
};
};
const IMPhoneNumberValidator = (country) => {
const config = IMCountryConfigurations.find(item => item.country === country);
const regexp = new RegExp(`^(?:${config.phoneNumber.callingCode})[0-9]{${config.phoneNumber.afterCodeNumbersLength}}$`);
return (control) => {
if (control.value && !regexp.test(control.value)) {
return {
phoneNumberError: {
isInvalid: true,
countryName: config.countryName
}
};
}
};
};
class IMRequiredValidatorConfigModel {
}
const IMRequiredValidator = (config = new IMRequiredValidatorConfigModel()) => {
return (control) => {
if (control.value || control.value === 0 || control.value === false) {
switch (typeof control.value) {
case 'string':
return config.isTrimValueRequired ? control.value.trim() ? null : { fieldRequiredError: true } : null;
case 'number':
return control.value === 0 && !config.isZeroAllowed ? { fieldRequiredError: true } : null;
case 'boolean':
return control.value === false && config.isCheckboxShouldBeChecked ? { fieldRequiredError: true } : null;
default: return null;
}
}
else {
return { fieldRequiredError: true };
}
};
};
var IMCreditCardTypeValidatorEnum;
(function (IMCreditCardTypeValidatorEnum) {
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["Visa"] = 0] = "Visa";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["VisaElectron"] = 1] = "VisaElectron";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["AmericanExpress"] = 2] = "AmericanExpress";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["ChinaUnionPay"] = 3] = "ChinaUnionPay";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["MasterCard"] = 4] = "MasterCard";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["Maestro"] = 5] = "Maestro";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["DinersClubCarteBlanche"] = 6] = "DinersClubCarteBlanche";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["DinersClubInternational"] = 7] = "DinersClubInternational";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["DinersClubUnitedStatesAndCanada"] = 8] = "DinersClubUnitedStatesAndCanada";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["Discover"] = 9] = "Discover";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["JCB"] = 10] = "JCB";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["UATP"] = 11] = "UATP";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["Dankort"] = 12] = "Dankort";
IMCreditCardTypeValidatorEnum[IMCreditCardTypeValidatorEnum["InterPayment"] = 13] = "InterPayment";
})(IMCreditCardTypeValidatorEnum || (IMCreditCardTypeValidatorEnum = {}));
const CreditCardValidatorResolver = {
NumberLength: {
[IMCreditCardTypeValidatorEnum.Visa]: { from: 13, to: 19 },
[IMCreditCardTypeValidatorEnum.VisaElectron]: 16,
[IMCreditCardTypeValidatorEnum.AmericanExpress]: 15,
[IMCreditCardTypeValidatorEnum.ChinaUnionPay]: { from: 16, to: 19 },
[IMCreditCardTypeValidatorEnum.MasterCard]: 16,
[IMCreditCardTypeValidatorEnum.Maestro]: { from: 12, to: 19 },
[IMCreditCardTypeValidatorEnum.DinersClubCarteBlanche]: 14,
[IMCreditCardTypeValidatorEnum.DinersClubInternational]: 14,
[IMCreditCardTypeValidatorEnum.DinersClubUnitedStatesAndCanada]: 16,
[IMCreditCardTypeValidatorEnum.Discover]: 16,
[IMCreditCardTypeValidatorEnum.JCB]: 16,
[IMCreditCardTypeValidatorEnum.UATP]: 15,
[IMCreditCardTypeValidatorEnum.Dankort]: 16,
[IMCreditCardTypeValidatorEnum.InterPayment]: { from: 16, to: 19 }
},
IINRange: {
[IMCreditCardTypeValidatorEnum.Visa]: [4],
[IMCreditCardTypeValidatorEnum.VisaElectron]: [4026, 417500, 4508, 4844, 4913, 4917],
[IMCreditCardTypeValidatorEnum.AmericanExpress]: [34, 37],
[IMCreditCardTypeValidatorEnum.ChinaUnionPay]: [62],
[IMCreditCardTypeValidatorEnum.MasterCard]: [{ from: 2221, to: 2720 }, { from: 51, to: 55 }],
[IMCreditCardTypeValidatorEnum.Maestro]: [5018, 5020, 5038, 5893, 6304, 6759, 6761, 6762, 6763],
[IMCreditCardTypeValidatorEnum.DinersClubCarteBlanche]: [],
[IMCreditCardTypeValidatorEnum.DinersClubInternational]: [36],
[IMCreditCardTypeValidatorEnum.DinersClubUnitedStatesAndCanada]: [54],
[IMCreditCardTypeValidatorEnum.Discover]: [6011, { from: 622126, to: 622925 }, 644, 645, 646, 647, 648, 649, 65],
[IMCreditCardTypeValidatorEnum.JCB]: [{ from: 3528, to: 3589 }],
[IMCreditCardTypeValidatorEnum.UATP]: [1],
[IMCreditCardTypeValidatorEnum.Dankort]: [5019, 4571],
[IMCreditCardTypeValidatorEnum.InterPayment]: [636]
}
};
class IMCreditCardValidatorConfigModel {
constructor() {
this.creditCardType = IMCreditCardTypeValidatorEnum.MasterCard;
}
}
const IMCreditCardValidator = (config = new IMCreditCardValidatorConfigModel()) => {
return (control) => {
var _a;
const creditCardNumber = (_a = control.value) === null || _a === void 0 ? void 0 : _a.replace(/\s/g, '');
if (creditCardNumber === null || creditCardNumber === void 0 ? void 0 : creditCardNumber.length) {
const creditCardNumberLength = creditCardNumber.length;
const requiredCreditCardLength = CreditCardValidatorResolver.NumberLength[config.creditCardType];
const isNumberInINNRange = () => CreditCardValidatorResolver.IINRange[config.creditCardType].some((IINRange) => {
for (let i = IINRange.from; i <= IINRange.to; i++) {
if (new RegExp('^' + i, 'i').test(creditCardNumber)) {
return true;
}
}
return new RegExp('^' + IINRange, 'i').test(creditCardNumber);
});
const isNumberFitToLength = () => creditCardNumberLength < requiredCreditCardLength
|| creditCardNumberLength > requiredCreditCardLength
|| (creditCardNumberLength < requiredCreditCardLength.from
|| creditCardNumberLength > requiredCreditCardLength.to);
const isLuhnCheckPassed = () => {
const arr = (creditCardNumber + '').split('').reverse().map(x => Number(x));
const lastDigit = arr.splice(0, 1)[0];
let sum = arr.reduce((acc, val, i) => (i % 2 !== 0 ? acc + val : acc + ((val * 2) % 9) || 9), 0);
sum += lastDigit;
return sum % 10 === 0;
};
if (!isNumberInINNRange()) {
return { creditCardTypeValidationError: true };
}
else {
if (isNumberFitToLength()) {
return { creditCardNumberLengthValidatorError: true };
}
else if (!isLuhnCheckPassed()) {
return { creditCardDoesNotExist: true };
}
}
}
};
};
const isNumber = (value) => {
return typeof value === 'number';
};
var IMComparatorOperatorEnum;
(function (IMComparatorOperatorEnum) {
IMComparatorOperatorEnum[IMComparatorOperatorEnum["equal"] = 1] = "equal";
IMComparatorOperatorEnum[IMComparatorOperatorEnum["greater"] = 2] = "greater";
IMComparatorOperatorEnum[IMComparatorOperatorEnum["greaterEqual"] = 3] = "greaterEqual";
IMComparatorOperatorEnum[IMComparatorOperatorEnum["less"] = 4] = "less";
IMComparatorOperatorEnum[IMComparatorOperatorEnum["lessEqual"] = 5] = "lessEqual";
})(IMComparatorOperatorEnum || (IMComparatorOperatorEnum = {}));
const IMNumberComparatorValidator = (config) => {
return (control) => {
var _a, _b;
if (config.comparingControlKey) {
const comparingValue = (_b = (_a = control === null || control === void 0 ? void 0 : control.parent) === null || _a === void 0 ? void 0 : _a.get(config.comparingControlKey)) === null || _b === void 0 ? void 0 : _b.value;
return getNumberComparatorValidationError(control.value, comparingValue, config.comparingOperator);
}
else {
return getNumberComparatorValidationError(control.value, config.comparingValue, config.comparingOperator);
}
};
};
const getNumberComparatorValidationError = (control_value, comparing_control_value, operator) => {
if (isNumber(control_value) && isNumber(comparing_control_value) &&
operatorCheckResolver$3[operator](control_value, comparing_control_value)) {
return {
numberComparatorError: {
isInvalid: true,
operator,
comparingValue: comparing_control_value
}
};
}
};
const operatorCheckResolver$3 = {
[IMComparatorOperatorEnum.equal]: (value, comparing_value) => value !== comparing_value,
[IMComparatorOperatorEnum.greater]: (value, comparing_value) => value <= comparing_value,
[IMComparatorOperatorEnum.greaterEqual]: (value, comparing_value) => value < comparing_value,
[IMComparatorOperatorEnum.less]: (value, comparing_value) => value >= comparing_value,
[IMComparatorOperatorEnum.lessEqual]: (value, comparing_value) => value > comparing_value
};
const IMWorkingDateFormat = 'DD.MM.YYYY';
const IMDateComparatorValidator = (config) => {
return (control) => {
var _a, _b;
if (config.comparingControlKey) {
const comparingValue = (_b = (_a = control === null || control === void 0 ? void 0 : control.parent) === null || _a === void 0 ? void 0 : _a.get(config.comparingControlKey)) === null || _b === void 0 ? void 0 : _b.value;
return getDateComparatorValidationError(control.value, comparingValue, config.comparingOperator);
}
else {
return getDateComparatorValidationError(control.value, config.comparingValue, config.comparingOperator);
}
};
};
const getDateComparatorValidationError = (control_value, comparing_control_value, operator) => {
if (control_value && comparing_control_value) {
if (operatorCheckResolver$2[operator](control_value, comparing_control_value)) {
return {
dateComparatorError: {
isInvalid: true,
operator,
comparingValue: comparing_control_value.format(IMWorkingDateFormat)
}
};
}
}
};
const operatorCheckResolver$2 = {
[IMComparatorOperatorEnum.equal]: (value, comparing_value) => {
return !value.isSame(comparing_value);
},
[IMComparatorOperatorEnum.greater]: (value, comparing_value) => {
return !value.isAfter(comparing_value);
},
[IMComparatorOperatorEnum.greaterEqual]: (value, comparing_value) => {
return !value.isSame(comparing_value) && !value.isAfter(comparing_value);
},
[IMComparatorOperatorEnum.less]: (value, comparing_value) => {
return !value.isBefore(comparing_value);
},
[IMComparatorOperatorEnum.lessEqual]: (value, comparing_value) => {
return !value.isSame(comparing_value) && !value.isBefore(comparing_value);
}
};
const IMTimeComparatorValidator = (config) => {
return (control) => {
var _a, _b;
if (config.comparingControlKey) {
const comparingValue = (_b = (_a = control === null || control === void 0 ? void 0 : control.parent) === null || _a === void 0 ? void 0 : _a.get(config.comparingControlKey)) === null || _b === void 0 ? void 0 : _b.value;
return getTimeComparatorValidationError(control.value, comparingValue, config.comparingOperator);
}
else {
return getTimeComparatorValidationError(control.value, config.comparingValue, config.comparingOperator);
}
};
};
const getTimeComparatorValidationError = (control_value, comparing_control_value, operator) => {
if (control_value && comparing_control_value) {
const timeFormatControlValue = moment(control_value, 'HH:mm');
const timeFormatComparingControlValue = moment(comparing_control_value, 'HH:mm');
if (operatorCheckResolver$1[operator](timeFormatControlValue, timeFormatComparingControlValue)) {
return {
timeComparatorError: {
isInvalid: true,
operator,
comparingValue: comparing_control_value
}
};
}
}
};
const operatorCheckResolver$1 = {
[IMComparatorOperatorEnum.equal]: (value, comparing_value) => {
return !value.isSame(comparing_value);
},
[IMComparatorOperatorEnum.greater]: (value, comparing_value) => {
return !value.isAfter(comparing_value);
},
[IMComparatorOperatorEnum.greaterEqual]: (value, comparing_value) => {
return !value.isSame(comparing_value) && !value.isAfter(comparing_value);
},
[IMComparatorOperatorEnum.less]: (value, comparing_value) => {
return !value.isBefore(comparing_value);
},
[IMComparatorOperatorEnum.lessEqual]: (value, comparing_value) => {
return !value.isSame(comparing_value) && !value.isBefore(comparing_value);
}
};
const IMNumberInRangeValidator = (from, to) => {
return (control) => {
const error = { isInvalid: true, from, to };
if (isNumber(from) && isNumber(to) && isNumber(control.value)) {
if (from > control.value || to < control.value) {
return { numberInRange: error };
}
}
};
};
const IMDateInRangeValidator = (from, to) => {
return (control) => {
const error = {
isInvalid: true,
from: from === null || from === void 0 ? void 0 : from.format(IMWorkingDateFormat),
to: to === null || to === void 0 ? void 0 : to.format(IMWorkingDateFormat)
};
if (from && to && control.value) {
if (from.isAfter(control.value) || to.isBefore(control.value)) {
return { dateInRange: error };
}
}
};
};
const IMPostCodeValidator = (country) => {
const config = IMCountryConfigurations.find(item => item.country === country);
const regexp = new RegExp(config.postCodePattern);
return (control) => {
if (control.value && !regexp.test(control.value)) {
return {
postCodeError: {
isInvalid: true,
countryName: config.countryName
}
};
}
};
};
var IMPasswordOperatorEnum;
(function (IMPasswordOperatorEnum) {
IMPasswordOperatorEnum[IMPasswordOperatorEnum["minLength"] = 0] = "minLength";
IMPasswordOperatorEnum[IMPasswordOperatorEnum["minNumberQuantity"] = 1] = "minNumberQuantity";
IMPasswordOperatorEnum[IMPasswordOperatorEnum["minCapitalLettersQuantity"] = 2] = "minCapitalLettersQuantity";
IMPasswordOperatorEnum[IMPasswordOperatorEnum["minSmallLettersQuantity"] = 3] = "minSmallLettersQuantity";
IMPasswordOperatorEnum[IMPasswordOperatorEnum["minSpecialCharactersQuantity"] = 4] = "minSpecialCharactersQuantity";
})(IMPasswordOperatorEnum || (IMPasswordOperatorEnum = {}));
class IMPasswordValidatorConfigModel {
}
const IMPasswordValidator = (config = new IMPasswordValidatorConfigModel()) => {
return (control) => {
if (control.value) {
const operator = passwordValidatorErrorResolver(control.value, config);
if (!!operator) {
return {
passwordValidatorError: {
isInvalid: true,
operator: IMPasswordOperatorEnum[operator],
comparingValue: config[operator]
}
};
}
}
};
};
const passwordValidatorErrorResolver = (control_value, configs) => {
return Object.keys(configs).find(key => configs[key] && operatorCheckResolver[IMPasswordOperatorEnum[key]](control_value, configs[key]));
};
const operatorCheckResolver = {
[IMPasswordOperatorEnum.minLength]: (value, required_password_length) => value.length < required_password_length,
[IMPasswordOperatorEnum.minNumberQuantity]: (value, required_numbers_quantity) => { var _a; return (((_a = value.match(/[0-9]/g)) === null || _a === void 0 ? void 0 : _a.length) || 0) < required_numbers_quantity; },
[IMPasswordOperatorEnum.minCapitalLettersQuantity]: (value, required_cap_letters_quantity) => { var _a; return (((_a = value.match(/[A-Z]/g)) === null || _a === void 0 ? void 0 : _a.length) || 0) < required_cap_letters_quantity; },
[IMPasswordOperatorEnum.minSmallLettersQuantity]: (value, required_small_letters_quantity) => { var _a; return (((_a = value.match(/[a-z]/g)) === null || _a === void 0 ? void 0 : _a.length) || 0) < required_small_letters_quantity; },
[IMPasswordOperatorEnum.minSpecialCharactersQuantity]: (value, required_special_char_quantity) => { var _a; return (((_a = value.match(/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/g)) === null || _a === void 0 ? void 0 : _a.length) || 0) < required_special_char_quantity; }
};
const IMNumberDecimalPlacesValidator = (scale = 0, fixed = false) => {
return (control) => {
const scaling = fixed ? `${scale}` : `0,${scale}`;
const regexp = new RegExp(`^-?([0-9]*[.]?)?[0-9]{${scaling}}$`);
if (control.value && !regexp.test(control.value)) {
return {
areDecimalPlacesInvalid: {
isInvalid: true,
scale,
fixed
}
};
}
};
};
var IMUrlProtocolTypeEnum;
(function (IMUrlProtocolTypeEnum) {
IMUrlProtocolTypeEnum[IMUrlProtocolTypeEnum["Any"] = 0] = "Any";
IMUrlProtocolTypeEnum[IMUrlProtocolTypeEnum["NoProtocol"] = 1] = "NoProtocol";
IMUrlProtocolTypeEnum[IMUrlProtocolTypeEnum["Http"] = 2] = "Http";
IMUrlProtocolTypeEnum[IMUrlProtocolTypeEnum["Https"] = 3] = "Https";
IMUrlProtocolTypeEnum[IMUrlProtocolTypeEnum["Ftp"] = 4] = "Ftp";
})(IMUrlProtocolTypeEnum || (IMUrlProtocolTypeEnum = {}));
class IMUrlValidatorConfigModel {
constructor() {
this.protocolType = IMUrlProtocolTypeEnum.Any;
}
}
const IMUrlValidator = (config = new IMUrlValidatorConfigModel()) => {
return (control) => {
if (control.value && !urlCheckResolver[config.protocolType](control.value)) {
return {
urlValidationError: {
isInvalid: true,
protocolType: config.protocolType
}
};
}
};
};
const urlCheckResolver = {
[IMUrlProtocolTypeEnum.Any]: (value) => new RegExp(`^(?:(?:http(s)?:\\/\\/)|(?:ftp(s)?:\\/\\/))?[\\w.-]+(?:\\.[\\w.-]+)+[\\w\\-._~:/?#[\\]@!$&'()*+,;=]+$`).test(value),
[IMUrlProtocolTypeEnum.NoProtocol]: (value) => new RegExp(`^www.`).test(value),
[IMUrlProtocolTypeEnum.Http]: (value) => new RegExp(`^http://`).test(value),
[IMUrlProtocolTypeEnum.Https]: (value) => new RegExp(`^https://`).test(value),
[IMUrlProtocolTypeEnum.Ftp]: (value) => new RegExp(`^ftp://`).test(value)
};
const IMJSONValidator = () => {
return (control) => {
if (control.value && !isJSON(control.value)) {
return { isJSONInvalid: true };
}
};
};
const isJSON = (str) => {
try {
JSON.parse(str);
return true;
}
catch (e) {
return false;
}
};
const IMUUIdValidator = () => {
return (control) => {
if (control.value || control.value === 0) {
if (typeof control.value === 'string') {
return new RegExp(/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i)
.test(control.value) ? null : { isUUIdInvalid: true };
}
else {
return { isUUIdInvalid: true };
}
}
};
};
// General exports
/**
* Generated bundle index. Do not edit.
*/
export { CreditCardValidatorResolver, IMComparatorOperatorEnum, IMCountryConfigurations, IMCountryEnum, IMCreditCardTypeValidatorEnum, IMCreditCardValidator, IMDateComparatorValidator, IMDateInRangeValidator, IMEmailValidator, IMJSONValidator, IMNumberComparatorValidator, IMNumberDecimalPlacesValidator, IMNumberInRangeValidator, IMPasswordOperatorEnum, IMPasswordValidator, IMPasswordValidatorConfigModel, IMPhoneNumberValidator, IMPostCodeValidator, IMRequiredValidator, IMTimeComparatorValidator, IMUUIdValidator, IMUrlProtocolTypeEnum, IMUrlValidator, IMUrlValidatorConfigModel };
//# sourceMappingURL=angular-validators.mjs.map