@oxog/vld 2.0.1 → 2.0.3

package/dist/chunks/{json-nIhyRPOU.js → json-Cp4WO0M9.js}

@@ -1,5 +1,5 @@
-import { i as VldBase, t as getMessages, V as VldString, a as VldNumber, b as VldBoolean, c as VldDate, e as VldOptional } from './bigint-ZKkWLdmi.js';
-import { c as VldCoerceString, b as VldCoerceNumber, a as VldCoerceBoolean, V as VldCoerceDate } from './date-7Iz2BGsL.js';
+import { i as VldBase, u as getMessages, h as VldString, c as VldNumber, a as VldBoolean, b as VldDate, f as VldOptional } from './bigint-CRS0QVsy.js';
+import { c as VldCoerceString, b as VldCoerceNumber, a as VldCoerceBoolean, V as VldCoerceDate } from './date-50JV_Mfj.js';
 
 /**
  * Default truthy and falsy value sets
@@ -170,16 +170,9 @@ class VldArray extends VldBase {
             }
             result[i] = parseResult.data; // Direct assignment is faster than push
         }
-        // Check uniqueness if required
+        // Check uniqueness if required - optimized with Map-based approach
         if (this.config.unique) {
-            const seen = new Set();
-            for (const item of result) {
-                const key = typeof item === 'object' ? this.stableStringify(item) : item;
-                if (seen.has(key)) {
-                    throw new Error('Array must contain unique items');
-                }
-                seen.add(key);
-            }
+            this.checkUnique(result);
         }
         return result;
     }
@@ -194,6 +187,38 @@ class VldArray extends VldBase {
             return { success: false, error: error };
         }
     }
+    /**
+     * Optimized uniqueness check using Map-based approach
+     * Avoids repeated stableStringify calls by caching serialized values
+     */
+    checkUnique(items) {
+        const seen = new Set(); // Set of seen keys
+        const objectKeys = new WeakMap(); // Cache for object->string mappings
+        for (const item of items) {
+            let key;
+            if (typeof item === 'object' && item !== null) {
+                // Check if we've already serialized this object reference
+                const cached = objectKeys.get(item);
+                if (cached !== undefined) {
+                    key = cached;
+                }
+                else {
+                    // Serialize and cache
+                    const serialized = this.stableStringify(item);
+                    key = serialized;
+                    objectKeys.set(item, serialized);
+                }
+            }
+            else {
+                // Primitives can be used directly as keys
+                key = item;
+            }
+            if (seen.has(key)) {
+                throw new Error('Array must contain unique items');
+            }
+            seen.add(key);
+        }
+    }
     /**
      * Create a stable string representation of an object for hashing
      * Handles circular references and deep nesting gracefully
@@ -321,11 +346,17 @@ class VldEnum extends VldBase {
     /**
      * Private constructor to enforce immutability
      */
-    constructor(values, errorMessage) {
+    constructor(_values, errorMessage) {
         super();
-        this.values = values;
+        this._values = _values;
         this.errorMessage = errorMessage;
     }
+    /**
+     * Get the enum values
+     */
+    get values() {
+        return this._values;
+    }
     /**
      * Create a new enum validator
      */
@@ -339,11 +370,11 @@ class VldEnum extends VldBase {
         // BUG-002 FIX: Add type check before includes() to prevent type confusion
         if (typeof value !== 'string') {
             throw new Error(this.errorMessage ||
-                getMessages().enumExpected([...this.values], JSON.stringify(value)));
+                getMessages().enumExpected([...this._values], JSON.stringify(value)));
         }
-        if (!this.values.includes(value)) {
+        if (!this._values.includes(value)) {
             throw new Error(this.errorMessage ||
-                getMessages().enumExpected([...this.values], JSON.stringify(value)));
+                getMessages().enumExpected([...this._values], JSON.stringify(value)));
         }
         return value;
     }
@@ -356,16 +387,16 @@ class VldEnum extends VldBase {
             return {
                 success: false,
                 error: new Error(this.errorMessage ||
-                    getMessages().enumExpected([...this.values], JSON.stringify(value)))
+                    getMessages().enumExpected([...this._values], JSON.stringify(value)))
             };
         }
