@varlet/use 2.16.2 → 2.16.3-alpha.1694361535255

package/lib/index.d.ts

@@ -1,9 +1,68 @@
-export * from './useEventListener.js';
-export * from './useClickOutside.js';
-export * from './onSmartMounted.js';
-export * from './onSmartUnmounted.js';
-export * from './useParent.js';
-export * from './useChildren.js';
-export * from './onWindowResize.js';
-export * from './useInitialized.js';
-export * from './useTouch.js';
+import * as vue from 'vue';
+import { Ref, ComponentInternalInstance, ComputedRef, WatchSource } from 'vue';
+
+type UseEventListenerTarget = EventTarget | Ref<EventTarget | undefined | null> | (() => EventTarget);
+interface UseEventListenerOptions {
+    capture?: boolean;
+    passive?: boolean;
+}
+declare function useEventListener<T extends keyof DocumentEventMap>(target: UseEventListenerTarget, type: T, listener: (event: DocumentEventMap[T]) => void, options?: UseEventListenerOptions): () => void;
+declare function useEventListener(target: UseEventListenerTarget, type: string, listener: EventListener, options?: UseEventListenerOptions): () => void;
+
+type UseClickOutsideTarget = Element | Ref<Element | undefined | null> | (() => Element);
+declare function useClickOutside(target: UseClickOutsideTarget, type: string, listener: EventListener): void;
+
+declare function onSmartMounted(hook: () => void): void;
+
+declare function onSmartUnmounted(hook: () => void): void;
+
+interface UseChildrenBaseProvider<C> {
+    childInstances: ComponentInternalInstance[];
+    collect(instance: ComponentInternalInstance, childProvider: C): void;
+    clear(instance: ComponentInternalInstance, childProvider: C): void;
+}
+declare function useChildren<P, C>(key: symbol | string): {
+    length: ComputedRef<number>;
+    childProviders: C[];
+    bindChildren: (parentProvider: P) => void;
+};
+
+declare function keyInProvides(key: symbol | string): boolean;
+declare function useParent<P, C>(key: symbol | string): {
+    index: null;
+    parentProvider: null;
+    bindParent: null;
+} | {
+    index: ComputedRef<number>;
+    parentProvider: Omit<P & UseChildrenBaseProvider<C>, "childInstances" | "collect" | "clear">;
+    bindParent: (childProvider: C) => void;
+};
+
+declare function onWindowResize(listener: EventListener): void;
+
+declare function useInitialized<T>(source: WatchSource<T>, value: T): vue.Ref<boolean>;
+
+type TouchDirection = 'horizontal' | 'vertical';
+declare function useTouch(): {
+    startX: vue.Ref<number>;
+    startY: vue.Ref<number>;
+    deltaX: vue.Ref<number>;
+    deltaY: vue.Ref<number>;
+    offsetX: vue.Ref<number>;
+    offsetY: vue.Ref<number>;
+    prevX: vue.Ref<number>;
+    prevY: vue.Ref<number>;
+    moveX: vue.Ref<number>;
+    moveY: vue.Ref<number>;
+    direction: vue.Ref<TouchDirection | undefined>;
+    touching: vue.Ref<boolean>;
+    dragging: vue.Ref<boolean>;
+    startTime: vue.Ref<number>;
+    distance: vue.Ref<number>;
+    resetTouch: () => void;
+    startTouch: (event: TouchEvent) => void;
+    moveTouch: (event: TouchEvent) => void;
+    endTouch: () => void;
+};
+
+export { TouchDirection, UseChildrenBaseProvider, UseClickOutsideTarget, UseEventListenerOptions, UseEventListenerTarget, keyInProvides, onSmartMounted, onSmartUnmounted, onWindowResize, useChildren, useClickOutside, useEventListener, useInitialized, useParent, useTouch };

package/lib/index.js

