@esmj/schema 0.2.3 → 0.3.1

package/README.md

@@ -17,6 +17,15 @@ npm install @esmj/schema
 3. **Rich Features**: Includes advanced features like preprocessing, transformations, piping, and refinements, which are not always available in similar libraries.
 4. **Lightweight**: None dependencies and a small footprint make it ideal for projects where performance and simplicity are key.
 5. **Customizable**: Offers fine-grained control over validation and error handling.
+6. **Performance**: `@esmj/schema` is optimized for speed, making it one of the fastest schema validation libraries available. Whether you're creating schemas, parsing data, or handling errors, `@esmj/schema` consistently outperforms many popular alternatives. Its minimalistic design ensures low overhead, even in high-performance applications.
+
+### Performance Highlights
+
+- **Schema Creation**: Create schemas in as little as `0.02 ms`, even for complex structures.
+- **Parsing**: Parse data with blazing-fast speeds, handling 1,000,000 iterations in under `300 ms`.
+- **Error Handling**: Efficiently manage errors with minimal performance impact, processing 1,000,000 iterations in under `400 ms`.
+
+These performance metrics make `@esmj/schema` an excellent choice for both frontend and backend applications where speed and efficiency are critical.
 
 ## Comparison with Similar Libraries
 
@@ -121,83 +130,133 @@ console.log(result);
 
 ### Schema Types
 
-#### `s.string()`
+#### `s.string(options?)`
 
-Creates a string schema.
+Creates a string schema. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
 ```typescript
-const stringSchema = s.string();
+const stringSchema = s.string({
+  message: (value) => `Custom error: "${value}" is not a valid string.`,
+});
 ```
 
-#### `s.number()`
+#### `s.number(options?)`
 
-Creates a number schema.
+Creates a number schema. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
 ```typescript
-const numberSchema = s.number();
+const numberSchema = s.number({
+  message: (value) => `Custom error: "${value}" is not a valid number.`,
+});
 ```
 
-#### `s.boolean()`
+#### `s.boolean(options?)`
 
-Creates a boolean schema.
+Creates a boolean schema. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
 ```typescript
-const booleanSchema = s.boolean();
+const booleanSchema = s.boolean({
+  message: (value) => `Custom error: "${value}" is not a valid boolean.`,
+});
 ```
 
-#### `s.date()`
+#### `s.date(options?)`
 
-Creates a date schema.
+Creates a date schema. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
 ```typescript
-const dateSchema = s.date();
+const dateSchema = s.date({
+  message: (value) => `Custom error: "${value}" is not a valid date.`,
+});
 ```
 
-#### `s.object(definition)`
+#### `s.object(definition, options?)`
 
-Creates an object schema with the given definition.
+Creates an object schema with the given definition. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
 ```typescript
-const objectSchema = s.object({
-  key: s.string(),
-  value: s.number(),
-});
+const objectSchema = s.object(
+  {
+    key: s.string(),
+    value: s.number(),
+  },
+  {
+    message: (value) => `Custom error: "${JSON.stringify(value)}" is not a valid object.`,
+  },
+);
 ```
 
-#### `s.array(definition)`
+#### `s.array(definition, options?)`
 
-Creates an array schema with the given item definition.
+Creates an array schema with the given item definition. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
 ```typescript
-const arraySchema = s.array(s.string());
+const arraySchema = s.array(s.string(), {
+  message: (value) => `Custom error: "${JSON.stringify(value)}" is not a valid array.`,
+});
 ```
 
-#### `s.any()`
+#### `s.enum(values, options?)`
 
-Creates a schema that accepts any value.
+Creates an enum schema that validates against a predefined set of string values. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
+
+- **`values`**: An array of strings representing the allowed values for the enum. Each value must be a string.
 
 ```typescript
-const anySchema = s.any();
+const enumSchema = s.enum(['admin', 'user', 'guest'], {
+  message: (value) => `Custom error: "${value}" is not a valid enum value.`,
+});
 ```
 
-#### `s.enum(values)`
+#### `s.union(definitions, options?)`
 
-Creates an enum schema that validates against a predefined set of string values.
+Creates a schema that validates against multiple schemas (a union of schemas). The value must match at least one of the provided schemas. You can optionally pass `SchemaInterfaceOptions` to customize error messages.
 
