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

package/dist/esm/validators/isHash.js

@@ -0,0 +1,31 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { configText, optionsOf } from '../helpers/config.js';
+const lengths = {
+    md5: 32,
+    md4: 32,
+    sha1: 40,
+    sha256: 64,
+    sha384: 96,
+    sha512: 128,
+    ripemd128: 32,
+    ripemd160: 40,
+    tiger128: 32,
+    tiger160: 40,
+    tiger192: 48,
+    crc32: 8,
+    crc32b: 8,
+};
+const hashRegex = Object.fromEntries(Object.entries(lengths).map(([name, len]) => [name, new RegExp(`^[a-fA-F0-9]{${len}}$`)]));
+export function isHash(value, options) {
+    const { algorithm } = optionsOf(options);
+    if (!hasOwn(hashRegex, algorithm)) {
+        throw new ValidationConfigError(`Invalid hash algorithm '${configText(algorithm)}'`);
+    }
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    return hashRegex[algorithm].test(s);
+}

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

@@ -0,0 +1,4 @@
+export interface IsHexColorOptions {
+    require_hashtag?: boolean;
+}
+export declare function isHexColor(value: unknown, options?: IsHexColorOptions): boolean;

package/dist/esm/validators/isHexColor.js

@@ -0,0 +1,17 @@
+import { toString } from '../convert/string.js';
+import { merge } from '../helpers/merge.js';
+const hexcolor = /^#?([0-9A-F]{3}|[0-9A-F]{4}|[0-9A-F]{6}|[0-9A-F]{8})$/i;
+const hexcolor_with_prefix = /^#([0-9A-F]{3}|[0-9A-F]{4}|[0-9A-F]{6}|[0-9A-F]{8})$/i;
+const default_is_hexcolor_options = {
+    require_hashtag: false,
+};
+export function isHexColor(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    options = merge(options, default_is_hexcolor_options);
+    const hexcolor_regex = options.require_hashtag ? hexcolor_with_prefix : hexcolor;
+    return hexcolor_regex.test(str);
+}

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

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

package/dist/esm/validators/isHexadecimal.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const hexadecimal = /^(0x|0h)?[0-9A-F]+$/i;
+export function isHexadecimal(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return hexadecimal.test(str);
+}

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

@@ -0,0 +1,6 @@
+export interface IsIBANOptions {
+    whitelist?: string[];
+    blacklist?: string[];
+}
+export declare function isIBAN(value: unknown, options?: IsIBANOptions): boolean;
+export declare const locales: readonly string[];

package/dist/esm/validators/isIBAN.js

