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

package/dist/esm/convert/float.js

@@ -0,0 +1,43 @@
+import { toString } from './string.js';
+import { ConvertMessages, failure, success } from './result.js';
+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 = ['', '.', ',', '-', '+'];
+export function toFloat(v, options) {
+    if (options?.syntax === 'validator')
+        return toFloatValidatorSyntax(v, options.decimalSeparator ?? '.');
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? success(v) : failure(ConvertMessages.FLOAT);
+    if (typeof v === 'string') {
+        const s = v.trim();
+        if (!PLAIN_DECIMAL_FORMAT.test(s))
+            return failure(ConvertMessages.FLOAT);
+        const n = Number(s);
+        return Number.isFinite(n) ? success(n) : failure(ConvertMessages.FLOAT);
+    }
+    return failure(ConvertMessages.FLOAT);
+}
+function toFloatValidatorSyntax(v, separator) {
+    if (typeof v === 'number')
+        return isFinite(v) ? success(v) : failure(ConvertMessages.FLOAT);
+    const str = toString(v);
+    if (!str.ok)
+        return failure(ConvertMessages.FLOAT);
+    const s = str.value;
+    if (VALIDATOR_REJECTED.includes(s) || !getValidatorFloatRegex(separator).test(s)) {
+        return failure(ConvertMessages.FLOAT);
+    }
+    const n = parseFloat(separator === '' ? s : s.replace(separator, '.'));
+    return Number.isFinite(n) ? success(n) : failure(ConvertMessages.FLOAT);
+}

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

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

package/dist/esm/convert/index.js

@@ -0,0 +1,10 @@
+export { ConvertMessages } from './result.js';
+export { toString } from './string.js';
+export { anyToString } from './any-to-string.js';
+export { toBoolean } from './boolean.js';
+export { toInteger } from './integer.js';
+export { toFloat } from './float.js';
+export { toDate } from './date.js';
+export { toJson, toJsonValue } from './json.js';
+export { toArray } from './array.js';
+export { toEnum } from './enum.js';

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

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

package/dist/esm/convert/integer.js

@@ -0,0 +1,38 @@
+import { toString } from './string.js';
+import { ConvertMessages, failure, success } from './result.js';
+const INTEGER_FORMAT = /^-?\d+$/;
+const VALIDATOR_INT = /^(?:[-+]?(?:0|[1-9][0-9]*))$/;
+const VALIDATOR_INT_LEADING_ZEROES = /^[-+]?[0-9]+$/;
+export function toInteger(v, options) {
+    if (options?.syntax === 'validator')
+        return toIntegerValidatorSyntax(v, options);
+    if (typeof v === 'number') {
+        if (!Number.isInteger(v))
+            return failure(ConvertMessages.INTEGER);
+        if (!Number.isSafeInteger(v))
+            return failure(ConvertMessages.INTEGER_OVERFLOW);
+        return success(v);
+    }
+    if (typeof v === 'string') {
+        const s = v.trim();
+        if (!INTEGER_FORMAT.test(s))
+            return failure(ConvertMessages.INTEGER);
+        const n = Number(s);
+        if (!Number.isSafeInteger(n))
+            return failure(ConvertMessages.INTEGER_OVERFLOW);
+        return success(n);
+    }
+    return failure(ConvertMessages.INTEGER);
+}
+function toIntegerValidatorSyntax(v, options) {
+    if (typeof v === 'number')
+        return Number.isInteger(v) ? success(v) : failure(ConvertMessages.INTEGER);
+    const str = toString(v);
+    if (!str.ok)
+        return failure(ConvertMessages.INTEGER);
+    const regex = options.allowLeadingZeroes === false ? VALIDATOR_INT : VALIDATOR_INT_LEADING_ZEROES;
+    if (!regex.test(str.value))
+        return failure(ConvertMessages.INTEGER);
+    const n = Number(str.value);
+    return Number.isFinite(n) ? success(n) : failure(ConvertMessages.INTEGER_OVERFLOW);
+}

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

@@ -0,0 +1,7 @@
+import type { Converted } from './result.js';
+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/esm/convert/json.js

