unischema 1.1.0 → 1.2.0

package/README.md

@@ -98,15 +98,144 @@ const emailProps = form.getFieldProps('email');
 
 ## 🎯 Features
 
-- ✅ **50+ Built-in Validators** - Email, URL, IPv4/IPv6, phone, coordinates, and more
+- ✅ **53+ Built-in Validators** - Email, URL, IPv4/IPv6, phone, coordinates, and more
+- ✅ **Async Validation** - Database checks, API validation with debouncing
+- ✅ **Data Transformation** - Transform & coerce values before validation
+- ✅ **Advanced Schema Composition** - deepPartial, passthrough, strict, catchall
 - ✅ **Isomorphic** - Same code runs in browser and Node.js
 - ✅ **TypeScript First** - Automatic type inference
 - ✅ **Hard & Soft Validation** - Errors vs warnings for enterprise apps
+- ✅ **Nullable/Nullish Support** - Proper null/undefined handling
 - ✅ **Tree-Shakeable** - Only bundle what you use (~2KB min+gzip)
 - ✅ **Framework Agnostic** - Works with React, Vue, Svelte, Angular, etc.
 - ✅ **Zero Dependencies** - Lightweight and fast
 
-## 📚 All Validators (v1.1.0)
+## 🆕 What's New in v1.2.0 - Production Ready!
+
+Phase 1 is complete! Unischema now includes powerful features for production applications:
+
+### Async Validation
+
+Validate against external APIs, databases, or async operations with built-in debouncing:
+
+```typescript
+const UserSchema = schema({
+  email: field.string()
+    .email()
+    .refineAsync(async (email) => {
+      const exists = await checkEmailExists(email);
+      return !exists || { message: 'Email already registered' };
+    }, { debounce: 500, timeout: 5000 }),
+
+  username: field.string()
+    .refineAsync(async (name) => {
+      const available = await api.checkUsername(name);
+      return available;
+    }, { debounce: 300, message: 'Username taken' })
+});
+
+// Use async validation
+const result = await validateAsync(UserSchema.definition, data);
+```
+
+### Data Transformation & Coercion
+
+Transform and coerce values before validation:
+
+```typescript
+// Transform strings
+const LoginSchema = schema({
+  email: field.string()
+    .transform(s => s.trim())
+    .transform(s => s.toLowerCase())
+    .email(),
+
+  name: field.string()
+    .transform(s => s.trim())
+    .transform(s => s.replace(/\s+/g, ' '))  // Normalize whitespace
+});
+
+// Type coercion from form inputs
+const FormSchema = schema({
+  age: coerce.number().min(18),          // "25" → 25
+  active: coerce.boolean(),              // "true" → true
+  startDate: coerce.date(),              // "2024-01-01" → Date
+  tags: coerce.array(field.string()),    // "javascript" → ["javascript"]
+});
+
+// Preprocessing for nullable values
+const ProfileSchema = schema({
+  bio: field.string()
+    .preprocess(s => s?.trim())  // Handle null/undefined safely
+    .nullable()
+});
+```
+
+### Advanced Schema Composition
+
+More flexible schema manipulation:
+
+```typescript
+const BaseSchema = schema({
+  id: field.string(),
+  name: field.string().required(),
+  email: field.string().email().required(),
+});
+
+// Deep partial - make all fields optional recursively
+const PartialSchema = deepPartial(BaseSchema);
+
+// Passthrough - allow unknown keys
+const FlexibleSchema = passthrough(BaseSchema);
+
+// Strict mode - reject unknown keys
+const StrictSchema = strict(BaseSchema);
+
+// Catchall - handle unknown keys with validation
+const CatchAllSchema = catchall(BaseSchema, field.string());
+
+// Make specific fields required/optional
+const RequiredFields = required(BaseSchema, ['name', 'email']);
+const OptionalFields = optional(BaseSchema, ['email']);
+```
+
+### Nullable & Nullish Handling
+
+Better null/undefined value handling:
+
+```typescript
+const UserSchema = schema({
+  // Allow null
+  middleName: field.string().nullable(),  // string | null
+
+  // Allow null or undefined
+  bio: field.string().nullish(),          // string | null | undefined
+
+  // Required but nullable
+  avatar: field.string().nullable().required(),
+});
+```
+
+### Enhanced Error Context
+
+Get detailed error information:
+
+```typescript
+const result = validate(schema({ age: field.number().min(18) }), { age: 15 });
+
+result.hardErrors[0];
+// {
+//   field: "age",
+//   code: "MIN_VALUE",
+//   message: "Value must be at least 18",
+//   severity: "hard",
+//   received: 15,     // ✨ The actual value
+//   expected: { min: 18 }  // ✨ The constraint that failed
+//   path: ["age"]     // ✨ Path as array
+// }
+```
+
+## 📚 All Validators (v1.2.0)
 
 ### String Validators (17)
 