@@ -1,9 +1,379 @@
-export * from './useEventListener.js';
-export * from './useClickOutside.js';
-export * from './onSmartMounted.js';
-export * from './onSmartUnmounted.js';
-export * from './useParent.js';
-export * from './useChildren.js';
-export * from './onWindowResize.js';
-export * from './useInitialized.js';
-export * from './useTouch.js';
+var __defProp = Object.defineProperty;
+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 __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;
+};
+
+// src/useEventListener.ts
+import { inBrowser, isFunction } from "@varlet/shared";
+import { isRef, onDeactivated, onBeforeUnmount, unref, watch } from "vue";
+
+// src/onSmartMounted.ts
+import { onMounted, nextTick, onActivated } 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 listening = false;
+  let cleaned = false;
+  const getElement = (target2) => isFunction(target2) ? target2() : unref(target2);
+  const add = (target2) => {
+    if (listening || cleaned) {
+      return;
+    }
+    const element = getElement(target2);
+    if (element) {
+      element.addEventListener(type, listener, {
+        passive,
+        capture
+      });
+      listening = true;
+    }
+  };
+  const remove = (target2) => {
+    if (!listening || cleaned) {
+      return;
+    }
+    const element = getElement(target2);
+    if (element) {
+      element.removeEventListener(type, listener, {
+        capture
+      });
+      listening = false;
+    }
+  };
+  let watchStopHandle;
+  if (isRef(target)) {
+    watchStopHandle = watch(
+      () => target.value,
+      (newValue, oldValue) => {
+        remove(oldValue);
+        add(newValue);
+      }
+    );
+  }
+  const cleanup = () => {
+    watchStopHandle == null ? void 0 : watchStopHandle();
+    remove(target);
+    cleaned = true;
+  };
+  onSmartMounted(() => {
+    add(target);
+  });
+  onBeforeUnmount(() => {
+    remove(target);
+  });
+  onDeactivated(() => {
+    remove(target);
+  });
+  return cleanup;
+}
+
+// src/useClickOutside.ts
+import { inBrowser as inBrowser2, isFunction as isFunction2 } from "@varlet/shared";
+import { unref as unref2 } from "vue";
+function useClickOutside(target, type, listener) {
+  if (!inBrowser2()) {
+    return;
+  }
+  const handler = (event) => {
+    const element = isFunction2(target) ? target() : unref2(target);
+    if (element && !element.contains(event.target)) {
+      listener(event);
+    }
+  };
+  useEventListener(document, type, handler);
+}
+
+// src/onSmartUnmounted.ts
+import { onDeactivated as onDeactivated2, onUnmounted } from "vue";
+function onSmartUnmounted(hook) {
+  onUnmounted(() => {
+    hook();
+  });
+  onDeactivated2(() => {
+    hook();
+  });
+}
+
+// src/useParent.ts
+import {
+  getCurrentInstance,
+  inject,
+  onMounted as onMounted2,
+  onBeforeUnmount as onBeforeUnmount2,
+  nextTick as nextTick2,
+  computed
+} 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) => {
+    onMounted2(() => {
+      nextTick2().then(() => {
+        collect(childInstance, childProvider);
+      });
+    });
+    onBeforeUnmount2(() => {
+      nextTick2().then(() => {
+        clear(childInstance, childProvider);
+      });
+    });
+  };
+  return {
+    index,
+    parentProvider,
+    bindParent
+  };
+}
+
+// src/useChildren.ts
+import { removeItem } from "@varlet/shared";
+import {
+  getCurrentInstance as getCurrentInstance2,
+  computed as computed2,
+  provide,
+  reactive,
+  isVNode
+} from "vue";
+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 (Array.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);
+    childInstances.sort((a, b) => vNodes.indexOf(a.vnode) - vNodes.indexOf(b.vnode));
+  };
+  const collect = (childInstance, childProvider) => {
+    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 { watch as watch2, ref } 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 { ref as ref2 } from "vue";
+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 resetTouch = () => {
+    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();
+    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) => {
+    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;
+    draggingAnimationFrame = window.requestAnimationFrame(() => {
+      dragging.value = false;
+    });
+  };
+  return {
+    startX,
+    startY,
+    deltaX,
+    deltaY,
+    offsetX,
+    offsetY,
+    prevX,
+    prevY,
+    moveX,
+    moveY,
+    direction,
+    touching,
+    dragging,
+    startTime,
+    distance,
+    resetTouch,
+    startTouch,
+    moveTouch,
+    endTouch
+  };
+}
+export {
+  keyInProvides,
+  onSmartMounted,
+  onSmartUnmounted,
+  onWindowResize,
+  useChildren,
+  useClickOutside,
+  useEventListener,
+  useInitialized,
+  useParent,
+  useTouch
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/use",
-  "version": "2.16.2",
+  "version": "2.16.3-alpha.1694361535255",
   "type": "module",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -24,10 +24,10 @@
     "url": "https://github.com/varletjs/varlet/issues"
   },
   "dependencies": {
-    "@varlet/shared": "2.16.2"
+    "@varlet/shared": "2.16.3-alpha.1694361535255"
   },
   "devDependencies": {
-    "rimraf": "^5.0.1",
+    "tsup": "7.2.0",
     "typescript": "^5.1.5",
     "vue": "3.3.4"
   },
