@oxog/vld 2.0.3 → 2.1.0

package/dist/cjs/validators/promise.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+require('../registry.cjs');
+
+/**
+ * Promise validator - validates Promise values
+ * Validates that the resolved value matches the inner schema
+ */
+/**
+ * Promise validator - validates Promise<T> where T matches inner schema
+ * Zod 4 API parity - allows async validation with proper type inference
+ *
+ * Validates that the input is a Promise, and validates the resolved value
+ * against the inner schema when parsed.
+ *
+ * Use parseAsync() or safeParseAsync() for proper async handling.
+ */
+class VldPromise {
+    constructor(inner) {
+        this.inner = inner;
+        this.validatorType = validators_base.VLD_VALIDATOR_TYPES.PROMISE;
+    }
+    get '~standard'() {
+        return {
+            version: 1,
+            vendor: 'vld',
+            validate: async (value) => {
+                const result = await this.safeParseAsync(value);
+                if (result.success) {
+                    return { value: result.data };
+                }
+                return { issues: [{ message: result.error.message }] };
+            },
+            types: undefined
+        };
+    }
+    /**
+     * Check if value is thenable (Promise-like)
+     * Must be called BEFORE wrapping in Promise.resolve
+     */
+    _isThenable(value) {
+        return value !== null && typeof value.then === 'function';
+    }
+    unwrap() {
+        return this.inner;
+    }
+    /**
+     * Parse and validate a Promise value asynchronously
+     * @param value The Promise to validate
+     * @returns The validated value
+     * @throws {Error} If validation fails when Promise resolves
+     */
+    async parse(value) {
+        // Check if value is thenable BEFORE wrapping in Promise.resolve
+        if (!this._isThenable(value)) {
+            throw new Error('Expected a Promise value');
+        }
+        // Now we can safely await it
+        const resolved = await Promise.resolve(value);
+        return this.inner.parseAsync ? this.inner.parseAsync(resolved) : this.inner.parse(resolved);
+    }
+    parseAsync(value) {
+        return this.parse(value);
+    }
+    /**
+     * Safely parse and validate a Promise value asynchronously
+     * @param value The Promise to validate
+     * @returns A Promise resolving to ParseResult containing the validated value
+     */
+    async safeParse(value) {
+        // Check if value is thenable BEFORE wrapping in Promise.resolve
+        if (!this._isThenable(value)) {
+            return {
+                success: false,
+                error: new Error('Expected a Promise value')
+            };
+        }
+        try {
+            const resolved = await Promise.resolve(value);
+            if (this.inner.safeParseAsync) {
+                return await this.inner.safeParseAsync(resolved);
+            }
+            const innerResult = this.inner.safeParse(resolved);
+            if (!innerResult.success) {
+                return innerResult;
+            }
+            return { success: true, data: innerResult.data };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err : new Error(String(err))
+            };
+        }
+    }
+    safeParseAsync(value) {
+        return this.safeParse(value);
+    }
+}
+/**
+ * Create a Promise validator
+ * @param inner The schema to validate the resolved value against
+ * @returns A new Promise validator
+ * @example
+ * const promiseSchema = v.promise(v.string());
+ * const result = await promiseSchema.parse(Promise.resolve("hello"));
+ * // result is string
+ */
+function promise(inner) {
+    return new VldPromise(inner);
+}
+
+exports.VldPromise = VldPromise;
+exports.promise = promise;

package/dist/cjs/validators/record.cjs

