@volverjs/form-vue 1.0.0-beta.15 → 1.0.0-beta.17

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 (19) hide show
  1. package/dist/VvForm.d.ts +62 -166
  2. package/dist/VvFormField.d.ts +40 -28
  3. package/dist/VvFormTemplate.d.ts +25 -68
  4. package/dist/VvFormWrapper.d.ts +38 -95
  5. package/dist/enums.d.ts +1 -0
  6. package/dist/index.d.ts +580 -1120
  7. package/dist/index.es.js +501 -436
  8. package/dist/index.umd.js +1 -1
  9. package/dist/types.d.ts +4 -2
  10. package/dist/utils.d.ts +0 -1
  11. package/package.json +18 -18
  12. package/src/VvForm.ts +112 -75
  13. package/src/VvFormField.ts +69 -41
  14. package/src/VvFormTemplate.ts +129 -137
  15. package/src/VvFormWrapper.ts +60 -62
  16. package/src/enums.ts +1 -0
  17. package/src/index.ts +32 -28
  18. package/src/types.ts +31 -28
  19. package/src/utils.ts +1 -1
package/dist/VvForm.d.ts CHANGED
@@ -1,148 +1,53 @@
1
- import { Component, InjectionKey, DeepReadonly, Ref, PropType, WatchStopHandle } from 'vue';
2
- import { IgnoredUpdater } from '@vueuse/core';
1
+ import { Component, InjectionKey, PropType, SlotsType } from 'vue';
3
2
  import { z } from 'zod';
4
3
  import { FormComponentOptions, FormSchema, FormTemplate, InjectedFormData } from './types';
5
4
  import { FormStatus } from './enums';
