maz-ui 4.0.0-beta.12 → 4.0.0-beta.13

package/dist/composables/useFormField.js

@@ -63,7 +63,7 @@ function useFormField(name, options) {
     };
     onMounted(() => {
       const element = finalOpts.ref?.value, elementToBind = element instanceof HTMLElement ? element : element?.$el;
-      elementToBind instanceof HTMLElement ? handleInteractiveElements(elementToBind) : console.warn(`[maz-ui](useFormField) No element found for ref in field '${String(name)}'. Make sure the ref is properly bound to an HTMLElement or Vue component (form identifier: ${formOptions.identifier})`);
+      elementToBind instanceof HTMLElement ? handleInteractiveElements(elementToBind) : console.warn(`[maz-ui](useFormField) No element found for ref in field '${String(name)}'. Make sure the ref is properly bound to an HTMLElement or Vue component (form identifier: ${String(formOptions.identifier)})`);
     }), onUnmounted(() => {
       removeEventFromInteractiveElements({
         interactiveElements,

package/dist/composables/useFormValidator.js

@@ -29,7 +29,17 @@ function useFormValidator({ schema, defaultValues, model, options }) {
       payload: payload.value,
       options: opts
     })
-  ), isSubmitting = ref(!1), isSubmitted = ref(!1), isValid = computed(() => Object.values(fieldsStates.value).every(({ valid }) => valid)), isDirty = computed(() => Object.values(fieldsStates.value).some(({ dirty }) => dirty)), errors = computed(() => getFieldsErrors(fieldsStates.value)), errorMessages = computed(() => getErrorMessages(errors.value, fieldsStates.value));
+  ), isSubmitting = ref(!1), isSubmitted = ref(!1), isValid = computed(() => {
+    for (const key in fieldsStates.value)
+      if (!fieldsStates.value[key].valid)
+        return !1;
+    return !0;
+  }), isDirty = computed(() => {
+    for (const key in fieldsStates.value)
+      if (fieldsStates.value[key].dirty)
+        return !0;
+    return !1;
+  }), errors = computed(() => getFieldsErrors(fieldsStates.value)), errorMessages = computed(() => getErrorMessages(errors.value, fieldsStates.value));
   model && watch(
     payload,
     (newModel) => {
@@ -79,7 +89,13 @@ function useFormValidator({ schema, defaultValues, model, options }) {
           return fieldState && newSnapshot[name] !== oldSnapshot?.[name] && hasModeIncludes(["aggressive", "lazy", "progressive"], fieldState.mode);
         });
         if (fieldsToValidate.length > 0) {
-          const processValidations = createValidationProcessor(fieldsToValidate, fieldsStates, payload, internalSchema, isSubmitted);
+          const processValidations = createValidationProcessor(
+            fieldsToValidate,
+            fieldsStates,
+            payload,
+            internalSchema,
+            isSubmitted
+          );
           typeof requestIdleCallback < "u" ? requestIdleCallback(processValidations, { timeout: 100 }) : nextTick(processValidations);
         }
       },

package/dist/types/composables/useFormField.d.ts

@@ -1,18 +1,16 @@
-import { BaseFormPayload, ExtractModelKey, FormFieldOptions, FormSchema, ValidationIssues } from './useFormValidator/types';
-import { ComputedRef, Ref } from 'vue';
-import { getValidationEvents } from './useFormValidator/dom-events';
-interface UseFormFieldReturn<FieldType> {
-    hasError: ComputedRef<boolean>;
-    errors: ComputedRef<ValidationIssues>;
-    errorMessage: ComputedRef<string | undefined>;
-    isValid: ComputedRef<boolean>;
-    isDirty: ComputedRef<boolean>;
-    isBlurred: ComputedRef<boolean>;
-    isValidated: ComputedRef<boolean>;
-    isValidating: ComputedRef<boolean>;
-    mode: ComputedRef<FormFieldOptions<FieldType>['mode']>;
-    value: Ref<FieldType>;
-    validationEvents: ComputedRef<ReturnType<typeof getValidationEvents>>;
-}
-export declare function useFormField<FieldType, Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(name: ModelKey, options?: FormFieldOptions<FieldType>): UseFormFieldReturn<FieldType>;
-export {};
+import { BaseFormPayload, ExtractModelKey, FormFieldOptions, FormSchema } from './useFormValidator/types';
+export declare function useFormField<FieldType, Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(name: ModelKey, options?: FormFieldOptions<Model, ModelKey, FieldType>): {
+    hasError: import('vue').ComputedRef<boolean>;
+    errors: import('vue').ComputedRef<import('./useFormValidator/types').ValidationIssues>;
+    errorMessage: import('vue').ComputedRef<Record<ModelKey, string | undefined>[ModelKey]>;
+    isValid: import('vue').ComputedRef<boolean>;
+    isDirty: import('vue').ComputedRef<boolean>;
+    isBlurred: import('vue').ComputedRef<boolean>;
+    isValidated: import('vue').ComputedRef<boolean>;
+    isValidating: import('vue').ComputedRef<boolean>;
+    mode: import('vue').ComputedRef<"blur" | "eager" | "lazy" | "aggressive" | "progressive" | undefined>;
+    value: import('vue').WritableComputedRef<FieldType, FieldType>;
+    validationEvents: import('vue').ComputedRef<{
+        onBlur: () => void;
+    } | undefined>;
+};

package/dist/types/composables/useFormValidator/config.d.ts

@@ -1,6 +1,6 @@
-import { StrictOptions } from './types';
+import { BaseFormPayload, ExtractModelKey, FormSchema, StrictOptions } from './types';
 export declare const CONFIG: {
-    mode: StrictOptions['mode'];
+    mode: StrictOptions<BaseFormPayload, ExtractModelKey<FormSchema<BaseFormPayload>>>['mode'];
     scrollToErrorSelector: string;
     debounceTime: number;
     throttleTime: number;

package/dist/types/composables/useFormValidator/dom-events.d.ts

@@ -1,18 +1,18 @@
-import { BaseFormPayload, FieldState, StrictOptions } from './types';
+import { BaseFormPayload, ExtractModelKey, FieldState, FormSchema, StrictOptions } from './types';
 export declare function scrollToError(selector?: string): void;
 export declare function findInteractiveElements(el: HTMLElement): HTMLElement[];
 export declare function addEventToInteractiveElements({ interactiveElements, onBlur, mode, }: {
     interactiveElements: HTMLElement[];
     onBlur: () => void;
-    mode: StrictOptions['mode'];
+    mode: StrictOptions<BaseFormPayload, ExtractModelKey<FormSchema<BaseFormPayload>>>['mode'];
 }): void;
 export declare function removeEventFromInteractiveElements({ interactiveElements, onBlur, }: {
     interactiveElements: HTMLElement[];
     onBlur: () => void;
 }): void;
-export declare function getValidationEvents<Model extends BaseFormPayload>({ hasRef, fieldState, onBlur, }: {
+export declare function getValidationEvents<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>, F extends FieldState<Model, ModelKey, Model[ModelKey]>>({ hasRef, fieldState, onBlur, }: {
     hasRef?: boolean;
-    fieldState: FieldState<Model>;
+    fieldState: F;
     onBlur: () => void;
 }): {
     onBlur: () => void;

package/dist/types/composables/useFormValidator/state-management.d.ts

@@ -1,54 +1,72 @@
 import { InjectionKey } from 'vue';
 import { BaseFormPayload, CustomInstance, ExtractModelKey, FieldsStates, FieldState, FormContext, FormFieldOptions, FormSchema, StrictOptions } from './types';
-export declare function getFieldState<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, schema, initialValue, fieldState, options, }: {
+export declare function getFieldState<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]>({ name, schema, initialValue, fieldState, options, }: {
     name: ModelKey;
     schema?: FormSchema<Model>;
-    initialValue?: Model[ModelKey];
-    fieldState: FieldState<Model>;
-    options?: Pick<StrictOptions<Model>, 'debouncedFields' | 'throttledFields' | 'mode'>;
-}): FieldState<Model>;
+    initialValue?: FieldType;
+    fieldState: FieldState<Model, ModelKey, FieldType>;
+    options?: Pick<StrictOptions<Model, ModelKey>, 'debouncedFields' | 'throttledFields' | 'mode'>;
+}): FieldState<Model, ModelKey, FieldType>;
 export declare function fieldHasValidation<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>>(field: ModelKey, schema: FormSchema<Model>): boolean;
 export declare function getFieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ schema, payload, options, }: {
     schema: FormSchema<Model>;
     payload: Partial<Model>;
-    options: StrictOptions<Model>;
-}): FieldsStates<Model>;
+    options: StrictOptions<Model, ModelKey>;
+}): FieldsStates<Model, ModelKey>;
 export declare function updateFieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ fieldsStates, payload, schema, options, updateMode, }: {
-    fieldsStates: FieldsStates<Model>;
+    fieldsStates: FieldsStates<Model, ModelKey>;
     payload: Model;
     schema: FormSchema<Model>;
-    options: StrictOptions<Model>;
+    options: StrictOptions<Model, ModelKey>;
     updateMode?: boolean;
 }): void;