@@ -0,0 +1,262 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var security = require('../chunks/security-Dc3Jh13T.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+function createRecordError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_object', path: [], message }]);
+}
+/**
+ * Immutable record validator for key-value pairs
+ * BUG-NEW-018 FIX: Uses comprehensive dangerous key protection
+ */
+class VldRecord extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(valueValidator, errorMessage) {
+        super(validators_base.VLD_VALIDATOR_TYPES.RECORD);
+        this.valueValidator = valueValidator;
+        this.errorMessage = errorMessage;
+        this._simpleValueMode = this.getSimpleValueMode(valueValidator);
+        this._simpleValue = this._simpleValueMode === 'literal' ? valueValidator.literal : undefined;
+    }
+    get valueSchema() {
+        return this.valueValidator;
+    }
+    /**
+     * Create a new record validator
+     */
+    static create(valueValidator) {
+        return new VldRecord(valueValidator);
+    }
+    getSimpleValueMode(valueValidator) {
+        if (valueValidator.isSimple !== true) {
+            return undefined;
+        }
+        switch (valueValidator.validatorType) {
+            case validators_base.VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case validators_base.VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case validators_base.VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case validators_base.VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case validators_base.VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case validators_base.VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case validators_base.VLD_VALIDATOR_TYPES.UNDEFINED:
+            case validators_base.VLD_VALIDATOR_TYPES.VOID:
+                return 'undefinedValue';
+            case validators_base.VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case validators_base.VLD_VALIDATOR_TYPES.ANY:
+            case validators_base.VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    getSimpleValueError(received) {
+        switch (this._simpleValueMode) {
+            case 'string':
+                return locales_runtime.getMessages().invalidString;
+            case 'number':
+                return locales_runtime.getMessages().invalidNumber;
+            case 'boolean':
+                return locales_runtime.getMessages().invalidBoolean;
+            case 'bigint':
+                return locales_runtime.getMessages().invalidBigint;
+            case 'symbol':
+                return locales_runtime.getMessages().invalidSymbol;
+            case 'null':
+                return `Expected null, received ${typeof received}`;
+            case 'undefinedValue':
+                return locales_runtime.getMessages().expectedUndefined;
+            case 'literal':
+                return locales_runtime.getMessages().literalExpected(JSON.stringify(this._simpleValue), JSON.stringify(received));
+            default:
+                return locales_runtime.getMessages().invalidRecord;
+        }
+    }
+    /**
+     * Parse and validate a record value
+     * BUG-NEW-018 FIX: Use comprehensive dangerous key protection
+     */
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error(this.errorMessage || locales_runtime.getMessages().invalidRecord);
+        }
+        return this.parseKnownRecord(value);
+    }
+    /**
+     * Parse a value that has already passed the record object type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownRecord(obj) {
+        const result = {};
+        const keys = Object.keys(obj);
+        const simpleMode = this._simpleValueMode;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // Skip dangerous keys to prevent prototype pollution
+            // Now using comprehensive protection from shared utility
+            if (security.isDangerousKey(key)) {
+                continue;
+            }
+            const val = obj[key];
+            if (simpleMode !== undefined) {
+                switch (simpleMode) {
+                    case 'string':
+                        if (typeof val !== 'string') {
+                            throw new Error(locales_runtime.getMessages().objectField(key, locales_runtime.getMessages().invalidString));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'number':
+                        if (typeof val !== 'number' || isNaN(val)) {
+                            throw new Error(locales_runtime.getMessages().objectField(key, locales_runtime.getMessages().invalidNumber));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'boolean':
+                        if (typeof val !== 'boolean') {
+                            throw new Error(locales_runtime.getMessages().objectField(key, locales_runtime.getMessages().invalidBoolean));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'bigint':
+                        if (typeof val !== 'bigint') {
+                            throw new Error(locales_runtime.getMessages().objectField(key, locales_runtime.getMessages().invalidBigint));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'symbol':
+                        if (typeof val !== 'symbol') {
+                            throw new Error(locales_runtime.getMessages().objectField(key, locales_runtime.getMessages().invalidSymbol));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'null':
+                        if (val !== null) {
+                            throw new Error(locales_runtime.getMessages().objectField(key, this.getSimpleValueError(val)));
+                        }
+                        result[key] = null;
+                        continue;
+                    case 'undefinedValue':
+                        if (val !== undefined) {
+                            throw new Error(locales_runtime.getMessages().objectField(key, locales_runtime.getMessages().expectedUndefined));
+                        }
+                        result[key] = undefined;
+                        continue;
+                    case 'literal':
+                        if (val !== this._simpleValue) {
+                            throw new Error(locales_runtime.getMessages().objectField(key, this.getSimpleValueError(val)));
+                        }
+                        result[key] = this._simpleValue;
+                        continue;
+                    case 'passthrough':
+                        result[key] = val;
+                        continue;
+                }
+            }
+            try {
+                result[key] = this.valueValidator.parse(val);
+            }
+            catch (error) {
+                throw new Error(locales_runtime.getMessages().objectField(key, error.message));
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a record value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createRecordError(error.message) };
+        }
+    }
+    /**
+     * Create a partial record variant (all keys optional)
+     * Similar to v.object().partial() but for records
+     */
+    partial() {
+        const optionalValidator = this.valueValidator.optional();
+        return new VldRecord(optionalValidator);
+    }
+    /**
+     * Create a loose record variant (allows extra keys)
+     * Similar to v.object().passthrough() but for records
+     * Note: Records already allow any keys, so this mainly affects error handling
+     */
+    loose() {
+        // For records, "loose" means we don't throw errors for validation failures
+        // We return a modified version that catches validation errors
+        return new VldLooseRecord(this.valueValidator);
+    }
+}
+/**
+ * Loose record variant that allows validation failures
+ * Used internally by .loose() method
+ */
+class VldLooseRecord extends validators_base.VldBase {
+    constructor(valueValidator) {
+        super(validators_base.VLD_VALIDATOR_TYPES.RECORD);
+        this.valueValidator = valueValidator;
+    }
+    get valueSchema() {
+        return this.valueValidator;
+    }
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error(locales_runtime.getMessages().invalidRecord);
+        }
+        const result = {};
+        const obj = value;
+        for (const [key, val] of Object.entries(obj)) {
+            // Skip dangerous keys
+            if (security.isDangerousKey(key)) {
+                continue;
+            }
+            // For loose records, skip invalid values instead of throwing
+            const parseResult = this.valueValidator.safeParse(val);
+            if (parseResult.success) {
+                result[key] = parseResult.data;
+            }
+        }
+        return result;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createRecordError(error.message) };
+        }
+    }
+    /**
+     * Create a partial variant (all keys optional)
+     */
+    partial() {
+        const optionalValidator = this.valueValidator.optional();
+        return new VldLooseRecord(optionalValidator);
+    }
+    /**
+     * Return self (already loose)
+     */
+    loose() {
+        return this;
+    }
+}
+
+exports.VldRecord = VldRecord;

