@oxog/vld 2.0.2 → 2.1.0

package/dist/validators/union.js

@@ -0,0 +1,187 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+
+/**
+ * Optimized immutable union validator for multiple type options
+ * Features type-checking shortcuts for 110x performance improvement
+ */
+class VldUnion extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(validators, errorMessage) {
+        super(VLD_VALIDATOR_TYPES.UNION);
+        this.validators = validators;
+        this.errorMessage = errorMessage;
+        this.typeCheckers = validators.map(validator => this.createTypeChecker(validator));
+        this.simpleModes = validators.map(validator => this.createSimpleMode(validator));
+        this.simpleValues = validators.map((validator, i) => this.simpleModes[i] === 'literal' ? validator.literal : undefined);
+    }
+    createSimpleMode(validator) {
+        if (validator.isSimple !== true) {
+            return undefined;
+        }
+        switch (validator.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 'undefined';
+            case VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case VLD_VALIDATOR_TYPES.ANY:
+            case VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    parseSimpleValue(mode, index, value) {
+        switch (mode) {
+            case 'string':
+            case 'number':
+            case 'boolean':
+            case 'bigint':
+            case 'symbol':
+                return value;
+            case 'null':
+                return null;
+            case 'undefined':
+                return undefined;
+            case 'literal':
+                return this.simpleValues[index];
+            case 'passthrough':
+                return value;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Create type checker based on validator type for fast path optimization
+     * Uses a safer approach that's less prone to spoofing
+     */
+    createTypeChecker(validator) {
+        switch (validator.validatorType) {
+            case VLD_VALIDATOR_TYPES.STRING:
+                return (v) => typeof v === 'string';
+            case VLD_VALIDATOR_TYPES.NUMBER:
+                return (v) => typeof v === 'number' && !isNaN(v);
+            case VLD_VALIDATOR_TYPES.BOOLEAN:
+                return (v) => typeof v === 'boolean';
+            case VLD_VALIDATOR_TYPES.BIGINT:
+                return (v) => typeof v === 'bigint';
+            case VLD_VALIDATOR_TYPES.SYMBOL:
+                return (v) => typeof v === 'symbol';
+            case VLD_VALIDATOR_TYPES.NAN:
+                return (v) => typeof v === 'number' && Number.isNaN(v);
+            case VLD_VALIDATOR_TYPES.ARRAY:
+                return Array.isArray;
+            case VLD_VALIDATOR_TYPES.OBJECT:
+                return (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+            case VLD_VALIDATOR_TYPES.NULL:
+                return (v) => v === null;
+            case VLD_VALIDATOR_TYPES.UNDEFINED:
+            case VLD_VALIDATOR_TYPES.VOID:
+                return (v) => v === undefined;
+            case VLD_VALIDATOR_TYPES.ENUM:
+                return (v) => typeof v === 'string' || typeof v === 'number';
+            case VLD_VALIDATOR_TYPES.LITERAL: {
+                const literal = validator.literal;
+                return (v) => v === literal;
+            }
+            case VLD_VALIDATOR_TYPES.NEVER:
+                return () => false;
+            case VLD_VALIDATOR_TYPES.ANY:
+            case VLD_VALIDATOR_TYPES.UNKNOWN:
+                return () => true;
+            default:
+                return () => true;
+        }
+    }
+    /**
+     * Create a new union validator
+     */
+    static create(...validators) {
+        return new VldUnion(validators);
+    }
+    /**
+     * Parse and validate a value against union options
+     * Optimized with type checking and direct parsing to avoid success-result allocations
+     * BUG-NEW-013 FIX: Single-pass error collection to avoid double parsing
+     */
+    parse(value) {
+        // Single pass: collect errors during validation
+        const errors = [];
+        for (let i = 0; i < this.validators.length; i++) {
+            const validator = this.validators[i];
+            const typeChecker = this.typeCheckers[i];
+            // Skip validators that definitely won't match based on type
+            if (typeChecker && !typeChecker(value)) {
+                continue;
+            }
+            const simpleMode = this.simpleModes[i];
+            if (simpleMode !== undefined) {
+                return this.parseSimpleValue(simpleMode, i, value);
+            }
+            try {
+                return validator.parse(value);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                errors.push(message);
+            }
+        }
+        // All validators failed - throw with collected errors
+        throw new Error(this.errorMessage ||
+            getMessages().unionNoMatch(errors));
+    }
+    /**
+     * Safely parse and validate a value against union options
+     * Optimized version using type checking shortcuts
+     * BUG-NEW-013 FIX: Single-pass error collection to avoid double parsing
+     */
+    safeParse(value) {
+        // Single pass: collect errors during validation
+        const errors = [];
+        for (let i = 0; i < this.validators.length; i++) {
+            const validator = this.validators[i];
+            const typeChecker = this.typeCheckers[i];
+            // Skip validators that definitely won't match based on type
+            if (typeChecker && !typeChecker(value)) {
+                continue;
+            }
+            const simpleMode = this.simpleModes[i];
+            if (simpleMode !== undefined) {
+                return {
+                    success: true,
+                    data: this.parseSimpleValue(simpleMode, i, value)
+                };
+            }
+            try {
+                return { success: true, data: validator.parse(value) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                errors.push(message);
+            }
+        }
+        // All validators failed - return error with collected messages
+        return {
+            success: false,
+            error: new Error(this.errorMessage ||
+                getMessages().unionNoMatch(errors))
+        };
+    }
+}
+
+export { VldUnion };

package/dist/validators/unknown.d.ts

@@ -1,12 +1,18 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Validator that accepts unknown values
  */
 export declare class VldUnknown extends VldBase<unknown, unknown> {
+    private constructor();
     /**
      * Create a new unknown validator
      */
     static create(): VldUnknown;
+    /**
+     * Returns true because unknown accepts every input without checks.
+     * Used by composite validators for passthrough fast paths.
+     */
+    get isSimple(): boolean;
     /**
      * Parse unknown value (always succeeds)
      */
@@ -16,4 +22,3 @@ export declare class VldUnknown extends VldBase<unknown, unknown> {
      */
     safeParse(value: unknown): ParseResult<unknown>;
 }
-//# sourceMappingURL=unknown.d.ts.map

package/dist/{chunks/unknown-SLIH1VCf.js → validators/unknown.js}

@@ -1,15 +1,25 @@
-import { i as VldBase } from './bigint-DgsCr2dC.js';
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
 
 /**
  * Validator that accepts unknown values
  */
 class VldUnknown extends VldBase {
+    constructor() {
+        super(VLD_VALIDATOR_TYPES.UNKNOWN);
+    }
     /**
      * Create a new unknown validator
      */
     static create() {
         return new VldUnknown();
     }
+    /**
+     * Returns true because unknown accepts every input without checks.
+     * Used by composite validators for passthrough fast paths.
+     */
+    get isSimple() {
+        return true;
+    }
     /**
      * Parse unknown value (always succeeds)
      */
@@ -24,5 +34,4 @@ class VldUnknown extends VldBase {
     }
 }
 
-export { VldUnknown as V };
-//# sourceMappingURL=unknown-SLIH1VCf.js.map
+export { VldUnknown };

package/dist/validators/void.d.ts

@@ -1,12 +1,14 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Validator that only accepts undefined
  */
 export declare class VldVoid extends VldBase<void, void> {
+    private constructor();
     /**
      * Create a new void validator
      */
     static create(): VldVoid;
+    get isSimple(): boolean;
     /**
      * Parse void value (must be undefined)
      */
@@ -16,4 +18,3 @@ export declare class VldVoid extends VldBase<void, void> {
      */
     safeParse(value: unknown): ParseResult<void>;
 }
-//# sourceMappingURL=void.d.ts.map

package/dist/validators/void.js

@@ -0,0 +1,44 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+import { getMessages } from '../locales/runtime.js';
+import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
+
+/**
+ * Validator that only accepts undefined
+ */
+class VldVoid extends VldBase {
+    constructor() {
+        super(VLD_VALIDATOR_TYPES.VOID);
+    }
+    /**
+     * Create a new void validator
+     */
+    static create() {
+        return new VldVoid();
+    }
+    get isSimple() {
+        return true;
+    }
+    /**
+     * Parse void value (must be undefined)
+     */
+    parse(value) {
+        if (value !== undefined) {
+            throw new Error(getMessages().expectedUndefined);
+        }
+        return undefined;
+    }
+    /**
+     * Safely parse void value
+     */
+    safeParse(value) {
+        if (value === undefined) {
+            return { success: true, data: undefined };
+        }
+        return {
+            success: false,
+            error: new VldError([{ code: 'invalid_type', path: [], message: getMessages().expectedUndefined }])
+        };
+    }
+}
+
+export { VldVoid };

package/dist/validators/xor.d.ts

@@ -3,8 +3,8 @@
  * Part of Zod 4 API parity implementation
  * Ensures exactly one schema in the union matches
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * XOR validator - ensures exactly one option matches
  * Unlike regular union which allows multiple matches, XOR requires exactly one
@@ -20,4 +20,3 @@ export declare class VldXor<Options extends VldBase<any, any>[]> extends VldBase
      */
     getOptions(): Options;
 }
-//# sourceMappingURL=xor.d.ts.map

package/dist/validators/xor.js

@@ -0,0 +1,66 @@
+import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
+
+/**
+ * VldXor - Exclusive union validator
+ * Part of Zod 4 API parity implementation
+ * Ensures exactly one schema in the union matches
+ */
+/**
+ * XOR validator - ensures exactly one option matches
+ * Unlike regular union which allows multiple matches, XOR requires exactly one
+ */
+class VldXor extends VldBase {
+    constructor(_options) {
+        super(VLD_VALIDATOR_TYPES.XOR);
+        this._options = _options;
+    }
+    static create(options) {
+        if (options.length < 2) {
+            throw new Error('XOR requires at least 2 options');
+        }
+        return new VldXor(options);
+    }
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    safeParse(value) {
+        let matchCount = 0;
+        let lastSuccess = null;
+        for (const option of this._options) {
+            const result = option.safeParse(value);
+            if (result.success) {
+                matchCount++;
+                lastSuccess = result;
+                if (matchCount > 1) {
+                    // Early exit if more than one match
+                    break;
+                }
+            }
+        }
+        if (matchCount === 0) {
+            return {
+                success: false,
+                error: new Error('No schema matched in XOR union')
+            };
+        }
+        if (matchCount > 1) {
+            return {
+                success: false,
+                error: new Error(`Input matches ${matchCount} schemas in XOR union, but exactly one is required`)
+            };
+        }
+        return lastSuccess;
+    }
+    /**
+     * Get all options
+     */
+    getOptions() {
+        return this._options;
+    }
+}
+
+export { VldXor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxog/vld",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Ultra-fast TypeScript-first schema validation with zero dependencies, 27+ language support, plugin system, and CLI tools",
   "type": "module",
   "main": "./dist/cjs/index.cjs",
@@ -9,6 +9,9 @@
   "bin": {
     "vld": "./dist/cli/bin.js"
   },
+  "engines": {
+    "node": ">=18"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -27,75 +30,152 @@
     },
     "./validators": {
       "types": "./dist/validators/index.d.ts",
-      "import": "./dist/validators/index.js"
+      "import": "./dist/validators/index.js",
+      "require": "./dist/cjs/validators/index.cjs"
     },
     "./validators/*": {
       "types": "./dist/validators/*.d.ts",
-      "import": "./dist/validators/*.js"
+      "import": "./dist/validators/*.js",
+      "require": "./dist/cjs/validators/*.cjs"
     },
     "./coercion": {
       "types": "./dist/coercion/index.d.ts",
-      "import": "./dist/coercion/index.js"
+      "import": "./dist/coercion/index.js",
+      "require": "./dist/cjs/coercion/index.cjs"
     },
     "./codecs": {
       "types": "./dist/codecs/index.d.ts",
-      "import": "./dist/codecs/index.js"
+      "import": "./dist/codecs/index.js",
+      "require": "./dist/cjs/codecs/index.cjs"
     },
     "./locales": {
       "types": "./dist/locales/index.d.ts",
       "import": "./dist/locales/index.js",
       "require": "./dist/cjs/locales/index.cjs"
     },
+    "./v3": {
+      "types": "./dist/v3/index.d.ts",
+      "import": "./dist/v3/index.js",
+      "require": "./dist/cjs/v3/index.cjs"
+    },
+    "./v4": {
+      "types": "./dist/v4/index.d.ts",
+      "import": "./dist/v4/index.js",
+      "require": "./dist/cjs/v4/index.cjs"
+    },
+    "./v4-mini": {
+      "types": "./dist/v4-mini/index.d.ts",
+      "import": "./dist/v4-mini/index.js",
+      "require": "./dist/cjs/v4-mini/index.cjs"
+    },
+    "./v4/mini": {
+      "types": "./dist/v4/mini/index.d.ts",
+      "import": "./dist/v4/mini/index.js",
+      "require": "./dist/cjs/v4/mini/index.cjs"
+    },
+    "./v4/core": {
+      "types": "./dist/v4/core/index.d.ts",
+      "import": "./dist/v4/core/index.js",
+      "require": "./dist/cjs/v4/core/index.cjs"
+    },
+    "./v4/locales": {
+      "types": "./dist/v4/locales/index.d.ts",
+      "import": "./dist/v4/locales/index.js",
+      "require": "./dist/cjs/v4/locales/index.cjs"
+    },
+    "./v4/locales/types": null,
+    "./v4/locales/runtime": null,
+    "./v4/locales/*": {
+      "types": "./dist/locales/*.d.ts",
+      "import": "./dist/locales/*.js",
+      "require": "./dist/cjs/locales/*.cjs"
+    },
     "./locales/lazy": {
       "types": "./dist/locales/lazy.d.ts",
       "import": "./dist/locales/lazy.js",
       "require": "./dist/cjs/locales/lazy.cjs"
     },
+    "./locales/types": null,
+    "./locales/runtime": null,
+    "./locales/backup-en": null,
     "./locales/*": {
       "types": "./dist/locales/*.d.ts",
-      "import": "./dist/locales/*.js"
+      "import": "./dist/locales/*.js",
+      "require": "./dist/cjs/locales/*.cjs"
     },
     "./result": {
       "types": "./dist/compat/result.d.ts",
-      "import": "./dist/compat/result.js"
+      "import": "./dist/compat/result.js",
+      "require": "./dist/cjs/compat/result.cjs"
     },
     "./kernel": {
       "types": "./dist/kernel.d.ts",
-      "import": "./dist/kernel.js"
+      "import": "./dist/kernel.js",
+      "require": "./dist/cjs/kernel.cjs"
+    },
+    "./registry": {
+      "types": "./dist/registry.d.ts",
+      "import": "./dist/registry.js",
+      "require": "./dist/cjs/registry.cjs"
     },
     "./pigment": {
       "types": "./dist/pigment.d.ts",
-      "import": "./dist/pigment.js"
+      "import": "./dist/pigment.js",
+      "require": "./dist/cjs/pigment.cjs"
     },
     "./cli": {
       "types": "./dist/cli/index.d.ts",
-      "import": "./dist/cli/index.js"
+      "import": "./dist/cli/index.js",
+      "require": "./dist/cjs/cli/index.cjs"
     },
     "./plugins": {
       "types": "./dist/plugins/index.d.ts",
-      "import": "./dist/plugins/index.js"
+      "import": "./dist/plugins/index.js",
+      "require": "./dist/cjs/plugins/index.cjs"
     },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "npm run build:clean && npm run build:esm && npm run build:cjs && npm run build:types && npm run build:fix",
+    "build": "npm run build:clean && npm run build:bundle && npm run build:types && npm run build:fix",
     "build:clean": "node -e \"require('fs').rmSync('./dist', { recursive: true, force: true })\"",
-    "build:esm": "rollup -c rollup.config.mjs",
-    "build:cjs": "echo 'CJS built by rollup'",
+    "build:bundle": "rollup -c rollup.config.mjs",
+    "build:esm": "npm run build:bundle",
+    "build:cjs": "npm run build:bundle",
     "build:types": "tsc -p tsconfig.build.json",
     "build:fix": "node scripts/fix-imports.cjs",
     "build:legacy": "tsc && node scripts/fix-imports.cjs",
+    "verify:exports": "node scripts/verify-exports.cjs",
+    "verify:ascii": "node scripts/verify-ascii.cjs",
+    "verify:bundle": "node scripts/verify-bundle.cjs",
+    "verify:docs": "node scripts/verify-docs.cjs",
+    "verify:drop-in": "node scripts/verify-drop-in-app.cjs",
+    "verify:install": "node scripts/verify-install.cjs",
+    "verify:package": "node scripts/verify-package.cjs",
+    "verify:security": "npm audit --audit-level=low",
+    "verify:types": "node scripts/verify-types.cjs",
+    "verify:zod": "node scripts/verify-zod-parity.cjs",
     "test": "jest --coverage",
     "test:types": "tsc --noEmit",
-    "benchmark": "node benchmarks/quick-bench.cjs",
-    "benchmark:full": "node benchmarks/performance.cjs",
-    "benchmark:memory": "node --expose-gc benchmarks/memory.cjs",
-    "benchmark:startup": "node benchmarks/startup.cjs",
-    "benchmark:all": "npm run benchmark && npm run benchmark:memory && npm run benchmark:startup",
+    "benchmark": "npm run build && node benchmarks/quick-bench.cjs",
+    "benchmark:stable": "npm run build && node benchmarks/stable-bench.cjs",
+    "benchmark:guard": "npm run build && npm run benchmark:guard:built",
+    "benchmark:guard:built": "node benchmarks/performance-guard.cjs",
+    "benchmark:startup:guard": "node benchmarks/startup-guard.cjs",
+    "benchmark:memory:guard": "node benchmarks/memory-guard.cjs",
+    "benchmark:truth": "npm run build && node benchmarks/performance.cjs",
+    "benchmark:full": "npm run build && node benchmarks/performance.cjs",
+    "benchmark:memory": "npm run build && node --expose-gc benchmarks/memory.cjs",
+    "benchmark:startup": "npm run build && node benchmarks/startup.cjs",
+    "benchmark:all": "npm run build && node benchmarks/quick-bench.cjs && node --expose-gc benchmarks/memory.cjs && node benchmarks/startup.cjs",
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
-    "prepublishOnly": "npm run build && npm test"
+    "prepack": "npm run build",
+    "release:check": "npm run lint && npm run test:types && npm test -- --runInBand && npm run build && npm run verify:ascii && npm run verify:docs && npm run verify:exports && npm run verify:bundle && npm run verify:types && npm run verify:package && npm run verify:install && npm run verify:security && npm run verify:zod && npm run verify:drop-in && npm run benchmark:guard:built && npm run benchmark:startup:guard && npm run benchmark:memory:guard",
+    "prepublishOnly": "npm run release:check"
   },
   "keywords": [
     "validation",
@@ -133,21 +213,26 @@
   },
   "homepage": "https://github.com/ersinkoc/vld#readme",
   "devDependencies": {
-    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-terser": "^1.0.0",
     "@rollup/plugin-typescript": "^12.1.4",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^20.10.5",
-    "@typescript-eslint/eslint-plugin": "^6.15.0",
-    "@typescript-eslint/parser": "^6.15.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.19.43",
+    "@typescript-eslint/eslint-plugin": "^8.61.0",
+    "@typescript-eslint/parser": "^8.61.0",
     "benchmark": "^2.1.4",
     "eslint": "^8.56.0",
     "fast-glob": "^3.3.3",
-    "jest": "^29.7.0",
-    "jest-junit": "^16.0.0",
-    "prettier": "^3.1.1",
-    "rollup": "^4.46.2",
-    "ts-jest": "^29.4.1",
+    "jest": "^30.4.2",
+    "jest-junit": "^17.0.0",
+    "prettier": "^3.8.4",
+    "rollup": "^4.62.0",
+    "ts-jest": "^29.4.11",
+    "tslib": "^2.8.1",
     "typescript": "^5.3.3",
-    "zod": "^4.0.17"
+    "zod": "^4.4.3"
+  },
+  "overrides": {
+    "@babel/core": "^7.29.7",
+    "js-yaml": "^4.2.0"
   }
 }