@@ -0,0 +1,77 @@
+import { toString } from './string.js';
+import { ConvertMessages, failure, success } from './result.js';
+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;
+}
+export function toJson(v) {
+    if (typeof v === 'string') {
+        let parsed;
+        try {
+            parsed = JSON.parse(v);
+        }
+        catch {
+            return failure(ConvertMessages.JSON);
+        }
+        return isNonEmptyPlainRecord(parsed) ? success(parsed) : failure(ConvertMessages.JSON);
+    }
+    try {
+        return isNonEmptyPlainRecord(v) && isJsonSafe(v) ? success(v) : failure(ConvertMessages.JSON);
+    }
+    catch {
+        return failure(ConvertMessages.JSON);
+    }
+}
+export function toJsonValue(v, options) {
+    const str = toString(v);
+    if (!str.ok)
+        return failure(ConvertMessages.JSON_VALUE);
+    let parsed;
+    try {
+        parsed = JSON.parse(str.value);
+    }
+    catch {
+        return failure(ConvertMessages.JSON_VALUE);
+    }
+    if (options?.allowAnyValue)
+        return success(parsed);
+    if (options?.allowPrimitives && (parsed === null || parsed === true || parsed === false)) {
+        return success(parsed);
+    }
+    return parsed !== null && typeof parsed === 'object'
+        ? success(parsed)
+        : failure(ConvertMessages.JSON_VALUE);
+}

package/dist/esm/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/esm/convert/result.js

@@ -0,0 +1,18 @@
+export const 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',
+});
+export function failure(error) {
+    return { ok: false, value: null, error };
+}
+export function success(value) {
+    return { ok: true, value, error: null };
+}

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

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

package/dist/esm/convert/string.js

@@ -0,0 +1,10 @@
+import { ConvertMessages, failure, success } from './result.js';
+export function toString(v) {
+    if (typeof v === 'string')
+        return success(v);
+    if (typeof v === 'boolean')
+        return success(v ? 'true' : 'false');
+    if (typeof v === 'number' && Number.isFinite(v))
+        return success(String(v));
+    return failure(ConvertMessages.STRING);
+}

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

@@ -0,0 +1,23 @@
+import type { ValidatedClass } from './validations.js';
+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/esm/decorator/validate.js

