vuelidify 1.0.1 → 2.0.1

package/README.md

@@ -1,23 +1,24 @@
 # Vuelidify
 
-
 [Installation](#installation)
 [Types](#types)
 [Examples](#examples)
+[Technical Details](#technical-details)
+[Custom Validators](#custom-validators)
 ---
-*A simple and lightweight Vue 3 model based validation library with strong type support.*
+*Vuelidify is a Vue 3 model-based validation library that makes complex form validation easy.*
 
-This library was inspired by Vuelidate but seeks to solve some of its biggest problems. This library does NOT support Vue2, and does NOT support commonJS. Technology must move forward.
+This library was inspired by Vuelidate and sought to solve some of its biggest problems. This library does NOT support Vue2, and does NOT support commonJS. Technology must move forward.
 
-**✨ Simple** because it does exactly what it needs to with no dependencies other than Vue.
+**✨ Powerful** because it handles complex validation scenarios easily and efficiently.
 
-**🪶 Lightweight** because the .mjs is <9KB (uncompressed), and ~3KB gzipped.
+**🪶 Lightweight** because the .mjs is <9KB (uncompressed), and ~3KB gzipped; no bloat or useless dependencies.
 
-**📝 Model based** refers to validation being done in the script tag on an object. This is an alternative to template based validation, which uses template components and attributes to validate an object.
+**📝 Model-based** refers to validation being done in your script alongside your data instead of in your templates.
 
-**💪 Strong types** makes setting up validation intuitive for developers. No more: "wait, how do I do that again?"
+**💪 Strong types** makes setup intuitive for developers. No more, "wait, how do I do that again?"
 
-Too many validation libraries for Vue lack good type support; which negatively impacts maintainability. Changes to models would not indicate that validation needs to be updated as well. This library was created to fix that problem.
+Too many validation libraries for Vue lack good type support, which makes maintaining codebases harder over time. When your data models change, there's often no clear signal that your validation needs updated as well. Vuelidify was built to solve this problem.
 
 ---
 
@@ -37,7 +38,7 @@ pnpm add vuelidify
 
 ## Types
 
-This was created for use in ```<script setup lang="ts">```, meaning you need TypeScript in order to get the full benefits of this library.
+This was created for use in ```<script setup lang="ts">```. You need TypeScript in order to get the full benefits of this library.
 
 **useValidation()** is the starting point for validating your models.
 
@@ -52,62 +53,84 @@ This was created for use in ```<script setup lang="ts">```, meaning you need Typ
 Here is a breakdown of the configuration object the composable expects.
 ```ts
 {
-  objectToValidate: T, // The ref, computed, or reactive object you want to validate.
+  model: T, // The ref, computed, or reactive object you want to validate.
   validation: Validation<T>, // Describes how to validate your object.
-  args: A = undefined, // Can be anything! Will be passed into every validator.
+  args: A = undefined, // Can be anything and will be passed into every validator.
   delayReactiveValidation: boolean, // Should reactive validation be active immediately or only after calling validate()?
 }
 ```
 That's it, super simple!
 
-Just kidding, ```validation: Validation<T>``` isn't the full picture. The type here is quite complicated, but easy to use. Here's what you need to know.
+Just kidding, ```validation: Validation<T>``` isn't the full picture. The type here is quite complicated, but easy to use. Here's what you need to know:
 
-1. ```Validation<T>``` will copy the type of your object, down to the names of properties. Nested objects will also be copied, and their inner types as well. This type is recursive!
-2. Properties which are primitives or arrays are the exit conditions to the recursive type. Instead they will present ```PrimitiveValidationTypes``` or ```ArrayValidationTypes``` respectively.
+1. ```Validation<T>``` will copy the layout of T's properties. Nested objects will also be copied. This type is recursive!
+2. Types which can be validated will have some unique properties available:
 ```ts
+
+// foo is a string
+foo: {
+	$reactive?: [],
+	$lazy?: []
+}
+// bar is an array
+bar: {
+	$reactive?: [],
+	$lazy?: []
+	$each?: {},
+}
+// zaa is an object containing { foo: string, bar: array }
 {
-	// foo is a string
-	foo: {
+	$reactive?: [],
+	$lazy?: [],
+	bar: {
 		$reactive?: [],
 		$lazy?: []
-	}
-	// bar is an array
-	bar: {
 		$each?: {},
+	},
+	foo: {
 		$reactive?: [],
 		$lazy?: []
 	}
 }
+
 ```
-3. Arrays are special. If you have an array of objects that need validated, ```$each``` will be your friend. ```$each``` will be the same type as ```Validation<U>``` where ```U``` is the type of each object in the array. This loop can go on forever, as long as your object also has sufficiently many children and arrays!
-4. ```$reactive``` is an array of validators that should be performed on that property reactively.
-5. ```$lazy``` is an array of validators that should be performed on that property whenever ```validate()``` is called. This was added so you can control when more expensive validatiors are invoked.
+3. ```$each``` is the same type as ```Validation<U>``` where ```U``` is the type of each object in the array you are validating.
+4. ```$reactive``` is an array of validators that should be performed reactively on that property. [See technical details](#technical-details) for more information.
+5. ```$lazy``` is an array of validators that should be performed on that property whenever ```validate()``` is called. [See technical details](#technical-details) for more information.
 
-Here is the breakdown of the return of the composable
+Here is the breakdown of the composable's return type
 ```ts
 {
+	// true after validate() is invoked once
 	hasValidated: boolean,
-	// True if you object has changed from the reference.
-	// Useful for enabling save buttons after changes have been made
-	isDirty: boolean,
-	isValid: boolean, 
+	// invokes every validator defined in the validation rules.
+	// returns whether or not they all passed
+	validate: () => Promise<boolean>
 	isValidating: boolean,
-	// Access the results of validation. This will copy the properties of your object.
-	// Every "exit" condition have it's own type explained below
+	// Access the results of validation.
+	// This type is explained below.
 	state: ValidationState<T>,
+	// true only if every validator passed
+	isValid: boolean,
+	// true if any validator failed
+	isErrored: boolean,
 	// Set the comparison object for determining dirty state.
-	// If your object must first load in asynchronously,
+	// If your object must load in asynchronously,
 	// use this function to set the reference once it has loaded.
-	setReference: (reference: T) => void, 
-	validate: () => Promise<boolean>
+	setReference: (reference: T) => void,
+	// True if your object has changed from the reference.
+	// Useful for enabling save buttons after changes have been made
+	isDirty: boolean,
 }
 ```
-Here is the breakdown of the validation state
+Validation state also copies the layout of the model you provide. However, instead of providing validators, you now get access to `$state` and `$arrayState`. `$arrayState` is just an array of state objects created by validating an array object.
+
+Here is the breakdown of `$state`
 ```ts
 {
 	// The collected error messages returned from all the validators
 	errorMessages: string[],
-	// True if any validators returned false.
+	// True if any validators failed.
 	// Not equivalent to !isValid, because !isValid is true even
 	// when validation has not been ran yet.
 	// Can be false when there are lazy validators that still need executed.
@@ -116,27 +139,29 @@ Here is the breakdown of the validation state
 	isValid: boolean,
 	isValidating: boolean,
 	// A map for easily accessing named validation results.
-	// This is the one spot without type support
+	// This is the one spot without good type support.
 	results: { [key: string]: BaseValidationReturn<F> }
-	// A 2D array of the validation results
+	// A collection of validator responses.
 	resultsArray: Array<BaseValidationReturn<F>>
 }
 ```
-Here is the breakdown of the return type from validators.
+Validators must return one of the following:
 ```ts
-// Validators must either return a BaseValidationReturn<F> object, undefined,
-// or an array of validators which will be invoked immediately.
-{
+BaseValidationReturn<F> | Validator[] | undefined
+```
+Here is the breakdown of the `BaseValidationReturn<F>`
+```ts
+type BaseValidationReturn<F> = {
 	// Name the result of this validator. This will put the validation result
 	// into the results map in the validation state of this property.
 	// Make sure your names are unique between your validators.
 	name?: string,
-	// the unique identifier for this validation result. Assigned interally.
+	// the unique identifier for this validation result. Assigned internally.
 	// you can use this ID to identify your DOM elements that display error messages.
 	id? string,
 	// required for determining whether or not this validator passed
 	isValid: boolean,
-	errorMessage?: string,
+	message?: string,
 	// Sometimes a true or false is not enough information for end users.
 	// Use this to return any object to give additional information about the validation.
 	// In order to access this custom data easily, make sure you give the result a name
@@ -145,27 +170,24 @@ Here is the breakdown of the return type from validators.
 ```
 Here is the breakdown of the parameters that are passed into validators
 ```ts
-{
+type ValidatorParams<T,P,V,A> = {
 	// The value of the property being validated
 	value: T,
 	// The top-most ancestor being validated. The object that was passed to the composable.
 	parent: P,
 	// The args that were specified in the composable configuration.
-	// This type will only appear for you when args is NOT undefined.
 	args: V,
-	// Will only appear for properties nested in some array.
 	// The type will be an ordered array of strongly typed objects.
-	// Each element is a "parent" in the array, or an ancestor to the property you're validating.
-	// Index 0 will be appear when you're 1 array deep, and index 1 will appear 2 arrays deep, etc.
-	// The limit of nested arrays is currently 20, and I don't think you'll need more than that.
-	// Extremely useful for complex validation of arrays where validation depends on the array object,
-	// rather than the top-most parent object which contains the array.
-	arrayParents: A
+	// Each index is an ancestor to what you're validating.
+	// Index 0 will appear when you're 1 array deep, and index 1 will appear 2 arrays deep, etc.
+	// Extremely useful for complex validation.
+	arrayAncestors: A
 }
 ```
 
 ## Examples
-#### Primitives
+### Validation Rules
+#### Validating Primitives
 ```ts
 <script setup lang="ts">
 	import { ref } from 'vue';
@@ -173,29 +195,42 @@ Here is the breakdown of the parameters that are passed into validators
 	
 	const string = ref("");
 	const v$ = useValidation({
-		objectToValidate: string,
+		model: string,
 		validation: {
 			$reactive: [minLength(10)] // Put as many validators as you want here
 		}
 	});
 </script>
 ```
-#### Simple Objects
+#### Validating Simple Objects
 ```ts
 <script setup lang="ts">
-	import { ref } from 'vue';
+	import { ref, type Ref } from 'vue';
 	import { minLength, useValidation, minNumber } from "vuelidify";
 
-	const obj = ref({
+	// Note this format may not have correctly typed validation when using strict TypeScript.
+	// const obj = ref({
+	// 	foo: "string",
+	// 	bar: true,
+	// 	zaa: 1
+	// });
+
+	type SimpleObject = {
+		foo: name;
+		bar: boolean;
+		zaa: number;
+	}
+	const obj: Ref<SimpleObject> = ref({
 		foo: "string",
 		bar: true,
 		zaa: 1
-	});
+	})
+
 	const v$ = useValidation({
-		objectToValidate: obj,
+		model: obj,
 		validation: {
 			foo: {
-				// Validate foo when v$.validate is called.
+				// Validate foo when v$.validate() is invoked.
 				$lazy: [minLength(10)]
 			},
 			bar: {
@@ -207,15 +242,15 @@ Here is the breakdown of the parameters that are passed into validators
 				}]
 			},
 			zaa: {
-				// Validate zaa reactively and when v$.validate is called.
-				// Notice how validation can depend on other properties in the parent.
+				// Validate zaa reactively and when v$.validate() is invoked.
+				// Notice how you can validate using other properties in the model.
 				$reactive: [minNumber(10)],
 				$lazy: [
 					(params) => {
-						const isBar = params.parent.bar;
+						const isBar = params.model.bar;
 						return {
 							isValid: isBar ? params.value > 100 : true,
-							errorMessage: "Must be greater than 100 when bar is true"
+							message: "Must be greater than 100 when bar is true"
 						}
 					}
 				]
@@ -224,7 +259,7 @@ Here is the breakdown of the parameters that are passed into validators
 	});
 </script>
 ```
-#### Arrays
+#### Validating Arrays
 ```ts
 <script setup lang="ts">
 	import { ref } from 'vue';
@@ -235,9 +270,9 @@ Here is the breakdown of the parameters that are passed into validators
 		isActive: boolean;
 	}
 
-	const array = ref<FooBar[]>([]);
+	const array: Ref<FooBar[]> = ref([]);
 	const v$ = useValidation({
-		objectToValidate: array,
+		model: array,
 		validation: {
 			// Validate each object in the array.
 			$each: {
@@ -246,11 +281,12 @@ Here is the breakdown of the parameters that are passed into validators
 					$reactive: [
 						// Validate the length of the name only if the object's isActive property is true.
 						(params) => {
-							if (params.arrayParents[0].isActive !== true) {
-								// Return undefined to ignore this validator when the condition is not true.
-								// This check can even be asynchronous!
+							// arrayAncestors[0] is an object with ancestor, index, and the array it is in.
+							if (params.arrayAncestors[0].ancestor.isActive === false) {
+								// Return undefined to ignore this validator
 								return;
 							}
+							// Return an array of validators which are immediately invoked. Useful for conditional validation.
 							return [minLength(10)]
 						}
 					]
@@ -260,26 +296,26 @@ Here is the breakdown of the parameters that are passed into validators
 	});
 </script>
 ```
-#### Complex Objects
-Sometimes your objects will contain other objects and arrays.
+#### Validating Complex Objects
+Sometimes your objects will contain objects and arrays.
 ```ts
 <script setup lang="ts">
 	import { ref } from 'vue';
 	import { minLength, minNumber, useValidation } from "vuelidify";
 
-	type Person = {
+	type Example = {
 		a: Person,
 		b: Person[]
 	}
-	
+
 	type Person = {
 		name: string;
 		age: number;
 	}
 
-	const complexObj = ref<Person>();
+	const complexObj: Ref<Example | undefined> = ref();
 	const v$ = useValidation({
-		objectToValidate: complexObj,
+		model: complexObj,
 		validation: {
 			a: {
 				// Validate person a's age reactively
@@ -296,8 +332,9 @@ Sometimes your objects will contain other objects and arrays.
 							// Make sure each person in the array is younger than person a
 							(params) => {
 								return {
-									isValid: params.value < params.parent.a.age,
-									errorMessage: "Must be younger than person a."
+									isValid: params.model?.a.age != undefined
+										&& params.value < params.model.a.age,
+									message: "Must be younger than person a."
 								}
 							}
 						],
@@ -312,20 +349,34 @@ Sometimes your objects will contain other objects and arrays.
 	});
 </script>
 ```
+### Validation State
+All of the validation types present their results similarly. Just access `state` to get started! As long as you have TypeScript enabled in your workspace, you should have no problem understanding its layout. Here's a short example on what you can do with the state object.
+```ts
+const v$ = useValidation({ 
+	// ... complex object validation provided earlier ...
+})
+// The error messages present on person a's age
+const aAgeErrors: string[] | undefined = v$.state.a?.age?.$state?.errorMessages;
+// An array of validation state objects on each person of property b.
+const bErrors = v$.state.b?.$arrayState;
+```
+Note, properties may show up in the intellisense, but they are undefinable *on purpose*. If validation rules are not provided for a property, its state object will not exist.
 
 ## Technical Details
 For those interested in the inner workings of the library without looking at the code:
 
-- Reactive validation is performed by a deep watcher on the parent object. This was done because of inter-property dependence. When a validator for one property relies on another property in the object, it needs to be reevaluated. This does come with the technical debt of running every *reactive* validator in your object every time the user enters a character. But I this is mediated by validator optimizations discussed later.
-- Lazy validation is only performed only when the validate() function is called. However, validate() will also invoke all reactive validators to guarantee all validation results are up-to-date with the model. Properties or the object itself may be valid before ever calling validate() if there were no lazy validators specified, and all reactive validators were true (or again none specified).
-- Async validators can be mixed with sync validators, so there is no way to distinguish them upon initialization. However, once they are invoked for the first time, it is possible to distinguish them. Optimizations can then be made on the sync and async validators to improve validation behavior and performance. Sync validators will be wrapped in a computed function which has the benefit of determining reactive dependencies and caching the result. This counteracts the downside of using a deep watcher discussed previously. Synchronous validators will not be needlessly reevaluated every time a character changes in an unrelated property because the computed determines it doesn't rely on it. Async validators will be optimized based on how long they take to return. If they return faster than 250ms, they will not be given any optimization; if they return less than 500ms they will be given a throttle of 250ms; if they return longer than that they will be given a buffer. Details of the throttles are below.
-- ```throttleQueueAsync``` is a custom function exported by this library which solves some of the problems I had with lodash's throttle function. This function throttles a function, can copy it's signature, and returns a promise for the result of the function. Calling this function will instantly execute the function if there is no active throttle. Calling this function with an active throttle will return a promise to call the function as soon as the throttle has expired. Calling the function multiple times during the throttle period will keep overriding the queued promise. Overridden queued promises will return undefined once the throttle expires. This function is very complicated, but extremely useful for returning control back to the caller and guaranteeing that the function gets called with the latest parameters. This are all problems with current implementation of debounce or throttle which use setTimeout() without being wrapped in a promise.
-- ```bufferAsync``` is another custom function exported by this library which offers a more aggressive throttling behavior than ```throttleQueueAsync```. Instead, this function creates an "invocation buffer" on the provided function, copies the functions signature, and returns a promise to the result of the function. Essentially, the function provided will only be ran once the previous invocation of the function has returned. This function also uses a queue to guarantee invocation of the desired function after the previous invocation has returned.
+- Reactive validation is performed by a deep watcher on the provided model. This was done because of inter-property dependence. When a validator for one property relies on another property in the object, it needs to be reevaluated. This does come with the technical debt of running *every* reactive validator *every* time the model is changed. However, the problem is mediated by validator optimizations which is discussed later.
+- Lazy validation is only performed only when the `validate()` function is called. However, `validate()` will also invoke all reactive validators to guarantee all validation results are up-to-date with the model. Properties or the model itself may be valid before ever calling `validate()` if there were no lazy validators provided, and all reactive validators were true (or again none specified).
+- Async validators can be mixed with sync validators, so there is no way to distinguish them upon initialization. However, once they are invoked for the first time, it is possible to distinguish them. Optimizations can then be made on the sync and async validators to improve validation behavior and performance. Sync validators will be wrapped in a computed function which has the benefit of determining reactive dependencies and caching the result. This counteracts the downside of using a deep watcher discussed previously. Synchronous validators will not be needlessly reevaluated every time a character changes in an unrelated property because the computed determines it doesn't rely on it. Async validators will be optimized based on how long they take to return. If they return faster than 250ms, they will not be given any optimization; if they return in less than 500ms, they will be given a throttle of 250ms; if they return longer than that they will be given a buffer. Details of the throttles are below.
+- `throttleAsync` is an async throttler that preserves your function’s signature and always returns a Promise of its result. It executes immediately when idle; if called during the throttle interval, it buffers only the latest call and runs it once the interval elapses—earlier buffered calls resolve to `undefined`. This lets you schedule non-blocking, promise-based throttling without overlapping executions and guarantees you always call your function with the latest arguments. Note, you are unable to distinguish if your function returned `undefined` or `throttleAsync` returned `undefined`.
+- `bufferAsync` is another custom function exported by this library that provides a more aggressive throttling behavior than `throttleAsync`. `bufferAsync` preserves the original function’s signature and returns a promise resolving to its result. It only remembers the latest invocation while the provided function is still executing. Once the current execution completes, only the remembered call will be invoked — all intermediate calls will return `undefined`. This mechanism prevents overlapping executions and reduces redundant work, making it ideal for expensive async operations where only the most recent intent should be executed. Note, you are unable to distinguish if your function returned `undefined` or `bufferAsync` returned `undefined`.
+- Returning arrays of validators from within other validators is powerful but complex. Initially, we aimed to optimize these nested validators, but their dynamic nature--varying instances, order, and presence between iterations--made this unreliable. Since their results merge with all other validators, Vuelidify tracks and removes outdated results when the "parent" validator is invoked again and the same results are not returned.
+- This library uses `unknown` instead of `any` to align with Deno and strict TypeScript standards. While `Args` and `Ancestors` are logically `undefined` by default, using `undefined` as a type causes issues—`unknown` can't be assigned to `undefined`. This distinction is why some of Vuelidify’s types may seem unusual, especially when creating generic validators meant to work universally. Additionally, the default type of `Return` is `any` because it truly *can be* anything. If it was unknown, you would be unable to access it for anything. `Return` is the only part of Vuelidify that is not strongly-typed. Be sure to cast it to what you expect before using it.
 
-# Create your own validators
-There aren't many validators provided by this library on purpose. Mostly because I didn't want to think of what could be useful, and would rather rely on feedback for useful validators. Feel free to give me feedback on the github repo.
+# Custom Validators
+There aren't many validators provided by this library on purpose. Mostly because I would rather rely on feedback for useful validators. Feel free to give me feedback on the github repo.
 
-I highly encourage you to understand the types enough to create your own validators. It isn't too difficult, and you should be able to base it off some of the existing ones.
+I highly encourage you to understand the types enough to create your own validators. It isn't too difficult, and you should be able to base your validator off of existing ones.
 
 Here is a breakdown of one of the validators exported by this library (expanded to make comments more readable):
 
@@ -333,16 +384,13 @@ Here is a breakdown of one of the validators exported by this library (expanded
 // always provide a header comment to explain what the validator does!
 /**
  * Checks if the string value is a valid looking email using RegEx.
- * 
- * The RegEx was taken from https://stackoverflow.com/questions/46155/how-can-i-validate-an-email-address-in-javascript, and may be updated in the future.
- * @returns Synchronous validator
  */
 export function isEmailSync<
 	// The type of the property you want to support validation for.
 	// adding | undefined | null is good practice for writing more robust code
-	// Furthermore, if you just did string here, it wouldn't work with string?
-	T extends string | undefined | null, 
-	// The type for the parent object.
+	// Furthermore, if you just did string here, it wouldn't work with string | undefined
+	T extends string | undefined | null,
+	// The type for the model parameter.
 	// Generally you don't put constraints on this.
 	P,
 	// The type for the args
@@ -355,8 +403,8 @@ export function isEmailSync<
 	// But you have to accept this generic in order to pass the type forward to not mess up outside types.
 	A
 >(
-// Specify any parameters you need here. They could be Refs, primitives, whatever!
-): SyncValidator<T, P, V, R, A> // Strongly type the type of validator you'll be returning
+// Specify any parameters you need here. This is a function that returns a validator.
+): SyncValidator<T, P, V, R, A> // Explicitly type the validator you'll be returning
 {
 	// Return a validator function
 	return (
@@ -368,11 +416,26 @@ export function isEmailSync<
 		// In this case, we're checking the value of the property against an email regex.
 		return {
 			isValid: params.value ? RegExp(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/).test(params.value) : false,
-			errorMessage: "Invalid email format"
+			message: "Invalid email format"
 		}
 	};
 }
 ```
 
-The type system that makes all this possible is fairly fragile. These problems may well be a limitation of TypeScript rather than of this package.
-I have encountered such problems when trying to build certain generic custom validators. Feel free to post issues you may have with the package on the git repo!
+Because every generic has a default value in `SyncValidator`, we can greatly simplify this validator definition to only what is required for constraints:
+
+```ts
+/**
+ * Validates a string is a valid looking email using RegEx.
+ */
+export function isEmailSync<T extends string | undefined | null>(): SyncValidator<T> {
+	return (params: ValidatorParams<T>) => ({
+		isValid: params.value ? RegExp(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/).test(params.value) : false,
+		message: "Invalid email format"
+	});
+}
+```
+
+This validator is effectively: `SyncValidator<string | undefined | null, unknown, unknown, unknown, unknown>`
+
+Feel free to post issues you may have with the package on the git repo! Happy validating!

package/dist/index.d.ts

@@ -1,144 +1,162 @@
-import { Ref } from 'vue';
+import { Ref, Reactive, ComputedRef } from 'vue';
 
 /** Shorthand union of the primitive types */
 type Primitive = string | number | boolean;
-/** Holds the latest results of validation for an object */
-type ValidationState<T, FValidationReturn> = T extends Array<infer U> ? ArrayValidationState<U, FValidationReturn> : T extends IndexableObject ? RecursiveValidationState<T, FValidationReturn> : T extends Primitive ? PrimitiveValidationState<FValidationReturn> : undefined;
-type RecursiveValidationState<T, FValidationReturn> = {
-    [key in keyof T]?: ValidationState<T[key], FValidationReturn>;
+/** Defines the layout of validation results. Copies the format of the object being validated. */
+type ValidationState<T, Return = any> = T extends Array<infer U> ? ArrayValidationState<U, Return> : T extends IndexableRecord ? RecursiveValidationState<T, Return> : T extends Primitive ? PrimitiveValidationState<Return> : never;
+/** Determines the validation state available to objects. */
+type RecursiveValidationState<T extends IndexableRecord, Return = any> = BaseValidationState<Return> & {
+    [key in keyof T]?: ValidationState<T[key], Return>;
 };
-/** Contains the reactive state of validation for a property. */
-type PrimitiveValidationState<FValidationReturn> = {
-    /** True if all the validators defined for this property have passed. False otherwise. */
-    isValid: boolean;
-    isValidating: boolean;
+/** Describes the Vuelidify validation state. */
+type BaseValidationState<Return = any> = {
     /**
-     * True if there are any results that failed validation.
+     * The validation state for this object.
      *
-     * Not quite the complement of {@link isValid} because !{@link isValid} can be true when no validators have been called yet.
-     * This will only ever be true when validation results have returned.
+     * Is named this way to avoid naming conflicts with existing object properties.
      */
-    isErrored: boolean;
-    /** Easy collection of the error messages from the raw validation returns */
-    errorMessages: string[];
-    results: {
-        [key: string]: BaseValidationReturn<FValidationReturn>;
+    $state?: {
+        /** True if all the validators defined have passed. False otherwise. */
+        isValid: boolean;
+        isValidating: boolean;
+        /**
+         * True if there are any results that failed validation.
+         *
+         * Not always equal to `!isValid` because `!isValid` can be true when validators haven't been invoked.
+         */
+        isErrored: boolean;
+        /** Collection of the error messages from validators */
+        errorMessages: string[];
+        /**
+         * An indexable object of the validators that returned with names.
+         *
+         * Useful for validators which return data you want to use.
+         */
+        results: {
+            [key: string]: BaseValidationReturn<Return> | undefined;
+        };
+        resultsArray: BaseValidationReturn<Return>[];
     };
-    resultsArray: BaseValidationReturn<FValidationReturn>[];
 };
-type ArrayValidationState<U, FValidationReturn> = PrimitiveValidationState<FValidationReturn> & {
+/** Defines the validation state for a primitive value. */
+type PrimitiveValidationState<Return = any> = BaseValidationState<Return>;
+/** Defines the validation state for an array. */
+type ArrayValidationState<U, Return = any> = BaseValidationState<Return> & {
     /**
      * Contains the validation state for each element in the array.
      *
      * Maps 1:1 to the array which was validated.
      */
-    arrayState: ValidationState<U, FValidationReturn>[];
-};
-type RecursiveValidation<T extends IndexableObject, KParent, ValidationArgs, FValidationReturn, ArrParent, NLevel extends number> = {
-    [key in keyof Partial<T>]: Validation<T[key], ValidationArgs, FValidationReturn, KParent, ArrParent, NLevel>;
+    $arrayState: ValidationState<U, Return>[];
 };
-type PrimitiveValidation<T extends Primitive | undefined | null, KParent, Args, FValidationReturn, ArrParent> = PrimitiveValidatorTypes<T, KParent, Args, FValidationReturn, ArrParent>;
-type IndexableObject = {
-    [key: string]: any;
+/** Defines validation rules for records. */
+type RecursiveValidation<T, KModel, ValidationArgs, Return, Ancestors, NLevel extends number> = ObjectValidationTypes<T, KModel, ValidationArgs, Return, Ancestors> & {
+    [key in keyof Partial<T>]: Validation<T[key], ValidationArgs, Return, KModel, Ancestors, NLevel>;
 };
-/** Separates the reactive and lazy validators of a primitive property. */
-type PrimitiveValidatorTypes<T, KParent, Args, FValidationReturn, ArrParent> = {
-    /** The validators for this property that are invoked whenever the form is changed. */
-    $reactive?: Validator<T, KParent, Args, FValidationReturn, ArrParent>[];
-    /** The validators for this property that are invoked only after {@link validate()} is invoked. */
-    $lazy?: Validator<T, KParent, Args, FValidationReturn, ArrParent>[];
+/** Defines the validation rules for records */
+type ObjectValidationTypes<T = unknown, KModel = unknown, Args = unknown, Return = any, Ancestors = unknown> = BaseValidation<T, KModel, Args, Return, Ancestors>;
+type IndexableRecord = Record<string, unknown>;
+/** Defines the validation rules for all supported objects. */
+type BaseValidation<T = unknown, KModel = unknown, Args = unknown, Return = any, Ancestors = unknown> = {
+    /** Validators invoked whenever the model is changed. */
+    $reactive?: Validator<T, KModel, Args, Return, Ancestors>[];
+    /** Validators invoked only after {@link UseValidationReturn.validate | validate()} is invoked. */
+    $lazy?: Validator<T, KModel, Args, Return, Ancestors>[];
 };
-type ArrayValidatorTypes<U, T extends Array<U>, KParent, Args, FValidationReturn, ArrParent, NLevel extends number> = {
+/** Defines the validation rules for an array. */
+type ArrayValidation<U, T = U[], KModel = unknown, Args = unknown, Return = any, Ancestors = unknown, NLevel extends number = number> = BaseValidation<T, KModel, Args, Return, Ancestors> & {
     /**
-     * Can only be used with object arrays. Not string, number, or boolean (primitive) arrays.
-     *
-     * Defines the validation that should be performed on each element of the array.
+     * Defines the validation rules for each element of an array.
      *
-     * Element validation requires much more logic, which may introduce performance problems for large arrays.
+     * Works best with arrays of objects; see documentation for details.
      */
-    $each?: Validation<U, Args, FValidationReturn, KParent, ArrParent extends undefined ? Array<any> & {
-        [key in NLevel]: U;
-    } : ArrParent & {
-        [key in NLevel]: U;
+    $each?: Validation<U, Args, Return, KModel, Ancestors extends undefined ? {
+        [key in NLevel]: ArrayAncestor<U, T>;
+    } : Ancestors & {
+        [key in NLevel]: ArrayAncestor<U, T>;
     }, Increment<NLevel>>;
-    /** The validators for the array that are invoked whenever the form is changed. */
-    $reactive?: Validator<T, KParent, Args, FValidationReturn, ArrParent>[];
-    /** The validators for the array that are invoked only when {@link validate()} is called. */
-    $lazy?: Validator<T, KParent, Args, FValidationReturn, ArrParent>[];
 };
+type ArrayAncestor<U = unknown, // the type of T's elements
+T = unknown> = Readonly<{
+    /** The index this ancestor is at in `array` */
+    index: number;
+    /** The array which contains the ancestor. Useful for referencing this ancestor's siblings. */
+    array: T;
+    /** An object which contains the value you are validating. */
+    ancestor: U;
+}>;
 /** A synchronous or asynchronous validator. */
-type Validator<T, KParent, Args, FValidationReturn, ArrParent> = (SyncValidator<T, KParent, Args, FValidationReturn, ArrParent> | AsyncValidator<T, KParent, Args, FValidationReturn, ArrParent>);
-type ValidatorTypes<T, KParent, Args, FValidationReturn, ArrParent, NLevel extends number> = T extends Array<infer U> ? ArrayValidatorTypes<U, T, KParent, Args, FValidationReturn, ArrParent, NLevel> : PrimitiveValidatorTypes<T, KParent, Args, FValidationReturn, ArrParent>;
-type BaseValidator<T, Parent, Args, Return, ArrParent> = (input: ValidatorParams<T, Parent, Args, ArrParent>) => Return;
-type SyncValidator<T, Parent, Args, Return, ArrParent> = BaseValidator<T, Parent, Args, BaseValidationReturn<Return> | Array<Validator<T, Parent, Args, Return, ArrParent>> | undefined, ArrParent>;
-type AsyncValidator<T, Parent, Args, Return, ArrParent> = BaseValidator<T, Parent, Args, Promise<BaseValidationReturn<Return> | Array<Validator<T, Parent, Args, Return, ArrParent>> | undefined>, ArrParent>;
-type BaseValidationReturn<F = any> = {
+type Validator<T = unknown, KModel = unknown, Args = unknown, Return = any, Ancestors = unknown> = SyncValidator<T, KModel, Args, Return, Ancestors> | AsyncValidator<T, KModel, Args, Return, Ancestors>;
+/** Defines a validator function */
+type BaseValidator<T, Parent, Args, Return, Ancestors> = (input: ValidatorParams<T, Parent, Args, Ancestors>) => Return;
+/** Defines a validator which always runs synchronously */
+type SyncValidator<T = unknown, Parent = unknown, Args = unknown, Return = any, Ancestors = unknown> = BaseValidator<T, Parent, Args, BaseValidationReturn<Return> | Array<Validator<T, Parent, Args, Return, Ancestors>> | undefined, Ancestors>;
+/** Defines a validator which returns a promise */
+type AsyncValidator<T = unknown, Parent = unknown, Args = unknown, Return = any, Ancestors = unknown> = BaseValidator<T, Parent, Args, Promise<BaseValidationReturn<Return> | Array<Validator<T, Parent, Args, Return, Ancestors>> | undefined>, Ancestors>;
+/** Defines the return value of validators */
+type BaseValidationReturn<F = unknown> = {
     /**
-     * Assign this validator's result a name.
-     * The result will then be added to a map using the name as the key
-     * so you can easily access the result.
+     * The validation result's name.
+     * The result will be added to a record using the name as the key
      *
-     * Note, the map entry will not exist until this validator has been run at least once, so account for undefined.
+     * Note, the entry will not exist until this validator has been ran once, so account for undefined.
      */
     name?: string;
     /**
      * The unique identifier for this validation result.
      *
-     * Assigned and used internally, but can be used as your element's ID or key attribute.
+     * Assigned and used internally, but can be used as an element's ID or key.
      */
     id?: string;
-    /** Used to determine if validation was successful or not. */
+    /** Determines if this validator passed. */
     isValid: boolean;
-    /** The message or messages to display if isValid is false. */
-    errorMessage?: string;
+    /** The error message for this validator. */
+    message?: string;
     /**
-     * Return a custom object from this validator.
+     * Return any extra data you want from this validator.
      *
-     * Should be used for more sophisticated return types than a boolean.
-     *
-     * i.e. password strength, severity levels, functions, etc.
+     * Meant for more sophisticated validation which returns data instead of just an error message (e.g. password strength, severity levels, or arrays).
      */
     custom?: F;
 };
-type ArrayValidationReturn<U, FValidationReturn> = BaseValidationReturn<FValidationReturn> & {
-    /** The raw list of results from validating every object in the array. */
-    arrayResults?: ValidationState<U, FValidationReturn>[];
-};
-type Validation<T, Args = undefined, FValidationReturn = undefined, KParent = T, ArrParent = undefined, NLevel extends number = 0> = T extends Array<infer U> ? ArrayValidatorTypes<U, T, KParent, Args, FValidationReturn, ArrParent, NLevel> : T extends IndexableObject ? RecursiveValidation<T, KParent, Args, FValidationReturn, ArrParent, NLevel> : T extends boolean ? PrimitiveValidation<boolean | undefined | null, KParent | undefined | null, Args, FValidationReturn, ArrParent> : T extends Primitive ? PrimitiveValidation<T | undefined | null, KParent | undefined | null, Args, FValidationReturn, ArrParent> : undefined;
-type ValidationConfig<T, Args, FValidationReturn> = {
-    /**
-     * If the object you provided is not in a good state (i.e. it must be loaded in asynchronously first),
-     * call the {@link setup()} method returned by this composable after it has loaded.
-     *
-     * Setting up validation on an incomplete object will mean that the properties of the object
-     * can not be linked to the validation configured, thus causing problems.
-     */
-    objectToValidate: Ref<T | undefined | null>;
-    validation: Validation<T, Args, FValidationReturn, T>;
+/**
+ * The entry point for validation with Vuelidify.
+ *
+ * Defines the validation rules for all the supported object types.
+ */
+type Validation<T, Args = unknown, Return = any, KModel = T, Ancestors = unknown, NLevel extends number = 0> = [
+    NonNullable<T>
+] extends [Array<infer U>] ? ArrayValidation<U, T, KModel, Args, Return, Ancestors, NLevel> : [NonNullable<T>] extends [IndexableRecord] ? RecursiveValidation<T, KModel, Args, Return, Ancestors, NLevel> : [NonNullable<T>] extends [Primitive] ? BaseValidation<T, KModel, Args, Return, Ancestors> : never;
+/** Defines the configuration for the {@link useValidation | useValidation() } composable */
+type ValidationConfig<T = unknown, Args = unknown, Return = any> = {
+    /** The object to validate */
+    model: Ref<T>;
+    /** Configures the validation on the model. */
+    validation: Validation<T, Args, Return, T>;
     /**
-     * False - reactive validation will always be active.
+     * Controls when reactive validation is triggered.
      *
-     * True - reactive validation will start after the first invocation of {@link validate()}.
+     * - `false`: Reactive validation is always active.
+     * - `true`: Reactive validation starts after the first invocation of {@link validate()}.
      *
-     * Defaults to true.
+     * Defaults to `true`.
      */
     delayReactiveValidation?: boolean;
     /**
-     * Provide an object, ref, or function that will be passed to each validator.
-     * Particularly useful when defining validation in separate files and you want to use variables outside of the object being validated.
+     * Provide anything you want your validators to have access to.
+     *
+     * Particularly useful when defining validation in separate files and you want to reference local variables.
      */
     args?: Args;
 };
-/** Describes the parameter passed into validator functions */
-type ValidatorParams<T, KParent, Args, ArrParent> = {
+/** Defines the parameters passed into every validator */
+type ValidatorParams<T = unknown, KModel = unknown, Args = unknown, Ancestors = unknown> = {
     /** The current value of the property */
     value: T;
     /** The entire object that was passed into the useValidation() composable to be validated. */
-    parent: KParent;
-} & (Args extends undefined ? unknown : {
+    model: KModel;
     /** The args passed in to the useValidation() composable configuration. */
     args: Args;
-}) & (ArrParent extends undefined ? unknown : {
     /**
      * An ordered list of objects that were traversed through while navigating to this validator.
      *
@@ -146,9 +164,9 @@ type ValidatorParams<T, KParent, Args, ArrParent> = {
      *
      * Useful for inter-property dependence when validating arrays of complex objects.
      */
-    arrayParents: ArrParent;
-});
-/** Type that increments a provided integer (0-19). */
+    arrayAncestors: Ancestors;
+};
+/** Increments a provided integer. Only works for 0 through 19, inclusive. */
 type Increment<N extends number> = [
     1,
     2,
@@ -174,10 +192,18 @@ type Increment<N extends number> = [
 ][N];
 
 /**
- * Returns a function that will only execute the provided promise returning function
- * with the most recently specified params only if a previously created promise does not exist.
+ * Returns a function that will execute the provided function
+ * with the latest params only if a previously created promise does not exist.
+ * ```ts
+ * async function test(): Promise<boolean> {}
+ * // Call this constant instead of the function to get the buffer benefits
+ * const bufferedTest = bufferAsync<
+ * 		typeof test, // this type makes the return the same signature as test()
+ * 		Awaited<ReturnType<typeof test>> // this type makes the returned function have the same return type
+ * >(test);
+ * ```
  */
-declare function bufferAsync<F extends (...args: any) => any, K>(func: (...params: Parameters<F>) => Promise<K>): (...params: Parameters<typeof func>) => Promise<K | undefined>;
+declare function bufferAsync<F extends (...args: any[]) => any, K>(func: (...params: Parameters<F>) => K | Promise<K>): (...params: Parameters<typeof func>) => Promise<K | undefined>;
 /**
  * Guarantees delay between invocations of the given function.
  *
@@ -186,66 +212,80 @@ declare function bufferAsync<F extends (...args: any) => any, K>(func: (...param
  * Subsequent invocations during the cool down return a promise to invoke the function after the remaining delay has passed.
  *
  * Once the interval has passed, all queued promises are executed, but only the latest promise will execute the function. The others will return undefined.
+ * ```ts
+ * async function test(): Promise<boolean> {}
+ * // Call this constant instead of the function to get the throttle benefits
+ * const throttledTest = throttleQueueAsync<
+ * 		typeof test, // this type makes the return the same signature as test()
+ * 		Awaited<ReturnType<typeof test>> // this type makes the returned function have the same return type
+ * >(test);
+ * ```
  * @param func the function to throttle
  * @param delay milliseconds required between invocations of the function.
  */
-declare function throttleQueueAsync<F extends (...args: any) => any, K>(func: (...params: Parameters<F>) => K | Promise<K>, delay: number): (...params: Parameters<typeof func>) => Promise<K | undefined>;
+declare function throttleQueueAsync<F extends (...args: any[]) => any, K>(func: (...params: Parameters<F>) => K | Promise<K>, delay: number): (...params: Parameters<typeof func>) => Promise<K | undefined>;
 
 /**
- * Makes sure the object is not undefined and the trim length is greater than 0.
- * @param value
- * @returns Synchronous validator
+ * Validates the object is not loosely undefined.
  */
-declare function required<T, P, V, R, A>(): SyncValidator<T, P, V, R, A>;
+declare function required(): SyncValidator;
 /**
- * Makes sure the string or number to validate has a length >= to the provided length.
+ * Validates a string or number has a length >= to the provided length. Undefined and null are 0 length.
  * @param minLength
- * @returns Synchronous validator
  */
-declare function minLength<T extends string | undefined | null, P, V, R, A>(minLength: number): SyncValidator<T, P, V, R, A>;
+declare function minLength<T extends string | number | undefined | null>(minLength: number): SyncValidator<T>;
 /**
- * Makes sure the string or number to validate is less than the provided length. Undefined strings are treated as 0 length.
- * @param maxLength
- * @return Synchronous validator
+ * Validates a string or number's length. Undefined and null are 0 length.
+ * @param maxLength the maximum length of the string or number
  */
-declare function maxLength<T extends string | number | undefined | null, P, V, R, A>(maxLength: number): SyncValidator<T, P, V, R, A>;
+declare function maxLength<T extends string | number | undefined | null>(maxLength: number): SyncValidator<T>;
 /**
- * Makes sure the number to validate is not undefined and is at least the provided value.
- * @param minNumber
- * @returns Synchronous validator
+ * Validates a number is defined and is at least some value.
+ * @param minNumber the minimum number the value can be
  */
-declare function minNumber<T extends number | undefined | null, P, V, R, A>(minNumber: number): SyncValidator<T, P, V, R, A>;
+declare function minNumber<T extends number | undefined | null>(minNumber: number): SyncValidator<T>;
 /**
- * Makes sure the number to validate is not undefined and is at most the provided value.
- * @param maxNumber
- * @returns Synchronous validator
+ * Validates a number is defined and is at most some value.
+ * @param maxNumber the maximum number the value can be
  */
-declare function maxNumber<T extends number | undefined | null, P, V, R, A>(maxNumber: number): SyncValidator<T, P, V, R, A>;
+declare function maxNumber<T extends number | undefined | null>(maxNumber: number): SyncValidator<T>;
 /**
- * Checks if the value of this property strictly equals the value returned by the provided getter.
+ * Validate the provided predicate function.
+ * @param fn predicate that returns true if the value is valid.
+ * @param errorMessage the message to display when the values are not equal.
  */
-declare function mustEqual<T, P, V, R, A>(getter: (params: ValidatorParams<T, P, V, A>) => T, errorMessage: string): SyncValidator<T, P, V, R, A>;
+declare function must<T, K, V, R, A>(fn: (params: ValidatorParams<T, K, V, A>) => boolean, errorMessage: string): SyncValidator<T, K, V, R, A>;
 /**
- * Checks if the string value is a valid looking email using RegEx.
+ * Validates a string is a valid looking email using RegEx.
  *
  * The RegEx was taken from https://stackoverflow.com/questions/46155/how-can-i-validate-an-email-address-in-javascript, and may be updated in the future.
- * @returns Synchronous validator
- */
-declare function isEmailSync<T extends string | undefined | null, P, V, R, A>(): SyncValidator<T, P, V, R, A>;
+s */
+declare function isEmailSync<T extends string | undefined | null>(): SyncValidator<T>;
 
+type UseValidationReturn<T = unknown, Return = any> = {
+    hasValidated: Ref<boolean>;
+    validate: () => Promise<boolean>;
+    isValidating: ComputedRef<boolean>;
+    /** Stores the results of validation */
+    state: ComputedRef<ValidationState<T, Return>>;
+    /** True only if all validators passed. */
+    isValid: ComputedRef<boolean>;
+    /** True if any of the validators failed. */
+    isErrored: ComputedRef<boolean>;
+    /** Sets the internal reference object for determining {@link isDirty} */
+    setReference: (reference: T) => void;
+    /**
+     * Reactively determines if the object being validated has changed from the reference state.
+     *
+     * The reference state can be changed using {@link setReference()}.
+     */
+    isDirty: ComputedRef<boolean>;
+};
 /**
- * A simple and lightweight Vue3 model based validation library with strong type support.
+ * The starting point for validation with Vuelidify.
  *
  * @author Daniel Walbolt
  */
-declare function useValidation<T, Args = undefined, FValidationReturn = unknown>(validationConfig: ValidationConfig<T, Args | undefined, FValidationReturn>): {
-    hasValidated: boolean;
-    validate: () => Promise<boolean>;
-    isValidating: boolean;
-    propertyState: ValidationState<T, FValidationReturn>;
-    isValid: boolean;
-    setReference: (reference: T) => void;
-    isDirty: boolean;
-};
+declare function useValidation<T, Args = unknown, Return = any>(validationConfig: ValidationConfig<T, Args, Return>): Reactive<UseValidationReturn<T, Return>>;
 
-export { ArrayValidationReturn, ArrayValidationState, ArrayValidatorTypes, AsyncValidator, BaseValidationReturn, BaseValidator, Primitive, PrimitiveValidation, PrimitiveValidationState, PrimitiveValidatorTypes, RecursiveValidation, RecursiveValidationState, SyncValidator, Validation, ValidationConfig, ValidationState, Validator, ValidatorParams, ValidatorTypes, bufferAsync, isEmailSync, maxLength, maxNumber, minLength, minNumber, mustEqual, required, throttleQueueAsync, useValidation };
+export { ArrayAncestor, ArrayValidation, ArrayValidationState, AsyncValidator, BaseValidation, BaseValidationReturn, BaseValidationState, BaseValidator, ObjectValidationTypes, Primitive, PrimitiveValidationState, RecursiveValidation, RecursiveValidationState, SyncValidator, Validation, ValidationConfig, ValidationState, Validator, ValidatorParams, bufferAsync, isEmailSync, maxLength, maxNumber, minLength, minNumber, must, required, throttleQueueAsync, useValidation };

package/dist/index.mjs

@@ -1 +1 @@
-var g=(a,e,t)=>new Promise((i,s)=>{var r=n=>{try{l(t.next(n))}catch(V){s(V)}},d=n=>{try{l(t.throw(n))}catch(V){s(V)}},l=n=>n.done?i(n.value):Promise.resolve(n.value).then(r,d);l((t=t.apply(a,e)).next())});function O(a){let e=0,t;return(...i)=>{var r;let s=++e;return t=(r=t==null?void 0:t.then(()=>{if(e===s)return t=a(...i).then(d=>(t=void 0,d)),t}))!=null?r:a(...i).then(d=>(t=void 0,d)),t}}function I(a,e){let t=0,i;return(...s)=>new Promise(r=>{let d=++t,l=new Date().getTime();i!=null||(i=l-e);let n=l-i-e;n<0?new Promise(V=>setTimeout(V,-1*n)).then(()=>{i=new Date().getTime(),d===t&&r(a(...s)),r(void 0)}):(i=l,r(a(...s)))})}function j(a,e=t=>t){return a.reduce((t,i)=>{if(i!==void 0){let s=e(i);s!==void 0&&t.push(s)}return t},[])}function aa(){return a=>({isValid:a.value!==void 0&&String(a.value).trim().length>0,errorMessage:"This field is required"})}function ea(a){return e=>{var i;let t=String((i=e.value)!=null?i:"");return{isValid:t.length>=a,errorMessage:`Too short (${t.length} / ${a})`}}}function ta(a){return e=>{var i;let t=String((i=e.value)!=null?i:"");return{isValid:t.length<=a,errorMessage:`Too long (${t.length} / ${a})`}}}function ia(a){return e=>({isValid:e.value!==void 0&&e.value>=a,errorMessage:`The minimum value is ${a}`})}function na(a){return e=>({isValid:e.value!==void 0&&e.value<=a,errorMessage:`The maximum value is ${a}`})}function ra(a,e){return t=>({isValid:t.value===a(t),errorMessage:e})}function oa(){return a=>({isValid:a.value?RegExp(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/).test(a.value):!1,errorMessage:"Invalid email format"})}import{ref as B,computed as x,watch as W,reactive as q}from"vue";import{computed as Q}from"vue";import{computed as A,reactive as T,ref as b,toValue as J}from"vue";function M(){return`${Date.now()}-${Math.floor(Math.random()*1e3)}`}function k(a,e){let t,i;if(z(e)){let l=$(a,e);t=T(l.validationState),i=[l]}else{let l=L(a,e);t=T(l.state),i=l.validationConfigs}return{propertyState:t,validationConfigs:i}}function S(a,e,t){let i=[],s=()=>`${e?"reactive":"lazy"}-${M()}`;t!=null&&(s=r=>`${t}-${r}`);for(let[r,d]of a.entries())i.push({validatorId:s(r),validator:d,optimized:!1,isReactive:e,previouslyReturnedValidators:!1,previouslySpawnedValidators:{},spawnedValidators:{}});return i}function $(a,e,t=[]){var V,f,u,o;let i=T({isValid:A(()=>{var P,y;let c=(P=n.isLazyValid.value)!=null?P:!1,m=(y=n.isReactiveValid.value)!=null?y:!1;return c&&m}),isValidating:A(()=>n.isValidatingReactive.value||n.isValidatingLazy.value),isErrored:A(()=>i.resultsArray.some(c=>c.isValid===!1)),errorMessages:A(()=>j(i.resultsArray,c=>c.isValid?void 0:c.errorMessage)),results:A(()=>n.namedValidationResults.value),resultsArray:A(()=>n.validationResults.value),arrayState:A(()=>{if(Array.isArray(a.value)===!1||n.elementValidation===void 0)return[];console.time("Array state");let c=a.value,m=n.elementValidation,P=n.arrayConfigMap,y=[],p={},v,w=[];for(let R=0;R<c.length;R++){if(c[R]!==void 0&&typeof c[R]=="object"?(c[R].$ffId===void 0&&Object.defineProperty(c[R],"$ffId",{value:`${n.id}-${n.elementId++}`,writable:!1,configurable:!1,enumerable:!1}),v=c[R].$ffId):c[R]!==void 0&&(v=R),w.push(v),P[v]){y.push(P[v].validationState),p[v]=P[v];continue}if(z(m)){let G=A(()=>c[R]),K=$(G,m,n.arrayParents);P[v]={validationConfigs:[K],validationState:K.validationState}}else{let G=c[R],K=L(G,m,n.arrayParents.concat(G));P[v]={validationConfigs:K.validationConfigs,validationState:K.state}}y.push(P[v].validationState),p[v]=P[v]}return n.arrayConfigMap=p,console.timeEnd("Array state"),y})}),s=!(((f=(V=e.$lazy)==null?void 0:V.length)!=null?f:-1)>0),r=!(((o=(u=e.$reactive)==null?void 0:u.length)!=null?o:-1)>0),d=e.$reactive?S(e.$reactive,!0):[],l=e.$lazy?S(e.$lazy,!1):[],n={id:M(),validationIterationId:0,isReactiveValid:b(r),isValidatingReactive:b(!1),reactiveProcessedValidators:d,isLazyValid:b(s),isValidatingLazy:b(!1),lazyProcessedValidators:l,property:a,validation:e,validationState:i,validationResults:b([]),namedValidationResults:b({}),arrayConfigMap:{},elementId:0,elementValidation:e.$each,arrayParents:T(t)};return n}function L(a,e,t=[]){let i=[],s={};e!==void 0&&r(a,e);function r(d,l){for(let n in l){let V=A(()=>J(d)[n]);if(z(l[n])){let f=l[n],u=$(V,f,t);i.push(u),s[n]=u.validationState}else{let f={},u=l[n];s[n]=f,r(V,u)}}}return{validationConfigs:i,state:s}}function z(a){return(a==null?void 0:a.$reactive)!==void 0||(a==null?void 0:a.$lazy)!==void 0||(a==null?void 0:a.$each)!==void 0}var h=250;function D(a,e,t,i,s){return g(this,null,function*(){let r=!0,d=(V,f,u)=>{if(i!==V.validationIterationId)return;u.isValid===!1&&(r=!1),u.id=f.validatorId;let o=V.validationResults.value.find(c=>c.id===u.id);o!==void 0?(Object.assign(o,u),u.name!==void 0&&V.namedValidationResults[u.name]!==void 0&&Object.assign(V.namedValidationResults.value[u.name],u)):(V.validationResults.value.push(u),u.name!==void 0&&(V.namedValidationResults.value[u.name]=u))},{asyncPromises:l,validatorsWhichPreviouslyReturnedValidators:n}=N(a,e,t,i,s,d,!0,1);if(yield Promise.all(l),i===a.validationIterationId){for(let V of n)for(let f of Object.keys(V.previouslySpawnedValidators))if(V.spawnedValidators[f]==null){let u=a.validationResults.value.findIndex(o=>o.id===f);u!==-1&&a.validationResults.value.splice(u)}}return r})}function N(a,e,t,i,s,r,d,l){let n=a.property.value,V=[],f=[],u=[];for(let o of s){let c=!1;o.previouslyReturnedValidators&&(o.previouslySpawnedValidators=o.spawnedValidators,o.spawnedValidators={},c=!0),o.previouslyReturnedValidators=!1;let m;if(o.computedValidator===void 0){let P={value:n,parent:e,args:t,arrayParents:a.arrayParents};m=o.validator(P)}else m=o.computedValidator.value;if(m instanceof Promise){let P=Date.now();V.push(m.then(y=>g(this,null,function*(){if(y===void 0){c&&u.push(o);return}let p=Date.now()-P;if(d&&p>h&&o.optimized===!1&&(o.optimized=!0,p>h&&p<2*h?o.validator=I(o.validator,h):o.validator=O(o.validator)),Array.isArray(y)){let{asyncPromises:v,syncResults:w}=C(a,e,t,i,r,o,y,l);f.push(...w),yield Promise.all(v);return}else c&&u.push(o);r(a,o,y)})))}else if(Array.isArray(m)){let{asyncPromises:P,syncResults:y}=C(a,e,t,i,r,o,m,l);V.push(...P),f.push(...y)}else if(c&&u.push(o),m!==void 0){if(d&&o.optimized===!1){let P=o.validator;o.computedValidator=Q(()=>{let y={value:a.property.value,parent:e,args:t,arrayParents:a.arrayParents};return P(y)}),o.optimized=!0,o.validator=()=>o.computedValidator.value}f.push(m),r(a,o,m)}}return{asyncPromises:V,syncResults:f,validatorsWhichPreviouslyReturnedValidators:u}}function C(a,e,t,i,s,r,d,l){let n=S(d,r.isReactive,r.validatorId),V=N(a,e,t,i,n,s,!1,++l),f={};for(let u of n)f[u.validatorId]=u;return r.spawnedValidators=f,r.previouslyReturnedValidators=!0,V}function U(a,e,t,i){return g(this,null,function*(){a.isValidatingReactive.value=!0;let s=yield D(a,e,t,i,a.reactiveProcessedValidators);return i===a.validationIterationId&&(a.isReactiveValid.value=s,a.isValidatingReactive.value=!1),a.isReactiveValid.value})}function Z(a,e,t,i){return g(this,null,function*(){a.isValidatingLazy.value=!0;let s=a.lazyProcessedValidators,r=yield D(a,e,t,i,s);return i===a.validationIterationId&&(a.isLazyValid.value=r,a.isValidatingLazy.value=!1),a.isLazyValid.value})}function F(a,e,t,i,s){return g(this,null,function*(){let r=[];for(let d of a){let l=++d.validationIterationId;if(i&&d.validation.$reactive!==void 0&&r.push(yield U(d,e.value,t,l)),s&&d.validation.$lazy!==void 0&&r.push(yield Z(d,e.value,t,l)),d.elementValidation!==void 0){let n=[];for(let V in d.arrayConfigMap)n.push(...d.arrayConfigMap[V].validationConfigs);r.push(yield F(n,e,t,i,s))}}return Promise.all(r).then(d=>d.every(l=>l===!0))})}function H(a){var P;(P=a.delayReactiveValidation)!=null||(a.delayReactiveValidation=!0);let{objectToValidate:e,validation:t,delayReactiveValidation:i,args:s}=a,r=B(!1),d=x(()=>n.some(y=>y.validationState.isValidating)),l=x(()=>n.every(p=>p.isReactiveValid.value&&p.isLazyValid.value)),n=[],V=q({}),f=B(JSON.stringify(a.objectToValidate.value)),u=x(()=>f.value!==JSON.stringify(a.objectToValidate.value)),o=k(e,t);V=o.propertyState,n=o.validationConfigs,W(a.objectToValidate,()=>{i?r.value===!0&&F(n,e,s,!0,!1):F(n,e,s,!0,!1)},{deep:!0});function c(){return g(this,null,function*(){let y=yield F(n,e,s,!0,!0);return r.value=!0,y})}function m(y){f.value=JSON.stringify(y)}return q({hasValidated:r,validate:c,isValidating:d,propertyState:x(()=>V),isValid:l,setReference:m,isDirty:u})}export{O as bufferAsync,oa as isEmailSync,ta as maxLength,na as maxNumber,ea as minLength,ia as minNumber,ra as mustEqual,aa as required,I as throttleQueueAsync,H as useValidation};
+function x(e){let t=0,i;return(...r)=>{let o=++t;return i=(i==null?void 0:i.then(()=>{if(t===o)return i=new Promise(n=>n(e(...r))).then(n=>(i=void 0,n)),i}))??new Promise(n=>n(e(...r))).then(n=>(i=void 0,n)),i}}function S(e,t){let i=0,r;return(...o)=>new Promise(n=>{let l=++i,f=new Date().getTime();r??(r=f-t);let d=f-r-t;d<0?new Promise(u=>setTimeout(u,-1*d)).then(()=>{r=new Date().getTime(),l===i&&n(e(...o)),n(void 0)}):(r=f,n(e(...o)))})}function I(e,t=i=>i){return e.reduce((i,r)=>{if(r!==void 0){let o=t(r);o!==void 0&&i.push(o)}return i},[])}function X(){return e=>({isValid:e.value!=null,message:"This field is required"})}function Y(e){return t=>{let i=String(t.value??"");return{isValid:i.length>=e,message:`Too short (${i.length} / ${e})`}}}function _(e){return t=>{let i=String(t.value??"");return{isValid:i.length<=e,message:`Too long (${i.length} / ${e})`}}}function ee(e){return t=>({isValid:t.value!=null&&t.value>=e,message:`The minimum value is ${e}`})}function ae(e){return t=>({isValid:t.value!=null&&t.value<=e,message:`The maximum value is ${e}`})}function te(e,t){return i=>({isValid:e(i),message:t})}function ie(){return e=>({isValid:e.value?RegExp(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/).test(e.value):!1,message:"Invalid email format"})}import{computed as b,reactive as q,ref as N,watch as Z}from"vue";import{computed as U,toValue as G}from"vue";import{computed as R,reactive as O,ref as P,toValue as M}from"vue";function L(){return`${Date.now()}-${Math.floor(Math.random()*1e3)}`}function C(e,t){return D(e,t)}function A(e,t,i){let r=[],o=()=>`${t?"reactive":"lazy"}-${L()}`;i!=null&&(o=n=>`${i}-${n}`);for(let[n,l]of e.entries())r.push({validatorId:o(n),validator:l,optimized:!1,isReactive:t,previouslyReturnedValidators:!1,previouslySpawnedValidators:{},spawnedValidators:{}});return r}function K(e,t,i=[]){var u;let r=O({$state:{isValid:R(()=>{let s=d.isLazyValid.value??!1,c=d.isReactiveValid.value??!1;return s&&c}),isValidating:R(()=>d.isValidatingReactive.value||d.isValidatingLazy.value),isErrored:R(()=>{var s;return((s=r.$state)==null?void 0:s.resultsArray.some(c=>c.isValid===!1))??!1}),errorMessages:R(()=>{var s;return I(((s=r.$state)==null?void 0:s.resultsArray)??[],c=>c.isValid?void 0:c.message)}),results:R(()=>d.namedValidationResults.value),resultsArray:R(()=>d.validationResults.value)},$arrayState:R(()=>{if(Array.isArray(e.value)===!1||d.elementValidation===void 0)return[];let s=e.value,c=d.elementValidation,a=d.arrayConfigMap,v=[],m={},y,V=[];for(let p=0;p<s.length;p++){let T=s[p]!==void 0&&typeof s[p]=="object";if(T?(s[p].$ffId===void 0&&Object.defineProperty(s[p],"$ffId",{value:`${d.id}-${d.elementId++}`,writable:!1,configurable:!1,enumerable:!1}),y=s[p].$ffId):s[p]!==void 0&&(y=p),V.push(y),a[y]){v.push(a[y].validationState),m[y]=a[y];continue}let h=R(()=>s[p]),z=[...d.arrayAncestors];T&&z.push({ancestor:h,array:s,index:p});let k=D(h,c,z);a[y]={validationConfigs:k.validationConfigs,validationState:k.state},v.push(a[y].validationState),m[y]=a[y]}return d.arrayConfigMap=m,v})}),o=!0,n=!0,l=[],f=[];t.$reactive&&t.$reactive.length>0&&(n=!1,l=A(t.$reactive,!0)),t.$lazy&&((u=t.$lazy)==null?void 0:u.length)>0&&(o=!1,f=A(t.$lazy,!1));let d={id:L(),reactiveIterationId:0,lazyIterationId:0,isReactiveValid:P(n),isValidatingReactive:P(!1),reactiveProcessedValidators:l,isLazyValid:P(o),isValidatingLazy:P(!1),lazyProcessedValidators:f,target:e,validation:t,validationState:r,validationResults:P([]),namedValidationResults:P({}),arrayConfigMap:{},elementId:0,elementValidation:t.$each,arrayAncestors:O(i)};return d}function D(e,t,i=[]){let r=[],o={};if(j(t)){let l=R(()=>M(e)),f=K(l,t,i);r.push(f),o=f.validationState}t!=null&&n(e,t,o);function n(l,f,d){if($(f)!==!1)for(let u in f){if(u==="$reactive"||u==="$lazy"||u==="$each")continue;let s=R(()=>{let a=M(l);return $(a)?a[u]:(console.error(`Vuelidify Error: validation could not be setup correctly on ${a} because ${l} is not enumerable.`),null)}),c=f[u];if(j(c)){let a=K(s,c,i);r.push(a),d[u]=a.validationState}if($(c)){let a=d[u]??{};d[u]=a,n(s,c,a)}}}return{validationConfigs:r,state:o}}function j(e){return Array.isArray(e==null?void 0:e.$reactive)||Array.isArray(e==null?void 0:e.$lazy)||(e==null?void 0:e.$each)!==void 0}function $(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}var w=250;async function B(e,t,i,r,o,n){let l=!0,f=(s,c,a)=>{if(r!==G(o))return;a.isValid===!1&&(l=!1),a.id=c.validatorId;let v=s.validationResults.value.find(m=>m.id===a.id);v!==void 0?(Object.assign(v,a),a.name!==void 0&&s.namedValidationResults.value[a.name]!==void 0&&Object.assign(s.namedValidationResults.value[a.name],a)):(s.validationResults.value.push(a),a.name!==void 0&&(s.namedValidationResults.value[a.name]=a))},{asyncPromises:d,validatorsWhichPreviouslyReturnedValidators:u}=F(e,t,i,r,n,f,!0,1);if(await Promise.all(d),r===G(o)){for(let s of u)for(let c of Object.keys(s.previouslySpawnedValidators))if(s.spawnedValidators[c]==null){let a=e.validationResults.value.findIndex(v=>v.id===c);a!==-1&&e.validationResults.value.splice(a)}}return l}function F(e,t,i,r,o,n,l,f){let d=e.target.value,u=[],s=[],c=[];for(let a of o){let v=!1;a.previouslyReturnedValidators&&(a.previouslySpawnedValidators=a.spawnedValidators,a.spawnedValidators={},v=!0),a.previouslyReturnedValidators=!1;let m;if(a.computedValidator===void 0){let y={value:d,model:t,args:i,arrayAncestors:e.arrayAncestors};m=a.validator(y)}else m=a.computedValidator.value;if(m instanceof Promise){let y=Date.now();u.push(m.then(async V=>{if(V===void 0){v&&c.push(a);return}let p=Date.now()-y;if(l&&p>w&&a.optimized===!1&&(a.optimized=!0,p>w&&p<2*w?a.validator=S(a.validator,w):a.validator=x(a.validator)),Array.isArray(V)){let{asyncPromises:T,syncResults:h}=E(e,t,i,r,n,a,V,f);s.push(...h),await Promise.all(T);return}else v&&c.push(a);n(e,a,V)}))}else if(Array.isArray(m)){let{asyncPromises:y,syncResults:V}=E(e,t,i,r,n,a,m,f);u.push(...y),s.push(...V)}else if(v&&c.push(a),m!==void 0){if(l&&a.optimized===!1){let y=a.validator;a.computedValidator=U(()=>{let V={value:e.target.value,model:t,args:i,arrayAncestors:e.arrayAncestors};return y(V)}),a.optimized=!0,a.validator=()=>{var V;return(V=a.computedValidator)==null?void 0:V.value}}s.push(m),n(e,a,m)}}return{asyncPromises:u,syncResults:s,validatorsWhichPreviouslyReturnedValidators:c}}function E(e,t,i,r,o,n,l,f){let d=A(l,n.isReactive,n.validatorId),u=F(e,t,i,r,d,o,!1,++f),s={};for(let c of d)s[c.validatorId]=c;return n.spawnedValidators=s,n.previouslyReturnedValidators=!0,u}async function J(e,t,i,r,o){e.isValidatingReactive.value=!0;let n=await B(e,t,i,r,o,e.reactiveProcessedValidators);return r===G(o)&&(e.isReactiveValid.value=n,e.isValidatingReactive.value=!1),e.isReactiveValid.value??!1}async function Q(e,t,i,r,o){e.isValidatingLazy.value=!0;let n=await B(e,t,i,r,o,e.lazyProcessedValidators);return r===G(o)&&(e.isLazyValid.value=n,e.isValidatingLazy.value=!1),e.isLazyValid.value??!1}function g(e,t,i,r,o){let n=[];for(let l of e)if(r&&l.reactiveProcessedValidators.length>0&&n.push(J(l,t.value,i,++l.reactiveIterationId,()=>l.reactiveIterationId)),o&&l.lazyProcessedValidators.length>0&&n.push(Q(l,t.value,i,++l.lazyIterationId,()=>l.lazyIterationId)),Array.isArray(l.validationState.$arrayState)){let f=[];for(let d in l.arrayConfigMap)f.push(...l.arrayConfigMap[d].validationConfigs);n.push(g(f,t,i,r,o))}return Promise.all(n).then(l=>l.every(f=>f===!0))}function W(e){e.delayReactiveValidation??(e.delayReactiveValidation=!0);let{model:t,validation:i,delayReactiveValidation:r,args:o}=e,n=N(!1),l=b(()=>u.some(V=>V.isValidatingLazy.value||V.isValidatingReactive.value)),f=b(()=>u.some(V=>V.validationResults.value.some(p=>p.isValid===!1))),d=b(()=>u.every(p=>p.isReactiveValid.value&&p.isLazyValid.value)),u=[],s=N(JSON.stringify(e.model.value)),c=b(()=>s.value!==JSON.stringify(e.model.value)),a=C(t,i),v=a.state;u=a.validationConfigs,Z(e.model,()=>{r?n.value===!0&&g(u,t,o,!0,!1):g(u,t,o,!0,!1)},{deep:!0});async function m(){let V=await g(u,t,o,!0,!0);return n.value=!0,V}function y(V){s.value=JSON.stringify(V)}return q({hasValidated:n,validate:m,isValidating:l,state:b(()=>v),isValid:d,isErrored:f,setReference:y,isDirty:c})}export{x as bufferAsync,ie as isEmailSync,_ as maxLength,ae as maxNumber,Y as minLength,ee as minNumber,te as must,X as required,S as throttleQueueAsync,W as useValidation};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vuelidify",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "author": "Daniel Walbolt",
   "private": false,
   "main": "./dist/index.js",