-export declare function updateFieldState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, fieldState, payload, schema, options, updateMode, }: {
+export declare function updateFieldState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]>({ name, fieldState, payload, schema, options, updateMode, }: {
     name: ModelKey;
-    fieldState: FieldState<Model>;
+    fieldState: FieldState<Model, ModelKey, FieldType>;
     payload: Model;
     schema: FormSchema<Model>;
-    options: FormFieldOptions<Model[ModelKey]> & StrictOptions<Model>;
+    options: FormFieldOptions<Model, ModelKey, FieldType> & StrictOptions<Model, ModelKey>;
     updateMode?: boolean;
-}): FieldState<Model>;
-export declare function canExecuteValidation<Model extends BaseFormPayload>({ eventName, fieldState, isSubmitted, }: {
+}): {
+    blurred: boolean;
+    dirty: boolean;
+    error: boolean;
+    errors: import('./types').ValidationIssues;
+    valid: boolean;
+    validating: boolean;
+    validated: boolean;
+    validateFunction: ((args_0: {
+        name: ModelKey;
+        fieldState: FieldState<Model, ModelKey, Model[ModelKey]>;
+        schema: FormSchema<Model>;
+        payload: Model;
+        setError?: boolean;
+        setErrorIfInvalidAndNotEmpty?: boolean;
+    }) => Promise<void>) | undefined;
+    initialValue: Readonly<FieldType> | undefined;
+    mode: "blur" | "eager" | "lazy" | "aggressive" | "progressive" | undefined;
+};
+export declare function canExecuteValidation<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]>({ eventName, fieldState, isSubmitted, }: {
     eventName: 'blur' | 'input';
-    fieldState: FieldState<Model>;
+    fieldState: FieldState<Model, ModelKey, FieldType>;
     isSubmitted: boolean;
 }): boolean;
