@vitejs/devtools 0.1.10 → 0.1.13

package/dist/{dist-CCdqIez-.js → dist-DD29zy1v.js}

@@ -1,5 +1,5 @@
-import { computed, customRef, getCurrentInstance, getCurrentScope, hasInjectionContext, inject, isRef, nextTick, onMounted, onScopeDispose, readonly, ref, shallowReadonly, shallowRef, toRef, toValue, unref, watch, watchEffect } from "vue";
-//#region ../../node_modules/.pnpm/@vueuse+shared@14.2.1_vue@3.5.30_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
+import { computed, customRef, getCurrentInstance, getCurrentScope, hasInjectionContext, inject, isRef, nextTick, onMounted, onScopeDispose, readonly, ref, shallowReadonly, shallowRef, toRaw, toRef, toRefs, toValue, unref, watch, watchEffect } from "vue";
+//#region ../../node_modules/.pnpm/@vueuse+shared@14.2.1_vue@3.5.31_typescript@6.0.2_/node_modules/@vueuse/shared/dist/index.js
 /**
 * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
 *
@@ -137,6 +137,31 @@ function pausableFilter(extendFilter = bypassFilter, options = {}) {
 	};
 }
 /**
+* Create singleton promise function
+*
+* @example
+* ```
+* const promise = createSingletonPromise(async () => { ... })
+*
+* await promise()
+* await promise() // all of them will be bind to a single promise instance
+* await promise() // and be resolved together
+* ```
+*/
+function createSingletonPromise(fn) {
+	let _promise;
+	function wrapper() {
+		if (!_promise) _promise = fn();
+		return _promise;
+	}
+	wrapper.reset = async () => {
+		const _prev = _promise;
+		_promise = void 0;
+		if (_prev) await _prev;
+	};
+	return wrapper;
+}
+/**
 * Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
 */
 function pxValue(px) {
@@ -194,6 +219,39 @@ function watchPausable(source, cb, options = {}) {
 	};
 }
 /**
+* Extended `toRefs` that also accepts refs of an object.
+*
+* @see https://vueuse.org/toRefs
+* @param objectRef A ref or normal object or array.
+* @param options Options
+*/
+function toRefs$1(objectRef, options = {}) {
+	if (!isRef(objectRef)) return toRefs(objectRef);
+	const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
+	for (const key in objectRef.value) result[key] = customRef(() => ({
+		get() {
+			return objectRef.value[key];
+		},
+		set(v) {
+			var _toValue;
+			if ((_toValue = toValue(options.replaceRef)) !== null && _toValue !== void 0 ? _toValue : true) if (Array.isArray(objectRef.value)) {
+				const copy = [...objectRef.value];
+				copy[key] = v;
+				objectRef.value = copy;
+			} else {
+				const newObject = {
+					...objectRef.value,
+					[key]: v
+				};
+				Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
+				objectRef.value = newObject;
+			}
+			else objectRef.value[key] = v;
+		}
+	}));
+	return result;
+}
+/**
 * Call onMounted() if it's inside a component lifecycle, if not, just call the function
 *
 * @param fn
@@ -246,6 +304,48 @@ function useIntervalFn(cb, interval = 1e3, options = {}) {
 		resume
 	};
 }
+/**
+* Wrapper for `setTimeout` with controls.
+*
+* @param cb
+* @param interval
+* @param options
+*/
+function useTimeoutFn(cb, interval, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	const isPending = shallowRef(false);
+	let timer;
+	function clear() {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	}
+	function stop() {
+		isPending.value = false;
+		clear();
+	}
+	function start(...args) {
+		if (immediateCallback) cb();
+		clear();
+		isPending.value = true;
+		timer = setTimeout(() => {
+			isPending.value = false;
+			timer = void 0;
+			cb(...args);
+		}, toValue(interval));
+	}
+	if (immediate) {
+		isPending.value = true;
+		if (isClient) start();
+	}
+	tryOnScopeDispose(stop);
+	return {
+		isPending: shallowReadonly(isPending),
+		start,
+		stop
+	};
+}
 function watchDebounced(source, cb, options = {}) {
 	const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
 	return watchWithFilter(source, cb, {
@@ -265,10 +365,10 @@ function watchImmediate(source, cb, options) {
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@vueuse+core@14.2.1_vue@3.5.30_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js
+//#region ../../node_modules/.pnpm/@vueuse+core@14.2.1_vue@3.5.31_typescript@6.0.2_/node_modules/@vueuse/core/dist/index.js
 const defaultWindow = isClient ? window : void 0;
 isClient && window.document;
-isClient && window.navigator;
+const defaultNavigator = isClient ? window.navigator : void 0;
 isClient && window.location;
 /**
 * Get the dom element of a ref of element or Vue component instance
@@ -566,6 +666,101 @@ function useMediaQuery(query, options = {}) {
 	useEventListener(mediaQuery, "change", handler, { passive: true });
 	return computed(() => matches.value);
 }
+/**
+* Reactive Permissions API.
+*
+* @see https://vueuse.org/usePermission
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function usePermission(permissionDesc, options = {}) {
+	const { controls = false, navigator: navigator$1 = defaultNavigator } = options;
+	const isSupported = /* @__PURE__ */ useSupported(() => navigator$1 && "permissions" in navigator$1);
+	const permissionStatus = shallowRef();
+	const desc = typeof permissionDesc === "string" ? { name: permissionDesc } : permissionDesc;
+	const state = shallowRef();
+	const update = () => {
+		var _permissionStatus$val, _permissionStatus$val2;
+		state.value = (_permissionStatus$val = (_permissionStatus$val2 = permissionStatus.value) === null || _permissionStatus$val2 === void 0 ? void 0 : _permissionStatus$val2.state) !== null && _permissionStatus$val !== void 0 ? _permissionStatus$val : "prompt";
+	};
+	useEventListener(permissionStatus, "change", update, { passive: true });
+	const query = createSingletonPromise(async () => {
+		if (!isSupported.value) return;
+		if (!permissionStatus.value) try {
+			permissionStatus.value = await navigator$1.permissions.query(desc);
+		} catch (_unused) {
+			permissionStatus.value = void 0;
+		} finally {
+			update();
+		}
+		if (controls) return toRaw(permissionStatus.value);
+	});
+	query();
+	if (controls) return {
+		state,
+		isSupported,
+		query
+	};
+	else return state;
+}
+function useClipboard(options = {}) {
+	const { navigator: navigator$1 = defaultNavigator, read = false, source, copiedDuring = 1500, legacy = false } = options;
+	const isClipboardApiSupported = /* @__PURE__ */ useSupported(() => navigator$1 && "clipboard" in navigator$1);
+	const permissionRead = usePermission("clipboard-read");
+	const permissionWrite = usePermission("clipboard-write");
+	const isSupported = computed(() => isClipboardApiSupported.value || legacy);
+	const text = shallowRef("");
+	const copied = shallowRef(false);
+	const timeout = useTimeoutFn(() => copied.value = false, copiedDuring, { immediate: false });
+	async function updateText() {
+		let useLegacy = !(isClipboardApiSupported.value && isAllowed(permissionRead.value));
+		if (!useLegacy) try {
+			text.value = await navigator$1.clipboard.readText();
+		} catch (_unused) {
+			useLegacy = true;
+		}
+		if (useLegacy) text.value = legacyRead();
+	}
+	if (isSupported.value && read) useEventListener(["copy", "cut"], updateText, { passive: true });
+	async function copy(value = toValue(source)) {
+		if (isSupported.value && value != null) {
+			let useLegacy = !(isClipboardApiSupported.value && isAllowed(permissionWrite.value));
+			if (!useLegacy) try {
+				await navigator$1.clipboard.writeText(value);
+			} catch (_unused2) {
+				useLegacy = true;
+			}
+			if (useLegacy) legacyCopy(value);
+			text.value = value;
+			copied.value = true;
+			timeout.start();
+		}
+	}
+	function legacyCopy(value) {
+		const ta = document.createElement("textarea");
+		ta.value = value;
+		ta.style.position = "absolute";
+		ta.style.opacity = "0";
+		ta.setAttribute("readonly", "");
+		document.body.appendChild(ta);
+		ta.select();
+		document.execCommand("copy");
+		ta.remove();
+	}
+	function legacyRead() {
+		var _document$getSelectio, _document, _document$getSelectio2;
+		return (_document$getSelectio = (_document = document) === null || _document === void 0 || (_document$getSelectio2 = _document.getSelection) === null || _document$getSelectio2 === void 0 || (_document$getSelectio2 = _document$getSelectio2.call(_document)) === null || _document$getSelectio2 === void 0 ? void 0 : _document$getSelectio2.toString()) !== null && _document$getSelectio !== void 0 ? _document$getSelectio : "";
+	}
+	function isAllowed(status) {
+		return status === "granted" || status === "prompt";
+	}
+	return {
+		isSupported,
+		text: readonly(text),
+		copied: readonly(copied),
+		copy
+	};
+}
 const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 const globalKey = "__vueuse_ssr_handlers__";
 const handlers = /* @__PURE__ */ getHandlers();
@@ -891,6 +1086,196 @@ function useDark(options = {}) {
 		}
 	});
 }
