@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/promise.d.ts

@@ -2,7 +2,7 @@
  * Promise validator - validates Promise values
  * Validates that the resolved value matches the inner schema
  */
-import { type ParseResult, type StandardSchemaV1Props } from './base.js';
+import { VldBase, type ParseResult, type StandardSchemaV1Props } from './base.js';
 type PromiseInner<T> = {
     parse(value: unknown): T;
     safeParse(value: unknown): ParseResult<T>;
@@ -18,11 +18,10 @@ type PromiseInner<T> = {
  *
  * Use parseAsync() or safeParseAsync() for proper async handling.
  */
-export declare class VldPromise<T> {
+export declare class VldPromise<T> extends VldBase<unknown, Promise<T>> {
     private readonly inner;
-    readonly validatorType: "promise";
     constructor(inner: PromiseInner<T>);
-    get '~standard'(): StandardSchemaV1Props<unknown, T>;
+    get '~standard'(): StandardSchemaV1Props<unknown, any>;
     /**
      * Check if value is thenable (Promise-like)
      * Must be called BEFORE wrapping in Promise.resolve
@@ -36,14 +35,14 @@ export declare class VldPromise<T> {
      * @throws {Error} If validation fails when Promise resolves
      */
     parse(value: unknown): Promise<T>;
-    parseAsync(value: unknown): Promise<T>;
+    parseAsync(value: unknown): Promise<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>>;
+    safeParse(value: unknown): any;
+    safeParseAsync(value: unknown): Promise<ParseResult<Promise<T>>>;
 }
 /**
  * Create a Promise validator

package/dist/validators/promise.js

@@ -1,111 +1 @@
-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 };
+import{VldBase as e,VLD_VALIDATOR_TYPES as s,ensureVldError as r}from"./base.js";class VldPromise extends e{constructor(e){super(s.PROMISE),this.inner=e}get"~standard"(){return{version:1,vendor:"vld",validate:async e=>{const s=await this.safeParse(e);return s.success?{value:s.data}:{issues:[{message:s.error.message}]}},types:void 0}}_isThenable(e){return null!==e&&"function"==typeof e.then}unwrap(){return this.inner}async parse(e){if(!this._isThenable(e))throw new Error("Expected a Promise value");const s=await Promise.resolve(e);return this.inner.parseAsync?this.inner.parseAsync(s):this.inner.parse(s)}parseAsync(e){return this.parse(e)}safeParse(e){return this._isThenable(e)?(async()=>{try{const s=await Promise.resolve(e);if(this.inner.safeParseAsync)return await this.inner.safeParseAsync(s);const r=this.inner.safeParse(s);return r.success?{success:!0,data:r.data}:r}catch(e){return{success:!1,error:r(e)}}})():Promise.resolve({success:!1,error:r("Expected a Promise value")})}safeParseAsync(e){return this.safeParse(e)}}function n(e){return new VldPromise(e)}export{VldPromise,n as promise};

package/dist/validators/record.d.ts

@@ -3,45 +3,50 @@ import { VldBase, ParseResult } from './base.js';
  * Immutable record validator for key-value pairs
  * BUG-NEW-018 FIX: Uses comprehensive dangerous key protection
  */
-export declare class VldRecord<T> extends VldBase<unknown, Record<string, T>> {
+export declare class VldRecord<T, K extends PropertyKey = string> extends VldBase<unknown, Record<K, T>> {
     protected readonly valueValidator: VldBase<unknown, T>;
+    private readonly keyValidator?;
     private readonly errorMessage?;
     /**
      * Private constructor to enforce immutability
      */
-    protected constructor(valueValidator: VldBase<unknown, T>, errorMessage?: string | undefined);
+    protected constructor(valueValidator: VldBase<unknown, T>, keyValidator?: VldBase<unknown, K> | undefined, errorMessage?: string | undefined);
     private readonly _simpleValueMode;
     private readonly _simpleValue;
     get valueSchema(): VldBase<unknown, T>;
+    get keySchema(): VldBase<unknown, K> | undefined;
+    get valueType(): VldBase<unknown, T>;
+    get keyType(): VldBase<unknown, K> | undefined;
     /**
      * Create a new record validator
      */
-    static create<T>(valueValidator: VldBase<unknown, T>): VldRecord<T>;
+    static create<T, K extends PropertyKey = string>(valueValidator: VldBase<unknown, T>, keyValidator?: VldBase<unknown, K>): VldRecord<T, K>;
     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(value: unknown): Record<K, 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>;
+    parseKnownRecord(obj: Record<string, unknown>): Record<K, T>;
+    private parseKeyedRecord;
     /**
      * Safely parse and validate a record value
      */
-    safeParse(value: unknown): ParseResult<Record<string, T>>;
+    safeParse(value: unknown): ParseResult<Record<K, T>>;
     /**
      * Create a partial record variant (all keys optional)
      * Similar to v.object().partial() but for records
      */
-    partial(): VldRecord<T | undefined>;
+    partial(): VldRecord<T | undefined, K>;
     /**
      * 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(): VldBase<unknown, Record<string, T>>;
+    loose(): VldBase<unknown, Record<K, T>>;
 }

package/dist/validators/record.js

@@ -1,258 +1 @@
-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 };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{i}from"../chunks/security-Dy24T8N7.js";import{V as a}from"../chunks/errors-core-CerMg2rq.js";function o(e){return new a([{code:"invalid_object",path:[],message:e}])}class VldRecord extends e{constructor(e,t,i){super(r.RECORD),this.valueValidator=e,this.keyValidator=t,this.errorMessage=i,this._simpleValueMode=this.getSimpleValueMode(e),this._simpleValue="literal"===this._simpleValueMode?e.literal:void 0}get valueSchema(){return this.valueValidator}get keySchema(){return this.keyValidator}get valueType(){return this.valueValidator}get keyType(){return this.keyValidator}static create(e,r){return new VldRecord(e,r)}getSimpleValueMode(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleValueError(e){switch(this._simpleValueMode){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof e;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(this._simpleValue),JSON.stringify(e));default:return t().invalidRecord}}parse(e){if("object"!=typeof e||null===e||Array.isArray(e))throw new Error(this.errorMessage||t().invalidRecord);return this.parseKnownRecord(e)}parseKnownRecord(e){if(void 0!==this.keyValidator)return this.parseKeyedRecord(e);const r={},a=Object.keys(e),o=this._simpleValueMode;for(let s=0;s<a.length;s++){const n=a[s];if(i(n))continue;const l=e[n];if(void 0!==o)switch(o){case"string":if("string"!=typeof l)throw new Error(t().objectField(n,t().invalidString));r[n]=l;continue;case"number":if("number"!=typeof l||isNaN(l))throw new Error(t().objectField(n,t().invalidNumber));r[n]=l;continue;case"boolean":if("boolean"!=typeof l)throw new Error(t().objectField(n,t().invalidBoolean));r[n]=l;continue;case"bigint":if("bigint"!=typeof l)throw new Error(t().objectField(n,t().invalidBigint));r[n]=l;continue;case"symbol":if("symbol"!=typeof l)throw new Error(t().objectField(n,t().invalidSymbol));r[n]=l;continue;case"null":if(null!==l)throw new Error(t().objectField(n,this.getSimpleValueError(l)));r[n]=null;continue;case"undefinedValue":if(void 0!==l)throw new Error(t().objectField(n,t().expectedUndefined));r[n]=void 0;continue;case"literal":if(l!==this._simpleValue)throw new Error(t().objectField(n,this.getSimpleValueError(l)));r[n]=this._simpleValue;continue;case"passthrough":r[n]=l;continue}try{r[n]=this.valueValidator.parse(l)}catch(e){throw new Error(t().objectField(n,e.message))}}return r}parseKeyedRecord(e){const r={},o=Reflect.ownKeys(e);for(const s of o){if(!Object.prototype.propertyIsEnumerable.call(e,s))continue;if("string"==typeof s&&i(s))continue;const o=this.keyValidator.safeParse(s);if(!o.success)throw new a([{code:"invalid_key",path:[String(s)],message:o.error.message}]);if("string"!=typeof o.data&&"number"!=typeof o.data&&"symbol"!=typeof o.data)throw new a([{code:"invalid_key",path:[String(s)],message:"Record key transform must return a property key"}]);if("string"!=typeof o.data||!i(o.data))try{r[o.data]=this.valueValidator.parse(e[s])}catch(e){throw new Error(t().objectField(String(s),e.message))}}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return e instanceof a?{success:!1,error:e}:{success:!1,error:o(e.message)}}}partial(){const e=this.valueValidator.optional();return new VldRecord(e,this.keyValidator)}loose(){return new VldLooseRecord(this.valueValidator,this.keyValidator)}}class VldLooseRecord extends e{constructor(e,t){super(r.RECORD),this.valueValidator=e,this.keyValidator=t}get valueSchema(){return this.valueValidator}parse(e){if("object"!=typeof e||null===e||Array.isArray(e))throw new Error(t().invalidRecord);const r={},a=e;for(const e of Reflect.ownKeys(a)){if(!Object.prototype.propertyIsEnumerable.call(a,e))continue;if("string"==typeof e&&i(e))continue;const t=this.keyValidator?.safeParse(e);if(t&&!t.success)continue;const o=t?.data??e;if("string"!=typeof o&&"number"!=typeof o&&"symbol"!=typeof o)continue;if("string"==typeof o&&i(o))continue;const s=this.valueValidator.safeParse(a[e]);s.success&&(r[o]=s.data)}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:o(e.message)}}}partial(){const e=this.valueValidator.optional();return new VldLooseRecord(e,this.keyValidator)}loose(){return this}}export{VldRecord};

package/dist/validators/set.d.ts

@@ -5,6 +5,7 @@ import { VldBase, ParseResult } from './base.js';
 export declare class VldSet<T> extends VldBase<unknown, Set<T>> {
     private readonly itemValidator;
     private readonly errorMessage?;
+    private readonly _checks;
     /**
      * Private constructor to enforce immutability
      */
@@ -31,4 +32,8 @@ export declare class VldSet<T> extends VldBase<unknown, Set<T>> {
      * Safely parse and validate a Set value
      */
     safeParse(value: unknown): ParseResult<Set<T>>;
+    min(size: number, message?: string): VldSet<T>;
+    max(size: number, message?: string): VldSet<T>;
+    size(size: number, message?: string): VldSet<T>;
+    nonempty(message?: string): VldSet<T>;
 }