maz-ui 4.0.0-beta.2 → 4.0.0-beta.21

package/dist/types/components/MazSelectCountry.vue.d.ts

@@ -1,12 +1,15 @@
 import { MazTranslationsNestedSchema } from '@maz-ui/translations/src/types.js';
 import { HTMLAttributes } from 'vue';
-import { PopoverPosition } from './MazPopover.vue';
-import { MazColor, MazSize } from './types';
 import { CodesType, DisplayNameCode, DisplayNamesOptions } from '../composables/useDisplayNames';
+import { MazPopoverPosition } from './MazPopover.vue';
 import { MazSelectProps } from './MazSelect.vue';
+import { MazColor, MazSize } from './types';
 export interface MazSelectCountryProps<Option extends {
     name: string;
     code: DisplayNameCode | string;
+} = {
+    name: string;
+    code: string;
 }> extends Omit<MazSelectProps<Option['code'], Option, false>, 'options' | 'multiple'> {
     /**
      * Style attribut of the component root element
@@ -54,7 +57,7 @@ export interface MazSelectCountryProps<Option extends {
      * @type {PopoverPosition}
      * @default bottom-start
      */
-    listPosition?: PopoverPosition;
+    listPosition?: MazPopoverPosition;
     /**
      * Hide flags
      */
@@ -89,7 +92,7 @@ export interface MazSelectCountryProps<Option extends {
      */
     warning?: boolean;
     /**
-     * Country selector display name
+     *
      */
     displayCode?: boolean;
     /**
@@ -124,6 +127,12 @@ export interface MazSelectCountryProps<Option extends {
      * @values 'iso' | 'bcp' | 'country' | 'all'
      */
     codesType?: CodesType;
+    /**
+     * Open the select
+     * @type {boolean}
+     * @default false
+     */
+    open?: boolean;
 }
 declare const _default: <Option extends {
     name: string;

package/dist/types/components/MazStepper.vue.d.ts

@@ -33,13 +33,24 @@ export interface MazStepperProps {
     /** Allow to close the steps */
     canCloseSteps?: boolean;
 }
-declare function __VLS_template(): any;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`icon-${number}`, (_: {}) => any>> & Partial<Record<`title-${number}`, (_: {}) => any>> & Partial<Record<`subtitle-${number}`, (_: {}) => any>> & Partial<Record<`title-info-${number}`, (_: {}) => any>> & Partial<Record<`content-${number}`, (_: {
+        validated: boolean;
+        error: boolean | undefined;
+        warning: boolean | undefined;
+        nextStep: () => void;
+        previousStep: () => void;
+    }) => any>>;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<MazStepperProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:model-value": (value: number) => any;
 }, string, import('vue').PublicProps, Readonly<MazStepperProps> & Readonly<{
     "onUpdate:model-value"?: ((value: number) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/types/components/MazTable.vue.d.ts

@@ -244,10 +244,71 @@ declare const _default: <T extends MazTableRow<T>>(__VLS_props: NonNullable<Awai
         readonly "onUpdate:search-query"?: ((searchQuery: string | undefined) => any) | undefined;
         readonly "onUpdate:page"?: ((page: number) => any) | undefined;
         readonly "onUpdate:page-size"?: ((pageSize: number) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:model-value" | "onUpdate:search-query" | "onUpdate:page" | "onUpdate:page-size"> & MazTableProps<T> & any> & import('vue').PublicProps;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:model-value" | "onUpdate:search-query" | "onUpdate:page" | "onUpdate:page-size"> & MazTableProps<T> & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
     attrs: any;
-    slots: any;
+    slots: Partial<Record<`header-label-${string}`, (_: {
+        header: {
+            label: string;
+            key?: string | undefined;
+            sortable?: boolean | undefined;
+            hidden?: boolean | undefined;
+            srOnly?: boolean | undefined;
+            width?: string | undefined;
+            maxWidth?: string | undefined;
+            classes?: ThHTMLAttributes["class"];
+            scope?: string | undefined;
+            align?: "justify" | "center" | "left" | "right" | "char" | undefined;
+            rowspan?: (string | number) | undefined;
+            colspan?: (string | number) | undefined;
+            headers?: string | undefined;
+            thHeaders?: string | undefined;
+            sorted?: "ASC" | "DESC" | undefined;
+        };
+        label: string;
+    }) => any>> & Partial<Record<`cell-${string}`, (_: {
+        row: T;
+        value: any;
+    }) => any>> & {
+        title?(_: {}): any;
+        caption?(_: {}): any;
+        thead?(_: {}): any;
+        header?(_: {
+            header: {
+                label: string;
+                key?: string | undefined;
+                sortable?: boolean | undefined;
+                hidden?: boolean | undefined;
+                srOnly?: boolean | undefined;
+                width?: string | undefined;
+                maxWidth?: string | undefined;
+                classes?: ThHTMLAttributes["class"];
+                scope?: string | undefined;
+                align?: "justify" | "center" | "left" | "right" | "char" | undefined;
+                rowspan?: (string | number) | undefined;
+                colspan?: (string | number) | undefined;
+                headers?: string | undefined;
+                thHeaders?: string | undefined;
+                sorted?: "ASC" | "DESC" | undefined;
+            };
+            label: string;
+        }): any;
+        'actions-header'?(_: {}): any;
+        default?(_: {}): any;
+        select?(_: {
+            row: T;
+            selected: boolean | undefined;
+        }): any;
+        cell?(_: {
+            row: T;
+            value: any;
+        }): any;
+        actions?(_: {
+            row: T;
+        }): any;
+        'no-results'?(_: {}): any;
+        'no-results-text'?(_: {}): any;
+    };
     emit: {
         (event: "update:model-value", value: (MazTableRow<T> | string | number | boolean)[] | undefined): void;
         (event: "update:search-query", searchQuery: string | undefined): void;

package/dist/types/components/index.d.ts

@@ -34,12 +34,12 @@ export { default as MazDatePicker } from './MazDatePicker.vue';
 export type { MazDatePickerPartialRangeValue, MazDatePickerProps, MazDatePickerRangeValue, MazDatePickerShortcut, MazDatePickerValue } from './MazDatePicker.vue';
 export { default as MazDialog } from './MazDialog.vue';
 export type { MazDialogProps } from './MazDialog.vue';
-export { default as MazDialogPromise, useMazDialogPromise } from './MazDialogPromise.vue';
-export type { MazDialogPromiseButton, MazDialogPromiseData, MazDialogPromiseProps } from './MazDialogPromise.vue';
+export { default as MazDialogConfirm, useMazDialogConfirm } from './MazDialogConfirm.vue';
+export type { MazDialogConfirmButton, MazDialogConfirmData, MazDialogConfirmProps } from './MazDialogConfirm.vue';
 export { default as MazDrawer } from './MazDrawer.vue';
 export type { MazDrawerProps } from './MazDrawer.vue';
 export { default as MazDropdown } from './MazDropdown.vue';
-export type { MazDropdownProps } from './MazDropdown.vue';
+export type { MazDropdownMenuItem, MazDropdownProps } from './MazDropdown.vue';
 export { default as MazDropzone } from './MazDropzone.vue';
 export type { MazDropzoneErrorCode, MazDropzoneFileData, MazDropzoneProps } from './MazDropzone.vue';
 export { default as MazExpandAnimation } from './MazExpandAnimation.vue';
@@ -71,7 +71,7 @@ export type { MazLoadingBarProps } from './MazLoadingBar.vue';
 export { default as MazPagination } from './MazPagination.vue';
 export type { MazPaginationProps } from './MazPagination.vue';
 export { default as MazPopover } from './MazPopover.vue';
-export type { PopoverPosition as MazPopoverPosition, MazPopoverProps, PopoverRole as MazPopoverRole, PopoverTrigger as MazPopoverTrigger } from './MazPopover.vue';
+export type { MazPopoverPosition, MazPopoverProps, MazPopoverRole, MazPopoverTrigger } from './MazPopover.vue';
 export { default as MazPullToRefresh } from './MazPullToRefresh.vue';
 export type { MazPullToRefreshProps } from './MazPullToRefresh.vue';
 export { default as MazRadio } from './MazRadio.vue';

package/dist/types/components/types.d.ts

@@ -1,3 +1,4 @@
 import { colors } from './constantes';
 export type MazColor = (typeof colors)[number];
 export type MazSize = 'mini' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export declare function getColor(color: MazColor | 'background'): "primary" | "secondary" | "accent" | "info" | "success" | "warning" | "destructive" | "contrast" | "transparent" | "surface";

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

@@ -2,9 +2,10 @@ export * from './useAos';
 export * from './useBreakpoints';
 export * from './useDialog';
 export * from './useDisplayNames';
+export * from './useDropzone';
 export * from './useFormField';
 export * from './useFormValidator';
-export * from './useFormValidator/types';
+export type { FieldsStates, FieldState, FormFieldOptions, FormSchema, FormValidatorOptions, InferOutputSchemaFormValidator, InferSchemaFormValidator } from './useFormValidator/types';
 export * from './useFreezeValue';
 export * from './useIdleTimeout';
 export * from './useInjectStrict';

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

@@ -34,8 +34,8 @@ type GetAllDisplayNamesOptions<T extends CodesType> = MaybeRefOrGetter<{
 } & DynamicDisplayNamesOptions>;
 type CodeResult<T extends CodesType> = T extends 'iso' ? Iso6391Code : T extends 'bcp' ? Bcp47Code : T extends 'country' ? CountryCode : DisplayNameCode | string;
 export declare function useDisplayNames(mainLocale?: MaybeRefOrGetter<string | DisplayNameCode>): {
-    getDisplayName: (code: Parameters<typeof getDisplayName>[0], options: GetDisplayNameOptions) => import('vue').ComputedRef<string | undefined>;
-    getAllDisplayNames: <T extends CodesType>(options: GetAllDisplayNamesOptions<T>) => import('vue').ComputedRef<{
+    getDisplayName: (code: Parameters<typeof getDisplayName>[0], options?: GetDisplayNameOptions) => import('vue').ComputedRef<string | undefined>;
+    getAllDisplayNames: <T extends CodesType>(options?: GetAllDisplayNamesOptions<T>) => import('vue').ComputedRef<{
         name: string;
         code: CodeResult<T>;
     }[] | undefined>;

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

@@ -1,10 +1,10 @@
 import { MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
-export interface UseDropZoneReturn {
+export interface UseDropzoneReturn {
     files: Ref<File[] | null>;
     isOverDropZone: Ref<boolean>;
     isOverError: Ref<boolean>;
 }
-export interface UseDropZoneOptions {
+export interface UseDropzoneOptions {
     /**
      * Allowed data types, if not set, all data types are allowed.
      * Also can be a function to check the data types.
@@ -24,4 +24,4 @@ export interface UseDropZoneOptions {
      */
     preventDefaultForUnhandled?: boolean;
 }
-export declare function useDropZone(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UseDropZoneOptions | UseDropZoneOptions['onDrop']): UseDropZoneReturn;
+export declare function useDropzone(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UseDropzoneOptions | UseDropzoneOptions['onDrop']): UseDropzoneReturn;

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

@@ -1,56 +1,16 @@
-import { ComputedRef, WritableComputedRef } from 'vue';
-import { BaseFormPayload, ExtractModelKey, FormFieldOptions, FormSchema, ValidationIssues } from '../composables/useFormValidator/types';
-import { getValidationEvents } from '../composables/useFormValidator/utils';
-interface UseFormFieldReturn<FieldType> {
-    /**
-     * Indicates if the field has an error
-     */
-    hasError: ComputedRef<boolean>;
-    /**
-     * Errors of the field
-     */
-    errors: ComputedRef<ValidationIssues>;
-    /**
-     * Error message of the field
-     * It's the first error of the field
-     */
-    errorMessage: ComputedRef<string | undefined>;
-    /**
-     * Indicates if the field is valid
-     */
-    isValid: ComputedRef<boolean>;
-    /**
-     * Indicates if the field has been modified
-     */
-    isDirty: ComputedRef<boolean>;
-    /**
-     * Indicates if the field has been blurred
-     */
-    isBlurred: ComputedRef<boolean>;
-    /**
-     * Indicates if the field has been validated
-     */
-    isValidated: ComputedRef<boolean>;
-    /**
-     * Indicates if the field is validating
-     */
-    isValidating: ComputedRef<boolean>;
-    /**
-     * Validation mode of the field
-     */
-    mode: ComputedRef<FormFieldOptions<FieldType>['mode']>;
-    /**
-     * Value of the field
-     */
-    value: WritableComputedRef<FieldType>;
-    /**
-     * Validation events of the field
-     */
-    validationEvents: ComputedRef<ReturnType<typeof getValidationEvents>>;
-    /**
-     * Function to handle the blur event of the field
-     */
-    onBlur: () => void;
-}
-export declare function useFormField<FieldType extends Model[ExtractModelKey<FormSchema<Model>>], Model extends BaseFormPayload = BaseFormPayload>(name: ExtractModelKey<FormSchema<Model>>, 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

@@ -0,0 +1,19 @@
+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<BaseFormPayload, ExtractModelKey<FormSchema<BaseFormPayload>>>['mode'];
+}): void;
+export declare function removeEventFromInteractiveElements({ interactiveElements, onBlur, }: {
+    interactiveElements: HTMLElement[];
+    onBlur: () => void;
+}): void;
+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: F;
+    onBlur: () => void;
+}): {
+    onBlur: () => void;
+} | undefined;

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

@@ -0,0 +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>>, FieldType = Model[ModelKey]>({ name, schema, initialValue, fieldState, options, }: {
+    name: ModelKey;
+    schema?: FormSchema<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, 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, ModelKey>;
+    payload: Model;
+    schema: FormSchema<Model>;
+    options: StrictOptions<Model, ModelKey>;
+    updateMode?: boolean;
+}): void;
+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, ModelKey, FieldType>;
+    payload: Model;
+    schema: FormSchema<Model>;
+    options: FormFieldOptions<Model, ModelKey, FieldType> & StrictOptions<Model, ModelKey>;
+    updateMode?: boolean;
+}): {
+    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, ModelKey, FieldType>;
+    isSubmitted: boolean;
+}): boolean;
+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, 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>>, FieldType = Model[ModelKey]>({ name, payload, fieldState, schema, isSubmitted, forceValidation, }: {
+    name: ModelKey;
+    payload: Model;
+    fieldState: FieldState<Model, ModelKey, FieldType>;
+    schema: FormSchema<Model>;
+    isSubmitted: boolean;
+    forceValidation?: boolean;
+}): Promise<void> | undefined;
+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

@@ -1,21 +1,16 @@
-import { DeepPartial } from '@maz-ui/utils/src/ts-helpers/DeepPartial.js';
-import { BaseIssue, BaseSchema, BaseSchemaAsync, InferIssue, InferOutput, objectAsync } from 'valibot';
-import { ComponentInternalInstance, ComponentPublicInstance, InjectionKey, MaybeRef, Ref } from 'vue';
-import { useFormField } from './../useFormField';
-import { useFormValidator } from './../useFormValidator';
-import { getValidateFunction } from './utils';
-export type ValidationSync = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
-export type ValidationAsync = ValidationSync | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>;
-export type Validation = ValidationAsync;
+import { BaseIssue, BaseSchema, BaseSchemaAsync, InferInput, InferIssue, InferOutput, objectAsync } from 'valibot';
+import { ComponentInternalInstance, InjectionKey, Ref, TemplateRef } from 'vue';
+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> = {
+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>>> {
     /**
@@ -53,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;
@@ -71,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
@@ -86,12 +81,12 @@ 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
      */
-    ref?: Ref<HTMLElement | ComponentPublicInstance | undefined>;
+    ref?: Ref | TemplateRef;
     /**
      * Identifier for the form
      * Useful when you have multiple forms on the same component
@@ -99,12 +94,5 @@ export interface FormFieldOptions<FieldType> {
      */
     formIdentifier?: string | symbol;
 }
-export type UseFormValidator<Model extends BaseFormPayload = BaseFormPayload> = typeof useFormValidator<Model>;
-export interface UseFormValidatorParams<Model extends BaseFormPayload> {
-    schema: MaybeRef<FormSchema<Model>>;
-    defaultValues?: MaybeRef<DeepPartial<Model> | undefined | null>;
-    model?: Ref<DeepPartial<Model> | undefined | null>;
-    options?: FormValidatorOptions<Model>;
-}
-export type UseFormField<FieldType extends Model[ExtractModelKey<FormSchema<Model>>], Model extends BaseFormPayload = BaseFormPayload> = typeof useFormField<FieldType, Model>;
-export type InferSchemaFormValidator<T> = T extends Ref<infer U> ? U extends Record<string, Validation> ? InferOutput<ReturnType<typeof objectAsync<U>>> : never : T extends Record<string, Validation> ? InferOutput<ReturnType<typeof objectAsync<T>>> : never;
+export type InferSchemaFormValidator<T> = T extends Ref<infer U> ? U extends FormSchema<BaseFormPayload> ? Partial<InferInput<ReturnType<typeof objectAsync<U>>>> : never : T extends (...args: any[]) => FormSchema<BaseFormPayload> ? Partial<InferInput<ReturnType<typeof objectAsync<ReturnType<T>>>>> : T extends FormSchema<BaseFormPayload> ? Partial<InferInput<ReturnType<typeof objectAsync<T>>>> : never;
+export type InferOutputSchemaFormValidator<T> = T extends Ref<infer U> ? U extends FormSchema<BaseFormPayload> ? InferOutput<ReturnType<typeof objectAsync<U>>> : never : T extends (...args: any[]) => FormSchema<BaseFormPayload> ? InferOutput<ReturnType<typeof objectAsync<ReturnType<T>>>> : T extends FormSchema<BaseFormPayload> ? InferOutput<ReturnType<typeof objectAsync<T>>> : never;

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

@@ -0,0 +1,37 @@
+import { BaseFormPayload, ExtractModelKey, FieldsStates, FieldState, FormSchema, StrictOptions, ValidationIssues } from './types';
+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>>>(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>>>({ name, fieldState, schema, payload, setError, setErrorIfInvalidAndNotEmpty, }: {
+    name: ModelKey;
+    fieldState: FieldState<Model, ModelKey, Model[ModelKey]>;
+    schema: FormSchema<Model>;
+    payload: Model;
+    setError?: boolean;
+    setErrorIfInvalidAndNotEmpty?: boolean;
+}): Promise<void>;
+export declare function validateForm<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>> = ExtractModelKey<FormSchema<Model>>>({ fieldsStates, payload, setErrors, schema, }: {
+    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, 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, ModelKey>['debouncedFields'];
+    throttledFields?: StrictOptions<Model, ModelKey>['throttledFields'];
+}): ((args_0: {
+    name: ModelKey;
+    fieldState: FieldState<Model, ModelKey, Model[ModelKey]>;
+    schema: FormSchema<Model>;
+    payload: Model;
+    setError?: boolean;
+    setErrorIfInvalidAndNotEmpty?: boolean;
+}) => Promise<void>) | undefined;

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

@@ -1,17 +1,23 @@
-import { Ref } from 'vue';
-import { BaseFormPayload, ExtractModelKey, FieldsStates, FormSchema, FormValidatorOptions, UseFormValidatorParams } from '../composables/useFormValidator/types';
-import { scrollToError } from '../composables/useFormValidator/utils';
-export declare function useFormValidator<Model extends BaseFormPayload>({ schema, defaultValues, model, options }: UseFormValidatorParams<Model>): {
+import { DeepPartial } from '@maz-ui/utils/src/ts-helpers/DeepPartial.js';
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { BaseFormPayload, ExtractModelKey, FieldsStates, FormSchema, FormValidatorOptions, InferOutputSchemaFormValidator, InferSchemaFormValidator } from './useFormValidator/types';
+import { scrollToError } from './useFormValidator/dom-events';
+export declare function useFormValidator<TSchema extends MaybeRefOrGetter<FormSchema<BaseFormPayload>>>({ schema, defaultValues, model, options }: {
+    schema: TSchema;
+    defaultValues?: MaybeRefOrGetter<DeepPartial<InferSchemaFormValidator<TSchema>> | undefined | null>;
+    model?: Ref<DeepPartial<InferSchemaFormValidator<TSchema>> | undefined | null>;
+    options?: FormValidatorOptions<InferSchemaFormValidator<TSchema>>;
+}): {
     identifier: string | symbol;
     isDirty: import('vue').ComputedRef<boolean>;
     isSubmitting: Ref<boolean, boolean>;
     isSubmitted: Ref<boolean, boolean>;
     isValid: import('vue').ComputedRef<boolean>;
-    errors: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<Model>>, import('.').ValidationIssues>>;
-    model: Ref<Model, Model>;
-    fieldsStates: Ref<FieldsStates<Model>, FieldsStates<Model>>;
-    validateForm: (showErrors?: boolean) => Promise<void[]>;
+    errors: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<InferSchemaFormValidator<TSchema>>>, import('./useFormValidator/types').ValidationIssues>>;
+    model: Ref<InferSchemaFormValidator<TSchema>, 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: Model) => Promise<Awaited<ReturnType<Func>>> | ReturnType<Func>>(successCallback: Func, enableScrollOrSelector?: FormValidatorOptions["scrollToError"]) => (event?: Event) => Promise<ReturnType<Func> | undefined>;
-    errorMessages: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<Model>>, string | undefined>>;
+    handleSubmit: <Func extends (model: InferOutputSchemaFormValidator<TSchema>) => Promise<Awaited<ReturnType<Func>>> | ReturnType<Func>>(successCallback: Func, enableScrollOrSelector?: FormValidatorOptions["scrollToError"]) => (event?: Event) => Promise<ReturnType<Func> | undefined>;
+    errorMessages: import('vue').ComputedRef<Record<ExtractModelKey<FormSchema<InferSchemaFormValidator<TSchema>>>, string | undefined>>;
 };

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

@@ -1,4 +1,4 @@
-import { IdleTimeoutCallback, IdleTimeoutOptions, IdleTimeout } from '@maz-ui/utils/src/utils/idleTimeout.js';
+import { IdleTimeoutCallback, IdleTimeoutOptions, IdleTimeout } from '@maz-ui/utils/src/helpers/idleTimeout.js';
 export declare function useIdleTimeout({ callback, options, }: {
     callback: IdleTimeoutCallback;
     options?: IdleTimeoutOptions;

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

@@ -1,2 +1,2 @@
 import { InjectionKey } from 'vue';
-export declare function useInjectStrict<T>(key: string | InjectionKey<T> | symbol, fallback?: T): NonNullable<T>;
+export declare function useInjectStrict<T>(key: string | InjectionKey<T> | symbol, fallback?: T, errorMessage?: string): NonNullable<T>;

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

@@ -1,4 +1,4 @@
-import { SwipeOptions } from '@maz-ui/utils/src/utils/swipeHandler.js';
+import { SwipeOptions } from '@maz-ui/utils/src/helpers/swipeHandler.js';
 import { MaybeRef } from 'vue';
 export declare function useSwipe(options: Omit<SwipeOptions, 'onValuesChanged' | 'element'> & {
     element: MaybeRef<HTMLElement> | string | null | undefined;

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

@@ -1,4 +1,4 @@
-import { UserVisibility, UserVisibilyCallback, UserVisibilyOptions } from '@maz-ui/utils/src/utils/userVisibility.js';
+import { UserVisibilyCallback, UserVisibilyOptions, UserVisibility } from '@maz-ui/utils/src/helpers/userVisibility.js';
 export declare function useUserVisibility({ callback, options, }: {
     callback: UserVisibilyCallback;
     options?: UserVisibilyOptions;