package/dist/cjs/validators/set.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+function createSetError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable Set validator
+ */
+class VldSet extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(itemValidator, errorMessage) {
+        super(validators_base.VLD_VALIDATOR_TYPES.SET);
+        this.itemValidator = itemValidator;
+        this.errorMessage = errorMessage;
+        this._simpleItemMode = this.getSimpleItemMode(itemValidator);
+        this._simpleItemValue = this._simpleItemMode === 'literal' ? itemValidator.literal : undefined;
+    }
+    get itemSchema() {
+        return this.itemValidator;
+    }
+    /**
+     * Create a new Set validator
+     */
+    static create(itemValidator) {
+        return new VldSet(itemValidator);
+    }
+    getSimpleItemMode(itemValidator) {
+        if (itemValidator.isSimple !== true) {
+            return undefined;
+        }
+        switch (itemValidator.validatorType) {
+            case validators_base.VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case validators_base.VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case validators_base.VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case validators_base.VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case validators_base.VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case validators_base.VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case validators_base.VLD_VALIDATOR_TYPES.UNDEFINED:
+            case validators_base.VLD_VALIDATOR_TYPES.VOID:
+                return 'undefinedValue';
+            case validators_base.VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case validators_base.VLD_VALIDATOR_TYPES.ANY:
+            case validators_base.VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    getSimpleItemError(received) {
+        switch (this._simpleItemMode) {
+            case 'string':
+                return locales_runtime.getMessages().invalidString;
+            case 'number':
+                return locales_runtime.getMessages().invalidNumber;
+            case 'boolean':
+                return locales_runtime.getMessages().invalidBoolean;
+            case 'bigint':
+                return locales_runtime.getMessages().invalidBigint;
+            case 'symbol':
+                return locales_runtime.getMessages().invalidSymbol;
+            case 'null':
+                return `Expected null, received ${typeof received}`;
+            case 'undefinedValue':
+                return locales_runtime.getMessages().expectedUndefined;
+            case 'literal':
+                return locales_runtime.getMessages().literalExpected(JSON.stringify(this._simpleItemValue), JSON.stringify(received));
+            default:
+                return locales_runtime.getMessages().invalidSet;
+        }
+    }
+    /**
+     * Parse and validate a Set value
+     */
+    parse(value) {
+        if (!(value instanceof Set)) {
+            throw new Error(this.errorMessage || locales_runtime.getMessages().invalidSet);
+        }
+        return this.parseKnownSet(value);
+    }
+    /**
+     * Parse a value that has already passed the Set instance guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownSet(value) {
+        const result = new Set();
+        const simpleMode = this._simpleItemMode;
+        if (simpleMode === 'string') {
+            for (const item of value) {
+                if (typeof item !== 'string') {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(item);
+            }
+            return result;
+        }
+        if (simpleMode === 'number') {
+            for (const item of value) {
+                if (typeof item !== 'number' || isNaN(item)) {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(item);
+            }
+            return result;
+        }
+        if (simpleMode === 'boolean') {
+            for (const item of value) {
+                if (typeof item !== 'boolean') {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(item);
+            }
+            return result;
+        }
+        if (simpleMode === 'bigint') {
+            for (const item of value) {
+                if (typeof item !== 'bigint') {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(item);
+            }
+            return result;
+        }
+        if (simpleMode === 'symbol') {
+            for (const item of value) {
+                if (typeof item !== 'symbol') {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(item);
+            }
+            return result;
+        }
+        if (simpleMode === 'null') {
+            for (const item of value) {
+                if (item !== null) {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(null);
+            }
+            return result;
+        }
+        if (simpleMode === 'undefinedValue') {
+            for (const item of value) {
+                if (item !== undefined) {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(undefined);
+            }
+            return result;
+        }
+        if (simpleMode === 'literal') {
+            for (const item of value) {
+                if (item !== this._simpleItemValue) {
+                    throw new Error(this.getSimpleItemError(item));
+                }
+                result.add(this._simpleItemValue);
+            }
+            return result;
+        }
+        if (simpleMode === 'passthrough') {
+            for (const item of value) {
+                result.add(item);
+            }
+            return result;
+        }
+        for (const item of value) {
+            try {
+                result.add(this.itemValidator.parse(item));
+            }
+            catch (error) {
+                throw new Error(error.message);
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a Set value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createSetError(error.message) };
+        }
+    }
+}
+
+exports.VldSet = VldSet;

package/dist/cjs/validators/string-bool.cjs

@@ -0,0 +1,124 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Default truthy and falsy value sets
+ */
+const DEFAULT_TRUTHY = ['true', '1', 'yes', 'on', 'y', 'enabled'];
+const DEFAULT_FALSY = ['false', '0', 'no', 'off', 'n', 'disabled'];
+/**
+ * Immutable string boolean validator for flexible boolean parsing
+ * Supports string representations like "true", "yes", "on", "1", etc.
+ */
+class VldStringBool extends validators_base.VldBase {
+    constructor(options) {
+        super(validators_base.VLD_VALIDATOR_TYPES.STRING_BOOL);
+        this.options = options;
+        this.truthyValues = options.truthy ?? DEFAULT_TRUTHY;
+        this.falsyValues = options.falsy ?? DEFAULT_FALSY;
+        const normalizedTruthy = this.normalizeValues(this.truthyValues);
+        const normalizedFalsy = this.normalizeValues(this.falsyValues);
+        this.normalizedTruthySet = new Set(normalizedTruthy);
+        this.normalizedFalsySet = new Set(normalizedFalsy);
+        this.validValuesText = [...normalizedTruthy, ...normalizedFalsy].join(', ');
+    }
+    /**
+     * Create a new string boolean validator
+     */
+    static create(options = {}) {
+        return new VldStringBool(options);
+    }
+    /**
+     * Normalize a string value based on case sensitivity setting
+     */
+    normalizeValue(value) {
+        return this.options.caseSensitive ? value : value.toLowerCase();
+    }
+    normalizeValues(values) {
+        if (this.options.caseSensitive) {
+            return values;
+        }
+        return values.map(value => value.toLowerCase());
+    }
+    /**
+     * Parse and validate a string boolean value
+     */
+    parse(value) {
+        // First, ensure we have a string
+        if (typeof value !== 'string') {
+            // Also accept actual boolean values for convenience
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            throw new Error(locales_runtime.getMessages().stringExpected(typeof value, 'string'));
+        }
+        const normalized = this.normalizeValue(value);
+        // Check if value is in truthy set
+        if (this.normalizedTruthySet.has(normalized)) {
+            return true;
+        }
+        // Check if value is in falsy set
+        if (this.normalizedFalsySet.has(normalized)) {
+            return false;
+        }
+        // Value is not recognized
+        throw new Error(locales_runtime.getMessages().stringBoolExpected(this.validValuesText, value));
+    }
+    /**
+     * Safely parse and validate a string boolean value
+     */
+    safeParse(value) {
+        try {
+            const result = this.parse(value);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+    /**
+     * Create a new validator with custom truthy values
+     */
+    withTruthy(values) {
+        return new VldStringBool({
+            ...this.options,
+            truthy: values
+        });
+    }
+    /**
+     * Create a new validator with custom falsy values
+     */
+    withFalsy(values) {
+        return new VldStringBool({
+            ...this.options,
+            falsy: values
+        });
+    }
+    /**
+     * Create a new validator with case-sensitive matching
+     */
+    caseSensitive() {
+        return new VldStringBool({
+            ...this.options,
+            caseSensitive: true
+        });
+    }
+    /**
+     * Create a new validator with case-insensitive matching (default)
+     */
+    caseInsensitive() {
+        return new VldStringBool({
+            ...this.options,
+            caseSensitive: false
+        });
+    }
+}
+
+exports.VldStringBool = VldStringBool;