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

package/dist/esm/validators/isIdentityCard.js

@@ -0,0 +1,439 @@
+import { toString } from '../convert/string.js';
+import { isCalendarDate } from '../convert/date.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { isInt } from './isInt.js';
+import { configText, optionsOf } from '../helpers/config.js';
+const validators = {
+    PL: (str) => {
+        const weightOfDigits = {
+            1: 1,
+            2: 3,
+            3: 7,
+            4: 9,
+            5: 1,
+            6: 3,
+            7: 7,
+            8: 9,
+            9: 1,
+            10: 3,
+            11: 0,
+        };
+        if (str != null && str.length === 11 && isInt(str, { allow_leading_zeroes: true })) {
+            const digits = str.split('').slice(0, -1);
+            const sum = digits.reduce((acc, digit, index) => acc + Number(digit) * weightOfDigits[index + 1], 0);
+            const modulo = sum % 10;
+            const lastDigit = Number(str.charAt(str.length - 1));
+            if ((modulo === 0 && lastDigit === 0) || lastDigit === 10 - modulo) {
+                return true;
+            }
+        }
+        return false;
+    },
+    ES: (str) => {
+        const DNI = /^[0-9X-Z][0-9]{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/;
+        const charsValue = {
+            X: 0,
+            Y: 1,
+            Z: 2,
+        };
+        const controlDigits = [
+            'T',
+            'R',
+            'W',
+            'A',
+            'G',
+            'M',
+            'Y',
+            'F',
+            'P',
+            'D',
+            'X',
+            'B',
+            'N',
+            'J',
+            'Z',
+            'S',
+            'Q',
+            'V',
+            'H',
+            'L',
+            'C',
+            'K',
+            'E',
+        ];
+        const sanitized = str.trim().toUpperCase();
+        if (!DNI.test(sanitized)) {
+            return false;
+        }
+        const number = sanitized.slice(0, -1).replace(/[X,Y,Z]/g, (char) => charsValue[char]);
+        return sanitized.endsWith(controlDigits[number % 23]);
+    },
+    FI: (str) => {
+        if (str.length !== 11) {
+            return false;
+        }
+        if (!str.match(/^\d{6}[-A+]\d{3}[0-9ABCDEFHJKLMNPRSTUVWXY]{1}$/)) {
+            return false;
+        }
+        const checkDigits = '0123456789ABCDEFHJKLMNPRSTUVWXY';
+        const idAsNumber = parseInt(str.slice(0, 6), 10) * 1000 + parseInt(str.slice(7, 10), 10);
+        const remainder = idAsNumber % 31;
+        const checkDigit = checkDigits[remainder];
+        return checkDigit === str.slice(10, 11);
+    },
+    IN: (str) => {
+        const DNI = /^[1-9]\d{3}\s?\d{4}\s?\d{4}$/;
+        const verhoeffMultiplication = [
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+            [1, 2, 3, 4, 0, 6, 7, 8, 9, 5],
+            [2, 3, 4, 0, 1, 7, 8, 9, 5, 6],
+            [3, 4, 0, 1, 2, 8, 9, 5, 6, 7],
+            [4, 0, 1, 2, 3, 9, 5, 6, 7, 8],
+            [5, 9, 8, 7, 6, 0, 4, 3, 2, 1],
+            [6, 5, 9, 8, 7, 1, 0, 4, 3, 2],
+            [7, 6, 5, 9, 8, 2, 1, 0, 4, 3],
+            [8, 7, 6, 5, 9, 3, 2, 1, 0, 4],
+            [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+        ];
+        const verhoeffPermutation = [
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+            [1, 5, 7, 6, 2, 8, 3, 0, 9, 4],
+            [5, 8, 0, 3, 7, 9, 6, 1, 4, 2],
+            [8, 9, 1, 6, 0, 4, 3, 5, 2, 7],
+            [9, 4, 5, 3, 1, 2, 6, 8, 7, 0],
+            [4, 2, 8, 6, 5, 7, 3, 9, 0, 1],
+            [2, 7, 9, 3, 8, 0, 6, 4, 1, 5],
+            [7, 0, 4, 6, 9, 1, 3, 2, 5, 8],
+        ];
+        const sanitized = str.trim();
+        if (!DNI.test(sanitized)) {
+            return false;
+        }
+        let checksum = 0;
+        const invertedArray = sanitized.replace(/\s/g, '').split('').map(Number).reverse();
+        invertedArray.forEach((val, i) => {
+            checksum = verhoeffMultiplication[checksum][verhoeffPermutation[i % 8][val]];
+        });
+        return checksum === 0;
+    },
+    IR: (str) => {
+        if (!str.match(/^\d{10}$/))
+            return false;
+        str = `0000${str}`.slice(str.length - 6);
+        if (parseInt(str.slice(3, 9), 10) === 0)
+            return false;
+        const lastNumber = parseInt(str.slice(9, 10), 10);
+        let sum = 0;
+        for (let i = 0; i < 9; i++) {
+            sum += parseInt(str.slice(i, i + 1), 10) * (10 - i);
+        }
+        sum %= 11;
+        return (sum < 2 && lastNumber === sum) || (sum >= 2 && lastNumber === 11 - sum);
+    },
+    IT: function IT(str) {
+        if (str.length !== 9)
+            return false;
+        if (str === 'CA00000AA')
+            return false;
+        return str.search(/C[A-Z]\d{5}[A-Z]{2}/is) > -1;
+    },
+    NO: (str) => {
+        const sanitized = str.trim();
+        if (isNaN(Number(sanitized)))
+            return false;
+        if (sanitized.length !== 11)
+            return false;
+        if (sanitized === '00000000000')
+            return false;
+        const f = sanitized.split('').map(Number);
+        const k1 = (11 -
+            ((3 * f[0] +
+                7 * f[1] +
+                6 * f[2] +
+                1 * f[3] +
+                8 * f[4] +
+                9 * f[5] +
+                4 * f[6] +
+                5 * f[7] +
+                2 * f[8]) %
+                11)) %
+            11;
+        const k2 = (11 -
+            ((5 * f[0] +
+                4 * f[1] +
+                3 * f[2] +
+                2 * f[3] +
+                7 * f[4] +
+                6 * f[5] +
+                5 * f[6] +
+                4 * f[7] +
+                3 * f[8] +
+                2 * k1) %
+                11)) %
+            11;
+        if (k1 !== f[9] || k2 !== f[10])
+            return false;
+        return true;
+    },
+    TH: (str) => {
+        if (!str.match(/^[1-8]\d{12}$/))
+            return false;
+        let sum = 0;
+        for (let i = 0; i < 12; i++) {
+            sum += parseInt(str[i], 10) * (13 - i);
+        }
+        return str[12] === ((11 - (sum % 11)) % 10).toString();
+    },
+    LK: (str) => {
+        const old_nic = /^[1-9]\d{8}[vx]$/i;
+        const new_nic = /^[1-9]\d{11}$/i;
+        if (str.length === 10 && old_nic.test(str))
+            return true;
+        if (str.length === 12 && new_nic.test(str))
+            return true;
+        return false;
+    },
+    'he-IL': (str) => {
+        const DNI = /^\d{9}$/;
+        const sanitized = str.trim();
+        if (!DNI.test(sanitized)) {
+            return false;
+        }
+        const id = sanitized;
+        let sum = 0, incNum;
+        for (let i = 0; i < id.length; i++) {
+            incNum = Number(id[i]) * ((i % 2) + 1);
+            sum += incNum > 9 ? incNum - 9 : incNum;
+        }
+        return sum % 10 === 0;
+    },
+    'ar-LY': (str) => {
+        const NIN = /^(1|2)\d{11}$/;
+        const sanitized = str.trim();
+        return NIN.test(sanitized);
+    },
+    'ar-TN': (str) => {
+        const DNI = /^\d{8}$/;
+        const sanitized = str.trim();
+        return DNI.test(sanitized);
+    },
+    'zh-CN': (str) => {
+        const provincesAndCities = [
+            '11',
+            '12',
+            '13',
+            '14',
+            '15',
+            '21',
+            '22',
+            '23',
+            '31',
+            '32',
+            '33',
+            '34',
+            '35',
+            '36',
+            '37',
+            '41',
+            '42',
+            '43',
+            '44',
+            '45',
+            '46',
+            '50',
+            '51',
+            '52',
+            '53',
+            '54',
+            '61',
+            '62',
+            '63',
+            '64',
+            '65',
+            '71',
+            '81',
+            '82',
+            '91',
+        ];
+        const powers = [
+            '7',
+            '9',
+            '10',
+            '5',
+            '8',
+            '4',
+            '2',
+            '1',
+            '6',
+            '3',
+            '7',
+            '9',
+            '10',
+            '5',
+            '8',
+            '4',
+            '2',
+        ];
+        const parityBit = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+        const checkAddressCode = (addressCode) => provincesAndCities.includes(addressCode);
+        const checkBirthDayCode = (birDayCode) => {
+            const yyyy = parseInt(birDayCode.substring(0, 4), 10);
+            const mm = parseInt(birDayCode.substring(4, 6), 10);
+            const dd = parseInt(birDayCode.substring(6), 10);
+            if (!isCalendarDate(yyyy, mm, dd))
+                return false;
+            return new Date(yyyy, mm - 1, dd) <= new Date();
+        };
+        const getParityBit = (idCardNo) => {
+            const id17 = idCardNo.substring(0, 17);
+            let power = 0;
+            for (let i = 0; i < 17; i++) {
+                power += parseInt(id17.charAt(i), 10) * parseInt(powers[i], 10);
+            }
+            const mod = power % 11;
+            return parityBit[mod];
+        };
+        const checkParityBit = (idCardNo) => getParityBit(idCardNo) === idCardNo.charAt(17).toUpperCase();
+        const check15IdCardNo = (idCardNo) => {
+            let check = /^[1-9]\d{7}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\d{3}$/.test(idCardNo);
+            if (!check)
+                return false;
+            const addressCode = idCardNo.substring(0, 2);
+            check = checkAddressCode(addressCode);
+            if (!check)
+                return false;
+            const birDayCode = `19${idCardNo.substring(6, 12)}`;
+            check = checkBirthDayCode(birDayCode);
+            if (!check)
+                return false;
+            return true;
+        };
+        const check18IdCardNo = (idCardNo) => {
+            let check = /^[1-9]\d{5}[1-9]\d{3}((0[1-9])|(1[0-2]))((0[1-9])|([1-2][0-9])|(3[0-1]))\d{3}(\d|x|X)$/.test(idCardNo);
+            if (!check)
+                return false;
+            const addressCode = idCardNo.substring(0, 2);
+            check = checkAddressCode(addressCode);
+            if (!check)
+                return false;
+            const birDayCode = idCardNo.substring(6, 14);
+            check = checkBirthDayCode(birDayCode);
+            if (!check)
+                return false;
+            return checkParityBit(idCardNo);
+        };
+        const checkIdCardNo = (idCardNo) => {
+            const check = /^\d{15}|(\d{17}(\d|x|X))$/.test(idCardNo);
+            if (!check)
+                return false;
+            if (idCardNo.length === 15) {
+                return check15IdCardNo(idCardNo);
+            }
+            return check18IdCardNo(idCardNo);
+        };
+        return checkIdCardNo(str);
+    },
+    'zh-HK': (str) => {
+        str = str.trim();
+        const regexHKID = /^[A-Z]{1,2}[0-9]{6}((\([0-9A]\))|(\[[0-9A]\])|([0-9A]))$/;
+        const regexIsDigit = /^[0-9]$/;
+        str = str.toUpperCase();
+        if (!regexHKID.test(str))
+            return false;
+        str = str.replace(/\[|\]|\(|\)/g, '');
+        if (str.length === 8)
+            str = `3${str}`;
+        let checkSumVal = 0;
+        for (let i = 0; i <= 7; i++) {
+            let convertedChar;
+            if (!regexIsDigit.test(str[i]))
+                convertedChar = (str[i].charCodeAt(0) - 55) % 11;
+            else
+                convertedChar = str[i];
+            checkSumVal += convertedChar * (9 - i);
+        }
+        checkSumVal %= 11;
+        let checkSumConverted;
+        if (checkSumVal === 0)
+            checkSumConverted = '0';
+        else if (checkSumVal === 1)
+            checkSumConverted = 'A';
+        else
+            checkSumConverted = String(11 - checkSumVal);
+        if (checkSumConverted === str[str.length - 1])
+            return true;
+        return false;
+    },
+    'zh-TW': (str) => {
+        const ALPHABET_CODES = {
+            A: 10,
+            B: 11,
+            C: 12,
+            D: 13,
+            E: 14,
+            F: 15,
+            G: 16,
+            H: 17,
+            I: 34,
+            J: 18,
+            K: 19,
+            L: 20,
+            M: 21,
+            N: 22,
+            O: 35,
+            P: 23,
+            Q: 24,
+            R: 25,
+            S: 26,
+            T: 27,
+            U: 28,
+            V: 29,
+            W: 32,
+            X: 30,
+            Y: 31,
+            Z: 33,
+        };
+        const sanitized = str.trim().toUpperCase();
+        if (!/^[A-Z][0-9]{9}$/.test(sanitized))
+            return false;
+        return Array.from(sanitized).reduce((sum, char, index) => {
+            if (index === 0) {
+                const code = ALPHABET_CODES[char];
+                return (code % 10) * 9 + Math.floor(code / 10);
+            }
+            if (index === 9) {
+                return (10 - (sum % 10) - Number(char)) % 10 === 0;
+            }
+            return sum + Number(char) * (9 - index);
+        }, 0);
+    },
+    PK: (str) => {
+        const CNIC = /^[1-7][0-9]{4}-[0-9]{7}-[1-9]$/;
+        const sanitized = str.trim();
+        return CNIC.test(sanitized);
+    },
+};
+export function isIdentityCard(value, options) {
+    const { locale = 'any' } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (hasOwn(validators, locale)) {
+        return validators[locale](str);
+    }
+    if (locale === 'any') {
+        for (const key in validators) {
+            if (Object.prototype.hasOwnProperty.call(validators, key)) {
+                const validator = validators[key];
+                if (validator(str)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    throw new ValidationConfigError(`Invalid locale '${configText(locale)}'`);
+}

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

@@ -0,0 +1,4 @@
+export interface IsInOptions {
+    values: unknown[] | Record<string, unknown> | string;
+}
+export declare function isIn(value: unknown, options: IsInOptions): boolean;

package/dist/esm/validators/isIn.js

@@ -0,0 +1,33 @@
+import { toString } from '../convert/string.js';
+import { toEnum } from '../convert/enum.js';
+import { configText, optionsOf } from '../helpers/config.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+export function isIn(value, options) {
+    const { values } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    let i;
+    if (Object.prototype.toString.call(values) === '[object Array]') {
+        const array = [];
+        for (i in values) {
+            if ({}.hasOwnProperty.call(values, i)) {
+                const item = toString(values[i]);
+                if (item.ok)
+                    array[i] = item.value;
+            }
+        }
+        return toEnum(str, array).ok;
+    }
+    if (values !== null && typeof values === 'object') {
+        return Object.prototype.hasOwnProperty.call(values, str);
+    }
+    if (values === undefined || values === null)
+        return false;
+    if (typeof values === 'string') {
+        return values.indexOf(str) >= 0;
+    }
+    throw new ValidationConfigError(`values must be an array, an object or a string, got ${configText(values)}`);
+}

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

@@ -0,0 +1,8 @@
+export interface IsIntOptions {
+    min?: number;
+    max?: number;
+    lt?: number;
+    gt?: number;
+    allow_leading_zeroes?: boolean;
+}
+export declare function isInt(value: unknown, options?: IsIntOptions): boolean;

package/dist/esm/validators/isInt.js

@@ -0,0 +1,26 @@
+import { toInteger } from '../convert/integer.js';
+import { ConvertMessages } from '../convert/result.js';
+import { toString } from '../convert/string.js';
+export function isInt(value, options) {
+    const opts = options || {};
+    const r = toInteger(value, {
+        syntax: 'validator',
+        allowLeadingZeroes: opts.allow_leading_zeroes,
+    });
+    if (!r.ok && r.error !== ConvertMessages.INTEGER_OVERFLOW)
+        return false;
+    const text = typeof value === 'number' ? undefined : toString(value).value;
+    const n = r.ok ? r.value : Number(text);
+    const big = text !== undefined && !Number.isSafeInteger(n) ? BigInt(text) : undefined;
+    const compare = (bound) => {
+        if (big !== undefined && Number.isInteger(bound)) {
+            const b = BigInt(bound);
+            return big < b ? -1 : big > b ? 1 : 0;
+        }
+        return n < bound ? -1 : n > bound ? 1 : 0;
+    };
+    return ((opts.min == null || compare(opts.min) >= 0) &&
+        (opts.max == null || compare(opts.max) <= 0) &&
+        (opts.lt == null || compare(opts.lt) < 0) &&
+        (opts.gt == null || compare(opts.gt) > 0));
+}

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

@@ -0,0 +1,5 @@
+export interface IsJSONOptions {
+    allow_primitives?: boolean;
+    allow_any_value?: boolean;
+}
+export declare function isJSON(value: unknown, options?: IsJSONOptions): boolean;

package/dist/esm/validators/isJSON.js

@@ -0,0 +1,7 @@
+import { toJsonValue } from '../convert/json.js';
+export function isJSON(value, options) {
+    return toJsonValue(value, {
+        allowPrimitives: options?.allow_primitives,
+        allowAnyValue: options?.allow_any_value,
+    }).ok;
+}

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

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

package/dist/esm/validators/isJWT.js

@@ -0,0 +1,20 @@
+import { toString } from '../convert/string.js';
+import { isBase64 } from './isBase64.js';
+export function isJWT(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const dotSplit = str.split('.');
+    const len = dotSplit.length;
+    if (len !== 3) {
+        return false;
+    }
+    const [header, payload, signature] = dotSplit;
+    if (header === '' || payload === '')
+        return false;
+    return (isBase64(header, { urlSafe: true }) &&
+        isBase64(payload, { urlSafe: true }) &&
+        isBase64(signature, { urlSafe: true }));
+}

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

@@ -0,0 +1,4 @@
+export interface IsLatLongOptions {
+    checkDMS?: boolean;
+}
+export declare function isLatLong(value: unknown, options?: IsLatLongOptions): boolean;

package/dist/esm/validators/isLatLong.js

@@ -0,0 +1,26 @@
+import { toString } from '../convert/string.js';
+import { merge } from '../helpers/merge.js';
+const lat = /^\(?[+-]?(90(\.0+)?|[1-8]?\d(\.\d+)?)$/;
+const long = /^\s?[+-]?(180(\.0+)?|1[0-7]\d(\.\d+)?|\d{1,2}(\.\d+)?)\)?$/;
+const latDMS = /^(([1-8]?\d)\D+([1-5]?\d|60)\D+([1-5]?\d|60)(\.\d+)?|90\D+0\D+0)\D+[NSns]?$/i;
+const longDMS = /^\s*([1-7]?\d{1,2}\D+([1-5]?\d|60)\D+([1-5]?\d|60)(\.\d+)?|180\D+0\D+0)\D+[EWew]?$/i;
+const defaultLatLongOptions = {
+    checkDMS: false,
+};
+export function isLatLong(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    options = merge(options, defaultLatLongOptions);
+    const pair = s.split(',');
+    if (pair.length !== 2)
+        return false;
+    if ((pair[0].startsWith('(') && !pair[1].endsWith(')')) ||
+        (pair[1].endsWith(')') && !pair[0].startsWith('(')))
+        return false;
+    if (options.checkDMS) {
+        return latDMS.test(pair[0]) && longDMS.test(pair[1]);
+    }
+    return lat.test(pair[0]) && long.test(pair[1]);
+}

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

@@ -0,0 +1,7 @@
+export interface IsLengthOptions {
+    min?: number;
+    max?: number;
+    discreteLengths?: number[];
+    graphemes?: boolean;
+}
+export declare function isLength(value: unknown, options?: IsLengthOptions): boolean;

package/dist/esm/validators/isLength.js

@@ -0,0 +1,25 @@
+import { toString } from '../convert/string.js';
+import { boundsOf } from '../helpers/config.js';
+function countCodePointsWithoutPresentationSelectors(s) {
+    const presentationSequences = s.match(/[^\uFE0F\uFE0E][\uFE0F\uFE0E]/g) || [];
+    const surrogatePairs = s.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || [];
+    return s.length - presentationSequences.length - surrogatePairs.length;
+}
+let segmenter;
+function countGraphemes(s) {
+    segmenter ?? (segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' }));
+    return Array.from(segmenter.segment(s)).length;
+}
+export function isLength(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const { options: opts, min, max } = boundsOf(options);
+    const len = opts.graphemes ? countGraphemes(s) : countCodePointsWithoutPresentationSelectors(s);
+    const isInsideRange = len >= min && (typeof max === 'undefined' || len <= max);
+    if (isInsideRange && Array.isArray(opts.discreteLengths)) {
+        return opts.discreteLengths.some((discreteLen) => discreteLen === len);
+    }
+    return isInsideRange;
+}

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

@@ -0,0 +1,21 @@
+declare const validators: {
+    'cs-CZ': (str: any) => boolean;
+    'de-DE': (str: any) => boolean;
+    'de-LI': (str: any) => boolean;
+    'en-IN': (str: any) => boolean;
+    'en-SG': (str: any) => boolean;
+    'es-AR': (str: any) => boolean;
+    'fi-FI': (str: any) => boolean;
+    'hu-HU': (str: any) => boolean;
+    'pt-BR': (str: any) => boolean;
+    'pt-PT': (str: any) => boolean;
+    'sq-AL': (str: any) => boolean;
+    'sv-SE': (str: any) => boolean;
+    'en-PK': (str: any) => boolean;
+};
+export type LicensePlateLocale = keyof typeof validators | 'any' | (string & {});
+export interface IsLicensePlateOptions {
+    locale: LicensePlateLocale;
+}
+export declare function isLicensePlate(value: unknown, options: IsLicensePlateOptions): boolean;
+export {};