maz-ui 4.0.0-beta.3 → 4.0.0-beta.33

package/dist/composables/useDropzone.js

@@ -1,6 +1,6 @@
 import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
 import { ref, shallowRef, watch, toValue, onBeforeUnmount, unref } from "vue";
-function useDropZone(target, options = {}) {
+function useDropzone(target, options = {}) {
   const isOverDropZone = ref(!1), isOverError = ref(!1), files = shallowRef(null);
   let counter = 0, isValid = !0;
   if (isClient()) {
@@ -16,7 +16,7 @@ function useDropZone(target, options = {}) {
       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);
+      return /^(?:(?!chrome|android).)*safari/i.test(navigator.userAgent) && !("chrome" in globalThis);
     }, handleDragEvent = function(event, eventType) {
       const dataTransferItemList = event.dataTransfer?.items;
       isValid = (dataTransferItemList && checkValidity(dataTransferItemList)) ?? !1, preventDefaultForUnhandled && event.preventDefault();
@@ -37,11 +37,11 @@ function useDropZone(target, options = {}) {
       }
     }, 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")));
+      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;
-    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")));
+    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();
     });
@@ -53,5 +53,5 @@ function useDropZone(target, options = {}) {
   };
 }
 export {
-  useDropZone
+  useDropzone
 };

package/dist/composables/useFormField.js

