@vueuse/components 9.1.1 → 9.3.0

package/index.cjs

@@ -71,23 +71,21 @@ function onClickOutside(target, handler, options = {}) {
   const listener = (event) => {
     window.clearTimeout(fallback);
     const el = unrefElement(target);
-    const composedPath = event.composedPath();
-    if (!el || el === event.target || composedPath.includes(el) || !shouldListen.value)
+    if (!el || el === event.target || event.composedPath().includes(el) || !shouldListen.value)
       return;
-    if (ignore && ignore.length > 0) {
-      if (ignore.some((target2) => {
-        const el2 = unrefElement(target2);
-        return el2 && (event.target === el2 || composedPath.includes(el2));
-      }))
-        return;
-    }
     handler(event);
   };
+  const shouldIgnore = (event) => {
+    return ignore && ignore.some((target2) => {
+      const el = unrefElement(target2);
+      return el && (event.target === el || event.composedPath().includes(el));
+    });
+  };
   const cleanup = [
     useEventListener(window, "click", listener, { passive: true, capture }),
     useEventListener(window, "pointerdown", (e) => {
       const el = unrefElement(target);
-      shouldListen.value = !!el && !e.composedPath().includes(el);
+      shouldListen.value = !!el && !e.composedPath().includes(el) && !shouldIgnore(e);
     }, { passive: true }),
     useEventListener(window, "pointerup", (e) => {
       if (e.button === 0) {
@@ -107,18 +105,20 @@ function onClickOutside(target, handler, options = {}) {
   return stop;
 }
 
-const handler = () => {
-  let stop = null;
-  return (el, binding) => {
-    if (stop) {
-      stop();
-      stop = onClickOutside(el, binding.value);
-      return;
+const vOnClickOutside = {
+  [shared.directiveHooks.mounted](el, binding) {
+    const capture = !binding.modifiers.bubble;
+    if (typeof binding.value === "function") {
+      el.__onClickOutside_stop = onClickOutside(el, binding.value, { capture });
+    } else {
+      const [handler, options] = binding.value;
+      el.__onClickOutside_stop = onClickOutside(el, handler, Object.assign({ capture }, options));
     }
-    stop = onClickOutside(el, binding.value);
-  };
+  },
+  [shared.directiveHooks.unmounted](el) {
+    el.__onClickOutside_stop();
+  }
 };
-const vOnClickOutside = handler();
 
 const createKeyPredicate = (keyFilter) => {
   if (typeof keyFilter === "function")
@@ -127,12 +127,29 @@ const createKeyPredicate = (keyFilter) => {
     return (event) => event.key === keyFilter;
   else if (Array.isArray(keyFilter))
     return (event) => keyFilter.includes(event.key);
-  else if (keyFilter)
-    return () => true;
-  else
-    return () => false;
+  return () => true;
 };
-function onKeyStroke(key, handler, options = {}) {
+function onKeyStroke(...args) {
+  let key;
+  let handler;
+  let options = {};
+  if (args.length === 3) {
+    key = args[0];
+    handler = args[1];
+    options = args[2];
+  } else if (args.length === 2) {
+    if (typeof args[1] === "object") {
+      key = true;
+      handler = args[0];
+      options = args[1];
+    } else {
+      key = args[0];
+      handler = args[1];
+    }
+  } else {
+    key = true;
+    handler = args[0];
+  }
   const { target = defaultWindow, eventName = "keydown", passive = false } = options;
   const predicate = createKeyPredicate(key);
   const listener = (e) => {
@@ -161,7 +178,7 @@ var __spreadValues$d = (a, b) => {
 const vOnKeyStroke = {
   [shared.directiveHooks.mounted](el, binding) {
     var _a, _b;
-    const keys = (_b = (_a = binding.arg) == null ? void 0 : _a.split(",")) != null ? _b : [];
+    const keys = (_b = (_a = binding.arg) == null ? void 0 : _a.split(",")) != null ? _b : true;
     if (typeof binding.value === "function") {
       onKeyStroke(keys, binding.value, {
         target: el
@@ -179,11 +196,11 @@ const DEFAULT_DELAY = 500;
 function onLongPress(target, handler, options) {
   var _a, _b;
   const elementRef = vueDemi.computed(() => unrefElement(target));
-  let timeout = null;
+  let timeout;
   function clear() {
-    if (timeout != null) {
+    if (timeout) {
       clearTimeout(timeout);
-      timeout = null;
+      timeout = void 0;
     }
   }
   function onDown(ev) {
@@ -422,28 +439,27 @@ function useMediaQuery(query, options = {}) {
   const isSupported = useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function");
   let mediaQuery;
   const matches = vueDemi.ref(false);
+  const cleanup = () => {
+    if (!mediaQuery)
+      return;
+    if ("removeEventListener" in mediaQuery)
+      mediaQuery.removeEventListener("change", update);
+    else
+      mediaQuery.removeListener(update);
+  };
   const update = () => {
     if (!isSupported.value)
       return;
-    if (!mediaQuery)
-      mediaQuery = window.matchMedia(query);
+    cleanup();
+    mediaQuery = window.matchMedia(shared.resolveRef(query).value);
     matches.value = mediaQuery.matches;
-  };
-  shared.tryOnBeforeMount(() => {
-    update();
-    if (!mediaQuery)
-      return;
     if ("addEventListener" in mediaQuery)
       mediaQuery.addEventListener("change", update);
     else
       mediaQuery.addListener(update);
-    shared.tryOnScopeDispose(() => {
-      if ("removeEventListener" in mediaQuery)
-        mediaQuery.removeEventListener("change", update);
-      else
-        mediaQuery.removeListener(update);
-    });
-  });
+  };
+  vueDemi.watchEffect(update);
+  shared.tryOnScopeDispose(() => cleanup());
   return matches;
 }
 
@@ -649,12 +665,18 @@ const UseDraggable = vueDemi.defineComponent({
     "preventDefault",
     "stopPropagation",
     "pointerTypes",
-    "as"
+    "as",
+    "handle"
   ],
   setup(props, { slots }) {
     const target = vueDemi.ref();
+    const handle = vueDemi.computed(() => {
+      var _a;
+      return (_a = props.handle) != null ? _a : target.value;
+    });
     const initialValue = props.storageKey ? core.useStorage(props.storageKey, shared.resolveUnref(props.initialValue) || { x: 0, y: 0 }, core.isClient ? props.storageType === "session" ? sessionStorage : localStorage : void 0) : props.initialValue || { x: 0, y: 0 };
     const data = vueDemi.reactive(core.useDraggable(target, __spreadProps$8(__spreadValues$a({}, props), {
+      handle,
       initialValue
     })));
     return () => {
@@ -750,11 +772,18 @@ function useResizeObserver(target, callback, options = {}) {
 }
 
 function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {
+  const { box = "content-box" } = options;
   const width = vueDemi.ref(initialSize.width);
   const height = vueDemi.ref(initialSize.height);
   useResizeObserver(target, ([entry]) => {
-    width.value = entry.contentRect.width;
-    height.value = entry.contentRect.height;
+    const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;
+    if (boxSize) {
+      width.value = boxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);
+      height.value = boxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
+    } else {
+      width.value = entry.contentRect.width;
+      height.value = entry.contentRect.height;
+    }
   }, options);
   vueDemi.watch(() => unrefElement(target), (ele) => {
     width.value = ele ? initialSize.width : 0;
@@ -797,7 +826,7 @@ function useElementVisibility(element, { window = defaultWindow, scrollTarget }
     if (!window)
       return;
     const document = window.document;
-    const el = shared.resolveUnref(element);
+    const el = unrefElement(element);
     if (!el) {
       elementIsVisible.value = false;
     } else {
@@ -805,9 +834,12 @@ function useElementVisibility(element, { window = defaultWindow, scrollTarget }
       elementIsVisible.value = rect.top <= (window.innerHeight || document.documentElement.clientHeight) && rect.left <= (window.innerWidth || document.documentElement.clientWidth) && rect.bottom >= 0 && rect.right >= 0;
     }
   };
-  shared.tryOnMounted(testBounding);
+  vueDemi.watch(() => unrefElement(element), () => testBounding(), { immediate: true, flush: "post" });
   if (window) {
-    shared.tryOnMounted(() => useEventListener(() => shared.resolveUnref(scrollTarget) || window, "scroll", testBounding, { capture: false, passive: true }));
+    useEventListener(scrollTarget || window, "scroll", testBounding, {
+      capture: false,
+      passive: true
+    });
   }
   return elementIsVisible;
 }
@@ -999,10 +1031,38 @@ function useScroll(element, options = {}) {
     eventListenerOptions = {
       capture: false,
       passive: true
-    }
+    },
+    behavior = "auto"
   } = options;
-  const x = vueDemi.ref(0);
-  const y = vueDemi.ref(0);
+  const internalX = vueDemi.ref(0);
+  const internalY = vueDemi.ref(0);
+  const x = vueDemi.computed({
+    get() {
+      return internalX.value;
+    },
+    set(x2) {
+      scrollTo(x2, void 0);
+    }
+  });
+  const y = vueDemi.computed({
+    get() {
+      return internalY.value;
+    },
+    set(y2) {
+      scrollTo(void 0, y2);
+    }
+  });
+  function scrollTo(_x, _y) {
+    var _a, _b, _c;
+    const _element = shared.resolveUnref(element);
+    if (!_element)
+      return;
+    (_c = _element instanceof Document ? document.body : _element) == null ? void 0 : _c.scrollTo({
+      top: (_a = shared.resolveUnref(_y)) != null ? _a : y.value,
+      left: (_b = shared.resolveUnref(_x)) != null ? _b : x.value,
+      behavior: shared.resolveUnref(behavior)
+    });
+  }
   const isScrolling = vueDemi.ref(false);
   const arrivedState = vueDemi.reactive({
     left: true,
@@ -1027,19 +1087,19 @@ function useScroll(element, options = {}) {
   const onScrollHandler = (e) => {
     const eventTarget = e.target === document ? e.target.documentElement : e.target;
     const scrollLeft = eventTarget.scrollLeft;
-    directions.left = scrollLeft < x.value;
-    directions.right = scrollLeft > x.value;
+    directions.left = scrollLeft < internalX.value;
+    directions.right = scrollLeft > internalY.value;
     arrivedState.left = scrollLeft <= 0 + (offset.left || 0);
     arrivedState.right = scrollLeft + eventTarget.clientWidth >= eventTarget.scrollWidth - (offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
-    x.value = scrollLeft;
+    internalX.value = scrollLeft;
     let scrollTop = eventTarget.scrollTop;
     if (e.target === document && !scrollTop)
       scrollTop = document.body.scrollTop;
-    directions.top = scrollTop < y.value;
-    directions.bottom = scrollTop > y.value;
+    directions.top = scrollTop < internalY.value;
+    directions.bottom = scrollTop > internalY.value;
     arrivedState.top = scrollTop <= 0 + (offset.top || 0);
     arrivedState.bottom = scrollTop + eventTarget.clientHeight >= eventTarget.scrollHeight - (offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;
-    y.value = scrollTop;
+    internalY.value = scrollTop;
     isScrolling.value = true;
     onScrollEnd(e);
     onScroll(e);