@splitty-test/validation 0.1.2 → 0.2.0

package/dist/FieldValidation.vue.d.ts

@@ -1,6 +1,6 @@
 import { PropType } from 'vue';
-import { Validator } from './ValidatorClass';
-import { ValidationRule } from './FieldValidatorClass';
+import { FormValidator } from './FormValidator';
+import { ValidationRule } from './FieldValidator';
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     name: {
         type: StringConstructor;
@@ -13,18 +13,21 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     modelModifiers: {
         default: () => {};
     };
+    replaceRules: {
+        type: BooleanConstructor;
+    };
     rules: {
         type: PropType<ValidationRule[]>;
         default(): never[];
     };
     validator: {
-        type: typeof Validator;
+        type: PropType<FormValidator>;
         required: true;
     };
 }>, {}, {
     form_fields: HTMLElement[];
 }, {
-    field(): import('./FieldValidatorClass').FieldValidator;
+    field(): import('./FieldValidator').FieldValidator;
     error(): string | null | undefined;
 }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     name: {
@@ -38,17 +41,21 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     modelModifiers: {
         default: () => {};
     };
+    replaceRules: {
+        type: BooleanConstructor;
+    };
     rules: {
         type: PropType<ValidationRule[]>;
         default(): never[];
     };
     validator: {
-        type: typeof Validator;
+        type: PropType<FormValidator>;
         required: true;
     };
 }>> & Readonly<{}>, {
     hideError: boolean;
     modelModifiers: {};
+    replaceRules: boolean;
     rules: ValidationRule[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/FieldValidator.d.ts

@@ -0,0 +1,50 @@
+import { FormValidator } from './FormValidator';
+import { Reactive, Ref } from 'vue';
+export type ValidationRule = (value: any, ...args: any) => Promise<string | null> | (string | null);
+export interface FieldValidatorOptions {
+    replace_rules?: boolean;
+    group?: string;
+}
+export interface FieldValidatorConfig {
+    value?: Ref<any, any> | Reactive<any>;
+    rules?: ValidationRule[];
+    group?: string;
+}
+export interface FieldValidator {
+    form_value: Ref<any, any>;
+    controls: HTMLElement[];
+    dirty: Ref<boolean, boolean>;
+    errors: Reactive<string[]>;
+    group?: string;
+    rules: Reactive<ValidationRule[]>;
+    touched: Ref<boolean, boolean>;
+    validated: Ref<boolean, boolean>;
+    setValue: (value: any) => void;
+    replaceRules: (new_rules: ValidationRule[]) => void;
+    appendRules: (new_rules: ValidationRule[]) => void;
+    addToGroup: (group_name: string) => void;
+    removeFromGroup: (group_name: string) => void;
+    validate: () => Promise<boolean>;
+    isValid: () => boolean;
+    setTouched: () => void;
+    reset: () => void;
+}
+export declare function useFieldValidator(field_name: string, value: Ref<any, any> | Reactive<any>, new_rules: ValidationRule[], validator: FormValidator, options?: FieldValidatorOptions): {
+    form_value: Ref<any, any>;
+    controls: HTMLElement[];
+    dirty: Ref<boolean, boolean>;
+    errors: Reactive<string[]>;
+    group: string | undefined;
+    rules: Reactive<ValidationRule[]>;
+    touched: Ref<boolean, boolean>;
+    validated: Ref<boolean, boolean>;
+    setValue: (v: any) => void;
+    replaceRules: (new_rules: ValidationRule[]) => void;
+    appendRules: (new_rules: ValidationRule[]) => void;
+    addToGroup: (group_name: string) => void;
+    removeFromGroup: (group_name: string) => void;
+    validate: () => Promise<boolean>;
+    isValid: () => boolean;
+    setTouched: () => void;
+    reset: () => void;
+};

package/dist/FieldValidatorGroup.d.ts

@@ -0,0 +1,18 @@
+import { Reactive, Ref } from 'vue';
+import { FieldValidator } from './FieldValidator';
+export interface FieldValidatorGroup {
+    dirty: Ref<boolean, boolean>;
+    fields: Reactive<Record<string, FieldValidator>>;
+    touched: Ref<boolean, boolean>;
+    validated: Ref<boolean, boolean>;
+    setTouched: () => void;
+    reset: () => void;
+}
+export declare function useFieldValidatorGroup(): {
+    dirty: Ref<boolean, boolean>;
+    touched: Ref<boolean, boolean>;
+    validated: Ref<boolean, boolean>;
+    fields: {};
+    setTouched: () => void;
+    reset: () => void;
+};

package/dist/FormValidator.d.ts

@@ -0,0 +1,32 @@
+import { Reactive, Ref } from 'vue';
+import { FieldValidator, FieldValidatorConfig, FieldValidatorOptions, ValidationRule } from './FieldValidator';
+import { FieldValidatorGroup } from './FieldValidatorGroup';
+export interface FormValidator {
+    dirty: Ref<boolean, boolean>;
+    errors: Reactive<string[]>;
+    fields: Reactive<Record<string, FieldValidator>>;
+    groups: Reactive<Record<string, FieldValidatorGroup>>;
+    touched: Ref<boolean, boolean>;
+    validated: Ref<boolean, boolean>;
+    addField: (field_name: string, value?: Ref<any, any> | Reactive<any>, rules?: Reactive<ValidationRule[]>, options?: FieldValidatorOptions) => void;
+    removeField: (field_name: string) => void;
+    validate: (group_name?: string) => Promise<boolean>;
+    isValid: (group_name?: string) => boolean;
+    setTouched: () => void;
+    reset: (group_name?: string) => void;
+}
+export type FormValidatorConfig = Record<string, FieldValidatorConfig>;
+export declare function useFormValidator(config?: FormValidatorConfig): {
+    dirty: Ref<boolean, boolean>;
+    errors: Reactive<string[]>;
+    fields: Record<string, FieldValidator>;
+    groups: Record<string, FieldValidatorGroup>;
+    touched: Ref<boolean, boolean>;
+    validated: Ref<boolean, boolean>;
+    addField: (field_name: string, value?: Ref<any, any> | Reactive<any>, rules?: Reactive<ValidationRule[]>, options?: FieldValidatorOptions) => void;
+    removeField: (field_name: string) => void;
+    validate: (group_name?: string) => Promise<boolean>;
+    isValid: (group_name?: string) => boolean;
+    setTouched: () => void;
+    reset: (group_name?: string) => void;
+};

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-import { Validator } from './ValidatorClass';
-import { FieldValidator } from './FieldValidatorClass';
+import { useFormValidator, FormValidator, FormValidatorConfig } from './FormValidator';
+import { useFieldValidator, FieldValidator, FieldValidatorOptions, FieldValidatorConfig, ValidationRule } from './FieldValidator';
+import { useFieldValidatorGroup, FieldValidatorGroup } from './FieldValidatorGroup';
 import { default as FieldValidation } from './FieldValidation.vue';
+import { zodRule, zodSchema } from './utils/zodValidation';
 import * as rules from './rules';
-export { Validator, FieldValidator, FieldValidation, rules };
+export type { FormValidator, FormValidatorConfig, FieldValidator, FieldValidatorOptions, FieldValidatorConfig, FieldValidatorGroup, ValidationRule, };
+export { useFormValidator, useFieldValidator, useFieldValidatorGroup, FieldValidation, rules, zodSchema, zodRule, };