@onereach/ui-components 8.24.1-beta.4148.0 → 8.24.1-beta.4149.0

package/dist/bundled/v2/hooks/useTheme.js

@@ -3723,6 +3723,8 @@ var plugins = [
 	{
 	},
 	{
+	},
+	{
 	}
 ];
 var darkMode = [

package/dist/bundled/v2/{index-76f2ac63.js → index-13c63b4c.js}

@@ -1,4 +1,4 @@
-import { i as isClient, e as isIOS, n as noop, f as computedWithControl, g as resolveUnref, t as toRefs, h as tryOnScopeDispose, j as tryOnMounted, k as resolveRef, l as isString, m as identity, o as isFunction, p as isDef } from './index-1612099e.js';
+import { i as isClient, e as isIOS, n as noop, f as computedWithControl, g as resolveUnref, t as toRefs, h as tryOnScopeDispose, j as tryOnMounted, a as useDebounceFn, k as resolveRef, l as isString, m as useThrottleFn, o as identity, p as isFunction, q as isDef } from './index-279e78b9.js';
 import { ref, computed, watch, reactive, unref, getCurrentInstance, isVue2, watchEffect, readonly, getCurrentScope } from 'vue-demi';
 
 function unrefElement(elRef) {
@@ -478,6 +478,109 @@ function useFocus(target, options = {}) {
   return { focused };
 }
 
+const ARRIVED_STATE_THRESHOLD_PIXELS = 1;
+function useScroll(element, options = {}) {
+  const {
+    throttle = 0,
+    idle = 200,
+    onStop = noop,
+    onScroll = noop,
+    offset = {
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0
+    },
+    eventListenerOptions = {
+      capture: false,
+      passive: true
+    },
+    behavior = "auto"
+  } = options;
+  const internalX = ref(0);
+  const internalY = ref(0);
+  const x = computed({
+    get() {
+      return internalX.value;
+    },
+    set(x2) {
+      scrollTo(x2, void 0);
+    }
+  });
+  const y = computed({
+    get() {
+      return internalY.value;
+    },
+    set(y2) {
+      scrollTo(void 0, y2);
+    }
+  });
+  function scrollTo(_x, _y) {
+    var _a, _b, _c;
+    const _element = resolveUnref(element);
+    if (!_element)
+      return;
+    (_c = _element instanceof Document ? document.body : _element) == null ? void 0 : _c.scrollTo({
+      top: (_a = resolveUnref(_y)) != null ? _a : y.value,
+      left: (_b = resolveUnref(_x)) != null ? _b : x.value,
+      behavior: resolveUnref(behavior)
+    });
+  }
+  const isScrolling = ref(false);
+  const arrivedState = reactive({
+    left: true,
+    right: false,
+    top: true,
+    bottom: false
+  });
+  const directions = reactive({
+    left: false,
+    right: false,
+    top: false,
+    bottom: false
+  });
+  const onScrollEnd = (e) => {
+    if (!isScrolling.value)
+      return;
+    isScrolling.value = false;
+    directions.left = false;
+    directions.right = false;
+    directions.top = false;
+    directions.bottom = false;
+    onStop(e);
+  };
+  const onScrollEndDebounced = useDebounceFn(onScrollEnd, throttle + idle);
+  const onScrollHandler = (e) => {
+    const eventTarget = e.target === document ? e.target.documentElement : e.target;
+    const scrollLeft = eventTarget.scrollLeft;
+    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;
+    internalX.value = scrollLeft;
+    let scrollTop = eventTarget.scrollTop;
+    if (e.target === document && !scrollTop)
+      scrollTop = document.body.scrollTop;
+    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;
+    internalY.value = scrollTop;
+    isScrolling.value = true;
+    onScrollEndDebounced(e);
+    onScroll(e);
+  };
+  useEventListener(element, "scroll", throttle ? useThrottleFn(onScrollHandler, throttle, true, false) : onScrollHandler, eventListenerOptions);
+  useEventListener(element, "scrollend", onScrollEnd, eventListenerOptions);
+  return {
+    x,
+    y,
+    isScrolling,
+    arrivedState,
+    directions
+  };
+}
+
 const DefaultMagicKeysAliasMap = {
   ctrl: "control",
   command: "meta",
@@ -948,4 +1051,4 @@ function useVModel(props, key, emit, options = {}) {
   }
 }
 
-export { useMagicKeys as a, useActiveElement as b, useVModel as c, useElementBounding as d, useDraggable as e, useResizeObserver as f, useFocus as g, formatTimeAgo as h, useElementSize as i, useScrollLock as j, useMutationObserver as k, useMediaQuery as l, useEventBus as m, unrefElement as n, onClickOutside as o, usePointerSwipe as p, useElementHover as u };
+export { useMagicKeys as a, useActiveElement as b, useScroll as c, useVModel as d, useElementBounding as e, useDraggable as f, useResizeObserver as g, useFocus as h, formatTimeAgo as i, useElementSize as j, useScrollLock as k, useMutationObserver as l, useMediaQuery as m, useEventBus as n, onClickOutside as o, unrefElement as p, usePointerSwipe as q, useElementHover as u };

package/dist/bundled/v2/{index-1612099e.js → index-279e78b9.js}

@@ -66,6 +66,52 @@ function debounceFilter(ms, options = {}) {
   };
   return filter;
 }
+function throttleFilter(ms, trailing = true, leading = true, rejectOnCancel = false) {
+  let lastExec = 0;
+  let timer;
+  let isLeading = true;
+  let lastRejector = noop;
+  let lastValue;
+  const clear = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+      lastRejector();
+      lastRejector = noop;
+    }
+  };
+  const filter = (_invoke) => {
+    const duration = resolveUnref(ms);
+    const elapsed = Date.now() - lastExec;
+    const invoke = () => {
+      return lastValue = _invoke();
+    };
+    clear();
+    if (duration <= 0) {
+      lastExec = Date.now();
+      return invoke();
+    }
+    if (elapsed > duration && (leading || !isLeading)) {
+      lastExec = Date.now();
+      invoke();
+    } else if (trailing) {
+      lastValue = new Promise((resolve, reject) => {
+        lastRejector = rejectOnCancel ? reject : resolve;
+        timer = setTimeout(() => {
+          lastExec = Date.now();
+          isLeading = true;
+          resolve(invoke());
+          clear();
+        }, Math.max(0, duration - elapsed));
+      });
+    }
+    if (!leading && !timer)
+      timer = setTimeout(() => isLeading = true, duration);
+    isLeading = false;
+    return lastValue;
+  };
+  return filter;
+}
 function identity(arg) {
   return arg;
 }