@@ -714,17 +843,37 @@ Import only what you use for minimal bundle size.
 
 ```typescript
 import {
+  // Schema creation
   schema,           // Create schema
   field,            // Field builders
+  coerce,           // Type coercion builders
+
+  // Sync validation
   validate,         // Validate data
   validateSchema,   // Validate with schema
   isValid,          // Boolean validation
   assertValid,      // Throws if invalid
+
+  // Async validation (v1.2.0)
+  validateAsync,    // Async validate data
+  validateSchemaAsync, // Async validate with schema
+  isValidAsync,     // Async boolean validation
+  assertValidAsync, // Async throws if invalid
+
+  // Schema composition
   extend,           // Extend schema
   pick,             // Pick fields
   omit,             // Omit fields
   merge,            // Merge schemas
   partial,          // Make all optional
+  deepPartial,      // Make all optional recursively (v1.2.0)
+  passthrough,      // Allow unknown keys (v1.2.0)
+  strict,           // Reject unknown keys (v1.2.0)
+  catchall,         // Validate unknown keys (v1.2.0)
+  required,         // Make specific fields required (v1.2.0)
+  optional,         // Make specific fields optional (v1.2.0)
+
+  // Type inference
   type InferInput,  // Input type
   type InferOutput  // Output type
 } from 'unischema';

package/dist/adapters/backend/index.d.mts

@@ -1,6 +1,6 @@
 import { Request, Response, RequestHandler, NextFunction } from 'express';
-import { S as SchemaBuilder, I as InferInput } from '../../schema-DYU1zGVm.mjs';
-import { b as ValidationResult, E as EnterpriseValidationResponse } from '../../index-BQR7OrY7.mjs';
+import { S as SchemaBuilder, I as InferInput } from '../../schema-DYE8Wz8X.mjs';
+import { b as ValidationResult, E as EnterpriseValidationResponse } from '../../index-C17xs-fU.mjs';
 
 /**
  * Express.js middleware adapter for FormSchema validation

package/dist/adapters/backend/index.d.ts

@@ -1,6 +1,6 @@
 import { Request, Response, RequestHandler, NextFunction } from 'express';
-import { S as SchemaBuilder, I as InferInput } from '../../schema-CpAjXgEF.js';
-import { b as ValidationResult, E as EnterpriseValidationResponse } from '../../index-BQR7OrY7.js';
+import { S as SchemaBuilder, I as InferInput } from '../../schema-Dtp-joeT.js';
+import { b as ValidationResult, E as EnterpriseValidationResponse } from '../../index-C17xs-fU.js';
 
 /**
  * Express.js middleware adapter for FormSchema validation

package/dist/adapters/backend/index.js

@@ -1,14 +1,14 @@
 'use strict';
 
 var chunkBVRXGZLS_js = require('../../chunk-BVRXGZLS.js');
-var chunkBJLVOIAP_js = require('../../chunk-BJLVOIAP.js');
-require('../../chunk-BNIB23NQ.js');
-require('../../chunk-2JYFKT3R.js');
-require('../../chunk-CQYXR2LZ.js');
-require('../../chunk-3FANCMEF.js');
-require('../../chunk-FZ7K2PC7.js');
-require('../../chunk-ASKTY6EG.js');
-require('../../chunk-NUW55QTO.js');
+var chunkDT2TQZU7_js = require('../../chunk-DT2TQZU7.js');
+require('../../chunk-76BBWQDH.js');
+require('../../chunk-FPCCH55A.js');
+require('../../chunk-JEW6U6CB.js');
+require('../../chunk-IUXRLMET.js');
+require('../../chunk-TXT36BCE.js');
+require('../../chunk-66RFUBVU.js');
+require('../../chunk-OIYG5D2I.js');
 
 // src/adapters/backend/express.ts
 function defaultErrorHandler(result, _req, res) {
@@ -38,7 +38,7 @@ function validateRequest(schema, options = {}) {
     if (transform) {
       data = transform(data);
     }
-    const result = chunkBJLVOIAP_js.validate(schema.definition, data);
+    const result = chunkDT2TQZU7_js.validate(schema.definition, data);
     req.validationResult = result;
     if (!result.valid) {
       onError(result, req, res);
@@ -120,7 +120,7 @@ function createHandler(schema, handler, options = {}) {
         };
       }
     }
-    const validation = chunkBJLVOIAP_js.validate(schema.definition, data);
+    const validation = chunkDT2TQZU7_js.validate(schema.definition, data);
     if (!validation.valid) {
       return {
         statusCode: 400,
@@ -176,7 +176,7 @@ function createHandler(schema, handler, options = {}) {
 }
 function validateInput(schema, input) {
   const data = typeof input === "string" ? JSON.parse(input) : input;
-  const result = chunkBJLVOIAP_js.validate(schema.definition, data);
+  const result = chunkDT2TQZU7_js.validate(schema.definition, data);
   return {
     valid: result.valid,
     data: result.valid ? data : null,

package/dist/adapters/backend/index.mjs

@@ -1,12 +1,12 @@
 import { toEnterpriseResponse } from '../../chunk-TTK77YBI.mjs';
-import { validate } from '../../chunk-3TS35CVJ.mjs';
-import '../../chunk-KHHJD6QK.mjs';
-import '../../chunk-XC4DKEXP.mjs';
-import '../../chunk-FRBZHN4K.mjs';
-import '../../chunk-VWP24NYS.mjs';
-import '../../chunk-ELL7U7IC.mjs';
-import '../../chunk-XGTUU27F.mjs';
-import '../../chunk-FKDWSZIV.mjs';
+import { validate } from '../../chunk-MFEBMQAU.mjs';
+import '../../chunk-75YSYC4K.mjs';
+import '../../chunk-KZCV5IW4.mjs';
+import '../../chunk-COMVAVFU.mjs';
+import '../../chunk-RW6HDA5H.mjs';
+import '../../chunk-7XES4A3M.mjs';
+import '../../chunk-5A4ITJVD.mjs';
+import '../../chunk-KZZ7NVU3.mjs';
 
 // src/adapters/backend/express.ts
 function defaultErrorHandler(result, _req, res) {

package/dist/adapters/frontend/index.d.mts

@@ -1,5 +1,5 @@
-import { S as SchemaBuilder, I as InferInput } from '../../schema-DYU1zGVm.mjs';
-import { a as ValidationError, b as ValidationResult } from '../../index-BQR7OrY7.mjs';
+import { S as SchemaBuilder, I as InferInput } from '../../schema-DYE8Wz8X.mjs';
+import { a as ValidationError, b as ValidationResult } from '../../index-C17xs-fU.mjs';
 
 /**
  * Headless form utilities for frontend frameworks

package/dist/adapters/frontend/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SchemaBuilder, I as InferInput } from '../../schema-CpAjXgEF.js';
-import { a as ValidationError, b as ValidationResult } from '../../index-BQR7OrY7.js';
+import { S as SchemaBuilder, I as InferInput } from '../../schema-Dtp-joeT.js';
+import { a as ValidationError, b as ValidationResult } from '../../index-C17xs-fU.js';
 
 /**
  * Headless form utilities for frontend frameworks

package/dist/adapters/frontend/index.js

@@ -1,13 +1,13 @@
 'use strict';
 
-var chunkBJLVOIAP_js = require('../../chunk-BJLVOIAP.js');
-require('../../chunk-BNIB23NQ.js');
-require('../../chunk-2JYFKT3R.js');
-require('../../chunk-CQYXR2LZ.js');
-require('../../chunk-3FANCMEF.js');
-require('../../chunk-FZ7K2PC7.js');
-require('../../chunk-ASKTY6EG.js');
-require('../../chunk-NUW55QTO.js');
+var chunkDT2TQZU7_js = require('../../chunk-DT2TQZU7.js');
+require('../../chunk-76BBWQDH.js');
+require('../../chunk-FPCCH55A.js');
+require('../../chunk-JEW6U6CB.js');
+require('../../chunk-IUXRLMET.js');
+require('../../chunk-TXT36BCE.js');
+require('../../chunk-66RFUBVU.js');
+require('../../chunk-OIYG5D2I.js');
 
 // src/adapters/frontend/form.ts
 function createForm(schema, options = {}) {
@@ -137,7 +137,7 @@ var FormController = class {
    * Validate a single field
    */
   validateField(field) {
-    const result = chunkBJLVOIAP_js.validate(this.schema.definition, this.state.values);
+    const result = chunkDT2TQZU7_js.validate(this.schema.definition, this.state.values);
     const fieldHardErrors = result.hardErrors.filter((e) => e.field === field);
     const fieldSoftErrors = result.softErrors.filter((e) => e.field === field);
     this.state.errors[field] = fieldHardErrors;
@@ -154,7 +154,7 @@ var FormController = class {
    * Validate entire form
    */
   validate() {
-    const result = chunkBJLVOIAP_js.validate(this.schema.definition, this.state.values);
+    const result = chunkDT2TQZU7_js.validate(this.schema.definition, this.state.values);
     const errors = {};
     const warnings = {};
     for (const error of result.hardErrors) {

package/dist/adapters/frontend/index.mjs

@@ -1,11 +1,11 @@
-import { validate } from '../../chunk-3TS35CVJ.mjs';
-import '../../chunk-KHHJD6QK.mjs';
-import '../../chunk-XC4DKEXP.mjs';
-import '../../chunk-FRBZHN4K.mjs';
-import '../../chunk-VWP24NYS.mjs';
-import '../../chunk-ELL7U7IC.mjs';
-import '../../chunk-XGTUU27F.mjs';
-import '../../chunk-FKDWSZIV.mjs';
+import { validate } from '../../chunk-MFEBMQAU.mjs';
+import '../../chunk-75YSYC4K.mjs';
+import '../../chunk-KZCV5IW4.mjs';
+import '../../chunk-COMVAVFU.mjs';
+import '../../chunk-RW6HDA5H.mjs';
+import '../../chunk-7XES4A3M.mjs';
+import '../../chunk-5A4ITJVD.mjs';
+import '../../chunk-KZZ7NVU3.mjs';
 
 // src/adapters/frontend/form.ts
 function createForm(schema, options = {}) {

package/dist/{chunk-XGTUU27F.mjs → chunk-5A4ITJVD.mjs}

@@ -1,4 +1,4 @@
-import { isEmpty, isArray, createError } from './chunk-FKDWSZIV.mjs';
+import { isEmpty, isArray, createError } from './chunk-KZZ7NVU3.mjs';
 
 // src/validators/array/includes.ts
 var includesValidator = (value, params, context) => {

package/dist/{chunk-ASKTY6EG.js → chunk-66RFUBVU.js}

@@ -1,16 +1,16 @@
 'use strict';
 
-var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
 
 // src/validators/array/includes.ts
 var includesValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const item = params?.item;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
   if (!value.includes(item)) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_INCLUDES",
       message || `Array must include ${JSON.stringify(item)}`,
@@ -22,13 +22,13 @@ var includesValidator = (value, params, context) => {
 
 // src/validators/array/excludes.ts
 var excludesValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const item = params?.item;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
   if (value.includes(item)) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_EXCLUDES",
       message || `Array must not include ${JSON.stringify(item)}`,
@@ -40,12 +40,12 @@ var excludesValidator = (value, params, context) => {
 
 // src/validators/array/empty.ts
 var emptyValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
   if (value.length > 0) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_EMPTY",
       message || "Array must be empty",
@@ -57,12 +57,12 @@ var emptyValidator = (value, params, context) => {
 
 // src/validators/array/notEmpty.ts
 var notEmptyValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
   if (value.length === 0) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_NOT_EMPTY",
       message || "Array must not be empty",
@@ -74,17 +74,17 @@ var notEmptyValidator = (value, params, context) => {
 
 // src/validators/array/sorted.ts
 var sortedValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const order = params?.order || "asc";
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
   for (let i = 1; i < value.length; i++) {
     const prev = value[i - 1];
     const curr = value[i];
     if (order === "asc") {
       if (prev > curr) {
-        return chunkNUW55QTO_js.createError(
+        return chunkOIYG5D2I_js.createError(
           context,
           "INVALID_SORTED",
           message || "Array must be sorted in ascending order",
@@ -93,7 +93,7 @@ var sortedValidator = (value, params, context) => {
       }
     } else {
       if (prev < curr) {
-        return chunkNUW55QTO_js.createError(
+        return chunkOIYG5D2I_js.createError(
           context,
           "INVALID_SORTED",
           message || "Array must be sorted in descending order",
@@ -107,13 +107,13 @@ var sortedValidator = (value, params, context) => {
 
 // src/validators/array/compact.ts
 var compactValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isArray(value)) return null;
+  if (!chunkOIYG5D2I_js.isArray(value)) return null;
   const hasFalsy = value.some((item) => !item);
   if (hasFalsy) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_COMPACT",
       message || "Array must not contain falsy values",

package/dist/{chunk-KHHJD6QK.mjs → chunk-75YSYC4K.mjs}

@@ -1,4 +1,4 @@
-import { isEmpty, isObject, createError } from './chunk-FKDWSZIV.mjs';
+import { isEmpty, isObject, createError } from './chunk-KZZ7NVU3.mjs';
 
 // src/validators/object/keys.ts
 var keysValidator = (value, params, context) => {

package/dist/{chunk-BNIB23NQ.js → chunk-76BBWQDH.js}

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
 
 // src/validators/object/keys.ts
 var keysValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const pattern = params?.pattern;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isObject(value)) return null;
+  if (!chunkOIYG5D2I_js.isObject(value)) return null;
   if (pattern) {
     const keys = Object.keys(value);
     const invalidKeys = keys.filter((key) => !pattern.test(key));
     if (invalidKeys.length > 0) {
-      return chunkNUW55QTO_js.createError(
+      return chunkOIYG5D2I_js.createError(
         context,
         "INVALID_KEYS",
         message || `Invalid keys: ${invalidKeys.join(", ")}`,
@@ -26,15 +26,15 @@ var keysValidator = (value, params, context) => {
 
 // src/validators/object/pick.ts
 var pickValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const allowedKeys = params?.keys;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isObject(value) || !allowedKeys) return null;
+  if (!chunkOIYG5D2I_js.isObject(value) || !allowedKeys) return null;
   const keys = Object.keys(value);
   const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
   if (extraKeys.length > 0) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_PICK",
       message || `Unexpected keys: ${extraKeys.join(", ")}`,
@@ -46,15 +46,15 @@ var pickValidator = (value, params, context) => {
 
 // src/validators/object/omit.ts
 var omitValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const forbiddenKeys = params?.keys;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isObject(value) || !forbiddenKeys) return null;
+  if (!chunkOIYG5D2I_js.isObject(value) || !forbiddenKeys) return null;
   const keys = Object.keys(value);
   const foundForbidden = keys.filter((key) => forbiddenKeys.includes(key));
   if (foundForbidden.length > 0) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_OMIT",
       message || `Forbidden keys found: ${foundForbidden.join(", ")}`,
@@ -66,15 +66,15 @@ var omitValidator = (value, params, context) => {
 
 // src/validators/object/strict.ts
 var strictValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const allowedKeys = params?.allowedKeys;
   const soft = params?.soft;
   const message = params?.message;
-  if (!chunkNUW55QTO_js.isObject(value) || !allowedKeys) return null;
+  if (!chunkOIYG5D2I_js.isObject(value) || !allowedKeys) return null;
   const keys = Object.keys(value);
   const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
   if (extraKeys.length > 0) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_STRICT",
       message || `Unknown keys not allowed: ${extraKeys.join(", ")}`,

package/dist/{chunk-ELL7U7IC.mjs → chunk-7XES4A3M.mjs}

@@ -1,4 +1,4 @@
-import { isEmpty, parseDate, createError } from './chunk-FKDWSZIV.mjs';
+import { isEmpty, parseDate, createError } from './chunk-KZZ7NVU3.mjs';
 
 // src/validators/date/today.ts
 var todayValidator = (value, params, context) => {

package/dist/{chunk-FRBZHN4K.mjs → chunk-COMVAVFU.mjs}

@@ -1,4 +1,4 @@
-import { isEmpty, isString, createError } from './chunk-FKDWSZIV.mjs';
+import { isEmpty, isString, createError } from './chunk-KZZ7NVU3.mjs';
 
 // src/validators/string/email.ts
 var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;