@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/string.d.ts

@@ -14,6 +14,16 @@ interface StringJSONSchemaHints {
     format?: string;
     pattern?: string;
 }
+/**
+ * Metadata for a single string constraint, enabling Zod 4-compatible issues.
+ */
+interface StringCheckMeta {
+    readonly kind: 'min' | 'max' | 'length' | 'format' | 'regex' | 'other';
+    readonly value?: number;
+    readonly format?: string;
+    readonly pattern?: string;
+    readonly message: string | undefined;
+}
 /**
  * Configuration for string validator
  */
@@ -23,6 +33,7 @@ interface StringValidatorConfig {
     readonly errorMessage: string | undefined;
     readonly validatorType?: ValidatorType;
     readonly jsonSchema: StringJSONSchemaHints | undefined;
+    readonly checkMetas: ReadonlyArray<StringCheckMeta> | undefined;
 }
 /**
  * Immutable string validator with chainable methods
@@ -33,29 +44,31 @@ export declare class VldString extends VldBase<string, string> {
     private readonly _checks;
     private readonly _transforms;
     private readonly _isSimple;
-    private _compiledValidator;
+    private readonly _checkMetas;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
     protected constructor(config?: Partial<StringValidatorConfig>);
     /**
-     * Compile all transforms and checks into a single optimized function
-     * This eliminates loop overhead and enables better JIT optimization
-     */
-    private _compileValidator;
-    /**
-     * Get the cached compiled validator, creating it if necessary
+     * Create a new string validator
      */
-    private _getCompiledValidator;
+    static create(): VldString;
     /**
      * Returns true if this is a simple string validator with no transforms or checks
      * Used by VldObject for optimized fast-path dispatch
      */
     get isSimple(): boolean;
+    get minLength(): number | null;
+    get maxLength(): number | null;
     /**
-     * Create a new string validator
+     * Build the Zod 4-compatible VldIssue for a failed check at the given index.
      */
-    static create(): VldString;
+    private _createCheckIssue;
+    /**
+     * Run all checks against a known string and return the first failing meta, or null.
+     */
+    private _runChecks;
+    private _fallbackMeta;
     /**
      * Parse and validate a string value without allocating intermediate result objects.
      */
