@oxog/vld 2.0.3 → 2.1.0

package/dist/cjs/validators/map.cjs

@@ -0,0 +1,218 @@
+'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 createMapError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable Map validator
+ */
+class VldMap extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(keyValidator, valueValidator, errorMessage) {
+        super(validators_base.VLD_VALIDATOR_TYPES.MAP);
+        this.keyValidator = keyValidator;
+        this.valueValidator = valueValidator;
+        this.errorMessage = errorMessage;
+        this._simpleKeyMode = this.getSimpleItemMode(keyValidator);
+        this._simpleValueMode = this.getSimpleItemMode(valueValidator);
+        this._simpleKeyValue = this._simpleKeyMode === 'literal' ? keyValidator.literal : undefined;
+        this._simpleValueValue = this._simpleValueMode === 'literal' ? valueValidator.literal : undefined;
+    }
+    get keySchema() {
+        return this.keyValidator;
+    }
+    get valueSchema() {
+        return this.valueValidator;
+    }
+    /**
+     * Create a new Map validator
+     */
+    static create(keyValidator, valueValidator) {
+        return new VldMap(keyValidator, valueValidator);
+    }
+    getSimpleItemMode(validator) {
+        if (validator.isSimple !== true) {
+            return undefined;
+        }
+        switch (validator.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(mode, expected, received) {
+        switch (mode) {
+            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(expected), JSON.stringify(received));
+            default:
+                return locales_runtime.getMessages().invalidMap;
+        }
+    }
+    parseSimpleItem(mode, expected, value) {
+        switch (mode) {
+            case 'string':
+                if (typeof value !== 'string') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'number':
+                if (typeof value !== 'number' || isNaN(value)) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'boolean':
+                if (typeof value !== 'boolean') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'bigint':
+                if (typeof value !== 'bigint') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'symbol':
+                if (typeof value !== 'symbol') {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return value;
+            case 'null':
+                if (value !== null) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return null;
+            case 'undefinedValue':
+                if (value !== undefined) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return undefined;
+            case 'literal':
+                if (value !== expected) {
+                    throw new Error(this.getSimpleItemError(mode, expected, value));
+                }
+                return expected;
+            case 'passthrough':
+                return value;
+        }
+    }
+    /**
+     * Parse and validate a Map value
+     */
+    parse(value) {
+        if (!(value instanceof Map)) {
+            throw new Error(this.errorMessage || locales_runtime.getMessages().invalidMap);
+        }
+        return this.parseKnownMap(value);
+    }
+    /**
+     * Parse a value that has already passed the Map instance guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownMap(value) {
+        const result = new Map();
+        const simpleKeyMode = this._simpleKeyMode;
+        const simpleValueMode = this._simpleValueMode;
+        if (simpleKeyMode === 'string' && simpleValueMode === 'number') {
+            for (const [key, val] of value) {
+                if (typeof key !== 'string') {
+                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
+                }
+                if (typeof val !== 'number' || isNaN(val)) {
+                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
+                }
+                result.set(key, val);
+            }
+            return result;
+        }
+        if (simpleKeyMode === 'string' && simpleValueMode === 'string') {
+            for (const [key, val] of value) {
+                if (typeof key !== 'string') {
+                    throw new Error(this.getSimpleItemError(simpleKeyMode, this._simpleKeyValue, key));
+                }
+                if (typeof val !== 'string') {
+                    throw new Error(this.getSimpleItemError(simpleValueMode, this._simpleValueValue, val));
+                }
+                result.set(key, val);
+            }
+            return result;
+        }
+        if (simpleKeyMode !== undefined && simpleValueMode !== undefined) {
+            const keyMode = simpleKeyMode;
+            const valueMode = simpleValueMode;
+            for (const [key, val] of value) {
+                const validKey = this.parseSimpleItem(keyMode, this._simpleKeyValue, key);
+                const validValue = this.parseSimpleItem(valueMode, this._simpleValueValue, val);
+                result.set(validKey, validValue);
+            }
+            return result;
+        }
+        for (const [key, val] of value) {
+            try {
+                const validKey = simpleKeyMode === undefined
+                    ? this.keyValidator.parse(key)
+                    : this.parseSimpleItem(simpleKeyMode, this._simpleKeyValue, key);
+                const validValue = simpleValueMode === undefined
+                    ? this.valueValidator.parse(val)
+                    : this.parseSimpleItem(simpleValueMode, this._simpleValueValue, val);
+                result.set(validKey, validValue);
+            }
+            catch (error) {
+                throw new Error(error.message);
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a Map value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createMapError(error.message) };
+        }
+    }
+}
+
+exports.VldMap = VldMap;

package/dist/cjs/validators/nan.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+
+/**
+ * VldNan - Validates that a value is NaN (Not a Number)
+ * Part of Zod 4 API parity implementation
+ */
+function createNanError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_number', path: [], message }]);
+}
+/**
+ * NaN validator - validates that a value is NaN
+ * Note: Uses Number.isNaN() which is more strict than global isNaN()
+ */
+class VldNan extends validators_base.VldBase {
+    constructor() {
+        super(validators_base.VLD_VALIDATOR_TYPES.NAN);
+    }
+    static create() {
+        return new VldNan();
+    }
+    parse(value) {
+        if (typeof value !== 'number' || !Number.isNaN(value)) {
+            throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);
+        }
+        return value;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createNanError(error.message) };
+        }
+    }
+}
+
+exports.VldNan = VldNan;

package/dist/cjs/validators/never.cjs

@@ -0,0 +1,36 @@
+'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');
+
+/**
+ * Validator that never succeeds
+ */
+class VldNever extends validators_base.VldBase {
+    /**
+     * Create a new never validator
+     */
+    static create() {
+        return new VldNever();
+    }
+    /**
+     * Parse never value (always fails)
+     */
+    parse(_value) {
+        throw new Error(locales_runtime.getMessages().neverType);
+    }
+    /**
+     * Safely parse never value (always fails)
+     */
+    safeParse(_value) {
+        return {
+            success: false,
+            error: new errorsCore.VldError([{ code: 'invalid_type', path: [], message: locales_runtime.getMessages().neverType }])
+        };
+    }
+}
+
+exports.VldNever = VldNever;

package/dist/cjs/validators/null.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+
+/**
+ * VldNull - Validates that a value is exactly null
+ * Part of Zod 4 API parity implementation
+ */
+function createNullError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Null validator - validates that a value is exactly null
+ */
+class VldNull extends validators_base.VldBase {
+    constructor() {
+        super(validators_base.VLD_VALIDATOR_TYPES.NULL);
+    }
+    static create() {
+        return new VldNull();
+    }
+    get isSimple() {
+        return true;
+    }
+    parse(value) {
+        if (value !== null) {
+            throw new Error(`Expected null, received ${typeof value}`);
+        }
+        return null;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createNullError(error.message) };
+        }
+    }
+}
+
+exports.VldNull = VldNull;