-- **`values`**: An array of strings representing the allowed values for the enum. Each value must be a string.
+- **`definitions`**: An array of schemas to validate against.
 
 ```typescript
-const enumSchema = s.enum(['admin', 'user', 'guest']);
+const schema = s.union([
+  s.string(),
+  s.number(),
+  s.boolean(),
+]);
+
+const validString = schema.parse('hello');
+console.log(validString);
+// 'hello'
+
+const validNumber = schema.parse(42);
+console.log(validNumber);
+// 42
 
-const validResult = enumSchema.parse('admin');
-console.log(validResult);
-// 'admin'
+const validBoolean = schema.parse(true);
+console.log(validBoolean);
+// true
 
-const invalidResult = enumSchema.safeParse('invalidRole');
-console.log(invalidResult.success);
+const invalidValue = schema.safeParse({ key: 'value' });
+console.log(invalidValue.success);
 // false
-console.log(invalidResult.error.message);
-// Error: Invalid enum value. Expected "admin" | "user" | "guest", received "invalidRole".
+console.log(invalidValue.error.message);
+// Validation failed. Expected the value to match one of the schemas: "string" | "number" | "boolean", but received "object" with value "{"key":"value"}".
+```
+
+**Use Case**: The `union` method is useful when you need to validate data that can be of multiple types, such as a value that can be a string, number, or boolean.
+
+```typescript
+const schema = s.union(
+  [s.string(), s.number(), s.boolean()],
+  {
+    message: (value) => `Custom error: "${value}" does not match any of the union schemas.`,
+  },
+);
+```
+
+#### `s.any()`
+
+Creates a schema that accepts any value.
+
+```typescript
+const anySchema = s.any();
 ```
 
 #### `s.preprocess(callback, schema)`

package/dist/index.d.mts

