@rdeam/qui 2.0.0

package/es/hooks/tryOnScopeDispose/index.mjs

@@ -0,0 +1,18 @@
+import { getCurrentScope, onScopeDispose } from "vue";
+//#region packages/hooks/tryOnScopeDispose/index.ts
+/**
+* Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
+*
+* @param fn
+*/
+function tryOnScopeDispose(fn) {
+	if (getCurrentScope()) {
+		onScopeDispose(fn);
+		return true;
+	}
+	return false;
+}
+//#endregion
+export { tryOnScopeDispose };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/tryOnScopeDispose/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/tryOnScopeDispose/index.ts"],"sourcesContent":["import type { Fn } from '../utils'\r\nimport { getCurrentScope, onScopeDispose } from 'vue'\r\n\r\n/**\r\n * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing\r\n *\r\n * @param fn\r\n */\r\nexport function tryOnScopeDispose(fn: Fn) {\r\n  if (getCurrentScope()) {\r\n    onScopeDispose(fn)\r\n    return true\r\n  }\r\n  return false\r\n}\r\n"],"mappings":";;;;;;;AAQA,SAAgB,kBAAkB,IAAQ;AACxC,KAAI,iBAAiB,EAAE;AACrB,iBAAe,GAAG;AAClB,SAAO;;AAET,QAAO"}

package/es/hooks/unrefElement/index.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentPublicInstance, MaybeRef, MaybeRefOrGetter } from 'vue';
+export type VueInstance = ComponentPublicInstance;
+export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
+export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;
+export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
+export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;
+/**
+ * Get the dom element of a ref of element or Vue component instance
+ *
+ * @param elRef
+ */
+export declare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;

package/es/hooks/unrefElement/index.mjs

