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

package/dist/cjs/convert/boolean.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBoolean = toBoolean;
+const result_1 = require("./result");
+const TRUE_VALUES = { default: ['true', '1'], strict: ['true', '1'], loose: ['true', '1', 'yes'] };
+const FALSE_VALUES = {
+    default: ['false', '0'],
+    strict: ['false', '0'],
+    loose: ['false', '0', 'no'],
+};
+function toBoolean(v, options) {
+    if (typeof v === 'boolean')
+        return (0, result_1.success)(v);
+    if (typeof v === 'number') {
+        if (v === 1)
+            return (0, result_1.success)(true);
+        if (v === 0)
+            return (0, result_1.success)(false);
+        return (0, result_1.failure)(result_1.ConvertMessages.BOOLEAN);
+    }
+    if (typeof v === 'string') {
+        const mode = options?.mode === 'strict' || options?.mode === 'loose' ? options.mode : 'default';
+        const s = mode === 'strict' ? v : mode === 'loose' ? v.toLowerCase() : v.trim().toLowerCase();
+        if (TRUE_VALUES[mode].includes(s))
+            return (0, result_1.success)(true);
+        if (FALSE_VALUES[mode].includes(s))
+            return (0, result_1.success)(false);
+    }
+    return (0, result_1.failure)(result_1.ConvertMessages.BOOLEAN);
+}

package/dist/cjs/convert/date.d.ts

@@ -0,0 +1,11 @@
+import type { Converted } from './result';
+export declare function isCalendarDate(year: number, month: number, day: number): boolean;
+export interface DateConvertOptions {
+    format?: string;
+    delimiters?: string[];
+    strictMode?: boolean;
+    twoDigitYearPivot?: number;
+    iso?: boolean;
+    lax?: boolean;
+}
+export declare function toDate(v: unknown, options?: DateConvertOptions): Converted<Date>;