6
-
7
5
  export declare function defineForm<Schema extends FormSchema>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema>>, options?: FormComponentOptions<Schema>, VvFormTemplate?: Component): {
8
- errors: Ref<z.inferFormattedError<Schema, string> | undefined>;
9
- status: Ref<FormStatus | undefined>;
6
+ clear: () => void;
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>>;
9
+ ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
10
10
  invalid: import('vue').ComputedRef<boolean>;
11
- readonly: Ref<boolean>;
12
- formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
13
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
11
+ readonly: import('vue').Ref<boolean, boolean>;
12
+ reset: () => void;
13
+ status: import('vue').Ref<FormStatus | undefined, FormStatus | undefined>;
14
+ stopUpdatesWatch: import('vue').WatchStopHandle;
14
15
  submit: () => Promise<boolean>;
15
- ignoreUpdates: IgnoredUpdater;
16
- stopUpdatesWatch: WatchStopHandle;
17
- /**
18
- * An hack to add types to the default slot
19
- */
20
- VvForm: {
21
- new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import('vue').ExtractPropTypes<{
22
- continuousValidation: {
23
- type: BooleanConstructor;
24
- default: boolean;
25
- };
26
- modelValue: {
27
- type: ObjectConstructor;
28
- default: () => {};
29
- };
30
- readonly: {
31
- type: BooleanConstructor;
32
- default: boolean;
33
- };
34
- tag: {
35
- type: StringConstructor;
36
- default: string;
37
- };
38
- template: {
39
- type: PropType<FormTemplate<Schema>>;
40
- default: undefined;
41
- };
42
- }>> & {
43
- onInvalid?: ((...args: any[]) => any) | undefined;
44
- onValid?: ((...args: any[]) => any) | undefined;
45
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
46
- onSubmit?: ((...args: any[]) => any) | undefined;
47
- "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
48
- }, {
49
- formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
50
- submit: () => Promise<boolean>;
51
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
52
- ignoreUpdates: IgnoredUpdater;
53
- stopUpdatesWatch: WatchStopHandle;
54
- errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
55
- status: Readonly<Ref<FormStatus | undefined>>;
56
- invalid: import('vue').ComputedRef<boolean>;
57
- isReadonly: Ref<boolean>;
58
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
59
- continuousValidation: {
60
- type: BooleanConstructor;
61
- default: boolean;
62
- };
63
- modelValue: {
64
- type: ObjectConstructor;
65
- default: () => {};
66
- };
67
- readonly: {
68
- type: BooleanConstructor;
69
- default: boolean;
70
- };
71
- tag: {
72
- type: StringConstructor;
73
- default: string;
74
- };
75
- template: {
76
- type: PropType<FormTemplate<Schema>>;
77
- default: undefined;
78
- };
79
- }>> & {
80
- onInvalid?: ((...args: any[]) => any) | undefined;
81
- onValid?: ((...args: any[]) => any) | undefined;
82
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
83
- onSubmit?: ((...args: any[]) => any) | undefined;
84
- "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
85
- }, {
86
- readonly: boolean;
87
- template: FormTemplate<Schema>;
88
- modelValue: Record<string, any>;
89
- continuousValidation: boolean;
90
- tag: string;
91
- }, true, {}, {}, {
92
- P: {};
93
- B: {};
94
- D: {};
95
- C: {};
96
- M: {};
97
- Defaults: {};
98
- }, Readonly<import('vue').ExtractPropTypes<{
99
- continuousValidation: {
100
- type: BooleanConstructor;
101
- default: boolean;
102
- };
103
- modelValue: {
104
- type: ObjectConstructor;
105
- default: () => {};
106
- };
107
- readonly: {
108
- type: BooleanConstructor;
109
- default: boolean;
110
- };
111
- tag: {
112
- type: StringConstructor;
113
- default: string;
114
- };
115
- template: {
116
- type: PropType<FormTemplate<Schema>>;
117
- default: undefined;
118
- };
119
- }>> & {
120
- onInvalid?: ((...args: any[]) => any) | undefined;
121
- onValid?: ((...args: any[]) => any) | undefined;
122
- "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
123
- onSubmit?: ((...args: any[]) => any) | undefined;
124
- "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
125
- }, {
126
- formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
127
- submit: () => Promise<boolean>;
128
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
129
- ignoreUpdates: IgnoredUpdater;
130
- stopUpdatesWatch: WatchStopHandle;
131
- errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
132
- status: Readonly<Ref<FormStatus | undefined>>;
133
- invalid: import('vue').ComputedRef<boolean>;
134
- isReadonly: Ref<boolean>;
135
- }, {}, {}, {}, {
136
- readonly: boolean;
137
- template: FormTemplate<Schema>;
138
- modelValue: Record<string, any>;
139
- continuousValidation: boolean;
140
- tag: string;
141
- }>;
142
- __isFragment?: undefined;
143
- __isTeleport?: undefined;
144
- __isSuspense?: undefined;
145
- } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
16
+ validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
17
+ VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
18
+ continuousValidation: {
19
+ type: BooleanConstructor;
20
+ default: boolean;
21
+ };
22
+ modelValue: {
23
+ type: ObjectConstructor;
24
+ default: () => {};
25
+ };
26
+ readonly: {
27
+ type: BooleanConstructor;
28
+ default: boolean;
29
+ };
30
+ tag: {
31
+ type: StringConstructor;
32
+ default: string;
33
+ };
34
+ template: {
35
+ type: PropType<FormTemplate<Schema>>;
36
+ default: undefined;
37
+ };
38
+ }>, {
39
+ clear: () => void;
40
+ 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
+ ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
43
+ invalid: import('vue').ComputedRef<boolean>;
44
+ isReadonly: import('vue').Ref<boolean, boolean>;
45
+ reset: () => void;
46
+ status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
47
+ stopUpdatesWatch: import('vue').WatchStopHandle;
48
+ submit: () => Promise<boolean>;
49
+ validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
50
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "update:modelValue" | "submit" | "update:readonly")[], "invalid" | "valid" | "reset" | "update:modelValue" | "submit" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
146
51
  continuousValidation: {
147
52
  type: BooleanConstructor;
148
53
  default: boolean;
@@ -163,41 +68,32 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
163
68
  type: PropType<FormTemplate<Schema>>;
164
69
  default: undefined;
165
70
  };
