@archi-code/validation 0.0.0-stage → 3.0.0-alpha.2

package/dist/esm/validators/index.js

@@ -0,0 +1,190 @@
+import { equals } from './equals.js';
+import { contains } from './contains.js';
+import { matches } from './matches.js';
+import { isEmail } from './isEmail.js';
+import { isURL } from './isURL.js';
+import { isMACAddress } from './isMACAddress.js';
+import { isIP } from './isIP.js';
+import { isIPRange } from './isIPRange.js';
+import { isFQDN } from './isFQDN.js';
+import { isDate } from './isDate.js';
+import { isTime } from './isTime.js';
+import { isBoolean } from './isBoolean.js';
+import { isLocale } from './isLocale.js';
+import { isAbaRouting } from './isAbaRouting.js';
+import { isAlpha, locales as isAlphaLocales } from './isAlpha.js';
+import { isAlphanumeric, locales as isAlphanumericLocales } from './isAlphanumeric.js';
+import { isNumeric } from './isNumeric.js';
+import { isPassportNumber, locales as passportNumberLocales } from './isPassportNumber.js';
+import { isPort } from './isPort.js';
+import { isLowercase } from './isLowercase.js';
+import { isUppercase } from './isUppercase.js';
+import { isIMEI } from './isIMEI.js';
+import { isAscii } from './isAscii.js';
+import { isFullWidth } from './isFullWidth.js';
+import { isHalfWidth } from './isHalfWidth.js';
+import { isVariableWidth } from './isVariableWidth.js';
+import { isMultibyte } from './isMultibyte.js';
+import { isSemVer } from './isSemVer.js';
+import { isSurrogatePair } from './isSurrogatePair.js';
+import { isInt } from './isInt.js';
+import { isFloat, locales as isFloatLocales } from './isFloat.js';
+import { isDecimal } from './isDecimal.js';
+import { isHexadecimal } from './isHexadecimal.js';
+import { isOctal } from './isOctal.js';
+import { isDivisibleBy } from './isDivisibleBy.js';
+import { isHexColor } from './isHexColor.js';
+import { isRgbColor } from './isRgbColor.js';
+import { isHSL } from './isHSL.js';
+import { isISRC } from './isISRC.js';
+import { isIBAN, locales as ibanLocales } from './isIBAN.js';
+import { isBIC } from './isBIC.js';
+import { isMD5 } from './isMD5.js';
+import { isHash } from './isHash.js';
+import { isJWT } from './isJWT.js';
+import { isJSON } from './isJSON.js';
+import { isEmpty } from './isEmpty.js';
+import { isNotEmpty } from './isNotEmpty.js';
+import { isRequired } from './isRequired.js';
+import { isLength } from './isLength.js';
+import { isByteLength } from './isByteLength.js';
+import { isULID } from './isULID.js';
+import { isUUID } from './isUUID.js';
+import { isMongoId } from './isMongoId.js';
+import { isAfter } from './isAfter.js';
+import { isBefore } from './isBefore.js';
+import { isIn } from './isIn.js';
+import { isLuhnNumber } from './isLuhnNumber.js';
+import { isCreditCard } from './isCreditCard.js';
+import { isIdentityCard } from './isIdentityCard.js';
+import { isEAN } from './isEAN.js';
+import { isISIN } from './isISIN.js';
+import { isISBN } from './isISBN.js';
+import { isISSN } from './isISSN.js';
+import { isMobilePhone, locales as isMobilePhoneLocales } from './isMobilePhone.js';
+import { isEthereumAddress } from './isEthereumAddress.js';
+import { isCurrency } from './isCurrency.js';
+import { isBtcAddress } from './isBtcAddress.js';
+import { isISO6346, isFreightContainerID } from './isISO6346.js';
+import { isISO6391 } from './isISO6391.js';
+import { isISO8601 } from './isISO8601.js';
+import { isRFC3339 } from './isRFC3339.js';
+import { isISO15924 } from './isISO15924.js';
+import { isISO31661Alpha2 } from './isISO31661Alpha2.js';
+import { isISO31661Alpha3 } from './isISO31661Alpha3.js';
+import { isISO31661Numeric } from './isISO31661Numeric.js';
+import { isISO4217 } from './isISO4217.js';
+import { isBase32 } from './isBase32.js';
+import { isBase58 } from './isBase58.js';
+import { isBase64 } from './isBase64.js';
+import { isDataURI } from './isDataURI.js';
+import { isMagnetURI } from './isMagnetURI.js';
+import { isMailtoURI } from './isMailtoURI.js';
+import { isMimeType } from './isMimeType.js';
+import { isLatLong } from './isLatLong.js';
+import { isPostalCode, locales as isPostalCodeLocales } from './isPostalCode.js';
+import { isWhitelisted } from './isWhitelisted.js';
+import { isSlug } from './isSlug.js';
+import { isLicensePlate } from './isLicensePlate.js';
+import { isStrongPassword } from './isStrongPassword.js';
+import { isVAT } from './isVAT.js';
+export const validator = Object.freeze({
+    equals,
+    contains,
+    matches,
+    isEmail,
+    isURL,
+    isMACAddress,
+    isIP,
+    isIPRange,
+    isFQDN,
+    isBoolean,
+    isIBAN,
+    isBIC,
+    isAbaRouting,
+    isAlpha,
+    isAlphaLocales,
+    isAlphanumeric,
+    isAlphanumericLocales,
+    isNumeric,
+    isPassportNumber,
+    passportNumberLocales,
+    isPort,
+    isLowercase,
+    isUppercase,
+    isAscii,
+    isFullWidth,
+    isHalfWidth,
+    isVariableWidth,
+    isMultibyte,
+    isSemVer,
+    isSurrogatePair,
+    isInt,
+    isIMEI,
+    isFloat,
+    isFloatLocales,
+    isDecimal,
+    isHexadecimal,
+    isOctal,
+    isDivisibleBy,
+    isHexColor,
+    isRgbColor,
+    isHSL,
+    isISRC,
+    isMD5,
+    isHash,
+    isJWT,
+    isJSON,
+    isEmpty,
+    isNotEmpty,
+    isRequired,
+    isLength,
+    isLocale,
+    isByteLength,
+    isULID,
+    isUUID,
+    isMongoId,
+    isAfter,
+    isBefore,
+    isIn,
+    isLuhnNumber,
+    isCreditCard,
+    isIdentityCard,
+    isEAN,
+    isISIN,
+    isISBN,
+    isISSN,
+    isMobilePhone,
+    isMobilePhoneLocales,
+    isPostalCode,
+    isPostalCodeLocales,
+    isEthereumAddress,
+    isCurrency,
+    isBtcAddress,
+    isISO6346,
+    isFreightContainerID,
+    isISO6391,
+    isISO8601,
+    isISO15924,
+    isRFC3339,
+    isISO31661Alpha2,
+    isISO31661Alpha3,
+    isISO31661Numeric,
+    isISO4217,
+    isBase32,
+    isBase58,
+    isBase64,
+    isDataURI,
+    isMagnetURI,
+    isMailtoURI,
+    isMimeType,
+    isLatLong,
+    isWhitelisted,
+    isSlug,
+    isStrongPassword,
+    isDate,
+    isTime,
+    isLicensePlate,
+    isVAT,
+    ibanLocales,
+});

