@dolanske/v-valid 2.1.0 → 3.0.0

package/dist/v-valid.d.ts

@@ -1,76 +1,38 @@
 import { ComputedRef } from 'vue-demi';
+import { MaybeRef } from 'vue-demi';
 import { Ref } from 'vue-demi';
 import { UnwrapRef } from 'vue-demi';
 
 /**
- * @rule Value must pass every provided check
- * @param rules Single or multiple validation rules
+ * @Rule Input must be a date after or at the provided rule
+ * @param min Minimum allowed value
  */
-export declare function $and(...rules: ValidationRule[]): ValidationRule;
+export declare function after(min: MaybeRef<Date>): ValidationRule;
 
-export declare namespace $and {
+export declare namespace after {
     var skip: (..._args: any[]) => ValidationRule;
 }
 
 /**
- * @rule Value must fail the check or list of all provided checks
+ * @rule Value must pass every provided check
  * @param rules Single or multiple validation rules
  */
-export declare function $not(...rules: ValidationRule[]): ValidationRule;
+export declare function and(...rules: ValidationRule[]): ValidationRule;
 
-export declare namespace $not {
-    var skip: ValidationRule;
+export declare namespace and {
+    var skip: (..._args: any[]) => ValidationRule;
 }
 
 /**
- * @rule Value must pass at least one of the provided checks
- * @param rules Single or multiple validation rules
+ * @Rule Input must be a date before or at the provided rule
+ * @param max maximum allowed value
  */
-export declare function $or(...rules: ValidationRule[]): ValidationRule;
+export declare function before(max: MaybeRef<Date>): ValidationRule;
 
-export declare namespace $or {
+export declare namespace before {
     var skip: (..._args: any[]) => ValidationRule;
 }
 
-/**
- * Shorthand for calling `rule(...args).validate(value)`
- *
- * @Rule Execute validation against a provided value outside of the validation
- * scope. This helper can be also used within `validateIf` and `validateIfNot`
- *
- * @param rule Validation rule
- * @param value Value to validate
- * @returns Wether the provided value passes the provided check
- */
-export declare function $test(rule: ValidationRule, value: any): Promise<boolean> | boolean;
-
-/**
- * @Rule Perform validation if provided condition is met
- * @param condition Boolean or function returning boolean
- * @param rule Validation rule
- */
-export declare function $validateIf(condition: boolean | (() => boolean) | Ref<boolean> | Promise<boolean>, rule: ValidationRule): ValidationRule | Promise<ValidationRule>;
-
-/**
- * @Rule Perform validation if provided condition is not met
- * @param condition Boolean or function returning boolean
- * @param rule Validation rule
- */
-export declare function $validateIfNot(condition: boolean | (() => boolean) | Ref<boolean> | Promise<boolean>, rule: ValidationRule): ValidationRule | Promise<ValidationRule>;
-
-/**
- *
- * Helper method which adds custom message to any validation.
- *
- * ```ts
- * minLength: withLabel("Too short!", minLength(10))
- * ```
- *
- * @param message Custom message to display in the returned error
- * @param validator Validation rule
- */
-export declare function $withLabel(message: string | Label, validator: ValidationRule): ValidationRule;
-
 /**
  * @Rule Checks if value is between the provided range
  * @param min Minimum value
@@ -115,6 +77,16 @@ declare type _DeepKeys<T> = T extends object ? ({
     [K in (string | number) & keyof T]: `${(`.${K}` | (`${K}` extends `${number}` ? `[${K}]` : never))}${'' | _DeepKeys<FixArr<T[K]>>}`;
 }[(string | number) & keyof T]) : never;
 
+/**
+ * Type safe helper to generating rules from form objects. Also allows array rule definition
+ *
+ * @param rules
+ * @returns Rules to be used within the composable
+ */
+export declare function defineRules<F>(rules: DefineRuleType<F>): DefineRuleType<F>;
+
+declare type DefineRuleType<T> = ReplacePrimitivesOptional<T, Record<string, Rule> | Array<Rule>>;
+
 declare type DefLabel = string | ((value: any) => string);
 
 /**
@@ -153,54 +125,6 @@ declare type FixArr<T> = T extends readonly any[] ? Omit<T, Exclude<keyof any[],
  */
 export declare const hasSpecialChars: ValidationRuleObject;
 
-/**
- * @Rule Checkes wether value is an Array
- * @param value Input value
- */
-export declare const isArr: Type['arr'];
-
-/**
- * @Rule Checkes wether value is a valid Date object
- * @param value Input value
- */
-export declare const isDate: Type['date'];
-
-/**
- * @Rule Checkes wether value is a Map
- * @param value Input value
- */
-export declare const isMap: Type['map'];
-
-/**
- * @Rule Checkes wether value is a number
- * @param value Input value
- */
-export declare const isNum: Type['num'];
-
-/**
- * @Rule Checkes wether value is an Object
- * @param value Input value
- */
-export declare const isObj: Type['obj'];
-
-/**
- * @Rule Checkes wether value is a Set
- * @param value Input value
- */
-export declare const isSet: Type['set'];
-
-/**
- * @Rule Checkes wether value is a string
- * @param value Input value
- */
-export declare const isStr: Type['str'];
-
-/**
- * @Rule Checkes wether value is a Symbol
- * @param value Input value
- */
-export declare const isSymbol: Type['symbol'];
-
 declare type Label = (value: any, args?: Record<string, unknown>) => string;
 
 /**
@@ -233,16 +157,6 @@ export declare namespace maxLenNoSpace {
     var skip: (..._args: any[]) => ValidationRule;
 }
 
-/**
- * @Rule Input must be a number or a date which satisfies the maximum provided value.
- * @param max maximum allowed value
- */
-export declare function maxValue(max: number | Date | Ref<number | Date>): ValidationRule;
-
-export declare namespace maxValue {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
 /**
  * @Rule Input must be equal or greater than the provided amount
  * @param min Minimum allowed length the input must satisfy
@@ -264,12 +178,22 @@ export declare namespace minLenNoSpace {
 }
 
 /**
- * @Rule Input must be a number or a date which satisfies the minimum provided value.
- * @param min Minimum allowed value
+ * @rule Value must fail the check or list of all provided checks
+ * @param rules Single or multiple validation rules
  */
-export declare function minValue(min: number | Date | Ref<number | Date>): ValidationRule;
+export declare function not(...rules: ValidationRule[]): ValidationRule;
 
-export declare namespace minValue {
+export declare namespace not {
+    var skip: ValidationRule;
+}
+
+/**
+ * @rule Value must pass at least one of the provided checks
+ * @param rules Single or multiple validation rules
+ */
+export declare function or(...rules: ValidationRule[]): ValidationRule;
+
+export declare namespace or {
     var skip: (..._args: any[]) => ValidationRule;
 }
 
@@ -277,12 +201,18 @@ declare type ReplacePrimitives<T, ReplaceWith> = T extends Record<string, unknow
     [K in keyof T]: ReplacePrimitives<T[K], ReplaceWith>;
 } : ReplaceWith;
 
+declare type ReplacePrimitivesOptional<T, ReplaceWith> = T extends Record<string, unknown> ? {
+    [K in keyof T]?: ReplacePrimitivesOptional<T[K], ReplaceWith>;
+} : ReplaceWith;
+
 /**
  * @Rule Input must not be empty, null or undefined.
  * If input is number with value 0, it will return true as value was provided
  */
 export declare const required: ValidationRuleObject;
 
+declare type Rule = ValidationRule | ValidationRuleObject;
+
 declare type RuleParams = Record<string, any>;
 
 /**
@@ -312,19 +242,6 @@ export declare namespace startsWith {
     var skip: (..._args: any[]) => ValidationRule;
 }
 
-declare interface Type {
-    str: ValidationRuleObject;
-    num: ValidationRuleObject;
-    arr: ValidationRuleObject;
-    obj: ValidationRuleObject;
-    set: ValidationRuleObject;
-    map: ValidationRuleObject;
-    date: ValidationRuleObject;
-    symbol: ValidationRuleObject;
-}
-
-export declare const type: Type;
-
 /**
  * @Rule Input must be a valid URL
  */
@@ -351,108 +268,157 @@ export declare function useValidation<F extends Record<string, any>, R extends P
     pending: Ref<boolean>;
 };
 
+/**
+ * @Rule Perform validation if provided condition is met
+ * @param condition Boolean or function returning boolean
+ * @param rule Validation rule
+ */
+export declare function validateIf(condition: boolean | (() => boolean) | Ref<boolean> | Promise<boolean>, rule: ValidationRule): ValidationRule | Promise<ValidationRule>;
+
+/**
+ * @Rule Perform validation if provided condition is not met
+ * @param condition Boolean or function returning boolean
+ * @param rule Validation rule
+ */
+export declare function validateIfNot(condition: boolean | (() => boolean) | Ref<boolean> | Promise<boolean>, rule: ValidationRule): ValidationRule | Promise<ValidationRule>;
+
 export declare interface ValidationError {
+    /**
+     * Form object property name
+     */
     id: string | null;
+    /**
+     * Received value
+     */
     value: any;
+    /**
+     * Status
+     */
     invalid: boolean;
+    /**
+     * Errors object where the key is the name of the rule and the value is the error message
+     */
     errors: Record<string, string>;
+    /**
+     * Flat array of error messages so it can be easily consumed by UI libraries
+     */
+    messages: string[];
 }
 
-declare interface ValidationOptions {
+export declare interface ValidationOptions {
+    /**
+     * Performs validation whenever the form object updates
+     */
     proactive?: boolean;
+    /**
+     * Clears errors on new input
+     */
     autoclear?: boolean;
 }
 
-declare interface ValidationRule {
+export declare interface ValidationRule {
     __skip: boolean;
     validate: (arg: any) => Promise<boolean> | boolean;
     label: Label;
     name: string;
 }
 
-declare interface ValidationRuleObject extends ValidationRule {
+export declare interface ValidationRuleObject extends ValidationRule {
     skip: () => void;
 }
 
-export { }
-
-
-declare namespace $and {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace $or {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace $not {
-    var skip: ValidationRule;
-}
-
-
-declare namespace minLength {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace sameAs {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace maxLength {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace match {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace between {
-    var skip: (..._args: any[]) => import("../types").ValidationRule;
-}
-
-
-declare namespace minValue {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace maxLenNoSpace {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace maxValue {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace startsWith {
-    var skip: (..._args: any[]) => import("../../types").ValidationRule;
-}
-
-
-declare namespace endsWith {
-    var skip: (..._args: any[]) => import("../../types").ValidationRule;
-}
-
-
-declare namespace contains {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace minLenNoSpace {
-    var skip: (..._args: any[]) => ValidationRule;
-}
-
-
-declare namespace password {
-    var skip: (..._args: any[]) => ValidationRule;
-}
+/**
+ *
+ * Helper method which adds custom message to any validation.
+ *
+ * ```ts
+ * minLength: withLabel("Too short!", minLength(10))
+ * ```
+ *
+ * @param message Custom message to display in the returned error
+ * @param validator Validation rule
+ */
+export declare function withLabel(message: string | Label, validator: ValidationRule): ValidationRule;
 
+export { }
+
+
+declare namespace not {
+    var skip: ValidationRule;
+}
+
+
+declare namespace and {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace or {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace minLength {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace sameAs {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace match {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace after {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace between {
+    var skip: (..._args: any[]) => import("..").ValidationRule;
+}
+
+
+declare namespace before {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace maxLength {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace maxLenNoSpace {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace minLenNoSpace {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace contains {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+
+
+declare namespace startsWith {
+    var skip: (..._args: any[]) => import("../..").ValidationRule;
+}
+
+
+declare namespace endsWith {
+    var skip: (..._args: any[]) => import("../..").ValidationRule;
+}
+
+
+declare namespace password {
+    var skip: (..._args: any[]) => ValidationRule;
+}
+