package/dist/cjs/convert/date.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCalendarDate = isCalendarDate;
+exports.toDate = toDate;
+const result_1 = require("./result");
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+function isCalendarDate(year, month, day) {
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    return day <= (month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1]);
+}
+function validTime(hour, minute, second) {
+    return Number(hour ?? 0) <= 23 && Number(minute ?? 0) <= 59 && Number(second ?? 0) <= 59;
+}
+function validZone(zone) {
+    return (zone === undefined ||
+        zone === 'Z' ||
+        (Number(zone.slice(1, 3)) <= 23 && Number(zone.slice(4, 6)) <= 59));
+}
+function validInstant(d) {
+    return isNaN(d.getTime()) ? (0, result_1.failure)(result_1.ConvertMessages.DATE) : (0, result_1.success)(d);
+}
+function pinZonelessTimeToUtc(isoText, time, zone) {
+    return time !== undefined && zone === undefined ? `${isoText}Z` : isoText;
+}
+const DATE_FORMAT = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2}):(\d{2})(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
+function toDate(v, options) {
+    try {
+        if (options?.lax)
+            return toDateLax(v);
+        if (options?.iso)
+            return toDateIso(v);
+        return toDateByFormat(v, options);
+    }
+    catch {
+        return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    }
+}
+function toDateIso(v) {
+    if (v instanceof Date)
+        return validInstant(v);
+    if (typeof v !== 'string')
+        return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    const m = DATE_FORMAT.exec(v);
+    if (m === null)
+        return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    if (!isCalendarDate(Number(m[1]), Number(m[2]), Number(m[3])))
+        return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    const hasTime = m[4] !== undefined;
+    if (hasTime && (!validTime(m[4], m[5], m[6]) || !validZone(m[8])))
+        return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    return validInstant(new Date(pinZonelessTimeToUtc(v.replace(' ', 'T'), m[4], m[8])));
+}
+const ISO_DATE_TIME = /^(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?$/;
+const DATE_TO_STRING = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{2} -?\d{4,6} \d{2}:\d{2}:\d{2} GMT[+-](?:[01]\d|2[0-3])[0-5]\d(?: \(.+\))?$/;
+const DATE_TO_UTC_STRING = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) -?\d{4,6} \d{2}:\d{2}:\d{2} GMT$/;
+function toDateLax(v) {
+    if (v instanceof Date)
+        return validInstant(v);
+    if (typeof v !== 'string')
+        return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    const m = ISO_DATE_TIME.exec(v);
+    if (m !== null) {
+        const month = m[2] === undefined ? 1 : Number(m[2]);
+        const day = m[3] === undefined ? 1 : Number(m[3]);
+        if (!isCalendarDate(Number(m[1]), month, day))
+            return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+        if (!validTime(m[4], m[5], m[6]) || !validZone(m[7]))
+            return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+        return validInstant(new Date(pinZonelessTimeToUtc(v, m[4], m[7])));
+    }
+    if (DATE_TO_STRING.test(v) || DATE_TO_UTC_STRING.test(v))
+        return validInstant(new Date(v));
+    return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+}
+const default_date_options = {
+    format: 'YYYY/MM/DD',
+    delimiters: ['/', '-'],
+    strictMode: false,
+};
+const validFormatRegex = /(^(y{4}|y{2})[./-](m{1,2})[./-](d{1,2})$)|(^(m{1,2})[./-](d{1,2})[./-]((y{4}|y{2})$))|(^(d{1,2})[./-](m{1,2})[./-]((y{4}|y{2})$))/i;
+function isValidFormat(format) {
+    return validFormatRegex.test(format);
+}
+function zip(date, format) {
+    const zippedArr = [], len = Math.max(date.length, format.length);
+    for (let i = 0; i < len; i++) {
+        zippedArr.push([date[i], format[i]]);
+    }
+    return zippedArr;
+}
+function withDefaults(options) {
+    const merged = { ...options };
+    for (const key of Object.keys(default_date_options)) {
+        if (merged[key] === undefined)
+            merged[key] = default_date_options[key];
+    }
+    return merged;
+}
+function currentTwoDigitYear() {
+    return new Date().getFullYear() % 100;
+}
+function toDateByFormat(input, options) {
+    const mergedOptions = withDefaults(options);
+    if (typeof input === 'string' && isValidFormat(mergedOptions.format)) {
+        if (mergedOptions.strictMode && input.length !== mergedOptions.format.length) {
+            return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+        }
+        if (!Array.isArray(mergedOptions.delimiters))
+            return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+        const formatDelimiter = mergedOptions.delimiters.find((delimiter) => mergedOptions.format.indexOf(delimiter) !== -1);
+        if (formatDelimiter === undefined)
+            return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+        const dateDelimiter = mergedOptions.strictMode
+            ? formatDelimiter
+            : mergedOptions.delimiters.find((delimiter) => input.indexOf(delimiter) !== -1);
+        const dateAndFormat = zip(input.split(dateDelimiter), mergedOptions.format.toLowerCase().split(formatDelimiter));
+        const dateObj = {};
+        for (const [dateWord, formatWord] of dateAndFormat) {
+            if (!dateWord || !formatWord || dateWord.length !== formatWord.length) {
+                return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+            }
+            dateObj[formatWord.charAt(0)] = dateWord;
+        }
+        let fullYear = dateObj.y;
+        if (fullYear.startsWith('-')) {
+            return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+        }
+        if (dateObj.y.length === 2) {
+            const parsedYear = parseInt(dateObj.y, 10);
+            if (isNaN(parsedYear)) {
+                return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+            }
+            const pivot = mergedOptions.twoDigitYearPivot ?? currentTwoDigitYear();
+            if (parsedYear < pivot) {
+                fullYear = `20${dateObj.y}`;
+            }
+            else {
+                fullYear = `19${dateObj.y}`;
+            }
+        }
+        let month = dateObj.m;
+        if (dateObj.m.length === 1) {
+            month = `0${dateObj.m}`;
+        }
+        let day = dateObj.d;
+        if (dateObj.d.length === 1) {
+            day = `0${dateObj.d}`;
+        }
+        const date = new Date(`${fullYear}-${month}-${day}T00:00:00.000Z`);
+        return date.getUTCDate() === +dateObj.d ? (0, result_1.success)(date) : (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    }
+    if (!mergedOptions.strictMode) {
+        return Object.prototype.toString.call(input) === '[object Date]' && isFinite(input)
+            ? (0, result_1.success)(input)
+            : (0, result_1.failure)(result_1.ConvertMessages.DATE);
+    }
+    return (0, result_1.failure)(result_1.ConvertMessages.DATE);
+}

package/dist/cjs/convert/enum.d.ts

@@ -0,0 +1,2 @@
+import type { Converted } from './result';
+export declare function toEnum<T extends string>(v: unknown, options: readonly T[]): Converted<T>;

package/dist/cjs/convert/enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEnum = toEnum;
+const result_1 = require("./result");
+function toEnum(v, options) {
+    if (typeof v !== 'string' && typeof v !== 'number' && typeof v !== 'boolean')
+        return (0, result_1.failure)(result_1.ConvertMessages.ENUM);
+    const key = String(v);
+    const index = options.indexOf(key);
+    return index === -1 ? (0, result_1.failure)(result_1.ConvertMessages.ENUM) : (0, result_1.success)(options[index]);
+}

package/dist/cjs/convert/float.d.ts

@@ -0,0 +1,6 @@
+import type { Converted } from './result';
+export interface FloatConvertOptions {
+    syntax?: 'default' | 'validator';
+    decimalSeparator?: string;
+}
+export declare function toFloat(v: unknown, options?: FloatConvertOptions): Converted<number>;

package/dist/cjs/convert/float.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFloat = toFloat;
+const string_1 = require("./string");
+const result_1 = require("./result");
+const PLAIN_DECIMAL_FORMAT = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const validatorFloatRegex = new Map();
+const MAX_CACHED_SEPARATORS = 64;
+function getValidatorFloatRegex(separator) {
+    let re = validatorFloatRegex.get(separator);
+    if (re === undefined) {
+        const escapedSeparator = separator.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&');
+        re = new RegExp(`^(?:[-+])?(?:[0-9]+)?(?:${escapedSeparator}[0-9]*)?(?:[eE][\\+\\-]?(?:[0-9]+))?$`);
+        if (validatorFloatRegex.size < MAX_CACHED_SEPARATORS)
+            validatorFloatRegex.set(separator, re);
+    }
+    return re;
+}
+const VALIDATOR_REJECTED = ['', '.', ',', '-', '+'];
+function toFloat(v, options) {
+    if (options?.syntax === 'validator')
+        return toFloatValidatorSyntax(v, options.decimalSeparator ?? '.');
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? (0, result_1.success)(v) : (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+    if (typeof v === 'string') {
+        const s = v.trim();
+        if (!PLAIN_DECIMAL_FORMAT.test(s))
+            return (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+        const n = Number(s);
+        return Number.isFinite(n) ? (0, result_1.success)(n) : (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+    }
+    return (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+}
+function toFloatValidatorSyntax(v, separator) {
+    if (typeof v === 'number')
+        return isFinite(v) ? (0, result_1.success)(v) : (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+    const str = (0, string_1.toString)(v);
+    if (!str.ok)
+        return (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+    const s = str.value;
+    if (VALIDATOR_REJECTED.includes(s) || !getValidatorFloatRegex(separator).test(s)) {
+        return (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+    }
+    const n = parseFloat(separator === '' ? s : s.replace(separator, '.'));
+    return Number.isFinite(n) ? (0, result_1.success)(n) : (0, result_1.failure)(result_1.ConvertMessages.FLOAT);
+}

package/dist/cjs/convert/index.d.ts

@@ -0,0 +1,16 @@
+export type { Converted, ConvertMessage, Success, Failure } from './result';
+export { ConvertMessages } from './result';
+export { toString } from './string';
+export { anyToString } from './any-to-string';
+export { toBoolean } from './boolean';
+export type { BooleanConvertOptions } from './boolean';
+export { toInteger } from './integer';
+export type { IntegerConvertOptions } from './integer';
+export { toFloat } from './float';
+export type { FloatConvertOptions } from './float';
+export { toDate } from './date';
+export type { DateConvertOptions } from './date';
+export { toJson, toJsonValue } from './json';
+export type { JsonValueConvertOptions } from './json';
+export { toArray } from './array';
+export { toEnum } from './enum';

package/dist/cjs/convert/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEnum = exports.toArray = exports.toJsonValue = exports.toJson = exports.toDate = exports.toFloat = exports.toInteger = exports.toBoolean = exports.anyToString = exports.toString = exports.ConvertMessages = void 0;
+var result_1 = require("./result");
+Object.defineProperty(exports, "ConvertMessages", { enumerable: true, get: function () { return result_1.ConvertMessages; } });
+var string_1 = require("./string");
+Object.defineProperty(exports, "toString", { enumerable: true, get: function () { return string_1.toString; } });
+var any_to_string_1 = require("./any-to-string");
+Object.defineProperty(exports, "anyToString", { enumerable: true, get: function () { return any_to_string_1.anyToString; } });
+var boolean_1 = require("./boolean");
+Object.defineProperty(exports, "toBoolean", { enumerable: true, get: function () { return boolean_1.toBoolean; } });
+var integer_1 = require("./integer");
+Object.defineProperty(exports, "toInteger", { enumerable: true, get: function () { return integer_1.toInteger; } });
+var float_1 = require("./float");
+Object.defineProperty(exports, "toFloat", { enumerable: true, get: function () { return float_1.toFloat; } });
+var date_1 = require("./date");
+Object.defineProperty(exports, "toDate", { enumerable: true, get: function () { return date_1.toDate; } });
+var json_1 = require("./json");
+Object.defineProperty(exports, "toJson", { enumerable: true, get: function () { return json_1.toJson; } });
+Object.defineProperty(exports, "toJsonValue", { enumerable: true, get: function () { return json_1.toJsonValue; } });
+var array_1 = require("./array");
+Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return array_1.toArray; } });
+var enum_1 = require("./enum");
+Object.defineProperty(exports, "toEnum", { enumerable: true, get: function () { return enum_1.toEnum; } });

package/dist/cjs/convert/integer.d.ts

@@ -0,0 +1,6 @@
+import type { Converted } from './result';
+export interface IntegerConvertOptions {
+    syntax?: 'default' | 'validator';
+    allowLeadingZeroes?: boolean;
+}
+export declare function toInteger(v: unknown, options?: IntegerConvertOptions): Converted<number>;

package/dist/cjs/convert/integer.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toInteger = toInteger;
+const string_1 = require("./string");
+const result_1 = require("./result");
+const INTEGER_FORMAT = /^-?\d+$/;
+const VALIDATOR_INT = /^(?:[-+]?(?:0|[1-9][0-9]*))$/;
+const VALIDATOR_INT_LEADING_ZEROES = /^[-+]?[0-9]+$/;
+function toInteger(v, options) {
+    if (options?.syntax === 'validator')
+        return toIntegerValidatorSyntax(v, options);
+    if (typeof v === 'number') {
+        if (!Number.isInteger(v))
+            return (0, result_1.failure)(result_1.ConvertMessages.INTEGER);
+        if (!Number.isSafeInteger(v))
+            return (0, result_1.failure)(result_1.ConvertMessages.INTEGER_OVERFLOW);
+        return (0, result_1.success)(v);
+    }
+    if (typeof v === 'string') {
+        const s = v.trim();
+        if (!INTEGER_FORMAT.test(s))
+            return (0, result_1.failure)(result_1.ConvertMessages.INTEGER);
+        const n = Number(s);
+        if (!Number.isSafeInteger(n))
+            return (0, result_1.failure)(result_1.ConvertMessages.INTEGER_OVERFLOW);
+        return (0, result_1.success)(n);
+    }
+    return (0, result_1.failure)(result_1.ConvertMessages.INTEGER);
+}
+function toIntegerValidatorSyntax(v, options) {
+    if (typeof v === 'number')
+        return Number.isInteger(v) ? (0, result_1.success)(v) : (0, result_1.failure)(result_1.ConvertMessages.INTEGER);
+    const str = (0, string_1.toString)(v);
+    if (!str.ok)
+        return (0, result_1.failure)(result_1.ConvertMessages.INTEGER);
+    const regex = options.allowLeadingZeroes === false ? VALIDATOR_INT : VALIDATOR_INT_LEADING_ZEROES;
+    if (!regex.test(str.value))
+        return (0, result_1.failure)(result_1.ConvertMessages.INTEGER);
+    const n = Number(str.value);
+    return Number.isFinite(n) ? (0, result_1.success)(n) : (0, result_1.failure)(result_1.ConvertMessages.INTEGER_OVERFLOW);
+}

package/dist/cjs/convert/json.d.ts

@@ -0,0 +1,7 @@
+import type { Converted } from './result';
+export declare function toJson(v: unknown): Converted<Record<string, unknown>>;
+export interface JsonValueConvertOptions {
+    allowPrimitives?: boolean;
+    allowAnyValue?: boolean;
+}
+export declare function toJsonValue(v: unknown, options?: JsonValueConvertOptions): Converted<unknown>;

package/dist/cjs/convert/json.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJson = toJson;
+exports.toJsonValue = toJsonValue;
+const string_1 = require("./string");
+const result_1 = require("./result");
+function isNonEmptyPlainRecord(v) {
+    return (v !== null && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0);
+}
+function isPlainObject(v) {
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+function isJsonSafe(root) {
+    const ancestors = new Set();
+    const stack = [{ node: root, exit: false }];
+    while (stack.length > 0) {
+        const { node, exit } = stack.pop();
+        if (exit) {
+            ancestors.delete(node);
+            continue;
+        }
+        if (ancestors.has(node))
+            return false;
+        if (!Array.isArray(node) && !isPlainObject(node))
+            return false;
+        ancestors.add(node);
+        stack.push({ node, exit: true });
+        for (const child of Object.values(node)) {
+            if (child === null || typeof child === 'string' || typeof child === 'boolean')
+                continue;
+            if (typeof child === 'number') {
+                if (!Number.isFinite(child))
+                    return false;
+                continue;
+            }
+            if (typeof child !== 'object')
+                return false;
+            stack.push({ node: child, exit: false });
+        }
+    }
+    return true;
+}
+function toJson(v) {
+    if (typeof v === 'string') {
+        let parsed;
+        try {
+            parsed = JSON.parse(v);
+        }
+        catch {
+            return (0, result_1.failure)(result_1.ConvertMessages.JSON);
+        }
+        return isNonEmptyPlainRecord(parsed) ? (0, result_1.success)(parsed) : (0, result_1.failure)(result_1.ConvertMessages.JSON);
+    }
+    try {
+        return isNonEmptyPlainRecord(v) && isJsonSafe(v) ? (0, result_1.success)(v) : (0, result_1.failure)(result_1.ConvertMessages.JSON);
+    }
+    catch {
+        return (0, result_1.failure)(result_1.ConvertMessages.JSON);
+    }
+}
+function toJsonValue(v, options) {
+    const str = (0, string_1.toString)(v);
+    if (!str.ok)
+        return (0, result_1.failure)(result_1.ConvertMessages.JSON_VALUE);
+    let parsed;
+    try {
+        parsed = JSON.parse(str.value);
+    }
+    catch {
+        return (0, result_1.failure)(result_1.ConvertMessages.JSON_VALUE);
+    }
+    if (options?.allowAnyValue)
+        return (0, result_1.success)(parsed);
+    if (options?.allowPrimitives && (parsed === null || parsed === true || parsed === false)) {
+        return (0, result_1.success)(parsed);
+    }
+    return parsed !== null && typeof parsed === 'object'
+        ? (0, result_1.success)(parsed)
+        : (0, result_1.failure)(result_1.ConvertMessages.JSON_VALUE);
+}

package/dist/cjs/convert/result.d.ts

@@ -0,0 +1,26 @@
+export declare const ConvertMessages: Readonly<{
+    readonly STRING: "Value cannot be converted to string";
+    readonly BOOLEAN: "Value cannot be converted to boolean";
+    readonly INTEGER: "Value is not an integer";
+    readonly INTEGER_OVERFLOW: "Integer exceeds the safe integer limits (-9007199254740991 to 9007199254740991)";
+    readonly FLOAT: "Value is not a finite decimal number";
+    readonly DATE: "Value is not a valid date";
+    readonly JSON: "Value is not a non-empty JSON object";
+    readonly JSON_VALUE: "Value is not an accepted JSON value";
+    readonly ARRAY: "Value is not an array";
+    readonly ENUM: "Value is not one of the enum options";
+}>;
+export type ConvertMessage = (typeof ConvertMessages)[keyof typeof ConvertMessages];
+export type Converted<T> = Success<T> | Failure;
+export interface Success<T> {
+    readonly ok: true;
+    readonly value: T;
+    readonly error: null;
+}
+export interface Failure {
+    readonly ok: false;
+    readonly value: null;
+    readonly error: ConvertMessage;
+}
+export declare function failure(error: ConvertMessage): Failure;
+export declare function success<T>(value: T): Success<T>;

package/dist/cjs/convert/result.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvertMessages = void 0;
+exports.failure = failure;
+exports.success = success;
+exports.ConvertMessages = Object.freeze({
+    STRING: 'Value cannot be converted to string',
+    BOOLEAN: 'Value cannot be converted to boolean',
+    INTEGER: 'Value is not an integer',
+    INTEGER_OVERFLOW: 'Integer exceeds the safe integer limits (-9007199254740991 to 9007199254740991)',
+    FLOAT: 'Value is not a finite decimal number',
+    DATE: 'Value is not a valid date',
+    JSON: 'Value is not a non-empty JSON object',
+    JSON_VALUE: 'Value is not an accepted JSON value',
+    ARRAY: 'Value is not an array',
+    ENUM: 'Value is not one of the enum options',
+});
+function failure(error) {
+    return { ok: false, value: null, error };
+}
+function success(value) {
+    return { ok: true, value, error: null };
+}

package/dist/cjs/convert/string.d.ts

@@ -0,0 +1,2 @@
+import type { Converted } from './result';
+export declare function toString(v: unknown): Converted<string>;

package/dist/cjs/convert/string.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toString = toString;
+const result_1 = require("./result");
+function toString(v) {
+    if (typeof v === 'string')
+        return (0, result_1.success)(v);
+    if (typeof v === 'boolean')
+        return (0, result_1.success)(v ? 'true' : 'false');
+    if (typeof v === 'number' && Number.isFinite(v))
+        return (0, result_1.success)(String(v));
+    return (0, result_1.failure)(result_1.ConvertMessages.STRING);
+}

package/dist/cjs/decorator/validate.d.ts

@@ -0,0 +1,23 @@
+import type { ValidatedClass } from './validations';
+export type ValidationError = {
+    validator: string;
+    message: string;
+} | {
+    custom: string;
+    message: string;
+};
+export interface ValidationSuccess<T> {
+    readonly ok: true;
+    readonly value: T;
+    readonly errors: readonly [];
+}
+export interface ValidationFailure<T> {
+    readonly ok: false;
+    readonly value: T;
+    readonly errors: readonly ValidationError[];
+}
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure<T>;
+export interface Validatable<T> {
+    validate(): ValidationResult<T>;
+}
+export declare function runValidations<T>(target: ValidatedClass, value: T): ValidationResult<T>;

package/dist/cjs/decorator/validate.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runValidations = runValidations;
+const validators_1 = require("../validators");
+const isRequired_1 = require("../validators/isRequired");
+const errors_1 = require("../helpers/errors");
+const validations_1 = require("./validations");
+const IS_REQUIRED = (0, validations_1.keyOf)({ validator: 'isRequired' });
+function validationsOf(target) {
+    const rootFirstChain = [];
+    for (let current = target; current !== Function.prototype && current !== null; current = Object.getPrototypeOf(current)) {
+        rootFirstChain.unshift(current);
+    }
+    const byKey = new Map();
+    for (const cls of rootFirstChain) {
+        for (const validation of validations_1.ownValidations.get(cls) ?? []) {
+            byKey.set((0, validations_1.keyOf)(validation), validation);
+        }
+    }
+    return [...byKey.values()];
+}
+function errorOf(validation, value) {
+    if ((0, validations_1.isCustom)(validation)) {
+        if (validation.fn(value))
+            return null;
+        return {
+            custom: validation.custom,
+            message: validation.message ?? `Value does not satisfy ${validation.custom}`,
+        };
+    }
+    const name = validation.validator;
+    if (!(0, validations_1.isValidatorName)(name)) {
+        throw new errors_1.ValidationConfigError(`Unknown validator "${name}"`);
+    }
+    const run = validators_1.validator[name];
+    if (run(value, validation.properties))
+        return null;
+    return { validator: name, message: validation.message ?? `Value does not satisfy ${name}` };
+}
+function runValidations(target, value) {
+    if (typeof target !== 'function')
+        throw new errors_1.ValidationConfigError('runValidations expects a class, not an instance or a value');
+    const declared = validationsOf(target);
+    const isRequired = declared.filter((validation) => (0, validations_1.keyOf)(validation) === IS_REQUIRED);
+    const isOptional = isRequired.length === 0;
+    let toRun;
+    if ((0, isRequired_1.isRequired)(value))
+        toRun = declared;
+    else if (isOptional)
+        toRun = [];
+    else
+        toRun = isRequired;
+    const errors = [];
+    for (const validation of toRun) {
+        const error = errorOf(validation, value);
+        if (error !== null)
+            errors.push(error);
+    }
+    return Object.freeze(errors.length === 0
+        ? { ok: true, value, errors: Object.freeze([]) }
+        : { ok: false, value, errors: Object.freeze(errors.map((error) => Object.freeze(error))) });
+}

package/dist/cjs/decorator/validations.d.ts

@@ -0,0 +1,35 @@
+import type { ValidatorRegistry } from '../validators';
+export type ValidatorName = {
+    [K in keyof ValidatorRegistry]: ValidatorRegistry[K] extends (...args: any[]) => boolean ? K : never;
+}[keyof ValidatorRegistry];
+type Params<K extends ValidatorName> = ValidatorRegistry[K] extends (value: any, ...rest: infer R) => boolean ? R : never;
+export type ValidationProperties<K extends ValidatorName> = Params<K> extends [] ? never : NonNullable<Params<K>[0]>;
+type PropertiesField<P> = [P] extends [never] ? {
+    properties?: undefined;
+} : Record<never, never> extends P ? {
+    properties?: P;
+} : {
+    properties: P;
+};
+export type BuiltInValidation = {
+    [K in ValidatorName]: {
+        validator: K;
+        message?: string;
+        custom?: undefined;
+        fn?: undefined;
+    } & PropertiesField<ValidationProperties<K>>;
+}[ValidatorName];
+export interface CustomValidation {
+    custom: string;
+    fn: (value: unknown) => boolean;
+    message?: string;
+    validator?: undefined;
+}
+export type Validation = BuiltInValidation | CustomValidation;
+export type ValidatedClass = abstract new (...args: any[]) => unknown;
+export declare const ownValidations: WeakMap<ValidatedClass, Validation[]>;
+export declare function isCustom(validation: Validation): validation is CustomValidation;
+export declare function isValidatorName(name: unknown): name is ValidatorName;
+export declare function keyOf(validation: Validation): string;
+export declare function Validations(validations: Validation[]): (target: ValidatedClass) => void;
+export {};