@youcan/celeste 0.6.102 → 0.7.0

package/dist/es/chunks/FocusScope.js

@@ -0,0 +1,356 @@
+import { t as getActiveElement } from "./getActiveElement.js";
+import { d as isClient, f as isIOS, g as tryOnBeforeUnmount, i as useEventListener, l as createGlobalState, u as createSharedComposable } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as injectConfigProviderContext } from "./ConfigProvider.js";
+import { n as defu } from "./DismissableLayer.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { computed, createBlock, defineComponent, nextTick, openBlock, reactive, ref, renderSlot, unref, watch, watchEffect, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/shared/useBodyScrollLock.js
+var useBodyLockStackCount = createSharedComposable(() => {
+	const map = ref(/* @__PURE__ */ new Map());
+	const initialOverflow = ref();
+	const locked = computed(() => {
+		for (const value of map.value.values()) if (value) return true;
+		return false;
+	});
+	const context = injectConfigProviderContext({ scrollBody: ref(true) });
+	let stopTouchMoveListener = null;
+	const resetBodyStyle = () => {
+		document.body.style.paddingRight = "";
+		document.body.style.marginRight = "";
+		document.body.style.pointerEvents = "";
+		document.documentElement.style.removeProperty("--scrollbar-width");
+		document.body.style.overflow = initialOverflow.value ?? "";
+		isIOS && stopTouchMoveListener?.();
+		initialOverflow.value = void 0;
+	};
+	watch(locked, (val, oldVal) => {
+		if (!isClient) return;
+		if (!val) {
+			if (oldVal) resetBodyStyle();
+			return;
+		}
+		if (initialOverflow.value === void 0) initialOverflow.value = document.body.style.overflow;
+		const verticalScrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+		const defaultConfig = {
+			padding: verticalScrollbarWidth,
+			margin: 0
+		};
+		const config = context.scrollBody?.value ? typeof context.scrollBody.value === "object" ? defu({
+			padding: context.scrollBody.value.padding === true ? verticalScrollbarWidth : context.scrollBody.value.padding,
+			margin: context.scrollBody.value.margin === true ? verticalScrollbarWidth : context.scrollBody.value.margin
+		}, defaultConfig) : defaultConfig : {
+			padding: 0,
+			margin: 0
+		};
+		if (verticalScrollbarWidth > 0) {
+			document.body.style.paddingRight = typeof config.padding === "number" ? `${config.padding}px` : String(config.padding);
+			document.body.style.marginRight = typeof config.margin === "number" ? `${config.margin}px` : String(config.margin);
+			document.documentElement.style.setProperty("--scrollbar-width", `${verticalScrollbarWidth}px`);
+			document.body.style.overflow = "hidden";
+		}
+		if (isIOS) stopTouchMoveListener = useEventListener(document, "touchmove", (e) => preventDefault(e), { passive: false });
+		nextTick(() => {
+			if (!locked.value) return;
+			document.body.style.pointerEvents = "none";
+			document.body.style.overflow = "hidden";
+		});
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	return map;
+});
+function useBodyScrollLock(initialState) {
+	const id = Math.random().toString(36).substring(2, 7);
+	const map = useBodyLockStackCount();
+	map.value.set(id, initialState ?? false);
+	const locked = computed({
+		get: () => map.value.get(id) ?? false,
+		set: (value) => map.value.set(id, value)
+	});
+	tryOnBeforeUnmount(() => {
+		map.value.delete(id);
+	});
+	return locked;
+}
+function checkOverflowScroll(ele) {
+	const style = window.getComputedStyle(ele);
+	if (style.overflowX === "scroll" || style.overflowY === "scroll" || style.overflowX === "auto" && ele.clientWidth < ele.scrollWidth || style.overflowY === "auto" && ele.clientHeight < ele.scrollHeight) return true;
+	else {
+		const parent = ele.parentNode;
+		if (!(parent instanceof Element) || parent.tagName === "BODY") return false;
+		return checkOverflowScroll(parent);
+	}
+}
+function preventDefault(rawEvent) {
+	const e = rawEvent || window.event;
+	const _target = e.target;
+	if (_target instanceof Element && checkOverflowScroll(_target)) return false;
+	if (e.touches.length > 1) return true;
+	if (e.preventDefault && e.cancelable) e.preventDefault();
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/FocusScope/stack.js
+var useFocusStackState = createGlobalState(() => {
+	return ref([]);
+});
+function createFocusScopesStack() {
+	/** A stack of focus scopes, with the active one at the top */
+	const stack = useFocusStackState();
+	return {
+		add(focusScope) {
+			const activeFocusScope = stack.value[0];
+			if (focusScope !== activeFocusScope) activeFocusScope?.pause();
+			stack.value = arrayRemove(stack.value, focusScope);
+			stack.value.unshift(focusScope);
+		},
+		remove(focusScope) {
+			stack.value = arrayRemove(stack.value, focusScope);
+			stack.value[0]?.resume();
+		}
+	};
+}
+function arrayRemove(array, item) {
+	const updatedArray = [...array];
+	const index = updatedArray.indexOf(item);
+	if (index !== -1) updatedArray.splice(index, 1);
+	return updatedArray;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/FocusScope/utils.js
+var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+var EVENT_OPTIONS = {
+	bubbles: false,
+	cancelable: true
+};
+/**
+* Attempts focusing the first element in a list of candidates.
+* Stops when focus has actually moved.
+*/
+function focusFirst(candidates, { select = false } = {}) {
+	const previouslyFocusedElement = getActiveElement();
+	for (const candidate of candidates) {
+		focus(candidate, { select });
+		if (getActiveElement() !== previouslyFocusedElement) return true;
+	}
+}
+/**
+* Returns the first and last tabbable elements inside a container.
+*/
+function getTabbableEdges(container) {
+	const candidates = getTabbableCandidates(container);
+	return [findVisible(candidates, container), findVisible(candidates.reverse(), container)];
+}
+/**
+* Returns a list of potential tabbable candidates.
+*
+* NOTE: This is only a close approximation. For example it doesn't take into account cases like when
+* elements are not visible. This cannot be worked out easily by just reading a property, but rather
+* necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.
+*
+* See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
+* Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
+*/
+function getTabbableCandidates(container) {
+	const nodes = [];
+	const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, { acceptNode: (node) => {
+		const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+		if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+		return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+	} });
+	while (walker.nextNode()) nodes.push(walker.currentNode);
+	return nodes;
+}
+/**
+* Returns the first visible element in a list.
+* NOTE: Only checks visibility up to the `container`.
+*/
+function findVisible(elements, container) {
+	for (const element of elements) if (!isHidden(element, { upTo: container })) return element;
+}
+function isHidden(node, { upTo }) {
+	if (getComputedStyle(node).visibility === "hidden") return true;
+	while (node) {
+		if (upTo !== void 0 && node === upTo) return false;
+		if (getComputedStyle(node).display === "none") return true;
+		node = node.parentElement;
+	}
+	return false;
+}
+function isSelectableInput(element) {
+	return element instanceof HTMLInputElement && "select" in element;
+}
+function focus(element, { select = false } = {}) {
+	if (element && element.focus) {
+		const previouslyFocusedElement = getActiveElement();
+		element.focus({ preventScroll: true });
+		if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/FocusScope/FocusScope.js
+var FocusScope_default = /* @__PURE__ */ defineComponent({
+	__name: "FocusScope",
+	props: {
+		loop: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		trapped: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		present: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["mountAutoFocus", "unmountAutoFocus"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { currentRef, currentElement } = useForwardExpose();
+		const lastFocusedElementRef = ref(null);
+		const focusScopesStack = createFocusScopesStack();
+		const focusScope = /* @__PURE__ */ reactive({
+			paused: false,
+			pause() {
+				this.paused = true;
+			},
+			resume() {
+				this.paused = false;
+			}
+		});
+		watchEffect((cleanupFn) => {
+			if (!isClient) return;
+			const container = currentElement.value;
+			if (!props.trapped) return;
+			function handleFocusIn(event) {
+				if (focusScope.paused || !container) return;
+				const target = event.target;
+				if (container.contains(target)) lastFocusedElementRef.value = target;
+				else focus(lastFocusedElementRef.value, { select: true });
+			}
+			function handleFocusOut(event) {
+				if (focusScope.paused || !container) return;
+				const relatedTarget = event.relatedTarget;
+				if (relatedTarget === null) return;
+				if (!container.contains(relatedTarget)) focus(lastFocusedElementRef.value, { select: true });
+			}
+			function handleMutations(mutations) {
+				const lastFocusedElement = lastFocusedElementRef.value;
+				if (lastFocusedElement === null) return;
+				if (!mutations.some((m) => m.removedNodes.length > 0)) return;
+				if (!container.contains(lastFocusedElement)) focus(container);
+			}
+			document.addEventListener("focusin", handleFocusIn);
+			document.addEventListener("focusout", handleFocusOut);
+			const mutationObserver = new MutationObserver(handleMutations);
+			if (container) mutationObserver.observe(container, {
+				childList: true,
+				subtree: true
+			});
+			cleanupFn(() => {
+				document.removeEventListener("focusin", handleFocusIn);
+				document.removeEventListener("focusout", handleFocusOut);
+				mutationObserver.disconnect();
+			});
+		});
+		function dispatchMountAutoFocus(container, previouslyFocusedElement) {
+			const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+			const handleMountAutoFocus = (ev) => emits("mountAutoFocus", ev);
+			container.addEventListener(AUTOFOCUS_ON_MOUNT, handleMountAutoFocus);
+			container.dispatchEvent(mountEvent);
+			container.removeEventListener(AUTOFOCUS_ON_MOUNT, handleMountAutoFocus);
+			if (!mountEvent.defaultPrevented) {
+				focusFirst(getTabbableCandidates(container), { select: true });
+				if (getActiveElement() === previouslyFocusedElement) focus(container);
+			}
+		}
+		watchEffect(async (cleanupFn) => {
+			const container = currentElement.value;
+			await nextTick();
+			if (!container) return;
+			if (props.present !== false) focusScopesStack.add(focusScope);
+			const previouslyFocusedElement = getActiveElement();
+			if (!container.contains(previouslyFocusedElement) && props.present !== false) dispatchMountAutoFocus(container, previouslyFocusedElement);
+			cleanupFn(() => {
+				const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+				const unmountEventHandler = (ev) => {
+					emits("unmountAutoFocus", ev);
+				};
+				container.addEventListener(AUTOFOCUS_ON_UNMOUNT, unmountEventHandler);
+				container.dispatchEvent(unmountEvent);
+				container.setAttribute("data-focus-scope-unmounting", "");
+				setTimeout(() => {
+					if (!unmountEvent.defaultPrevented) focus(previouslyFocusedElement ?? document.body, { select: true });
+					container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, unmountEventHandler);
+					focusScopesStack.remove(focusScope);
+					container.removeAttribute("data-focus-scope-unmounting");
+				}, 0);
+			});
+		});
+		watch(() => props.present, async (present, prevPresent) => {
+			if (!isClient) return;
+			if (present === false && prevPresent === true) {
+				focusScopesStack.remove(focusScope);
+				return;
+			}
+			if (present !== true || prevPresent !== false) return;
+			focusScopesStack.add(focusScope);
+			await nextTick();
+			const container = currentElement.value;
+			if (!container) return;
+			const previouslyFocusedElement = getActiveElement();
+			if (!container.contains(previouslyFocusedElement)) dispatchMountAutoFocus(container, previouslyFocusedElement);
+		});
+		function handleKeyDown(event) {
+			if (!props.loop && !props.trapped) return;
+			if (focusScope.paused) return;
+			const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+			const focusedElement = getActiveElement();
+			if (isTabKey && focusedElement) {
+				const container = event.currentTarget;
+				const [first, last] = getTabbableEdges(container);
+				if (!(first && last)) {
+					if (focusedElement === container) event.preventDefault();
+				} else if (!event.shiftKey && focusedElement === last) {
+					event.preventDefault();
+					if (props.loop) focus(first, { select: true });
+				} else if (event.shiftKey && focusedElement === first) {
+					event.preventDefault();
+					if (props.loop) focus(last, { select: true });
+				}
+			}
+		}
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				ref_key: "currentRef",
+				ref: currentRef,
+				tabindex: "-1",
+				"as-child": _ctx.asChild,
+				as: _ctx.as,
+				onKeydown: handleKeyDown
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, ["as-child", "as"]);
+		};
+	}
+});
+//#endregion
+export { useBodyScrollLock as n, FocusScope_default as t };

package/dist/es/chunks/Label.js

@@ -0,0 +1,36 @@
+import { t as Primitive } from "./Primitive.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { createBlock, defineComponent, mergeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Label/Label.js
+var Label_default = /* @__PURE__ */ defineComponent({
+	__name: "Label",
+	props: {
+		for: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false,
+			default: "label"
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps(props, { onMousedown: _cache[0] || (_cache[0] = (event) => {
+				if (!event.defaultPrevented && event.detail > 1) event.preventDefault();
+			}) }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+export { Label_default as t };

package/dist/es/chunks/MenuAnchor.js

@@ -0,0 +1,31 @@
+import { t as PopperAnchor_default } from "./PopperAnchor.js";
+import { createBlock, defineComponent, guardReactiveProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Menu/MenuAnchor.js
+var MenuAnchor_default = /* @__PURE__ */ defineComponent({
+	__name: "MenuAnchor",
+	props: {
+		reference: {
+			type: null,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(PopperAnchor_default), normalizeProps(guardReactiveProps(props)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+export { MenuAnchor_default as t };