package/dist/esm/validators/isAbaRouting.d.ts

@@ -0,0 +1 @@
+export declare function isAbaRouting(value: unknown): boolean;

package/dist/esm/validators/isAbaRouting.js

@@ -0,0 +1,21 @@
+import { toString } from '../convert/string.js';
+const nineDigitsOutsideReservedSeries = /^(?!(1[3-9])|(20)|(3[3-9])|(4[0-9])|(5[0-9])|(60)|(7[3-9])|(8[1-9])|(9[0-2])|(9[3-9]))[0-9]{9}$/;
+export function isAbaRouting(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (!nineDigitsOutsideReservedSeries.test(str))
+        return false;
+    let checkSumVal = 0;
+    for (let i = 0; i < str.length; i++) {
+        if (i % 3 === 0)
+            checkSumVal += Number(str[i]) * 3;
+        else if (i % 3 === 1)
+            checkSumVal += Number(str[i]) * 7;
+        else
+            checkSumVal += Number(str[i]);
+    }
+    return checkSumVal % 10 === 0;
+}

package/dist/esm/validators/isAfter.d.ts

@@ -0,0 +1,4 @@
+export interface IsAfterOptions {
+    comparisonDate?: string;
+}
+export declare function isAfter(value: unknown, options?: IsAfterOptions): boolean;

package/dist/esm/validators/isAfter.js

