@volverjs/form-vue 1.0.0-beta.25 → 1.0.0-beta.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (17) hide show
  1. package/dist/VvForm.d.ts +13 -10
  2. package/dist/VvFormField.d.ts +5 -5
  3. package/dist/VvFormFieldsGroup.d.ts +5 -5
  4. package/dist/VvFormTemplate.d.ts +9 -9
  5. package/dist/VvFormWrapper.d.ts +10 -10
  6. package/dist/index.d.ts +683 -177
  7. package/dist/index.es.js +627 -587
  8. package/dist/index.umd.js +1 -1
  9. package/dist/types.d.ts +25 -20
  10. package/package.json +10 -10
  11. package/src/VvForm.ts +26 -15
  12. package/src/VvFormField.ts +14 -7
  13. package/src/VvFormFieldsGroup.ts +17 -6
  14. package/src/VvFormTemplate.ts +17 -19
  15. package/src/VvFormWrapper.ts +45 -14
  16. package/src/index.ts +24 -10
  17. package/src/types.ts +39 -34
package/dist/VvForm.d.ts CHANGED
@@ -2,18 +2,19 @@ import { Component, InjectionKey, PropType, SlotsType } from 'vue';
2
2
  import { z } from 'zod';
3
3
  import { FormComponentOptions, FormSchema, FormTemplate, InjectedFormData } from './types';
4
4
  import { FormStatus } from './enums';
5
- export declare function defineForm<Schema extends FormSchema>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema>>, options?: FormComponentOptions<Schema>, VvFormTemplate?: Component): {
5
+ export declare function defineForm<Schema extends FormSchema, Type, FormTemplateComponent extends Component, FormWrapperComponent extends Component>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema, Type>>, options: FormComponentOptions<Schema, Type>, VvFormTemplate: FormTemplateComponent, wrappers: Map<string, FormWrapperComponent>): {
6
6
  clear: () => void;
7
7
  errors: import('vue').Ref<z.inferFormattedError<Schema, string> | undefined, z.inferFormattedError<Schema, string> | undefined>;
8
- formData: import('vue').Ref<Partial<z.TypeOf<Schema> | undefined>, Partial<z.TypeOf<Schema> | undefined>>;
8
+ formData: import('vue').Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined>;
9
9
  ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
10
10
  invalid: import('vue').ComputedRef<boolean>;
11
11
  readonly: import('vue').Ref<boolean, boolean>;
12
12
  reset: () => void;
13
13
  status: import('vue').Ref<FormStatus | undefined, FormStatus | undefined>;
14
+ wrappers: Map<string, FormWrapperComponent>;
14
15
  stopUpdatesWatch: import('vue').WatchStopHandle;
15
16
  submit: () => Promise<boolean>;
16
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
17
+ validate: (value?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, fields?: Set<string>) => Promise<boolean>;
17
18
  VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
18
19
  continuousValidation: {
19
20
  type: BooleanConstructor;
@@ -32,13 +33,13 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
32
33
  default: string;
33
34
  };
34
35
  template: {
35
- type: PropType<FormTemplate<Schema>>;
36
+ type: PropType<FormTemplate<Schema, Type>>;
36
37
  default: undefined;
37
38
  };
38
39
  }>, {
39
40
  clear: () => void;
40
41
  errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
41
- formData: import('vue').Ref<Partial<z.TypeOf<Schema> | undefined>, Partial<z.TypeOf<Schema> | undefined>>;
42
+ formData: import('vue').Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined>;
42
43
  ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
43
44
  invalid: import('vue').ComputedRef<boolean>;
44
45
  isReadonly: import('vue').Ref<boolean, boolean>;
@@ -46,7 +47,8 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
46
47
  status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
47
48
  stopUpdatesWatch: import('vue').WatchStopHandle;
48
49
  submit: () => Promise<boolean>;
49
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
50
+ validate: (value?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, fields?: Set<string>) => Promise<boolean>;
51
+ wrappers: Map<string, FormWrapperComponent>;
50
52
  }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly")[], "invalid" | "valid" | "reset" | "submit" | "update:modelValue" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
51
53
  continuousValidation: {
52
54
  type: BooleanConstructor;
@@ -65,7 +67,7 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
65
67
  default: string;
66
68
  };
67
69
  template: {
68
- type: PropType<FormTemplate<Schema>>;
70
+ type: PropType<FormTemplate<Schema, Type>>;
69
71
  default: undefined;
70
72
  };