@@ -35,7 +35,7 @@
     "vue": "^3.2.0"
   },
   "scripts": {
-    "dev": "tsc --watch",
-    "build": "rimraf ./lib && tsc"
+    "dev": "tsup src/index.ts --format esm --out-dir=lib --watch --dts",
+    "build": "tsup src/index.ts --format esm --out-dir=lib --dts --clean"
   }
 }

package/lib/onSmartMounted.d.ts

@@ -1 +0,0 @@
-export declare function onSmartMounted(hook: () => void): void;

package/lib/onSmartMounted.js

@@ -1,16 +0,0 @@
-import { onMounted, nextTick, onActivated } from 'vue';
-export function onSmartMounted(hook) {
-    let isMounted = false;
-    onMounted(() => {
-        hook();
-        nextTick(() => {
-            isMounted = true;
-        });
-    });
-    onActivated(() => {
-        if (!isMounted) {
-            return;
-        }
-        hook();
-    });
-}

package/lib/onSmartUnmounted.d.ts

@@ -1 +0,0 @@
-export declare function onSmartUnmounted(hook: () => void): void;

package/lib/onSmartUnmounted.js

@@ -1,9 +0,0 @@
-import { onDeactivated, onUnmounted } from 'vue';
-export function onSmartUnmounted(hook) {
-    onUnmounted(() => {
-        hook();
-    });
-    onDeactivated(() => {
-        hook();
-    });
-}

package/lib/onWindowResize.d.ts

@@ -1 +0,0 @@
-export declare function onWindowResize(listener: EventListener): void;

package/lib/onWindowResize.js

@@ -1,5 +0,0 @@
-import { useEventListener } from './useEventListener.js';
-export function onWindowResize(listener) {
-    useEventListener(() => window, 'resize', listener, { passive: true });
-    useEventListener(() => window, 'orientationchange', listener, { passive: true });
-}

package/lib/useChildren.d.ts

@@ -1,11 +0,0 @@
-import { type ComponentInternalInstance, type ComputedRef } from 'vue';
-export interface UseChildrenBaseProvider<C> {
-    childInstances: ComponentInternalInstance[];
-    collect(instance: ComponentInternalInstance, childProvider: C): void;
-    clear(instance: ComponentInternalInstance, childProvider: C): void;
-}
-export declare function useChildren<P, C>(key: symbol | string): {
-    length: ComputedRef<number>;
-    childProviders: C[];
-    bindChildren: (parentProvider: P) => void;
-};

package/lib/useChildren.js

@@ -1,50 +0,0 @@
-import { removeItem } from '@varlet/shared';
-import { getCurrentInstance, computed, provide, reactive, isVNode, } from 'vue';
-function flatVNodes(subTree) {
-    const vNodes = [];
-    const flat = (subTree) => {
-        if (subTree === null || subTree === void 0 ? void 0 : subTree.component) {
-            flat(subTree === null || subTree === void 0 ? void 0 : subTree.component.subTree);
-            return;
-        }
-        if (Array.isArray(subTree === null || subTree === void 0 ? void 0 : subTree.children)) {
-            subTree.children.forEach((child) => {
-                if (isVNode(child)) {
-                    vNodes.push(child);
-                    flat(child);
-                }
-            });
-        }
-    };
-    flat(subTree);
-    return vNodes;
-}
-export function useChildren(key) {
-    const parentInstance = getCurrentInstance();
-    const childInstances = reactive([]);
-    const childProviders = [];
-    const length = computed(() => childInstances.length);
-    const sortInstances = () => {
-        const vNodes = flatVNodes(parentInstance.subTree);
-        childInstances.sort((a, b) => vNodes.indexOf(a.vnode) - vNodes.indexOf(b.vnode));
-    };
-    const collect = (childInstance, childProvider) => {
-        childInstances.push(childInstance);
-        childProviders.push(childProvider);
-        sortInstances();
-    };
-    const clear = (childInstance, childProvider) => {
-        removeItem(childInstances, childInstance);
-        removeItem(childProviders, childProvider);
-    };
-    const bindChildren = (parentProvider) => {
-        provide(key, Object.assign({ childInstances,
-            collect,
-            clear }, parentProvider));
-    };
-    return {
-        length,
-        childProviders,
-        bindChildren,
-    };
-}