@@ -93,6 +106,28 @@ export declare class VldString extends VldBase<string, string> {
      * Create a new validator that checks for valid UUID format
      */
     uuid(message?: ErrorParam): VldString;
+    private format;
+    uuidv4(message?: ErrorParam): VldString;
+    uuidv6(message?: ErrorParam): VldString;
+    uuidv7(message?: ErrorParam): VldString;
+    emoji(message?: ErrorParam): VldString;
+    base64(message?: ErrorParam): VldString;
+    base64url(message?: ErrorParam): VldString;
+    jwt(message?: ErrorParam): VldString;
+    nanoid(message?: ErrorParam): VldString;
+    cuid(message?: ErrorParam): VldString;
+    cuid2(message?: ErrorParam): VldString;
+    ulid(message?: ErrorParam): VldString;
+    cidrv4(message?: ErrorParam): VldString;
+    cidrv6(message?: ErrorParam): VldString;
+    e164(message?: ErrorParam): VldString;
+    xid(message?: ErrorParam): VldString;
+    guid(message?: ErrorParam): VldString;
+    ksuid(message?: ErrorParam): VldString;
+    date(message?: ErrorParam): VldString;
+    time(message?: ErrorParam): VldString;
+    datetime(message?: ErrorParam): VldString;
+    duration(message?: ErrorParam): VldString;
     /**
      * Create a new validator with regex pattern matching
      */
@@ -105,10 +140,14 @@ export declare class VldString extends VldBase<string, string> {
      * Create a new validator that converts to lowercase
      */
     toLowerCase(): VldString;
+    lowercase(): VldString;
     /**
      * Create a new validator that converts to uppercase
      */
     toUpperCase(): VldString;
+    uppercase(): VldString;
+    normalize(form?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD'): VldString;
+    slugify(): VldString;
     /**
      * Create a new validator that checks if string starts with a substring
      */

package/dist/validators/string.js

@@ -1,4 +1 @@
-import './base.js';
-import '../locales/runtime.js';
-export { V as VldString } from '../chunks/string-BJRQod3t.js';
-import '../chunks/errors-core-BeiFUtZM.js';
+import{VldBase as s,VLD_VALIDATOR_TYPES as e,resolveErrorMessage as t}from"./base.js";import{getMessages as r}from"../locales/runtime.js";import{i}from"../chunks/ip-validation-g5LWgy9t.js";import{V as n,c as a,g as c}from"../chunks/errors-core-CerMg2rq.js";const o={email:/^[^\s@]+@[^\s@]+\.[^\s@]+$/,uuid:/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,url:/^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/,ipv4:/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,uuidv4:/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,uuidv6:/^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,uuidv7:/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,emoji:/^(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)(?:\u200D(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F))*$/u,base64:/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,base64url:/^[A-Za-z0-9_-]*$/,jwt:/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/,nanoid:/^[A-Za-z0-9_-]{21}$/,cuid:/^c[^\s-]{8,}$/i,cuid2:/^[0-9a-z]+$/,ulid:/^[0-9A-HJKMNP-TV-Z]{26}$/,cidrv4:/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(?:3[0-2]|[12]?[0-9])$/,cidrv6:/^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^(?:[0-9a-fA-F]{1,4}:){1,7}:\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,e164:/^\+[1-9]\d{1,14}$/,xid:/^[A-HJKMNP-TV-Z0-9]{20}$/,guid:/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i,ksuid:/^[0-9A-Za-z]{27}$/,isoDate:/^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/,isoTime:/^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?$/,isoDateTime:/^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z?$/,isoDuration:/^-?P(?!$)(?:\d+(?:\.\d+)?Y)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?W)?(?:\d+(?:\.\d+)?D)?(?:T(?=\d)(?:\d+(?:\.\d+)?H)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?S)?)?$/};class VldString extends s{constructor(s){super(s?.validatorType||e.STRING),this.config={checks:s?.checks||[],transforms:s?.transforms||[],errorMessage:s?.errorMessage,jsonSchema:s?.jsonSchema,checkMetas:s?.checkMetas},this._checks=this.config.checks,this._transforms=this.config.transforms,this._isSimple=0===this._checks.length&&0===this._transforms.length,this._checkMetas=this.config.checkMetas}static create(){return new VldString}get isSimple(){return this._isSimple}get minLength(){return this.config.jsonSchema?.minLength??null}get maxLength(){return this.config.jsonSchema?.maxLength??null}_createCheckIssue(s){switch(s.kind){case"min":return{code:"too_small",path:[],origin:"string",minimum:s.value,inclusive:!0,message:s.message||`Too small: expected string to have >=${s.value} characters`};case"max":return{code:"too_big",path:[],origin:"string",maximum:s.value,inclusive:!0,message:s.message||`Too big: expected string to have <=${s.value} characters`};case"length":return{code:"too_big",path:[],origin:"string",exact:s.value,message:s.message||`Too big: expected string to have exactly ${s.value} characters`};case"format":{const e={code:"invalid_format",path:[],origin:"string",format:s.format,message:s.message||`Invalid ${s.format}`};return void 0!==s.pattern&&(e.pattern=s.pattern),e}case"regex":{const e={code:"invalid_format",path:[],origin:"string",format:"regex",message:s.message||"Invalid string: does not match pattern"};return void 0!==s.pattern&&(e.pattern=s.pattern),e}default:return{code:"custom",path:[],message:s.message||"Invalid string"}}}_runChecks(s){const e=this._checks,t=this._checkMetas;for(let r=0;r<e.length;r++)if(!e[r](s))return t?.[r]??this._fallbackMeta();return null}_fallbackMeta(){return{kind:"other",message:this.config.errorMessage}}parse(s){if("string"!=typeof s)throw new n([a("string",c(s),this.config.errorMessage)]);return this._isSimple?s:this.parseKnownString(s)}parseKnownString(s){if(this._isSimple)return s;const e=this._transforms;let t=s;switch(e.length){case 0:break;case 1:t=e[0](t);break;case 2:t=e[1](e[0](t));break;case 3:t=e[2](e[1](e[0](t)));break;default:for(let s=0;s<e.length;s++)t=e[s](t)}const r=this._runChecks(t);if(r)throw new n([this._createCheckIssue(r)]);return t}safeParse(s){if("string"!=typeof s)return{success:!1,error:new n([a("string",c(s),this.config.errorMessage)])};if(this._isSimple)return{success:!0,data:s};try{return{success:!0,data:this.parseKnownString(s)}}catch(s){return s instanceof n?{success:!1,error:s}:{success:!1,error:(e=s.message,new n([{code:"invalid_string",path:[],message:e}]))}}var e}min(s,e){return new VldString({checks:[...this.config.checks,e=>e.length>=s],transforms:this.config.transforms,errorMessage:t(e,r().stringMin(s)),jsonSchema:{...this.config.jsonSchema,minLength:s},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:s,message:t(e,r().stringMin(s))}]})}max(s,e){return new VldString({checks:[...this.config.checks,e=>e.length<=s],transforms:this.config.transforms,errorMessage:t(e,r().stringMax(s)),jsonSchema:{...this.config.jsonSchema,maxLength:s},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:s,message:t(e,r().stringMax(s))}]})}length(s,e){return new VldString({checks:[...this.config.checks,e=>e.length===s],transforms:this.config.transforms,errorMessage:t(e,r().stringLength(s)),jsonSchema:{...this.config.jsonSchema,exactLength:s},checkMetas:[...this.config.checkMetas??[],{kind:"length",value:s,message:t(e,r().stringLength(s))}]})}email(s){return new VldString({checks:[...this.config.checks,s=>o.email.test(s)],transforms:this.config.transforms,errorMessage:t(s,r().stringEmail),jsonSchema:{...this.config.jsonSchema,format:"email"},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:"email",message:t(s,r().stringEmail)}]})}url(s){return new VldString({checks:[...this.config.checks,s=>o.url.test(s)],transforms:this.config.transforms,errorMessage:t(s,r().stringUrl),jsonSchema:{...this.config.jsonSchema,format:"uri"},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:"url",message:t(s,r().stringUrl)}]})}uuid(s){return new VldString({checks:[...this.config.checks,s=>o.uuid.test(s)],transforms:this.config.transforms,errorMessage:t(s,r().stringUuid),jsonSchema:{...this.config.jsonSchema,format:"uuid"},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:"uuid",message:t(s,r().stringUuid)}]})}format(s,e,r){return new VldString({checks:[...this.config.checks,e=>s.test(e)],transforms:this.config.transforms,errorMessage:t(r,`Invalid ${e}`),jsonSchema:{...this.config.jsonSchema,format:e,pattern:s.source},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:e,pattern:s.source,message:t(r,`Invalid ${e}`)}]})}uuidv4(s){return this.format(o.uuidv4,"uuid",s)}uuidv6(s){return this.format(o.uuidv6,"uuid",s)}uuidv7(s){return this.format(o.uuidv7,"uuid",s)}emoji(s){return this.format(o.emoji,"emoji",s)}base64(s){return this.format(o.base64,"base64",s)}base64url(s){return this.format(o.base64url,"base64url",s)}jwt(s){return this.format(o.jwt,"jwt",s)}nanoid(s){return this.format(o.nanoid,"nanoid",s)}cuid(s){return this.format(o.cuid,"cuid",s)}cuid2(s){return this.format(o.cuid2,"cuid2",s)}ulid(s){return this.format(o.ulid,"ulid",s)}cidrv4(s){return this.format(o.cidrv4,"cidrv4",s)}cidrv6(s){return this.format(o.cidrv6,"cidrv6",s)}e164(s){return this.format(o.e164,"e164",s)}xid(s){return this.format(o.xid,"xid",s)}guid(s){return this.format(o.guid,"guid",s)}ksuid(s){return this.format(o.ksuid,"ksuid",s)}date(s){return this.format(o.isoDate,"date",s)}time(s){return this.format(o.isoTime,"time",s)}datetime(s){return this.format(o.isoDateTime,"datetime",s)}duration(s){return this.format(o.isoDuration,"duration",s)}regex(s,e){return new VldString({checks:[...this.config.checks,e=>s.test(e)],transforms:this.config.transforms,errorMessage:t(e,r().stringRegex),jsonSchema:{...this.config.jsonSchema,pattern:s.source},checkMetas:[...this.config.checkMetas??[],{kind:"regex",pattern:s.source,message:t(e,r().stringRegex)}]})}trim(){return new VldString({checks:this.config.checks,transforms:[...this.config.transforms,s=>s.trim()],errorMessage:this.config.errorMessage,jsonSchema:this.config.jsonSchema})}toLowerCase(){return new VldString({checks:this.config.checks,transforms:[...this.config.transforms,s=>s.toLowerCase()],errorMessage:this.config.errorMessage,jsonSchema:this.config.jsonSchema})}lowercase(){return this.toLowerCase()}toUpperCase(){return new VldString({checks:this.config.checks,transforms:[...this.config.transforms,s=>s.toUpperCase()],errorMessage:this.config.errorMessage,jsonSchema:this.config.jsonSchema})}uppercase(){return this.toUpperCase()}normalize(s){return new VldString({checks:this.config.checks,transforms:[...this.config.transforms,e=>e.normalize(s)],errorMessage:this.config.errorMessage,jsonSchema:this.config.jsonSchema})}slugify(){return new VldString({checks:this.config.checks,transforms:[...this.config.transforms,s=>s.toLowerCase().trim().replace(/[^\w\s-]/g,"").replace(/[\s_-]+/g,"-").replace(/^-+|-+$/g,"")],errorMessage:this.config.errorMessage,jsonSchema:this.config.jsonSchema})}startsWith(s,e){return new VldString({checks:[...this.config.checks,e=>e.startsWith(s)],transforms:this.config.transforms,errorMessage:t(e,r().stringStartsWith(s)),jsonSchema:this.config.jsonSchema})}endsWith(s,e){return new VldString({checks:[...this.config.checks,e=>e.endsWith(s)],transforms:this.config.transforms,errorMessage:t(e,r().stringEndsWith(s)),jsonSchema:this.config.jsonSchema})}includes(s,e){return new VldString({checks:[...this.config.checks,e=>e.includes(s)],transforms:this.config.transforms,errorMessage:t(e,r().stringIncludes(s)),jsonSchema:this.config.jsonSchema})}ip(s){return new VldString({checks:[...this.config.checks,s=>!(s.length>100)&&(o.ipv4.test(s)||i(s))],transforms:this.config.transforms,errorMessage:t(s,r().stringIp),jsonSchema:{...this.config.jsonSchema,format:"ip"},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:"ip",message:t(s,r().stringIp)}]})}ipv4(s){return new VldString({checks:[...this.config.checks,s=>o.ipv4.test(s)],transforms:this.config.transforms,errorMessage:t(s,r().stringIpv4),jsonSchema:{...this.config.jsonSchema,format:"ipv4"},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:"ipv4",message:t(s,r().stringIpv4)}]})}ipv6(s){return new VldString({checks:[...this.config.checks,s=>i(s)],transforms:this.config.transforms,errorMessage:t(s,r().stringIpv6),jsonSchema:{...this.config.jsonSchema,format:"ipv6"},checkMetas:[...this.config.checkMetas??[],{kind:"format",format:"ipv6",message:t(s,r().stringIpv6)}]})}nonempty(s){return new VldString({checks:[...this.config.checks,s=>s.length>0],transforms:this.config.transforms,errorMessage:t(s,r().stringEmpty),jsonSchema:{...this.config.jsonSchema,minLength:Math.max(this.config.jsonSchema?.minLength||0,1)},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:1,message:t(s,r().stringEmpty)}]})}}export{VldString};