@@ -14,9 +14,10 @@ type Invalid = {
 };
 type InternalParseOutput<Output> = Valid<Output> | Invalid;
 interface SchemaInterface<Input, Output> {
-    _parse(value: Input | Partial<Input> | unknown): InternalParseOutput<Output>;
-    parse(value: Input | Partial<Input> | unknown): Output;
-    safeParse(value: Input | Partial<Input> | unknown): InternalParseOutput<Output>;
+    _getType(): string;
+    _parse(value: Input | Partial<Input>): InternalParseOutput<Output>;
+    parse(value: Input | Partial<Input>): Output;
+    safeParse(value: Input | Partial<Input>): InternalParseOutput<Output>;
     optional(): SchemaInterface<Input, Partial<Output> | undefined>;
     transform<NewOutput>(callback: (value: Input) => NewOutput): SchemaInterface<Input, NewOutput>;
     nullable(): SchemaInterface<Input, Output | null>;
@@ -24,9 +25,11 @@ interface SchemaInterface<Input, Output> {
     default(defaultValue: Partial<Input> | (() => Partial<Input>) | Partial<Output>): SchemaInterface<Input, Output>;
     pipe<NewOutput>(schema: SchemaInterface<Output, NewOutput>): SchemaInterface<Output, NewOutput>;
     refine(validation: (value: Output) => boolean, { message }: {
-        message: string;
+        message: ErrorMessage;
     }): SchemaInterface<Input, Output>;
 }
+interface UnionSchemaInterface<T extends Array<SchemaInterface<unknown, unknown>>> extends SchemaInterface<ReturnType<T[number]['parse']>, ReturnType<T[number]['parse']>> {
+}
 interface EnumSchemaInterface<T extends string> extends SchemaInterface<string, T> {
 }
 interface StringSchemaInterface extends SchemaInterface<string, string> {
@@ -40,28 +43,35 @@ interface DateSchemaInterface extends SchemaInterface<Date, Date> {
 interface ArraySchemaInterface<T extends SchemaType> extends SchemaInterface<Array<T>, Array<ReturnType<T['parse']>>> {
 }
 interface ObjectSchemaInterface<T extends Record<string, SchemaType>> extends SchemaInterface<{
-    [Property in keyof T]: T[Property];
+    [Property in keyof T]: ReturnType<T[Property]['parse']>;
 }, {
     [Property in keyof T]: ReturnType<T[Property]['parse']>;
 }> {
 }
-type SchemaType = StringSchemaInterface | SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | ObjectSchemaInterface<Record<string, SchemaType>> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | NumberSchemaInterface | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | BooleanSchemaInterface | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | DateSchemaInterface | SchemaInterface<Date, Date> | SchemaInterface<Date, Date | undefined> | SchemaInterface<Date, Date | null> | SchemaInterface<Date, Date | undefined | null> | EnumSchemaInterface<string> | ArraySchemaInterface<StringSchemaInterface | ObjectSchemaInterface<Record<string, SchemaType>> | NumberSchemaInterface | BooleanSchemaInterface | DateSchemaInterface | EnumSchemaInterface<string>> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+type SchemaType = StringSchemaInterface | SchemaInterface<unknown, unknown> | SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | ObjectSchemaInterface<Record<string, SchemaType>> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | NumberSchemaInterface | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | BooleanSchemaInterface | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | DateSchemaInterface | SchemaInterface<Date, Date> | SchemaInterface<Date, Date | undefined> | SchemaInterface<Date, Date | null> | SchemaInterface<Date, Date | undefined | null> | EnumSchemaInterface<string> | UnionSchemaInterface<Array<SchemaInterface<unknown, unknown>>> | ArraySchemaInterface<StringSchemaInterface | ObjectSchemaInterface<Record<string, SchemaType>> | NumberSchemaInterface | BooleanSchemaInterface | DateSchemaInterface | EnumSchemaInterface<string>> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+type ErrorMessage = string | ((value: unknown) => string);
 type ExtenderType = (inter: SchemaType, validation: Function, options: {
-    message: string;
+    message: ErrorMessage;
     type: string;
 }) => SchemaType;
+interface CreateSchemaInterfaceOptions {
+    type?: string;
+    message?: (value: unknown) => string;
+}
+type SchemaInterfaceOptions = Omit<CreateSchemaInterfaceOptions, 'type'>;
 declare const s: {
-    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }): ObjectSchemaInterface<T>;
-    string(): StringSchemaInterface;
-    number(): NumberSchemaInterface;
-    boolean(): BooleanSchemaInterface;
-    date(): DateSchemaInterface;
-    enum(definition: Readonly<Array<string>>): EnumSchemaInterface<(typeof definition)[number]>;
-    array<T extends SchemaType>(definition: T): ArraySchemaInterface<T>;
+    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }, options: SchemaInterfaceOptions): ObjectSchemaInterface<T>;
+    string(options: SchemaInterfaceOptions): StringSchemaInterface;
+    number(options: SchemaInterfaceOptions): NumberSchemaInterface;
+    boolean(options: SchemaInterfaceOptions): BooleanSchemaInterface;
+    date(options: SchemaInterfaceOptions): DateSchemaInterface;
+    enum(definition: Readonly<Array<string>>, options: SchemaInterfaceOptions): EnumSchemaInterface<(typeof definition)[number]>;
+    array<T extends SchemaType>(definition: T, options: SchemaInterfaceOptions): ArraySchemaInterface<T>;
     any(): any;
     preprocess<T extends SchemaType>(callback: Function, schema: T): T;
+    union<T extends Array<SchemaType>>(definitions: T, options: SchemaInterfaceOptions): UnionSchemaInterface<T>;
 };
 declare function extend(callback: ExtenderType): void;
 type Infer<T> = T extends SchemaType ? ReturnType<T['parse']> : unknown;
 
-export { type ArraySchemaInterface, type BooleanSchemaInterface, type DateSchemaInterface, type EnumSchemaInterface, type ExtenderType, type Infer, type NumberSchemaInterface, type ObjectSchemaInterface, type SchemaInterface, type SchemaType, type StringSchemaInterface, extend, s };
+export { type ArraySchemaInterface, type BooleanSchemaInterface, type DateSchemaInterface, type EnumSchemaInterface, type ExtenderType, type Infer, type NumberSchemaInterface, type ObjectSchemaInterface, type SchemaInterface, type SchemaInterfaceOptions, type SchemaType, type StringSchemaInterface, type UnionSchemaInterface, extend, s };

package/dist/index.d.ts