166
- }>> & {
71
+ }>> & Readonly<{
167
72
  onInvalid?: ((...args: any[]) => any) | undefined;
168
73
  onValid?: ((...args: any[]) => any) | undefined;
169
74
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
75
+ onReset?: ((...args: any[]) => any) | undefined;
170
76
  onSubmit?: ((...args: any[]) => any) | undefined;
171
77
  "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
172
- }, {
173
- formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
174
- submit: () => Promise<boolean>;
175
- validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
176
- ignoreUpdates: IgnoredUpdater;
177
- stopUpdatesWatch: WatchStopHandle;
178
- errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
179
- status: Readonly<Ref<FormStatus | undefined>>;
180
- invalid: import('vue').ComputedRef<boolean>;
181
- isReadonly: Ref<boolean>;
182
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly")[], "invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly", {
78
+ }>, {
183
79
  readonly: boolean;
184
80
  template: FormTemplate<Schema>;
185
81
  modelValue: Record<string, any>;
186
- continuousValidation: boolean;
187
82
  tag: string;
188
- }, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
189
- $slots: {
190
- default: (_: {
191
- formData: unknown extends Partial<z.TypeOf<Schema>> | undefined ? undefined : Partial<z.TypeOf<Schema>> | undefined;
192
- submit: () => Promise<boolean>;
193
- validate: () => Promise<boolean>;
194
- ignoreUpdates: IgnoredUpdater;
195
- stopUpdatesWatch: WatchStopHandle;
196
- errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
197
- status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
198
- invalid: Ref<DeepReadonly<boolean>>;
199
- readonly: Ref<boolean>;
200
- }) => any;
83
+ continuousValidation: boolean;
84
+ }, SlotsType<{
85
+ default: {
86
+ 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>>;
88
+ ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
89
+ invalid: import('vue').ComputedRef<boolean>;
90
+ readonly: import('vue').Ref<boolean, boolean>;
91
+ status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
92
+ stopUpdatesWatch: import('vue').WatchStopHandle;
93
+ submit: () => Promise<boolean>;
94
+ validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
95
+ clear: () => void;
96
+ reset: () => void;
201
97
  };
202
- });
98
+ }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "clear" | "errors" | "submit" | "validate" | "readonly" | "template" | "tag", import('vue').ComponentProvideOptions, true, {}, any>;
203
99
  };
