@esmj/schema 0.0.2 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # Schema
 
-This small library provides a simple schema validation system for JavaScript/TypeScript. The library has basic types with opportunity for extending. 
+This small library provides a simple schema validation system for JavaScript/TypeScript. The library has basic types with opportunities for extending. 
 
 ## Installation
 
@@ -8,17 +8,43 @@ This small library provides a simple schema validation system for JavaScript/Typ
 npm install @esmj/schema
 ```
 
+## Why Use `@esmj/schema`?
+
+`@esmj/schema` is a lightweight and flexible schema validation library designed for developers who need a simple yet powerful way to validate and transform data. Here are some reasons to choose this package:
+
+1. **TypeScript First**: Built with TypeScript in mind, it provides strong type inference and ensures type safety throughout your codebase.
+2. **Extensibility**: Easily extend the library with custom logic using the `extend` function.
+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.
+
+## Comparison with Similar Libraries
+
+When choosing a schema validation library, bundle size can be an important factor, especially for frontend applications where minimizing JavaScript size is critical. Here's how `@esmj/schema` compares to other popular libraries:
+
+| Library         | Bundle Size (minified + gzipped) |
+|------------------|---------------------------------|
+| `@esmj/schema`   | ~1 KB                           |
+| Superstruct      | ~3,2 KB                         |
+| Yup              | ~12,2 KB                        |
+| Zod              | ~14 KB                          |
+| Joi              | ~40 KB                          |
+
 ## Usage
 
 ### Basic Usage
 
 ```typescript