@@ -0,0 +1,12 @@
+import { toDate } from '../convert/date.js';
+import { optionsOf } from '../helpers/config.js';
+export function isAfter(value, options) {
+    const { comparisonDate } = optionsOf(options);
+    const comparison = comparisonDate
+        ? toDate(comparisonDate, { lax: true })
+        : { ok: true, value: new Date() };
+    const original = toDate(value, { lax: true });
+    if (!comparison.ok || !original.ok)
+        return false;
+    return original.value > comparison.value;
+}

package/dist/esm/validators/isAlpha.d.ts

@@ -0,0 +1,8 @@
+import { alpha } from './alpha.js';
+export type AlphaLocale = keyof typeof alpha | (string & {});
+export interface IsAlphaOptions {
+    locale?: AlphaLocale;
+    ignore?: string | RegExp;
+}
+export declare function isAlpha(value: unknown, options?: IsAlphaOptions): boolean;
+export declare const locales: readonly string[];

package/dist/esm/validators/isAlpha.js

@@ -0,0 +1,31 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { escapeRegExp } from '../helpers/escapeRegExp.js';
+import { alpha } from './alpha.js';
+import { configText, optionsOf } from '../helpers/config.js';
+export function isAlpha(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let str = s;
+    const { locale = 'en-US', ignore } = optionsOf(options);
+    if (ignore) {
+        if (ignore instanceof RegExp) {
+            ignore.lastIndex = 0;
+            str = str.replace(ignore, '');
+        }
+        else if (typeof ignore === 'string') {
+            str = str.replace(new RegExp(`[${escapeRegExp(ignore)}]`, 'g'), '');
+        }
+        else {
+            throw new ValidationConfigError('ignore should be instance of a String or RegExp');
+        }
+    }
+    if (hasOwn(alpha, locale)) {
+        return alpha[locale].test(str);
+    }
+    throw new ValidationConfigError(`Invalid locale '${configText(locale)}'`);
+}
+export const locales = Object.freeze(Object.keys(alpha));

package/dist/esm/validators/isAlphanumeric.d.ts

@@ -0,0 +1,8 @@
+import { alphanumeric } from './alpha.js';
+export type AlphanumericLocale = keyof typeof alphanumeric | (string & {});
+export interface IsAlphanumericOptions {
+    locale?: AlphanumericLocale;
+    ignore?: string | RegExp;
+}
+export declare function isAlphanumeric(value: unknown, options?: IsAlphanumericOptions): boolean;
+export declare const locales: readonly string[];

package/dist/esm/validators/isAlphanumeric.js

@@ -0,0 +1,31 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { escapeRegExp } from '../helpers/escapeRegExp.js';
+import { alphanumeric } from './alpha.js';
+import { configText, optionsOf } from '../helpers/config.js';
+export function isAlphanumeric(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let str = s;
+    const { locale = 'en-US', ignore } = optionsOf(options);
+    if (ignore) {
+        if (ignore instanceof RegExp) {
+            ignore.lastIndex = 0;
+            str = str.replace(ignore, '');
+        }
+        else if (typeof ignore === 'string') {
+            str = str.replace(new RegExp(`[${escapeRegExp(ignore)}]`, 'g'), '');
+        }
+        else {
+            throw new ValidationConfigError('ignore should be instance of a String or RegExp');
+        }
+    }
+    if (hasOwn(alphanumeric, locale)) {
+        return alphanumeric[locale].test(str);
+    }
+    throw new ValidationConfigError(`Invalid locale '${configText(locale)}'`);
+}
+export const locales = Object.freeze(Object.keys(alphanumeric));

package/dist/esm/validators/isAscii.d.ts

@@ -0,0 +1 @@
+export declare function isAscii(value: unknown): boolean;

package/dist/esm/validators/isAscii.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const ascii = /^[\x00-\x7F]+$/;
+export function isAscii(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return ascii.test(str);
+}

package/dist/esm/validators/isBIC.d.ts

@@ -0,0 +1 @@
+export declare function isBIC(value: unknown): boolean;

package/dist/esm/validators/isBIC.js

@@ -0,0 +1,15 @@
+import { toString } from '../convert/string.js';
+import { CountryCodes } from './isISO31661Alpha2.js';
+const isBICReg = /^[A-Za-z]{6}[A-Za-z0-9]{2}([A-Za-z0-9]{3})?$/;
+export function isBIC(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const countryCode = str.slice(4, 6).toUpperCase();
+    if (!CountryCodes.has(countryCode) && countryCode !== 'XK') {
+        return false;
+    }
+    return isBICReg.test(str);
+}

