@oxog/vld 2.0.2 → 2.1.0

package/dist/validators/promise.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Promise validator - validates Promise values
+ * Validates that the resolved value matches the inner schema
+ */
+import { type ParseResult, type StandardSchemaV1Props } from './base.js';
+type PromiseInner<T> = {
+    parse(value: unknown): T;
+    safeParse(value: unknown): ParseResult<T>;
+    parseAsync?(value: unknown): Promise<T>;
+    safeParseAsync?(value: unknown): Promise<ParseResult<T>>;
+};
+/**
+ * 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.
+ */
+export declare class VldPromise<T> {
+    private readonly inner;
+    readonly validatorType: "promise";
+    constructor(inner: PromiseInner<T>);
+    get '~standard'(): StandardSchemaV1Props<unknown, T>;
+    /**
+     * Check if value is thenable (Promise-like)
+     * Must be called BEFORE wrapping in Promise.resolve
+     */
+    private _isThenable;
+    unwrap(): PromiseInner<T>;
+    /**
+     * 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
+     */
+    parse(value: unknown): Promise<T>;
+    parseAsync(value: unknown): Promise<T>;
+    /**
+     * Safely parse and validate a Promise value asynchronously
+     * @param value The Promise to validate
+     * @returns A Promise resolving to ParseResult containing the validated value
+     */
+    safeParse(value: unknown): Promise<ParseResult<T>>;
+    safeParseAsync(value: unknown): Promise<ParseResult<T>>;
+}
+/**
+ * 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
+ */
+export declare function promise<T>(inner: PromiseInner<T>): VldPromise<T>;
+export {};

package/dist/validators/promise.js

@@ -0,0 +1,111 @@
+import { VLD_VALIDATOR_TYPES } from './base.js';
+
+/**
+ * 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 = 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);
+}
+
+export { VldPromise, promise };

package/dist/validators/record.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable record validator for key-value pairs
  * BUG-NEW-018 FIX: Uses comprehensive dangerous key protection
@@ -10,15 +10,25 @@ export declare class VldRecord<T> extends VldBase<unknown, Record<string, T>> {
      * Private constructor to enforce immutability
      */
     protected constructor(valueValidator: VldBase<unknown, T>, errorMessage?: string | undefined);
+    private readonly _simpleValueMode;
+    private readonly _simpleValue;
+    get valueSchema(): VldBase<unknown, T>;
     /**
      * Create a new record validator
      */
     static create<T>(valueValidator: VldBase<unknown, T>): VldRecord<T>;
+    private getSimpleValueMode;
+    private getSimpleValueError;
     /**
      * Parse and validate a record value
      * BUG-NEW-018 FIX: Use comprehensive dangerous key protection
      */
     parse(value: unknown): Record<string, T>;
+    /**
+     * 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: Record<string, unknown>): Record<string, T>;
     /**
      * Safely parse and validate a record value
      */
@@ -35,4 +45,3 @@ export declare class VldRecord<T> extends VldBase<unknown, Record<string, T>> {
      */
     loose(): VldBase<unknown, Record<string, T>>;
 }
-//# sourceMappingURL=record.d.ts.map

package/dist/validators/record.js