+const defaultScrollConfig = {
+	speed: 2,
+	margin: 30,
+	direction: "both"
+};
+function clampContainerScroll(container) {
+	if (container.scrollLeft > container.scrollWidth - container.clientWidth) container.scrollLeft = Math.max(0, container.scrollWidth - container.clientWidth);
+	if (container.scrollTop > container.scrollHeight - container.clientHeight) container.scrollTop = Math.max(0, container.scrollHeight - container.clientHeight);
+}
+/**
+* Make elements draggable.
+*
+* @see https://vueuse.org/useDraggable
+* @param target
+* @param options
+*/
+function useDraggable(target, options = {}) {
+	var _toValue, _toValue2, _toValue3, _scrollConfig$directi;
+	const { pointerTypes, preventDefault: preventDefault$1, stopPropagation, exact, onMove, onEnd, onStart, initialValue, axis = "both", draggingElement = defaultWindow, containerElement, handle: draggingHandle = target, buttons = [0], restrictInView, autoScroll = false } = options;
+	const position = ref((_toValue = toValue(initialValue)) !== null && _toValue !== void 0 ? _toValue : {
+		x: 0,
+		y: 0
+	});
+	const pressedDelta = ref();
+	const filterEvent = (e) => {
+		if (pointerTypes) return pointerTypes.includes(e.pointerType);
+		return true;
+	};
+	const handleEvent = (e) => {
+		if (toValue(preventDefault$1)) e.preventDefault();
+		if (toValue(stopPropagation)) e.stopPropagation();
+	};
+	const scrollConfig = toValue(autoScroll);
+	const scrollSettings = typeof scrollConfig === "object" ? {
+		speed: (_toValue2 = toValue(scrollConfig.speed)) !== null && _toValue2 !== void 0 ? _toValue2 : defaultScrollConfig.speed,
+		margin: (_toValue3 = toValue(scrollConfig.margin)) !== null && _toValue3 !== void 0 ? _toValue3 : defaultScrollConfig.margin,
+		direction: (_scrollConfig$directi = scrollConfig.direction) !== null && _scrollConfig$directi !== void 0 ? _scrollConfig$directi : defaultScrollConfig.direction
+	} : defaultScrollConfig;
+	const getScrollAxisValues = (value) => typeof value === "number" ? [value, value] : [value.x, value.y];
+	const handleAutoScroll = (container, targetRect, position$1) => {
+		const { clientWidth, clientHeight, scrollLeft, scrollTop, scrollWidth, scrollHeight } = container;
+		const [marginX, marginY] = getScrollAxisValues(scrollSettings.margin);
+		const [speedX, speedY] = getScrollAxisValues(scrollSettings.speed);
+		let deltaX = 0;
+		let deltaY = 0;
+		if (scrollSettings.direction === "x" || scrollSettings.direction === "both") {
+			if (position$1.x < marginX && scrollLeft > 0) deltaX = -speedX;
+			else if (position$1.x + targetRect.width > clientWidth - marginX && scrollLeft < scrollWidth - clientWidth) deltaX = speedX;
+		}
+		if (scrollSettings.direction === "y" || scrollSettings.direction === "both") {
+			if (position$1.y < marginY && scrollTop > 0) deltaY = -speedY;
+			else if (position$1.y + targetRect.height > clientHeight - marginY && scrollTop < scrollHeight - clientHeight) deltaY = speedY;
+		}
+		if (deltaX || deltaY) container.scrollBy({
+			left: deltaX,
+			top: deltaY,
+			behavior: "auto"
+		});
+	};
+	let autoScrollInterval = null;
+	const startAutoScroll = () => {
+		const container = toValue(containerElement);
+		if (container && !autoScrollInterval) autoScrollInterval = setInterval(() => {
+			const targetRect = toValue(target).getBoundingClientRect();
+			const { x, y } = position.value;
+			const relativePosition = {
+				x: x - container.scrollLeft,
+				y: y - container.scrollTop
+			};
+			if (relativePosition.x >= 0 && relativePosition.y >= 0) {
+				handleAutoScroll(container, targetRect, relativePosition);
+				relativePosition.x += container.scrollLeft;
+				relativePosition.y += container.scrollTop;
+				position.value = relativePosition;
+			}
+		}, 1e3 / 60);
+	};
+	const stopAutoScroll = () => {
+		if (autoScrollInterval) {
+			clearInterval(autoScrollInterval);
+			autoScrollInterval = null;
+		}
+	};
+	const isPointerNearEdge = (pointer, container, margin, targetRect) => {
+		const [marginX, marginY] = typeof margin === "number" ? [margin, margin] : [margin.x, margin.y];
+		const { clientWidth, clientHeight } = container;
+		return pointer.x < marginX || pointer.x + targetRect.width > clientWidth - marginX || pointer.y < marginY || pointer.y + targetRect.height > clientHeight - marginY;
+	};
+	const checkAutoScroll = () => {
+		if (toValue(options.disabled) || !pressedDelta.value) return;
+		const container = toValue(containerElement);
+		if (!container) return;
+		const targetRect = toValue(target).getBoundingClientRect();
+		const { x, y } = position.value;
+		if (isPointerNearEdge({
+			x: x - container.scrollLeft,
+			y: y - container.scrollTop
+		}, container, scrollSettings.margin, targetRect)) startAutoScroll();
+		else stopAutoScroll();
+	};
+	if (toValue(autoScroll)) watch(position, checkAutoScroll);
+	const start = (e) => {
+		var _container$getBoundin;
+		if (!toValue(buttons).includes(e.button)) return;
+		if (toValue(options.disabled) || !filterEvent(e)) return;
+		if (toValue(exact) && e.target !== toValue(target)) return;
+		const container = toValue(containerElement);
+		const containerRect = container === null || container === void 0 || (_container$getBoundin = container.getBoundingClientRect) === null || _container$getBoundin === void 0 ? void 0 : _container$getBoundin.call(container);
+		const targetRect = toValue(target).getBoundingClientRect();
+		const pos = {
+			x: e.clientX - (container ? targetRect.left - containerRect.left + (autoScroll ? 0 : container.scrollLeft) : targetRect.left),
+			y: e.clientY - (container ? targetRect.top - containerRect.top + (autoScroll ? 0 : container.scrollTop) : targetRect.top)
+		};
+		if ((onStart === null || onStart === void 0 ? void 0 : onStart(pos, e)) === false) return;
+		pressedDelta.value = pos;
+		handleEvent(e);
+	};
+	const move = (e) => {
+		if (toValue(options.disabled) || !filterEvent(e)) return;
+		if (!pressedDelta.value) return;
+		const container = toValue(containerElement);
+		if (container instanceof HTMLElement) clampContainerScroll(container);
+		const targetRect = toValue(target).getBoundingClientRect();
+		let { x, y } = position.value;
+		if (axis === "x" || axis === "both") {
+			x = e.clientX - pressedDelta.value.x;
+			if (container) x = Math.min(Math.max(0, x), container.scrollWidth - targetRect.width);
+		}
+		if (axis === "y" || axis === "both") {
+			y = e.clientY - pressedDelta.value.y;
+			if (container) y = Math.min(Math.max(0, y), container.scrollHeight - targetRect.height);
+		}
+		if (toValue(autoScroll) && container) {
+			if (autoScrollInterval === null) handleAutoScroll(container, targetRect, {
+				x,
+				y
+			});
+			x += container.scrollLeft;
+			y += container.scrollTop;
+		}
+		if (container && (restrictInView || autoScroll)) {
+			if (axis !== "y") {
+				const relativeX = x - container.scrollLeft;
+				if (relativeX < 0) x = container.scrollLeft;
+				else if (relativeX > container.clientWidth - targetRect.width) x = container.clientWidth - targetRect.width + container.scrollLeft;
+			}
+			if (axis !== "x") {
+				const relativeY = y - container.scrollTop;
+				if (relativeY < 0) y = container.scrollTop;
+				else if (relativeY > container.clientHeight - targetRect.height) y = container.clientHeight - targetRect.height + container.scrollTop;
+			}
+		}
+		position.value = {
+			x,
+			y
+		};
+		onMove === null || onMove === void 0 || onMove(position.value, e);
+		handleEvent(e);
+	};
+	const end = (e) => {
+		if (toValue(options.disabled) || !filterEvent(e)) return;
+		if (!pressedDelta.value) return;
+		pressedDelta.value = void 0;
+		if (autoScroll) stopAutoScroll();
+		onEnd === null || onEnd === void 0 || onEnd(position.value, e);
+		handleEvent(e);
+	};
+	if (isClient) {
+		const config = () => {
+			var _options$capture;
+			return {
+				capture: (_options$capture = options.capture) !== null && _options$capture !== void 0 ? _options$capture : true,
+				passive: !toValue(preventDefault$1)
+			};
+		};
+		useEventListener(draggingHandle, "pointerdown", start, config);
+		useEventListener(draggingElement, "pointermove", move, config);
+		useEventListener(draggingElement, "pointerup", end, config);
+	}
+	return {
+		...toRefs$1(position),
+		position,
+		isDragging: computed(() => !!pressedDelta.value),
+		style: computed(() => `
+      left: ${position.value.x}px;
+      top: ${position.value.y}px;
+      ${autoScroll ? "text-wrap: nowrap;" : ""}
+    `)
+	};
+}
 /**
 * Reports changes to the dimensions of an Element's content or the border-box
 *
@@ -1233,4 +1618,4 @@ function useWindowSize(options = {}) {
 	};
 }
 //#endregion
-export { useLocalStorage as a, useWindowSize as c, watchImmediate as d, useEventListener as i, useDebounceFn as l, useDark as n, useScreenSafeArea as o, useElementBounding as r, useTimeAgo as s, onClickOutside as t, watchDebounced as u };
+export { useElementBounding as a, useScreenSafeArea as c, useDebounceFn as d, watchDebounced as f, useDraggable as i, useTimeAgo as l, useClipboard as n, useEventListener as o, watchImmediate as p, useDark as r, useLocalStorage as s, onClickOutside as t, useWindowSize as u };