@varlet/use 2.8.6-alpha.1678026101378

package/LICENCE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 varlet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useEventListener.js';
+export * from './useClickOutside.js';
+export * from './useMounted';

package/lib/index.js

@@ -0,0 +1,3 @@
+export * from './useEventListener.js';
+export * from './useClickOutside.js';
+export * from './useMounted';

package/lib/useClickOutside.d.ts

@@ -0,0 +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;

package/lib/useClickOutside.js

@@ -0,0 +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);
+}

package/lib/useEventListener copy.d.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,63 @@
+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
+}

package/lib/useEventListener.d.ts

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

@@ -0,0 +1,58 @@
+import { inBrowser } 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 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;
+    };
+    useMounted(() => {
+        add(target);
+    });
+    onBeforeUnmount(() => {
+        remove(target);
+    });
+    onDeactivated(() => {
+        remove(target);
+    });
+    return cleanup;
+}

package/lib/useMounted.d.ts

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

package/lib/useMounted.js

@@ -0,0 +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();
+    });
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@varlet/use",
+  "version": "2.8.6-alpha.1678026101378",
+  "type": "module",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "description": "composable utils of varlet",
+  "keywords": [
+    "composable",
+    "utils",
+    "varlet"
+  ],
+  "author": "haoziqaq <357229046@qq.com>",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "tsconfig.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/varletjs/varlet.git"
+  },
+  "bugs": {
+    "url": "https://github.com/varletjs/varlet/issues"
+  },
+  "dependencies": {
+    "@varlet/shared": "2.8.6-alpha.1678026101378"
+  },
+  "devDependencies": {
+    "typescript": "^4.4.4",
+    "vue": "3.2.25"
+  },
+  "peerDependencies": {
+    "vue": "3.2.25"
+  },
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./lib"
+  }
+}