@@ -0,0 +1,59 @@
+import { validator } from '../validators/index.js';
+import { isRequired as hasValue } from '../validators/isRequired.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { isCustom, isValidatorName, keyOf, ownValidations } from './validations.js';
+const IS_REQUIRED = 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 ownValidations.get(cls) ?? []) {
+            byKey.set(keyOf(validation), validation);
+        }
+    }
+    return [...byKey.values()];
+}
+function errorOf(validation, value) {
+    if (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 (!isValidatorName(name)) {
+        throw new ValidationConfigError(`Unknown validator "${name}"`);
+    }
+    const run = validator[name];
+    if (run(value, validation.properties))
+        return null;
+    return { validator: name, message: validation.message ?? `Value does not satisfy ${name}` };
+}
+export function runValidations(target, value) {
+    if (typeof target !== 'function')
+        throw new ValidationConfigError('runValidations expects a class, not an instance or a value');
+    const declared = validationsOf(target);
+    const isRequired = declared.filter((validation) => keyOf(validation) === IS_REQUIRED);
+    const isOptional = isRequired.length === 0;
+    let toRun;
+    if (hasValue(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/esm/decorator/validations.d.ts

@@ -0,0 +1,35 @@
+import type { ValidatorRegistry } from '../validators/index.js';
+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 {};

package/dist/esm/decorator/validations.js

@@ -0,0 +1,68 @@
+var _a;
+import { validator } from '../validators/index.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+const REGISTRY = Symbol.for('@archi-code/validation/decorator.v1');
+export const ownValidations = ((_a = globalThis)[REGISTRY] ?? (_a[REGISTRY] = new WeakMap()));
+export function isCustom(validation) {
+    return validation.custom !== undefined;
+}
+export function isValidatorName(name) {
+    return hasOwn(validator, name) && typeof validator[name] === 'function';
+}
+function assertShape(validation) {
+    if (validation === null || typeof validation !== 'object')
+        throw new ValidationConfigError('A validation must be an object');
+    const { validator: name, custom, fn } = validation;
+    if (name !== undefined && custom !== undefined)
+        throw new ValidationConfigError('A validation cannot have both "validator" and "custom"');
+    if (custom !== undefined) {
+        if (typeof custom !== 'string' || custom === '')
+            throw new ValidationConfigError('"custom" must be a non-empty string');
+        if (typeof fn !== 'function')
+            throw new ValidationConfigError(`Custom "${custom}" needs a "fn" function`);
+        return;
+    }
+    if (name === undefined)
+        throw new ValidationConfigError('A validation needs "validator" or "custom"');
+    if (!isValidatorName(name))
+        throw new ValidationConfigError(`Unknown validator "${String(name)}"`);
+}
+export function keyOf(validation) {
+    return isCustom(validation) ? `custom:${validation.custom}` : `validator:${validation.validator}`;
+}
+function snapshot(value) {
+    if (Array.isArray(value))
+        return Object.freeze(value.map(snapshot));
+    if (value !== null &&
+        typeof value === 'object' &&
+        Object.getPrototypeOf(value) === Object.prototype) {
+        const copy = {};
+        for (const [key, item] of Object.entries(value))
+            copy[key] = snapshot(item);
+        return Object.freeze(copy);
+    }
+    return value;
+}
+export function Validations(validations) {
+    return (target) => {
+        if (typeof target !== 'function')
+            throw new ValidationConfigError('@Validations can only decorate a class');
+        if (!Array.isArray(validations))
+            throw new ValidationConfigError('@Validations expects an array of validations');
+        const declared = new Set();
+        for (const validation of validations) {
+            assertShape(validation);
+            const key = keyOf(validation);
+            if (declared.has(key))
+                throw new ValidationConfigError(isCustom(validation)
+                    ? `Custom "${validation.custom}" is declared more than once`
+                    : `Validator "${validation.validator}" is declared more than once`);
+            declared.add(key);
+        }
+        const own = new Map((ownValidations.get(target) ?? []).map((v) => [keyOf(v), v]));
+        for (const validation of validations)
+            own.set(keyOf(validation), snapshot(validation));
+        ownValidations.set(target, [...own.values()]);
+    };
+}

package/dist/esm/helpers/algorithms.d.ts

@@ -0,0 +1 @@
+export declare function reverseMultiplyAndSum(digits: number[], base: number): number;

package/dist/esm/helpers/algorithms.js

@@ -0,0 +1,7 @@
+export function reverseMultiplyAndSum(digits, base) {
+    let total = 0;
+    for (let i = 0; i < digits.length; i++) {
+        total += digits[i] * (base - i);
+    }
+    return total;
+}

package/dist/esm/helpers/analyzePassword.d.ts

@@ -0,0 +1,9 @@
+export interface PasswordAnalysis {
+    length: number;
+    uniqueChars: number;
+    uppercaseCount: number;
+    lowercaseCount: number;
+    numberCount: number;
+    symbolCount: number;
+}
+export declare function analyzePassword(password: string): PasswordAnalysis;

package/dist/esm/helpers/analyzePassword.js

@@ -0,0 +1,38 @@
+const upperCaseRegex = /^\p{Lu}$/u;
+const lowerCaseRegex = /^\p{Ll}$/u;
+const numberRegex = /^\p{Nd}$/u;
+const symbolRegex = /^[\p{P}\p{S}\p{Zs}]$/u;
+function countCodePoints(codePoints) {
+    const result = new Map();
+    for (const char of codePoints) {
+        result.set(char, (result.get(char) ?? 0) + 1);
+    }
+    return result;
+}
+export function analyzePassword(password) {
+    const codePoints = Array.from(password);
+    const charMap = countCodePoints(codePoints);
+    const analysis = {
+        length: codePoints.length,
+        uniqueChars: charMap.size,
+        uppercaseCount: 0,
+        lowercaseCount: 0,
+        numberCount: 0,
+        symbolCount: 0,
+    };
+    charMap.forEach((count, char) => {
+        if (upperCaseRegex.test(char)) {
+            analysis.uppercaseCount += count;
+        }
+        else if (lowerCaseRegex.test(char)) {
+            analysis.lowercaseCount += count;
+        }
+        else if (numberRegex.test(char)) {
+            analysis.numberCount += count;
+        }
+        else if (symbolRegex.test(char)) {
+            analysis.symbolCount += count;
+        }
+    });
+    return analysis;
+}

package/dist/esm/helpers/assertString.d.ts

@@ -0,0 +1 @@
+export declare function assertString(input?: unknown): asserts input is string;

package/dist/esm/helpers/assertString.js

@@ -0,0 +1,6 @@
+export function assertString(input = undefined) {
+    if (input === undefined || input === null)
+        throw new TypeError(`Expected a string but received a ${input}`);
+    if (typeof input !== 'string')
+        throw new TypeError(`Expected a string but received a ${typeof input}`);
+}

package/dist/esm/helpers/boundedCache.d.ts

@@ -0,0 +1,9 @@
+export declare class BoundedCache<V> {
+    private readonly maxSize;
+    private readonly map;
+    constructor(maxSize?: number);
+    get size(): number;
+    getOrCreate(key: string, create: () => V): V;
+    private markMostRecentlyUsed;
+    private evictLeastRecentlyUsed;
+}

package/dist/esm/helpers/boundedCache.js

@@ -0,0 +1,29 @@
+export class BoundedCache {
+    constructor(maxSize = 256) {
+        this.maxSize = maxSize;
+        this.map = new Map();
+    }
+    get size() {
+        return this.map.size;
+    }
+    getOrCreate(key, create) {
+        const hit = this.map.get(key);
+        if (hit !== undefined) {
+            this.markMostRecentlyUsed(key, hit);
+            return hit;
+        }
+        const value = create();
+        if (this.map.size >= this.maxSize) {
+            this.evictLeastRecentlyUsed();
+        }
+        this.map.set(key, value);
+        return value;
+    }
+    markMostRecentlyUsed(key, value) {
+        this.map.delete(key);
+        this.map.set(key, value);
+    }
+    evictLeastRecentlyUsed() {
+        this.map.delete(this.map.keys().next().value);
+    }
+}

package/dist/esm/helpers/checkHost.d.ts

@@ -0,0 +1,2 @@
+export declare function checkHost(host: string, matches: (string | RegExp)[]): boolean;
+export declare function hostList(list: unknown, name: string): (string | RegExp)[];

package/dist/esm/helpers/checkHost.js

@@ -0,0 +1,32 @@
+import { configText } from './config.js';
+import { ValidationConfigError } from './errors.js';
+function normalizeHost(host) {
+    const lower = host.toLowerCase();
+    return lower.endsWith('.') ? lower.slice(0, -1) : lower;
+}
+export function checkHost(host, matches) {
+    const normalized = normalizeHost(host);
+    for (const match of matches) {
+        if (typeof match === 'string') {
+            if (normalized === normalizeHost(match))
+                return true;
+            continue;
+        }
+        if (testFromStart(match, normalized)) {
+            return true;
+        }
+    }
+    return false;
+}
+function testFromStart(regex, text) {
+    regex.lastIndex = 0;
+    return regex.test(text);
+}
+export function hostList(list, name) {
+    if (list === undefined || list === null)
+        return [];
+    if (!Array.isArray(list) || !list.every((m) => typeof m === 'string' || m instanceof RegExp)) {
+        throw new ValidationConfigError(`${name} must be an array of strings or RegExps, got ${configText(list)}`);
+    }
+    return list;
+}

package/dist/esm/helpers/config.d.ts

@@ -0,0 +1,10 @@
+export declare function optionsOf<T extends object>(options: T | null | undefined, name?: string): Partial<T>;
+export declare function configText(value: unknown): string;
+export declare function boundsOf<T extends {
+    min?: number;
+    max?: number;
+}>(options: T | null | undefined): {
+    options: Partial<T>;
+    min: number;
+    max: number | undefined;
+};

package/dist/esm/helpers/config.js

@@ -0,0 +1,29 @@
+import { anyToString } from '../convert/any-to-string.js';
+import { ValidationConfigError } from './errors.js';
+export function optionsOf(options, name = 'options') {
+    if (options === undefined || options === null)
+        return {};
+    if (typeof options !== 'object') {
+        throw new ValidationConfigError(`${name} must be an object, got ${configText(options)}`);
+    }
+    return options;
+}
+export function configText(value) {
+    return anyToString(value);
+}
+export function boundsOf(options) {
+    const opts = optionsOf(options);
+    return {
+        options: opts,
+        min: bound(opts.min, 'min') || 0,
+        max: bound(opts.max, 'max'),
+    };
+}
+function bound(value, name) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'symbol' || typeof value === 'function' || typeof value === 'object') {
+        throw new ValidationConfigError(`${name} must be a number, got ${configText(value)}`);
+    }
+    return value;
+}

package/dist/esm/helpers/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class ValidationConfigError extends Error {
+    constructor(message: string);
+}

package/dist/esm/helpers/errors.js

@@ -0,0 +1,6 @@
+export class ValidationConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationConfigError';
+    }
+}