vft 0.0.369 → 0.0.371

package/es/hooks/use-composition/index.js

@@ -1,38 +1,28 @@
-import { ref, nextTick } from "vue";
-import { isKorean } from "@vft/utils";
-function useComposition({
-  afterComposition,
-  emit
+import { ref as c, nextTick as l } from "vue";
+import { isKorean as m } from "@vft/utils";
+function f({
+  afterComposition: e,
+  emit: n
 }) {
-  const isComposing = ref(false);
-  const handleCompositionStart = (event) => {
-    emit?.("compositionstart", event);
-    isComposing.value = true;
-  };
-  const handleCompositionUpdate = (event) => {
-    emit?.("compositionupdate", event);
-    const text = event.target?.value;
-    const lastCharacter = text[text.length - 1] || "";
-    isComposing.value = !isKorean(lastCharacter);
-  };
-  const handleCompositionEnd = (event) => {
-    emit?.("compositionend", event);
-    if (isComposing.value) {
-      isComposing.value = false;
-      nextTick(() => afterComposition(event));
-    }
-  };
-  const handleComposition = (event) => {
-    event.type === "compositionend" ? handleCompositionEnd(event) : handleCompositionUpdate(event);
+  const t = c(!1), p = (o) => {
+    n?.("compositionstart", o), t.value = !0;
+  }, i = (o) => {
+    n?.("compositionupdate", o);
+    const a = o.target?.value, r = a[a.length - 1] || "";
+    t.value = !m(r);
+  }, s = (o) => {
+    n?.("compositionend", o), t.value && (t.value = !1, l(() => e(o)));
   };
   return {
-    isComposing,
-    handleComposition,
-    handleCompositionStart,
-    handleCompositionUpdate,
-    handleCompositionEnd
+    isComposing: t,
+    handleComposition: (o) => {
+      o.type === "compositionend" ? s(o) : i(o);
+    },
+    handleCompositionStart: p,
+    handleCompositionUpdate: i,
+    handleCompositionEnd: s
   };
 }
 export {
-  useComposition
+  f as useComposition
 };

package/es/hooks/use-delayed-toggle/index.js

@@ -1,10 +1,10 @@
-import { unref } from "vue";
+import { unref as t } from "vue";
 import "@vueuse/core";
-import { isNumber } from "@vft/utils";
+import { isNumber as c } from "@vft/utils";
 import "../../components/config-provider/hooks/use-global-config.js";
-import { buildProps } from "../../utils/vue/props/runtime.js";
-import { useTimeout } from "../use-timeout/index.js";
-const useDelayedToggleProps = buildProps({
+import { buildProps as a } from "../../utils/vue/props/runtime.js";
+import { useTimeout as s } from "../use-timeout/index.js";
+const h = a({
   /**
    * @description delay of appearance, in millisecond
    */
@@ -26,42 +26,35 @@ const useDelayedToggleProps = buildProps({
     type: Number,
     default: 0
   }
-});
-const useDelayedToggle = ({
-  showAfter,
-  hideAfter,
-  autoClose,
-  open,
-  close
+}), D = ({
+  showAfter: m,
+  hideAfter: i,
+  autoClose: n,
+  open: l,
+  close: r
 }) => {
-  const { registerTimeout } = useTimeout();
-  const {
-    registerTimeout: registerTimeoutForAutoClose,
-    cancelTimeout: cancelTimeoutForAutoClose
-  } = useTimeout();
-  const onOpen = (event) => {
-    registerTimeout(() => {
-      open(event);
-      const _autoClose = unref(autoClose);
-      if (isNumber(_autoClose) && _autoClose > 0) {
-        registerTimeoutForAutoClose(() => {
-          close(event);
-        }, _autoClose);
-      }
-    }, unref(showAfter));
-  };
-  const onClose = (event) => {
-    cancelTimeoutForAutoClose();
-    registerTimeout(() => {
-      close(event);
-    }, unref(hideAfter));
-  };
+  const { registerTimeout: u } = s(), {
+    registerTimeout: p,
+    cancelTimeout: f
+  } = s();
   return {
-    onOpen,
-    onClose
+    onOpen: (e) => {
+      u(() => {
+        l(e);
+        const o = t(n);
+        c(o) && o > 0 && p(() => {
+          r(e);
+        }, o);
+      }, t(m));
+    },
+    onClose: (e) => {
+      f(), u(() => {
+        r(e);
+      }, t(i));
+    }
   };
 };
 export {
-  useDelayedToggle,
-  useDelayedToggleProps
+  D as useDelayedToggle,
+  h as useDelayedToggleProps
 };

package/es/hooks/use-draggable/index.js

@@ -1,75 +1,45 @@
 import "@vueuse/core";
 import "@vft/utils";
-import { addUnit } from "../../utils/helper.js";
-import { onMounted, watchEffect, onBeforeUnmount } from "vue";
+import { addUnit as p } from "../../utils/helper.js";
+import { onMounted as W, watchEffect as B, onBeforeUnmount as U } from "vue";
 import "lodash-es";
-const useDraggable = (targetRef, dragRef, draggable) => {
-  let transform = {
+const q = (t, e, g) => {
+  let c = {
     offsetX: 0,
     offsetY: 0
   };
-  const onMousedown = (e) => {
-    const downX = e.clientX;
-    const downY = e.clientY;
-    const { offsetX, offsetY } = transform;
-    const targetRect = targetRef.value.getBoundingClientRect();
-    const targetLeft = targetRect.left;
-    const targetTop = targetRect.top;
-    const targetWidth = targetRect.width;
-    const targetHeight = targetRect.height;
-    const clientWidth = document.documentElement.clientWidth;
-    const clientHeight = document.documentElement.clientHeight;
-    const minLeft = -targetLeft + offsetX;
-    const minTop = -targetTop + offsetY;
-    const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
-    const maxTop = clientHeight - targetTop - targetHeight + offsetY;
-    const onMousemove = (e2) => {
-      const moveX = Math.min(
-        Math.max(offsetX + e2.clientX - downX, minLeft),
-        maxLeft
+  const m = (u) => {
+    const L = u.clientX, M = u.clientY, { offsetX: n, offsetY: s } = c, o = t.value.getBoundingClientRect(), a = o.left, l = o.top, w = o.width, X = o.height, Y = document.documentElement.clientWidth, x = document.documentElement.clientHeight, b = -a + n, D = -l + s, H = Y - a - w + n, T = x - l - X + s, r = (v) => {
+      const f = Math.min(
+        Math.max(n + v.clientX - L, b),
+        H
+      ), h = Math.min(
+        Math.max(s + v.clientY - M, D),
+        T
       );
-      const moveY = Math.min(
-        Math.max(offsetY + e2.clientY - downY, minTop),
-        maxTop
-      );
-      transform = {
-        offsetX: moveX,
-        offsetY: moveY
-      };
-      targetRef.value.style.transform = `translate(${addUnit(
-        moveX
-      )}, ${addUnit(moveY)})`;
-    };
-    const onMouseup = () => {
-      document.removeEventListener("mousemove", onMousemove);
-      document.removeEventListener("mouseup", onMouseup);
+      c = {
+        offsetX: f,
+        offsetY: h
+      }, t.value.style.transform = `translate(${p(
+        f
+      )}, ${p(h)})`;
+    }, d = () => {
+      document.removeEventListener("mousemove", r), document.removeEventListener("mouseup", d);
     };
-    document.addEventListener("mousemove", onMousemove);
-    document.addEventListener("mouseup", onMouseup);
-  };
-  const onDraggable = () => {
-    if (dragRef.value && targetRef.value) {
-      dragRef.value.addEventListener("mousedown", onMousedown);
-    }
+    document.addEventListener("mousemove", r), document.addEventListener("mouseup", d);
+  }, E = () => {
+    e.value && t.value && e.value.addEventListener("mousedown", m);
+  }, i = () => {
+    e.value && t.value && e.value.removeEventListener("mousedown", m);
   };
-  const offDraggable = () => {
-    if (dragRef.value && targetRef.value) {
-      dragRef.value.removeEventListener("mousedown", onMousedown);
-    }
-  };
-  onMounted(() => {
-    watchEffect(() => {
-      if (draggable.value) {
-        onDraggable();
-      } else {
-        offDraggable();
-      }
+  W(() => {
+    B(() => {
+      g.value ? E() : i();
     });
-  });
-  onBeforeUnmount(() => {
-    offDraggable();
+  }), U(() => {
+    i();
   });
 };
 export {
-  useDraggable
+  q as useDraggable
 };

package/es/hooks/use-empty-values/index.js

@@ -1,14 +1,10 @@
-import { getCurrentInstance, inject, ref, computed } from "vue";
+import { getCurrentInstance as v, inject as m, ref as r, computed as o } from "vue";
 import "@vueuse/core";
-import { isFunction } from "@vft/utils";
-import { debugWarn } from "../../utils/error.js";
+import { isFunction as t } from "@vft/utils";
+import { debugWarn as c } from "../../utils/error.js";
 import "../../components/config-provider/hooks/use-global-config.js";
-import { buildProps } from "../../utils/vue/props/runtime.js";
-const emptyValuesContextKey = Symbol("emptyValuesContextKey");
-const SCOPE = "use-empty-values";
-const DEFAULT_EMPTY_VALUES = ["", void 0, null];
-const DEFAULT_VALUE_ON_CLEAR = void 0;
-const useEmptyValuesProps = buildProps({
+import { buildProps as y } from "../../utils/vue/props/runtime.js";
+const C = Symbol("emptyValuesContextKey"), p = "use-empty-values", d = ["", void 0, null], f = void 0, _ = y({
   /**
    * @description empty values supported by the component
    */
@@ -19,43 +15,23 @@ const useEmptyValuesProps = buildProps({
   valueOnClear: {
     type: [String, Number, Boolean, Function],
     default: void 0,
-    validator: (val) => isFunction(val) ? !val() : !val
+    validator: (e) => t(e) ? !e() : !e
   }
-});
-const useEmptyValues = (props, defaultValue) => {
-  const config = getCurrentInstance() ? inject(emptyValuesContextKey, ref({})) : ref({});
-  const emptyValues = computed(
-    () => props.emptyValues || config.value.emptyValues || DEFAULT_EMPTY_VALUES
-  );
-  const valueOnClear = computed(() => {
-    if (isFunction(props.valueOnClear)) {
-      return props.valueOnClear();
-    } else if (props.valueOnClear !== void 0) {
-      return props.valueOnClear;
-    } else if (isFunction(config.value.valueOnClear)) {
-      return config.value.valueOnClear();
-    } else if (config.value.valueOnClear !== void 0) {
-      return config.value.valueOnClear;
-    }
-    return defaultValue !== void 0 ? defaultValue : DEFAULT_VALUE_ON_CLEAR;
-  });
-  const isEmptyValue = (value) => {
-    return emptyValues.value.includes(value);
-  };
-  if (!emptyValues.value.includes(valueOnClear.value)) {
-    debugWarn(SCOPE, "value-on-clear should be a value of empty-values");
-  }
-  return {
-    emptyValues,
-    valueOnClear,
-    isEmptyValue
+}), g = (e, a) => {
+  const l = v() ? m(C, r({})) : r({}), u = o(
+    () => e.emptyValues || l.value.emptyValues || d
+  ), n = o(() => t(e.valueOnClear) ? e.valueOnClear() : e.valueOnClear !== void 0 ? e.valueOnClear : t(l.value.valueOnClear) ? l.value.valueOnClear() : l.value.valueOnClear !== void 0 ? l.value.valueOnClear : a !== void 0 ? a : f), s = (i) => u.value.includes(i);
+  return u.value.includes(n.value) || c(p, "value-on-clear should be a value of empty-values"), {
+    emptyValues: u,
+    valueOnClear: n,
+    isEmptyValue: s
   };
 };
 export {
-  DEFAULT_EMPTY_VALUES,
-  DEFAULT_VALUE_ON_CLEAR,
-  SCOPE,
-  emptyValuesContextKey,
-  useEmptyValues,
-  useEmptyValuesProps
+  d as DEFAULT_EMPTY_VALUES,
+  f as DEFAULT_VALUE_ON_CLEAR,
+  p as SCOPE,
+  C as emptyValuesContextKey,
+  g as useEmptyValues,
+  _ as useEmptyValuesProps
 };

package/es/hooks/use-focus/index.js

@@ -1,10 +1,8 @@
-const useFocus = (el) => {
-  return {
-    focus: () => {
-      el.value?.focus?.();
-    }
-  };
-};
+const o = (u) => ({
+  focus: () => {
+    u.value?.focus?.();
+  }
+});
 export {
-  useFocus
+  o as useFocus
 };

package/es/hooks/use-focus-controller/index.js

@@ -1,68 +1,38 @@
-import { getCurrentInstance, shallowRef, ref, watch, unref, onMounted } from "vue";
-import { useEventListener } from "@vueuse/core";
-import { isElement, isFunction } from "@vft/utils";
-import { isFocusable } from "../../utils/dom/aria.js";
+import { getCurrentInstance as F, shallowRef as x, ref as b, watch as g, unref as c, onMounted as w } from "vue";
+import { useEventListener as u } from "@vueuse/core";
+import { isElement as C, isFunction as p } from "@vft/utils";
+import { isFocusable as k } from "../../utils/dom/aria.js";
 import "../../components/config-provider/hooks/use-global-config.js";
 import "lodash-es";
-function useFocusController(target, {
-  disabled,
-  beforeFocus,
-  afterFocus,
-  beforeBlur,
-  afterBlur
+function B(s, {
+  disabled: n,
+  beforeFocus: i,
+  afterFocus: v,
+  beforeBlur: f,
+  afterBlur: E
 } = {}) {
-  const instance = getCurrentInstance();
-  const { emit } = instance;
-  const wrapperRef = shallowRef();
-  const isFocused = ref(false);
-  const handleFocus = (event) => {
-    const cancelFocus = isFunction(beforeFocus) ? beforeFocus(event) : false;
-    if (unref(disabled) || isFocused.value || cancelFocus) return;
-    isFocused.value = true;
-    emit("focus", event);
-    afterFocus?.();
+  const d = F(), { emit: m } = d, t = x(), o = b(!1), a = (e) => {
+    const r = p(i) ? i(e) : !1;
+    c(n) || o.value || r || (o.value = !0, m("focus", e), v?.());
+  }, l = (e) => {
+    const r = p(f) ? f(e) : !1;
+    c(n) || e.relatedTarget && t.value?.contains(e.relatedTarget) || r || (o.value = !1, m("blur", e), E?.());
+  }, h = (e) => {
+    c(n) || k(e.target) || t.value?.contains(document.activeElement) && t.value !== document.activeElement || s.value?.focus();
   };
-  const handleBlur = (event) => {
-    const cancelBlur = isFunction(beforeBlur) ? beforeBlur(event) : false;
-    if (unref(disabled) || event.relatedTarget && wrapperRef.value?.contains(event.relatedTarget) || cancelBlur)
-      return;
-    isFocused.value = false;
-    emit("blur", event);
-    afterBlur?.();
-  };
-  const handleClick = (event) => {
-    if (unref(disabled) || isFocusable(event.target) || wrapperRef.value?.contains(document.activeElement) && wrapperRef.value !== document.activeElement)
-      return;
-    target.value?.focus();
-  };
-  watch([wrapperRef, () => unref(disabled)], ([el, disabled2]) => {
-    if (!el) return;
-    if (disabled2) {
-      el.removeAttribute("tabindex");
-    } else {
-      el.setAttribute("tabindex", "-1");
-    }
-  });
-  useEventListener(wrapperRef, "focus", handleFocus, true);
-  useEventListener(wrapperRef, "blur", handleBlur, true);
-  useEventListener(wrapperRef, "click", handleClick, true);
-  if (process.env.NODE_ENV === "test") {
-    onMounted(() => {
-      const targetEl = isElement(target.value) ? target.value : document.querySelector("input,textarea");
-      if (targetEl) {
-        useEventListener(targetEl, "focus", handleFocus, true);
-        useEventListener(targetEl, "blur", handleBlur, true);
-      }
-    });
-  }
-  return {
-    isFocused,
+  return g([t, () => c(n)], ([e, r]) => {
+    e && (r ? e.removeAttribute("tabindex") : e.setAttribute("tabindex", "-1"));
+  }), u(t, "focus", a, !0), u(t, "blur", l, !0), u(t, "click", h, !0), process.env.NODE_ENV === "test" && w(() => {
+    const e = C(s.value) ? s.value : document.querySelector("input,textarea");
+    e && (u(e, "focus", a, !0), u(e, "blur", l, !0));
+  }), {
+    isFocused: o,
     /** Avoid using wrapperRef and handleFocus/handleBlur together */
-    wrapperRef,
-    handleFocus,
-    handleBlur
+    wrapperRef: t,
+    handleFocus: a,
+    handleBlur: l
   };
 }
 export {
-  useFocusController
+  B as useFocusController
 };

package/es/hooks/use-forward-ref/index.js

@@ -1,28 +1,23 @@
-import { provide } from "vue";
-const FORWARD_REF_INJECTION_KEY = Symbol("vftForwardRef");
-const useForwardRef = (forwardRef) => {
-  const setForwardRef = (el) => {
-    forwardRef.value = el;
-  };
-  provide(FORWARD_REF_INJECTION_KEY, {
-    setForwardRef
-  });
-};
-const useForwardRefDirective = (setForwardRef) => {
-  return {
-    mounted(el) {
-      setForwardRef(el);
-    },
-    updated(el) {
-      setForwardRef(el);
-    },
-    unmounted() {
-      setForwardRef(null);
+import { provide as t } from "vue";
+const n = Symbol("vftForwardRef"), d = (e) => {
+  t(n, {
+    setForwardRef: (r) => {
+      e.value = r;
     }
-  };
-};
+  });
+}, s = (e) => ({
+  mounted(o) {
+    e(o);
+  },
+  updated(o) {
+    e(o);
+  },
+  unmounted() {
+    e(null);
+  }
+});
 export {
-  FORWARD_REF_INJECTION_KEY,
-  useForwardRef,
-  useForwardRefDirective
+  n as FORWARD_REF_INJECTION_KEY,
+  d as useForwardRef,
+  s as useForwardRefDirective
 };

package/es/hooks/use-id/index.js

@@ -1,38 +1,30 @@
-import { unref, inject, getCurrentInstance } from "vue";
-import { isClient, computedEager } from "@vueuse/core";
+import { unref as n, inject as i, getCurrentInstance as c } from "vue";
+import { isClient as s, computedEager as u } from "@vueuse/core";
 import "@vft/utils";
-import { debugWarn } from "../../utils/error.js";
+import { debugWarn as d } from "../../utils/error.js";
 import "../../components/config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useGetDerivedNamespace } from "../use-namespace/index.js";
-const defaultIdInjection = {
+import { useGetDerivedNamespace as p } from "../use-namespace/index.js";
+const r = {
   prefix: Math.floor(Math.random() * 1e4),
   current: 0
-};
-const ID_INJECTION_KEY = Symbol("vftIdInjection");
-const useIdInjection = () => {
-  return getCurrentInstance() ? inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
-};
-const useId = (deterministicId) => {
-  const idInjection = useIdInjection();
-  if (!isClient && idInjection === defaultIdInjection) {
-    debugWarn(
-      "IdInjection",
-      `Looks like you are using server rendering, you must provide a id provider to ensure the hydration process to be succeed
+}, m = Symbol("vftIdInjection"), a = () => c() ? i(m, r) : r, N = (t) => {
+  const e = a();
+  !s && e === r && d(
+    "IdInjection",
+    `Looks like you are using server rendering, you must provide a id provider to ensure the hydration process to be succeed
 usage: app.provide(ID_INJECTION_KEY, {
   prefix: number,
   current: number,
 })`
-    );
-  }
-  const namespace = useGetDerivedNamespace();
-  const idRef = computedEager(
-    () => unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`
   );
-  return idRef;
+  const o = p();
+  return u(
+    () => n(t) || `${o.value}-id-${e.prefix}-${e.current++}`
+  );
 };
 export {
-  ID_INJECTION_KEY,
-  useId,
-  useIdInjection
+  m as ID_INJECTION_KEY,
+  N as useId,
+  a as useIdInjection
 };

package/es/hooks/use-lockscreen/index.js

@@ -1,53 +1,35 @@
-import { hasClass, getStyle, addClass, removeClass } from "@vft/utils";
-import { isClient } from "@vueuse/core";
-import { getScrollBarWidth } from "../../utils/dom/scroll.js";
-import { throwError } from "../../utils/error.js";
+import { hasClass as r, getStyle as a, addClass as p, removeClass as f } from "@vft/utils";
+import { isClient as y } from "@vueuse/core";
+import { getScrollBarWidth as h } from "../../utils/dom/scroll.js";
+import { throwError as b } from "../../utils/error.js";
 import "../../components/config-provider/hooks/use-global-config.js";
-import { isRef, computed, watch, onScopeDispose } from "vue";
+import { isRef as v, computed as w, watch as C, onScopeDispose as H } from "vue";
 import "lodash-es";
-import { useNamespace } from "../use-namespace/index.js";
-const useLockscreen = (trigger, options = {}) => {
-  if (!isRef(trigger)) {
-    throwError(
-      "[useLockscreen]",
-      "You need to pass a ref param to this function"
-    );
-  }
-  const ns = options.ns || useNamespace("popup");
-  const hiddenCls = computed(() => ns.bm("parent", "hidden"));
-  if (!isClient || hasClass(document.body, hiddenCls.value)) {
+import { useNamespace as S } from "../use-namespace/index.js";
+const O = (s, l = {}) => {
+  v(s) || b(
+    "[useLockscreen]",
+    "You need to pass a ref param to this function"
+  );
+  const d = l.ns || S("popup"), o = w(() => d.bm("parent", "hidden"));
+  if (!y || r(document.body, o.value))
     return;
-  }
-  let scrollBarWidth = 0;
-  let withoutHiddenClass = false;
-  let bodyWidth = "0";
-  const cleanup = () => {
+  let t = 0, e = !1, n = "0";
+  const c = () => {
     setTimeout(() => {
-      removeClass(document?.body, hiddenCls.value);
-      if (withoutHiddenClass && document) {
-        document.body.style.width = bodyWidth;
-      }
+      f(document?.body, o.value), e && document && (document.body.style.width = n);
     }, 200);
   };
-  watch(trigger, (val) => {
-    if (!val) {
-      cleanup();
+  C(s, (m) => {
+    if (!m) {
+      c();
       return;
     }
-    withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
-    if (withoutHiddenClass) {
-      bodyWidth = document.body.style.width;
-    }
-    scrollBarWidth = getScrollBarWidth(ns.namespace.value);
-    const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
-    const bodyOverflowY = getStyle(document.body, "overflowY");
-    if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
-      document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
-    }
-    addClass(document.body, hiddenCls.value);
-  });
-  onScopeDispose(() => cleanup());
+    e = !r(document.body, o.value), e && (n = document.body.style.width), t = h(d.namespace.value);
+    const i = document.documentElement.clientHeight < document.body.scrollHeight, u = a(document.body, "overflowY");
+    t > 0 && (i || u === "scroll") && e && (document.body.style.width = `calc(100% - ${t}px)`), p(document.body, o.value);
+  }), H(() => c());
 };
 export {
-  useLockscreen
+  O as useLockscreen
 };