-        if (this.values.includes(value)) {
+        if (this._values.includes(value)) {
             return { success: true, data: value };
         }
         return {
             success: false,
             error: new Error(this.errorMessage ||
-                getMessages().enumExpected([...this.values], JSON.stringify(value)))
+                getMessages().enumExpected([...this._values], JSON.stringify(value)))
         };
     }
     /**
@@ -373,7 +404,7 @@ class VldEnum extends VldBase {
      * Creates a new enum validator without the specified values
      */
     exclude(...excludeValues) {
-        const filtered = this.values.filter(v => !excludeValues.includes(v));
+        const filtered = this._values.filter(v => !excludeValues.includes(v));
         if (filtered.length === 0) {
             throw new Error('Cannot exclude all enum values');
         }
@@ -385,7 +416,7 @@ class VldEnum extends VldBase {
      * Creates a new enum validator with only the specified values
      */
     extract(...extractValues) {
-        const extracted = this.values.filter(v => extractValues.includes(v));
+        const extracted = this._values.filter(v => extractValues.includes(v));
         if (extracted.length === 0) {
             throw new Error('Cannot extract non-existent enum values');
         }
@@ -404,10 +435,30 @@ class VldObject extends VldBase {
      */
     constructor(config) {
         super();
-        this.config = config;
+        this._config = config;
         // Pre-compute shape keys for faster access
-        this.shapeKeys = Object.keys(config.shape);
-        this.shapeKeysSet = new Set(this.shapeKeys);
+        this._shapeKeys = Object.keys(config.shape);
+        this._shapeKeysSet = new Set(this._shapeKeys);
+    }
+    /**
+     * Get the validator configuration
+     * @internal Used by discriminated union validator
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * Get the shape keys array
+     */
+    get shapeKeys() {
+        return this._shapeKeys;
+    }
+    /**
+     * Get the shape keys set for O(1) lookups
+     * @internal Used by discriminated union validator
+     */
+    get shapeKeysSet() {
+        return this._shapeKeysSet;
     }
     /**
      * Create a new object validator
@@ -422,14 +473,14 @@ class VldObject extends VldBase {
     parse(value) {
         // Fast type check
         if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            throw new Error(this.config.errorMessage || getMessages().invalidObject);
+            throw new Error(this._config.errorMessage || getMessages().invalidObject);
         }
         const obj = value;
         const result = {};
         // Ultra-optimized field validation with inline fast paths
-        for (let i = 0; i < this.shapeKeys.length; i++) {
-            const key = this.shapeKeys[i];
-            const validator = this.config.shape[key];
+        for (let i = 0; i < this._shapeKeys.length; i++) {
+            const key = this._shapeKeys[i];
+            const validator = this._config.shape[key];
             const fieldValue = obj[key];
             // BUG-NEW-002 FIX: Use instanceof instead of constructor.name
             // constructor.name breaks in minified builds where class names become 'a', 'b', etc.
@@ -486,38 +537,39 @@ class VldObject extends VldBase {
                 result[key] = parseResult.data;
             }
         }
-        // Handle strict mode - optimized with Set
-        if (this.config.strict) {
+        // Handle strict/passthrough/catchall modes - optimized single Object.keys() call
+        if (this._config.strict || this._config.passthrough || this._config.catchall) {
             const objKeys = Object.keys(obj);
-            const extraKeys = [];
-            for (let i = 0; i < objKeys.length; i++) {
-                if (!this.shapeKeysSet.has(objKeys[i])) {
-                    extraKeys.push(objKeys[i]);
+            // Handle strict mode - optimized with Set
+            if (this._config.strict) {
+                const extraKeys = [];
+                for (let i = 0; i < objKeys.length; i++) {
+                    if (!this._shapeKeysSet.has(objKeys[i])) {
+                        extraKeys.push(objKeys[i]);
+                    }
+                }
+                if (extraKeys.length > 0) {
+                    throw new Error(getMessages().unexpectedKeys(extraKeys));
                 }
             }
-            if (extraKeys.length > 0) {
-                throw new Error(getMessages().unexpectedKeys(extraKeys));
-            }
-        }
-        // Handle passthrough mode - optimized with comprehensive prototype pollution protection
-        if (this.config.passthrough) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip dangerous keys to prevent prototype pollution
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    result[key] = obj[key];
+            // Handle passthrough mode - optimized with comprehensive prototype pollution protection
+            if (this._config.passthrough) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip dangerous keys to prevent prototype pollution
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        result[key] = obj[key];
+                    }
                 }
             }
-        }
-        // Handle catchall - validate extra keys with catchall validator
-        if (this.config.catchall) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip keys already in shape and dangerous keys
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    result[key] = this.config.catchall.parse(obj[key]);
+            // Handle catchall - validate extra keys with catchall validator
+            if (this._config.catchall) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip keys already in shape and dangerous keys
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        result[key] = this._config.catchall.parse(obj[key]);
+                    }
                 }
             }
         }
@@ -532,15 +584,15 @@ class VldObject extends VldBase {
         if (typeof value !== 'object' || value === null || Array.isArray(value)) {
             return {
                 success: false,
-                error: new Error(this.config.errorMessage || getMessages().invalidObject)
+                error: new Error(this._config.errorMessage || getMessages().invalidObject)
             };
         }
         const obj = value;
         const result = {};
         // Validate all fields
-        for (let i = 0; i < this.shapeKeys.length; i++) {
-            const key = this.shapeKeys[i];
-            const validator = this.config.shape[key];
+        for (let i = 0; i < this._shapeKeys.length; i++) {
+            const key = this._shapeKeys[i];
+            const validator = this._config.shape[key];
             const fieldValue = obj[key];
             const parseResult = validator.safeParse(fieldValue);
             if (parseResult.success) {
@@ -553,48 +605,49 @@ class VldObject extends VldBase {
                 };
             }
         }
-        // Handle strict mode
-        if (this.config.strict) {
+        // Handle strict/passthrough/catchall modes - optimized single Object.keys() call
+        if (this._config.strict || this._config.passthrough || this._config.catchall) {
             const objKeys = Object.keys(obj);
-            const extraKeys = [];
-            for (let i = 0; i < objKeys.length; i++) {
-                if (!this.shapeKeysSet.has(objKeys[i])) {
-                    extraKeys.push(objKeys[i]);
+            // Handle strict mode
+            if (this._config.strict) {
+                const extraKeys = [];
+                for (let i = 0; i < objKeys.length; i++) {
+                    if (!this._shapeKeysSet.has(objKeys[i])) {
+                        extraKeys.push(objKeys[i]);
+                    }
+                }
+                if (extraKeys.length > 0) {
+                    return {
+                        success: false,
+                        error: new Error(getMessages().unexpectedKeys(extraKeys))
+                    };
                 }
             }
-            if (extraKeys.length > 0) {
-                return {
-                    success: false,
-                    error: new Error(getMessages().unexpectedKeys(extraKeys))
-                };
-            }
-        }
-        // Handle passthrough mode with comprehensive prototype pollution protection
-        if (this.config.passthrough) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip dangerous keys to prevent prototype pollution
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    result[key] = obj[key];
+            // Handle passthrough mode with comprehensive prototype pollution protection
+            if (this._config.passthrough) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip dangerous keys to prevent prototype pollution
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        result[key] = obj[key];
+                    }
                 }
             }
-        }
-        // Handle catchall - validate extra keys with catchall validator
-        if (this.config.catchall) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip keys already in shape and dangerous keys
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    const catchallResult = this.config.catchall.safeParse(obj[key]);
-                    if (!catchallResult.success) {
-                        return {
-                            success: false,
-                            error: new Error(getMessages().objectField(key, catchallResult.error.message))
-                        };
+            // Handle catchall - validate extra keys with catchall validator
+            if (this._config.catchall) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip keys already in shape and dangerous keys
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        const catchallResult = this._config.catchall.safeParse(obj[key]);
+                        if (!catchallResult.success) {
+                            return {
+                                success: false,
+                                error: new Error(getMessages().objectField(key, catchallResult.error.message))
+                            };
+                        }
+                        result[key] = catchallResult.data;
                     }
-                    result[key] = catchallResult.data;
                 }
             }
         }
@@ -659,7 +712,7 @@ class VldObject extends VldBase {
      */
     strict(message) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: true,
             passthrough: false,
             errorMessage: message
@@ -670,7 +723,7 @@ class VldObject extends VldBase {
      */
     passthrough() {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: false,
             passthrough: true
         });
@@ -680,11 +733,11 @@ class VldObject extends VldBase {
      */
     partial() {
         const partialShape = {};
-        for (const key in this.config.shape) {
-            partialShape[key] = new VldOptional(this.config.shape[key]);
+        for (const key in this._config.shape) {
+            partialShape[key] = new VldOptional(this._config.shape[key]);
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: partialShape
         });
     }
@@ -693,8 +746,8 @@ class VldObject extends VldBase {
      */
     deepPartial() {
         const deepPartialShape = {};
-        for (const key in this.config.shape) {
-            const validator = this.config.shape[key];
+        for (const key in this._config.shape) {
+            const validator = this._config.shape[key];
             if (validator instanceof VldObject) {
                 deepPartialShape[key] = new VldOptional(validator.deepPartial());
             }
@@ -703,7 +756,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: deepPartialShape
         });
     }
@@ -713,12 +766,12 @@ class VldObject extends VldBase {
     pick(...keys) {
         const pickedShape = {};
         for (const key of keys) {
-            if (key in this.config.shape) {
-                pickedShape[key] = this.config.shape[key];
+            if (key in this._config.shape) {
+                pickedShape[key] = this._config.shape[key];
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: pickedShape
         });
     }
@@ -728,13 +781,13 @@ class VldObject extends VldBase {
     omit(...keys) {
         const omittedShape = {};
         const keysToOmit = new Set(keys);
-        for (const key in this.config.shape) {
+        for (const key in this._config.shape) {
             if (!keysToOmit.has(key)) {
-                omittedShape[key] = this.config.shape[key];
+                omittedShape[key] = this._config.shape[key];
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: omittedShape
         });
     }
@@ -743,8 +796,8 @@ class VldObject extends VldBase {
      */
     extend(extension) {
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...extension }
+            ...this._config,
+            shape: { ...this._config.shape, ...extension }
         });
     }
     /**
@@ -752,8 +805,8 @@ class VldObject extends VldBase {
      */
     merge(other) {
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...other.config.shape }
+            ...this._config,
+            shape: { ...this._config.shape, ...other.config.shape }
         });
     }
     /**
@@ -761,8 +814,8 @@ class VldObject extends VldBase {
      */
     required() {
         const requiredShape = {};
-        for (const key in this.config.shape) {
-            const validator = this.config.shape[key];
+        for (const key in this._config.shape) {
+            const validator = this._config.shape[key];
             // If it's optional, unwrap it
             if (validator instanceof VldOptional) {
                 // BUG-001 FIX: Add defensive check for baseValidator property
@@ -777,7 +830,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: requiredShape
         });
     }
@@ -787,7 +840,7 @@ class VldObject extends VldBase {
      */
     catchall(schema) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             catchall: schema,
             passthrough: false // catchall overrides passthrough
         });
@@ -797,14 +850,14 @@ class VldObject extends VldBase {
      * Zod 4 API parity - returns the shape object
      */
     get shape() {
-        return this.config.shape;
+        return this._config.shape;
     }
     /**
      * Create an enum validator from object keys
      * Zod 4 API parity - creates literal union of keys
      */
     keyof() {
-        const keys = Object.keys(this.config.shape);
+        const keys = Object.keys(this._config.shape);
         if (keys.length === 0) {
             throw new Error('Cannot create keyof enum from empty object');
         }
@@ -823,7 +876,7 @@ class VldObject extends VldBase {
      */
     safeExtend(extension) {
         // Check for overlapping keys
-        const existingKeys = new Set(Object.keys(this.config.shape));
+        const existingKeys = new Set(Object.keys(this._config.shape));
         const extensionKeys = Object.keys(extension);
         const overlappingKeys = [];
         for (const key of extensionKeys) {
@@ -835,8 +888,8 @@ class VldObject extends VldBase {
             throw new Error(`safeExtend: ${getMessages().safeExtendOverlap(overlappingKeys)}`);
         }
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...extension }
+            ...this._config,
+            shape: { ...this._config.shape, ...extension }
         });
     }
 }
@@ -972,11 +1025,17 @@ class VldLiteral extends VldBase {
     /**
      * Private constructor to enforce immutability
      */
-    constructor(literal, errorMessage) {
+    constructor(_literal, errorMessage) {
         super();
-        this.literal = literal;
+        this._literal = _literal;
         this.errorMessage = errorMessage;
     }
+    /**
+     * Get the literal value
+     */
+    get literal() {
+        return this._literal;
+    }
     /**
      * Create a new literal validator
      */
@@ -987,23 +1046,23 @@ class VldLiteral extends VldBase {
      * Parse and validate a literal value
      */
     parse(value) {
-        if (value !== this.literal) {
+        if (value !== this._literal) {
             throw new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)));
+                getMessages().literalExpected(JSON.stringify(this._literal), JSON.stringify(value)));
         }
-        return this.literal;
+        return this._literal;
     }
     /**
      * Safely parse and validate a literal value
      */
     safeParse(value) {
-        if (value === this.literal) {
-            return { success: true, data: this.literal };
+        if (value === this._literal) {
+            return { success: true, data: this._literal };
         }
         return {
             success: false,
             error: new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)))
+                getMessages().literalExpected(JSON.stringify(this._literal), JSON.stringify(value)))
         };
     }
 }
@@ -1678,27 +1737,56 @@ class VldNan extends VldBase {
 /**
  * Lazy validator - defers schema evaluation until runtime
  * Essential for recursive and self-referencing types
+ *
+ * MEMORY OPTIMIZATION: Uses WeakRef for the cached schema to allow garbage collection
+ * when the validator is no longer in use. This prevents memory leaks in long-running
+ * applications with dynamically created schemas.
  */
 class VldLazy extends VldBase {
     constructor(_schemaGetter) {
         super();
         this._schemaGetter = _schemaGetter;
-        this._cachedSchema = null;
+        // Use WeakRef to allow garbage collection of the cached schema
+        this._cachedSchemaRef = null;
+        // Keep a strong reference flag to prevent GC during active use
+        this._strongRef = null;
     }
     static create(schemaGetter) {
         return new VldLazy(schemaGetter);
     }
     /**
      * Get the actual schema, caching it after first retrieval
+     * Uses WeakRef to allow garbage collection when validator is not in use
      */
     _getSchema() {
-        if (!this._cachedSchema) {
-            this._cachedSchema = this._schemaGetter();
+        // Check if we have a strong reference first (active use)
+        if (this._strongRef) {
+            return this._strongRef;
+        }
+        // Try to get from WeakRef
+        if (this._cachedSchemaRef) {
+            const cached = this._cachedSchemaRef.deref();
+            if (cached) {
+                // Restore strong reference for active use
+                this._strongRef = cached;
+                return cached;
+            }
         }
-        return this._cachedSchema;
+        // Create new schema
+        const schema = this._schemaGetter();
+        this._cachedSchemaRef = new WeakRef(schema);
+        this._strongRef = schema;
+        // Clear strong reference after a tick to allow GC
+        // This keeps the schema alive during synchronous operations
+        // but allows it to be collected if the validator is discarded
+        Promise.resolve().then(() => {
+            this._strongRef = null;
+        });
+        return schema;
     }
     /**
      * Get the inner schema (unwrap)
+     * Returns a strong reference that will keep the schema alive
      */
     unwrap() {
         return this._getSchema();
@@ -1721,11 +1809,10 @@ class VldLazy extends VldBase {
  */
 function extractLiteralValues(schema) {
     if (schema instanceof VldLiteral) {
-        const value = schema.literal;
-        return [value];
+        return [schema.literal];
     }
     if (schema instanceof VldEnum) {
-        return schema.values;
+        return [...schema.values];
     }
     throw new Error('Discriminator must be a literal or enum schema');
 }
@@ -1930,5 +2017,5 @@ class VldJson extends VldBase {
     }
 }
 
-export { VldSymbol as V, VldStringBool as a, VldArray as b, VldObject as c, VldTuple as d, VldRecord as e, VldSet as f, VldMap as g, VldUnion as h, VldIntersection as i, VldDiscriminatedUnion as j, VldXor as k, VldLiteral as l, VldEnum as m, VldAny as n, VldVoid as o, VldNever as p, VldNull as q, VldUndefined as r, VldNan as s, VldLazy as t, VldJson as u };
-//# sourceMappingURL=json-nIhyRPOU.js.map
+export { VldNever as V, VldAny as a, VldArray as b, VldDiscriminatedUnion as c, VldEnum as d, VldIntersection as e, VldJson as f, VldLazy as g, VldLiteral as h, VldObject as i, VldRecord as j, VldMap as k, VldNan as l, VldNull as m, VldSet as n, VldStringBool as o, VldSymbol as p, VldTuple as q, VldUndefined as r, VldUnion as s, VldVoid as t, VldXor as u };
+//# sourceMappingURL=json-Cp4WO0M9.js.map