-import { s } from '@esmj/schema';
+import { s, type Infer} from '@esmj/schema';
 
 const schema = s.object({
-  username: s.string().optional(),
+  username: s.string().optional().refine((val) => val.length <= 255, {
+    message: "Username can't be more than 255 characters",
+  }),
   password: s.string().default('unknown'),
-  account: s.number().default(0),
+  birthday: s.preprocess((value) => new Date(value), s.date()),
+  account: s.string().default('0').transform((value) => Number.parseInt(value)).pipe(s.number()),
+  money: s.number(),
   address: s.object({
     street: s.string(),
     city: s.string().optional(),
@@ -26,12 +52,28 @@ const schema = s.object({
   records: s.array(s.object({ name: s.string() })).default([]),
 });
 
+type schemaType = Infer<typeof schema>;
+
 const result = schema.parse({
   username: 'john_doe',
+  birthday: '2000-01-01T23:59:59.000Z',
   address: { city: 'New York' },
+  money: 100,
 });
 
 console.log(result);
+// {
+//   username: 'john_doe',
+//   password: 'unknown',
+//   birthday: Date('2000-01-01T23:59:59.000Z'),
+//   account: 0,
+//   money: 100,
+//   address: {
+//     street: 'unknown',
+//     city: 'New York',
+//   },
+//   records: [],
+// }
 ```
 
 ### Schema Types
@@ -60,6 +102,14 @@ Creates a boolean schema.
 const booleanSchema = s.boolean();
 ```
 
+#### `s.date()`
+
+Creates a date schema.
+
+```typescript
+const dateSchema = s.date();
+```
+
 #### `s.object(definition)`
 
 Creates an object schema with the given definition.
@@ -87,6 +137,34 @@ Creates a schema that accepts any value.
 const anySchema = s.any();
 ```
 
+#### `s.enum(values)`
+
+Creates an enum schema that validates against a predefined set of string values.
+
+- **`values`**: An array of strings representing the allowed values for the enum. Each value must be a string.
+
+```typescript
+const enumSchema = s.enum(['admin', 'user', 'guest']);
+
+const validResult = enumSchema.parse('admin');
+console.log(validResult);
+// 'admin'
+
+const invalidResult = enumSchema.safeParse('invalidRole');
+console.log(invalidResult.success);
+// false
+console.log(invalidResult.error.message);
+// Error: Invalid enum value. Expected "admin" | "user" | "guest", received "invalidRole".
+```
+
+#### `s.preprocess(callback, schema)`
+
+Creates a schema that preprocesses the input value using the provided callback before validating it with the given schema.
+
+```typescript
+const preprocessSchema = s.preprocess((value) => new Date(value), s.date());
+```
+
 ### Schema Methods
 
 #### `parse(value)`
@@ -102,10 +180,7 @@ const result = stringSchema.parse('hello');
 Safely parses the given value according to the schema, returning a success or error result.
 
 ```typescript
-// correct
-const result = stringSchema.safeParse('hello'); // { success: true, data: 'hello' };
-// bad
-const result = stringSchema.safeParse('hello'); // { success: false, error: new Error() };
+const result = stringSchema.safeParse('hello'); // { success: true, data: 'hello' }
 ```
 
 #### `optional()`
@@ -140,22 +215,220 @@ Sets a default value for the schema.
 const defaultSchema = stringSchema.default('default value');
 ```
 
+#### `transform(callback)`
+
+Transforms the parsed value using the provided callback.
+
+```typescript
+const transformedSchema = s.string().transform((value) => value.toUpperCase());
+```
+
+#### `pipe(schema)`
+
+Pipes the output of one schema into another schema for further validation or transformation.
+
+```typescript
+const pipedSchema = s.string().pipe(s.number());
+```
+
+#### `refine(validation, { message })`
+
+Adds a refinement to the schema with a custom validation function and error message.
+
+```typescript
+const refinedSchema = s.string().refine((val) => val.length <= 255, {
+  message: "String can't be more than 255 characters",
+});
+```
+
 ### Extending Schemas
 
 You can extend the schema system with custom logic.
 
 ```typescript
-import { extend } from '@esmj/schema';
+import { extend, type StringSchemaInterface } from '@esmj/schema';
+
+interface StringSchemaInterface {
+  customMethod(value: string): string {}
+}
 
 extend((schema, validation, options) => {
-  schema.customMethod = () => {
+  schema.customMethod = (value) => {
     // Custom logic
+
+    return value;
   };
 
   return schema;
 });
 ```
 
+### More Examples
+
+#### Nested Objects
+
+You can define schemas for deeply nested objects.
+
+```typescript
+const nestedSchema = s.object({
+  user: s.object({
+    id: s.number(),
+    profile: s.object({
+      name: s.string(),
+      age: s.number().optional(),
+    }),
+  }),
+});
+
+const result = nestedSchema.parse({
+  user: {
+    id: 1,
+    profile: {
+      name: 'John Doe',
+    },
+  },
+});
+
+console.log(result);
+// {
+//   user: {
+//     id: 1,
+//     profile: {
+//       name: 'John Doe',
+//     },
+//   },
+// }
+```
+
+#### Arrays with Validation
+
+You can validate arrays with specific item schemas.
+
+```typescript
+const arraySchema = s.array(s.object({ id: s.number(), name: s.string() }));
+
+const result = arraySchema.parse([
+  { id: 1, name: 'Item 1' },
+  { id: 2, name: 'Item 2' },
+]);
+
+console.log(result);
+// [
+//   { id: 1, name: 'Item 1' },
+//   { id: 2, name: 'Item 2' },
+// ]
+```
+
+#### Preprocessing Values
+
+Use `s.preprocess` to transform input values before validation.
+
+```typescript
+const preprocessSchema = s.preprocess(
+  (value) => value.trim(),
+  s.string().refine((val) => val.length > 0, { message: 'String cannot be empty' }),
+);
+
+const result = preprocessSchema.parse('   hello   ');
+
+console.log(result);
+// 'hello'
+```
+
+#### Transforming Values
+
+Use `transform` to modify the parsed value.
+
+```typescript
+const transformSchema = s.string().transform((value) => value.toUpperCase());
+
+const result = transformSchema.parse('hello');
+
+console.log(result);
+// 'HELLO'
+```
+
+#### Piping Schemas
+
+Pipe the output of one schema into another for further validation or transformation.
+
+```typescript
+const pipedSchema = s.string()
+  .transform((value) => Number.parseInt(value))
+  .pipe(s.number().refine((val) => val > 0, { message: 'Number must be positive' }));
+
+const result = pipedSchema.parse('42');
+
+console.log(result);
+// 42
+```
+
+#### Refining Values
+
+Add custom validation logic with `refine`.
+
+```typescript
+const refinedSchema = s.string().refine((val) => val.startsWith('A'), {
+  message: 'String must start with "A"',
+});
+
+const result = refinedSchema.parse('Apple');
+
+console.log(result);
+// 'Apple'
+```
+
+#### Default Values
+
+Set default values for optional fields.
+
+```typescript
+const defaultSchema = s.object({
+  name: s.string().default('Anonymous'),
+  age: s.number().optional().default(18),
+});
+
+const result = defaultSchema.parse({});
+
+console.log(result);
+// { name: 'Anonymous', age: 18 }
+```
+
+#### Safe Parsing
+
+Use `safeParse` to handle errors gracefully.
+
+```typescript
+const safeSchema = s.number();
+
+const result = safeSchema.safeParse('not a number');
+
+if (!result.success) {
+  console.error(result.error.message);
+} else {
+  console.log(result.data);
+}
+// Error: The value "not a number" must be type of number but is type of "string".
+```
+
+#### Combining Multiple Features
+
+Combine multiple features like preprocessing, transformations, and refinements.
+
+```typescript
+const combinedSchema = s.preprocess(
+  (value) => value.trim(),
+  s.string()
+    .transform((value) => value.toUpperCase())
+    .refine((val) => val.length <= 10, { message: 'String must be at most 10 characters' }),
+);
+
+const result = combinedSchema.parse('   hello   ');
+
+console.log(result);
+// 'HELLO'
+```
+
 ## License
 
 MIT

package/dist/index.d.mts

@@ -8,19 +8,50 @@ interface SchemaInterface<Input, Output> {
         error: Error;
     };
     optional(): SchemaInterface<Input, Partial<Output> | undefined>;
+    transform<NewOutput>(callback: (value: Input) => NewOutput): SchemaInterface<Input, NewOutput>;
     nullable(): SchemaInterface<Input, Output | null>;
     nullish(): SchemaInterface<Input, Output | undefined | null>;
     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;
+    }): SchemaInterface<Input, Output>;
 }
-type SchemaType = SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+interface EnumSchemaInterface<T extends string> extends SchemaInterface<string, T> {
+}
+interface StringSchemaInterface extends SchemaInterface<string, string> {
+}
+interface NumberSchemaInterface extends SchemaInterface<number, number> {
+}
+interface BooleanSchemaInterface extends SchemaInterface<boolean, boolean> {
+}
+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']>;
+}> {
+}
+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 ExtenderType = (inter: SchemaType, validation: Function, options: {
+    message: string;
+    type: string;
+}) => SchemaType;
 declare const s: {
-    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }): SchemaInterface<{ [Property in keyof T]: T[Property]; }, { [Property in keyof T]: ReturnType<T[Property]["parse"]>; }>;
-    string(): SchemaInterface<string, string>;
-    number(): SchemaInterface<number, number>;
-    boolean(): SchemaInterface<boolean, boolean>;
-    array<T extends SchemaType>(definition: T): SchemaInterface<Array<T>, Array<ReturnType<T["parse"]>>>;
+    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>;
     any(): any;