-export declare function handleFieldBlur<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, force, payload, fieldState, schema, isSubmitted, }: {
+export declare function handleFieldBlur<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]>({ name, force, payload, fieldState, schema, isSubmitted, }: {
     name: ModelKey;
     payload: Model;
-    fieldState: FieldState<Model>;
+    fieldState: FieldState<Model, ModelKey, FieldType>;
     schema: FormSchema<Model>;
     isSubmitted: boolean;
     force?: boolean;
 }): Promise<void> | undefined;
-export declare function handleFieldInput<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, payload, fieldState, schema, isSubmitted, forceValidation, }: {
+export declare function handleFieldInput<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]>({ name, payload, fieldState, schema, isSubmitted, forceValidation, }: {
     name: ModelKey;
     payload: Model;
-    fieldState: FieldState<Model>;
+    fieldState: FieldState<Model, ModelKey, FieldType>;
     schema: FormSchema<Model>;
     isSubmitted: boolean;
     forceValidation?: boolean;
 }): Promise<void> | undefined;
-export declare function hasModeIncludes(modes: StrictOptions['mode'][], value?: StrictOptions['mode']): value is StrictOptions['mode'];
-export declare function getInstance<Model extends BaseFormPayload>(composableName: string): CustomInstance<Model>;
-export declare function getContext<Model extends BaseFormPayload>(identifier: string | symbol | InjectionKey<FormContext<Model>>, composableName: string): FormContext<Model, Extract<keyof { [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? K : never]: import('./types').Validation; }, string> | Extract<keyof { [K_1 in Extract<keyof Model, string> as Model[K_1] extends Required<Model>[K_1] ? never : K_1]?: import('./types').Validation | undefined; }, string>>;
+export declare function hasModeIncludes<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(modes: StrictOptions<Model, ModelKey>['mode'][], value?: StrictOptions<Model, ModelKey>['mode']): value is StrictOptions<Model, ModelKey>['mode'];
+export declare function getInstance<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(composableName: string): CustomInstance<Model, ModelKey>;
+export declare function getContext<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(identifier: string | symbol | InjectionKey<FormContext<Model, ModelKey>>, composableName: string): FormContext<Model, ModelKey>;

