vuelidify 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Daniel Walbolt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,378 @@
+# Vuelidify
+
+
+[Installation](#installation)
+[Types](#types)
+[Examples](#examples)
+---
+*A simple and lightweight Vue 3 model based validation library with strong type support.*
+
+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.
+
+**✨ Simple** because it does exactly what it needs to with no dependencies other than Vue.
+
+**🪶 Lightweight** because the .mjs is <9KB (uncompressed), and ~3KB gzipped.
+
+**📝 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.
+
+**💪 Strong types** makes setting up validation 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.
+
+---
+
+## Installation
+
+```sh
+npm i vuelidify
+```
+
+```sh
+yarn add vuelidify
+```
+
+```sh
+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.
+
+**useValidation()** is the starting point for validating your models.
+
+```ts
+<script setup lang="ts">
+	import { useValidation } from "vuelidify";
+
+	// The starting point for validation
+	const v$ = useValidation({});
+</script>
+```
+Here is a breakdown of the configuration object the composable expects.
+```ts
+{
+  objectToValidate: 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.
+  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.
+
+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.
+```ts
+{
+	// foo is a string
+	foo: {
+		$reactive?: [],
+		$lazy?: []
+	}
+	// bar is an array
+	bar: {
+		$each?: {},
+		$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.
+
+Here is the breakdown of the return of the composable
+```ts
+{
+	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, 
+	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
+	state: ValidationState<T>,
+	// Set the comparison object for determining dirty state.
+	// If your object must first load in asynchronously,
+	// use this function to set the reference once it has loaded.
+	setReference: (reference: T) => void, 
+	validate: () => Promise<boolean>
+}
+```
+Here is the breakdown of the validation state
+```ts
+{
+	// The collected error messages returned from all the validators
+	errorMessages: string[],
+	// True if any validators returned false.
+	// 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.
+	isErrored: boolean,
+	// True if the last run of lazy and reactive validators all passed.
+	isValid: boolean,
+	isValidating: boolean,
+	// A map for easily accessing named validation results.
+	// This is the one spot without type support
+	results: { [key: string]: BaseValidationReturn<F> }
+	// A 2D array of the validation results
+	resultsArray: Array<BaseValidationReturn<F>>
+}
+```
+Here is the breakdown of the return type from validators.
+```ts
+// Validators must either return a BaseValidationReturn<F> object, undefined,
+// or an array of validators which will be invoked immediately.
+{
+	// 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.
+	// 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,
+	// 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
+	custom?: F,
+}
+```
+Here is the breakdown of the parameters that are passed into validators
+```ts
+{
+	// 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
+}
+```
+
+## Examples
+#### Primitives
+```ts
+<script setup lang="ts">
+	import { ref } from 'vue';
+	import { minLength, useValidation } from "vuelidify";
+	
+	const string = ref("");
+	const v$ = useValidation({
+		objectToValidate: string,
+		validation: {
+			$reactive: [minLength(10)] // Put as many validators as you want here
+		}
+	});
+</script>
+```
+#### Simple Objects
+```ts
+<script setup lang="ts">
+	import { ref } from 'vue';
+	import { minLength, useValidation, minNumber } from "vuelidify";
+
+	const obj = ref({
+		foo: "string",
+		bar: true,
+		zaa: 1
+	});
+	const v$ = useValidation({
+		objectToValidate: obj,
+		validation: {
+			foo: {
+				// Validate foo when v$.validate is called.
+				$lazy: [minLength(10)]
+			},
+			bar: {
+				// Validate bar reactively
+				$reactive: [(params) => {
+					return {
+						isValid: params.value
+					}
+				}]
+			},
+			zaa: {
+				// Validate zaa reactively and when v$.validate is called.
+				// Notice how validation can depend on other properties in the parent.
+				$reactive: [minNumber(10)],
+				$lazy: [
+					(params) => {
+						const isBar = params.parent.bar;
+						return {
+							isValid: isBar ? params.value > 100 : true,
+							errorMessage: "Must be greater than 100 when bar is true"
+						}
+					}
+				]
+			}
+		}
+	});
+</script>
+```
+#### Arrays
+```ts
+<script setup lang="ts">
+	import { ref } from 'vue';
+	import { minLength, useValidation } from "vuelidify";
+
+	type FooBar = {
+		name: string;
+		isActive: boolean;
+	}
+
+	const array = ref<FooBar[]>([]);
+	const v$ = useValidation({
+		objectToValidate: array,
+		validation: {
+			// Validate each object in the array.
+			$each: {
+				name: {
+					// Reactively validate every name
+					$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!
+								return;
+							}
+							return [minLength(10)]
+						}
+					]
+				}
+			}
+		}
+	});
+</script>
+```
+#### Complex Objects
+Sometimes your objects will contain other objects and arrays.
+```ts
+<script setup lang="ts">
+	import { ref } from 'vue';
+	import { minLength, minNumber, useValidation } from "vuelidify";
+
+	type Person = {
+		a: Person,
+		b: Person[]
+	}
+	
+	type Person = {
+		name: string;
+		age: number;
+	}
+
+	const complexObj = ref<Person>();
+	const v$ = useValidation({
+		objectToValidate: complexObj,
+		validation: {
+			a: {
+				// Validate person a's age reactively
+				age: {
+					$reactive: [minNumber(16)]
+				}
+			},
+			b: {
+				// Validate each person in b
+				$each: {
+					// Validate age reactively and lazily
+					age: {
+						$reactive: [
+							// 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."
+								}
+							}
+						],
+						$lazy: [minNumber(15)]
+					},
+					name: {
+						$reactive: [minLength(10)]
+					}
+				}
+			}
+		}
+	});
+</script>
+```
+
+## 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.
+
+# 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.
+
+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.
+
+Here is a breakdown of one of the validators exported by this library (expanded to make comments more readable):
+
+```ts
+// 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.
+	// Generally you don't put constraints on this.
+	P,
+	// The type for the args
+	// You may want to put a constraint on this if you need access to a store, or some other external data.
+	V,
+	// The type for the custom return from the validator
+	R,
+	// The type for the arrayParents parameter.
+	// Generally you don't put constraints on this.
+	// 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
+{
+	// Return a validator function
+	return (
+		// Strongly type the expected params object to have intellisense
+		params: ValidatorParams<T, P, V, A>
+	) => {
+		// you can do whatever you want a normal validator can in here.
+		// Return undefined, an array of validators, or a validation result.
+		// 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"
+		}
+	};
+}
+```
+
+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!

package/dist/index.d.ts

@@ -0,0 +1,251 @@
+import { Ref } 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>;
+};
+/** 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;
+    /**
+     * True if there are any results that failed validation.
+     *
+     * 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.
+     */
+    isErrored: boolean;
+    /** Easy collection of the error messages from the raw validation returns */
+    errorMessages: string[];
+    results: {
+        [key: string]: BaseValidationReturn<FValidationReturn>;
+    };
+    resultsArray: BaseValidationReturn<FValidationReturn>[];
+};
+type ArrayValidationState<U, FValidationReturn> = PrimitiveValidationState<FValidationReturn> & {
+    /**
+     * 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>;
+};
+type PrimitiveValidation<T extends Primitive | undefined | null, KParent, Args, FValidationReturn, ArrParent> = PrimitiveValidatorTypes<T, KParent, Args, FValidationReturn, ArrParent>;
+type IndexableObject = {
+    [key: string]: any;
+};
+/** 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>[];
+};
+type ArrayValidatorTypes<U, T extends Array<U>, KParent, Args, FValidationReturn, ArrParent, NLevel extends number> = {
+    /**
+     * 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.
+     *
+     * Element validation requires much more logic, which may introduce performance problems for large arrays.
+     */
+    $each?: Validation<U, Args, FValidationReturn, KParent, ArrParent extends undefined ? Array<any> & {
+        [key in NLevel]: U;
+    } : ArrParent & {
+        [key in NLevel]: U;
+    }, 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>[];
+};
+/** 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> = {
+    /**
+     * 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.
+     *
+     * Note, the map entry will not exist until this validator has been run at least 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.
+     */
+    id?: string;
+    /** Used to determine if validation was successful or not. */
+    isValid: boolean;
+    /** The message or messages to display if isValid is false. */
+    errorMessage?: string;
+    /**
+     * Return a custom object from this validator.
+     *
+     * Should be used for more sophisticated return types than a boolean.
+     *
+     * i.e. password strength, severity levels, functions, etc.
+     */
+    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>;
+    /**
+     * False - reactive validation will always be active.
+     *
+     * True - reactive validation will start after the first invocation of {@link validate()}.
+     *
+     * 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.
+     */
+    args?: Args;
+};
+/** Describes the parameter passed into validator functions */
+type ValidatorParams<T, KParent, Args, ArrParent> = {
+    /** 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 : {
+    /** 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.
+     *
+     * Each nested array will add 1 entry to this list. Each entry will be strongly-typed to the element of its respective array.
+     *
+     * Useful for inter-property dependence when validating arrays of complex objects.
+     */
+    arrayParents: ArrParent;
+});
+/** Type that increments a provided integer (0-19). */
+type Increment<N extends number> = [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    ...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.
+ */
+declare function bufferAsync<F extends (...args: any) => any, K>(func: (...params: Parameters<F>) => Promise<K>): (...params: Parameters<typeof func>) => Promise<K | undefined>;
+/**
+ * Guarantees delay between invocations of the given function.
+ *
+ * Invocations of the throttled function after the given interval has passed will execute instantly.
+ *
+ * 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.
+ * @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>;
+
+/**
+ * Makes sure the object is not undefined and the trim length is greater than 0.
+ * @param value
+ * @returns Synchronous validator
+ */
+declare function required<T, P, V, R, A>(): SyncValidator<T, P, V, R, A>;
+/**
+ * Makes sure the string or number to validate has a length >= to the provided 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>;
+/**
+ * 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
+ */
+declare function maxLength<T extends string | number | undefined | null, P, V, R, A>(maxLength: number): SyncValidator<T, P, V, R, A>;
+/**
+ * Makes sure the number to validate is not undefined and is at least the provided value.
+ * @param minNumber
+ * @returns Synchronous validator
+ */
+declare function minNumber<T extends number | undefined | null, P, V, R, A>(minNumber: number): SyncValidator<T, P, V, R, A>;
+/**
+ * Makes sure the number to validate is not undefined and is at most the provided value.
+ * @param maxNumber
+ * @returns Synchronous validator
+ */
+declare function maxNumber<T extends number | undefined | null, P, V, R, A>(maxNumber: number): SyncValidator<T, P, V, R, A>;
+/**
+ * Checks if the value of this property strictly equals the value returned by the provided getter.
+ */
+declare function mustEqual<T, P, V, R, A>(getter: (params: ValidatorParams<T, P, V, A>) => T, errorMessage: string): SyncValidator<T, P, V, R, A>;
+/**
+ * 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
+ */
+declare function isEmailSync<T extends string | undefined | null, P, V, R, A>(): SyncValidator<T, P, V, R, A>;
+
+/**
+ * A simple and lightweight Vue3 model based validation library with strong type support.
+ *
+ * @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;
+};
+
+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 };

package/dist/index.js

@@ -0,0 +1 @@
+var O=Object.defineProperty;var Q=Object.getOwnPropertyDescriptor;var q=Object.getOwnPropertyNames;var E=Object.prototype.hasOwnProperty;var U=(a,e)=>{for(var t in e)O(a,t,{get:e[t],enumerable:!0})},Z=(a,e,t,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of q(e))!E.call(a,r)&&r!==t&&O(a,r,{get:()=>e[r],enumerable:!(i=Q(e,r))||i.enumerable});return a};var W=a=>Z(O({},"__esModule",{value:!0}),a);var b=(a,e,t)=>new Promise((i,r)=>{var o=n=>{try{V(t.next(n))}catch(l){r(l)}},d=n=>{try{V(t.throw(n))}catch(l){r(l)}},V=n=>n.done?i(n.value):Promise.resolve(n.value).then(o,d);V((t=t.apply(a,e)).next())});var ra={};U(ra,{bufferAsync:()=>h,isEmailSync:()=>ta,maxLength:()=>_,maxNumber:()=>ea,minLength:()=>Y,minNumber:()=>aa,required:()=>H,throttleQueueAsync:()=>G,useValidation:()=>C,validateIf:()=>X});module.exports=W(ra);function h(a){let e=0,t;return(...i)=>{var o;let r=++e;return t=(o=t==null?void 0:t.then(()=>{if(e===r)return t=a(...i).then(d=>(t=void 0,d)),t}))!=null?o:a(...i).then(d=>(t=void 0,d)),t}}function G(a,e){let t=0,i;return(...r)=>new Promise(o=>{let d=++t,V=new Date().getTime();i!=null||(i=V-e);let n=V-i-e;n<0?new Promise(l=>setTimeout(l,-1*n)).then(()=>{i=new Date().getTime(),d===t&&o(a(...r)),o(void 0)}):(i=V,o(a(...r)))})}function j(a,e=t=>t){return a.reduce((t,i)=>{if(i!==void 0){let r=e(i);r!==void 0&&t.push(r)}return t},[])}function M(a){return a.reduce((e,t)=>{if(t!==void 0)if(t instanceof Array)for(let i of t)i!==void 0&&e.push(i);else e.push(t);return e},[])}function H(){return a=>({isValid:a.value!==void 0&&String(a.value).trim().length>0,errorMessage:"This field is required"})}function X(a,e){return t=>b(this,null,function*(){return(yield a(t))===!1?{isValid:!0}:e})}function Y(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 _(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 aa(a){return e=>({isValid:e.value!==void 0&&e.value>=a,errorMessage:`The minimum value is ${a}`})}function ea(a){return e=>({isValid:e.value!==void 0&&e.value<=a,errorMessage:`The maximum value is ${a}`})}function ta(){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"})}var R=require("vue");var N=require("vue");var v=require("vue");function k(){return`${Date.now()}-${Math.floor(Math.random()*1e3)}`}function S(a,e,t){let i=[],r=o=>`${e?"reactive":"lazy"}-${k()}`;t!=null&&(r=o=>`${t}-${o}`);for(let[o,d]of a.entries())i.push({validatorId:r(o),validator:d,optimized:!1,isReactive:e,previouslyReturnedValidators:!1,previouslySpawnedValidators:{},spawnedValidators:{}});return i}function x(a,e,t=[]){var l,y,u,s;let i=(0,v.reactive)({isValid:(0,v.computed)(()=>{var P,f;let c=(P=n.isLazyValid.value)!=null?P:!1,p=(f=n.isReactiveValid.value)!=null?f:!1;return c&&p}),isValidating:(0,v.computed)(()=>n.isValidatingReactive.value||n.isValidatingLazy.value),isErrored:(0,v.computed)(()=>i.resultsArray.some(c=>c.isValid===!1)),errorMessages:(0,v.computed)(()=>M(j(i.resultsArray,c=>c.isValid?void 0:c.errorMessage))),results:(0,v.computed)(()=>n.namedValidationResults.value),resultsArray:(0,v.computed)(()=>n.validationResults.value),arrayState:(0,v.computed)(()=>{if(Array.isArray(a.value)===!1||n.elementValidation===void 0)return[];console.time("Array state");let c=a.value,p=n.elementValidation,P=n.arrayConfigMap,f=[],A={},m,I=[];for(let g=0;g<c.length;g++){if(c[g]!==void 0&&typeof c[g]=="object"?(c[g].$ffId===void 0&&Object.defineProperty(c[g],"$ffId",{value:`${n.id}-${n.elementId++}`,writable:!1,configurable:!1,enumerable:!1}),m=c[g].$ffId):c[g]!==void 0&&(m=g),I.push(m),P[m]){f.push(P[m].validationState),A[m]=P[m];continue}if(w(p)){let T=(0,v.computed)(()=>c[g]),F=x(T,p,n.arrayParents);P[m]={validationConfigs:[F],validationState:F.validationState}}else{let T=c[g],F=$(T,p,n.arrayParents.concat(T));P[m]={validationConfigs:F.validationConfigs,validationState:F.state}}f.push(P[m].validationState),A[m]=P[m]}return n.arrayConfigMap=A,console.timeEnd("Array state"),f})}),r=!(((y=(l=e.$lazy)==null?void 0:l.length)!=null?y:-1)>0),o=!(((s=(u=e.$reactive)==null?void 0:u.length)!=null?s:-1)>0),d=e.$reactive?S(e.$reactive,!0):[],V=e.$lazy?S(e.$lazy,!1):[],n={id:k(),validationIterationId:0,isReactiveValid:(0,v.ref)(o),isValidatingReactive:(0,v.ref)(!1),reactiveProcessedValidators:d,isLazyValid:(0,v.ref)(r),isValidatingLazy:(0,v.ref)(!1),lazyProcessedValidators:V,property:a,validation:e,validationState:i,validationResults:(0,v.ref)([]),namedValidationResults:(0,v.ref)({}),arrayConfigMap:{},elementId:0,elementValidation:e.$each,arrayParents:(0,v.reactive)(t)};return n}function $(a,e,t=[]){let i=[],r={};e!==void 0&&o(a,e);function o(d,V){for(let n in V){let l=(0,v.computed)(()=>d[n]);if(w(V[n])){let y=V[n],u=x(l,y,t);i.push(u),r[n]=u.validationState}else{let y={},u=V[n];r[n]=y,o(l,u)}}}return{validationConfigs:i,state:r}}function w(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 z=500;function D(a,e,t,i,r){return b(this,null,function*(){let o=!0,d=(l,y,u)=>{if(i!==l.validationIterationId)return;u.isValid===!1&&(o=!1),u.id=y.validatorId;let s=l.validationResults.value.find(c=>c.id===u.id);s!==void 0?(Object.assign(s,u),u.name!==void 0&&l.namedValidationResults[u.name]!==void 0&&Object.assign(l.namedValidationResults.value[u.name],u)):(l.validationResults.value.push(u),u.name!==void 0&&(l.namedValidationResults.value[u.name]=u))},{asyncPromises:V,validatorsWhichPreviouslyReturnedValidators:n}=B(a,e,t,i,r,d,!0,1);if(yield Promise.all(V),i===a.validationIterationId){for(let l of n)for(let y of Object.keys(l.previouslySpawnedValidators))if(l.spawnedValidators[y]==null){let u=a.validationResults.value.findIndex(s=>s.id===y);u!==-1&&a.validationResults.value.splice(u)}}return o})}function B(a,e,t,i,r,o,d,V){let n=a.property.value,l=[],y=[],u=[];for(let s of r){let c=!1;s.previouslyReturnedValidators&&(s.previouslySpawnedValidators=s.spawnedValidators,s.spawnedValidators={},c=!0),s.previouslyReturnedValidators=!1;let p;if(s.computedValidator===void 0){let P={value:n,parent:e,args:t,arrayParents:a.arrayParents};p=s.validator(P)}else p=s.computedValidator.value;if(p instanceof Promise){let P=Date.now();l.push(p.then(f=>b(this,null,function*(){if(f===void 0){c&&u.push(s);return}let A=Date.now()-P;if(d&&A>z&&s.optimized===!1&&(s.optimized=!0,A<2*z?s.validator=G(s.validator,z):s.validator=h(s.validator)),Array.isArray(f)){let{asyncPromises:m,syncResults:I}=L(a,e,t,i,o,s,f,V);y.push(...I),yield Promise.all(m);return}else c&&u.push(s);o(a,s,f)})))}else if(Array.isArray(p)){let{asyncPromises:P,syncResults:f}=L(a,e,t,i,o,s,p,V);l.push(...P),y.push(...f)}else if(c&&u.push(s),p!==void 0){if(d&&s.optimized===!1){let P=s.validator;s.computedValidator=(0,N.computed)(()=>{let f={value:a.property.value,parent:e,args:t,arrayParents:a.arrayParents};return P(f)}),s.optimized=!0,s.validator=()=>s.computedValidator.value}y.push(p),o(a,s,p)}}return{asyncPromises:l,syncResults:y,validatorsWhichPreviouslyReturnedValidators:u}}function L(a,e,t,i,r,o,d,V){let n=S(d,o.isReactive,o.validatorId),l=B(a,e,t,i,n,r,!1,++V),y={};for(let u of n)y[u.validatorId]=u;return o.spawnedValidators=y,o.previouslyReturnedValidators=!0,l}function ia(a,e,t,i){return b(this,null,function*(){a.isValidatingReactive.value=!0;let r=yield D(a,e,t,i,a.reactiveProcessedValidators);return i===a.validationIterationId&&(a.isReactiveValid.value=r,a.isValidatingReactive.value=!1),a.isReactiveValid.value})}function na(a,e,t,i){return b(this,null,function*(){a.isValidatingLazy.value=!0;let r=a.lazyProcessedValidators,o=yield D(a,e,t,i,r);return i===a.validationIterationId&&(a.isLazyValid.value=o,a.isValidatingLazy.value=!1),a.isLazyValid.value})}function K(a,e,t,i,r){return b(this,null,function*(){let o=[];for(let d of a){let V=++d.validationIterationId;if(i&&d.validation.$reactive!==void 0&&o.push(yield ia(d,e.value,t,V)),r&&d.validation.$lazy!==void 0&&o.push(yield na(d,e.value,t,V)),d.elementValidation!==void 0){let n=[];for(let l in d.arrayConfigMap)n.push(...d.arrayConfigMap[l].validationConfigs);o.push(yield K(n,e,t,i,r))}}return Promise.all(o).then(d=>d.every(V=>V===!0))})}function C(a){var P;(P=a.delayReactiveValidation)!=null||(a.delayReactiveValidation=!0);let{objectToValidate:e,validation:t,delayReactiveValidation:i,args:r}=a,o=(0,R.ref)(!1),d=(0,R.computed)(()=>n.some(f=>f.validationState.isValidating)),V=(0,R.computed)(()=>n.every(A=>A.isReactiveValid.value&&A.isLazyValid.value)),n=[],l=(0,R.reactive)({}),y=(0,R.ref)(JSON.stringify(a.objectToValidate.value)),u=(0,R.computed)(()=>y.value!==JSON.stringify(a.objectToValidate.value));if(w(t)){let m=x(e,t);l=(0,R.reactive)(m.validationState),n=[m]}else{let f=e,A=t,m=$(f.value,A);l=(0,R.reactive)(m.state),n=m.validationConfigs}(0,R.watch)(a.objectToValidate,()=>{i?o.value===!0&&K(n,e,r,!0,!1):K(n,e,r,!0,!1)},{deep:!0});function c(){return b(this,null,function*(){let f=yield K(n,e,r,!0,!0);return o.value=!0,f})}function p(f){y.value=JSON.stringify(f)}return(0,R.reactive)({hasValidated:o,validate:c,isValidating:d,propertyState:(0,R.computed)(()=>l),isValid:V,setReference:p,isDirty:u})}0&&(module.exports={bufferAsync,isEmailSync,maxLength,maxNumber,minLength,minNumber,required,throttleQueueAsync,useValidation,validateIf});

package/dist/index.mjs

@@ -0,0 +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};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "vuelidify",
+  "version": "1.0.0",
+  "author": "Daniel Walbolt",
+  "private": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "icon": "./favicon.ico",
+  "files": [
+    "dist",
+    "favicon.ico",
+    "assets"
+  ],
+  "homepage": "https://github.com/Daniel-Walbolt/vue-final-form",
+  "issues": "https://github.com/Daniel-Walbolt/vue-final-form/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Daniel-Walbolt/vue-final-form"
+  },
+  "dependencies": {
+    "vue": "^3.4.38"
+  },
+  "devDependencies": {
+    "@tsconfig/node20": "^20.1.4",
+    "@types/node": "^20.16.2",
+    "@vitejs/plugin-vue": "^5.1.3",
+    "@vue/eslint-config-typescript": "^13.0.0",
+    "@vue/tsconfig": "^0.5.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-vue": "^9.27.0",
+    "npm-run-all2": "^6.2.2",
+    "tsup": "^6.7.0",
+    "typescript": "~5.4.5",
+    "vue-tsc": "^2.1.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --minify",
+    "lint": "tsc"
+  }
+}