package/dist/VvFormField.d.ts CHANGED
@@ -1,24 +1,23 @@
1
- import { Component, InjectionKey, PropType, Ref, ConcreteComponent } from 'vue';
2
- import { z } from 'zod';
1
+ import { Component, ConcreteComponent, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
2
+ import { inferFormattedError, TypeOf, z } from 'zod';
3
3
  import { FormFieldType } from './enums';
4
- import { InjectedFormData, InjectedFormWrapperData, InjectedFormFieldData, FormFieldComponentOptions, Path, FormSchema } from './types';
5
-
6
- export declare function defineFormField<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions): import('vue').DefineComponent<{
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<{
7
6
  type: {
8
- type: PropType<"number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom">;
7
+ type: PropType<`${FormFieldType}`>;
9
8
  validator: (value: FormFieldType) => boolean;
10
9
  default: FormFieldType;
11
10
  };
12
11
  is: {
13
- type: PropType<string | Component>;
12
+ type: PropType<Component | string>;
14
13
  default: undefined;
15
14
  };
16
15
  name: {
17
- type: PropType<Path<z.TypeOf<Schema>>>;
16
+ type: PropType<Path<z.infer<Schema>>>;
18
17
  required: true;
19
18
  };
20
19
  props: {
21
- type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
20
+ type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
22
21
  default: () => {};
23
22
  };
24
23
  showValid: {
@@ -37,19 +36,19 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
37
36
  type: BooleanConstructor;
38
37
  default: undefined;
39
38
  };
40
- }, {
39
+ }>, {
41
40
  component: import('vue').ComputedRef<{
42
41
  new (...args: any[]): any;
43
- __isFragment?: undefined;
44
- __isTeleport?: undefined;
45
- __isSuspense?: undefined;
42
+ __isFragment?: never;
43
+ __isTeleport?: never;
44
+ __isSuspense?: never;
46
45
  } | ConcreteComponent>;
47
46
  hasProps: import('vue').ComputedRef<{
48
47
  name: {} | ([{
49
- type: PropType<Path<z.TypeOf<Schema>>>;
48
+ type: PropType<Path<z.infer<Schema>>>;
50
49
  required: true;
51
- }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? import('@vue/shared').IfAny<V, V, D> : V : {
52
- type: PropType<Path<z.TypeOf<Schema>>>;
50
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
51
+ type: PropType<Path<z.infer<Schema>>>;
53
52
  required: true;
54
53
  });
55
54
  invalid: boolean;
@@ -57,26 +56,26 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
57
56
  type: FormFieldType | undefined;
58
57
  invalidLabel: any;
59
58
  modelValue: any;
60
- readonly: {} | undefined;
59
+ readonly: boolean;
61
60
  'onUpdate:modelValue': (value: unknown) => void;
62
61
  }>;
63
62
  invalid: import('vue').ComputedRef<boolean>;
64
- }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:formData" | "update:modelValue")[], "invalid" | "valid" | "update:formData" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
63
+ }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:formData" | "update:modelValue")[], "invalid" | "valid" | "update:formData" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
65
64
  type: {
66
- type: PropType<"number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom">;
65
+ type: PropType<`${FormFieldType}`>;
67
66
  validator: (value: FormFieldType) => boolean;
68
67
  default: FormFieldType;
69
68
  };
70
69
  is: {
71
- type: PropType<string | Component>;
70
+ type: PropType<Component | string>;
72
71
  default: undefined;
73
72
  };
74
73
  name: {
75
- type: PropType<Path<z.TypeOf<Schema>>>;
74
+ type: PropType<Path<z.infer<Schema>>>;
76
75
  required: true;
77
76
  };
78
77
  props: {
79
- type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
78
+ type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
80
79
  default: () => {};
81
80
  };
82
81
  showValid: {
@@ -95,18 +94,18 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
95
94
  type: BooleanConstructor;
96
95
  default: undefined;
97
96
  };
98
- }>> & {
97
+ }>> & Readonly<{
99
98
  onInvalid?: ((...args: any[]) => any) | undefined;
100
99
  onValid?: ((...args: any[]) => any) | undefined;
101
100
  "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
102
101
  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
103
- }, {
102
+ }>, {
104
103
  type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
105
104
  props: [{
106
- type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
105
+ type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
107
106
  default: () => {};
108
- }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? import('@vue/shared').IfAny<V, V, D> : V : {
109
- type: PropType<Partial<z.TypeOf<Schema> | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined) | undefined>>;
107
+ }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
108
+ type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
110
109
  default: () => {};
111
110
  };
112
111
  is: string | Component;
@@ -114,4 +113,17 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
114
113
  defaultValue: string | number | boolean | unknown[] | Record<string, any>;
115
114
  lazyLoad: boolean;
116
115
  readonly: boolean;
117
- }, {}>;
116
+ }, SlotsType<{
117
+ default: {
118
+ errors: z.inferFormattedError<Schema>;
119
+ formData?: Partial<TypeOf<Schema>>;
120
+ formErrors?: DeepReadonly<inferFormattedError<Schema, string>>;
121
+ invalid: boolean;
122
+ invalidLabel: string;
123
+ modelValue: unknown;
124
+ onUpdate: (value: unknown) => void;
125
+ readonly: boolean;
126
+ submit?: InjectedFormData<Schema>["submit"];
127
+ validate?: InjectedFormData<Schema>["validate"];
128
+ };
129
+ }>, {}, {}, "invalid" | "type" | "component" | "errors" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;
package/dist/VvFormTemplate.d.ts CHANGED
@@ -1,60 +1,8 @@
1
- import { Component, PropType, InjectionKey, DeepReadonly, Ref, VNode } from 'vue';
2
- import { TypeOf, z } from 'zod';
1
+ import { Component, DeepReadonly, InjectionKey, PropType, SlotsType, VNode } from 'vue';
3
2
  import { FormSchema, InjectedFormData, FormTemplate } from './types';