@@ -0,0 +1,16 @@
+import { toValue } from "vue";
+//#region packages/hooks/unrefElement/index.ts
+/**
+* Get the dom element of a ref of element or Vue component instance
+*
+* @param elRef
+*/
+function unrefElement(elRef) {
+	var _plain$$el;
+	const plain = toValue(elRef);
+	return (_plain$$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _plain$$el !== void 0 ? _plain$$el : plain;
+}
+//#endregion
+export { unrefElement };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/unrefElement/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/unrefElement/index.ts"],"sourcesContent":["import type { ComponentPublicInstance, MaybeRef, MaybeRefOrGetter } from 'vue'\r\nimport { toValue } from 'vue'\r\n\r\nexport type VueInstance = ComponentPublicInstance\r\nexport type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>\r\nexport type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>\r\nexport type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null\r\n\r\nexport type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance\r\n  ? Exclude<MaybeElement, VueInstance>\r\n  : T | undefined\r\n\r\n/**\r\n * Get the dom element of a ref of element or Vue component instance\r\n *\r\n * @param elRef\r\n */\r\nexport function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T> {\r\n  const plain = toValue(elRef)\r\n  return (plain as VueInstance)?.$el ?? plain\r\n}\r\n"],"mappings":";;;;;;;AAiBA,SAAgB,aAAqC,OAA0D;;CAC7G,MAAM,QAAQ,QAAQ,MAAM;AAC5B,SAAA,aAAA,UAAA,QAAA,UAAA,KAAA,IAAA,KAAA,IAAQ,MAAuB,SAAA,QAAA,eAAA,KAAA,IAAA,aAAO"}

package/es/hooks/use-full-screen/index.d.ts

@@ -0,0 +1 @@
+export declare function useFullScreen(): any;

package/es/hooks/use-full-screen/index.mjs

@@ -0,0 +1,32 @@
+//#region packages/hooks/use-full-screen/index.ts
+function useFullScreen() {
+	/**判断是否全屏*/
+	function isFullScreen() {
+		return document.fullscreenElement || document.msFullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement ? true : false;
+	}
+	/**实现F11全屏效果*/
+	function fullScreen() {
+		if (isFullScreen()) return;
+		const docElm = document.documentElement;
+		if (docElm.requestFullscreen) docElm.requestFullscreen();
+		else if (docElm.mozRequestFullScreen) docElm.mozRequestFullScreen();
+		else if (docElm.webkitRequestFullScreen) docElm.webkitRequestFullScreen();
+		else if (docElm.msRequestFullscreen) docElm.msRequestFullscreen();
+	}
+	/**退出F11全屏*/
+	function exitFullScreen() {
+		if (!isFullScreen()) return;
+		if (document.exitFullscreen) document.exitFullscreen();
+		else if (document.mozCancelFullScreen) document.mozCancelFullScreen();
+		else if (document.webkitCancelFullScreen) document.webkitCancelFullScreen();
+		else if (document.msExitFullscreen) document.msExitFullscreen();
+	}
+	function toggleFullScreen() {
+		isFullScreen() ? exitFullScreen() : fullScreen();
+	}
+	return { toggleFullScreen };
+}
+//#endregion
+export { useFullScreen };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/use-full-screen/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/use-full-screen/index.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/ban-ts-comment\r\n// @ts-nocheck\r\nexport function useFullScreen(): any {\r\n  /**判断是否全屏*/\r\n  function isFullScreen() {\r\n    return document.fullscreenElement ||\r\n      document.msFullscreenElement ||\r\n      document.mozFullScreenElement ||\r\n      document.webkitFullscreenElement\r\n      ? true\r\n      : false\r\n  }\r\n\r\n  /**实现F11全屏效果*/\r\n  function fullScreen() {\r\n    if (isFullScreen()) return\r\n    const docElm = document.documentElement\r\n    /*W3C*/\r\n    if (docElm.requestFullscreen) {\r\n      docElm.requestFullscreen()\r\n    } /*FireFox */ else if (docElm.mozRequestFullScreen) {\r\n      docElm.mozRequestFullScreen()\r\n    } /*Chrome等 */ else if (docElm.webkitRequestFullScreen) {\r\n      docElm.webkitRequestFullScreen()\r\n    } /*IE11*/ else if (docElm.msRequestFullscreen) {\r\n      docElm.msRequestFullscreen()\r\n    }\r\n  }\r\n  /**退出F11全屏*/\r\n  function exitFullScreen() {\r\n    if (!isFullScreen()) return\r\n    if (document.exitFullscreen) {\r\n      document.exitFullscreen()\r\n    } else if (document.mozCancelFullScreen) {\r\n      document.mozCancelFullScreen()\r\n    } else if (document.webkitCancelFullScreen) {\r\n      document.webkitCancelFullScreen()\r\n    } else if (document.msExitFullscreen) {\r\n      document.msExitFullscreen()\r\n    }\r\n  }\r\n  // 在全屏与非全屏之间来回切换\r\n  function toggleFullScreen() {\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-expressions\r\n    isFullScreen() ? exitFullScreen() : fullScreen()\r\n  }\r\n  return {\r\n    toggleFullScreen,\r\n  }\r\n}\r\n"],"mappings":";AAEA,SAAgB,gBAAqB;;CAEnC,SAAS,eAAe;AACtB,SAAO,SAAS,qBACd,SAAS,uBACT,SAAS,wBACT,SAAS,0BACP,OACA;;;CAIN,SAAS,aAAa;AACpB,MAAI,cAAc,CAAE;EACpB,MAAM,SAAS,SAAS;AAExB,MAAI,OAAO,kBACT,QAAO,mBAAmB;WACJ,OAAO,qBAC7B,QAAO,sBAAsB;WACP,OAAO,wBAC7B,QAAO,yBAAyB;WACd,OAAO,oBACzB,QAAO,qBAAqB;;;CAIhC,SAAS,iBAAiB;AACxB,MAAI,CAAC,cAAc,CAAE;AACrB,MAAI,SAAS,eACX,UAAS,gBAAgB;WAChB,SAAS,oBAClB,UAAS,qBAAqB;WACrB,SAAS,uBAClB,UAAS,wBAAwB;WACxB,SAAS,iBAClB,UAAS,kBAAkB;;CAI/B,SAAS,mBAAmB;AAE1B,gBAAc,GAAG,gBAAgB,GAAG,YAAY;;AAElD,QAAO,EACL,kBACD"}

package/es/hooks/useEventListener/index.d.ts

@@ -0,0 +1,83 @@
+import type { Arrayable, Fn } from '../utils/types.js';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+interface InferEventTarget<Events> {
+    addEventListener: (event: Events, fn?: any, options?: any) => any;
+    removeEventListener: (event: Events, fn?: any, options?: any) => any;
+}
+export type WindowEventName = keyof WindowEventMap;
+export type DocumentEventName = keyof DocumentEventMap;
+export interface GeneralEventListener<E = Event> {
+    (evt: E): void;
+}
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 1: Omitted Window target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<E extends keyof WindowEventMap>(event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 2: Explicitly Window target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<E extends keyof WindowEventMap>(target: Window, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 3: Explicitly Document target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<E extends keyof DocumentEventMap>(target: DocumentOrShadowRoot, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 4: Explicitly HTMLElement target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<E extends keyof HTMLElementEventMap>(target: MaybeRefOrGetter<Arrayable<HTMLElement> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<(this: HTMLElement, ev: HTMLElementEventMap[E]) => any>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): () => void;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 5: Custom event target with event type infer
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<Names extends string, EventType = Event>(target: MaybeRefOrGetter<Arrayable<InferEventTarget<Names>> | null | undefined>, event: MaybeRefOrGetter<Arrayable<Names>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 6: Custom event target fallback
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<EventType = Event>(target: MaybeRefOrGetter<Arrayable<EventTarget> | null | undefined>, event: MaybeRefOrGetter<Arrayable<string>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+export {};

package/es/hooks/useEventListener/index.mjs

@@ -0,0 +1,47 @@
+import { tryOnScopeDispose } from "../tryOnScopeDispose/index.mjs";
+import { isObject } from "../utils/is.mjs";
+import { toArray } from "../utils/general.mjs";
+import { defaultWindow } from "../_configurable.mjs";
+import { unrefElement } from "../unrefElement/index.mjs";
+import { watchImmediate } from "../watchImmediate/index.mjs";
+import { computed, toValue, unref } from "vue";
+//#region packages/hooks/useEventListener/index.ts
+function useEventListener(...args) {
+	const cleanups = [];
+	const cleanup = () => {
+		cleanups.forEach((fn) => fn());
+		cleanups.length = 0;
+	};
+	const register = (el, event, listener, options) => {
+		el.addEventListener(event, listener, options);
+		return () => el.removeEventListener(event, listener, options);
+	};
+	const firstParamTargets = computed(() => {
+		const test = toArray(toValue(args[0])).filter((e) => e != null);
+		return test.every((e) => typeof e !== "string") ? test : void 0;
+	});
+	const stopWatch = watchImmediate(() => {
+		var _firstParamTargets$va, _firstParamTargets$va2;
+		return [
+			(_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
+			toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
+			toArray(unref(firstParamTargets.value ? args[2] : args[1])),
+			toValue(firstParamTargets.value ? args[3] : args[2])
+		];
+	}, ([raw_targets, raw_events, raw_listeners, raw_options]) => {
+		cleanup();
+		if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
+		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+		cleanups.push(...raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone)))));
+	}, { flush: "post" });
+	const stop = () => {
+		stopWatch();
+		cleanup();
+	};
+	tryOnScopeDispose(cleanup);
+	return stop;
+}
+//#endregion
+export { useEventListener };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/useEventListener/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/useEventListener/index.ts"],"sourcesContent":["import type { Arrayable, Fn } from '../utils/types'\r\nimport type { MaybeRef, MaybeRefOrGetter } from 'vue'\r\nimport { isObject, toArray } from '../utils'\r\nimport { tryOnScopeDispose } from '../tryOnScopeDispose'\r\nimport { watchImmediate } from '../watchImmediate'\r\n\r\nimport { computed, toValue, unref } from 'vue'\r\nimport { defaultWindow } from '../_configurable'\r\nimport { unrefElement } from '../unrefElement'\r\n\r\ninterface InferEventTarget<Events> {\r\n  addEventListener: (event: Events, fn?: any, options?: any) => any\r\n  removeEventListener: (event: Events, fn?: any, options?: any) => any\r\n}\r\n\r\nexport type WindowEventName = keyof WindowEventMap\r\nexport type DocumentEventName = keyof DocumentEventMap\r\n\r\nexport interface GeneralEventListener<E = Event> {\r\n  (evt: E): void\r\n}\r\n\r\n/**\r\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\r\n *\r\n * Overload 1: Omitted Window target\r\n *\r\n * @see https://vueuse.org/useEventListener\r\n * @param event\r\n * @param listener\r\n * @param options\r\n */\r\n\r\nexport function useEventListener<E extends keyof WindowEventMap>(\r\n  event: MaybeRefOrGetter<Arrayable<E>>,\r\n  listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>,\r\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>,\r\n): Fn\r\n\r\n/**\r\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\r\n *\r\n * Overload 2: Explicitly Window target\r\n *\r\n * @see https://vueuse.org/useEventListener\r\n * @param target\r\n * @param event\r\n * @param listener\r\n * @param options\r\n */\r\nexport function useEventListener<E extends keyof WindowEventMap>(\r\n  target: Window,\r\n  event: MaybeRefOrGetter<Arrayable<E>>,\r\n  listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>,\r\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>,\r\n): Fn\r\n\r\n/**\r\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\r\n *\r\n * Overload 3: Explicitly Document target\r\n *\r\n * @see https://vueuse.org/useEventListener\r\n * @param target\r\n * @param event\r\n * @param listener\r\n * @param options\r\n */\r\nexport function useEventListener<E extends keyof DocumentEventMap>(\r\n  target: DocumentOrShadowRoot,\r\n  event: MaybeRefOrGetter<Arrayable<E>>,\r\n  listener: MaybeRef<Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>>,\r\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>,\r\n): Fn\r\n\r\n/**\r\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\r\n *\r\n * Overload 4: Explicitly HTMLElement target\r\n *\r\n * @see https://vueuse.org/useEventListener\r\n * @param target\r\n * @param event\r\n * @param listener\r\n * @param options\r\n */\r\nexport function useEventListener<E extends keyof HTMLElementEventMap>(\r\n  target: MaybeRefOrGetter<Arrayable<HTMLElement> | null | undefined>,\r\n  event: MaybeRefOrGetter<Arrayable<E>>,\r\n  listener: MaybeRef<(this: HTMLElement, ev: HTMLElementEventMap[E]) => any>,\r\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>,\r\n): () => void\r\n\r\n/**\r\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\r\n *\r\n * Overload 5: Custom event target with event type infer\r\n *\r\n * @see https://vueuse.org/useEventListener\r\n * @param target\r\n * @param event\r\n * @param listener\r\n * @param options\r\n */\r\nexport function useEventListener<Names extends string, EventType = Event>(\r\n  target: MaybeRefOrGetter<Arrayable<InferEventTarget<Names>> | null | undefined>,\r\n  event: MaybeRefOrGetter<Arrayable<Names>>,\r\n  listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>,\r\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>,\r\n): Fn\r\n\r\n/**\r\n * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.\r\n *\r\n * Overload 6: Custom event target fallback\r\n *\r\n * @see https://vueuse.org/useEventListener\r\n * @param target\r\n * @param event\r\n * @param listener\r\n * @param options\r\n */\r\nexport function useEventListener<EventType = Event>(\r\n  target: MaybeRefOrGetter<Arrayable<EventTarget> | null | undefined>,\r\n  event: MaybeRefOrGetter<Arrayable<string>>,\r\n  listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>,\r\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>,\r\n): Fn\r\n\r\nexport function useEventListener(...args: Parameters<typeof useEventListener>) {\r\n  const cleanups: Function[] = []\r\n  const cleanup = () => {\r\n    cleanups.forEach((fn) => fn())\r\n    cleanups.length = 0\r\n  }\r\n\r\n  const register = (\r\n    el: EventTarget,\r\n    event: string,\r\n    listener: any,\r\n    options: boolean | AddEventListenerOptions | undefined,\r\n  ) => {\r\n    el.addEventListener(event, listener, options)\r\n    return () => el.removeEventListener(event, listener, options)\r\n  }\r\n\r\n  const firstParamTargets = computed(() => {\r\n    const test = toArray(toValue(args[0])).filter((e) => e != null)\r\n    return test.every((e) => typeof e !== 'string') ? test : undefined\r\n  })\r\n\r\n  const stopWatch = watchImmediate(\r\n    () =>\r\n      [\r\n        firstParamTargets.value?.map((e) => unrefElement(e as never)) ?? [defaultWindow].filter((e) => e != null),\r\n        toArray(toValue(firstParamTargets.value ? args[1] : args[0]) as string[]),\r\n        toArray(unref(firstParamTargets.value ? args[2] : args[1]) as Function[]),\r\n        toValue(firstParamTargets.value ? args[3] : args[2]) as boolean | AddEventListenerOptions | undefined,\r\n      ] as const,\r\n    ([raw_targets, raw_events, raw_listeners, raw_options]) => {\r\n      cleanup()\r\n\r\n      if (!raw_targets?.length || !raw_events?.length || !raw_listeners?.length) return\r\n\r\n      // create a clone of options, to avoid it being changed reactively on removal\r\n      const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options\r\n      cleanups.push(\r\n        ...raw_targets.flatMap((el) =>\r\n          raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))),\r\n        ),\r\n      )\r\n    },\r\n    { flush: 'post' },\r\n  )\r\n\r\n  const stop = () => {\r\n    stopWatch()\r\n    cleanup()\r\n  }\r\n\r\n  tryOnScopeDispose(cleanup)\r\n\r\n  return stop\r\n}\r\n"],"mappings":";;;;;;;;AAiIA,SAAgB,iBAAiB,GAAG,MAA2C;CAC7E,MAAM,WAAuB,EAAE;CAC/B,MAAM,gBAAgB;AACpB,WAAS,SAAS,OAAO,IAAI,CAAC;AAC9B,WAAS,SAAS;;CAGpB,MAAM,YACJ,IACA,OACA,UACA,YACG;AACH,KAAG,iBAAiB,OAAO,UAAU,QAAQ;AAC7C,eAAa,GAAG,oBAAoB,OAAO,UAAU,QAAQ;;CAG/D,MAAM,oBAAoB,eAAe;EACvC,MAAM,OAAO,QAAQ,QAAQ,KAAK,GAAG,CAAC,CAAC,QAAQ,MAAM,KAAK,KAAK;AAC/D,SAAO,KAAK,OAAO,MAAM,OAAO,MAAM,SAAS,GAAG,OAAO,KAAA;GACzD;CAEF,MAAM,YAAY,qBAEd;;;sDACE,kBAAkB,WAAA,QAAA,2BAAA,KAAA,IAAA,KAAA,IAAA,uBAAO,KAAK,MAAM,aAAa,EAAW,CAAC,MAAA,QAAA,0BAAA,KAAA,IAAA,wBAAI,CAAC,cAAc,CAAC,QAAQ,MAAM,KAAK,KAAK;GACzG,QAAQ,QAAQ,kBAAkB,QAAQ,KAAK,KAAK,KAAK,GAAG,CAAa;GACzE,QAAQ,MAAM,kBAAkB,QAAQ,KAAK,KAAK,KAAK,GAAG,CAAe;GACzE,QAAQ,kBAAkB,QAAQ,KAAK,KAAK,KAAK,GAAG;GACrD;KACF,CAAC,aAAa,YAAY,eAAe,iBAAiB;AACzD,WAAS;AAET,MAAI,EAAA,gBAAA,QAAA,gBAAA,KAAA,IAAA,KAAA,IAAC,YAAa,WAAU,EAAA,eAAA,QAAA,eAAA,KAAA,IAAA,KAAA,IAAC,WAAY,WAAU,EAAA,kBAAA,QAAA,kBAAA,KAAA,IAAA,KAAA,IAAC,cAAe,QAAQ;EAG3E,MAAM,eAAe,SAAS,YAAY,GAAG,EAAE,GAAG,aAAa,GAAG;AAClE,WAAS,KACP,GAAG,YAAY,SAAS,OACtB,WAAW,SAAS,UAAU,cAAc,KAAK,aAAa,SAAS,IAAI,OAAO,UAAU,aAAa,CAAC,CAAC,CAC5G,CACF;IAEH,EAAE,OAAO,QAAQ,CAClB;CAED,MAAM,aAAa;AACjB,aAAW;AACX,WAAS;;AAGX,mBAAkB,QAAQ;AAE1B,QAAO"}

package/es/hooks/useFullscreen/index.d.ts

@@ -0,0 +1,25 @@
+import type { ConfigurableDocument } from '../_configurable.js';
+import type { MaybeElementRef } from '../unrefElement/index.js';
+export interface UseFullscreenOptions extends ConfigurableDocument {
+    /**
+     * Automatically exit fullscreen when component is unmounted
+     *
+     * @default false
+     */
+    autoExit?: boolean;
+}
+/**
+ * Reactive Fullscreen API.
+ *
+ * @see https://vueuse.org/useFullscreen
+ * @param target
+ * @param options
+ */
+export declare function useFullscreen(target?: MaybeElementRef, options?: UseFullscreenOptions): {
+    isSupported: any;
+    isFullscreen: any;
+    enter: () => Promise<void>;
+    exit: () => Promise<void>;
+    toggle: () => Promise<void>;
+};
+export type UseFullscreenReturn = ReturnType<typeof useFullscreen>;

package/es/hooks/useFullscreen/index.mjs

@@ -0,0 +1,121 @@
+import { tryOnScopeDispose } from "../tryOnScopeDispose/index.mjs";
+import { defaultDocument } from "../_configurable.mjs";
+import { unrefElement } from "../unrefElement/index.mjs";
+import { useEventListener } from "../useEventListener/index.mjs";
+import { useSupported } from "../useSupported/index.mjs";
+import { computed, shallowRef } from "vue";
+//#region packages/hooks/useFullscreen/index.ts
+var eventHandlers = [
+	"fullscreenchange",
+	"webkitfullscreenchange",
+	"webkitendfullscreen",
+	"mozfullscreenchange",
+	"MSFullscreenChange"
+];
+/**
+* Reactive Fullscreen API.
+*
+* @see https://vueuse.org/useFullscreen
+* @param target
+* @param options
+*/
+function useFullscreen(target, options = {}) {
+	const { document = defaultDocument, autoExit = false } = options;
+	const targetRef = computed(() => {
+		var _unrefElement;
+		return (_unrefElement = unrefElement(target)) !== null && _unrefElement !== void 0 ? _unrefElement : document === null || document === void 0 ? void 0 : document.documentElement;
+	});
+	const isFullscreen = shallowRef(false);
+	const requestMethod = computed(() => {
+		return [
+			"requestFullscreen",
+			"webkitRequestFullscreen",
+			"webkitEnterFullscreen",
+			"webkitEnterFullScreen",
+			"webkitRequestFullScreen",
+			"mozRequestFullScreen",
+			"msRequestFullscreen"
+		].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+	});
+	const exitMethod = computed(() => {
+		return [
+			"exitFullscreen",
+			"webkitExitFullscreen",
+			"webkitExitFullScreen",
+			"webkitCancelFullScreen",
+			"mozCancelFullScreen",
+			"msExitFullscreen"
+		].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+	});
+	const fullscreenEnabled = computed(() => {
+		return [
+			"fullScreen",
+			"webkitIsFullScreen",
+			"webkitDisplayingFullscreen",
+			"mozFullScreen",
+			"msFullscreenElement"
+		].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+	});
+	const fullscreenElementMethod = [
+		"fullscreenElement",
+		"webkitFullscreenElement",
+		"mozFullScreenElement",
+		"msFullscreenElement"
+	].find((m) => document && m in document);
+	const isSupported = useSupported(() => targetRef.value && document && requestMethod.value !== void 0 && exitMethod.value !== void 0 && fullscreenEnabled.value !== void 0);
+	const isCurrentElementFullScreen = () => {
+		if (fullscreenElementMethod) return (document === null || document === void 0 ? void 0 : document[fullscreenElementMethod]) === targetRef.value;
+		return false;
+	};
+	const isElementFullScreen = () => {
+		if (fullscreenEnabled.value) if (document && document[fullscreenEnabled.value] != null) return document[fullscreenEnabled.value];
+		else {
+			const target = targetRef.value;
+			if ((target === null || target === void 0 ? void 0 : target[fullscreenEnabled.value]) != null) return Boolean(target[fullscreenEnabled.value]);
+		}
+		return false;
+	};
+	async function exit() {
+		if (!isSupported.value || !isFullscreen.value) return;
+		if (exitMethod.value) if ((document === null || document === void 0 ? void 0 : document[exitMethod.value]) != null) await document[exitMethod.value]();
+		else {
+			const target = targetRef.value;
+			if ((target === null || target === void 0 ? void 0 : target[exitMethod.value]) != null) await target[exitMethod.value]();
+		}
+		isFullscreen.value = false;
+	}
+	async function enter() {
+		if (!isSupported.value || isFullscreen.value) return;
+		if (isElementFullScreen()) await exit();
+		const target = targetRef.value;
+		if (requestMethod.value && (target === null || target === void 0 ? void 0 : target[requestMethod.value]) != null) {
+			await target[requestMethod.value]();
+			isFullscreen.value = true;
+		}
+	}
+	async function toggle() {
+		await (isFullscreen.value ? exit() : enter());
+	}
+	const handlerCallback = () => {
+		const isElementFullScreenValue = isElementFullScreen();
+		if (!isElementFullScreenValue || isElementFullScreenValue && isCurrentElementFullScreen()) isFullscreen.value = isElementFullScreenValue;
+	};
+	const listenerOptions = {
+		capture: false,
+		passive: true
+	};
+	useEventListener(document, eventHandlers, handlerCallback, listenerOptions);
+	useEventListener(() => unrefElement(targetRef), eventHandlers, handlerCallback, listenerOptions);
+	if (autoExit) tryOnScopeDispose(exit);
+	return {
+		isSupported,
+		isFullscreen,
+		enter,
+		exit,
+		toggle
+	};
+}
+//#endregion
+export { useFullscreen };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/useFullscreen/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/useFullscreen/index.ts"],"sourcesContent":["import type { ConfigurableDocument } from '../_configurable'\r\nimport type { MaybeElementRef } from '../unrefElement'\r\nimport { tryOnScopeDispose } from '../tryOnScopeDispose'\r\nimport { computed, shallowRef } from 'vue'\r\nimport { defaultDocument } from '../_configurable'\r\nimport { unrefElement } from '../unrefElement'\r\nimport { useEventListener } from '../useEventListener'\r\nimport { useSupported } from '../useSupported'\r\n\r\nexport interface UseFullscreenOptions extends ConfigurableDocument {\r\n  /**\r\n   * Automatically exit fullscreen when component is unmounted\r\n   *\r\n   * @default false\r\n   */\r\n  autoExit?: boolean\r\n}\r\n\r\nconst eventHandlers = [\r\n  'fullscreenchange',\r\n  'webkitfullscreenchange',\r\n  'webkitendfullscreen',\r\n  'mozfullscreenchange',\r\n  'MSFullscreenChange',\r\n] as any as 'fullscreenchange'[]\r\n\r\n/**\r\n * Reactive Fullscreen API.\r\n *\r\n * @see https://vueuse.org/useFullscreen\r\n * @param target\r\n * @param options\r\n */\r\nexport function useFullscreen(target?: MaybeElementRef, options: UseFullscreenOptions = {}) {\r\n  const { document = defaultDocument, autoExit = false } = options\r\n\r\n  const targetRef = computed(() => unrefElement(target) ?? document?.documentElement)\r\n  const isFullscreen = shallowRef(false)\r\n\r\n  const requestMethod = computed<'requestFullscreen' | undefined>(() => {\r\n    return [\r\n      'requestFullscreen',\r\n      'webkitRequestFullscreen',\r\n      'webkitEnterFullscreen',\r\n      'webkitEnterFullScreen',\r\n      'webkitRequestFullScreen',\r\n      'mozRequestFullScreen',\r\n      'msRequestFullscreen',\r\n    ].find((m) => (document && m in document) || (targetRef.value && m in targetRef.value)) as any\r\n  })\r\n\r\n  const exitMethod = computed<'exitFullscreen' | undefined>(() => {\r\n    return [\r\n      'exitFullscreen',\r\n      'webkitExitFullscreen',\r\n      'webkitExitFullScreen',\r\n      'webkitCancelFullScreen',\r\n      'mozCancelFullScreen',\r\n      'msExitFullscreen',\r\n    ].find((m) => (document && m in document) || (targetRef.value && m in targetRef.value)) as any\r\n  })\r\n\r\n  const fullscreenEnabled = computed<'fullscreenEnabled' | undefined>(() => {\r\n    return [\r\n      'fullScreen',\r\n      'webkitIsFullScreen',\r\n      'webkitDisplayingFullscreen',\r\n      'mozFullScreen',\r\n      'msFullscreenElement',\r\n    ].find((m) => (document && m in document) || (targetRef.value && m in targetRef.value)) as any\r\n  })\r\n\r\n  const fullscreenElementMethod = [\r\n    'fullscreenElement',\r\n    'webkitFullscreenElement',\r\n    'mozFullScreenElement',\r\n    'msFullscreenElement',\r\n  ].find((m) => document && m in document) as 'fullscreenElement' | undefined\r\n\r\n  const isSupported = useSupported(\r\n    () =>\r\n      targetRef.value &&\r\n      document &&\r\n      requestMethod.value !== undefined &&\r\n      exitMethod.value !== undefined &&\r\n      fullscreenEnabled.value !== undefined,\r\n  )\r\n\r\n  const isCurrentElementFullScreen = (): boolean => {\r\n    if (fullscreenElementMethod) return document?.[fullscreenElementMethod] === targetRef.value\r\n    return false\r\n  }\r\n\r\n  const isElementFullScreen = (): boolean => {\r\n    if (fullscreenEnabled.value) {\r\n      if (document && document[fullscreenEnabled.value] != null) {\r\n        return document[fullscreenEnabled.value]\r\n      } else {\r\n        const target = targetRef.value\r\n        if (target?.[fullscreenEnabled.value] != null) {\r\n          return Boolean(target[fullscreenEnabled.value])\r\n        }\r\n      }\r\n    }\r\n    return false\r\n  }\r\n\r\n  async function exit() {\r\n    if (!isSupported.value || !isFullscreen.value) return\r\n    if (exitMethod.value) {\r\n      if (document?.[exitMethod.value] != null) {\r\n        await document[exitMethod.value]()\r\n      } else {\r\n        const target = targetRef.value\r\n        if (target?.[exitMethod.value] != null) await target[exitMethod.value]()\r\n      }\r\n    }\r\n\r\n    isFullscreen.value = false\r\n  }\r\n\r\n  async function enter() {\r\n    if (!isSupported.value || isFullscreen.value) return\r\n\r\n    if (isElementFullScreen()) await exit()\r\n\r\n    const target = targetRef.value\r\n    if (requestMethod.value && target?.[requestMethod.value] != null) {\r\n      await target[requestMethod.value]()\r\n      isFullscreen.value = true\r\n    }\r\n  }\r\n\r\n  async function toggle() {\r\n    await (isFullscreen.value ? exit() : enter())\r\n  }\r\n\r\n  const handlerCallback = () => {\r\n    const isElementFullScreenValue = isElementFullScreen()\r\n    if (!isElementFullScreenValue || (isElementFullScreenValue && isCurrentElementFullScreen()))\r\n      isFullscreen.value = isElementFullScreenValue\r\n  }\r\n\r\n  const listenerOptions = { capture: false, passive: true }\r\n  useEventListener(document, eventHandlers, handlerCallback, listenerOptions)\r\n  useEventListener(() => unrefElement(targetRef), eventHandlers, handlerCallback, listenerOptions)\r\n\r\n  if (autoExit) tryOnScopeDispose(exit)\r\n\r\n  return {\r\n    isSupported,\r\n    isFullscreen,\r\n    enter,\r\n    exit,\r\n    toggle,\r\n  }\r\n}\r\n\r\nexport type UseFullscreenReturn = ReturnType<typeof useFullscreen>\r\n"],"mappings":"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"}

package/es/hooks/useMounted/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mounted state in ref.
+ *
+ * @see https://vueuse.org/useMounted
+ */
+export declare function useMounted(): any;

package/es/hooks/useMounted/index.mjs

@@ -0,0 +1,19 @@
+import { getCurrentInstance, onMounted, shallowRef } from "vue";
+//#region packages/hooks/useMounted/index.ts
+/**
+* Mounted state in ref.
+*
+* @see https://vueuse.org/useMounted
+*/
+function useMounted() {
+	const isMounted = shallowRef(false);
+	const instance = getCurrentInstance();
+	if (instance) onMounted(() => {
+		isMounted.value = true;
+	}, instance);
+	return isMounted;
+}
+//#endregion
+export { useMounted };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/useMounted/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/useMounted/index.ts"],"sourcesContent":["import { getCurrentInstance, onMounted, shallowRef } from 'vue'\r\n\r\n/**\r\n * Mounted state in ref.\r\n *\r\n * @see https://vueuse.org/useMounted\r\n */\r\nexport function useMounted() {\r\n  const isMounted = shallowRef(false)\r\n\r\n  const instance = getCurrentInstance()\r\n  if (instance) {\r\n    onMounted(() => {\r\n      isMounted.value = true\r\n    }, instance)\r\n  }\r\n\r\n  return isMounted\r\n}\r\n"],"mappings":";;;;;;;AAOA,SAAgB,aAAa;CAC3B,MAAM,YAAY,WAAW,MAAM;CAEnC,MAAM,WAAW,oBAAoB;AACrC,KAAI,SACF,iBAAgB;AACd,YAAU,QAAQ;IACjB,SAAS;AAGd,QAAO"}

package/es/hooks/useSupported/index.d.ts

@@ -0,0 +1,2 @@
+export declare function useSupported(callback: () => unknown): any;
+export type UseSupportedReturn = ReturnType<typeof useSupported>;

package/es/hooks/useSupported/index.mjs

@@ -0,0 +1,14 @@
+import { useMounted } from "../useMounted/index.mjs";
+import { computed } from "vue";
+//#region packages/hooks/useSupported/index.ts
+function useSupported(callback) {
+	const isMounted = useMounted();
+	return computed(() => {
+		isMounted.value;
+		return Boolean(callback());
+	});
+}
+//#endregion
+export { useSupported };
+
+//# sourceMappingURL=index.mjs.map

package/es/hooks/useSupported/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../../packages/hooks/useSupported/index.ts"],"sourcesContent":["import { computed } from 'vue'\r\nimport { useMounted } from '../useMounted'\r\n\r\nexport function useSupported(callback: () => unknown) {\r\n  const isMounted = useMounted()\r\n\r\n  return computed(() => {\r\n    void isMounted.value\r\n    return Boolean(callback())\r\n  })\r\n}\r\n\r\nexport type UseSupportedReturn = ReturnType<typeof useSupported>\r\n"],"mappings":";;;AAGA,SAAgB,aAAa,UAAyB;CACpD,MAAM,YAAY,YAAY;AAE9B,QAAO,eAAe;AACf,YAAU;AACf,SAAO,QAAQ,UAAU,CAAC;GAC1B"}

package/es/hooks/utils/filters.d.ts

@@ -0,0 +1,84 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { AnyFn, ArgumentsType, Awaited, Pausable, Promisify } from './types.js';
+export type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return;
+export interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
+    fn: FunctionArgs<Args, This>;
+    args: Args;
+    thisArg: This;
+}
+export type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
+export interface ConfigurableEventFilter {
+    /**
+     * Filter for if events should to be received.
+     *
+     * @see https://vueuse.org/guide/config.html#event-filters
+     */
+    eventFilter?: EventFilter;
+}
+export interface DebounceFilterOptions {
+    /**
+     * The maximum time allowed to be delayed before it's invoked.
+     * In milliseconds.
+     */
+    maxWait?: MaybeRefOrGetter<number>;
+    /**
+     * Whether to reject the last call if it's been cancel.
+     *
+     * @default false
+     */
+    rejectOnCancel?: boolean;
+}
+/**
+ * @internal
+ */
+export declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): (this: any, ...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+export declare const bypassFilter: EventFilter;
+/**
+ * Create an EventFilter that debounce the events
+ */
+export declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): EventFilter<any[], any, AnyFn>;
+export interface ThrottleFilterOptions {
+    /**
+     * The maximum time allowed to be delayed before it's invoked.
+     */
+    delay: MaybeRefOrGetter<number>;
+    /**
+     * Whether to invoke on the trailing edge of the timeout.
+     */
+    trailing?: boolean;
+    /**
+     * Whether to invoke on the leading edge of the timeout.
+     */
+    leading?: boolean;
+    /**
+     * Whether to reject the last call if it's been cancel.
+     */
+    rejectOnCancel?: boolean;
+}
+/**
+ * Create an EventFilter that throttle the events
+ *
+ * @param ms
+ * @param [trailing]
+ * @param [leading]
+ * @param [rejectOnCancel]
+ */
+export declare function throttleFilter(ms: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter;
+export declare function throttleFilter(options: ThrottleFilterOptions): EventFilter;
+export interface PausableFilterOptions {
+    /**
+     * The initial state
+     *
+     * @default 'active'
+     */
+    initialState?: 'active' | 'paused';
+}
+/**
+ * EventFilter that gives extra controls to pause and resume the filter
+ *
+ * @param extendFilter  Extra filter to apply when the PausableFilter is active, default to none
+ * @param options Options to configure the filter
+ */
+export declare function pausableFilter(extendFilter?: EventFilter, options?: PausableFilterOptions): Pausable & {
+    eventFilter: EventFilter;
+};