package/lib/useClickOutside.d.ts

@@ -1,3 +0,0 @@
-import { type Ref } from 'vue';
-export type UseClickOutsideTarget = Element | Ref<Element | undefined | null> | (() => Element);
-export declare function useClickOutside(target: UseClickOutsideTarget, type: string, listener: EventListener): void;

package/lib/useClickOutside.js

@@ -1,15 +0,0 @@
-import { useEventListener } from './useEventListener.js';
-import { inBrowser, isFunction } from '@varlet/shared';
-import { unref } from 'vue';
-export function useClickOutside(target, type, listener) {
-    if (!inBrowser()) {
-        return;
-    }
-    const handler = (event) => {
-        const element = isFunction(target) ? target() : unref(target);
-        if (element && !element.contains(event.target)) {
-            listener(event);
-        }
-    };
-    useEventListener(document, type, handler);
-}

package/lib/useEventListener.d.ts

@@ -1,8 +0,0 @@
-import { type Ref } from 'vue';
-export type UseEventListenerTarget = EventTarget | Ref<EventTarget | undefined | null> | (() => EventTarget);
-export interface UseEventListenerOptions {
-    capture?: boolean;
-    passive?: boolean;
-}
-export declare function useEventListener<T extends keyof DocumentEventMap>(target: UseEventListenerTarget, type: T, listener: (event: DocumentEventMap[T]) => void, options?: UseEventListenerOptions): () => void;
-export declare function useEventListener(target: UseEventListenerTarget, type: string, listener: EventListener, options?: UseEventListenerOptions): () => void;

package/lib/useEventListener.js

@@ -1,59 +0,0 @@
-import { inBrowser, isFunction } from '@varlet/shared';
-import { isRef, onDeactivated, onBeforeUnmount, unref, watch } from 'vue';
-import { onSmartMounted } from './onSmartMounted.js';
-export function useEventListener(target, type, listener, options = {}) {
-    if (!inBrowser()) {
-        return;
-    }
-    const { passive = false, capture = false } = options;
-    let listening = false;
-    let cleaned = false;
-    const getElement = (target) => isFunction(target) ? target() : unref(target);
-    const add = (target) => {
-        if (listening || cleaned) {
-            return;
-        }
-        const element = getElement(target);
-        if (element) {
-            element.addEventListener(type, listener, {
-                passive,
-                capture,
-            });
-            listening = true;
-        }
-    };
-    const remove = (target) => {
-        if (!listening || cleaned) {
-            return;
-        }
-        const element = getElement(target);
-        if (element) {
-            element.removeEventListener(type, listener, {
-                capture,
-            });
-            listening = false;
-        }
-    };
-    let watchStopHandle;
-    if (isRef(target)) {
-        watchStopHandle = watch(() => target.value, (newValue, oldValue) => {
-            remove(oldValue);
-            add(newValue);
-        });
-    }
-    const cleanup = () => {
-        watchStopHandle === null || watchStopHandle === void 0 ? void 0 : watchStopHandle();
-        remove(target);
-        cleaned = true;
-    };
-    onSmartMounted(() => {
-        add(target);
-    });
-    onBeforeUnmount(() => {
-        remove(target);
-    });
-    onDeactivated(() => {
-        remove(target);
-    });
-    return cleanup;
-}

package/lib/useInitialized.d.ts

@@ -1,2 +0,0 @@
-import { type WatchSource } from 'vue';
-export declare function useInitialized<T>(source: WatchSource<T>, value: T): import("vue").Ref<boolean>;

package/lib/useInitialized.js

@@ -1,10 +0,0 @@
-import { watch, ref } from 'vue';
-export function useInitialized(source, value) {
-    const initialized = ref(false);
-    watch(source, (newValue) => {
-        if (value === newValue) {
-            initialized.value = true;
-        }
-    }, { immediate: true });
-    return initialized;
-}

package/lib/useParent.d.ts