@@ -14,9 +14,10 @@ type Invalid = {
 };
 type InternalParseOutput<Output> = Valid<Output> | Invalid;
 interface SchemaInterface<Input, Output> {
-    _parse(value: Input | Partial<Input> | unknown): InternalParseOutput<Output>;
-    parse(value: Input | Partial<Input> | unknown): Output;
-    safeParse(value: Input | Partial<Input> | unknown): InternalParseOutput<Output>;
+    _getType(): string;
+    _parse(value: Input | Partial<Input>): InternalParseOutput<Output>;
+    parse(value: Input | Partial<Input>): Output;
+    safeParse(value: Input | Partial<Input>): InternalParseOutput<Output>;
     optional(): SchemaInterface<Input, Partial<Output> | undefined>;
     transform<NewOutput>(callback: (value: Input) => NewOutput): SchemaInterface<Input, NewOutput>;
     nullable(): SchemaInterface<Input, Output | null>;
@@ -24,9 +25,11 @@ interface SchemaInterface<Input, Output> {
     default(defaultValue: Partial<Input> | (() => Partial<Input>) | Partial<Output>): SchemaInterface<Input, Output>;
     pipe<NewOutput>(schema: SchemaInterface<Output, NewOutput>): SchemaInterface<Output, NewOutput>;
     refine(validation: (value: Output) => boolean, { message }: {
-        message: string;
+        message: ErrorMessage;
     }): SchemaInterface<Input, Output>;
 }
+interface UnionSchemaInterface<T extends Array<SchemaInterface<unknown, unknown>>> extends SchemaInterface<ReturnType<T[number]['parse']>, ReturnType<T[number]['parse']>> {
+}
 interface EnumSchemaInterface<T extends string> extends SchemaInterface<string, T> {
 }
 interface StringSchemaInterface extends SchemaInterface<string, string> {
@@ -40,28 +43,35 @@ interface DateSchemaInterface extends SchemaInterface<Date, Date> {
 interface ArraySchemaInterface<T extends SchemaType> extends SchemaInterface<Array<T>, Array<ReturnType<T['parse']>>> {
 }
 interface ObjectSchemaInterface<T extends Record<string, SchemaType>> extends SchemaInterface<{
-    [Property in keyof T]: T[Property];
+    [Property in keyof T]: ReturnType<T[Property]['parse']>;
 }, {
     [Property in keyof T]: ReturnType<T[Property]['parse']>;
 }> {
 }
-type SchemaType = StringSchemaInterface | SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | ObjectSchemaInterface<Record<string, SchemaType>> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | NumberSchemaInterface | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | BooleanSchemaInterface | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | DateSchemaInterface | SchemaInterface<Date, Date> | SchemaInterface<Date, Date | undefined> | SchemaInterface<Date, Date | null> | SchemaInterface<Date, Date | undefined | null> | EnumSchemaInterface<string> | ArraySchemaInterface<StringSchemaInterface | ObjectSchemaInterface<Record<string, SchemaType>> | NumberSchemaInterface | BooleanSchemaInterface | DateSchemaInterface | EnumSchemaInterface<string>> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+type SchemaType = StringSchemaInterface | SchemaInterface<unknown, unknown> | SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | ObjectSchemaInterface<Record<string, SchemaType>> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | NumberSchemaInterface | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | BooleanSchemaInterface | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | DateSchemaInterface | SchemaInterface<Date, Date> | SchemaInterface<Date, Date | undefined> | SchemaInterface<Date, Date | null> | SchemaInterface<Date, Date | undefined | null> | EnumSchemaInterface<string> | UnionSchemaInterface<Array<SchemaInterface<unknown, unknown>>> | ArraySchemaInterface<StringSchemaInterface | ObjectSchemaInterface<Record<string, SchemaType>> | NumberSchemaInterface | BooleanSchemaInterface | DateSchemaInterface | EnumSchemaInterface<string>> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+type ErrorMessage = string | ((value: unknown) => string);
 type ExtenderType = (inter: SchemaType, validation: Function, options: {
-    message: string;
+    message: ErrorMessage;
     type: string;
 }) => SchemaType;
+interface CreateSchemaInterfaceOptions {
+    type?: string;
+    message?: (value: unknown) => string;
+}
+type SchemaInterfaceOptions = Omit<CreateSchemaInterfaceOptions, 'type'>;
 declare const s: {
-    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }): ObjectSchemaInterface<T>;
-    string(): StringSchemaInterface;
-    number(): NumberSchemaInterface;
-    boolean(): BooleanSchemaInterface;
-    date(): DateSchemaInterface;
-    enum(definition: Readonly<Array<string>>): EnumSchemaInterface<(typeof definition)[number]>;
-    array<T extends SchemaType>(definition: T): ArraySchemaInterface<T>;
+    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }, options: SchemaInterfaceOptions): ObjectSchemaInterface<T>;
+    string(options: SchemaInterfaceOptions): StringSchemaInterface;
+    number(options: SchemaInterfaceOptions): NumberSchemaInterface;
+    boolean(options: SchemaInterfaceOptions): BooleanSchemaInterface;
+    date(options: SchemaInterfaceOptions): DateSchemaInterface;
+    enum(definition: Readonly<Array<string>>, options: SchemaInterfaceOptions): EnumSchemaInterface<(typeof definition)[number]>;
+    array<T extends SchemaType>(definition: T, options: SchemaInterfaceOptions): ArraySchemaInterface<T>;
     any(): any;
     preprocess<T extends SchemaType>(callback: Function, schema: T): T;