+    preprocess<T extends SchemaType>(callback: Function, schema: T): T;
 };
-declare function extend(callback: Function): void;
+declare function extend(callback: ExtenderType): void;
+type Infer<T> = T extends SchemaType ? ReturnType<T['parse']> : unknown;
 
-export { type SchemaInterface, type SchemaType, extend, s };
+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 };

package/dist/index.d.ts

@@ -8,19 +8,50 @@ interface SchemaInterface<Input, Output> {
         error: Error;
     };
     optional(): SchemaInterface<Input, Partial<Output> | undefined>;
+    transform<NewOutput>(callback: (value: Input) => NewOutput): SchemaInterface<Input, NewOutput>;
     nullable(): SchemaInterface<Input, Output | null>;
     nullish(): SchemaInterface<Input, Output | undefined | null>;
     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;
+    }): SchemaInterface<Input, Output>;
 }
-type SchemaType = SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+interface EnumSchemaInterface<T extends string> extends SchemaInterface<string, T> {
+}
+interface StringSchemaInterface extends SchemaInterface<string, string> {
+}
+interface NumberSchemaInterface extends SchemaInterface<number, number> {
+}
+interface BooleanSchemaInterface extends SchemaInterface<boolean, boolean> {
+}
+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']>;
+}> {
+}
+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 ExtenderType = (inter: SchemaType, validation: Function, options: {
+    message: string;
+    type: string;
+}) => SchemaType;
 declare const s: {
-    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }): SchemaInterface<{ [Property in keyof T]: T[Property]; }, { [Property in keyof T]: ReturnType<T[Property]["parse"]>; }>;
-    string(): SchemaInterface<string, string>;
-    number(): SchemaInterface<number, number>;
-    boolean(): SchemaInterface<boolean, boolean>;
-    array<T extends SchemaType>(definition: T): SchemaInterface<Array<T>, Array<ReturnType<T["parse"]>>>;
+    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>;
     any(): any;