package/dist/types/composables/useFormValidator/types.d.ts

@@ -4,13 +4,13 @@ import { getValidateFunction } from './validation';
 export type Validation = BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
 export type ValidationIssues = InferIssue<Validation>[];
 export type ExtractModelKey<T> = Extract<keyof T, string>;
-export type FormSchema<Model = BaseFormPayload> = {
+export type FormSchema<Model extends BaseFormPayload> = {
     [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? K : never]: Validation;
 } & {
     [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? never : K]?: Validation;
 };
-export type CustomInstance<Model extends BaseFormPayload> = ComponentInternalInstance & {
-    formContexts?: Map<string | symbol | InjectionKey<FormContext<Model>>, FormContext<Model>>;
+export type CustomInstance<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>> = ComponentInternalInstance & {
+    formContexts?: Map<string | symbol | InjectionKey<FormContext<Model, ModelKey>>, FormContext<Model, ModelKey>>;
 };
 export interface FormValidatorOptions<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>> {
     /**
@@ -48,16 +48,16 @@ export interface FormValidatorOptions<Model extends BaseFormPayload = BaseFormPa
      */
     identifier?: string | symbol;
 }
-export type StrictOptions<Model extends BaseFormPayload = BaseFormPayload> = Required<FormValidatorOptions<Model>>;
-export interface FormContext<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>> {
-    fieldsStates: Ref<FieldsStates<Model>>;
-    options: StrictOptions;
+export type StrictOptions<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>> = Required<FormValidatorOptions<Model, ModelKey>>;
+export interface FormContext<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>> {
+    fieldsStates: Ref<FieldsStates<Model, ModelKey>>;
+    options: StrictOptions<Model, ModelKey>;
     internalSchema: Ref<FormSchema<Model>>;
     payload: Ref<Model>;
     errorMessages: Ref<Record<ModelKey, string | undefined>>;
     isSubmitted: Ref<boolean>;
 }
-export interface FieldState<Model extends BaseFormPayload, FieldType = Model[ExtractModelKey<FormSchema<Model>>]> {
+export interface FieldState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]> {
     blurred: boolean;
     dirty: boolean;
     error: boolean;
@@ -66,12 +66,12 @@ export interface FieldState<Model extends BaseFormPayload, FieldType = Model[Ext
     initialValue?: Readonly<FieldType>;
     validating: boolean;
     validated: boolean;
-    validateFunction: ReturnType<typeof getValidateFunction<Model>>;
-    mode?: StrictOptions['mode'];
+    validateFunction: ReturnType<typeof getValidateFunction<Model, ModelKey>>;
+    mode?: StrictOptions<Model, ModelKey>['mode'];
 }
-export type FieldsStates<Model extends BaseFormPayload = BaseFormPayload> = Record<ExtractModelKey<Model>, FieldState<Model>>;
+export type FieldsStates<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>> = Record<ModelKey, FieldState<Model, ModelKey, Model[ModelKey]>>;
 export type BaseFormPayload = Record<string, any>;
-export interface FormFieldOptions<FieldType> {
+export interface FormFieldOptions<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>, FieldType> {
     /**
      * Default value of the field
      * @default undefined
@@ -81,7 +81,7 @@ export interface FormFieldOptions<FieldType> {
      * Validation mode
      * To override the form validation mode
      */
-    mode?: StrictOptions['mode'];
+    mode?: StrictOptions<Model, ModelKey>['mode'];
     /**
      * Reference to the component or HTML element to associate and trigger validation events
      * Necessary for 'eager', 'progressive' and 'blur' validation modes

package/dist/types/composables/useFormValidator/validation.d.ts

@@ -2,40 +2,34 @@ import { BaseFormPayload, ExtractModelKey, FieldsStates, FieldState, FormSchema,
 export declare function isEmptyValue(value: unknown): value is null | undefined | '';
 export declare function getValibotValidationMethod<MethodName extends keyof typeof import('valibot')>(methodName: MethodName): Promise<(typeof import('valibot'))[MethodName]>;
 export declare function getValidationSchema<Model extends BaseFormPayload>(formSchema: FormSchema<Model>): Promise<import('valibot').ObjectSchemaAsync<FormSchema<Model>, undefined>>;
-export declare function getFieldValidationResult<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(name: ModelKey, schema: FormSchema<Model>, value: Model[ModelKey]): Promise<{
+export declare function getFieldValidationResult<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>>(name: ModelKey, schema: FormSchema<Model>, value: Model[ModelKey]): Promise<{
     result: import('valibot').SafeParseResult<FormSchema<Model>[ModelKey]>;
     isValid: boolean;
 }>;
-export declare function setFieldValidationState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, fieldState, schema, payload, setError, setErrorIfInvalidAndNotEmpty, }: {
+export declare function setFieldValidationState<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>>({ name, fieldState, schema, payload, setError, setErrorIfInvalidAndNotEmpty, }: {
     name: ModelKey;
-    fieldState: FieldState<Model>;
+    fieldState: FieldState<Model, ModelKey, Model[ModelKey]>;
     schema: FormSchema<Model>;
     payload: Model;
     setError?: boolean;
     setErrorIfInvalidAndNotEmpty?: boolean;
 }): Promise<void>;
-export declare function validateField<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, fieldState, payload, schema, }: {
-    name: ModelKey;
-    fieldState: FieldState<Model>;
-    payload: Model;
-    schema: FormSchema<Model>;
-}): Promise<void> | undefined;
 export declare function validateForm<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ fieldsStates, payload, setErrors, schema, }: {
-    fieldsStates: FieldsStates<Model>;
+    fieldsStates: FieldsStates<Model, ExtractModelKey<FormSchema<Model>>>;
     setErrors?: boolean;
     payload: Model;
     schema: FormSchema<Model>;
 }): Promise<void[]>;
-export declare function getErrorMessages<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(errors: Record<ModelKey, ValidationIssues>, fieldsStates: FieldsStates<Model>): Record<ModelKey, string | undefined>;
-export declare function getFieldsErrors<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(fieldsStates: FieldsStates<Model>): Record<ModelKey, ValidationIssues>;
+export declare function getErrorMessages<Model extends BaseFormPayload = BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(errors: Record<ModelKey, ValidationIssues>, fieldsStates: FieldsStates<Model, ExtractModelKey<FormSchema<Model>>>): Record<ModelKey, string | undefined>;
+export declare function getFieldsErrors<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>(fieldsStates: FieldsStates<Model, ExtractModelKey<FormSchema<Model>>>): Record<ModelKey, ValidationIssues>;
 export declare function getValidateFunction<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ name, hasValidation, debouncedFields, throttledFields, }: {
     name: ModelKey;
     hasValidation: boolean;
-    debouncedFields?: StrictOptions<Model>['debouncedFields'];
-    throttledFields?: StrictOptions<Model>['throttledFields'];
+    debouncedFields?: StrictOptions<Model, ModelKey>['debouncedFields'];
+    throttledFields?: StrictOptions<Model, ModelKey>['throttledFields'];
 }): ((args_0: {
-    name: ExtractModelKey<FormSchema<Model>>;
-    fieldState: FieldState<Model, Model[Extract<keyof { [K in Extract<keyof Model, string> as Model[K] extends Required<Model>[K] ? K : never]: import('./types').Validation; }, string> | Extract<keyof { [K_1 in Extract<keyof Model, string> as Model[K_1] extends Required<Model>[K_1] ? never : K_1]?: import('./types').Validation | undefined; }, string>]>;
+    name: ModelKey;
+    fieldState: FieldState<Model, ModelKey, Model[ModelKey]>;
     schema: FormSchema<Model>;
     payload: Model;
     setError?: boolean;

package/dist/types/composables/useFormValidator.d.ts

@@ -15,7 +15,7 @@ export declare function useFormValidator<TSchema extends MaybeRefOrGetter<FormSc
     isValid: import('vue').ComputedRef<boolean>;
     errors: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<InferSchemaFormValidator<TSchema>>>, import('./useFormValidator/types').ValidationIssues>>;
     model: Ref<InferSchemaFormValidator<TSchema>, InferSchemaFormValidator<TSchema>>;
-    fieldsStates: Ref<FieldsStates<InferSchemaFormValidator<TSchema>>, FieldsStates<InferSchemaFormValidator<TSchema>>>;
+    fieldsStates: Ref<FieldsStates<InferSchemaFormValidator<TSchema>, ExtractModelKey<FormSchema<InferSchemaFormValidator<TSchema>>>>, FieldsStates<InferSchemaFormValidator<TSchema>, ExtractModelKey<FormSchema<InferSchemaFormValidator<TSchema>>>>>;
     validateForm: (setErrors?: boolean) => Promise<void[]>;
     scrollToError: typeof scrollToError;
     handleSubmit: <Func extends (model: InferOutputSchemaFormValidator<TSchema>) => Promise<Awaited<ReturnType<Func>>> | ReturnType<Func>>(successCallback: Func, enableScrollOrSelector?: FormValidatorOptions["scrollToError"]) => (event?: Event) => Promise<ReturnType<Func> | undefined>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maz-ui",
   "type": "module",
-  "version": "4.0.0-beta.12",
+  "version": "4.0.0-beta.13",
   "description": "A standalone components library for Vue.Js 3 & Nuxt.Js 3",
   "author": "Louis Mazel <me@loicmazuel.com>",
   "license": "MIT",
@@ -240,5 +240,5 @@
     "*.{js,ts,vue,mjs,mts,cjs,md,yml,json}": "cross-env NODE_ENV=production eslint --fix",
     "*.{vue,css,scss,postcss,pcss}": "stylelint --fix --allow-empty-input"
   },
-  "gitHead": "7664d25d6f0aeb087b186599a983b0f1303b178a"
+  "gitHead": "9f0dc4d0f42b64d34290fc328458e94fc977a2ff"
 }