@maple-design/use 0.0.0-stage → 1.1.0

package/lib/index.js

@@ -0,0 +1,846 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/useEventListener.ts
+import { isRef, onBeforeUnmount, onDeactivated, unref, watch } from "vue";
+import { inBrowser, isFunction } from "@maple-design/shared";
+
+// src/onSmartMounted.ts
+import { nextTick, onActivated, onMounted } from "vue";
+function onSmartMounted(hook) {
+  let isMounted = false;
+  onMounted(() => {
+    hook();
+    nextTick(() => {
+      isMounted = true;
+    });
+  });
+  onActivated(() => {
+    if (!isMounted) {
+      return;
+    }
+    hook();
+  });
+}
+
+// src/useEventListener.ts
+function useEventListener(target, type, listener, options = {}) {
+  if (!inBrowser()) {
+    return () => {
+    };
+  }
+  const { passive = false, capture = false } = options;
+  let boundTarget;
+  let active = false;
+  let cleaned = false;
+  let stop;
+  const resolveTarget = () => {
+    var _a;
+    return (_a = isFunction(target) ? target() : unref(target)) != null ? _a : void 0;
+  };
+  const detach = () => {
+    boundTarget == null ? void 0 : boundTarget.removeEventListener(type, listener, { capture });
+    boundTarget = void 0;
+  };
+  const bind = () => {
+    if (!active || cleaned) {
+      return;
+    }
+    const next = resolveTarget();
+    if (next === boundTarget) {
+      return;
+    }
+    detach();
+    next == null ? void 0 : next.addEventListener(type, listener, { passive, capture });
+    boundTarget = next;
+  };
+  const cleanup = () => {
+    if (cleaned) {
+      return;
+    }
+    cleaned = true;
+    active = false;
+    stop == null ? void 0 : stop();
+    detach();
+  };
+  if (isRef(target) || isFunction(target)) {
+    stop = watch(resolveTarget, bind);
+  }
+  onSmartMounted(() => {
+    active = true;
+    bind();
+  });
+  onDeactivated(() => {
+    active = false;
+    detach();
+  });
+  onBeforeUnmount(cleanup);
+  return cleanup;
+}
+
+// src/useClickOutside.ts
+import { unref as unref2 } from "vue";
+import { inBrowser as inBrowser2, isFunction as isFunction2 } from "@maple-design/shared";
+function useClickOutside(target, type, listener) {
+  if (!inBrowser2()) {
+    return;
+  }
+  const handler = (event) => {
+    const element = isFunction2(target) ? target() : unref2(target);
+    if (element && !event.composedPath().includes(element) && !element.contains(event.target)) {
+      listener(event);
+    }
+  };
+  useEventListener(document, type, handler);
+}
+
+// src/onSmartUnmounted.ts
+import { onDeactivated as onDeactivated2, onUnmounted } from "vue";
+function onSmartUnmounted(hook) {
+  let keepalive = false;
+  onDeactivated2(() => {
+    keepalive = true;
+    hook();
+  });
+  onUnmounted(() => {
+    if (keepalive) {
+      return;
+    }
+    hook();
+  });
+}
+
+// src/useParent.ts
+import {
+  computed,
+  getCurrentInstance,
+  inject,
+  nextTick as nextTick2,
+  onActivated as onActivated2,
+  onBeforeUnmount as onBeforeUnmount2,
+  onDeactivated as onDeactivated3,
+  onMounted as onMounted2
+} from "vue";
+function keyInProvides(key) {
+  const instance = getCurrentInstance();
+  return key in instance.provides;
+}
+function useParent(key) {
+  if (!keyInProvides(key)) {
+    return {
+      index: null,
+      parentProvider: null,
+      bindParent: null
+    };
+  }
+  const provider = inject(key);
+  const _a = provider, { childInstances, collect, clear } = _a, parentProvider = __objRest(_a, ["childInstances", "collect", "clear"]);
+  const childInstance = getCurrentInstance();
+  const index = computed(() => childInstances.indexOf(childInstance));
+  const bindParent = (childProvider) => {
+    let active = false;
+    let registered = false;
+    const add = () => {
+      active = true;
+      nextTick2(() => {
+        if (active && !registered) {
+          collect(childInstance, childProvider);
+          registered = true;
+        }
+      });
+    };
+    const remove = () => {
+      active = false;
+      if (registered) {
+        clear(childInstance, childProvider);
+        registered = false;
+      }
+    };
+    onMounted2(add);
+    onActivated2(add);
+    onDeactivated3(remove);
+    onBeforeUnmount2(remove);
+  };
+  return {
+    index,
+    parentProvider,
+    bindParent
+  };
+}
+
+// src/useChildren.ts
+import {
+  computed as computed2,
+  getCurrentInstance as getCurrentInstance2,
+  isVNode,
+  onUpdated,
+  provide,
+  reactive
+} from "vue";
+import { isArray, removeItem } from "@maple-design/shared";
+function flatVNodes(subTree) {
+  const vNodes = [];
+  const flat = (subTree2) => {
+    if (subTree2 == null ? void 0 : subTree2.component) {
+      flat(subTree2 == null ? void 0 : subTree2.component.subTree);
+      return;
+    }
+    if (isArray(subTree2 == null ? void 0 : subTree2.children)) {
+      subTree2.children.forEach((child) => {
+        if (isVNode(child)) {
+          vNodes.push(child);
+          flat(child);
+        }
+      });
+    }
+  };
+  flat(subTree);
+  return vNodes;
+}
+function useChildren(key) {
+  const parentInstance = getCurrentInstance2();
+  const childInstances = reactive([]);
+  const childProviders = [];
+  const length = computed2(() => childInstances.length);
+  const sortInstances = () => {
+    const vNodes = flatVNodes(parentInstance.subTree);
+    const sorted = [...childInstances].sort((a, b) => vNodes.indexOf(a.vnode) - vNodes.indexOf(b.vnode));
+    if (sorted.every((instance, index) => instance === childInstances[index])) {
+      return;
+    }
+    const providers = sorted.map((instance) => childProviders[childInstances.indexOf(instance)]);
+    childInstances.splice(0, childInstances.length, ...sorted);
+    childProviders.splice(0, childProviders.length, ...providers);
+  };
+  onUpdated(sortInstances);
+  const collect = (childInstance, childProvider) => {
+    if (childInstances.includes(childInstance)) {
+      return;
+    }
+    childInstances.push(childInstance);
+    childProviders.push(childProvider);
+    sortInstances();
+  };
+  const clear = (childInstance, childProvider) => {
+    removeItem(childInstances, childInstance);
+    removeItem(childProviders, childProvider);
+  };
+  const bindChildren = (parentProvider) => {
+    provide(key, __spreadValues({
+      childInstances,
+      collect,
+      clear
+    }, parentProvider));
+  };
+  return {
+    length,
+    childProviders,
+    bindChildren
+  };
+}
+
+// src/onWindowResize.ts
+function onWindowResize(listener) {
+  useEventListener(() => window, "resize", listener, { passive: true });
+  useEventListener(() => window, "orientationchange", listener, { passive: true });
+}
+
+// src/useInitialized.ts
+import { ref, watch as watch2 } from "vue";
+function useInitialized(source, value) {
+  const initialized = ref(false);
+  watch2(
+    source,
+    (newValue) => {
+      if (value === newValue) {
+        initialized.value = true;
+      }
+    },
+    { immediate: true }
+  );
+  return initialized;
+}
+
+// src/useTouch.ts
+import { onBeforeUnmount as onBeforeUnmount3, onDeactivated as onDeactivated4, ref as ref2 } from "vue";
+import { getScrollTop } from "@maple-design/shared";
+function getDirection(x, y) {
+  if (x > y) {
+    return "horizontal";
+  }
+  if (y > x) {
+    return "vertical";
+  }
+}
+function useTouch() {
+  const startX = ref2(0);
+  const startY = ref2(0);
+  const deltaX = ref2(0);
+  const deltaY = ref2(0);
+  const offsetX = ref2(0);
+  const offsetY = ref2(0);
+  const prevX = ref2(0);
+  const prevY = ref2(0);
+  const moveX = ref2(0);
+  const moveY = ref2(0);
+  const direction = ref2();
+  const touching = ref2(false);
+  const dragging = ref2(false);
+  const startTime = ref2(0);
+  const distance = ref2(0);
+  let draggingAnimationFrame = null;
+  const cancelFrame = () => {
+    if (draggingAnimationFrame !== null && typeof window !== "undefined") {
+      window.cancelAnimationFrame(draggingAnimationFrame);
+    }
+    draggingAnimationFrame = null;
+  };
+  const resetTouch = () => {
+    cancelFrame();
+    startX.value = 0;
+    startY.value = 0;
+    deltaX.value = 0;
+    deltaY.value = 0;
+    offsetX.value = 0;
+    offsetY.value = 0;
+    prevX.value = 0;
+    prevY.value = 0;
+    moveX.value = 0;
+    moveY.value = 0;
+    direction.value = void 0;
+    touching.value = false;
+    dragging.value = false;
+    startTime.value = 0;
+    distance.value = 0;
+  };
+  const startTouch = (event) => {
+    resetTouch();
+    if (!event.touches.length) {
+      return;
+    }
+    const { clientX: x, clientY: y } = event.touches[0];
+    startX.value = x;
+    startY.value = y;
+    prevX.value = x;
+    prevY.value = y;
+    touching.value = true;
+    startTime.value = performance.now();
+    dragging.value = false;
+    if (draggingAnimationFrame) {
+      window.cancelAnimationFrame(draggingAnimationFrame);
+    }
+  };
+  const moveTouch = (event) => {
+    if (!event.touches.length) {
+      return;
+    }
+    const { clientX: x, clientY: y } = event.touches[0];
+    dragging.value = true;
+    deltaX.value = x - startX.value;
+    deltaY.value = y - startY.value;
+    offsetX.value = Math.abs(deltaX.value);
+    offsetY.value = Math.abs(deltaY.value);
+    distance.value = Math.sqrt(offsetX.value ** 2 + offsetY.value ** 2);
+    moveX.value = x - prevX.value;
+    moveY.value = y - prevY.value;
+    if (!direction.value) {
+      direction.value = getDirection(offsetX.value, offsetY.value);
+    }
+    prevX.value = x;
+    prevY.value = y;
+  };
+  const endTouch = () => {
+    touching.value = false;
+    cancelFrame();
+    if (typeof window === "undefined") {
+      dragging.value = false;
+      return;
+    }
+    draggingAnimationFrame = window.requestAnimationFrame(() => {
+      draggingAnimationFrame = null;
+      dragging.value = false;
+    });
+  };
+  const isReachTop = (element) => {
+    const scrollTop = getScrollTop(element);
+    return scrollTop === 0 && deltaY.value > 0;
+  };
+  const isReachBottom = (element, offset = 1) => {
+    const { scrollHeight, clientHeight, scrollTop } = element;
+    const offsetBottom = Math.abs(scrollHeight - scrollTop - clientHeight);
+    return deltaY.value < 0 && offsetBottom <= offset;
+  };
+  onBeforeUnmount3(resetTouch);
+  onDeactivated4(resetTouch);
+  return {
+    startX,
+    startY,
+    deltaX,
+    deltaY,
+    offsetX,
+    offsetY,
+    prevX,
+    prevY,
+    moveX,
+    moveY,
+    direction,
+    touching,
+    dragging,
+    startTime,
+    distance,
+    resetTouch,
+    startTouch,
+    moveTouch,
+    endTouch,
+    isReachTop,
+    isReachBottom
+  };
+}
+
+// src/useId.ts
+import * as Vue from "vue";
+import { kebabCase } from "@maple-design/shared";
+function useId2() {
+  var _a, _b;
+  const instance = Vue.getCurrentInstance();
+  const name = kebabCase((_a = instance.type.name) != null ? _a : "component");
+  const nativeId = (_b = Vue.useId) == null ? void 0 : _b();
+  const id = Vue.ref();
+  id.value = process.env.NODE_ENV === "test" ? `${name}-mock-id` : nativeId ? `${name}-${nativeId}` : void 0;
+  Vue.onMounted(() => {
+    if (id.value === void 0) {
+      id.value = `${name}-${instance.uid}`;
+    }
+  });
+  return id;
+}
+
+// src/useClientId.ts
+import { getCurrentInstance as getCurrentInstance4, onMounted as onMounted4, ref as ref4 } from "vue";
+import { kebabCase as kebabCase2 } from "@maple-design/shared";
+function useClientId() {
+  const instance = getCurrentInstance4();
+  const name = kebabCase2(instance.type.name);
+  const id = ref4(process.env.NODE_ENV === "test" ? `${name}-mock-id` : void 0);
+  onMounted4(() => {
+    if (process.env.NODE_ENV !== "test") {
+      id.value = `${name}-${instance.uid}`;
+    }
+  });
+  return id;
+}
+
+// src/useWindowSize.ts
+import { ref as ref5 } from "vue";
+import { inBrowser as inBrowser3 } from "@maple-design/shared";
+function useWindowSize(options = {}) {
+  const { initialWidth = 0, initialHeight = 0 } = options;
+  const width = ref5(initialWidth);
+  const height = ref5(initialHeight);
+  const update = () => {
+    if (!inBrowser3()) {
+      return;
+    }
+    width.value = window.innerWidth;
+    height.value = window.innerHeight;
+  };
+  onSmartMounted(update);
+  onWindowResize(update);
+  return {
+    width,
+    height
+  };
+}
+
+// src/useVModel.ts
+import { computed as computed3, nextTick as nextTick3, ref as ref6, watch as watch3 } from "vue";
+import { call } from "@maple-design/shared";
+function useVModel(props, key, options = {}) {
+  const { passive = true, eventName, defaultValue, emit } = options;
+  const event = eventName != null ? eventName : `${emit ? "update" : "onUpdate"}:${key.toString()}`;
+  const getValue = () => {
+    var _a;
+    return (_a = props[key]) != null ? _a : defaultValue;
+  };
+  if (!passive) {
+    return computed3({
+      get() {
+        return getValue();
+      },
+      set(value) {
+        emit ? emit(event, value) : call(props[event], value);
+      }
+    });
+  }
+  const proxy = ref6(getValue());
+  let shouldEmit = true;
+  watch3(
+    () => props[key],
+    () => {
+      shouldEmit = false;
+      proxy.value = getValue();
+      nextTick3(() => {
+        shouldEmit = true;
+      });
+    }
+  );
+  watch3(
+    () => proxy.value,
+    (newValue) => {
+      if (!shouldEmit) {
+        return;
+      }
+      emit ? emit(event, newValue) : call(props[event], newValue);
+    }
+  );
+  return proxy;
+}
+
+// src/useMotion.ts
+import { ref as ref7 } from "vue";
+import { isFunction as isFunction3, motion } from "@maple-design/shared";
+function useMotion(options) {
+  const value = ref7(getter(options.from));
+  const state = ref7("pending");
+  let ctx = createMotionContext();
+  function getter(value2) {
+    return isFunction3(value2) ? value2() : value2;
+  }
+  function reset() {
+    ctx.reset();
+    value.value = getter(options.from);
+    state.value = "pending";
+    ctx = createMotionContext();
+  }
+  function start() {
+    ctx.start();
+  }
+  function pause() {
+    ctx.pause();
+  }
+  function createMotionContext() {
+    return motion({
+      from: getter(options.from),
+      to: getter(options.to),
+      duration: options.duration === void 0 ? 300 : getter(options.duration),
+      timingFunction: options.timingFunction,
+      onStateChange(newState) {
+        state.value = newState;
+      },
+      frame({ value: newValue, done }) {
+        var _a;
+        value.value = newValue;
+        if (done) {
+          (_a = options.onFinished) == null ? void 0 : _a.call(options, value.value);
+        }
+      }
+    });
+  }
+  return {
+    value,
+    state,
+    start,
+    pause,
+    reset
+  };
+}
+
+// src/useAsyncData.ts
+import { getCurrentInstance as getCurrentInstance5, getCurrentScope, onMounted as onMounted5, onScopeDispose, readonly, ref as ref8, shallowRef } from "vue";
+function useAsyncData(loader, options) {
+  const data = shallowRef(options.initialData);
+  const loading = ref8(false);
+  const error = shallowRef();
+  const initialKey = Symbol("initial");
+  const cache = /* @__PURE__ */ new Map();
+  let active;
+  let last = {};
+  let disposed = false;
+  let started = false;
+  function cancel() {
+    const task = active;
+    active = void 0;
+    if (task) {
+      clearTimeout(task.timer);
+      task.controller.abort();
+      task.settle({ status: "cancelled" });
+    }
+    loading.value = false;
+  }
+  function run(request, delay) {
+    var _a, _b, _c;
+    cancel();
+    if (disposed) {
+      return Promise.resolve({ status: "cancelled" });
+    }
+    started = true;
+    last = request;
+    error.value = void 0;
+    const currentLoader = (_a = request.loader) != null ? _a : loader;
+    const key = (_b = request.cacheKey) != null ? _b : request.loader ? void 0 : initialKey;
+    const ttl = (_c = options.cacheTime) != null ? _c : 0;
+    const cached = key === void 0 ? void 0 : cache.get(key);
+    if (!request.force && ttl > 0 && cached && cached.expires > Date.now()) {
+      data.value = cached.data;
+      return Promise.resolve({ status: "success", data: cached.data });
+    }
+    if (key !== void 0) {
+      cache.delete(key);
+    }
+    loading.value = true;
+    return new Promise((settle) => {
+      const task = {
+        controller: new AbortController(),
+        settle,
+        timer: void 0
+      };
+      active = task;
+      const start = () => __async(this, null, function* () {
+        try {
+          const value = yield currentLoader({ signal: task.controller.signal });
+          if (active !== task) {
+            return;
+          }
+          data.value = value;
+          if (ttl > 0 && key !== void 0) {
+            if (cache.size >= 50) {
+              cache.delete(cache.keys().next().value);
+            }
+            cache.set(key, { data: value, expires: Date.now() + ttl });
+          }
+          settle({ status: "success", data: value });
+        } catch (cause) {
+          if (active !== task) {
+            return;
+          }
+          error.value = cause;
+          settle({ status: "error", error: cause });
+        } finally {
+          if (active === task) {
+            active = void 0;
+            loading.value = false;
+          }
+        }
+      });
+      if (delay > 0) {
+        task.timer = setTimeout(start, delay);
+      } else {
+        void start();
+      }
+    });
+  }
+  const execute = (request = {}) => {
+    var _a;
+    return run(request, (_a = options.debounce) != null ? _a : 0);
+  };
+  const refresh = () => run(__spreadProps(__spreadValues({}, last), { force: true }), 0);
+  const initialize = () => {
+    if (!started && !disposed && options.immediate !== false) {
+      void run({}, 0);
+    }
+  };
+  if (getCurrentInstance5()) {
+    onMounted5(initialize);
+  } else {
+    initialize();
+  }
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      disposed = true;
+      cancel();
+      cache.clear();
+    });
+  }
+  return {
+    data,
+    loading: readonly(loading),
+    error: readonly(error),
+    execute,
+    refresh,
+    cancel,
+    clearCache: () => cache.clear()
+  };
+}
+
+// src/useDirection.ts
+import {
+  computed as computed4,
+  getCurrentInstance as getCurrentInstance6,
+  inject as inject2,
+  onActivated as onActivated3,
+  onDeactivated as onDeactivated5,
+  onMounted as onMounted6,
+  onScopeDispose as onScopeDispose2,
+  provide as provide2,
+  ref as ref9,
+  shallowRef as shallowRef2,
+  watchPostEffect
+} from "vue";
+var readingDirectionKey = Symbol("reading-direction");
+function provideDirection(direction) {
+  provide2(readingDirectionKey, direction);
+}
+function resolveDirection(element, fallback = "ltr") {
+  var _a, _b;
+  const scope = element == null ? void 0 : element.closest("[dir]");
+  const value = (_a = scope == null ? void 0 : scope.getAttribute("dir")) == null ? void 0 : _a.toLowerCase();
+  if (value === "ltr" || value === "rtl") {
+    return value;
+  }
+  if (value === "auto" && scope) {
+    return ((_b = scope.ownerDocument.defaultView) == null ? void 0 : _b.getComputedStyle(scope).direction) === "rtl" ? "rtl" : "ltr";
+  }
+  return fallback;
+}
+var documents = /* @__PURE__ */ new WeakMap();
+function useDirection(target, explicit) {
+  const inherited = inject2(readingDirectionKey, void 0);
+  const instance = getCurrentInstance6();
+  const element = shallowRef2();
+  const version = shallowRef2();
+  let release;
+  let active = false;
+  function observe(node) {
+    var _a;
+    if (node === element.value && release) {
+      return;
+    }
+    release == null ? void 0 : release();
+    release = void 0;
+    element.value = node != null ? node : void 0;
+    version.value = void 0;
+    const doc = node == null ? void 0 : node.ownerDocument;
+    const Observer = (_a = doc == null ? void 0 : doc.defaultView) == null ? void 0 : _a.MutationObserver;
+    if (!doc || !Observer) {
+      return;
+    }
+    let state = documents.get(doc);
+    if (!state) {
+      const counter = ref9(0);
+      const observer = new Observer(() => {
+        counter.value++;
+      });
+      observer.observe(doc.documentElement, { subtree: true, attributes: true, attributeFilter: ["dir"] });
+      state = { version: counter, observer, users: 0 };
+      documents.set(doc, state);
+    }
+    state.users++;
+    version.value = state.version;
+    const current = state;
+    release = () => {
+      if (--current.users === 0) {
+        current.observer.disconnect();
+        documents.delete(doc);
+      }
+    };
+  }
+  function refresh() {
+    const node = target ? target() : instance == null ? void 0 : instance.vnode.el;
+    observe((node == null ? void 0 : node.nodeType) === 1 ? node : node == null ? void 0 : node.parentElement);
+  }
+  function start() {
+    active = true;
+    refresh();
+  }
+  function stop() {
+    active = false;
+    release == null ? void 0 : release();
+    release = void 0;
+    version.value = void 0;
+  }
+  onMounted6(start);
+  onActivated3(start);
+  onDeactivated5(stop);
+  onScopeDispose2(stop);
+  watchPostEffect(() => {
+    const node = target == null ? void 0 : target();
+    if (active) {
+      if (target) {
+        observe(node);
+      } else {
+        refresh();
+      }
+    }
+  });
+  const dir = computed4(() => {
+    var _a, _b;
+    void ((_a = version.value) == null ? void 0 : _a.value);
+    const value = explicit == null ? void 0 : explicit();
+    if (value === "ltr" || value === "rtl") {
+      return value;
+    }
+    return resolveDirection(element.value, (_b = inherited == null ? void 0 : inherited.value) != null ? _b : "ltr");
+  });
+  return { dir, isRtl: computed4(() => dir.value === "rtl") };
+}
+export {
+  keyInProvides,
+  onSmartMounted,
+  onSmartUnmounted,
+  onWindowResize,
+  provideDirection,
+  readingDirectionKey,
+  resolveDirection,
+  useAsyncData,
+  useChildren,
+  useClickOutside,
+  useClientId,
+  useDirection,
+  useEventListener,
+  useId2 as useId,
+  useInitialized,
+  useMotion,
+  useParent,
+  useTouch,
+  useVModel,
+  useWindowSize
+};