package/dist/validators/symbol.js

@@ -1,58 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createSymbolError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable symbol validator
- */
-class VldSymbol extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(errorMessage) {
-        super(VLD_VALIDATOR_TYPES.SYMBOL);
-        this.errorMessage = errorMessage;
-    }
-    /**
-     * Create a new symbol validator
-     */
-    static create() {
-        return new VldSymbol();
-    }
-    get isSimple() {
-        return true;
-    }
-    /**
-     * Parse and validate a symbol value
-     */
-    parse(value) {
-        if (typeof value !== 'symbol') {
-            throw new Error(this.errorMessage || getMessages().invalidSymbol);
-        }
-        return value;
-    }
-    /**
-     * Parse a value that has already passed the symbol type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownSymbol(value) {
-        return value;
-    }
-    /**
-     * Safely parse and validate a symbol value
-     */
-    safeParse(value) {
-        if (typeof value === 'symbol') {
-            return { success: true, data: value };
-        }
-        return {
-            success: false,
-            error: createSymbolError(this.errorMessage || getMessages().invalidSymbol)
-        };
-    }
-}
-
-export { VldSymbol };
+import{VldBase as r,VLD_VALIDATOR_TYPES as e}from"./base.js";import{getMessages as s}from"../locales/runtime.js";import{V as o}from"../chunks/errors-core-CerMg2rq.js";class VldSymbol extends r{constructor(r){super(e.SYMBOL),this.errorMessage=r}static create(){return new VldSymbol}get isSimple(){return!0}parse(r){if("symbol"!=typeof r)throw new Error(this.errorMessage||s().invalidSymbol);return r}parseKnownSymbol(r){return r}safeParse(r){return"symbol"==typeof r?{success:!0,data:r}:{success:!1,error:(e=this.errorMessage||s().invalidSymbol,new o([{code:"invalid_type",path:[],message:e}]))};var e}}export{VldSymbol};