71
73
  }>> & Readonly<{
@@ -78,22 +80,23 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
78
80
  }>, {
79
81
  readonly: boolean;
80
82
  tag: string;
81
- template: FormTemplate<Schema>;
83
+ template: FormTemplate<Schema, Type>;
82
84
  continuousValidation: boolean;
83
85
  modelValue: Record<string, any>;
84
86
  }, SlotsType<{
85
87
  default: {
86
88
  errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
87
- formData: import('vue').Ref<Partial<z.TypeOf<Schema> | undefined>, Partial<z.TypeOf<Schema> | undefined>>;
89
+ formData: import('vue').Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined>;
88
90
  ignoreUpdates: import('@vueuse/core').IgnoredUpdater;
89
91
  invalid: import('vue').ComputedRef<boolean>;
90
92
  readonly: import('vue').Ref<boolean, boolean>;
91
93
  status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
92
94
  stopUpdatesWatch: import('vue').WatchStopHandle;
93
95
  submit: () => Promise<boolean>;
94
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
96
+ validate: (value?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, fields?: Set<string>) => Promise<boolean>;
95
97
  clear: () => void;
96
98
  reset: () => void;
99
+ wrappers: typeof wrappers;
97
100
  };
98
101
  }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "readonly" | "clear" | "submit" | "errors" | "tag" | "template" | "validate", import('vue').ComponentProvideOptions, true, {}, any>;
99
102
  };