package/dist/esm/validators/isBase32.d.ts

@@ -0,0 +1,4 @@
+export interface IsBase32Options {
+    crockford?: boolean;
+}
+export declare function isBase32(value: unknown, options?: IsBase32Options): boolean;

package/dist/esm/validators/isBase32.js

@@ -0,0 +1,18 @@
+import { toString } from '../convert/string.js';
+import { merge } from '../helpers/merge.js';
+const base32 = /^[A-Z2-7]+=*$/;
+const crockfordBase32 = /^[A-HJKMNP-TV-Z0-9]+$/;
+const defaultBase32Options = {
+    crockford: false,
+};
+export function isBase32(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    options = merge(options, defaultBase32Options);
+    if (options.crockford) {
+        return crockfordBase32.test(s);
+    }
+    return s.length % 8 === 0 && base32.test(s);
+}

package/dist/esm/validators/isBase58.d.ts

@@ -0,0 +1 @@
+export declare function isBase58(value: unknown): boolean;

package/dist/esm/validators/isBase58.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const base58Reg = /^[A-HJ-NP-Za-km-z1-9]*$/;
+export function isBase58(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return base58Reg.test(str);
+}

package/dist/esm/validators/isBase64.d.ts

@@ -0,0 +1,5 @@
+export interface IsBase64Options {
+    urlSafe?: boolean;
+    padding?: boolean;
+}
+export declare function isBase64(value: unknown, options?: IsBase64Options): boolean;

package/dist/esm/validators/isBase64.js

@@ -0,0 +1,25 @@
+import { toString } from '../convert/string.js';
+import { merge } from '../helpers/merge.js';
+const base64WithPadding = /^[A-Za-z0-9+/]+={0,2}$/;
+const base64WithoutPadding = /^[A-Za-z0-9+/]+$/;
+const base64UrlWithPadding = /^[A-Za-z0-9_-]+={0,2}$/;
+const base64UrlWithoutPadding = /^[A-Za-z0-9_-]+$/;
+export function isBase64(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    options = merge(options, { urlSafe: false, padding: !options?.urlSafe });
+    if (s === '')
+        return true;
+    if (options.padding && s.length % 4 !== 0)
+        return false;
+    let regex;
+    if (options.urlSafe) {
+        regex = options.padding ? base64UrlWithPadding : base64UrlWithoutPadding;
+    }
+    else {
+        regex = options.padding ? base64WithPadding : base64WithoutPadding;
+    }
+    return (!options.padding || s.length % 4 === 0) && regex.test(s);
+}

package/dist/esm/validators/isBefore.d.ts

@@ -0,0 +1,4 @@
+export interface IsBeforeOptions {
+    comparisonDate?: string;
+}
+export declare function isBefore(value: unknown, options?: IsBeforeOptions): boolean;

package/dist/esm/validators/isBefore.js

@@ -0,0 +1,12 @@
+import { toDate } from '../convert/date.js';
+import { optionsOf } from '../helpers/config.js';
+export function isBefore(value, options) {
+    const { comparisonDate } = optionsOf(options);
+    const comparison = comparisonDate
+        ? toDate(comparisonDate, { lax: true })
+        : { ok: true, value: new Date() };
+    const original = toDate(value, { lax: true });
+    if (!comparison.ok || !original.ok)
+        return false;
+    return original.value < comparison.value;
+}

package/dist/esm/validators/isBoolean.d.ts

@@ -0,0 +1,4 @@
+export interface IsBooleanOptions {
+    loose?: boolean;
+}
+export declare function isBoolean(value: unknown, options?: IsBooleanOptions): boolean;

package/dist/esm/validators/isBoolean.js

@@ -0,0 +1,4 @@
+import { toBoolean } from '../convert/boolean.js';
+export function isBoolean(value, options) {
+    return toBoolean(value, { mode: options?.loose ? 'loose' : 'strict' }).ok;
+}

package/dist/esm/validators/isBtcAddress.d.ts

@@ -0,0 +1 @@
+export declare function isBtcAddress(value: unknown): boolean;

package/dist/esm/validators/isBtcAddress.js