@@ -1,12 +0,0 @@
-import { type ComputedRef } from 'vue';
-import { type UseChildrenBaseProvider } from './useChildren.js';
-export declare function keyInProvides(key: symbol | string): boolean;
-export declare function useParent<P, C>(key: symbol | string): {
-    index: null;
-    parentProvider: null;
-    bindParent: null;
-} | {
-    index: ComputedRef<number>;
-    parentProvider: Omit<P & UseChildrenBaseProvider<C>, "childInstances" | "collect" | "clear">;
-    bindParent: (childProvider: C) => void;
-};

package/lib/useParent.js

@@ -1,46 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { getCurrentInstance, inject, onMounted, onBeforeUnmount, nextTick, computed, } from 'vue';
-export function keyInProvides(key) {
-    const instance = getCurrentInstance();
-    return key in instance.provides;
-}
-export function useParent(key) {
-    if (!keyInProvides(key)) {
-        return {
-            index: null,
-            parentProvider: null,
-            bindParent: null,
-        };
-    }
-    const provider = inject(key);
-    const { childInstances, collect, clear } = provider, parentProvider = __rest(provider, ["childInstances", "collect", "clear"]);
-    const childInstance = getCurrentInstance();
-    const index = computed(() => childInstances.indexOf(childInstance));
-    const bindParent = (childProvider) => {
-        onMounted(() => {
-            nextTick().then(() => {
-                collect(childInstance, childProvider);
-            });
-        });
-        onBeforeUnmount(() => {
-            nextTick().then(() => {
-                clear(childInstance, childProvider);
-            });
-        });
-    };
-    return {
-        index,
-        parentProvider,
-        bindParent,
-    };
-}

package/lib/useTouch.d.ts

@@ -1,22 +0,0 @@
-export type TouchDirection = 'horizontal' | 'vertical';
-export declare function useTouch(): {
-    startX: import("vue").Ref<number>;
-    startY: import("vue").Ref<number>;
-    deltaX: import("vue").Ref<number>;
-    deltaY: import("vue").Ref<number>;
-    offsetX: import("vue").Ref<number>;
-    offsetY: import("vue").Ref<number>;
-    prevX: import("vue").Ref<number>;
-    prevY: import("vue").Ref<number>;
-    moveX: import("vue").Ref<number>;
-    moveY: import("vue").Ref<number>;
-    direction: import("vue").Ref<TouchDirection | undefined>;
-    touching: import("vue").Ref<boolean>;
-    dragging: import("vue").Ref<boolean>;
-    startTime: import("vue").Ref<number>;
-    distance: import("vue").Ref<number>;
-    resetTouch: () => void;
-    startTouch: (event: TouchEvent) => void;
-    moveTouch: (event: TouchEvent) => void;
-    endTouch: () => void;
-};

package/lib/useTouch.js

@@ -1,101 +0,0 @@
-import { ref } from 'vue';
-function getDirection(x, y) {
-    if (x > y) {
-        return 'horizontal';
-    }
-    if (y > x) {
-        return 'vertical';
-    }
-}
-export function useTouch() {
-    const startX = ref(0);
-    const startY = ref(0);
-    const deltaX = ref(0);
-    const deltaY = ref(0);
-    const offsetX = ref(0);
-    const offsetY = ref(0);
-    const prevX = ref(0);
-    const prevY = ref(0);
-    const moveX = ref(0);
-    const moveY = ref(0);
-    const direction = ref();
-    const touching = ref(false);
-    const dragging = ref(false);
-    const startTime = ref(0);
-    const distance = ref(0);
-    let draggingAnimationFrame = null;
-    const resetTouch = () => {
-        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 = undefined;
-        touching.value = false;
-        dragging.value = false;
-        startTime.value = 0;
-        distance.value = 0;
-    };
-    const startTouch = (event) => {
-        resetTouch();
-        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) => {
-        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;
-        draggingAnimationFrame = window.requestAnimationFrame(() => {
-            dragging.value = false;
-        });
-    };
-    return {
-        startX,
-        startY,
-        deltaX,
-        deltaY,
-        offsetX,
-        offsetY,
-        prevX,
-        prevY,
-        moveX,
-        moveY,
-        direction,
-        touching,
-        dragging,
-        startTime,
-        distance,
-        resetTouch,
-        startTouch,
-        moveTouch,
-        endTouch,
-    };
-}