maz-ui 4.0.0-beta.8 → 4.0.0

package/dist/composables/useDisplayNames.js

@@ -1,5 +1,5 @@
+import { r } from "../chunks/truthyFilter.DZvXmxeK.js";
 import { toValue, computed } from "vue";
-import { t as truthyFilter } from "../chunks/truthyFilter.C2WOKUCG.js";
 const bcp47Codes = ["af-ZA", "sq-AL", "ar-DZ", "ar-BH", "ar-EG", "ar-IQ", "ar-JO", "ar-KW", "ar-LB", "ar-LY", "ar-MA", "ar-OM", "ar-QA", "ar-SA", "ar-SY", "ar-TN", "ar-AE", "ar-YE", "hy-AM", "Cy-az-AZ", "Lt-az-AZ", "eu-ES", "be-BY", "bg-BG", "ca-ES", "zh-CN", "zh-HK", "zh-MO", "zh-SG", "zh-TW", "zh-CHS", "zh-CHT", "hr-HR", "cs-CZ", "da-DK", "div-MV", "nl-BE", "nl-NL", "en-AU", "en-BZ", "en-CA", "en-CB", "en-IE", "en-JM", "en-NZ", "en-PH", "en-ZA", "en-TT", "en-GB", "en-US", "en-ZW", "et-EE", "fo-FO", "fa-IR", "fi-FI", "fr-BE", "fr-CA", "fr-FR", "fr-LU", "fr-MC", "fr-CH", "gl-ES", "ka-GE", "de-AT", "de-DE", "de-LI", "de-LU", "de-CH", "el-GR", "gu-IN", "he-IL", "hi-IN", "hu-HU", "is-IS", "id-ID", "it-IT", "it-CH", "ja-JP", "kn-IN", "kk-KZ", "kok-IN", "ko-KR", "ky-KZ", "lv-LV", "lt-LT", "mk-MK", "ms-BN", "ms-MY", "mr-IN", "mn-MN", "nb-NO", "nn-NO", "pl-PL", "pt-BR", "pt-PT", "pa-IN", "ro-RO", "ru-RU", "sa-IN", "Cy-sr-SP", "Lt-sr-SP", "sk-SK", "sl-SI", "es-AR", "es-BO", "es-CL", "es-CO", "es-CR", "es-DO", "es-EC", "es-SV", "es-GT", "es-HN", "es-MX", "es-NI", "es-PA", "es-PY", "es-PE", "es-PR", "es-ES", "es-UY", "es-VE", "sw-KE", "sv-FI", "sv-SE", "syr-SY", "ta-IN", "tt-RU", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "Cy-uz-UZ", "Lt-uz-UZ", "vi-VN"], countryCodes = ["AA", "AC", "AD", "AE", "AF", "AG", "AI", "AL", "AM", "AO", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BL", "BM", "BN", "BO", "BQ", "BR", "BS", "BT", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CU", "CV", "CW", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GT", "GU", "GW", "GY", "HK", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "SS", "ST", "SV", "SX", "SY", "SZ", "TA", "TC", "TD", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "XK", "YE", "YT", "ZA", "ZM", "ZW"], iso6391Codes = ["aa", "ab", "ae", "af", "ak", "am", "an", "ar", "as", "av", "ay", "az", "ba", "be", "bg", "bh", "bi", "bm", "bn", "bo", "br", "bs", "ca", "ce", "ch", "co", "cr", "cs", "cu", "cv", "cy", "da", "de", "dv", "dz", "ee", "el", "en", "eo", "es", "et", "eu", "fa", "ff", "fi", "fj", "fo", "fr", "fy", "ga", "gd", "gl", "gn", "gu", "gv", "ha", "he", "hi", "ho", "hr", "ht", "hu", "hy", "hz", "ia", "id", "ie", "ig", "ii", "ik", "io", "is", "it", "iu", "ja", "jv", "ka", "kg", "ki", "kj", "kk", "kl", "km", "kn", "ko", "kr", "ks", "ku", "kv", "kw", "ky", "la", "lb", "lg", "li", "ln", "lo", "lt", "lu", "lv", "mg", "mh", "mi", "mk", "ml", "mn", "mr", "ms", "mt", "my", "na", "nb", "nd", "ne", "ng", "nl", "nn", "no", "nr", "nv", "ny", "oc", "oj", "om", "or", "os", "pa", "pi", "pl", "ps", "pt", "qu", "rm", "rn", "ro", "ru", "rw", "sa", "sc", "sd", "se", "sg", "si", "sk", "sl", "sm", "sn", "so", "sq", "sr", "ss", "st", "su", "sv", "sw", "ta", "te", "tg", "th", "ti", "tk", "tl", "tn", "to", "tr", "ts", "tt", "tw", "ty", "ug", "uk", "ur", "uz", "ve", "vi", "vo", "wa", "wo", "xh", "yi", "yo", "za", "zh", "zu"], displayNamesCodes = [...iso6391Codes, ...bcp47Codes, ...countryCodes], DEFAULT_DISPLAY_NAMES_OPTIONS = {
   type: "region",
   languageDisplay: "standard",
@@ -9,9 +9,9 @@ const bcp47Codes = ["af-ZA", "sq-AL", "ar-DZ", "ar-BH", "ar-EG", "ar-IQ", "ar-JO
 }, displayNamesCache = /* @__PURE__ */ new Map();
 let cacheCleanupTimer = null;
 function scheduleCacheCleanup() {
-  cacheCleanupTimer && clearTimeout(cacheCleanupTimer), cacheCleanupTimer = setTimeout(() => {
+  typeof globalThis.window > "u" || (cacheCleanupTimer && clearTimeout(cacheCleanupTimer), cacheCleanupTimer = setTimeout(() => {
     displayNamesCache.size > 50 && displayNamesCache.clear(), cacheCleanupTimer = null;
-  }, 5 * 60 * 1e3);
+  }, 300 * 1e3));
 }
 function isSameLanguageThanCode(language, code) {
   return !language || language?.toLocaleLowerCase() === code.toLocaleLowerCase();
@@ -69,7 +69,8 @@ function getAllDisplayNames(options) {
       console.warn("[maz-ui] (useDisplayNames) locale is required");
       return;
     }
-    const result = (resolvedOnlyCodes ?? getDisplayNamesCodes(resolvedCodesType)).filter((code) => !resolvedExcludedCodes?.includes(code)).map((code) => {
+    const filteredCodes = (resolvedOnlyCodes ?? getDisplayNamesCodes(resolvedCodesType)).filter((code) => !resolvedExcludedCodes?.includes(code)), mappedResults = [];
+    for (const code of filteredCodes)
       try {
         const name = getName(code, resolvedLocale, {
           type: resolvedType,
@@ -78,40 +79,31 @@ function getAllDisplayNames(options) {
           style: resolvedStyle,
           localeMatcher: resolvedLocaleMatcher
         });
-        return resolvedRemoveUnmatched && (!name || isSameLanguageThanCode(name, code)) ? void 0 : {
+        if (resolvedRemoveUnmatched && (!name || isSameLanguageThanCode(name, code)))
+          continue;
+        mappedResults.push({
           name: name ?? code,
           code
-        };
+        });
       } catch {
-        return;
       }
-    }).sort((a, b) => a?.name && b?.name ? a.name.localeCompare(b.name) : 0).sort((a, b) => {
-      const aIndex = resolvedPreferredCodes?.indexOf(a?.code) ?? -1, bIndex = resolvedPreferredCodes?.indexOf(b?.code) ?? -1;
+    const result = mappedResults.filter(r).sort((a, b) => a.name && b.name ? a.name.localeCompare(b.name) : 0).sort((a, b) => {
+      const aIndex = resolvedPreferredCodes?.indexOf(a.code) ?? -1, bIndex = resolvedPreferredCodes?.indexOf(b.code) ?? -1;
       return aIndex !== -1 && bIndex !== -1 ? aIndex - bIndex : aIndex !== -1 ? -1 : bIndex !== -1 ? 1 : 0;
-    }).filter(truthyFilter);
+    });
     return resolvedRemoveDuplicates ? result.filter((item, index, self) => self.findIndex((t) => t[resolvedRemoveDuplicates].toLowerCase() === item[resolvedRemoveDuplicates].toLowerCase()) === index) : result;
   });
 }
 function useDisplayNames(mainLocale) {
   return {
-    getDisplayName: (code, options) => {
-      const resolvedOptions = toValue(options);
-      return getDisplayName(code, {
-        ...resolvedOptions,
-        locale: resolvedOptions?.locale || mainLocale
-      });
-    },
-    getAllDisplayNames: (options) => {
-      const resolvedOptions = toValue(options);
-      return getAllDisplayNames({
-        ...resolvedOptions,
-        locale: resolvedOptions?.locale || mainLocale
-      });
-    },
-    countryCodes,
-    iso6391Codes,
-    bcp47Codes,
-    normalizeCode
+    getDisplayName: (code, options) => getDisplayName(code, {
+      ...toValue(options),
+      locale: toValue(options)?.locale || mainLocale
+    }),
+    getAllDisplayNames: (options) => getAllDisplayNames({
+      ...toValue(options),
+      locale: toValue(options)?.locale || mainLocale
+    })
   };
 }
 export {

package/dist/composables/useDropzone.d.ts

@@ -0,0 +1,27 @@
+import { MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
+export interface UseDropzoneReturn {
+    files: Ref<File[] | null>;
+    isOverDropZone: Ref<boolean>;
+    isOverError: Ref<boolean>;
+}
+export interface UseDropzoneOptions {
+    /**
+     * Allowed data types, if not set, all data types are allowed.
+     * Also can be a function to check the data types.
+     */
+    dataTypes?: MaybeRef<string[]> | ((types: readonly string[]) => boolean);
+    onDrop?: (files: File[] | null, event: DragEvent) => unknown;
+    onEnter?: (files: File[] | null, event: DragEvent) => unknown;
+    onLeave?: (files: File[] | null, event: DragEvent) => unknown;
+    onOver?: (files: File[] | null, event: DragEvent) => unknown;
+    onError?: (files: File[] | null, event: DragEvent) => unknown;
+    /**
+     * Allow multiple files to be dropped. Defaults to true.
+     */
+    multiple?: boolean;
+    /**
+     * Prevent default behavior for unhandled events. Defaults to false.
+     */
+    preventDefaultForUnhandled?: boolean;
+}
+export declare function useDropzone(target: MaybeRefOrGetter<HTMLElement | null | undefined>, options?: UseDropzoneOptions | UseDropzoneOptions['onDrop']): UseDropzoneReturn;

package/dist/composables/useDropzone.js

@@ -1,9 +1,9 @@
-import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
+import { e } from "../chunks/isClient.8V3qjGdO.js";
 import { ref, shallowRef, watch, toValue, onBeforeUnmount, unref } from "vue";
 function useDropzone(target, options = {}) {
   const isOverDropZone = ref(!1), isOverError = ref(!1), files = shallowRef(null);
   let counter = 0, isValid = !0;
-  if (isClient()) {
+  if (e()) {
     let getFiles = function(event) {
       const list = Array.from(event.dataTransfer?.files ?? []);
       return list.length === 0 ? null : multiple ? list : [list[0]];
@@ -37,11 +37,11 @@ function useDropzone(target, options = {}) {
       }
     }, removeEventListeners = function() {
       const targetElement = toValue(target);
-      targetElement && (targetElement.removeEventListener("dragenter", dragHandler), targetElement.removeEventListener("dragover", dragHandler), targetElement.removeEventListener("dragleave", dragHandler), targetElement.removeEventListener("drop", dragHandler));
+      targetElement && (targetElement.removeEventListener("dragenter", dragEnterHandler), targetElement.removeEventListener("dragover", dragOverHandler), targetElement.removeEventListener("dragleave", dragLeaveHandler), targetElement.removeEventListener("drop", dropHandler));
     };
-    const _options = typeof options == "function" ? { onDrop: options } : options, multiple = _options.multiple ?? !0, preventDefaultForUnhandled = _options.preventDefaultForUnhandled ?? !1, dragHandler = (event) => handleDragEvent(event, "enter");
-    watch(() => toValue(target), (element) => {
-      element && (element.addEventListener("dragenter", dragHandler), element.addEventListener("dragover", dragHandler), element.addEventListener("dragleave", dragHandler), element.addEventListener("drop", dragHandler));
+    const _options = typeof options == "function" ? { onDrop: options } : options, multiple = _options.multiple ?? !0, preventDefaultForUnhandled = _options.preventDefaultForUnhandled ?? !1, dragEnterHandler = (event) => handleDragEvent(event, "enter"), dragOverHandler = (event) => handleDragEvent(event, "over"), dragLeaveHandler = (event) => handleDragEvent(event, "leave"), dropHandler = (event) => handleDragEvent(event, "drop");
+    watch(() => toValue(target), (element, oldElement) => {
+      oldElement && (oldElement.removeEventListener("dragenter", dragEnterHandler), oldElement.removeEventListener("dragover", dragOverHandler), oldElement.removeEventListener("dragleave", dragLeaveHandler), oldElement.removeEventListener("drop", dropHandler)), element && (element.addEventListener("dragenter", dragEnterHandler), element.addEventListener("dragover", dragOverHandler), element.addEventListener("dragleave", dragLeaveHandler), element.addEventListener("drop", dropHandler));
     }, { immediate: !0 }), onBeforeUnmount(() => {
       removeEventListeners();
     });

package/dist/composables/useFormField.d.ts

@@ -0,0 +1,16 @@
+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/composables/useFormField.js

@@ -1,4 +1,4 @@
-import { e as getContext, f as fieldHasValidation, i as updateFieldState, j as isEqual, k as setFieldValidationState, l as getValidationEvents, h as hasModeIncludes, r as removeEventFromInteractiveElements, m as findInteractiveElements, n as addEventToInteractiveElements, o as handleFieldBlur } from "../chunks/dom-events.Bbe7wDQl.js";
+import { e as getContext, f as fieldHasValidation, i as updateFieldState, j as s, k as setFieldValidationState, l as getValidationEvents, h as hasModeIncludes, r as removeEventFromInteractiveElements, m as findInteractiveElements, n as addEventToInteractiveElements, o as handleFieldBlur } from "../chunks/dom-events.H9KIOv83.js";
 import { computed, onMounted, onUnmounted } from "vue";
 import { useFreezeValue } from "./useFreezeValue.js";
 function useFormField(name, options) {
@@ -21,7 +21,7 @@ function useFormField(name, options) {
     payload: payload.value,
     schema: internalSchema.value,
     options: { ...formOptions, ...finalOpts }
-  }), finalOpts.defaultValue !== void 0 && !isEqual(payload.value[name], finalOpts.defaultValue)) {
+  }), finalOpts.defaultValue !== void 0 && !s(payload.value[name], finalOpts.defaultValue)) {
     const initialValue = finalOpts.defaultValue;
     payload.value[name] = initialValue, fieldsStates.value[name].initialValue = useFreezeValue(initialValue);
   }
@@ -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/config.d.ts

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

package/dist/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/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/composables/useFormValidator/types.d.ts

@@ -0,0 +1,98 @@
+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 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, 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>>> {
+    /**
+     * Validation mode
+     * - lazy: validate on input value change
+     * - aggressive: validate all fields immediately on form creation and on input value change
+     * - blur: validate on blur
+     * - eager: validate on blur at first (only if the field is not empty) and then on input value change
+     * - progressive: field becomes valid after the first validation and then validate on input value change. If invalid validate on blur.
+     * @default 'lazy'
+     */
+    mode?: 'eager' | 'lazy' | 'aggressive' | 'blur' | 'progressive';
+    /**
+     * Fields to validate with throttling
+     * Useful for fields that require a network request to avoid spamming the server
+     * @example { name: 1000 } or { name: true } for the default throttle time (1000ms)
+     */
+    throttledFields?: Partial<Record<ModelKey, number | true>> | null;
+    /**
+     * Fields to validate with debouncing
+     * Useful to wait for the user to finish typing before validating
+     * Useful for fields that require a network request to avoid spamming the server
+     * @example { name: 300 } or { name: true } for the default debounce time (300ms)
+     */
+    debouncedFields?: Partial<Record<ModelKey, number | true>> | null;
+    /**
+     * Scroll to the first error found
+     * @default '.has-field-error'
+     */
+    scrollToError?: string | false;
+    /**
+     * Identifier to use for the form
+     * Useful to have multiple forms on the same page
+     * @default `main-form-validator`
+     */
+    identifier?: string | symbol;
+}
+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, ModelKey extends ExtractModelKey<FormSchema<Model>>, FieldType = Model[ModelKey]> {
+    blurred: boolean;
+    dirty: boolean;
+    error: boolean;
+    errors: ValidationIssues;
+    valid: boolean;
+    initialValue?: Readonly<FieldType>;
+    validating: boolean;
+    validated: boolean;
+    validateFunction: ReturnType<typeof getValidateFunction<Model, ModelKey>>;
+    mode?: StrictOptions<Model, ModelKey>['mode'];
+}
+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<Model extends BaseFormPayload, ModelKey extends ExtractModelKey<FormSchema<Model>>, FieldType> {
+    /**
+     * Default value of the field
+     * @default undefined
+     */
+    defaultValue?: FieldType;
+    /**
+     * Validation mode
+     * To override the form validation 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 | TemplateRef;
+    /**
+     * Identifier for the form
+     * Useful when you have multiple forms on the same component
+     * Should be the same as the one used in `useFormValidator`
+     */
+    formIdentifier?: string | symbol;
+}
+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/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/composables/useFormValidator.d.ts

@@ -0,0 +1,23 @@
+import { DeepPartial } from '@maz-ui/utils/ts-helpers/DeepPartial';
+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<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: 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/composables/useFormValidator.js

@@ -1,5 +1,5 @@
 import { ref, toValue, computed, watch, provide, nextTick } from "vue";
-import { g as getInstance, a as getFieldsStates, b as getFieldsErrors, c as getErrorMessages, u as updateFieldsStates, v as validateForm, C as CONFIG, s as scrollToError, h as hasModeIncludes, d as handleFieldInput } from "../chunks/dom-events.Bbe7wDQl.js";
+import { g as getInstance, a as getFieldsStates, b as getFieldsErrors, c as getErrorMessages, u as updateFieldsStates, v as validateForm, C as CONFIG, s as scrollToError, h as hasModeIncludes, d as handleFieldInput } from "../chunks/dom-events.H9KIOv83.js";
 function createValidationProcessor(fieldsToValidate, fieldsStates, payload, internalSchema, isSubmitted) {
   return () => {
     fieldsToValidate.forEach((name) => {
@@ -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/composables/useFreezeValue.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRef } from 'vue';
+/**
+ * Freeze a value to prevent it from being modified
+ */
+export declare function useFreezeValue<T>(value: MaybeRef<T>): Readonly<T>;

package/dist/composables/useIdleTimeout.d.ts

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