@onereach/ui-components 8.20.1 → 8.20.2-beta.4019.0

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

@@ -1,167 +1,15 @@
-import { l as useMediaQuery } from '../../index-cc89d6b7.js';
+import { l as useMediaQuery } from '../../index-663755b4.js';
 import { getCurrentInstance, ref, watch, onMounted, isVue3, computed } from 'vue-demi';
 
-var createPlugin$2 = {};
-
-var createPlugin$1 = {};
-
-(function (exports) {
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-  Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function () {
-      return _default;
-    }
-  });
-  function createPlugin(plugin, config) {
-    return {
-      handler: plugin,
-      config
-    };
-  }
-  createPlugin.withOptions = function (pluginFunction) {
-    let configFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => ({});
-    const optionsFunction = function (options) {
-      return {
-        __options: options,
-        handler: pluginFunction(options),
-        config: configFunction(options)
-      };
-    };
-    optionsFunction.__isOptionsFunction = true;
-    // Expose plugin dependencies so that `object-hash` returns a different
-    // value if anything here changes, to ensure a rebuild is triggered.
-    optionsFunction.__pluginFunction = pluginFunction;
-    optionsFunction.__configFunction = configFunction;
-    return optionsFunction;
-  };
-  const _default = createPlugin;
-})(createPlugin$1);
-
-(function (exports) {
-
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-  Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function () {
-      return _default;
-    }
-  });
-  const _createPlugin = /*#__PURE__*/_interop_require_default(createPlugin$1);
-  function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-      default: obj
-    };
-  }
-  const _default = _createPlugin.default;
-})(createPlugin$2);
-
-let createPlugin = createPlugin$2;
-var plugin$1 = (createPlugin.__esModule ? createPlugin : {
-  default: createPlugin
-}).default;
-
-const plugin = plugin$1;
-
-const screens = {
-  'sm': '600px',
-  'md': '900px',
-  'lg': '1200px',
-  'xl': '1536px',
-};
-
-const variants = {
-  'mobile': '@media (hover: none)',
-  'desktop': '@media (hover: hover)',
-
-  'draggable': ['&[draggable]:not([draggable="false"])'],
-
-  'checked': ['&[checked]:not([checked="false"])', '&:checked'],
-  'selected': ['&[selected]:not([selected="false"])', '&:checked'],
-  'activated': ['&[activated]:not([activated="false"])'],
-
-  'enabled': ['&:not([disabled])', '&[disabled="false"]'],
-  'disabled': ['&[disabled]:not([disabled="false"])'],
-
-  'optional': ['&:not([required])', '&[required="false"]'],
-  'required': ['&[required]:not([required="false"])'],
-
-  'read-write': ['&:not([readonly])', '&[readonly="false"]'],
-  'read-only': ['&[readonly]:not([readonly="false"])'],
-
-  'valid': ['&:not([invalid])', '&[invalid="false"]'],
-  'invalid': ['&[invalid]:not([invalid="false"])'],
-
-  // Sub-components
-  'children': ['& > *'],
-
-  get 'hover'() {
-    return this['enabled'].flatMap((selector) => [
-      `${selector}:not(.interactivity-none):not([force-state]):hover`,
-      `${selector}:not(.interactivity-none)[force-state="hover"]`,
-    ]);
-  },
-
-  get 'focus'() {
-    return this['enabled'].flatMap((selector) => [
-      `${selector}:not(.interactivity-none):not([force-state]):focus`,
-      `${selector}:not(.interactivity-none)[force-state="focus"]`,
-    ]);
-  },
-
-  get 'focus-within'() {
-    return this['enabled'].flatMap((selector) => [
-      `${selector}:not(.interactivity-none):not([force-state]):focus-within`,
-      `${selector}:not(.interactivity-none)[force-state="focus-within"]`,
-    ]);
-  },
-
-  get 'focus-visible'() {
-    return this['enabled'].flatMap((selector) => [
-      `${selector}:not(.interactivity-none):not([force-state]):focus-visible`,
-      `${selector}:not(.interactivity-none)[force-state="focus-visible"]`,
-    ]);
-  },
-
-  get 'active'() {
-    return this['enabled'].flatMap((selector) => [
-      `${selector}:not(.interactivity-none):not([force-state]):active`,
-      `${selector}:not(.interactivity-none)[force-state="active"]`,
-    ]);
-  },
-};
-
-var core = {
-  screens,
-  variants,
-
-  plugin: plugin(({ addVariant, addUtilities }) => {
-    Object.entries(screens).forEach(([breakpoint, width]) => {
-      addVariant(breakpoint, [
-        `@media (min-width: ${width})`,
-        `[force-screen~="${breakpoint}"] &`,
-        `&[force-screen~="${breakpoint}"]`,
-      ]);
-    });
-
-    Object.entries(variants).forEach(([modifier, selectors]) => {
-      addVariant(modifier, selectors);
-    });
-
-    // TODO: Remove when migration complete
-    addUtilities({
-      '.visually-hidden': {
-        width: 0,
-        height: 0,
-        visibility: 'hidden',
-      },
-    });
-  }),
+var sm = "600px";
+var md = "900px";
+var lg = "1200px";
+var xl = "1536px";
+var screens = {
+	sm: sm,
+	md: md,
+	lg: lg,
+	xl: xl
 };
 
 function useResponsive(element) {
@@ -188,7 +36,7 @@ function useResponsive(element) {
   const isMobile = computed(() => {
     return !isDesktop.value;
   });
-  const desktopQuery = useMediaQuery(`(min-width: ${core.screens.md})`);
+  const desktopQuery = useMediaQuery(`(min-width: ${screens.md})`);
   // Helpers
   function isForcedDesktop(element) {
     var _a, _b;

package/dist/bundled/v2/index-559e7256.js

@@ -0,0 +1,266 @@
+import { effectScope, isRef, ref, watch, customRef, getCurrentScope, onScopeDispose, unref, toRef as toRef$1, readonly, toRefs as toRefs$1, getCurrentInstance, onMounted, nextTick } from 'vue-demi';
+
+function computedWithControl(source, fn) {
+  let v = void 0;
+  let track;
+  let trigger;
+  const dirty = ref(true);
+  const update = () => {
+    dirty.value = true;
+    trigger();
+  };
+  watch(source, update, { flush: "sync" });
+  const get = typeof fn === "function" ? fn : fn.get;
+  const set = typeof fn === "function" ? void 0 : fn.set;
+  const result = customRef((_track, _trigger) => {
+    track = _track;
+    trigger = _trigger;
+    return {
+      get() {
+        if (dirty.value) {
+          v = get();
+          dirty.value = false;
+        }
+        track();
+        return v;
+      },
+      set(v2) {
+        set == null ? void 0 : set(v2);
+      }
+    };
+  });
+  if (Object.isExtensible(result))
+    result.trigger = update;
+  return result;
+}
+
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+
+function createSharedComposable(composable) {
+  let subscribers = 0;
+  let state;
+  let scope;
+  const dispose = () => {
+    subscribers -= 1;
+    if (scope && subscribers <= 0) {
+      scope.stop();
+      state = void 0;
+      scope = void 0;
+    }
+  };
+  return (...args) => {
+    subscribers += 1;
+    if (!state) {
+      scope = effectScope(true);
+      state = scope.run(() => composable(...args));
+    }
+    tryOnScopeDispose(dispose);
+    return state;
+  };
+}
+
+function toValue(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+const isDef = (val) => typeof val !== "undefined";
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+const noop = () => {
+};
+const isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+  var _a;
+  return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /* @__PURE__ */ /iP(ad|hone|od)/.test(window.navigator.userAgent);
+}
+
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
+};
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = noop;
+  const _clearTimeout = (timer2) => {
+    clearTimeout(timer2);
+    lastRejector();
+    lastRejector = noop;
+  };
+  const filter = (invoke) => {
+    const duration = toValue(ms);
+    const maxDuration = toValue(options.maxWait);
+    if (timer)
+      _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      return Promise.resolve(invoke());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      if (maxDuration && !maxTimer) {
+        maxTimer = setTimeout(() => {
+          if (timer)
+            _clearTimeout(timer);
+          maxTimer = null;
+          resolve(invoke());
+        }, maxDuration);
+      }
+      timer = setTimeout(() => {
+        if (maxTimer)
+          _clearTimeout(maxTimer);
+        maxTimer = null;
+        resolve(invoke());
+      }, duration);
+    });
+  };
+  return filter;
+}
+
+function toRef(...args) {
+  if (args.length !== 1)
+    return toRef$1(...args);
+  const r = args[0];
+  return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
+}
+
+function useDebounceFn(fn, ms = 200, options = {}) {
+  return createFilterWrapper(
+    debounceFilter(ms, options),
+    fn
+  );
+}
+
+function refDebounced(value, ms = 200, options = {}) {
+  const debounced = ref(value.value);
+  const updater = useDebounceFn(() => {
+    debounced.value = value.value;
+  }, ms, options);
+  watch(value, () => updater());
+  return debounced;
+}
+
+function watchWithFilter(source, cb, options = {}) {
+  const {
+    eventFilter = bypassFilter,
+    ...watchOptions
+  } = options;
+  return watch(
+    source,
+    createFilterWrapper(
+      eventFilter,
+      cb
+    ),
+    watchOptions
+  );
+}
+
+function toRefs(objectRef, options = {}) {
+  if (!isRef(objectRef))
+    return toRefs$1(objectRef);
+  const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
+  for (const key in objectRef.value) {
+    result[key] = customRef(() => ({
+      get() {
+        return objectRef.value[key];
+      },
+      set(v) {
+        var _a;
+        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
+        if (replaceRef) {
+          if (Array.isArray(objectRef.value)) {
+            const copy = [...objectRef.value];
+            copy[key] = v;
+            objectRef.value = copy;
+          } else {
+            const newObject = { ...objectRef.value, [key]: v };
+            Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
+            objectRef.value = newObject;
+          }
+        } else {
+          objectRef.value[key] = v;
+        }
+      }
+    }));
+  }
+  return result;
+}
+
+function tryOnMounted(fn, sync = true) {
+  if (getCurrentInstance())
+    onMounted(fn);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+
+function useToggle(initialValue = false, options = {}) {
+  const {
+    truthyValue = true,
+    falsyValue = false
+  } = options;
+  const valueIsRef = isRef(initialValue);
+  const _value = ref(initialValue);
+  function toggle(value) {
+    if (arguments.length) {
+      _value.value = value;
+      return _value.value;
+    } else {
+      const truthy = toValue(truthyValue);
+      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
+      return _value.value;
+    }
+  }
+  if (valueIsRef)
+    return toggle;
+  else
+    return [_value, toggle];
+}
+
+function watchDebounced(source, cb, options = {}) {
+  const {
+    debounce = 0,
+    maxWait = void 0,
+    ...watchOptions
+  } = options;
+  return watchWithFilter(
+    source,
+    cb,
+    {
+      ...watchOptions,
+      eventFilter: debounceFilter(debounce, { maxWait })
+    }
+  );
+}
+
+function whenever(source, cb, options) {
+  return watch(
+    source,
+    (v, ov, onInvalidate) => {
+      if (v)
+        cb(v, ov, onInvalidate);
+    },
+    options
+  );
+}
+
+export { useDebounceFn as a, watchDebounced as b, clamp as c, createSharedComposable as d, isIOS as e, computedWithControl as f, toRefs as g, tryOnScopeDispose as h, isClient as i, tryOnMounted as j, toRef as k, isObject as l, isDef as m, noop as n, refDebounced as r, toValue as t, useToggle as u, whenever as w };