@@ -0,0 +1,258 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+import { i as isDangerousKey } from '../chunks/security-B0Pd_vSY.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+function createRecordError(message) {
+    return new 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 VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(valueValidator, errorMessage) {
+        super(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 VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case VLD_VALIDATOR_TYPES.UNDEFINED:
+            case VLD_VALIDATOR_TYPES.VOID:
+                return 'undefinedValue';
+            case VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case VLD_VALIDATOR_TYPES.ANY:
+            case VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    getSimpleValueError(received) {
+        switch (this._simpleValueMode) {
+            case 'string':
+                return getMessages().invalidString;
+            case 'number':
+                return getMessages().invalidNumber;
+            case 'boolean':
+                return getMessages().invalidBoolean;
+            case 'bigint':
+                return getMessages().invalidBigint;
+            case 'symbol':
+                return getMessages().invalidSymbol;
+            case 'null':
+                return `Expected null, received ${typeof received}`;
+            case 'undefinedValue':
+                return getMessages().expectedUndefined;
+            case 'literal':
+                return getMessages().literalExpected(JSON.stringify(this._simpleValue), JSON.stringify(received));
+            default:
+                return 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 || 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 (isDangerousKey(key)) {
+                continue;
+            }
+            const val = obj[key];
+            if (simpleMode !== undefined) {
+                switch (simpleMode) {
+                    case 'string':
+                        if (typeof val !== 'string') {
+                            throw new Error(getMessages().objectField(key, getMessages().invalidString));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'number':
+                        if (typeof val !== 'number' || isNaN(val)) {
+                            throw new Error(getMessages().objectField(key, getMessages().invalidNumber));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'boolean':
+                        if (typeof val !== 'boolean') {
+                            throw new Error(getMessages().objectField(key, getMessages().invalidBoolean));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'bigint':
+                        if (typeof val !== 'bigint') {
+                            throw new Error(getMessages().objectField(key, getMessages().invalidBigint));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'symbol':
+                        if (typeof val !== 'symbol') {
+                            throw new Error(getMessages().objectField(key, getMessages().invalidSymbol));
+                        }
+                        result[key] = val;
+                        continue;
+                    case 'null':
+                        if (val !== null) {
+                            throw new Error(getMessages().objectField(key, this.getSimpleValueError(val)));
+                        }
+                        result[key] = null;
+                        continue;
+                    case 'undefinedValue':
+                        if (val !== undefined) {
+                            throw new Error(getMessages().objectField(key, getMessages().expectedUndefined));
+                        }
+                        result[key] = undefined;
+                        continue;
+                    case 'literal':
+                        if (val !== this._simpleValue) {
+                            throw new Error(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(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 VldBase {
+    constructor(valueValidator) {
+        super(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(getMessages().invalidRecord);
+        }
+        const result = {};
+        const obj = value;
+        for (const [key, val] of Object.entries(obj)) {
+            // Skip dangerous keys
+            if (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;
+    }
+}
+
+export { VldRecord };

package/dist/validators/set.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable Set validator
  */
@@ -9,17 +9,26 @@ export declare class VldSet<T> extends VldBase<unknown, Set<T>> {
      * Private constructor to enforce immutability
      */
     private constructor();
+    private readonly _simpleItemMode;
+    private readonly _simpleItemValue;
+    get itemSchema(): VldBase<unknown, T>;
     /**
      * Create a new Set validator
      */
     static create<T>(itemValidator: VldBase<unknown, T>): VldSet<T>;
+    private getSimpleItemMode;
+    private getSimpleItemError;
     /**
      * Parse and validate a Set value
      */
     parse(value: unknown): Set<T>;
+    /**
+     * Parse a value that has already passed the Set instance guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownSet(value: Set<unknown>): Set<T>;
     /**
      * Safely parse and validate a Set value
      */
     safeParse(value: unknown): ParseResult<Set<T>>;
 }
-//# sourceMappingURL=set.d.ts.map

package/dist/validators/set.js

@@ -0,0 +1,199 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+function createSetError(message) {
+    return new VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable Set validator
+ */
+class VldSet extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(itemValidator, errorMessage) {
+        super(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 VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case VLD_VALIDATOR_TYPES.UNDEFINED:
+            case VLD_VALIDATOR_TYPES.VOID:
+                return 'undefinedValue';
+            case VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case VLD_VALIDATOR_TYPES.ANY:
+            case VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    getSimpleItemError(received) {
+        switch (this._simpleItemMode) {
+            case 'string':
+                return getMessages().invalidString;
+            case 'number':
+                return getMessages().invalidNumber;
+            case 'boolean':
+                return getMessages().invalidBoolean;
+            case 'bigint':
+                return getMessages().invalidBigint;
+            case 'symbol':
+                return getMessages().invalidSymbol;
+            case 'null':
+                return `Expected null, received ${typeof received}`;
+            case 'undefinedValue':
+                return getMessages().expectedUndefined;
+            case 'literal':
+                return getMessages().literalExpected(JSON.stringify(this._simpleItemValue), JSON.stringify(received));
+            default:
+                return getMessages().invalidSet;
+        }
+    }
+    /**
+     * Parse and validate a Set value
+     */
+    parse(value) {
+        if (!(value instanceof Set)) {
+            throw new Error(this.errorMessage || 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) };
+        }
+    }
+}
+
+export { VldSet };