valleyed 4.4.9 → 4.5.0

package/CHANGELOG.md

@@ -2,6 +2,77 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [4.5.0](https://github.com/kevinand11/valleyed/compare/v4.4.10...v4.5.0) (2025-06-23)
+
+
+### Features
+
+* accept multiple pipes in .pipe ([7a6ebb2](https://github.com/kevinand11/valleyed/commit/7a6ebb2987449df7092eee26e5293cd3fe71e460))
+* add __update function to allow update after init ([88a2f93](https://github.com/kevinand11/valleyed/commit/88a2f93c5d0403f443678db7ac3e4b17d7588013))
+* add id for json schema ([7499fe5](https://github.com/kevinand11/valleyed/commit/7499fe5fa6305c1c6dcbd679863ae7ff1a6f30b2))
+* allow value functions for all validators that expect a value input ([99276e7](https://github.com/kevinand11/valleyed/commit/99276e79bec45af2ea089474eafe85c01b78279c))
+* better PipeError ([96817b6](https://github.com/kevinand11/valleyed/commit/96817b6c96454cbe8ea3b29ce63ad07b46b67cd3))
+* bubble up config ([b24b8ee](https://github.com/kevinand11/valleyed/commit/b24b8eeb7161a3b9c26c41d2dc4be0ff0d284f6e))
+* coerce and function ([dcd4dc7](https://github.com/kevinand11/valleyed/commit/dcd4dc7a4009ac6e41fdcd8da258d86644c50555))
+* context ([d206e80](https://github.com/kevinand11/valleyed/commit/d206e80d43c5ddcc32504155c8e08cce32c12a92))
+* defaultOnFail sanitizer ([70cbb85](https://github.com/kevinand11/valleyed/commit/70cbb85e26b3f5b39169a43e78586897c1d067f4))
+* files and records pipe apis ([e9cca15](https://github.com/kevinand11/valleyed/commit/e9cca156067ec430b9a805a8b7bf5322247b1d91))
+* forward PipeError cause ([8507e4e](https://github.com/kevinand11/valleyed/commit/8507e4ec1a02b5077c6bf9c71b22e76024cf27a4))
+* fromJson pipe ([df1eafe](https://github.com/kevinand11/valleyed/commit/df1eafe90d739b63c900afdb24e85f293751944e))
+* generate json schema ([848ed78](https://github.com/kevinand11/valleyed/commit/848ed787c795b92879bec7fe8be59be5af8a3110))
+* isType supports any ([8584398](https://github.com/kevinand11/valleyed/commit/858439840f75bc4ebbbb009b0124fbbbeb480c02))
+* merge pipe ([005acb0](https://github.com/kevinand11/valleyed/commit/005acb01501cd5dd630f9c5ccefe7033206102ca))
+* meta on schema ([620143c](https://github.com/kevinand11/valleyed/commit/620143c80033205fe23206066d2a97a953a26c15))
+* more primitives ([f15ce01](https://github.com/kevinand11/valleyed/commit/f15ce0143cb21d2161050a7060ab4dd4367d292f))
+* new type ConditionalObjectKeys ([6829317](https://github.com/kevinand11/valleyed/commit/6829317c42bcf0dcec4f8614adf49171f369b573))
+* numbers pipe api ([9d1a5ab](https://github.com/kevinand11/valleyed/commit/9d1a5ab1a7709fc025d74c58ef5142744f48228d))
+* object extends ([129f32d](https://github.com/kevinand11/valleyed/commit/129f32de7dfe4f553251008ac4b2ffba95e75fd4))
+* objectExtends, objectPick and objectOmit ([6a89dc3](https://github.com/kevinand11/valleyed/commit/6a89dc367a3cb89bd579d600b282b677d395a7d8))
+* objectMerge ([2117fae](https://github.com/kevinand11/valleyed/commit/2117fae7dc2fde1e553657d7f5f47c72de58c038))
+* optionals api ([29a6fdc](https://github.com/kevinand11/valleyed/commit/29a6fdc878fbc0075a6ac285a09706ac075f7b40))
+* pipe api with primitives, junctions, core and arrays ([e9d2a69](https://github.com/kevinand11/valleyed/commit/e9d2a693b655016bd8c3caaaa15b1ae19a3e7954))
+* pipe node and gather when needed ([dc364b2](https://github.com/kevinand11/valleyed/commit/dc364b21992534cc31a107c93afb59d61cba07df))
+* refactor entire src for treeshaking ([254988d](https://github.com/kevinand11/valleyed/commit/254988d0c6fea4b3f15312fdddc9f73655f61b99))
+* remove need for anyOf in nullable schemas ([2bb3d00](https://github.com/kevinand11/valleyed/commit/2bb3d0043ef6f3e9ebf0a4d63c51512cebb4a051))
+* remove need for static list of files ([3d2d622](https://github.com/kevinand11/valleyed/commit/3d2d622067a9b29803e7c34bb3c2fc2cfe1baefb))
+* strings pipe api ([04c6df8](https://github.com/kevinand11/valleyed/commit/04c6df8b4a5d693efcf41c8680a5e7dfcea79ea4))
+* support custom context ([8530f8e](https://github.com/kevinand11/valleyed/commit/8530f8e8e7e423c425656af2c5bcfac61dae5684))
+* support generics for file validations ([e5cb7b4](https://github.com/kevinand11/valleyed/commit/e5cb7b45d8f2097520cc2515b9da85430a47f327))
+* support standard-schema ([e8b2c8f](https://github.com/kevinand11/valleyed/commit/e8b2c8fe115b1995d8a67cbbd20efec126df7345))
+* switch to reverse linked list impl ([831ec48](https://github.com/kevinand11/valleyed/commit/831ec48efcfe19c50c5e459b92fb36572482d045))
+* times pipe api ([1f18b5e](https://github.com/kevinand11/valleyed/commit/1f18b5e470da73de571d276c4a0dbb06e364a49e))
+* withStrippedHtml ([50cfe72](https://github.com/kevinand11/valleyed/commit/50cfe72bc226290345893d33abdb33d697b474b3))
+
+
+### Bug Fixes
+
+* before and after expects fn not plain values ([b40eb85](https://github.com/kevinand11/valleyed/commit/b40eb8549527d9fabd45fad27f00da244751b27a))
+* context and schema must be objects ([4d26247](https://github.com/kevinand11/valleyed/commit/4d26247b4c668fc70b8f16df480bd35455a6d154))
+* dataclass toJSON only returns original keys ([b1a5452](https://github.com/kevinand11/valleyed/commit/b1a54525c57bfc8fb9abef5959a8f0418d94b725))
+* fix JSONValue of DataClass<any, any> ([6a168c1](https://github.com/kevinand11/valleyed/commit/6a168c1f0af94b878c0870758e96b2ad2e858d75))
+* fix Prettify for class instances ([39d79fb](https://github.com/kevinand11/valleyed/commit/39d79fb70cff7d440f514f82d2b35278a58d7b82))
+* fix typings for objectX rules ([885ea27](https://github.com/kevinand11/valleyed/commit/885ea27adbb0d1dc3726454bb250057aaca19279))
+* fix up JSONValueOf ([de97762](https://github.com/kevinand11/valleyed/commit/de977629c8389986613dd3fd6379a68069d719ef))
+* impl for objectPick, objectOmit and objectExtends and add tests ([76a2f6b](https://github.com/kevinand11/valleyed/commit/76a2f6bf674e7e279046e1fb5f24c3424edfaf39))
+* no need to clone for objects ([f1f0f2d](https://github.com/kevinand11/valleyed/commit/f1f0f2d3493d29c359c1d1b1e2d6bffb10260611))
+* objectPick and objectEmit as value ([0f94a9a](https://github.com/kevinand11/valleyed/commit/0f94a9aa7f90e5e2ae6aaba425987a0c01e9b5f1))
+* optionals typing ([4ae6979](https://github.com/kevinand11/valleyed/commit/4ae6979836df939036870ffadd412c903dbc0979))
+* remove need for __update ([11bf277](https://github.com/kevinand11/valleyed/commit/11bf27709645853bbe9dcc0ec8a15dfe3a505996))
+* remove objectTrim ([630f1f0](https://github.com/kevinand11/valleyed/commit/630f1f05cab076344990e61ef5c266453d0f3388))
+* remove Pipe requirement for PipeInput, Output and Context ([0671b1e](https://github.com/kevinand11/valleyed/commit/0671b1e814cdfe6d95911752c13eaa90f1316c27))
+* remove unknown errors ([9d6fd72](https://github.com/kevinand11/valleyed/commit/9d6fd72fcc9067d6263f924f4db18d55c0912595))
+* rename safeParse to validate ([6ce2a75](https://github.com/kevinand11/valleyed/commit/6ce2a756ef728d49b61d94b29b0f779dffb5d828))
+* requiredIf doesnt add undefined to the type ([b8054fb](https://github.com/kevinand11/valleyed/commit/b8054fbe0d17cf1fb3904e766636f2a23be28f3c))
+* return type of DataClass toJSON ([9cd66ac](https://github.com/kevinand11/valleyed/commit/9cd66ac94f514979c59ebf50b6f7ff2e15c20c34))
+* stop Prettify from messing with classes ([2c6ca51](https://github.com/kevinand11/valleyed/commit/2c6ca51624e685e9a67720153711bf2abb200c2e))
+
+### [4.4.10](https://github.com/kevinand11/valleyed/compare/v4.4.9...v4.4.10) (2025-06-04)
+
+
+### Bug Fixes
+
+* type JSONValue of any with toJSON ([0d7d5a8](https://github.com/kevinand11/valleyed/commit/0d7d5a8aae7feed277ffb482e66ec583ed16a0a4))
+
 ### [4.4.9](https://github.com/kevinand11/valleyed/compare/v4.4.8...v4.4.9) (2025-06-04)
 
 

package/README.md

@@ -1,244 +1,318 @@
 # Valleyed
 
+Valleyed is a powerful, type-safe, and lightweight validation library for TypeScript and JavaScript. It provides a fluent, chainable API to build complex validation pipelines with ease, inspired by libraries like Zod, but with a focus on simplicity and extensibility.
 
-## Installation
+## ✨ Features
 
-This is a [Node.js](https://nodejs.org/en/) module available through the [npm registry](https://www.npmjs.com/package/valleyed).
-Before installing, [download and install Node.js](https://nodejs.org/en/download/). Node.js 4.2.4 or higher is required.
-If this is a brand new project, make sure to create a `package.json` first with the [`npm init` command](https://docs.npmjs.com/creating-a-package-json-file).
-Installation is done using the [`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+-   **Type-Safe**: Full TypeScript support, infer types directly from your schemas.
+-   **Lightweight**: Small bundle size with zero dependencies.
+-   **Chainable API**: Build complex validations by chaining methods.
+-   **Extensible**: Easily add your own custom validation logic.
+-   **Standard Schema Compatible**: Generate JSON Schemas from your validation pipes.
+-   **Isomorphic**: Works in both Node.js and browser environments.
 
-### Using npm:
-    npm install valleyed
+## 📦 Installation
 
-### Using yarn:
-    yarn add valleyed
+You can install Valleyed using your favorite package manager:
 
-### Using CDN:
-[Valleyed jsDelivr CDN](https://www.jsdelivr.com/package/npm/valleyed)
-
-
-## Basic Usage
-
-```ts
-import { isEmail, isMinOf } from 'valleyed'
-
-// The isEmail function builds and returns a function that checks if the first argument is a valid email
-let validity = isEmail()('johndoe@mail.co')
-console.log(validity)
-// Output should be : { valid: true, error: null, value: 'johndoe@mail.co' }
+```bash
+npm install valleyed
+# or
+yarn add valleyed
+# or
+pnpm add valleyed
+```
 
-// The isMinOf function builds a function that checks if the first argument is of minimum length of the length passed into the builder function
-validity = isMinOf(5)('abcd')
-console.log(validity)
-// Output should be : { valid: false, error: 'must contain 5 or more characters', value: 'abcd' }
+## 🚀 Quick Start
+
+Here's a quick example to get you started with Valleyed:
+
+```typescript
+import { v } from 'valleyed';
+
+// 1. Define a schema for your data
+const userSchema = v.object({
+  name: v.string().pipe(v.min(3)),
+  email: v.string().pipe(v.email()),
+  age: v.optional(v.number().pipe(v.gte(18))),
+});
+
+// 2. Some data to validate
+const userData = {
+  name: 'John Doe',
+  email: 'john.doe@example.com',
+};
+
+// 3. Validate the data
+const validationResult = userSchema.validate(userData);
+
+if (validationResult.valid) {
+  // Type-safe access to the validated data
+  console.log('Validation successful:', validationResult.value);
+} else {
+  // Detailed error messages
+  console.error('Validation failed:', validationResult.error.toString());
+}
+
+// 4. You can also parse directly, which throws on error
+try {
+    const user = userSchema.parse(userData);
+    console.log('Parsed user:', user);
+} catch (error) {
+    console.error(error);
+}
 ```
 
+## 📚 API Reference
 
-## Common Rule Builders
+Valleyed exports a single object `v` which contains all the validation functions.
 
-### Errors
+### Primitive Types
 
-All rule builders accept an optional string as the last argument used to customize the error message
+These are the basic building blocks for any schema.
 
-```ts
-const res = isEmail('is missing specific characters')('')
-console.log(res) // { valid: false, error: 'is missing specific characters', value: '' }
-```
+| Function         | Description                                          |
+| ---------------- | ---------------------------------------------------- |
+| `v.string()`     | Checks if the input is a `string`.                   |
+| `v.number()`     | Checks if the input is a `number` (and not `NaN`).   |
+| `v.boolean()`    | Checks if the input is a `boolean`.                  |
+| `v.null()`       | Checks if the input is `null`.                       |
+| `v.undefined()`  | Checks if the input is `undefined`.                  |
+| `v.any()`        | Allows any value, essentially a pass-through.        |
+| `v.instanceOf()` | Checks if the input is an instance of a given class. |
 
-### Equality
+```typescript
+// Example:
+v.string().validate('hello').valid; // true
+v.number().validate(123).valid; // true
+v.instanceOf(Date).validate(new Date()).valid; // true
+```
 
-```ts
-// Checks if the validation value is shallow equal to the compare. Valuable for comparing primitive types
-isShallowEqualTo(compare)
+### Core Validators
+
+These validators can be piped from any other validator to add more constraints.
+
+| Function                  | Description                                                              |
+| ------------------------- | ------------------------------------------------------------------------ |
+| `v.custom(fn, msg?)`      | Validates using a custom function that returns a boolean.                |
+| `v.eq(val, msg?)`         | Checks for deep equality with a given value. Alias: `v.is()`.            |
+| `v.ne(val, msg?)`         | Checks for deep inequality with a given value.                           |
+| `v.in(arr, msg?)`         | Checks if the value is present in the provided array.                    |
+| `v.nin(arr, msg?)`        | Checks if the value is **not** present in the provided array.            |
+| `v.has(len, msg?)`        | For strings and arrays, checks for an exact length.                      |
+| `v.min(len, msg?)`        | For strings and arrays, checks for a minimum length.                     |
+| `v.max(len, msg?)`        | For strings and arrays, checks for a maximum length.                     |
+
+```typescript
+// Example:
+const schema = v.string().pipe(v.min(5), v.in(['hello', 'world']));
+schema.validate('hello').valid; // true
+schema.validate('hi').valid; // false (fails min(5))
+schema.validate('testing').valid; // false (fails in([...]))
+```
 
-// Checks if the validation value resolves to true when passed into the compareFunction. The compareFunction passes the validation value and the compare value as the arguments and expects a boolean in return. Valuable for comparing non-primitive types.
-isDeepEqualTo(compare, compareFunction)
-const res = isDeepEqualTo({ id: 1 }, (value, compare) => {
-	return value?.id === compare.id
-})({ id: 1 }) // res.valid is true
+### String Validators
 
-// Checks if the validation value is in an array of predefined values
-arrayContains(array, compareFunction)
-const res = arrayContains([{ id: 1 }, { id: 2 }], (value, compare) => {
-	return value?.id === compare.id
-})({ id: 2 }) // res.valid is true
-```
+Specific validators and transformers for strings.
 
-### Strings
+| Function             | Description                                                              |
+| -------------------- | ------------------------------------------------------------------------ |
+| `v.email(msg?)`      | Validates an email address format.                                       |
+| `v.url(msg?)`        | Validates a URL format.                                                  |
+| `v.asTrimmed()`      | **Transformer**: Trims whitespace from the start and end of a string.    |
+| `v.asLowercased()`   | **Transformer**: Converts the string to lowercase.                       |
+| `v.asUppercased()`   | **Transformer**: Converts the string to uppercase.                       |
+| `v.asCapitalized()`  | **Transformer**: Capitalizes each word in the string.                    |
+| `v.asStrippedHtml()` | **Transformer**: Removes HTML tags from the string.                      |
+| `v.asSliced(len)`    | **Transformer**: Slices the string to a max length, adding `...`.        |
+| `v.withStrippedHtml(pipe)` | Applies a validation pipe to an HTML-stripped version of the string, but returns the original string if valid. |
 
-```ts
-// Checks if the validation value is of type String. This is used internally in all string methods, so no need to use it unless you are making a custom rule
-isString()
+```typescript
+// Example:
+v.string().pipe(v.email()).validate('test@example.com').valid; // true
 
-// Checks if the length of the validation value is equal to the length
-isLengthOf(length)
+const trimmedLower = v.string().pipe(v.asTrimmed(), v.asLowercased());
+trimmedLower.parse('  HeLLo  '); // 'hello'
+```
 
-// Checks if the length of the validation value is greater than or equal to the length
-isMinOf(length)
+### Number Validators
 
-// Checks if the length of the validation value is less than or equal to the length
-isMaxOf(length)
+Specific validators and transformers for numbers.
 
-// Checks if the validation value is formatted as a valid email
-isEmail()
+| Function          | Description                                              |
+| ----------------- | -------------------------------------------------------- |
+| `v.gt(num, msg?)` | Checks if the number is greater than the given value.    |
+| `v.gte(num, msg?)`| Checks if the number is greater than or equal to the given value. |
+| `v.lt(num, msg?)` | Checks if the number is less than the given value.       |
+| `v.lte(num, msg?)`| Checks if the number is less than or equal to the given value. |
+| `v.int(msg?)`     | Checks if the number is an integer.                      |
+| `v.asRounded(dp?)`| **Transformer**: Rounds the number to a number of decimal places. |
 
-// Checks if the validation value is formatted as a valid url
-isUrl()
+```typescript
+// Example:
+const ageSchema = v.number().pipe(v.int(), v.gte(18));
+ageSchema.validate(25).valid; // true
+ageSchema.validate(17.5).valid; // false
 ```
 
-### Numbers
-
-```ts
-// Checks if the validation value is of type Number. This is used internally in all number methods, so no need to use it unless you are making a custom rule
-isNumber()
+### Array Validators
 
-// Checks if the the validation value is greater than the compare
-isMoreThan(compare)
+Validators for handling arrays.
 
-// Checks if the the validation value is greater than or equal to the compare
-isMoreThanOrEqualTo(compare)
+| Function                  | Description                                                              |
+| ------------------------- | ------------------------------------------------------------------------ |
+| `v.array(schema)`         | Validates that every element in an array matches the provided schema.    |
+| `v.tuple([s1, s2])`       | Validates a fixed-length array where each element has a specific type.   |
+| `v.asSet(keyFn?)`         | **Transformer**: Removes duplicates from an array. By default, it uses the value itself for comparison. You can provide a `keyFn` for objects. |
 
-// Checks if the the validation value is less than the compare
-isLessThan(compare)
+```typescript
+// Example:
+const tagsSchema = v.array(v.string().pipe(v.min(2)));
+tagsSchema.validate(['food', 'travel']).valid; // true
 
-// Checks if the the validation value is less than or equal to the compare
-isLessThanOrEqualTo(compare)
+const pointSchema = v.tuple([v.number(), v.number()]);
+pointSchema.validate([10, 20]).valid; // true
 ```
 
-### Arrays
+### Object Validators
 
-```ts
-// Checks if the validation value is of type Array. This is used internally in all array methods, so no need to use it unless you are making a custom rule
-isArray()
+Validators for handling objects.
 
-// Checks if the length of the validation value is equal to the length
-hasLengthOf(length)
+| Function                        | Description                                                              |
+| ------------------------------- | ------------------------------------------------------------------------ |
+| `v.object({ k: schema })`       | Validates an object's properties against a schema definition.            |
+| `v.record(keySchema, valSchema)`| Validates objects with dynamic keys (like dictionaries or records).      |
+| `v.objectPick(schema, keys)`    | Creates a new object schema by picking specified keys from an existing one. |
+| `v.objectOmit(schema, keys)`    | Creates a new object schema by omitting specified keys from an existing one. |
+| `v.objectExtends(schema, pipes)`| Extends an object schema with new properties.                            |
+| `v.asMap()`                     | **Transformer**: Converts a record-like object into a `Map`.             |
 
-// Checks if the length of the validation value is greater than or equal to the length
-hasMinOf(length)
+```typescript
+// Example:
+const userSchema = v.object({ name: v.string(), age: v.number() });
 
-// Checks if the length of the validation value is less than or equal to the length
-hasMaxOf(length)
+const publicUserSchema = v.objectOmit(userSchema, ['age']);
+publicUserSchema.validate({ name: 'John' }).valid; // true
 
-// Checks if the validation value is formatted as a valid email
-isEmail()
-
-// Checks if all elements in the valition value passes a requirement. The compare function passes a element and its index as the arguments and expects a boolean in return.
-isArrayOf(compareFunction)
-const res = isArrayOf((element, index) => {
-	return isString(element).valid // This ensures all elements in the array are strings
-})(['a', 'b', 'c']) // res.valid is true
+const userWithIdSchema = v.objectExtends(userSchema, { id: v.string() });
+userWithIdSchema.validate({ id: 'user-1', name: 'Jane', age: 30 }).valid; // true
+```
 
-// Used to validate tuples(arrays that can contain different data types). Checks if all elements in the validation values passes a different requirement
-isTuple(compareFunctionsArray)
-const res = isTuple([
-	(element, index) => isString(element).valid,
-	(element, index) => isNumber(element).valid
-])(['hello world', 2]) // res.valid is true because it expects an array that contains a string at index 0 and a number at index 1
+### Optional & Default Values
+
+Functions for handling optional values and providing defaults.
+
+| Function                       | Description                                                              |
+| ------------------------------ | ------------------------------------------------------------------------ |
+| `v.optional(schema)`           | Allows the value to be `undefined`.                                      |
+| `v.nullable(schema)`           | Allows the value to be `null`.                                           |
+| `v.nullish(schema)`            | Allows the value to be `null` or `undefined`.                            |
+| `v.defaults(schema, val)`      | Provides a default value if the input is `undefined`.                    |
+| `v.defaultsOnFail(schema, val)`| Provides a default value if the initial validation fails.                |
+| `v.conditional(schema, fn)`    | Makes a field optional based on a dynamic boolean condition.             |
+
+```typescript
+// Example:
+const schema = v.object({
+  name: v.string(),
+  nickname: v.optional(v.string()),
+  role: v.defaults(v.string(), 'user'),
+});
+
+schema.parse({ name: 'John' });
+// { name: 'John', role: 'user' }
 ```
 
-### Datetime
+### Junctions (Unions & Intersections)
 
-```ts
-// Checks if the validation value can be parsed into a valid javascript date. Validation value can be a Date object, a timestamp number or a datetime string. This is used internally in all datetime methods, so no need to use it unless you are making a custom rule
-isTime()
+Combine schemas to create complex types.
 
-// Checks if the validation value is later than the compare. Compare can also be a Date object, a timestamp number or a datetime string
-isLaterThan(compare)
+| Function                               | Description                                                              |
+| -------------------------------------- | ------------------------------------------------------------------------ |
+| `v.or([s1, s2])`                       | A union type. The value must match at least one of the provided schemas. |
+| `v.and([s1, s2])`                      | An intersection. The value must match all of the provided schemas.       |
+| `v.merge(s1, s2)`                      | Merges two object or array schemas.                                      |
+| `v.discriminate(fn, schemas)`          | Validates against one of several object schemas based on a discriminator field. |
+| `v.fromJson(schema)`                   | **Transformer**: Parses a JSON string before validating against a schema. |
 
-// Checks if the validation value is earlier than the compare. Compare can also be a Date object, a timestamp number or a datetime string
-isEarlierThan(compare)
-```
+```typescript
+// Example: Discriminated Union
+const shapeSchema = v.discriminate(v => v.type, {
+  circle: v.object({ type: v.is('circle'), radius: v.number() }),
+  square: v.object({ type: v.is('square'), side: v.number() }),
+});
 
-### Other Types
-
-```ts
-// Checks if the validation value is a boolean
-isBoolean()
+shapeSchema.validate({ type: 'circle', radius: 10 }).valid; // true
+shapeSchema.validate({ type: 'square', side: 5 }).valid; // true
+```
 
-// Checks if the validation value is null
-isNull()
+### Date & Time Validators
 
-// Checks if the validation value is undefined
-isUndefined()
+Validators and transformers for dates and times.
 
-// Checks if the validation value is an instance of the Class passed in
-isInstanceOf(classDefinition)
-const res = isInstanceOf(String)('') // res.valid is true
-```
+| Function            | Description                                                              |
+| ------------------- | ------------------------------------------------------------------------ |
+| `v.time(msg?)`      | Validates a date, accepting `Date` objects, timestamps, or date strings. |
+| `v.after(date, msg?)`| Checks if the date is after a specified date.                          |
+| `v.before(date, msg?)`| Checks if the date is before a specified date.                         |
+| `v.asStamp()`       | **Transformer**: Converts a `Date` object into a numeric timestamp.      |
+| `v.asISOString()`   | **Transformer**: Converts a `Date` object into an ISO 8601 string.       |
 
-### Records and Maps
-
-```ts
-/// Checks if all values in an object passes a comparer function
-isRecord(compareFunction)
-const res = isRecord((currentValue) => {
-	return isNumber(currentValue).valid
-})({ a: 1, b: 2, c: 3 }) // res.valid is true because all the values of the object are numbers
-
-/// Checks if all keys and values in an map passes a comparer function
-isMap(keysCompareFunction, valuesCompareFunction)
-const map = new Map([
-	[1, true],
-	[2, false],
-	[3, true]
-])
-const res = isMap(
-	(key) => isNumber(key).valid,
-	(value) => isBoolean(value).valid
-)(map) // res.valid is true because all the keys of the map are numbers and all the values are booleans
+```typescript
+// Example:
+const eventSchema = v.object({
+  name: v.string(),
+  startsAt: v.time().pipe(v.after(new Date())),
+});
 ```
 
-### Files
-
-```ts
-// Checks if the validation value is an object with a key "type" that contains a supported file mimetypes. All supported file mimetypes can be imported under the name "fileMimeTypes". This is used internally in all file methods, so no need to use it unless you are making a custom rule
-isFile()
+### File Validators
 
-// Checks if the validation value's type is a valid image mimetype. All supported image mimetypes can be imported under the name "imageMimeTypes".
-isImage()
+Validators for file-like objects (e.g., from a file upload). These validators expect an object with a `type` property containing the MIME type.
 
-// Checks if the validation value's type is a valid audio mimetype. All supported audio mimetypes can be imported under the name "audioMimeTypes".
-isAudio()
+| Function                      | Description                                                              |
+| ----------------------------- | ------------------------------------------------------------------------ |
+| `v.file(msg?)`                | Validates a generic file-like object.                                    |
+| `v.image(msg?)`               | Validates if the file is an image (`image/*`).                           |
+| `v.audio(msg?)`               | Validates if the file is an audio file (`audio/*`).                      |
+| `v.video(msg?)`               | Validates if the file is a video file (`video/*`).                       |
+| `v.fileType(types, msg?)`     | Validates if the file's MIME type is in the provided list.               |
 
-// Checks if the validation value's type is a valid video mimetype. All supported video mimetypes can be imported under the name "videoMimeTypes".
-isVideo()
+```typescript
+// Example:
+const imageSchema = v.file().pipe(v.image(), v.fileType(['image/jpeg', 'image/png']));
+imageSchema.validate({ type: 'image/png' }).valid; // true
+imageSchema.validate({ type: 'image/gif' }).valid; // false
 ```
 
-### Custom Rule
+### Coercion
 
-```ts
-// If there is a rule for your usecase, you can create a custom one with this. The validityFunction passes the validation value as its argument and expects a boolean in return
-isCustom(validityFunction)
-const res = isCustom((value) => typeof value === 'function')(() => {}) // res.valid is true because the typeof value is function
-```
+These pipes attempt to convert the input to a specific type before validating it.
 
+| Function            | Description                                                              |
+| ------------------- | ------------------------------------------------------------------------ |
+| `v.coerceString()`  | Coerces to `string` using `String()`.                                    |
+| `v.coerceNumber()`  | Coerces to `number` using `Number()`. Fails if the result is `NaN`.      |
+| `v.coerceBoolean()` | Coerces to `boolean` using `Boolean()`.                                  |
+| `v.coerceTime()`    | Coerces to `Date` using `new Date()`.                                    |
 
-## Combining Rules
+```typescript
+// Example:
+const schema = v.coerceNumber().pipe(v.int());
+schema.parse('123'); // 123
+schema.validate('123.45').valid; // false (fails int())
+```
 
-```ts
-import { Validator, isEmail, isMinOf, isString, isNumber } from 'valleyed'
+## 🤝 Contributing
 
-// The Validator.and function is used to build up a schema or list of rules to validate a value against
-let res = Validator.and([[isEmail(), isMinOf(1)]])('johndoe@mail.com')
-console.log(res) // { valid: true, errors: [], value: 'johndoe@mail.com' }
+Contributions are welcome! Please open an issue or submit a pull request.
 
-// if the value fails validation, it returns a list of all errors in the errors array
-res = Validator.and([[isEmail(), isMinOf(1)]])('')
-console.log(res) // { valid: false, value: '', errors: [ 'is not a valid email', 'must contain 1 or more characters' ] }
+### Development Setup
 
-// Similar to the And function, Validator has an or function that checks if the value passes validation for any of the list of rules passed in
-let res = Validator.or([[isString(), isMinOf(1)], [isNumber()]])(2)
-console.log(res) // { valid: true, value: 2, errors: [] }
+1.  Clone the repository.
+2.  Install dependencies with `pnpm install`.
+3.  Run tests with `pnpm test`.
 
-// if the value fails validation, it returns a list of all errors in the errors array
-res = Validator.or([[isString(), isMinOf(1)], [isNumber()]])(false)
-console.log(res) // { valid: false, value: false, errors: [ 'doesn't match any of the schema' ] }
+## 📜 License
 
-// An optional third paramater can be passed into the And/Or functions to control if null and undefined are allowed to pass validation
-Validator.and([[isEmail()]], {
-	nullable: true, // Boolean: if true, null passed as the first argument passes validation
-	required: () => false // Boolean or Function that returns a boolean: if false, undefined passed as the first argument passes validation
-})('')
-```
+This project is licensed under the MIT License.

package/lib/api/arrays.d.ts

@@ -1,8 +1,4 @@
-import { VCore } from './core';
-export declare class VArray<I> extends VCore<I[]> {
-    constructor(comparer: VCore<I>, err?: string);
-    has(length: number, err?: string): this;
-    min(length: number, err?: string): this;
-    max(length: number, err?: string): this;
-    set(keyFn?: (v: I) => any): this;
-}
+import { PipeInput, type Pipe, type PipeOutput } from './base';
+export declare const array: <T extends Pipe<any, any, any>>(pipeSchema: T) => Pipe<PipeInput<T>[], PipeOutput<T>[], any>;
+export declare const tuple: <T extends ReadonlyArray<Pipe<any, any, any>>>(pipes: readonly [...T]) => Pipe<{ [K in keyof T]: PipeInput<T[K]>; }, { [K_1 in keyof T]: PipeOutput<T[K_1]>; }, any>;
+export declare const asSet: <T>(keyFn?: (i: T) => PropertyKey) => Pipe<T[], T[], any>;