@@ -0,0 +1,141 @@
+import { hasOwn } from '../helpers/hasOwn.js';
+import { toString } from '../convert/string.js';
+import { configText, optionsOf } from '../helpers/config.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+const ibanRegexThroughCountryCode = {
+    AD: /^(AD[0-9]{2})\d{8}[A-Z0-9]{12}$/,
+    AE: /^(AE[0-9]{2})\d{3}\d{16}$/,
+    AL: /^(AL[0-9]{2})\d{8}[A-Z0-9]{16}$/,
+    AT: /^(AT[0-9]{2})\d{16}$/,
+    AZ: /^(AZ[0-9]{2})[A-Z0-9]{4}\d{20}$/,
+    BA: /^(BA[0-9]{2})\d{16}$/,
+    BE: /^(BE[0-9]{2})\d{12}$/,
+    BG: /^(BG[0-9]{2})[A-Z]{4}\d{6}[A-Z0-9]{8}$/,
+    BH: /^(BH[0-9]{2})[A-Z]{4}[A-Z0-9]{14}$/,
+    BR: /^(BR[0-9]{2})\d{23}[A-Z]{1}[A-Z0-9]{1}$/,
+    BY: /^(BY[0-9]{2})[A-Z0-9]{4}\d{20}$/,
+    CH: /^(CH[0-9]{2})\d{5}[A-Z0-9]{12}$/,
+    CR: /^(CR[0-9]{2})\d{18}$/,
+    CY: /^(CY[0-9]{2})\d{8}[A-Z0-9]{16}$/,
+    CZ: /^(CZ[0-9]{2})\d{20}$/,
+    DE: /^(DE[0-9]{2})\d{18}$/,
+    DK: /^(DK[0-9]{2})\d{14}$/,
+    DO: /^(DO[0-9]{2})[A-Z]{4}\d{20}$/,
+    DZ: /^(DZ\d{24})$/,
+    EE: /^(EE[0-9]{2})\d{16}$/,
+    EG: /^(EG[0-9]{2})\d{25}$/,
+    ES: /^(ES[0-9]{2})\d{20}$/,
+    FI: /^(FI[0-9]{2})\d{14}$/,
+    FO: /^(FO[0-9]{2})\d{14}$/,
+    FR: /^(FR[0-9]{2})\d{10}[A-Z0-9]{11}\d{2}$/,
+    GB: /^(GB[0-9]{2})[A-Z]{4}\d{14}$/,
+    GE: /^(GE[0-9]{2})[A-Z0-9]{2}\d{16}$/,
+    GI: /^(GI[0-9]{2})[A-Z]{4}[A-Z0-9]{15}$/,
+    GL: /^(GL[0-9]{2})\d{14}$/,
+    GR: /^(GR[0-9]{2})\d{7}[A-Z0-9]{16}$/,
+    GT: /^(GT[0-9]{2})[A-Z0-9]{4}[A-Z0-9]{20}$/,
+    HR: /^(HR[0-9]{2})\d{17}$/,
+    HU: /^(HU[0-9]{2})\d{24}$/,
+    IE: /^(IE[0-9]{2})[A-Z]{4}\d{14}$/,
+    IL: /^(IL[0-9]{2})\d{19}$/,
+    IQ: /^(IQ[0-9]{2})[A-Z]{4}\d{15}$/,
+    IR: /^(IR[0-9]{2})\d{22}$/,
+    IS: /^(IS[0-9]{2})\d{22}$/,
+    IT: /^(IT[0-9]{2})[A-Z]{1}\d{10}[A-Z0-9]{12}$/,
+    JO: /^(JO[0-9]{2})[A-Z]{4}\d{22}$/,
+    KW: /^(KW[0-9]{2})[A-Z]{4}[A-Z0-9]{22}$/,
+    KZ: /^(KZ[0-9]{2})\d{3}[A-Z0-9]{13}$/,
+    LB: /^(LB[0-9]{2})\d{4}[A-Z0-9]{20}$/,
+    LC: /^(LC[0-9]{2})[A-Z]{4}[A-Z0-9]{24}$/,
+    LI: /^(LI[0-9]{2})\d{5}[A-Z0-9]{12}$/,
+    LT: /^(LT[0-9]{2})\d{16}$/,
+    LU: /^(LU[0-9]{2})\d{3}[A-Z0-9]{13}$/,
+    LV: /^(LV[0-9]{2})[A-Z]{4}[A-Z0-9]{13}$/,
+    MA: /^(MA[0-9]{26})$/,
+    MC: /^(MC[0-9]{2})\d{10}[A-Z0-9]{11}\d{2}$/,
+    MD: /^(MD[0-9]{2})[A-Z0-9]{20}$/,
+    ME: /^(ME[0-9]{2})\d{18}$/,
+    MK: /^(MK[0-9]{2})\d{3}[A-Z0-9]{10}\d{2}$/,
+    MR: /^(MR[0-9]{2})\d{23}$/,
+    MT: /^(MT[0-9]{2})[A-Z]{4}\d{5}[A-Z0-9]{18}$/,
+    MU: /^(MU[0-9]{2})[A-Z]{4}\d{19}[A-Z]{3}$/,
+    MZ: /^(MZ[0-9]{2})\d{21}$/,
+    NL: /^(NL[0-9]{2})[A-Z]{4}\d{10}$/,
+    NO: /^(NO[0-9]{2})\d{11}$/,
+    PK: /^(PK[0-9]{2})[A-Z0-9]{4}\d{16}$/,
+    PL: /^(PL[0-9]{2})\d{24}$/,
+    PS: /^(PS[0-9]{2})[A-Z]{4}[A-Z0-9]{21}$/,
+    PT: /^(PT[0-9]{2})\d{21}$/,
+    QA: /^(QA[0-9]{2})[A-Z]{4}[A-Z0-9]{21}$/,
+    RO: /^(RO[0-9]{2})[A-Z]{4}[A-Z0-9]{16}$/,
+    RS: /^(RS[0-9]{2})\d{18}$/,
+    SA: /^(SA[0-9]{2})\d{2}[A-Z0-9]{18}$/,
+    SC: /^(SC[0-9]{2})[A-Z]{4}\d{20}[A-Z]{3}$/,
+    SE: /^(SE[0-9]{2})\d{20}$/,
+    SI: /^(SI[0-9]{2})\d{15}$/,
+    SK: /^(SK[0-9]{2})\d{20}$/,
+    SM: /^(SM[0-9]{2})[A-Z]{1}\d{10}[A-Z0-9]{12}$/,
+    SV: /^(SV[0-9]{2})[A-Z0-9]{4}\d{20}$/,
+    TL: /^(TL[0-9]{2})\d{19}$/,
+    TN: /^(TN[0-9]{2})\d{20}$/,
+    TR: /^(TR[0-9]{2})\d{5}[A-Z0-9]{17}$/,
+    UA: /^(UA[0-9]{2})\d{6}[A-Z0-9]{19}$/,
+    VA: /^(VA[0-9]{2})\d{18}$/,
+    VG: /^(VG[0-9]{2})[A-Z]{4}\d{16}$/,
+    XK: /^(XK[0-9]{2})\d{16}$/,
+};
+function hasOnlyValidCountryCodes(countryCodeArray) {
+    const countryCodeArrayFilteredWithObjectIbanCode = countryCodeArray.filter((countryCode) => !hasOwn(ibanRegexThroughCountryCode, countryCode));
+    return countryCodeArrayFilteredWithObjectIbanCode.length === 0;
+}
+function countryCodeList(list, name) {
+    if (list === undefined || list === null)
+        return undefined;
+    if (!Array.isArray(list) || !list.every((code) => typeof code === 'string')) {
+        throw new ValidationConfigError(`${name} must be an array of country codes, got ${configText(list)}`);
+    }
+    return list.map((code) => code.toUpperCase());
+}
+function hasValidIbanFormat(str, options) {
+    const strippedStr = str.replace(/[\s-]+/gi, '').toUpperCase();
+    const isoCountryCode = strippedStr.slice(0, 2).toUpperCase();
+    const isoCountryCodeInIbanRegexCodeObject = hasOwn(ibanRegexThroughCountryCode, isoCountryCode);
+    const whitelist = countryCodeList(options.whitelist, 'whitelist');
+    const blacklist = countryCodeList(options.blacklist, 'blacklist');
+    if (whitelist) {
+        if (!hasOnlyValidCountryCodes(whitelist)) {
+            return false;
+        }
+        const isoCountryCodeInWhiteList = whitelist.includes(isoCountryCode);
+        if (!isoCountryCodeInWhiteList) {
+            return false;
+        }
+    }
+    if (blacklist) {
+        const isoCountryCodeInBlackList = blacklist.includes(isoCountryCode);
+        if (isoCountryCodeInBlackList) {
+            return false;
+        }
+    }
+    return (isoCountryCodeInIbanRegexCodeObject &&
+        ibanRegexThroughCountryCode[isoCountryCode].test(strippedStr));
+}
+function hasValidIbanChecksum(str) {
+    const strippedStr = str.replace(/[^A-Z0-9]+/gi, '').toUpperCase();
+    const rearranged = strippedStr.slice(4) + strippedStr.slice(0, 4);
+    const alphaCapsReplacedWithDigits = rearranged.replace(/[A-Z]/g, (char) => String(char.charCodeAt(0) - 55));
+    let remainder = 0;
+    for (const chunk of alphaCapsReplacedWithDigits.match(/\d{1,7}/g)) {
+        remainder = Number(`${remainder}${chunk}`) % 97;
+    }
+    return remainder === 1;
+}
+export function isIBAN(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return hasValidIbanFormat(str, optionsOf(options)) && hasValidIbanChecksum(str);
+}
+export const locales = Object.freeze(Object.keys(ibanRegexThroughCountryCode));

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