+    preprocess<T extends SchemaType>(callback: Function, schema: T): T;
 };
-declare function extend(callback: Function): void;
+declare function extend(callback: ExtenderType): void;
+type Infer<T> = T extends SchemaType ? ReturnType<T['parse']> : unknown;
 
-export { type SchemaInterface, type SchemaType, extend, s };
+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 };

package/dist/index.js

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

package/dist/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esmj/schema",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "Tiny extendable package for schema validation.",
   "keywords": [
     "schema",
@@ -24,7 +24,7 @@
     "lint:fix": "npm run lint -- --fix --unsafe",
     "dev": "node_modules/.bin/tsup --dts --watch --onSuccess 'node ./dist/index.mjs'",
     "test": "node --test --experimental-strip-types",
-    "test:watch": "npm run test -- --watchAll",
+    "test:watch": "npm run test -- --watch",
     "preversion": "npm test && npm run lint && npm run build",
     "version": "npm run changelog && git add CHANGELOG.md",
     "postversion": "git push && git push --tags",
@@ -62,17 +62,17 @@
   "homepage": "https://github.com/mjancarik/esmj-schema#readme",
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@commitlint/cli": "^19.7.1",
-    "@commitlint/config-conventional": "^19.7.1",
-    "@typescript-eslint/eslint-plugin": "^8.24.0",
-    "@typescript-eslint/parser": "^8.24.0",
+    "@commitlint/cli": "^19.8.0",
+    "@commitlint/config-conventional": "^19.8.0",
+    "@typescript-eslint/eslint-plugin": "^8.31.0",
+    "@typescript-eslint/parser": "^8.31.0",
     "commitizen": "^4.3.1",
     "conventional-changelog-cli": "^5.0.0",
     "cz-conventional-changelog": "^3.3.0",
     "git-cz": "^4.9.0",
     "husky": "^9.1.7",
-    "lint-staged": "^15.4.3",
-    "prettier": "^3.5.0",
-    "tsup": "^8.3.6"
+    "lint-staged": "^15.5.1",
+    "prettier": "^3.5.3",
+    "tsup": "^8.4.0"
   }
 }

package/biome.json

@@ -1,50 +0,0 @@
-{
-  "files": {
-    "include": ["src/**/*.mjs", "src/**/*.ts", "utils/**/*.mjs"],
-    "ignore": [".history/**/*"]
-  },
-  "formatter": {
-    "enabled": true,
-    "formatWithErrors": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineEnding": "lf",
-    "lineWidth": 80,
-    "attributePosition": "auto"
-  },
-  "organizeImports": { "enabled": true },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "complexity": {
-        "noForEach": "off",
-        "noBannedTypes": "off"
-      },
-      "style": {
-        "noParameterAssign": "off"
-      }
-    }
-  },
-  "javascript": {
-    "formatter": {
-      "jsxQuoteStyle": "double",
-      "quoteProperties": "asNeeded",
-      "trailingCommas": "all",
-      "semicolons": "always",
-      "arrowParentheses": "always",
-      "bracketSpacing": true,
-      "bracketSameLine": false,
-      "quoteStyle": "single",
-      "attributePosition": "auto"
-    }
-  },
-  "overrides": [
-    {
-      "include": ["*.json"],
-      "formatter": {
-        "indentWidth": 2
-      }
-    }
-  ]
-}