maz-ui 4.0.0-alpha.4 → 4.0.0-beta.0

package/dist/composables/useDisplayNames.js

@@ -0,0 +1,113 @@
+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",
+  fallback: "code",
+  style: "long",
+  localeMatcher: "lookup"
+}, displayNamesCache = /* @__PURE__ */ new Map();
+function isSameLanguageThanCode(language, code) {
+  return !language || language?.toLocaleLowerCase() === code.toLocaleLowerCase();
+}
+function normalizeCode(code, type) {
+  return type === "region" ? code.toUpperCase() : type === "language" ? code.toLowerCase() : code;
+}
+function getDisplayNamesInstance(locale, options = DEFAULT_DISPLAY_NAMES_OPTIONS) {
+  const cacheKey = `${locale}-${JSON.stringify(options)}`;
+  if (!displayNamesCache.has(cacheKey))
+    try {
+      const instance = new Intl.DisplayNames([locale], {
+        ...options,
+        type: options.type ?? DEFAULT_DISPLAY_NAMES_OPTIONS.type
+      });
+      displayNamesCache.set(cacheKey, instance);
+    } catch (error) {
+      return console.warn(`[maz-ui] (useDisplayNames) Failed to create DisplayNames instance for locale ${locale}:`, error), null;
+    }
+  return displayNamesCache.get(cacheKey) || null;
+}
+function getDisplayNamesCodes(codesType) {
+  return codesType === "iso" ? iso6391Codes : codesType === "bcp" ? bcp47Codes : codesType === "country" ? countryCodes : displayNamesCodes;
+}
+function getName(code, locale, options) {
+  const opts = {
+    ...DEFAULT_DISPLAY_NAMES_OPTIONS,
+    ...options,
+    type: options?.type ?? DEFAULT_DISPLAY_NAMES_OPTIONS.type
+  }, displayNamesInstance = getDisplayNamesInstance(locale, opts), normalizedCode = normalizeCode(code, opts.type);
+  return displayNamesInstance?.of(normalizedCode);
+}
+function getDisplayName(code, options) {
+  return computed(() => {
+    const resolvedOptions = toValue(options), resolvedLocale = toValue(resolvedOptions?.locale), resolvedType = toValue(resolvedOptions?.type) ?? DEFAULT_DISPLAY_NAMES_OPTIONS.type, resolvedCode = toValue(code), resolvedLanguageDisplay = toValue(resolvedOptions?.languageDisplay), resolvedFallback = toValue(resolvedOptions?.fallback), resolvedStyle = toValue(resolvedOptions?.style), resolvedLocaleMatcher = toValue(resolvedOptions?.localeMatcher);
+    if (!resolvedLocale)
+      return resolvedCode;
+    try {
+      return getName(resolvedCode, resolvedLocale, {
+        type: resolvedType,
+        languageDisplay: resolvedLanguageDisplay,
+        fallback: resolvedFallback,
+        style: resolvedStyle,
+        localeMatcher: resolvedLocaleMatcher
+      });
+    } catch {
+      return resolvedCode;
+    }
+  });
+}
+function getAllDisplayNames(options) {
+  return computed(() => {
+    const resolvedOptions = toValue(options), resolvedLocale = toValue(resolvedOptions?.locale), resolvedCodesType = toValue(resolvedOptions?.codesType) ?? "all", resolvedOnlyCodes = toValue(resolvedOptions.onlyCodes), resolvedExcludedCodes = toValue(resolvedOptions.excludedCodes), resolvedPreferredCodes = toValue(resolvedOptions.preferredCodes), resolvedRemoveDuplicates = toValue(resolvedOptions.removeDuplicates) ?? "name", resolvedRemoveUnmatched = toValue(resolvedOptions.removeUnmatched) ?? !0, resolvedType = toValue(resolvedOptions.type) ?? DEFAULT_DISPLAY_NAMES_OPTIONS.type, resolvedLanguageDisplay = toValue(resolvedOptions.languageDisplay), resolvedFallback = toValue(resolvedOptions.fallback), resolvedStyle = toValue(resolvedOptions.style), resolvedLocaleMatcher = toValue(resolvedOptions.localeMatcher);
+    if (!resolvedLocale) {
+      console.warn("[maz-ui] (useDisplayNames) locale is required");
+      return;
+    }
+    const result = (resolvedOnlyCodes ?? getDisplayNamesCodes(resolvedCodesType)).filter((code) => !resolvedExcludedCodes?.includes(code)).map((code) => {
+      try {
+        const name = getName(code, resolvedLocale, {
+          type: resolvedType,
+          languageDisplay: resolvedLanguageDisplay,
+          fallback: resolvedFallback,
+          style: resolvedStyle,
+          localeMatcher: resolvedLocaleMatcher
+        });
+        return resolvedRemoveUnmatched && (!name || isSameLanguageThanCode(name, code)) ? void 0 : {
+          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;
+      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
+  };
+}
+export {
+  useDisplayNames
+};

package/dist/composables/useDropzone.js

@@ -0,0 +1,57 @@
+import { i as isClient } from "../chunks/isClient.WI4oSt66.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()) {
+    let getFiles = function(event) {
+      const list = Array.from(event.dataTransfer?.files ?? []);
+      return list.length === 0 ? null : multiple ? list : [list[0]];
+    }, checkDataTypes = function(types) {
+      const dataTypes = unref(_options.dataTypes);
+      return typeof dataTypes == "function" ? dataTypes(types) : !dataTypes || dataTypes?.length === 0 ? !0 : types.length === 0 ? !1 : types.every(
+        (type) => dataTypes?.some((allowedType) => type.includes(allowedType))
+      );
+    }, checkValidity = function(items) {
+      const types = Array.from(items ?? []).map((item) => item.type), dataTypesValid = checkDataTypes(types), multipleFilesValid = multiple || items.length <= 1;
+      return dataTypesValid && multipleFilesValid;
+    }, isSafari = function() {
+      return /^(?:(?!chrome|android).)*safari/i.test(navigator.userAgent) && !("chrome" in window);
+    }, handleDragEvent = function(event, eventType) {
+      const dataTransferItemList = event.dataTransfer?.items;
+      isValid = (dataTransferItemList && checkValidity(dataTransferItemList)) ?? !1, preventDefaultForUnhandled && event.preventDefault();
+      const currentFiles = getFiles(event);
+      switch (!isSafari() && !isValid && event.dataTransfer && (event.dataTransfer.dropEffect = "none"), event.preventDefault(), event.dataTransfer && (event.dataTransfer.dropEffect = "copy"), eventType) {
+        case "enter":
+          counter += 1, isOverDropZone.value = !0, isOverError.value = !isValid, _options.onEnter?.(null, event);
+          break;
+        case "over":
+          _options.onOver?.(null, event);
+          break;
+        case "leave":
+          counter -= 1, counter === 0 && (isOverDropZone.value = !1, isOverError.value = !1), _options.onLeave?.(null, event);
+          break;
+        case "drop":
+          counter = 0, isOverDropZone.value = !1, isOverError.value = !1, isValid ? (files.value = currentFiles, _options.onDrop?.(currentFiles, event)) : _options.onError?.(currentFiles, event);
+          break;
+      }
+    }, removeEventListeners = function() {
+      const targetElement = toValue(target);
+      targetElement && (targetElement.removeEventListener("dragenter", (event) => handleDragEvent(event, "enter")), targetElement.removeEventListener("dragover", (event) => handleDragEvent(event, "over")), targetElement.removeEventListener("dragleave", (event) => handleDragEvent(event, "leave")), targetElement.removeEventListener("drop", (event) => handleDragEvent(event, "drop")));
+    };
+    const _options = typeof options == "function" ? { onDrop: options } : options, multiple = _options.multiple ?? !0, preventDefaultForUnhandled = _options.preventDefaultForUnhandled ?? !1;
+    watch(() => toValue(target), (element) => {
+      element && (element.addEventListener("dragenter", (event) => handleDragEvent(event, "enter")), element.addEventListener("dragover", (event) => handleDragEvent(event, "over")), element.addEventListener("dragleave", (event) => handleDragEvent(event, "leave")), element.addEventListener("drop", (event) => handleDragEvent(event, "drop")));
+    }, { immediate: !0 }), onBeforeUnmount(() => {
+      removeEventListeners();
+    });
+  }
+  return {
+    files,
+    isOverDropZone,
+    isOverError
+  };
+}
+export {
+  useDropZone
+};

package/dist/composables/useFormField.js

@@ -0,0 +1,97 @@
+import { c as checkAvailability } from "../chunks/checkAvailability.aTpZidex.js";
+import { i as isEqual } from "../chunks/throttleId.7PhWZjcS.js";
+import { computed, onMounted, onUnmounted } from "vue";
+import { e as getContext, f as fieldHasValidation, i as updateFieldState, j as setFieldValidationState, k as getValidationEvents, d as hasModeIncludes, r as removeEventFromInteractiveElements, l as handleFieldBlur, m as findInteractiveElements, n as addEventToInteractiveElements } from "../chunks/utils.BBuYjMbK.js";
+import { useFreezeValue } from "./useFreezeValue.js";
+function useFormField(name, options) {
+  const opts = {
+    formIdentifier: "main-form-validator",
+    ...options
+  }, {
+    fieldsStates,
+    payload,
+    options: formOptions,
+    internalSchema,
+    errorMessages,
+    isSubmitted
+  } = getContext(opts.formIdentifier, "useFormField"), fieldMode = fieldHasValidation(name, internalSchema.value) ? options?.mode ?? formOptions.mode : void 0;
+  opts.mode = fieldMode;
+  const fieldState = computed(() => fieldsStates.value[name]);
+  if (fieldsStates.value[name] = updateFieldState({
+    name,
+    fieldState: fieldState.value,
+    payload: payload.value,
+    schema: internalSchema.value,
+    options: { ...formOptions, ...opts }
+  }), opts.defaultValue !== void 0 && !isEqual(payload.value[name], opts.defaultValue)) {
+    const initialValue = opts.defaultValue;
+    payload.value[name] = initialValue, fieldsStates.value[name].initialValue = useFreezeValue(initialValue);
+  }
+  fieldMode && setFieldValidationState({
+    name,
+    fieldState: fieldState.value,
+    payload: payload.value,
+    schema: internalSchema.value,
+    setError: fieldMode === "aggressive",
+    setErrorIfInvalidAndNotEmpty: fieldMode === "lazy"
+  });
+  function onBlur() {
+    handleFieldBlur({
+      name,
+      fieldState: fieldState.value,
+      payload: payload.value,
+      schema: internalSchema.value,
+      isSubmitted: isSubmitted.value
+    });
+  }
+  const validationEvents = computed(
+    () => getValidationEvents({
+      hasRef: !!opts.ref?.value,
+      onBlur,
+      fieldState: fieldState.value
+    })
+  );
+  if (opts.ref && hasModeIncludes(["eager", "blur", "progressive"], fieldMode)) {
+    let interactiveElements = [];
+    const handleInteractiveElements = (element) => {
+      interactiveElements = findInteractiveElements(element), addEventToInteractiveElements({
+        interactiveElements,
+        onBlur,
+        mode: fieldMode
+      });
+    };
+    onMounted(() => {
+      checkAvailability(() => opts.ref?.value, (element) => {
+        const interactiveElement = element instanceof HTMLElement ? element : element?.$el;
+        interactiveElement && handleInteractiveElements(interactiveElement);
+      }, {
+        errorMessage: `[maz-ui](useFormField) No element found for ref ${opts.ref} for field ${name}`
+      });
+    }), onUnmounted(() => {
+      removeEventFromInteractiveElements({
+        interactiveElements,
+        onBlur
+      });
+    });
+  }
+  return {
+    hasError: computed(() => fieldState.value.error),
+    errors: computed(() => fieldState.value.errors),
+    errorMessage: computed(() => errorMessages.value[name]),
+    isValid: computed(() => fieldState.value.valid),
+    isDirty: computed(() => fieldState.value.dirty),
+    isBlurred: computed(() => fieldState.value.blurred),
+    isValidated: computed(() => fieldState.value.validated),
+    isValidating: computed(() => fieldState.value.validating),
+    mode: computed(() => fieldState.value.mode),
+    value: computed({
+      get: () => payload.value[name],
+      set: (value) => payload.value[name] = value
+    }),
+    validationEvents,
+    onBlur
+  };
+}
+export {
+  useFormField
+};

package/dist/composables/useFormValidator.js

@@ -0,0 +1,116 @@
+import { ref, 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 handleFieldInput, d as hasModeIncludes } from "../chunks/utils.BBuYjMbK.js";
+function useFormValidator({ schema, defaultValues, model, options }) {
+  const instance = getInstance("useFormValidator"), opts = {
+    mode: CONFIG.mode,
+    scrollToError: CONFIG.scrollToErrorSelector,
+    debouncedFields: null,
+    throttledFields: null,
+    identifier: "main-form-validator",
+    ...options
+  }, internalDefaultValues = ref(defaultValues), payload = ref({ ...internalDefaultValues.value, ...model?.value }), internalSchema = ref(schema), fieldsStates = ref(
+    getFieldsStates({
+      schema: internalSchema.value,
+      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));
+  model && watch(
+    payload,
+    (newModel) => {
+      model.value = { ...internalDefaultValues.value, ...newModel };
+    },
+    { deep: !0 }
+  ), watch(
+    internalDefaultValues,
+    (newDefaultValues) => {
+      payload.value = { ...newDefaultValues, ...payload.value };
+    },
+    { deep: !0 }
+  ), watch(
+    internalSchema,
+    (schema2) => {
+      updateFieldsStates({
+        schema: schema2,
+        fieldsStates: fieldsStates.value,
+        payload: payload.value,
+        options: opts
+      }), internalValidateForm();
+    },
+    { deep: !0 }
+  ), internalValidateForm();
+  function internalValidateForm(showErrors = opts.mode === "aggressive") {
+    return validateForm({
+      fieldsStates: fieldsStates.value,
+      payload: payload.value,
+      schema: internalSchema.value,
+      showErrors
+    });
+  }
+  const watchedPayloadStopFunctions = [];
+  async function addFieldValidationWatch(name) {
+    await nextTick();
+    const watchStopFunc = watch(
+      () => payload.value[name],
+      () => {
+        const fieldState = fieldsStates.value[name];
+        handleFieldInput({
+          name,
+          fieldState,
+          payload: payload.value,
+          schema: internalSchema.value,
+          isSubmitted: isSubmitted.value,
+          forceValidation: hasModeIncludes(["aggressive", "lazy", "progressive"], fieldState.mode)
+        });
+      },
+      { deep: typeof internalSchema.value[name] == "object" }
+    );
+    watchedPayloadStopFunctions.push(watchStopFunc);
+  }
+  function addFieldsValidationWatch() {
+    for (const watchStopFunc of watchedPayloadStopFunctions)
+      watchStopFunc();
+    for (const name of Object.keys(internalSchema.value))
+      addFieldValidationWatch(name);
+  }
+  function handleSubmit(successCallback, enableScrollOrSelector) {
+    return async (event) => {
+      if (event?.preventDefault(), !isSubmitting.value) {
+        isSubmitted.value = !0, isSubmitting.value = !0;
+        try {
+          await internalValidateForm(!0);
+          const scrollToErrorParam = typeof enableScrollOrSelector == "string" ? enableScrollOrSelector : opts.scrollToError;
+          let response;
+          return isValid.value ? response = await successCallback(payload.value) : typeof scrollToErrorParam != "boolean" && scrollToError(scrollToErrorParam), isSubmitting.value = !1, response;
+        } finally {
+          isSubmitting.value = !1;
+        }
+      }
+    };
+  }
+  const context = {
+    fieldsStates,
+    payload,
+    options: opts,
+    internalSchema,
+    errorMessages,
+    isSubmitted
+  };
+  return instance.formContexts ??= /* @__PURE__ */ new Map(), instance.formContexts.set(opts.identifier, context), provide(opts.identifier, context), addFieldsValidationWatch(), {
+    identifier: opts.identifier,
+    isDirty,
+    isSubmitting,
+    isSubmitted,
+    isValid,
+    errors,
+    model: payload,
+    fieldsStates,
+    validateForm: internalValidateForm,
+    scrollToError,
+    handleSubmit,
+    errorMessages
+  };
+}
+export {
+  useFormValidator
+};

package/dist/composables/useFreezeValue.js

@@ -0,0 +1,8 @@
+import { toValue } from "vue";
+function useFreezeValue(value) {
+  const rawValue = toValue(value);
+  return Array.isArray(rawValue) ? Object.freeze([...rawValue]) : typeof rawValue == "object" && rawValue !== null ? Object.freeze({ ...rawValue }) : rawValue;
+}
+export {
+  useFreezeValue
+};

package/dist/composables/useIdleTimeout.js

@@ -0,0 +1,10 @@
+import { I as IdleTimeout } from "../chunks/idleTimeout.-ICpdeGV.js";
+function useIdleTimeout({
+  callback,
+  options
+}) {
+  return new IdleTimeout(callback, options);
+}
+export {
+  useIdleTimeout
+};

package/dist/composables/useInjectStrict.js

@@ -0,0 +1,10 @@
+import { inject } from "vue";
+function useInjectStrict(key, fallback) {
+  const resolved = inject(key, fallback);
+  if (!resolved)
+    throw new TypeError(`[maz-ui](injectStrict) Could not resolve ${key.toString()}`);
+  return resolved;
+}
+export {
+  useInjectStrict
+};

package/dist/composables/useInstanceUniqId.js

@@ -0,0 +1,10 @@
+import { computed, useId } from "vue";
+function useInstanceUniqId({
+  componentName,
+  providedId
+}) {
+  return computed(() => providedId ?? `${componentName}-${useId().replace(/:/g, "")}`);
+}
+export {
+  useInstanceUniqId
+};

package/dist/composables/useMountComponent.js

@@ -0,0 +1,16 @@
+import { createVNode, render } from "vue";
+function useMountComponent(component, options) {
+  const el = options?.element ?? document.createElement("div");
+  function destroy() {
+    el && render(null, el);
+  }
+  const props = { ...options?.props, destroy }, vNode = createVNode(
+    component,
+    props,
+    options?.children
+  );
+  return options?.app && (vNode.appContext = options.app._context), options?.noRender || render(vNode, el), { vNode, destroy, el };
+}
+export {
+  useMountComponent
+};

package/dist/composables/useReadingTime.js

@@ -0,0 +1,32 @@
+import { computed } from "vue";
+function countWords(text) {
+  const words = text.join(", ").match(/\b\w+\b/g);
+  return words ? words.length : 0;
+}
+function getReadTimeInMinutes(content, velocity = 150) {
+  const words = countWords([content]);
+  return Math.ceil(words / velocity);
+}
+function useReadingTime(options) {
+  const velocity = computed(
+    () => typeof options.velocity == "number" ? options.velocity : options.velocity?.value ?? 150
+  ), selector = computed(() => typeof options.contentSelector == "string" ? options.contentSelector : options.contentSelector?.value), content = computed(() => {
+    if (typeof options.contentRef?.value == "object")
+      return options.contentRef.value?.textContent;
+    if (selector.value && typeof document < "u") {
+      const contentElement = document.querySelector(selector.value);
+      if (contentElement)
+        return contentElement.textContent;
+    }
+    return typeof options.content == "string" ? options.content : options.content?.value;
+  }), duration = computed(() => getReadTimeInMinutes(content.value, velocity.value)), wordCount = computed(() => countWords([content.value]));
+  return {
+    content,
+    wordCount,
+    velocity,
+    duration
+  };
+}
+export {
+  useReadingTime
+};

package/dist/composables/useStringMatching.js

@@ -0,0 +1,42 @@
+import { n as normalizeString } from "../chunks/normalizeString.CFe2M8S_.js";
+import { computed, toValue } from "vue";
+function levenshteinDistance(string1, string2) {
+  const length1 = string1.length, length2 = string2.length, matrix = [];
+  for (let index = 0; index <= length1; index++)
+    matrix[index] = [index];
+  for (let index = 0; index <= length2; index++)
+    matrix[0][index] = index;
+  for (let index = 1; index <= length1; index++)
+    for (let index_ = 1; index_ <= length2; index_++) {
+      const cost = string1[index - 1] === string2[index_ - 1] ? 0 : 1;
+      matrix[index][index_] = Math.min(
+        matrix[index - 1][index_] + 1,
+        matrix[index][index_ - 1] + 1,
+        matrix[index - 1][index_ - 1] + cost
+      );
+    }
+  return matrix[length1][length2];
+}
+function getMatchingScore(string1, string2) {
+  const distance = levenshteinDistance(string1, string2), maxLength = Math.max(string1.length, string2.length);
+  return 1 - distance / maxLength;
+}
+function getMatchingResults(string1, string2, threshold = 0.75) {
+  return getMatchingScore(string1, string2) >= threshold;
+}
+function useStringMatching(string1, string2, threshold = 0.75) {
+  const _string1 = computed(
+    () => normalizeString(toValue(string1))
+  ), _string2 = computed(
+    () => normalizeString(toValue(string2))
+  ), _threshold = computed(() => toValue(threshold)), score = computed(() => getMatchingScore(_string1.value, _string2.value));
+  return {
+    isMatching: computed(
+      () => getMatchingResults(_string1.value, _string2.value, _threshold.value)
+    ),
+    score
+  };
+}
+export {
+  useStringMatching
+};

package/dist/composables/useSwipe.js

@@ -0,0 +1,26 @@
+import { S as Swipe } from "../chunks/swipeHandler.8emelhOL.js";
+import { ref, computed, toValue } from "vue";
+function useSwipe(options) {
+  const xDiff = ref(), yDiff = ref(), xStart = ref(), xEnd = ref(), yStart = ref(), yEnd = ref(), element = computed(() => toValue(options.element)), swiper = new Swipe({
+    ...options,
+    element: element.value,
+    onValuesChanged(values) {
+      xDiff.value = values.xDiff, yDiff.value = values.yDiff, xStart.value = values.xStart, xEnd.value = values.xEnd, yStart.value = values.yStart, yEnd.value = values.yEnd;
+    }
+  });
+  return {
+    xDiff,
+    yDiff,
+    xStart,
+    xEnd,
+    yStart,
+    yEnd,
+    start: () => {
+      element.value && (swiper.options.element = element.value), swiper.start();
+    },
+    stop: swiper.stop
+  };
+}
+export {
+  useSwipe
+};

package/dist/composables/useTimer.js

@@ -0,0 +1,36 @@
+import { ref } from "vue";
+function useTimer({ timeout = 1e3, callback, remainingTimeUpdate = 200, callbackOffsetTime = 0 }) {
+  const internalTimeout = ref(timeout), remainingTime = ref(timeout);
+  let timerId;
+  function start(timeout2) {
+    typeof timeout2 == "number" && (remainingTime.value = timeout2), typeof timeout2 == "number" && (internalTimeout.value = timeout2), startInterval();
+  }
+  function startInterval() {
+    timerId || (timerId = setInterval(() => {
+      remainingTime.value -= remainingTimeUpdate, remainingTime.value <= 0 && (stop(), setTimeout(() => callback?.(), callbackOffsetTime));
+    }, remainingTimeUpdate));
+  }
+  function pause() {
+    timerId && (clearInterval(timerId), timerId = void 0);
+  }
+  function resume() {
+    !timerId && remainingTime.value > 0 && startInterval();
+  }
+  function stop() {
+    setTimeout(() => remainingTime.value = internalTimeout.value, callbackOffsetTime * 2), pause();
+  }
+  function reset() {
+    remainingTime.value = internalTimeout.value;
+  }
+  return {
+    remainingTime,
+    start,
+    pause,
+    resume,
+    stop,
+    reset
+  };
+}
+export {
+  useTimer
+};

package/dist/composables/useToast.js

@@ -0,0 +1,14 @@
+import { useInjectStrict } from "./useInjectStrict.js";
+function useToast() {
+  const toast = useInjectStrict("mazToast");
+  return {
+    message: toast.message.bind(toast),
+    success: toast.success.bind(toast),
+    error: toast.error.bind(toast),
+    info: toast.info.bind(toast),
+    warning: toast.warning.bind(toast)
+  };
+}
+export {
+  useToast
+};

package/dist/composables/useUserVisibility.js

@@ -0,0 +1,10 @@
+import { U as UserVisibility } from "../chunks/userVisibility.BbQSJASv.js";
+function useUserVisibility({
+  callback,
+  options
+}) {
+  return new UserVisibility(callback, options);
+}
+export {
+  useUserVisibility
+};

package/dist/composables/useWait.js

@@ -0,0 +1,7 @@
+import { useInjectStrict } from "./useInjectStrict.js";
+function useWait() {
+  return useInjectStrict("mazWait");
+}
+export {
+  useWait
+};

package/dist/composables/useWindowSize.js

@@ -0,0 +1,21 @@
+import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
+import { ref, onMounted, onUnmounted } from "vue";
+function useWindowSize(options = {}) {
+  const {
+    internalWindow = isClient() ? window : void 0,
+    initialWidth = Number.POSITIVE_INFINITY,
+    initialHeight = Number.POSITIVE_INFINITY,
+    includeScrollbar = !0
+  } = options, width = ref(initialWidth), height = ref(initialHeight);
+  function update() {
+    internalWindow && (includeScrollbar ? (width.value = internalWindow.innerWidth, height.value = internalWindow.innerHeight) : (width.value = internalWindow.document.documentElement.clientWidth, height.value = internalWindow.document.documentElement.clientHeight));
+  }
+  return update(), onMounted(() => {
+    internalWindow && window.addEventListener("resize", update, { passive: !0 });
+  }), onUnmounted(() => {
+    internalWindow && window.removeEventListener("resize", update);
+  }), { width, height };
+}
+export {
+  useWindowSize
+};