@@ -148,6 +194,10 @@ function refDebounced(value, ms = 200, options = {}) {
   return debounced;
 }
 
+function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
+  return createFilterWrapper(throttleFilter(ms, trailing, leading, rejectOnCancel), fn);
+}
+
 function resolveRef(r) {
   return typeof r === "function" ? computed(r) : ref(r);
 }
@@ -303,4 +353,4 @@ function whenever(source, cb, options) {
   }, options);
 }
 
-export { useDebounceFn as a, watchDebounced as b, clamp as c, createSharedComposable as d, isIOS as e, computedWithControl as f, resolveUnref as g, tryOnScopeDispose as h, isClient as i, tryOnMounted as j, resolveRef as k, isString as l, identity as m, noop as n, isFunction as o, isDef as p, refDebounced as r, toRefs as t, useToggle as u, whenever as w };
+export { useDebounceFn as a, watchDebounced as b, clamp as c, createSharedComposable as d, isIOS as e, computedWithControl as f, resolveUnref as g, tryOnScopeDispose as h, isClient as i, tryOnMounted as j, resolveRef as k, isString as l, useThrottleFn as m, noop as n, identity as o, isFunction as p, isDef as q, refDebounced as r, toRefs as t, useToggle as u, whenever as w };

package/dist/bundled/v2/{index-017c190e.js → index-fb642013.js}

@@ -1,5 +1,5 @@
 import { computed } from 'vue-demi';
-import { g as resolveUnref } from './index-1612099e.js';
+import { g as resolveUnref } from './index-279e78b9.js';
 
 function logicAnd(...args) {
   return computed(() => args.every((i) => resolveUnref(i)));