@varlet/use 2.10.0 → 2.10.1-alpha.1682608027166

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-export * from './useEventListener.js';
-export * from './useClickOutside.js';
-export * from './useMounted.js';
-export * from './useParent.js';
-export * from './useChildren.js';
+export * from './useEventListener.js';
+export * from './useClickOutside.js';
+export * from './useMounted.js';
+export * from './useParent.js';
+export * from './useChildren.js';

package/lib/index.js

@@ -1,5 +1,5 @@
-export * from './useEventListener.js';
-export * from './useClickOutside.js';
-export * from './useMounted.js';
-export * from './useParent.js';
-export * from './useChildren.js';
+export * from './useEventListener.js';
+export * from './useClickOutside.js';
+export * from './useMounted.js';
+export * from './useParent.js';
+export * from './useChildren.js';

package/lib/useChildren.d.ts

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

package/lib/useClickOutside.js

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

package/lib/useEventListener.d.ts

@@ -1,8 +1,8 @@
-import { type Ref } from 'vue';
-export declare 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;
+import { type Ref } from 'vue';
+export declare 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,61 +1,61 @@
-import { inBrowser, isFunction } from '@varlet/shared';
-import { isRef, onDeactivated, onBeforeUnmount, unref, watch } from 'vue';
-import { useMounted } from './useMounted.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) => {
-        return 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;
-    };
-    useMounted(() => {
-        add(target);
-    });
-    onBeforeUnmount(() => {
-        remove(target);
-    });
-    onDeactivated(() => {
-        remove(target);
-    });
-    return cleanup;
-}
+import { inBrowser, isFunction } from '@varlet/shared';
+import { isRef, onDeactivated, onBeforeUnmount, unref, watch } from 'vue';
+import { useMounted } from './useMounted.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) => {
+        return 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;
+    };
+    useMounted(() => {
+        add(target);
+    });
+    onBeforeUnmount(() => {
+        remove(target);
+    });
+    onDeactivated(() => {
+        remove(target);
+    });
+    return cleanup;
+}

package/lib/useMounted.d.ts

@@ -1 +1 @@
-export declare function useMounted(hook: () => void): void;
+export declare function useMounted(hook: () => void): void;

package/lib/useMounted.js

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

package/lib/useParent.d.ts

@@ -1,12 +1,12 @@
-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;
-};
+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 +1,46 @@
-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,
-    };
-}
+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/useVModel.d.ts

@@ -1,7 +1,7 @@
-export interface UseVModelOptions<P, K extends keyof P> {
-    passive?: boolean;
-    eventName?: string;
-    defaultValue?: P[K];
-    emit?: (event: string, value: P[K]) => void;
-}
-export declare function useVModel<P extends Record<string, any>, K extends keyof P>(props: P, key: K, options?: UseVModelOptions<P, K>): import("vue").WritableComputedRef<P[K]> | ([P[K]] extends [import("vue").Ref<any>] ? P[K] : import("vue").Ref<import("vue").UnwrapRef<P[K]>>);
+export interface UseVModelOptions<P, K extends keyof P> {
+    passive?: boolean;
+    eventName?: string;
+    defaultValue?: P[K];
+    emit?: (event: string, value: P[K]) => void;
+}
+export declare function useVModel<P extends Record<string, any>, K extends keyof P>(props: P, key: K, options?: UseVModelOptions<P, K>): import("vue").WritableComputedRef<P[K]> | ([P[K]] extends [import("vue").Ref<any>] ? P[K] : import("vue").Ref<import("vue").UnwrapRef<P[K]>>);

package/lib/useVModel.js

@@ -1,25 +1,25 @@
-import { computed, getCurrentInstance, ref, watch } from 'vue';
-export function useVModel(props, key, options = {}) {
-    const vm = getCurrentInstance();
-    const { passive = true, eventName, defaultValue, emit = vm === null || vm === void 0 ? void 0 : vm.emit } = options;
-    const event = eventName !== null && eventName !== void 0 ? eventName : `update:${key.toString()}`;
-    const getValue = () => (props[key] != null ? props[key] : defaultValue);
-    if (!passive) {
-        return computed({
-            get() {
-                return getValue();
-            },
-            set(value) {
-                emit(event, value);
-            },
-        });
-    }
-    const proxy = ref(getValue());
-    watch(() => props[key], () => {
-        proxy.value = getValue();
-    });
-    watch(() => proxy.value, (newValue) => {
-        emit(event, newValue);
-    });
-    return proxy;
-}
+import { computed, getCurrentInstance, ref, watch } from 'vue';
+export function useVModel(props, key, options = {}) {
+    const vm = getCurrentInstance();
+    const { passive = true, eventName, defaultValue, emit = vm === null || vm === void 0 ? void 0 : vm.emit } = options;
+    const event = eventName !== null && eventName !== void 0 ? eventName : `update:${key.toString()}`;
+    const getValue = () => (props[key] != null ? props[key] : defaultValue);
+    if (!passive) {
+        return computed({
+            get() {
+                return getValue();
+            },
+            set(value) {
+                emit(event, value);
+            },
+        });
+    }
+    const proxy = ref(getValue());
+    watch(() => props[key], () => {
+        proxy.value = getValue();
+    });
+    watch(() => proxy.value, (newValue) => {
+        emit(event, newValue);
+    });
+    return proxy;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/use",
-  "version": "2.10.0",
+  "version": "2.10.1-alpha.1682608027166",
   "type": "module",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -24,7 +24,7 @@
     "url": "https://github.com/varletjs/varlet/issues"
   },
   "dependencies": {
-    "@varlet/shared": "2.10.0"
+    "@varlet/shared": "2.10.1-alpha.1682608027166"
   },
   "devDependencies": {
     "typescript": "^4.4.4",

package/lib/useEventListener copy.d.ts

@@ -1,12 +0,0 @@
-import { type Ref } from 'vue'
-export declare type UseEventListenerTarget = EventTarget | undefined | Ref<EventTarget | undefined>
-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

package/lib/useEventListener copy.js

@@ -1,63 +0,0 @@
-import { inBrowser } from '@varlet/shared'
-import { isRef, onActivated, onDeactivated, onMounted, onUnmounted, unref, watch } from 'vue'
-export function useEventListener(target, type, listener, options = {}) {
-  if (!inBrowser()) {
-    return
-  }
-  const { passive = false, capture = false } = options
-  let listening = false
-  let cleaned = false
-  const add = (target) => {
-    if (listening || cleaned) {
-      return
-    }
-    const element = unref(target)
-    if (element) {
-      element.addEventListener(type, listener, {
-        passive,
-        capture,
-      })
-      listening = true
-    }
-  }
-  const remove = (target) => {
-    if (!listening || cleaned) {
-      return
-    }
-    const element = unref(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
-  }
-  onMounted(() => {
-    add(target)
-  })
-  onActivated(() => {
-    add(target)
-  })
-  onUnmounted(() => {
-    remove(target)
-  })
-  onDeactivated(() => {
-    remove(target)
-  })
-  return cleanup
-}