+    union<T extends Array<SchemaType>>(definitions: T, options: SchemaInterfaceOptions): UnionSchemaInterface<T>;
 };
 declare function extend(callback: ExtenderType): void;
 type Infer<T> = T extends SchemaType ? ReturnType<T['parse']> : unknown;
 
-export { type ArraySchemaInterface, type BooleanSchemaInterface, type DateSchemaInterface, type EnumSchemaInterface, type ExtenderType, type Infer, type NumberSchemaInterface, type ObjectSchemaInterface, type SchemaInterface, type SchemaType, type StringSchemaInterface, extend, s };
+export { type ArraySchemaInterface, type BooleanSchemaInterface, type DateSchemaInterface, type EnumSchemaInterface, type ExtenderType, type Infer, type NumberSchemaInterface, type ObjectSchemaInterface, type SchemaInterface, type SchemaInterfaceOptions, type SchemaType, type StringSchemaInterface, type UnionSchemaInterface, extend, s };

package/dist/index.js

@@ -1 +1 @@
-'use strict';var h=r=>typeof r=="string"||r instanceof String,I=r=>typeof r=="number"||r instanceof Number,l=r=>r===true||r===false,y=r=>r instanceof Date&&!Number.isNaN(r.getTime()),d=r=>Array.isArray(r),S=r=>typeof r=="object"&&r!==null&&!Array.isArray(r),g={object(r){let a=p(S,{type:"object"});return i(a,"_parse",(u,...o)=>{let c=u(...o);if(c.success===false)return c;let n={};for(let t in r){let e=r[t]._parse(c.data[t]);if(e.success)n[t]=e.data;else {e=e;let s=e?.error?.cause?.key?`${t}.${e?.error?.cause?.key}`:t;return e.error.message=`Error parsing key "${s}": ${e.error.message}`,e.error.cause={key:s},e}}return {success:true,data:n}}),a},string(){return p(h,{type:"string"})},number(){return p(I,{type:"number"})},boolean(){return p(l,{type:"boolean"})},date(){return p(y,{type:"date"})},enum(r){let a=n=>r.includes(n),u=n=>`Invalid ${o} value. Expected ${r.map(t=>`"${t}"`).join(" | ")}, received "${n}".`,o="enum";return p(a,{type:o,message:u})},array(r){let a=p(d,{type:"array"});return i(a,"_parse",(u,...o)=>{let c=u(...o);if(c.success===false)return c;let n=[];for(let t=0;t<c.data.length;t++){let e=r._parse(c.data[t]);if(e.success)n.push(e.data);else {e=e;let s=e.error?.cause?.key?`${t}.${e.error.cause.key}`:`${t}`;return e.error.message=`Error parsing index "${t}": ${e.error.message}`,e.error.cause={key:s},e}}return {success:true,data:n}}),a},any(){return p(()=>true)},preprocess(r,a){return i(a,"_parse",(u,o)=>(o=r(o),u(o))),a}};function b(r){return a=>`The value "${a}" must be type of ${r} but is type of "${typeof a}".`}function i(r,a,u){let o=r[a];r[a]=(...c)=>u(o,...c);}function p(r,{type:a="any",message:u}={}){u=u||b(a);let o={message:u,type:a},c={_parse(n){return r(n)?{success:true,data:n}:{success:false,error:{message:u(n)}}},parse(n){let t=c._parse(n);if(!t.success)throw t=t,new Error(t.error.message,{cause:t.error.cause});return t.data},safeParse(n){return c._parse(n)},transform(n){return i(this,"_parse",(t,e)=>{let s=t(e);return s.success&&(s.data=n(s.data)),s}),this},optional(){return i(this,"_parse",(n,t)=>{let e=n(t);return e.success||(e.data=void 0,e.success=true),e}),this},nullable(){return i(this,"_parse",(n,t)=>{let e=n(t);return e.success||(e.data=null,e.success=true),e}),this},nullish(){return i(this,"_parse",(n,t)=>{let e=n(t);return !e.success&&t==null&&(e.success=true,e.data=t),e}),this},default(n){return i(this,"_parse",(t,e)=>(e===void 0&&(e=n,e=typeof n=="function"?n():n),t(e))),this},pipe(n){return i(this,"_parse",(t,e)=>{let s=t(e);return s.success?n._parse(s.data):s}),this},refine(n,{message:t}){return i(this,"_parse",(e,s)=>{let m=e(s);return n(m.data)?m:{success:false,error:{message:t}}}),this}};return f.length>0?f.reduce((n,t)=>t(n,r,o)??n,c):c}var f=[];function T(r){f.push(r);}exports.extend=T;exports.s=g;
+'use strict';var h=e=>typeof e=="string"||e instanceof String,I=e=>typeof e=="number"||e instanceof Number,l=e=>e===true||e===false,y=e=>e instanceof Date&&!Number.isNaN(e.getTime()),S=e=>Array.isArray(e),d=e=>typeof e=="object"&&e!==null&&!Array.isArray(e),g={object(e,c){let s=p(d,{...c,type:"object"});return i(s,"_parse",(u,...o)=>{let t=u(...o);if(t.success===false)return t;let n={};for(let r in e){let a=e[r]._parse(t.data[r]);if(a.success)n[r]=a.data;else {a=a;let f=a?.error?.cause?.key?`${r}.${a?.error?.cause?.key}`:r;return a.error.message=`Error parsing key "${f}": ${a.error.message}`,a.error.cause={key:f},a}}return {success:true,data:n}}),s},string(e){return p(h,{...e,type:"string"})},number(e){return p(I,{...e,type:"number"})},boolean(e){return p(l,{...e,type:"boolean"})},date(e){return p(y,{...e,type:"date"})},enum(e,c){let s=n=>e.includes(n),u=n=>`Invalid ${o} value. Expected ${e.map(r=>`"${r}"`).join(" | ")}, received "${n}".`,o="enum";return p(s,{message:u,...c,type:o})},array(e,c){let s=p(S,{...c,type:"array"});return i(s,"_parse",(u,...o)=>{let t=u(...o);if(t.success===false)return t;let n=[];for(let r=0;r<t.data.length;r++){let a=e._parse(t.data[r]);if(a.success)n.push(a.data);else {a=a;let f=a.error?.cause?.key?`${r}.${a.error.cause.key}`:`${r}`;return a.error.message=`Error parsing index "${r}": ${a.error.message}`,a.error.cause={key:f},a}}return {success:true,data:n}}),s},any(){return p(()=>true)},preprocess(e,c){return i(c,"_parse",(s,u)=>(u=e(u),s(u))),c},union(e,c){return p(t=>{for(let n=0;n<e.length;n++)if(e[n]._parse(t).success)return  true;return  false},{message:t=>`Invalid union value. Expected the value to match one of the schemas: ${e.map(n=>`"${n._getType()}"`).join(" | ")}, but received "${typeof t}" with value "${t}".`,...c,type:"union"})}};function T(e){return c=>`The value "${c}" must be type of ${e} but is type of "${typeof c}".`}function i(e,c,s){let u=e[c];e[c]=(...o)=>s(u,...o);}function p(e,{type:c="any",message:s}={}){s=s||T(c);let u={message:s,type:c},o={_getType(){return c},_parse(t){return e(t)?{success:true,data:t}:{success:false,error:{message:s(t)}}},parse(t){let n=o._parse(t);if(!n.success)throw n=n,new Error(n.error.message,{cause:n.error.cause});return n.data},safeParse(t){return o._parse(t)},transform(t){return i(this,"_parse",(n,r)=>{let a=n(r);return a.success&&(a.data=t(a.data)),a}),this},optional(){return i(this,"_parse",(t,n)=>{let r=t(n);return r.success||(r.data=void 0,r.success=true),r}),this},nullable(){return i(this,"_parse",(t,n)=>{let r=t(n);return r.success||(r.data=null,r.success=true),r}),this},nullish(){return i(this,"_parse",(t,n)=>{let r=t(n);return !r.success&&n==null&&(r.success=true,r.data=n),r}),this},default(t){return i(this,"_parse",(n,r)=>(r===void 0&&(r=t,r=typeof t=="function"?t():t),n(r))),this},pipe(t){return i(this,"_parse",(n,r)=>{let a=n(r);return a.success?t._parse(a.data):a}),this},refine(t,{message:n}){return i(this,"_parse",(r,a)=>{let f=r(a);return t(f.data)?f:{success:false,error:{message:n}}}),this}};return m.length>0?m.reduce((t,n)=>n(t,e,u)??t,o):o}var m=[];function b(e){m.push(e);}exports.extend=b;exports.s=g;