package/dist/VvFormField.d.ts CHANGED
@@ -1,8 +1,8 @@
1
1
  import { Component, ConcreteComponent, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
2
- import { inferFormattedError, TypeOf, z } from 'zod';
2
+ import { inferFormattedError, z } from 'zod';
3
3
  import { FormFieldType } from './enums';
4
4
  import { FormFieldComponentOptions, FormSchema, InjectedFormData, InjectedFormFieldData, InjectedFormWrapperData, Path } from './types';
5
- export declare function defineFormField<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
5
+ export declare function defineFormField<Schema extends FormSchema, Type>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
6
6
  type: {
7
7
  type: PropType<`${FormFieldType}`>;
8
8
  validator: (value: FormFieldType) => boolean;
@@ -117,14 +117,14 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
117
117
  [key: string]: any;
118
118
  default: {
119
119
  errors: z.inferFormattedError<Schema>;
120
- formData?: Partial<TypeOf<Schema>>;
120
+ formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
121
121
  formErrors?: DeepReadonly<inferFormattedError<Schema, string>>;
122
122
  invalid: boolean;
123
123
  invalidLabel?: string[];
124
124
  modelValue: any;
125
125
  onUpdate: (value: unknown) => void;
126
126
  readonly: boolean;
127
- submit?: InjectedFormData<Schema>["submit"];
128
- validate?: InjectedFormData<Schema>["validate"];
127
+ submit?: InjectedFormData<Schema, Type>["submit"];
128
+ validate?: InjectedFormData<Schema, Type>["validate"];
129
129
  };
130
130
  }>, {}, {}, "invalid" | "type" | "errors" | "component" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;
package/dist/VvFormFieldsGroup.d.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  import { Component, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
2
- import { inferFormattedError, TypeOf, z } from 'zod';
2
+ import { inferFormattedError, z } from 'zod';
3
3
  import { FormSchema, InjectedFormData, InjectedFormFieldsGroupData, InjectedFormWrapperData, Path } from './types';
4
- export declare function defineFormFieldsGroup<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldsGroupInjectionKey: InjectionKey<InjectedFormFieldsGroupData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
4
+ export declare function defineFormFieldsGroup<Schema extends FormSchema, Type>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldsGroupInjectionKey: InjectionKey<InjectedFormFieldsGroupData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
5
5
  is: {
6
6
  type: PropType<Component | string>;
7
7
  default: undefined;
@@ -94,7 +94,7 @@ export declare function defineFormFieldsGroup<Schema extends FormSchema>(formPro
94
94
  [key: string]: any;
95
95
  default: {
96
96
  errors?: Record<Path<z.infer<Schema>>, z.inferFormattedError<Schema>>;
97
- formData?: Partial<TypeOf<Schema>>;
97
+ formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
98
98
  formErrors?: DeepReadonly<inferFormattedError<Schema, string>>;
99
99
  invalid: boolean;
100
100
  invalids: Record<string, boolean>;
@@ -103,7 +103,7 @@ export declare function defineFormFieldsGroup<Schema extends FormSchema>(formPro
103
103
  onUpdate: (value: Record<string, any>) => void;
104
104
  onUpdateField: (name: string, value: any) => void;
105
105
  readonly: boolean;
106
- submit?: InjectedFormData<Schema>["submit"];
107
- validate?: InjectedFormData<Schema>["validate"];
106
+ submit?: InjectedFormData<Schema, Type>["submit"];
107
+ validate?: InjectedFormData<Schema, Type>["validate"];
108
108
  };
109
109
  }>, {}, {}, "invalid" | "errors" | "component" | "hasProps" | "is" | "invalidLabels", import('vue').ComponentProvideOptions, true, {}, any>;
package/dist/VvFormTemplate.d.ts CHANGED
@@ -1,10 +1,10 @@
1
1
  import { Component, DeepReadonly, InjectionKey, PropType, SlotsType, VNode } from 'vue';
2
2
  import { FormSchema, InjectedFormData, FormTemplate } from './types';
3
- import { inferFormattedError, TypeOf } from 'zod';
3
+ import { z, inferFormattedError } from 'zod';
4
4
  import { FormStatus } from './enums';
5
- export declare function defineFormTemplate<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, VvFormField: Component): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
5
+ export declare function defineFormTemplate<Schema extends FormSchema, Type>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, VvFormField: Component): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
6
6
  schema: {
7
- type: PropType<FormTemplate<Schema>>;
7
+ type: PropType<FormTemplate<Schema, Type>>;
8
8
  required: true;
9
9
  };
10
10
  scope: {
@@ -17,7 +17,7 @@ export declare function defineFormTemplate<Schema extends FormSchema>(formProvid
17
17
  [key: string]: any;
18
18
  }>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
19
19
  schema: {
20
- type: PropType<FormTemplate<Schema>>;
20
+ type: PropType<FormTemplate<Schema, Type>>;
21
21
  required: true;
22
22
  };
23
23
  scope: {
@@ -29,12 +29,12 @@ export declare function defineFormTemplate<Schema extends FormSchema>(formProvid
29
29
  }, SlotsType<{
30
30
  default: {
31
31
  errors?: DeepReadonly<inferFormattedError<Schema, string>>;
32
- formData?: Partial<TypeOf<Schema>>;
32
+ formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
33
33
  invalid: boolean;
34
34
  status?: FormStatus;
35
- submit?: InjectedFormData<Schema>["submit"];
36
- validate?: InjectedFormData<Schema>["validate"];
37
- clear?: InjectedFormData<Schema>["clear"];
38
- reset?: InjectedFormData<Schema>["reset"];
35
+ submit?: InjectedFormData<Schema, Type>["submit"];
36
+ validate?: InjectedFormData<Schema, Type>["validate"];
37
+ clear?: InjectedFormData<Schema, Type>["clear"];
38
+ reset?: InjectedFormData<Schema, Type>["reset"];
39
39
  };
40
40
  }>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
package/dist/VvFormWrapper.d.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  import { DeepReadonly, InjectionKey, Ref, SlotsType } from 'vue';
2
- import { inferFormattedError, TypeOf, z } from 'zod';
2
+ import { inferFormattedError, z } from 'zod';
3
3
  import { FormSchema, InjectedFormData, InjectedFormWrapperData } from './types';
4
- export declare function defineFormWrapper<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
4
+ export declare function defineFormWrapper<Schema extends FormSchema, Type>(formProvideKey: InjectionKey<InjectedFormData<Schema, Type>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
5
5
  name: {
6
6
  type: StringConstructor;
7
7
  required: true;
@@ -13,13 +13,13 @@ export declare function defineFormWrapper<Schema extends FormSchema>(formProvide
13
13
  }>, {
14
14
  clear: (() => void) | undefined;
15
15
  errors: Readonly<Ref<DeepReadonly<inferFormattedError<Schema, string>> | undefined, DeepReadonly<inferFormattedError<Schema, string>> | undefined>> | undefined;
16
- fields: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
16
+ fields: Ref<Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>, Map<string, string> | (Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>)>;
17
17
  fieldsErrors: Ref<Map<string, inferFormattedError<Schema, string>>, Map<string, inferFormattedError<Schema, string>>>;
18
- formData: Ref<Partial<TypeOf<Schema>> | undefined, Partial<TypeOf<Schema>> | undefined> | undefined;
18
+ formData: Ref<(undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined> | undefined;
19
19
  invalid: import('vue').ComputedRef<boolean>;
20
20
  reset: (() => void) | undefined;
21
21
  submit: (() => Promise<boolean>) | undefined;
22
- validate: ((formData?: Partial<TypeOf<Schema>> | undefined, fields?: Set<string>) => Promise<boolean>) | undefined;
22
+ validate: ((formData?: (undefined extends Type ? Partial<z.TypeOf<Schema>> : Type) | undefined, fields?: Set<string>) => Promise<boolean>) | undefined;
23
23
  validateWrapper: () => Promise<boolean>;
24
24
  }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
25
25
  name: {
@@ -38,14 +38,14 @@ export declare function defineFormWrapper<Schema extends FormSchema>(formProvide
38
38
  }, SlotsType<{
39
39
  default: {
40
40
  errors?: DeepReadonly<z.inferFormattedError<Schema>>;
41
- formData?: Partial<TypeOf<Schema>>;
41
+ formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type;
42
42
  formErrors?: DeepReadonly<inferFormattedError<Schema, string>>;
43
43
  invalid: boolean;
44
- submit?: InjectedFormData<Schema>["submit"];
45
- validate?: InjectedFormData<Schema>["validate"];
44
+ submit?: InjectedFormData<Schema, Type>["submit"];
45
+ validate?: InjectedFormData<Schema, Type>["validate"];
46
46
  validateWrapper?: () => Promise<boolean>;
47
47
  fieldsErrors: Map<string, inferFormattedError<Schema, string>>;
48
- clear?: InjectedFormData<Schema>["clear"];
49
- reset?: InjectedFormData<Schema>["reset"];
48
+ clear?: InjectedFormData<Schema, Type>["clear"];
49
+ reset?: InjectedFormData<Schema, Type>["reset"];
50
50
  };
51
51
  }>, {}, {}, "invalid" | "reset" | "clear" | "submit" | "errors" | "tag" | "validate" | "formData" | "fields" | "fieldsErrors" | "validateWrapper", import('vue').ComponentProvideOptions, true, {}, any>;