package/dist/validators/template-literal.js

@@ -1,103 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-
-/**
- * Immutable template literal validator
- * Validates strings matching a template pattern
- */
-class VldTemplateLiteral extends VldBase {
-    constructor(pattern) {
-        super(VLD_VALIDATOR_TYPES.TEMPLATE_LITERAL);
-        this.pattern = pattern;
-    }
-    /**
-     * Create a template literal validator from components
-     */
-    static create(...components) {
-        // Build regex pattern from components
-        let pattern = '^';
-        for (const comp of components) {
-            if (typeof comp === 'string') {
-                // Escape special regex characters
-                pattern += comp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            }
-            else {
-                // Add appropriate pattern based on validator type
-                pattern += getPatternForValidator(comp);
-            }
-        }
-        pattern += '$';
-        return new VldTemplateLiteral(new RegExp(pattern));
-    }
-    /**
-     * Parse and validate a template literal string
-     */
-    parse(value) {
-        if (typeof value !== 'string') {
-            throw new Error(getMessages().invalidString);
-        }
-        if (!this.pattern.test(value)) {
-            throw new Error(getMessages().stringPatternInvalid);
-        }
-        return value;
-    }
-    /**
-     * Safely parse and validate a template literal string
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error
-            };
-        }
-    }
-}
-/**
- * Get regex pattern for a validator type
- */
-function getPatternForValidator(validator) {
-    // For template literals, we need to identify the validator type
-    // and return an appropriate capture group pattern
-    switch (validator.validatorType) {
-        case VLD_VALIDATOR_TYPES.STRING:
-        case VLD_VALIDATOR_TYPES.STRING_FORMAT:
-            return '(.+)';
-        case VLD_VALIDATOR_TYPES.NUMBER:
-        case VLD_VALIDATOR_TYPES.COERCE_NUMBER:
-            return '(-?\\d+(?:\\.\\d+)?)';
-        case VLD_VALIDATOR_TYPES.BIGINT:
-        case VLD_VALIDATOR_TYPES.COERCE_BIGINT:
-            return '(-?\\d+)';
-        case VLD_VALIDATOR_TYPES.BOOLEAN:
-        case VLD_VALIDATOR_TYPES.COERCE_BOOLEAN:
-            return '(true|false)';
-        case VLD_VALIDATOR_TYPES.NULL:
-            return '(null)';
-        case VLD_VALIDATOR_TYPES.UNDEFINED:
-        case VLD_VALIDATOR_TYPES.VOID:
-            return '(undefined)';
-        case VLD_VALIDATOR_TYPES.LITERAL: {
-            const literalValidator = validator;
-            if (literalValidator.literal !== undefined) {
-                const valueStr = String(literalValidator.literal);
-                return '(' + valueStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ')';
-            }
-            break;
-        }
-    }
-    // Default: match any string
-    return '(.+)';
-}
-/**
- * Helper function to create template literal validators
- * Usage: v.templateLiteral(v.string(), '-', v.number())
- */
-function templateLiteral(...components) {
-    return VldTemplateLiteral.create(...components);
-}
-
-export { VldTemplateLiteral, templateLiteral };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r,ensureVldError as t}from"./base.js";import{getMessages as a}from"../locales/runtime.js";class VldTemplateLiteral extends e{constructor(e){super(r.TEMPLATE_LITERAL),this.pattern=e}static create(...e){let r="^";for(const t of e)r+="string"==typeof t?t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"):s(t);return r+="$",new VldTemplateLiteral(new RegExp(r))}parse(e){if("string"!=typeof e)throw new Error(a().invalidString);if(!this.pattern.test(e))throw new Error(a().stringPatternInvalid);return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:t(e)}}}}function s(e){switch(e.validatorType){case r.STRING:case r.STRING_FORMAT:return"(.+)";case r.NUMBER:case r.COERCE_NUMBER:return"(-?\\d+(?:\\.\\d+)?)";case r.BIGINT:case r.COERCE_BIGINT:return"(-?\\d+)";case r.BOOLEAN:case r.COERCE_BOOLEAN:return"(true|false)";case r.NULL:return"(null)";case r.UNDEFINED:case r.VOID:return"(undefined)";case r.LITERAL:{const r=e;if(void 0!==r.literal){return"("+String(r.literal).replace(/[.*+?^${}()|[\]\\]/g,"\\$&")+")"}break}}return"(.+)"}function n(...e){return VldTemplateLiteral.create(...e)}export{VldTemplateLiteral,n as templateLiteral};

package/dist/validators/tuple.d.ts

@@ -1,12 +1,15 @@
 import { VldBase, ParseResult } from './base.js';
+type FixedTupleOutput<T extends readonly VldBase<any, any>[]> = {
+    -readonly [K in keyof T]: ReturnType<T[K]['parse']>;
+};
+type TupleOutput<T extends readonly VldBase<any, any>[], TRest extends VldBase<any, any> | null> = TRest extends VldBase<any, any> ? [...FixedTupleOutput<T>, ...ReturnType<TRest['parse']>[]] : FixedTupleOutput<T>;
 /**
  * Immutable tuple validator for fixed-length arrays
  */
-export declare class VldTuple<T extends readonly VldBase<any, any>[]> extends VldBase<unknown, {
-    [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
-}> {
+export declare class VldTuple<T extends readonly VldBase<any, any>[], TRest extends VldBase<any, any> | null = null> extends VldBase<unknown, TupleOutput<T, TRest>> {
     private readonly validators;
     private readonly errorMessage?;
+    private readonly restValidator;
     /**
      * Private constructor to enforce immutability
      */
@@ -21,24 +24,25 @@ export declare class VldTuple<T extends readonly VldBase<any, any>[]> extends Vl
     /**
      * Create a new tuple validator
      */
-    static create<T extends readonly VldBase<any, any>[]>(...validators: T): VldTuple<T>;
+    static create<T extends readonly VldBase<any, any>[]>(...validators: T): VldTuple<T, null>;
+    rest<TSchema extends VldBase<any, any>>(validator: TSchema): VldTuple<T, TSchema>;
     /**
      * Parse and validate a tuple value
      */
-    parse(value: unknown): {
-        [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
-    };
+    parse(value: unknown): TupleOutput<T, TRest>;
     /**
      * Parse a value that has already passed the tuple array type guard.
      * @internal Used by object validators to avoid duplicate hot-path checks.
      */
-    parseKnownTuple(value: unknown[]): {
-        [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
-    };
+    parseKnownTuple(value: unknown[]): TupleOutput<T, TRest>;
     /**
      * Safely parse and validate a tuple value
      */
-    safeParse(value: unknown): ParseResult<{
-        [K in keyof T]: T[K] extends VldBase<any, infer U> ? U : never;
-    }>;
+    safeParse(value: unknown): ParseResult<TupleOutput<T, TRest>>;
+    encode(value: TupleOutput<T, TRest>): unknown;
+    safeEncode(value: TupleOutput<T, TRest>): ParseResult<unknown>;
+    encodeAsync(value: TupleOutput<T, TRest>): Promise<unknown>;
+    safeEncodeAsync(value: TupleOutput<T, TRest>): Promise<ParseResult<unknown>>;
+    private validateEncodedLength;
 }
+export {};

package/dist/validators/tuple.js

@@ -1,183 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createTupleError(message) {
-    return new VldError([{ code: 'invalid_array', path: [], message }]);
-}
-/**
- * Immutable tuple validator for fixed-length arrays
- */
-class VldTuple extends VldBase {
-    constructor(validators, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.TUPLE);
-        this.validators = validators;
-        this.errorMessage = errorMessage;
-        this._length = validators.length;
-        this._validatorTypes = validators.map(validator => validator.validatorType);
-        this._simpleItemModes = validators.map((validator, index) => this.getSimpleItemMode(validator, this._validatorTypes[index]));
-        this._simpleItemValues = validators.map((validator, index) => this._simpleItemModes[index] === 'literal' ? validator.literal : undefined);
-    }
-    get items() {
-        return this.validators;
-    }
-    getSimpleItemMode(validator, type) {
-        if (validator.isSimple !== true) {
-            return undefined;
-        }
-        switch (type) {
-            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;
-        }
-    }
-    getSimpleItemError(mode, expected, received) {
-        switch (mode) {
-            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(expected), JSON.stringify(received));
-            default:
-                return getMessages().invalidTuple;
-        }
-    }
-    /**
-     * Create a new tuple validator
-     */
-    static create(...validators) {
-        return new VldTuple(validators);
-    }
-    /**
-     * Parse and validate a tuple value
-     */
-    parse(value) {
-        if (!Array.isArray(value)) {
-            throw new Error(this.errorMessage || getMessages().invalidTuple);
-        }
-        return this.parseKnownTuple(value);
-    }
-    /**
-     * Parse a value that has already passed the tuple array type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownTuple(value) {
-        if (value.length !== this._length) {
-            throw new Error(this.errorMessage ||
-                getMessages().tupleLength(this._length, value.length));
-        }
-        const result = new Array(this._length);
-        for (let i = 0; i < this._length; i++) {
-            const simpleMode = this._simpleItemModes[i];
-            const item = value[i];
-            if (simpleMode !== undefined) {
-                switch (simpleMode) {
-                    case 'string':
-                        if (typeof item !== 'string') {
-                            throw new Error(getMessages().arrayItem(i, getMessages().invalidString));
-                        }
-                        result[i] = item;
-                        continue;
-                    case 'number':
-                        if (typeof item !== 'number' || isNaN(item)) {
-                            throw new Error(getMessages().arrayItem(i, getMessages().invalidNumber));
-                        }
-                        result[i] = item;
-                        continue;
-                    case 'boolean':
-                        if (typeof item !== 'boolean') {
-                            throw new Error(getMessages().arrayItem(i, getMessages().invalidBoolean));
-                        }
-                        result[i] = item;
-                        continue;
-                    case 'bigint':
-                        if (typeof item !== 'bigint') {
-                            throw new Error(getMessages().arrayItem(i, getMessages().invalidBigint));
-                        }
-                        result[i] = item;
-                        continue;
-                    case 'symbol':
-                        if (typeof item !== 'symbol') {
-                            throw new Error(getMessages().arrayItem(i, getMessages().invalidSymbol));
-                        }
-                        result[i] = item;
-                        continue;
-                    case 'null':
-                        if (item !== null) {
-                            throw new Error(getMessages().arrayItem(i, this.getSimpleItemError(simpleMode, undefined, item)));
-                        }
-                        result[i] = null;
-                        continue;
-                    case 'undefinedValue':
-                        if (item !== undefined) {
-                            throw new Error(getMessages().arrayItem(i, getMessages().expectedUndefined));
-                        }
-                        result[i] = undefined;
-                        continue;
-                    case 'literal': {
-                        const literal = this._simpleItemValues[i];
-                        if (item !== literal) {
-                            throw new Error(getMessages().arrayItem(i, this.getSimpleItemError(simpleMode, literal, item)));
-                        }
-                        result[i] = literal;
-                        continue;
-                    }
-                    case 'passthrough':
-                        result[i] = item;
-                        continue;
-                }
-            }
-            try {
-                const validator = this.validators[i];
-                result[i] = validator.parse(item);
-            }
-            catch (error) {
-                throw new Error(getMessages().arrayItem(i, error.message));
-            }
-        }
-        return result;
-    }
-    /**
-     * Safely parse and validate a tuple value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createTupleError(error.message) };
-        }
-    }
-}
-
-export { VldTuple };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";function i(e){return new s([{code:"invalid_array",path:[],message:e}])}class VldTuple extends e{constructor(e,t,s=null){super(r.TUPLE),this.validators=e,this.errorMessage=t,this.restValidator=s,this._length=e.length,this._validatorTypes=e.map(e=>e.validatorType),this._simpleItemModes=e.map((e,r)=>this.getSimpleItemMode(e,this._validatorTypes[r])),this._simpleItemValues=e.map((e,r)=>"literal"===this._simpleItemModes[r]?e.literal:void 0)}get items(){return this.validators}getSimpleItemMode(e,t){if(!0===e.isSimple)switch(t){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}}getSimpleItemError(e,r,s){switch(e){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 s;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(r),JSON.stringify(s));default:return t().invalidTuple}}static create(...e){return new VldTuple(e)}rest(e){return new VldTuple(this.validators,this.errorMessage,e)}parse(e){if(!Array.isArray(e))throw new Error(this.errorMessage||t().invalidTuple);return this.parseKnownTuple(e)}parseKnownTuple(e){if(null===this.restValidator&&e.length!==this._length||null!==this.restValidator&&e.length<this._length)throw new Error(this.errorMessage||t().tupleLength(this._length,e.length));const r=new Array(e.length);for(let s=0;s<this._length;s++){const i=this._simpleItemModes[s],n=e[s];if(void 0!==i)switch(i){case"string":if("string"!=typeof n)throw new Error(t().arrayItem(s,t().invalidString));r[s]=n;continue;case"number":if("number"!=typeof n||isNaN(n))throw new Error(t().arrayItem(s,t().invalidNumber));r[s]=n;continue;case"boolean":if("boolean"!=typeof n)throw new Error(t().arrayItem(s,t().invalidBoolean));r[s]=n;continue;case"bigint":if("bigint"!=typeof n)throw new Error(t().arrayItem(s,t().invalidBigint));r[s]=n;continue;case"symbol":if("symbol"!=typeof n)throw new Error(t().arrayItem(s,t().invalidSymbol));r[s]=n;continue;case"null":if(null!==n)throw new Error(t().arrayItem(s,this.getSimpleItemError(i,void 0,n)));r[s]=null;continue;case"undefinedValue":if(void 0!==n)throw new Error(t().arrayItem(s,t().expectedUndefined));r[s]=void 0;continue;case"literal":{const e=this._simpleItemValues[s];if(n!==e)throw new Error(t().arrayItem(s,this.getSimpleItemError(i,e,n)));r[s]=e;continue}case"passthrough":r[s]=n;continue}try{const e=this.validators[s];r[s]=e.parse(n)}catch(e){throw new Error(t().arrayItem(s,e.message))}}if(this.restValidator)for(let s=this._length;s<e.length;s++)try{r[s]=this.restValidator.parse(e[s])}catch(e){throw new Error(t().arrayItem(s,e.message))}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:i(e.message)}}}encode(e){if(!Array.isArray(e))throw new Error(this.errorMessage||t().invalidTuple);this.validateEncodedLength(e.length);const r=new Array(e.length);for(let t=0;t<this._length;t++)r[t]=this.validators[t].encode(e[t]);if(this.restValidator)for(let t=this._length;t<e.length;t++)r[t]=this.restValidator.encode(e[t]);return r}safeEncode(e){try{return{success:!0,data:this.encode(e)}}catch(e){return{success:!1,error:i(e.message)}}}async encodeAsync(e){if(!Array.isArray(e))throw new Error(this.errorMessage||t().invalidTuple);this.validateEncodedLength(e.length);const r=new Array(e.length);for(let t=0;t<this._length;t++)r[t]=await this.validators[t].encodeAsync(e[t]);if(this.restValidator)for(let t=this._length;t<e.length;t++)r[t]=await this.restValidator.encodeAsync(e[t]);return r}async safeEncodeAsync(e){try{return{success:!0,data:await this.encodeAsync(e)}}catch(e){return{success:!1,error:i(e.message)}}}validateEncodedLength(e){if(null===this.restValidator&&e!==this._length||null!==this.restValidator&&e<this._length)throw new Error(this.errorMessage||t().tupleLength(this._length,e))}}export{VldTuple};

package/dist/validators/uint8array.js

@@ -1,101 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { createIssue } from '../errors.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * Uint8Array validator with immutable configuration
- * BUG-NEW-010 FIX: Refactored to follow immutability pattern
- */
-class VldUint8Array extends VldBase {
-    /**
-     * Protected constructor to maintain immutability
-     */
-    constructor(config) {
-        super(VLD_VALIDATOR_TYPES.UINT8_ARRAY);
-        this.config = config || {};
-    }
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    safeParse(value) {
-        if (!(value instanceof Uint8Array)) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('invalid_type', [], getMessages().expectedUint8Array)
-                ])
-            };
-        }
-        // Check exact length if specified
-        if (this.config.exactLength !== undefined && value.length !== this.config.exactLength) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().uint8ArrayExactLength(this.config.exactLength))
-                ])
-            };
-        }
-        // Check minimum length
-        if (this.config.minLength !== undefined && value.length < this.config.minLength) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().uint8ArrayMinLength(this.config.minLength))
-                ])
-            };
-        }
-        // Check maximum length
-        if (this.config.maxLength !== undefined && value.length > this.config.maxLength) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().uint8ArrayMaxLength(this.config.maxLength))
-                ])
-            };
-        }
-        return { success: true, data: value };
-    }
-    /**
-     * Set minimum byte length
-     * Returns new immutable validator instance
-     */
-    min(length) {
-        return new VldUint8Array({
-            ...this.config,
-            minLength: length
-        });
-    }
-    /**
-     * Set maximum byte length
-     * Returns new immutable validator instance
-     */
-    max(length) {
-        return new VldUint8Array({
-            ...this.config,
-            maxLength: length
-        });
-    }
-    /**
-     * Set exact byte length
-     * Returns new immutable validator instance
-     * Clears min/max when setting exact length
-     */
-    length(length) {
-        return new VldUint8Array({
-            exactLength: length,
-            // Clear min/max when exact length is set
-            minLength: undefined,
-            maxLength: undefined
-        });
-    }
-    static create() {
-        return new VldUint8Array();
-    }
-}
-
-export { VldUint8Array };
+import{VldBase as t,VLD_VALIDATOR_TYPES as r}from"./base.js";import{createIssue as n}from"../errors.js";import{getMessages as e}from"../locales/runtime.js";import{V as i}from"../chunks/errors-core-CerMg2rq.js";class VldUint8Array extends t{constructor(t){super(r.UINT8_ARRAY),this.config=t||{}}parse(t){const r=this.safeParse(t);if(!r.success)throw r.error;return r.data}safeParse(t){return t instanceof Uint8Array?void 0!==this.config.exactLength&&t.length!==this.config.exactLength?{success:!1,error:new i([n("custom",[],e().uint8ArrayExactLength(this.config.exactLength))])}:void 0!==this.config.minLength&&t.length<this.config.minLength?{success:!1,error:new i([n("custom",[],e().uint8ArrayMinLength(this.config.minLength))])}:void 0!==this.config.maxLength&&t.length>this.config.maxLength?{success:!1,error:new i([n("custom",[],e().uint8ArrayMaxLength(this.config.maxLength))])}:{success:!0,data:t}:{success:!1,error:new i([n("invalid_type",[],e().expectedUint8Array)])}}min(t){return new VldUint8Array({...this.config,minLength:t})}max(t){return new VldUint8Array({...this.config,maxLength:t})}length(t){return new VldUint8Array({exactLength:t,minLength:void 0,maxLength:void 0})}static create(){return new VldUint8Array}}export{VldUint8Array};