@@ -0,0 +1,4 @@
+export interface IsIMEIOptions {
+    allow_hyphens?: boolean;
+}
+export declare function isIMEI(value: unknown, options?: IsIMEIOptions): boolean;

package/dist/esm/validators/isIMEI.js

@@ -0,0 +1,42 @@
+import { toString } from '../convert/string.js';
+const imeiRegexWithoutHyphens = /^[0-9]{15}$/;
+const imeiRegexWithHyphens = /^\d{2}-\d{6}-\d{6}-\d{1}$/;
+export function isIMEI(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let strVal = s;
+    options = options || {};
+    let imeiRegex = imeiRegexWithoutHyphens;
+    if (options.allow_hyphens) {
+        imeiRegex = imeiRegexWithHyphens;
+    }
+    if (!imeiRegex.test(strVal)) {
+        return false;
+    }
+    strVal = strVal.replace(/-/g, '');
+    let sum = 0, mul = 2;
+    const l = 14;
+    for (let i = 0; i < l; i++) {
+        const digit = strVal.substring(l - i - 1, l - i);
+        const tp = parseInt(digit, 10) * mul;
+        if (tp >= 10) {
+            sum += (tp % 10) + 1;
+        }
+        else {
+            sum += tp;
+        }
+        if (mul === 1) {
+            mul += 1;
+        }
+        else {
+            mul -= 1;
+        }
+    }
+    const chk = (10 - (sum % 10)) % 10;
+    if (chk !== parseInt(strVal.substring(14, 15), 10)) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+export type IsIPVersion = 4 | 6 | '4' | '6' | (number & {}) | (string & {});
+export interface IsIPOptions {
+    version?: IsIPVersion;
+}
+export declare function isIP(value: unknown, options?: IsIPOptions): boolean;

package/dist/esm/validators/isIP.js

@@ -0,0 +1,35 @@
+import { toString } from '../convert/string.js';
+import { optionsOf } from '../helpers/config.js';
+const IPv4SegmentFormat = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';
+const IPv4AddressFormat = `(${IPv4SegmentFormat}[.]){3}${IPv4SegmentFormat}`;
+const IPv4AddressRegExp = new RegExp(`^${IPv4AddressFormat}$`);
+const IPv6SegmentFormat = '(?:[0-9a-fA-F]{1,4})';
+const optionalIPv6ZoneIdFormat = '(%[0-9a-zA-Z.]{1,})?';
+const IPv6AddressRegExp = new RegExp('^(' +
+    `(?:${IPv6SegmentFormat}:){7}(?:${IPv6SegmentFormat}|:)|` +
+    `(?:${IPv6SegmentFormat}:){6}(?:${IPv4AddressFormat}|:${IPv6SegmentFormat}|:)|` +
+    `(?:${IPv6SegmentFormat}:){5}(?::${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,2}|:)|` +
+    `(?:${IPv6SegmentFormat}:){4}(?:(:${IPv6SegmentFormat}){0,1}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,3}|:)|` +
+    `(?:${IPv6SegmentFormat}:){3}(?:(:${IPv6SegmentFormat}){0,2}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,4}|:)|` +
+    `(?:${IPv6SegmentFormat}:){2}(?:(:${IPv6SegmentFormat}){0,3}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,5}|:)|` +
+    `(?:${IPv6SegmentFormat}:){1}(?:(:${IPv6SegmentFormat}){0,4}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,6}|:)|` +
+    `(?::((?::${IPv6SegmentFormat}){0,5}:${IPv4AddressFormat}|(?::${IPv6SegmentFormat}){1,7}|:))` +
+    `)${optionalIPv6ZoneIdFormat}$`);
+export function isIP(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const ip = s;
+    const version = optionsOf(options).version || '';
+    if (!version) {
+        return IPv4AddressRegExp.test(ip) || IPv6AddressRegExp.test(ip);
+    }
+    if (version.toString() === '4') {
+        return IPv4AddressRegExp.test(ip);
+    }
+    if (version.toString() === '6') {
+        return IPv6AddressRegExp.test(ip);
+    }
+    return false;
+}

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

@@ -0,0 +1,5 @@
+import type { IsIPVersion } from './isIP.js';
+export interface IsIPRangeOptions {
+    version?: IsIPVersion;
+}
+export declare function isIPRange(value: unknown, options?: IsIPRangeOptions): boolean;

package/dist/esm/validators/isIPRange.js

@@ -0,0 +1,40 @@
+import { toString } from '../convert/string.js';
+import { optionsOf } from '../helpers/config.js';
+import { isIP } from './isIP.js';
+const subnetMaybe = /^\d{1,3}$/;
+const v4Subnet = 32;
+const v6Subnet = 128;
+export function isIPRange(value, options) {
+    const { version = '' } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const parts = str.split('/');
+    if (parts.length !== 2) {
+        return false;
+    }
+    if (!subnetMaybe.test(parts[1])) {
+        return false;
+    }
+    if (parts[1].length > 1 && parts[1].startsWith('0')) {
+        return false;
+    }
+    const isValidIP = isIP(parts[0], { version });
+    if (!isValidIP) {
+        return false;
+    }
+    let expectedSubnet = null;
+    switch (String(version)) {
+        case '4':
+            expectedSubnet = v4Subnet;
+            break;
+        case '6':
+            expectedSubnet = v6Subnet;
+            break;
+        default:
+            expectedSubnet = isIP(parts[0], { version: '6' }) ? v6Subnet : v4Subnet;
+    }
+    return Number(parts[1]) <= expectedSubnet;
+}

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

@@ -0,0 +1,5 @@
+export type IsISBNVersion = '10' | '13' | 10 | 13;
+export interface IsISBNOptions {
+    version?: IsISBNVersion;
+}
+export declare function isISBN(value: unknown, options?: IsISBNOptions): boolean;

package/dist/esm/validators/isISBN.js

@@ -0,0 +1,48 @@
+import { toString } from '../convert/string.js';
+import { optionsOf } from '../helpers/config.js';
+const possibleIsbn10 = /^(?:[0-9]{9}X|[0-9]{10})$/;
+const possibleIsbn13 = /^(?:[0-9]{13})$/;
+const factor = [1, 3];
+export function isISBN(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const isbn = s;
+    const rawVersion = optionsOf(options).version;
+    const version = String(rawVersion);
+    if (!rawVersion) {
+        return isISBN(isbn, { version: 10 }) || isISBN(isbn, { version: 13 });
+    }
+    const sanitizedIsbn = isbn.replace(/[\s-]+/g, '');
+    let checksum = 0;
+    if (version === '10') {
+        if (!possibleIsbn10.test(sanitizedIsbn)) {
+            return false;
+        }
+        for (let i = 0; i < Number(version) - 1; i++) {
+            checksum += (i + 1) * Number(sanitizedIsbn.charAt(i));
+        }
+        if (sanitizedIsbn.charAt(9) === 'X') {
+            checksum += 10 * 10;
+        }
+        else {
+            checksum += 10 * Number(sanitizedIsbn.charAt(9));
+        }
+        if (checksum % 11 === 0) {
+            return true;
+        }
+    }
+    else if (version === '13') {
+        if (!possibleIsbn13.test(sanitizedIsbn)) {
+            return false;
+        }
+        for (let i = 0; i < 12; i++) {
+            checksum += factor[i % 2] * Number(sanitizedIsbn.charAt(i));
+        }
+        if (Number(sanitizedIsbn.charAt(12)) - ((10 - (checksum % 10)) % 10) === 0) {
+            return true;
+        }
+    }
+    return false;
+}

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

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

package/dist/esm/validators/isISIN.js

@@ -0,0 +1,52 @@
+import { toString } from '../convert/string.js';
+const isin = /^[A-Z]{2}[0-9A-Z]{9}[0-9]$/;
+export function isISIN(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (!isin.test(str)) {
+        return false;
+    }
+    let double = true;
+    let sum = 0;
+    for (let i = str.length - 2; i >= 0; i--) {
+        if (str[i] >= 'A' && str[i] <= 'Z') {
+            const code = str[i].charCodeAt(0) - 55;
+            const lo = code % 10;
+            const hi = Math.trunc(code / 10);
+            for (const digit of [lo, hi]) {
+                if (double) {
+                    if (digit >= 5) {
+                        sum += 1 + (digit - 5) * 2;
+                    }
+                    else {
+                        sum += digit * 2;
+                    }
+                }
+                else {
+                    sum += digit;
+                }
+                double = !double;
+            }
+        }
+        else {
+            const digit = str[i].charCodeAt(0) - '0'.charCodeAt(0);
+            if (double) {
+                if (digit >= 5) {
+                    sum += 1 + (digit - 5) * 2;
+                }
+                else {
+                    sum += digit * 2;
+                }
+            }
+            else {
+                sum += digit;
+            }
+            double = !double;
+        }
+    }
+    const check = Math.trunc((sum + 9) / 10) * 10 - sum;
+    return +str[str.length - 1] === check;
+}

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

@@ -0,0 +1,2 @@
+export declare function isISO15924(value: unknown): boolean;
+export declare const ScriptCodes: Set<string>;