valgen 5.18.2 → 5.19.1

package/cjs/rules/type-rules/is-boolean.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBoolean = isBoolean;
-const index_js_1 = require("../../core/index.js");
-const TRUE_PATTERN = /^true|t|1|yes|y$/i;
-const FALSE_PATTERN = /^false|f|0|no|n$/i;
-/**
- * Validates if value is "boolean".
- * Converts input value to boolean if coerce option is set to 'true'.
- * @validator isBoolean
- */
-function isBoolean(options) {
-    return (0, index_js_1.validator)('isBoolean', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        let output = input;
-        if (output != null && typeof output !== 'boolean' && coerce) {
-            if (typeof input === 'string') {
-                if (TRUE_PATTERN.test(input))
-                    return true;
-                if (FALSE_PATTERN.test(input))
-                    return false;
-                throw new TypeError(`Invalid boolean string`);
-            }
-            if (input === 1 || input === 0)
-                output = !!input;
-        }
-        if (typeof output === 'boolean')
-            return output;
-        context.fail(_this, `Value must be a boolean`, input);
-    }, options);
-}

package/cjs/rules/type-rules/is-date.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDate = isDate;
-exports.isDateString = isDateString;
-const tslib_1 = require("tslib");
-const datefns = tslib_1.__importStar(require("date-fns"));
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if value is a "Date" instance or ISO 8601 formatted date string.
- *  if a `coerce` option is `true`, converts input value to Date instance
- * @validator isDate
- */
-function isDate(options) {
-    const trim = options?.trim;
-    return (0, index_js_1.validator)('isDate', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        let d;
-        if (input instanceof Date)
-            d = input;
-        else if (coerce) {
-            if (typeof input === 'number')
-                d = new Date(input);
-            else if (typeof input === 'string') {
-                const parsed = coerceDateString(input);
-                if (parsed) {
-                    d = new Date(parsed.value);
-                }
-            }
-        }
-        if (datefns.isValid(d)) {
-            setPrecision(d, trim);
-            return d;
-        }
-        context.fail(_this, `Value is not valid date`, input, {
-            ...options,
-        });
-    }, options);
-}
-/**
- * Validates if value is DFS (date formatted string).
- * Converts input value to DFS if the "coerce" option is set to 'true'.
- * @validator isDateString
- */
-function isDateString(options) {
-    const precisionMin = options?.precisionMin || 'minutes';
-    const precisionMax = options?.precisionMax || 'tz';
-    const precisionMaxIdx = PRECISION_INDEX[precisionMax] || 9;
-    const precisionMinIdx = Math.min(precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
-    return (0, index_js_1.validator)('isDateString', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        const parsed = coerceDateString(input, options?.trim);
-        if (parsed) {
-            if (parsed.precision >= precisionMinIdx &&
-                parsed.precision <= precisionMaxIdx) {
-                return coerce ? parsed.value : input;
-            }
-        }
-        context.fail(_this, `Value is not valid date string` +
-            (options?.precisionMin || options?.precisionMax
-                ? ` with required precision`
-                : ''), input, {
-            ...options,
-        });
-    }, options);
-}
-// noinspection RegExpUnnecessaryNonCapturingGroup
-const DATE_PATTERN = /^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[T ](?:([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?(?:\.(\d{0,6}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
-const DATE_PATTERN2 = /^(\d{4,14})(?:\.(\d{1,6}))?(?:(?:([+-])(0[0-9]|1[0-2])(\d{2})?)|Z)?$/;
-function coerceDateString(input, precision) {
-    let dateParts;
-    let outPrecision = 0;
-    if (input instanceof Date || typeof input === 'number') {
-        const d = typeof input === 'number' ? new Date(input) : input;
-        dateParts = [
-            String(d.getFullYear()).padStart(4, '0'),
-            String(d.getMonth() + 1).padStart(2, '0'),
-            String(d.getDate()).padStart(2, '0'),
-            String(d.getHours()).padStart(2, '0'),
-            String(d.getMinutes()).padStart(2, '0'),
-            String(d.getSeconds()).padStart(2, '0'),
-        ];
-        if (d.getMilliseconds() > 0)
-            dateParts.push(String(d.getMilliseconds()).padStart(3, '0'));
-    }
-    else if (typeof input === 'string') {
-        const d = datefns.parseISO(input);
-        let m = DATE_PATTERN.exec(input);
-        if (m && datefns.isValid(d)) {
-            m.shift();
-            dateParts = m;
-        }
-        else {
-            m = DATE_PATTERN2.exec(input);
-            if (m) {
-                dateParts = [
-                    m[1].substring(0, 4),
-                    m[1].substring(4, 6),
-                    m[1].substring(6, 8),
-                    m[1].substring(8, 10),
-                    m[1].substring(10, 12),
-                    m[1].substring(12, 14),
-                    m[2],
-                    m[3] ? m[3] + m[4] + (m[5] ? ':' + m[5] : '') : '',
-                ];
-            }
-        }
-    }
-    if (!dateParts)
-        return;
-    outPrecision = dateParts.findIndex(v => !v);
-    if (outPrecision === -1)
-        outPrecision = dateParts.length;
-    const precisionIndex = (precision ? PRECISION_INDEX[precision] : 9) || 9;
-    let value = dateParts[0] || '0000';
-    if (precisionIndex > 1)
-        value += '-' + (dateParts[1] || '01');
-    if (precisionIndex > 2)
-        value += '-' + (dateParts[2] || '01');
-    if (precisionIndex > 3)
-        value += 'T' + (dateParts[3] || '00');
-    if (precisionIndex > 4)
-        value += ':' + (dateParts[4] || '00');
-    if (precisionIndex > 5)
-        value += ':' + (dateParts[5] || '00');
-    if (precisionIndex > 5)
-        value += dateParts[6] ? '.' + dateParts[6] : '';
-    if (precisionIndex > 7)
-        value += dateParts[7] || '';
-    return {
-        value,
-        precision: outPrecision || 8,
-    };
-}
-const PRECISION_INDEX = {
-    year: 1,
-    yr: 1,
-    month: 2,
-    mo: 2,
-    day: 3,
-    d: 4,
-    hours: 4,
-    hr: 4,
-    minutes: 5,
-    min: 5,
-    seconds: 6,
-    sec: 6,
-    milliseconds: 7,
-    ms: 7,
-    tz: 8,
-};
-function setPrecision(d, precision) {
-    switch (precision) {
-        case 'year': {
-            d.setMonth(0, 1);
-            d.setHours(0, 0, 0, 0);
-            break;
-        }
-        case 'month': {
-            d.setDate(1);
-            d.setHours(0, 0, 0, 0);
-            break;
-        }
-        case 'day': {
-            d.setHours(0, 0, 0, 0);
-            break;
-        }
-        case 'hours': {
-            d.setMinutes(0, 0, 0);
-            break;
-        }
-        case 'minutes': {
-            d.setSeconds(0, 0);
-            break;
-        }
-        case 'seconds': {
-            d.setMilliseconds(0);
-            break;
-        }
-    }
-}

package/cjs/rules/type-rules/is-enum.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEnum = isEnum;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if given value is one of enum values.
- * @validator isEnum
- */
-function isEnum(values, options) {
-    const caseInSensitive = !!options?.caseInSensitive;
-    const enumName = options?.enumName;
-    // Prepare an object for fast lookup
-    const valObj = (Array.isArray(values) ? values : [values]).reduce((a, v) => {
-        if (typeof v === 'string' && caseInSensitive)
-            a[v.toUpperCase()] = true;
-        else
-            a[v] = true;
-        return a;
-    }, {});
-    return (0, index_js_1.validator)('isEnum', (input, context, _this) => {
-        if (input != null &&
-            valObj[typeof input === 'string' && caseInSensitive
-                ? input.toUpperCase()
-                : input]) {
-            return input;
-        }
-        context.fail(_this, `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`, input, {
-            enum: enumName,
-        });
-    }, options);
-}

package/cjs/rules/type-rules/is-integer.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInteger = isInteger;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if value is "integer".
- * Converts input value to integer number if coerce option is set to 'true'.
- * @validator isInteger
- */
-function isInteger(options) {
-    return (0, index_js_1.validator)('isInteger', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        let output = input;
-        if (output != null && typeof output !== 'number' && coerce) {
-            if (typeof input === 'string')
-                output = parseFloat(input);
-            else if (typeof input === 'bigint') {
-                output = Number(input);
-                if (input === BigInt(output))
-                    input = output;
-            }
-        }
-        if (typeof output === 'number' &&
-            !isNaN(output) &&
-            Number.isInteger(output)) {
-            return output;
-        }
-        context.fail(_this, `Value must be a valid integer value`, input);
-    }, options);
-}

package/cjs/rules/type-rules/is-null.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNull = isNull;
-exports.isNotNull = isNotNull;
-exports.isNullish = isNullish;
-exports.isNotNullish = isNotNullish;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if value is "null".
- * @validator isNull
- */
-function isNull(options) {
-    return (0, index_js_1.validator)('isNull', (input, context, _this) => {
-        if (input === null)
-            return input;
-        context.fail(_this, `Value must be null`, input);
-    }, options);
-}
-/**
- * Validates if value is not "null".
- * @validator isNotNull
- */
-function isNotNull(options) {
-    return (0, index_js_1.validator)('isNotNull', (input, context, _this) => {
-        if (input !== null)
-            return input;
-        context.fail(_this, `{{label}} is null`, input);
-    }, options);
-}
-/**
- * Validates if value is "null" or "undefined".
- * @validator isNullish
- */
-function isNullish(options) {
-    return (0, index_js_1.validator)('isNullish', (input, context, _this) => {
-        if (input == null)
-            return input;
-        context.fail(_this, `{{label}} is not nullish`, input);
-    }, options);
-}
-/**
- * Validates if value is not "null" nor "undefined".
- * @validator isNotNullish
- */
-function isNotNullish(options) {
-    return (0, index_js_1.validator)('isNotNullish', (input, context, _this) => {
-        if (input != null)
-            return input;
-        if (input === null)
-            context.fail(_this, `{{label}} is null`, input);
-        else
-            context.fail(_this, `{{label}} is undefined`, input);
-    }, options);
-}

package/cjs/rules/type-rules/is-number.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNumber = isNumber;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if value is "number".
- * Converts input value to number if coerce option is set to 'true'.
- * @validator isNumber
- */
-function isNumber(options) {
-    return (0, index_js_1.validator)('isNumber', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        let output = input;
-        if (output != null && typeof output !== 'number' && coerce) {
-            if (typeof input === 'string')
-                output = parseFloat(input);
-            else if (typeof input === 'bigint') {
-                output = Number(input);
-                if (input === BigInt(output))
-                    return output;
-            }
-        }
-        if (typeof output === 'number' && !isNaN(output))
-            return output;
-        context.fail(_this, `Value must be a number`, input);
-    }, options);
-}

package/cjs/rules/type-rules/is-object.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = isObject;
-const constants_js_1 = require("../../constants.js");
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates object according to schema
- * Converts properties according to schema rules if coerce option is set to 'true'.
- * @validator isObject
- */
-function isObject(schema, options) {
-    const ctor = options?.ctor;
-    const ctorName = options?.name || ctor?.name;
-    const additionalFields = options?.additionalFields ?? !schema;
-    const caseInSensitive = !!options?.caseInSensitive;
-    const detectCircular = !!options?.detectCircular;
-    const propertyRules = {};
-    const propertyOptions = {};
-    schema = schema || {};
-    const schemaKeys = Object.keys(schema);
-    for (const k of schemaKeys) {
-        const n = schema[k];
-        const key = caseInSensitive ? k.toLowerCase() : k;
-        if (Array.isArray(n)) {
-            if (!(0, index_js_1.isValidator)(n[0])) {
-                throw new TypeError(`Invalid tuple definition in validation schema (${k})`);
-            }
-            propertyRules[key] = n[0];
-            propertyOptions[key] = { as: k, ...n[1] };
-        }
-        else if ((0, index_js_1.isValidator)(n)) {
-            propertyRules[key] = n;
-            propertyOptions[key] = { as: k };
-        }
-        else {
-            throw new TypeError(`Invalid definition in validation schema (${k})`);
-        }
-    }
-    const _rule = (0, index_js_1.validator)('isObject', (input, context, _this) => {
-        let output = input;
-        if (ctor && ctor[constants_js_1.preValidation]) {
-            output = ctor[constants_js_1.preValidation](output, context, _this);
-        }
-        const coerce = options?.coerce ?? context.coerce;
-        if (typeof output === 'string' && coerce)
-            output = JSON.parse(output);
-        if (!(output && typeof output === 'object')) {
-            context.fail(_this, `Value must be an object`, input);
-            return;
-        }
-        const keys = Array.from(new Set([...Object.keys(output), ...schemaKeys]));
-        const l = keys.length;
-        let i = 0;
-        let inputKey;
-        let schemaKey;
-        let v;
-        let _propRule;
-        const out = {};
-        if (ctor)
-            Object.setPrototypeOf(out, ctor.prototype);
-        if (detectCircular) {
-            context.circMap = context.circMap || new Map();
-            if (context.circMap.has(output)) {
-                return context.circMap.get(output);
-            }
-            context.circMap.set(output, out);
-        }
-        if (context.root == null)
-            context.root = context.root || ctorName || '';
-        const location = context.location || '';
-        const processedSchemaKeys = {};
-        // Iterate object keys and perform rules
-        for (i = 0; i < l; i++) {
-            inputKey = keys[i];
-            schemaKey = caseInSensitive ? inputKey.toLowerCase() : inputKey;
-            v = output[inputKey];
-            _propRule =
-                propertyRules[schemaKey] ||
-                    ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
-            if (_propRule) {
-                if (processedSchemaKeys[schemaKey])
-                    continue;
-                processedSchemaKeys[schemaKey] = true;
-                const subCtx = context.extend();
-                subCtx.scope = output;
-                subCtx.context = ctorName;
-                subCtx.location = location + (location ? '.' : '') + schemaKey;
-                subCtx.property = schemaKey;
-                if (propertyOptions[schemaKey]?.label) {
-                    subCtx.label = propertyOptions[schemaKey]?.label;
-                }
-                v = _propRule(v, subCtx);
-            }
-            else if (v !== undefined) {
-                if (!additionalFields)
-                    continue;
-                if (additionalFields === 'error') {
-                    context.fail(_propRule, `${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`, v);
-                }
-            }
-            if (v !== undefined) {
-                out[propertyOptions[schemaKey]?.as || schemaKey] = v;
-            }
-        }
-        if (ctor && ctor[constants_js_1.postValidation]) {
-            ctor[constants_js_1.postValidation](out, context, _this);
-            return out;
-        }
-        return out;
-    }, options);
-    _rule.schema = schema;
-    return _rule;
-}

package/cjs/rules/type-rules/is-record.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRecord = isRecord;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates record object according to given "key" and "value" rules
- * Converts properties according to rules if coerce option is set to 'true'.
- * @validator isRecord
- */
-function isRecord(keyRule, valueRule, options) {
-    return (0, index_js_1.validator)('isRecord', (input, context, _this) => {
-        if (!(input && typeof input === 'object')) {
-            context.fail(_this, `Value must be an object`, input);
-            return;
-        }
-        const keyContext = context.extend();
-        const valueContext = context.extend();
-        const location = context.location || '';
-        const keys = Object.keys(input);
-        const l = keys.length;
-        let i;
-        let k;
-        let v;
-        const out = {};
-        for (i = 0; i < l; i++) {
-            k = keys[i];
-            v = input[k];
-            // Validate key
-            k = keyRule(k, {
-                onFail(issue) {
-                    return `${k} is not a valid key. ` + issue.message;
-                },
-            }, keyContext);
-            // Validate value
-            valueContext.property = k;
-            valueContext.location = location + (location ? '.' : '') + k;
-            v = valueRule(v, valueContext);
-            out[k] = v;
-        }
-        return context.errors.length ? undefined : out;
-    }, options);
-}

package/cjs/rules/type-rules/is-string.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trimStart = exports.trimEnd = void 0;
-exports.isString = isString;
-exports.stringReplace = stringReplace;
-exports.stringSplit = stringSplit;
-exports.trim = trim;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if value is "string".
- * Converts input value to string if coerce option is set to 'true'.
- * @validator isString
- */
-function isString(options) {
-    return (0, index_js_1.validator)('isString', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        let output = input;
-        if (output != null && typeof output !== 'string' && coerce) {
-            if (typeof output === 'object') {
-                if (typeof output.toJSON === 'function')
-                    output = output.toJSON();
-                else
-                    output = JSON.stringify(output);
-            }
-            else
-                output = String(output);
-        }
-        if (typeof output === 'string')
-            return output;
-        context.fail(_this, `Value must be a string`, input);
-    }, options);
-}
-function stringReplace(searchValue, replacer) {
-    return (0, index_js_1.validator)('stringReplace', (input) => {
-        if (input == null)
-            return input;
-        return String(input).replace(searchValue, replacer);
-    });
-}
-function stringSplit(splitter, limit) {
-    return (0, index_js_1.validator)('stringSplit', (input) => {
-        if (input == null)
-            return input;
-        return String(input).split(splitter, limit);
-    });
-}
-/**
- * Removes whitespace from both ends of a string
- * @validator trim
- */
-function trim() {
-    return (0, index_js_1.validator)('trim', (input) => {
-        if (input == null)
-            return input;
-        return String(input).trim();
-    });
-}
-// *************************************************************
-/**
- * Removes whitespace from the end of a string
- * @validator trimEnd
- */
-const trimEnd = () => trimEndRule;
-exports.trimEnd = trimEnd;
-const trimEndRule = (0, index_js_1.validator)('trimEnd', (input) => {
-    if (input == null)
-        return input;
-    return String(input).trimEnd();
-});
-// *************************************************************
-/**
- * Removes whitespace from the beginning of a string
- * @validator trimStart
- */
-const trimStart = () => trimStartRule;
-exports.trimStart = trimStart;
-const trimStartRule = (0, index_js_1.validator)('trimStart', (input) => {
-    if (input == null)
-        return input;
-    return String(input).trimStart();
-});

package/cjs/rules/type-rules/is-tuple.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTuple = isTuple;
-const index_js_1 = require("../../core/index.js");
-function isTuple(items, options) {
-    return (0, index_js_1.validator)('isTuple', (input, context, _this) => {
-        const coerce = options?.coerce ?? context.coerce;
-        let output = input;
-        if (output != null && coerce && !Array.isArray(output))
-            output = [output];
-        if (!Array.isArray(input)) {
-            context.fail(_this, `Value must be a tuple`, input);
-            return;
-        }
-        const location = context.location || '';
-        let itemRule;
-        let i;
-        let v;
-        const l = output.length;
-        const out = [];
-        const nl = items.length;
-        const itemContext = context.extend();
-        for (i = 0; i < l && i < nl; i++) {
-            itemRule = items[i];
-            itemContext.scope = output;
-            itemContext.label = context.label
-                ? context.label + `[${i}]`
-                : undefined;
-            itemContext.index = i;
-            itemContext.location = location + '[' + i + ']';
-            itemContext.label =
-                (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
-            v = itemRule(output[i], itemContext);
-            out.push(v);
-        }
-        return context.errors.length ? undefined : out;
-    }, options);
-}

package/cjs/rules/type-rules/is-undefined.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUndefined = isUndefined;
-const index_js_1 = require("../../core/index.js");
-/**
- * Validates if value is "undefined"
- * @validator isUndefined
- */
-function isUndefined(options) {
-    return (0, index_js_1.validator)('isUndefined', (input, context, _this) => {
-        if (options?.coerce ?? context.coerce)
-            return undefined;
-        if (input === undefined)
-            return;
-        context.fail(_this, `Value must be undefined`, input);
-    }, options);
-}

package/cjs/rules/utility-rules/all-of.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.allOf = allOf;
-const index_js_1 = require("../../core/index.js");
-/**
- * Test given value against to all codecs and returns original input
- * @validator allOf
- */
-function allOf(rules) {
-    return (0, index_js_1.validator)('allOf', (input, context) => {
-        let i;
-        let c;
-        const l = rules.length;
-        for (i = 0; i < l; i++) {
-            c = rules[i];
-            c(input, context);
-        }
-        return input;
-    });
-}