package/dist/index.mjs

@@ -1 +1 @@
-var h=r=>typeof r=="string"||r instanceof String,I=r=>typeof r=="number"||r instanceof Number,l=r=>r===true||r===false,y=r=>r instanceof Date&&!Number.isNaN(r.getTime()),d=r=>Array.isArray(r),S=r=>typeof r=="object"&&r!==null&&!Array.isArray(r),g={object(r){let a=p(S,{type:"object"});return i(a,"_parse",(u,...o)=>{let c=u(...o);if(c.success===false)return c;let n={};for(let t in r){let e=r[t]._parse(c.data[t]);if(e.success)n[t]=e.data;else {e=e;let s=e?.error?.cause?.key?`${t}.${e?.error?.cause?.key}`:t;return e.error.message=`Error parsing key "${s}": ${e.error.message}`,e.error.cause={key:s},e}}return {success:true,data:n}}),a},string(){return p(h,{type:"string"})},number(){return p(I,{type:"number"})},boolean(){return p(l,{type:"boolean"})},date(){return p(y,{type:"date"})},enum(r){let a=n=>r.includes(n),u=n=>`Invalid ${o} value. Expected ${r.map(t=>`"${t}"`).join(" | ")}, received "${n}".`,o="enum";return p(a,{type:o,message:u})},array(r){let a=p(d,{type:"array"});return i(a,"_parse",(u,...o)=>{let c=u(...o);if(c.success===false)return c;let n=[];for(let t=0;t<c.data.length;t++){let e=r._parse(c.data[t]);if(e.success)n.push(e.data);else {e=e;let s=e.error?.cause?.key?`${t}.${e.error.cause.key}`:`${t}`;return e.error.message=`Error parsing index "${t}": ${e.error.message}`,e.error.cause={key:s},e}}return {success:true,data:n}}),a},any(){return p(()=>true)},preprocess(r,a){return i(a,"_parse",(u,o)=>(o=r(o),u(o))),a}};function b(r){return a=>`The value "${a}" must be type of ${r} but is type of "${typeof a}".`}function i(r,a,u){let o=r[a];r[a]=(...c)=>u(o,...c);}function p(r,{type:a="any",message:u}={}){u=u||b(a);let o={message:u,type:a},c={_parse(n){return r(n)?{success:true,data:n}:{success:false,error:{message:u(n)}}},parse(n){let t=c._parse(n);if(!t.success)throw t=t,new Error(t.error.message,{cause:t.error.cause});return t.data},safeParse(n){return c._parse(n)},transform(n){return i(this,"_parse",(t,e)=>{let s=t(e);return s.success&&(s.data=n(s.data)),s}),this},optional(){return i(this,"_parse",(n,t)=>{let e=n(t);return e.success||(e.data=void 0,e.success=true),e}),this},nullable(){return i(this,"_parse",(n,t)=>{let e=n(t);return e.success||(e.data=null,e.success=true),e}),this},nullish(){return i(this,"_parse",(n,t)=>{let e=n(t);return !e.success&&t==null&&(e.success=true,e.data=t),e}),this},default(n){return i(this,"_parse",(t,e)=>(e===void 0&&(e=n,e=typeof n=="function"?n():n),t(e))),this},pipe(n){return i(this,"_parse",(t,e)=>{let s=t(e);return s.success?n._parse(s.data):s}),this},refine(n,{message:t}){return i(this,"_parse",(e,s)=>{let m=e(s);return n(m.data)?m:{success:false,error:{message:t}}}),this}};return f.length>0?f.reduce((n,t)=>t(n,r,o)??n,c):c}var f=[];function T(r){f.push(r);}export{T as extend,g as s};
+var h=e=>typeof e=="string"||e instanceof String,I=e=>typeof e=="number"||e instanceof Number,l=e=>e===true||e===false,y=e=>e instanceof Date&&!Number.isNaN(e.getTime()),S=e=>Array.isArray(e),d=e=>typeof e=="object"&&e!==null&&!Array.isArray(e),g={object(e,c){let s=p(d,{...c,type:"object"});return i(s,"_parse",(u,...o)=>{let t=u(...o);if(t.success===false)return t;let n={};for(let r in e){let a=e[r]._parse(t.data[r]);if(a.success)n[r]=a.data;else {a=a;let f=a?.error?.cause?.key?`${r}.${a?.error?.cause?.key}`:r;return a.error.message=`Error parsing key "${f}": ${a.error.message}`,a.error.cause={key:f},a}}return {success:true,data:n}}),s},string(e){return p(h,{...e,type:"string"})},number(e){return p(I,{...e,type:"number"})},boolean(e){return p(l,{...e,type:"boolean"})},date(e){return p(y,{...e,type:"date"})},enum(e,c){let s=n=>e.includes(n),u=n=>`Invalid ${o} value. Expected ${e.map(r=>`"${r}"`).join(" | ")}, received "${n}".`,o="enum";return p(s,{message:u,...c,type:o})},array(e,c){let s=p(S,{...c,type:"array"});return i(s,"_parse",(u,...o)=>{let t=u(...o);if(t.success===false)return t;let n=[];for(let r=0;r<t.data.length;r++){let a=e._parse(t.data[r]);if(a.success)n.push(a.data);else {a=a;let f=a.error?.cause?.key?`${r}.${a.error.cause.key}`:`${r}`;return a.error.message=`Error parsing index "${r}": ${a.error.message}`,a.error.cause={key:f},a}}return {success:true,data:n}}),s},any(){return p(()=>true)},preprocess(e,c){return i(c,"_parse",(s,u)=>(u=e(u),s(u))),c},union(e,c){return p(t=>{for(let n=0;n<e.length;n++)if(e[n]._parse(t).success)return  true;return  false},{message:t=>`Invalid union value. Expected the value to match one of the schemas: ${e.map(n=>`"${n._getType()}"`).join(" | ")}, but received "${typeof t}" with value "${t}".`,...c,type:"union"})}};function T(e){return c=>`The value "${c}" must be type of ${e} but is type of "${typeof c}".`}function i(e,c,s){let u=e[c];e[c]=(...o)=>s(u,...o);}function p(e,{type:c="any",message:s}={}){s=s||T(c);let u={message:s,type:c},o={_getType(){return c},_parse(t){return e(t)?{success:true,data:t}:{success:false,error:{message:s(t)}}},parse(t){let n=o._parse(t);if(!n.success)throw n=n,new Error(n.error.message,{cause:n.error.cause});return n.data},safeParse(t){return o._parse(t)},transform(t){return i(this,"_parse",(n,r)=>{let a=n(r);return a.success&&(a.data=t(a.data)),a}),this},optional(){return i(this,"_parse",(t,n)=>{let r=t(n);return r.success||(r.data=void 0,r.success=true),r}),this},nullable(){return i(this,"_parse",(t,n)=>{let r=t(n);return r.success||(r.data=null,r.success=true),r}),this},nullish(){return i(this,"_parse",(t,n)=>{let r=t(n);return !r.success&&n==null&&(r.success=true,r.data=n),r}),this},default(t){return i(this,"_parse",(n,r)=>(r===void 0&&(r=t,r=typeof t=="function"?t():t),n(r))),this},pipe(t){return i(this,"_parse",(n,r)=>{let a=n(r);return a.success?t._parse(a.data):a}),this},refine(t,{message:n}){return i(this,"_parse",(r,a)=>{let f=r(a);return t(f.data)?f:{success:false,error:{message:n}}}),this}};return m.length>0?m.reduce((t,n)=>n(t,e,u)??t,o):o}var m=[];function b(e){m.push(e);}export{b as extend,g as s};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esmj/schema",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Tiny extendable package for schema validation.",
   "keywords": [
     "schema",