3
+ import { inferFormattedError, TypeOf } from 'zod';
4
4
  import { FormStatus } from './enums';
5
-
6
- export declare function defineFormTemplate<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, VvFormField: Component): {
7
- new (...args: any[]): import('vue').CreateComponentPublicInstance<Readonly<import('vue').ExtractPropTypes<{
8
- schema: {
9
- type: PropType<FormTemplate<Schema>>;
10
- required: true;
11
- };
12
- scope: {
13
- type: PropType<Record<string, unknown>>;
14
- default: () => {};
15
- };
16
- }>>, (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
17
- [key: string]: any;
18
- }> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
19
- [key: string]: any;
20
- }>[] | undefined)[]) | undefined, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
21
- schema: {
22
- type: PropType<FormTemplate<Schema>>;
23
- required: true;
24
- };
25
- scope: {
26
- type: PropType<Record<string, unknown>>;
27
- default: () => {};
28
- };
29
- }>>, {
30
- scope: Record<string, unknown>;
31
- }, true, {}, {}, {
32
- P: {};
33
- B: {};
34
- D: {};
35
- C: {};
36
- M: {};
37
- Defaults: {};
38
- }, Readonly<import('vue').ExtractPropTypes<{
39
- schema: {
40
- type: PropType<FormTemplate<Schema>>;
41
- required: true;
42
- };
43
- scope: {
44
- type: PropType<Record<string, unknown>>;
45
- default: () => {};
46
- };
47
- }>>, {} | (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
48
- [key: string]: any;
49
- }> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
50
- [key: string]: any;
51
- }>[] | undefined)[]), {}, {}, {}, {
52
- scope: Record<string, unknown>;
53
- }>;
54
- __isFragment?: undefined;
55
- __isTeleport?: undefined;
56
- __isSuspense?: undefined;
57
- } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
5
+ export declare function defineFormTemplate<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, VvFormField: Component): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
58
6
  schema: {
59
7
  type: PropType<FormTemplate<Schema>>;
60
8
  required: true;
@@ -63,21 +11,30 @@ export declare function defineFormTemplate<Schema extends FormSchema>(formProvid
63
11
  type: PropType<Record<string, unknown>>;
64
12
  default: () => {};
65
13
  };
66
- }>>, (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
14
+ }>, (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
67
15
  [key: string]: any;
68
16
  }> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
69
17
  [key: string]: any;
70
- }>[] | undefined)[]) | undefined, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
18
+ }>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
19
+ schema: {
20
+ type: PropType<FormTemplate<Schema>>;
21
+ required: true;
22
+ };
23
+ scope: {
24
+ type: PropType<Record<string, unknown>>;
25
+ default: () => {};
26
+ };
27
+ }>> & Readonly<{}>, {
71
28
  scope: Record<string, unknown>;
72
- }, {}, string, {}> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
73
- $slots: {
74
- default: (_: {
75
- formData: unknown extends Partial<TypeOf<Schema>> | undefined ? undefined : Partial<TypeOf<Schema>> | undefined;
76
- submit: () => Promise<boolean>;
77
- validate: () => Promise<boolean>;
78
- errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
79
- status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
80
- invalid: Ref<DeepReadonly<boolean>>;
81
- }) => any;
29
+ }, SlotsType<{
30
+ default: {
31
+ errors?: DeepReadonly<inferFormattedError<Schema, string>>;
32
+ formData?: Partial<TypeOf<Schema>>;
33
+ invalid: boolean;
34
+ status?: FormStatus;
35
+ submit?: InjectedFormData<Schema>["submit"];
36
+ validate?: InjectedFormData<Schema>["validate"];
37
+ clear?: InjectedFormData<Schema>["clear"];
38
+ reset?: InjectedFormData<Schema>["reset"];
82
39
  };
83
- });
40
+ }>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;