@@ -0,0 +1,11 @@
+import { toString } from '../convert/string.js';
+const bech32 = /^(bc1|tb1|bc1p|tb1p)[ac-hj-np-z02-9]{39,58}$/;
+const base58 = /^(1|2|3|m)[A-HJ-NP-Za-km-z1-9]{25,39}$/;
+export function isBtcAddress(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return bech32.test(str) || base58.test(str);
+}

package/dist/esm/validators/isByteLength.d.ts

@@ -0,0 +1,5 @@
+export interface IsByteLengthOptions {
+    min?: number;
+    max?: number;
+}
+export declare function isByteLength(value: unknown, options?: IsByteLengthOptions): boolean;

package/dist/esm/validators/isByteLength.js

@@ -0,0 +1,33 @@
+import { toString } from '../convert/string.js';
+import { boundsOf } from '../helpers/config.js';
+export function isByteLength(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const { min, max } = boundsOf(options);
+    const len = utf8ByteLength(s);
+    return len >= min && (typeof max === 'undefined' || len <= max);
+}
+function utf8ByteLength(s) {
+    let bytes = 0;
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < s.length) {
+            const next = s.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                i++;
+            }
+            else
+                bytes += 3;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}

package/dist/esm/validators/isCreditCard.d.ts

@@ -0,0 +1,15 @@
+declare const cards: {
+    amex: RegExp;
+    dinersclub: RegExp;
+    discover: RegExp;
+    jcb: RegExp;
+    mastercard: RegExp;
+    unionpay: RegExp;
+    visa: RegExp;
+};
+export type CreditCardProvider = keyof typeof cards | (string & {});
+export interface IsCreditCardOptions {
+    provider?: CreditCardProvider;
+}
+export declare function isCreditCard(value: unknown, options?: IsCreditCardOptions): boolean;
+export {};

package/dist/esm/validators/isCreditCard.js

@@ -0,0 +1,47 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { isLuhnNumber as isLuhnValid } from './isLuhnNumber.js';
+import { configText, optionsOf } from '../helpers/config.js';
+const cards = {
+    amex: /^3[47][0-9]{13}$/,
+    dinersclub: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
+    discover: /^6(?:011|5[0-9][0-9])[0-9]{12,15}$/,
+    jcb: /^(?:2131|1800|35\d{3})\d{11}$/,
+    mastercard: /^(?:5[1-5][0-9]{2}|222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}$/,
+    unionpay: /^(6[27][0-9]{14}|^(81[0-9]{14,17}))$/,
+    visa: /^(?:4[0-9]{12})(?:[0-9]{3,6})?$/,
+};
+const allCards = (() => {
+    const tmpCardsArray = [];
+    for (const cardProvider in cards) {
+        if (Object.prototype.hasOwnProperty.call(cards, cardProvider)) {
+            tmpCardsArray.push(cards[cardProvider]);
+        }
+    }
+    return tmpCardsArray;
+})();
+export function isCreditCard(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const card = s;
+    const { provider } = optionsOf(options);
+    const sanitized = card.replace(/[- ]+/g, '');
+    if (provider !== undefined && typeof provider !== 'string') {
+        throw new ValidationConfigError('provider must be a string');
+    }
+    if (provider && hasOwn(cards, provider.toLowerCase())) {
+        if (!cards[provider.toLowerCase()].test(sanitized)) {
+            return false;
+        }
+    }
+    else if (provider) {
+        throw new ValidationConfigError(`${configText(provider)} is not a valid credit card provider.`);
+    }
+    else if (!allCards.some((cardProvider) => cardProvider.test(sanitized))) {
+        return false;
+    }
+    return isLuhnValid(card);
+}

package/dist/esm/validators/isCurrency.d.ts

@@ -0,0 +1,18 @@
+export interface IsCurrencyOptions {
+    symbol?: string;
+    require_symbol?: boolean;
+    allow_space_after_symbol?: boolean;
+    symbol_after_digits?: boolean;
+    allow_negatives?: boolean;
+    parens_for_negatives?: boolean;
+    negative_sign_before_digits?: boolean;
+    negative_sign_after_digits?: boolean;
+    allow_negative_sign_placeholder?: boolean;
+    thousands_separator?: string;
+    decimal_separator?: string;
+    allow_decimal?: boolean;
+    require_decimal?: boolean;
+    digits_after_decimal?: number[];
+    allow_space_after_digits?: boolean;
+}
+export declare function isCurrency(value: unknown, options?: IsCurrencyOptions): boolean;