@@ -1,7 +1,5 @@
-import { c as checkAvailability } from "../chunks/checkAvailability.aTpZidex.js";
-import { i as isEqual } from "../chunks/throttleId.7PhWZjcS.js";
+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 { 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 = {
@@ -14,17 +12,17 @@ function useFormField(name, options) {
     internalSchema,
     errorMessages,
     isSubmitted
-  } = getContext(opts.formIdentifier, "useFormField"), fieldMode = fieldHasValidation(name, internalSchema.value) ? options?.mode ?? formOptions.mode : void 0;
-  opts.mode = fieldMode;
+  } = getContext(opts.formIdentifier, "useFormField"), finalOpts = opts, fieldMode = fieldHasValidation(name, internalSchema.value) ? options?.mode ?? formOptions.mode : void 0;
+  finalOpts.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;
+    options: { ...formOptions, ...finalOpts }
+  }), finalOpts.defaultValue !== void 0 && !isEqual(payload.value[name], finalOpts.defaultValue)) {
+    const initialValue = finalOpts.defaultValue;
     payload.value[name] = initialValue, fieldsStates.value[name].initialValue = useFreezeValue(initialValue);
   }
   fieldMode && setFieldValidationState({
@@ -46,27 +44,26 @@ function useFormField(name, options) {
   }
   const validationEvents = computed(
     () => getValidationEvents({
-      hasRef: !!opts.ref?.value,
+      hasRef: !!finalOpts.ref?.value,
       onBlur,
       fieldState: fieldState.value
     })
   );
-  if (opts.ref && hasModeIncludes(["eager", "blur", "progressive"], fieldMode)) {
+  if (finalOpts.ref && fieldMode && hasModeIncludes(["eager", "blur", "progressive"], fieldMode)) {
     let interactiveElements = [];
     const handleInteractiveElements = (element) => {
-      interactiveElements = findInteractiveElements(element), addEventToInteractiveElements({
+      interactiveElements.length > 0 && removeEventFromInteractiveElements({
+        interactiveElements,
+        onBlur
+      }), 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}`
-      });
+      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: ${String(formOptions.identifier)})`);
     }), onUnmounted(() => {
       removeEventFromInteractiveElements({
         interactiveElements,
@@ -88,8 +85,7 @@ function useFormField(name, options) {
       get: () => payload.value[name],
       set: (value) => payload.value[name] = value
     }),
-    validationEvents,
-    onBlur
+    validationEvents
   };
 }
 export {

package/dist/composables/useFormValidator.js

@@ -1,5 +1,20 @@
-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";
+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";
+function createValidationProcessor(fieldsToValidate, fieldsStates, payload, internalSchema, isSubmitted) {
+  return () => {
+    fieldsToValidate.forEach((name) => {
+      const fieldState = fieldsStates.value[name];
+      handleFieldInput({
+        name,
+        fieldState,
+        payload: payload.value,
+        schema: internalSchema.value,
+        isSubmitted: isSubmitted.value,
+        forceValidation: !0
+      });
+    });
+  };
+}
 function useFormValidator({ schema, defaultValues, model, options }) {
   const instance = getInstance("useFormValidator"), opts = {
     mode: CONFIG.mode,
@@ -8,13 +23,23 @@ function useFormValidator({ schema, defaultValues, model, options }) {
     throttledFields: null,
     identifier: "main-form-validator",
     ...options
-  }, internalDefaultValues = ref(defaultValues), payload = ref({ ...internalDefaultValues.value, ...model?.value }), internalSchema = ref(schema), fieldsStates = ref(
+  }, internalDefaultValues = ref(toValue(defaultValues)), payload = ref({ ...internalDefaultValues.value, ...model?.value }), internalSchema = ref(toValue(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));
+  ), 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) => {
@@ -39,39 +64,43 @@ function useFormValidator({ schema, defaultValues, model, options }) {
     },
     { deep: !0 }
   ), internalValidateForm();
-  function internalValidateForm(showErrors = opts.mode === "aggressive") {
+  function internalValidateForm(setErrors = opts.mode === "aggressive") {
     return validateForm({
       fieldsStates: fieldsStates.value,
       payload: payload.value,
       schema: internalSchema.value,
-      showErrors
+      setErrors
     });
   }
-  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)
+  let payloadWatchStop = null;
+  function setupOptimizedWatch() {
+    payloadWatchStop && payloadWatchStop();
+    const payloadSnapshot = computed(() => {
+      const snapshot = {};
+      for (const key of Object.keys(internalSchema.value))
+        snapshot[key] = payload.value[key];
+      return snapshot;
+    });
+    payloadWatchStop = watch(
+      payloadSnapshot,
+      (newSnapshot, oldSnapshot) => {
+        const fieldsToValidate = Object.keys(internalSchema.value).filter((name) => {
+          const fieldState = fieldsStates.value[name];
+          return fieldState && newSnapshot[name] !== oldSnapshot?.[name] && hasModeIncludes(["aggressive", "lazy", "progressive"], fieldState.mode);
         });
+        if (fieldsToValidate.length > 0) {
+          const processValidations = createValidationProcessor(
+            fieldsToValidate,
+            fieldsStates,
+            payload,
+            internalSchema,
+            isSubmitted
+          );
+          typeof requestIdleCallback < "u" ? requestIdleCallback(processValidations, { timeout: 100 }) : nextTick(processValidations);
+        }
       },
-      { deep: typeof internalSchema.value[name] == "object" }
+      { deep: !0 }
     );
-    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) => {
@@ -96,7 +125,7 @@ function useFormValidator({ schema, defaultValues, model, options }) {
     errorMessages,
     isSubmitted
   };
-  return instance.formContexts ??= /* @__PURE__ */ new Map(), instance.formContexts.set(opts.identifier, context), provide(opts.identifier, context), addFieldsValidationWatch(), {
+  return instance.formContexts ??= /* @__PURE__ */ new Map(), instance.formContexts.set(opts.identifier, context), provide(opts.identifier, context), setupOptimizedWatch(), {
     identifier: opts.identifier,
     isDirty,
     isSubmitting,

package/dist/composables/useIdleTimeout.js

@@ -1,4 +1,111 @@
-import { I as IdleTimeout } from "../chunks/idleTimeout.-ICpdeGV.js";
+import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
+class IdleTimeout {
+  constructor(callback, options) {
+    this.callback = callback, this.options = {
+      ...this.defaultOptions,
+      ...options
+    }, isClient() && this.start();
+  }
+  defaultOptions = {
+    element: void 0,
+    timeout: 60 * 1e3 * 5,
+    // 5 minutes
+    once: !1,
+    immediate: !0
+  };
+  options;
+  timeoutHandler;
+  isIdle = !1;
+  isDestroy = !1;
+  startTime = 0;
+  remainingTime = 0;
+  lastClientX = -1;
+  lastClientY = -1;
+  eventNames = [
+    "DOMMouseScroll",
+    "mousedown",
+    "mousemove",
+    "mousewheel",
+    "MSPointerDown",
+    "MSPointerMove",
+    "keydown",
+    "touchmove",
+    "touchstart",
+    "wheel",
+    "click"
+  ];
+  get element() {
+    return this.options.element ?? document.body;
+  }
+  start() {
+    if (!isClient()) {
+      console.warn("[IdleTimeout](start) you should run this method on client side");
+      return;
+    }
+    for (const eventName of this.eventNames)
+      this.element.addEventListener(eventName, this.handleEvent);
+    this.resetTimeout(), this.options.immediate && this.callback({ isIdle: !1, instance: this });
+  }
+  pause() {
+    const remainingTime = this.startTime + this.options.timeout - Date.now();
+    remainingTime <= 0 || (this.remainingTime = remainingTime, this.timeoutHandler && (clearTimeout(this.timeoutHandler), this.timeoutHandler = void 0));
+  }
+  resume() {
+    this.remainingTime <= 0 || (this.resetTimeout(), this.callback({ isIdle: this.isIdle, instance: this }), this.remainingTime = 0);
+  }
+  reset() {
+    this.isDestroy = !1, this.isIdle = !1, this.remainingTime = 0, this.resetTimeout(), this.callback({ isIdle: this.isIdle, instance: this });
+  }
+  destroy() {
+    if (!isClient()) {
+      console.warn("[IdleTimeout](destroy) you should run this method on client side");
+      return;
+    }
+    this.isDestroy = !0;
+    for (const eventName of this.eventNames)
+      this.element.removeEventListener(eventName, this.handleEvent);
+    this.timeoutHandler && clearTimeout(this.timeoutHandler);
+  }
+  resetTimeout() {
+    this.isIdle = !1, this.timeoutHandler && (clearTimeout(this.timeoutHandler), this.timeoutHandler = void 0), this.timeoutHandler = setTimeout(
+      this.handleTimeout.bind(this),
+      this.remainingTime || this.options.timeout
+    ), this.startTime = Date.now();
+  }
+  handleEvent = (event) => {
+    try {
+      if (this.remainingTime > 0)
+        return;
+      if (event.type === "mousemove") {
+        const { clientX, clientY } = event;
+        if (clientX === void 0 && clientY === void 0 || clientX === this.lastClientX && clientY === this.lastClientY)
+          return;
+        this.lastClientX = clientX, this.lastClientY = clientY;
+      }
+      this.resetTimeout(), this.callback({ isIdle: this.isIdle, eventType: event.type, instance: this });
+    } catch (error) {
+      throw new Error(`[IdleTimeout](handleEvent) ${error}`);
+    }
+  };
+  handleTimeout() {
+    this.isIdle = !0, this.callback({ isIdle: this.isIdle, instance: this }), this.options.once && this.destroy();
+  }
+  get destroyed() {
+    return this.isDestroy;
+  }
+  get timeout() {
+    return this.options.timeout;
+  }
+  set timeout(value) {
+    this.options.timeout = value;
+  }
+  get idle() {
+    return this.isIdle;
+  }
+  set idle(value) {
+    value ? this.handleTimeout() : this.reset(), this.callback({ isIdle: this.isIdle, instance: this });
+  }
+}
 function useIdleTimeout({
   callback,
   options

package/dist/composables/useInjectStrict.js

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

package/dist/composables/useInstanceUniqId.js

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

package/dist/composables/useStringMatching.js

@@ -1,42 +1,5 @@
-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
-  };
-}
+import { u } from "../chunks/useStringMatching.BBezu-6J.js";
+import "vue";
 export {
-  useStringMatching
+  u as useStringMatching
 };

package/dist/composables/useSwipe.js

@@ -1,5 +1,81 @@
-import { S as Swipe } from "../chunks/swipeHandler.8emelhOL.js";
 import { ref, computed, toValue } from "vue";
+const defaultOptions = {
+  preventDefaultOnTouchMove: !1,
+  preventDefaultOnMouseWheel: !1,
+  threshold: 50,
+  immediate: !1,
+  triggerOnEnd: !1
+};
+class Swipe {
+  constructor(inputOption) {
+    this.inputOption = inputOption, this.options = { ...defaultOptions, ...inputOption }, this.onToucheStartCallback = this.toucheStartHandler.bind(this), this.onToucheMoveCallback = this.handleTouchMove.bind(this), this.onToucheEndCallback = this.handleTouchEnd.bind(this), this.onMouseWheelCallback = this.handleMouseWheel.bind(this), this.start = this.startListening.bind(this), this.stop = this.stopListening.bind(this), this.options.element && this.setElement(this.options.element), this.options.immediate && this.start();
+  }
+  element;
+  xStart;
+  yStart;
+  xEnd;
+  yEnd;
+  xDiff;
+  yDiff;
+  onToucheStartCallback;
+  onToucheMoveCallback;
+  onToucheEndCallback;
+  onMouseWheelCallback;
+  start;
+  stop;
+  options;
+  startListening() {
+    this.setElement(this.options.element), this.element?.addEventListener("touchstart", this.onToucheStartCallback, { passive: !0 }), this.element?.addEventListener("touchmove", this.onToucheMoveCallback, { passive: !0 }), this.options.triggerOnEnd && this.element?.addEventListener("touchend", this.onToucheEndCallback, { passive: !0 }), this.options.preventDefaultOnMouseWheel && this.element?.addEventListener("mousewheel", this.onMouseWheelCallback, { passive: !1 });
+  }
+  stopListening() {
+    this.element?.removeEventListener("touchstart", this.onToucheStartCallback), this.element?.removeEventListener("touchmove", this.onToucheMoveCallback), this.element?.removeEventListener("touchend", this.onToucheEndCallback), this.options.preventDefaultOnMouseWheel && this.element?.removeEventListener("mousewheel", this.onMouseWheelCallback);
+  }
+  setElement(element) {
+    if (!element) {
+      console.error(
+        "[maz-ui][SwipeHandler](setElement) Element should be provided. Its can be a string selector or an HTMLElement"
+      );
+      return;
+    }
+    if (typeof element == "string") {
+      const foundElement = document.querySelector(element);
+      if (!(foundElement instanceof HTMLElement)) {
+        console.error("[maz-ui][SwipeHandler](setElement) String selector for element is not found");
+        return;
+      }
+      this.element = foundElement;
+    } else
+      this.element = element;
+  }
+  handleMouseWheel(event) {
+    event.preventDefault();
+  }
+  toucheStartHandler(event) {
+    this.xStart = event.touches[0].clientX, this.yStart = event.touches[0].clientY, this.emitValuesChanged();
+  }
+  emitValuesChanged() {
+    this.options.onValuesChanged?.({
+      xStart: this.xStart,
+      yStart: this.yStart,
+      xEnd: this.xEnd,
+      yEnd: this.yEnd,
+      xDiff: this.xDiff,
+      yDiff: this.yDiff
+    });
+  }
+  handleTouchMove(event) {
+    this.options.preventDefaultOnTouchMove && event.cancelable && event.preventDefault(), this.xEnd = event.touches[0].clientX, this.yEnd = event.touches[0].clientY, !(!this.xStart || !this.yStart) && (this.xDiff = this.xStart - this.xEnd, this.yDiff = this.yStart - this.yEnd, this.emitValuesChanged(), this.options.triggerOnEnd || this.runCallbacks(event));
+  }
+  handleTouchEnd(event) {
+    this.runCallbacks(event), this.emitValuesChanged();
+  }
+  runCallbacks(event) {
+    typeof this.xDiff != "number" || typeof this.yDiff != "number" || Math.abs(this.xDiff) < this.options.threshold && Math.abs(this.yDiff) < this.options.threshold || (Math.abs(this.xDiff) > Math.abs(this.yDiff) ? this.xDiff > 0 ? this.options.onLeft?.(event) : this.options.onRight?.(event) : this.yDiff > 0 ? this.options.onUp?.(event) : this.options.onDown?.(event), this.resetValues());
+  }
+  resetValues() {
+    this.xStart = void 0, this.yStart = void 0, this.xEnd = void 0, this.yEnd = void 0, this.xDiff = void 0, this.yDiff = void 0, this.emitValuesChanged();
+  }
+}
 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,

package/dist/composables/useToast.js

@@ -1,6 +1,6 @@
 import { useInjectStrict } from "./useInjectStrict.js";
 function useToast() {
-  const toast = useInjectStrict("mazToast");
+  const toast = useInjectStrict("mazToast", void 0, "[maz-ui](useToast) ToastPlugin is not installed");
   return {
     message: toast.message.bind(toast),
     success: toast.success.bind(toast),

package/dist/composables/useUserVisibility.js

@@ -1,4 +1,50 @@
-import { U as UserVisibility } from "../chunks/userVisibility.BbQSJASv.js";
+import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
+class UserVisibility {
+  constructor(callback, options) {
+    this.callback = callback, this.options = {
+      ...this.defaultOptions,
+      ...options
+    }, this.eventHandlerFunction = this.eventHandler.bind(this), isClient() && this.start();
+  }
+  eventHandlerFunction;
+  event = "visibilitychange";
+  timeoutHandler;
+  options;
+  defaultOptions = {
+    timeout: 5e3,
+    once: !1,
+    immediate: !0
+  };
+  isVisible = !1;
+  start() {
+    if (!isClient()) {
+      console.warn("[UserVisibility](start) you should run this method on client side");
+      return;
+    }
+    this.options.immediate && this.emitCallback(), this.addEventListener();
+  }
+  emitCallback() {
+    this.isVisible = document.visibilityState === "visible", this.callback({ isVisible: this.isVisible }), this.options.once && this.destroy();
+  }
+  eventHandler() {
+    document.visibilityState === "visible" && !this.isVisible ? (this.clearTimeout(), this.emitCallback()) : document.visibilityState === "hidden" && this.initTimeout();
+  }
+  clearTimeout() {
+    this.timeoutHandler && (clearTimeout(this.timeoutHandler), this.timeoutHandler = void 0);
+  }
+  initTimeout() {
+    this.clearTimeout(), this.timeoutHandler = setTimeout(this.emitCallback.bind(this), this.options.timeout);
+  }
+  addEventListener() {
+    document.addEventListener(this.event, this.eventHandlerFunction);
+  }
+  removeEventListener() {
+    document.removeEventListener(this.event, this.eventHandlerFunction);
+  }
+  destroy() {
+    this.removeEventListener(), this.timeoutHandler && clearTimeout(this.timeoutHandler);
+  }
+}
 function useUserVisibility({
   callback,
   options

package/dist/composables/useWait.js

@@ -1,6 +1,6 @@
 import { useInjectStrict } from "./useInjectStrict.js";
 function useWait() {
-  return useInjectStrict("mazWait");
+  return useInjectStrict("mazWait", void 0, "[maz-ui](useWait) WaitPlugin is not installed");
 }
 export {
   useWait

package/dist/composables/useWindowSize.js

@@ -2,7 +2,7 @@ import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
 import { ref, onMounted, onUnmounted } from "vue";
 function useWindowSize(options = {}) {
   const {
-    internalWindow = isClient() ? window : void 0,
+    internalWindow = isClient() ? globalThis : void 0,
     initialWidth = Number.POSITIVE_INFINITY,
     initialHeight = Number.POSITIVE_INFINITY,
     includeScrollbar = !0