@oxog/vld 2.0.3 → 2.1.0

package/dist/cjs/validators/array.cjs

@@ -0,0 +1,283 @@
+'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 createArrayError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_array', path: [], message }]);
+}
+/**
+ * Immutable array validator with chainable methods
+ */
+class VldArray extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(config) {
+        super(validators_base.VLD_VALIDATOR_TYPES.ARRAY);
+        this.config = config;
+        this._simpleItemMode = this.getSimpleItemMode(config.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';
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Create a new array validator
+     */
+    static create(itemValidator) {
+        return new VldArray({ itemValidator });
+    }
+    /**
+     * Parse and validate an array value
+     */
+    parse(value) {
+        if (!Array.isArray(value)) {
+            throw new Error(this.config.errorMessage || locales_runtime.getMessages().invalidArray);
+        }
+        return this.parseArrayValue(value);
+    }
+    /**
+     * Parse a value that has already passed the array type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownArray(value) {
+        return this.parseArrayValue(value);
+    }
+    parseArrayValue(value) {
+        // Validate length constraints
+        if (this.config.exactLength !== undefined && value.length !== this.config.exactLength) {
+            throw new Error(this.config.errorMessage || locales_runtime.getMessages().arrayLength(this.config.exactLength));
+        }
+        if (this.config.minLength !== undefined && value.length < this.config.minLength) {
+            throw new Error(this.config.errorMessage || locales_runtime.getMessages().arrayMin(this.config.minLength));
+        }
+        if (this.config.maxLength !== undefined && value.length > this.config.maxLength) {
+            throw new Error(this.config.errorMessage || locales_runtime.getMessages().arrayMax(this.config.maxLength));
+        }
+        const length = value.length;
+        const result = new Array(length);
+        const simpleItemMode = this._simpleItemMode;
+        if (simpleItemMode !== undefined) {
+            for (let i = 0; i < length; i++) {
+                const item = value[i];
+                switch (simpleItemMode) {
+                    case 'string':
+                        if (typeof item !== 'string') {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidString));
+                        }
+                        result[i] = item;
+                        break;
+                    case 'number':
+                        if (typeof item !== 'number' || isNaN(item)) {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidNumber));
+                        }
+                        result[i] = item;
+                        break;
+                    case 'boolean':
+                        if (typeof item !== 'boolean') {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidBoolean));
+                        }
+                        result[i] = item;
+                        break;
+                }
+            }
+            if (this.config.unique) {
+                this.checkUnique(result);
+            }
+            return result;
+        }
+        // Validate each item without allocating a ParseResult object per element.
+        for (let i = 0; i < length; i++) {
+            try {
+                result[i] = this.config.itemValidator.parse(value[i]);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(locales_runtime.getMessages().arrayItem(i, message));
+            }
+        }
+        // Check uniqueness if required - optimized with Map-based approach
+        if (this.config.unique) {
+            this.checkUnique(result);
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate an array value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createArrayError(error.message) };
+        }
+    }
+    /**
+     * 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
+     * BUG-006 FIX: Added depth limit to prevent stack overflow
+     * BUG-NEW-003 FIX: Fixed depth tracking to properly track recursion depth
+     */
+    stableStringify(obj) {
+        const seen = new WeakSet();
+        const MAX_DEPTH = 100; // Reasonable depth limit to prevent stack overflow
+        // Helper function to sort keys and create stable representation
+        const sortedStringify = (value, depth = 0) => {
+            // Check depth limit
+            if (depth > MAX_DEPTH) {
+                return '"[Max Depth Exceeded]"';
+            }
+            // Handle primitives
+            if (value === null)
+                return 'null';
+            if (value === undefined)
+                return 'undefined';
+            if (typeof value !== 'object')
+                return JSON.stringify(value);
+            // Handle circular references
+            if (seen.has(value)) {
+                return '"[Circular]"';
+            }
+            seen.add(value);
+            try {
+                // Handle arrays
+                if (Array.isArray(value)) {
+                    const items = value.map(item => sortedStringify(item, depth + 1));
+                    return `[${items.join(',')}]`;
+                }
+                // Handle objects - sort keys for stability
+                const keys = Object.keys(value).sort();
+                const pairs = keys.map(key => {
+                    const serializedKey = JSON.stringify(key);
+                    const serializedValue = sortedStringify(value[key], depth + 1);
+                    return `${serializedKey}:${serializedValue}`;
+                });
+                return `{${pairs.join(',')}}`;
+            }
+            finally {
+                // Clean up seen set for this branch
+                seen.delete(value);
+            }
+        };
+        try {
+            return sortedStringify(obj);
+        }
+        catch {
+            // Fallback to safe representation if stringify fails
+            return String(obj);
+        }
+    }
+    /**
+     * Create a new validator with minimum length constraint
+     */
+    min(length, message) {
+        return new VldArray({
+            ...this.config,
+            minLength: length,
+            errorMessage: message || locales_runtime.getMessages().arrayMin(length)
+        });
+    }
+    /**
+     * Create a new validator with maximum length constraint
+     */
+    max(length, message) {
+        return new VldArray({
+            ...this.config,
+            maxLength: length,
+            errorMessage: message || locales_runtime.getMessages().arrayMax(length)
+        });
+    }
+    /**
+     * Create a new validator with exact length constraint
+     */
+    length(length, message) {
+        return new VldArray({
+            ...this.config,
+            exactLength: length,
+            minLength: undefined,
+            maxLength: undefined,
+            errorMessage: message || locales_runtime.getMessages().arrayLength(length)
+        });
+    }
+    /**
+     * Create a new validator that ensures array is not empty
+     */
+    nonempty(message) {
+        return new VldArray({
+            ...this.config,
+            minLength: 1,
+            errorMessage: message || locales_runtime.getMessages().arrayEmpty
+        });
+    }
+    /**
+     * Create a new validator that ensures array contains unique items
+     */
+    unique(message) {
+        return new VldArray({
+            ...this.config,
+            unique: true,
+            errorMessage: message || 'Array must contain unique items'
+        });
+    }
+    /**
+     * Create a new validator with a range constraint for length
+     */
+    between(min, max, message) {
+        return new VldArray({
+            ...this.config,
+            minLength: min,
+            maxLength: max,
+            errorMessage: message || `Array length must be between ${min} and ${max}`
+        });
+    }
+}
+
+exports.VldArray = VldArray;