@youcan/celeste 0.6.102 → 0.7.1

package/dist/es/chunks/PopperRoot.js

@@ -0,0 +1,20 @@
+import { t as createContext } from "./createContext.js";
+import { defineComponent, ref, renderSlot } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Popper/PopperRoot.js
+var [injectPopperRootContext, providePopperRootContext] = /* @__PURE__ */ createContext("PopperRoot");
+var PopperRoot_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "PopperRoot",
+	setup(__props) {
+		const anchor = ref();
+		providePopperRootContext({
+			anchor,
+			onAnchorChange: (element) => anchor.value = element
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+//#endregion
+export { injectPopperRootContext as n, PopperRoot_default as t };

package/dist/es/chunks/Presence.js

@@ -0,0 +1,182 @@
+import { d as isClient, r as unrefElement, t as defaultWindow } from "./dist.js";
+import { r as renderSlotFragments } from "./Primitive.js";
+import { computed, defineComponent, getCurrentInstance, h, nextTick, onUnmounted, ref, toRefs, watch } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/shared/useStateMachine.js
+/**
+* The `useStateMachine` function is a TypeScript function that creates a state machine and returns the
+* current state and a dispatch function to update the state based on events.
+* @param initialState - The `initialState` parameter is the initial state of the state machine. It
+* represents the starting point of the state machine's state.
+* @param machine - The `machine` parameter is an object that represents a state machine. It should
+* have keys that correspond to the possible states of the machine, and the values should be objects
+* that represent the possible events and their corresponding next states.
+* @returns The `useStateMachine` function returns an object with two properties: `state` and
+* `dispatch`.
+*/
+function useStateMachine(initialState, machine) {
+	const state = ref(initialState);
+	function reducer(event) {
+		return machine[state.value][event] ?? state.value;
+	}
+	const dispatch = (event) => {
+		state.value = reducer(event);
+	};
+	return {
+		state,
+		dispatch
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Presence/usePresence.js
+function usePresence(present, node) {
+	const stylesRef = ref({});
+	const prevAnimationNameRef = ref("none");
+	const prevPresentRef = ref(present);
+	const initialState = present.value ? "mounted" : "unmounted";
+	let timeoutId;
+	const ownerWindow = node.value?.ownerDocument.defaultView ?? defaultWindow;
+	const { state, dispatch } = useStateMachine(initialState, {
+		mounted: {
+			UNMOUNT: "unmounted",
+			ANIMATION_OUT: "unmountSuspended"
+		},
+		unmountSuspended: {
+			MOUNT: "mounted",
+			ANIMATION_END: "unmounted"
+		},
+		unmounted: { MOUNT: "mounted" }
+	});
+	const dispatchCustomEvent = (name) => {
+		if (isClient) {
+			const customEvent = new CustomEvent(name, {
+				bubbles: false,
+				cancelable: false
+			});
+			node.value?.dispatchEvent(customEvent);
+		}
+	};
+	watch(present, async (currentPresent, prevPresent) => {
+		const hasPresentChanged = prevPresent !== currentPresent;
+		await nextTick();
+		if (hasPresentChanged) {
+			const prevAnimationName = prevAnimationNameRef.value;
+			const currentAnimationName = getAnimationName(node.value);
+			if (currentPresent) {
+				dispatch("MOUNT");
+				dispatchCustomEvent("enter");
+				if (currentAnimationName === "none") dispatchCustomEvent("after-enter");
+			} else if (currentAnimationName === "none" || currentAnimationName === "undefined" || stylesRef.value?.display === "none") {
+				dispatch("UNMOUNT");
+				dispatchCustomEvent("leave");
+				dispatchCustomEvent("after-leave");
+			} else if (prevPresent && prevAnimationName !== currentAnimationName) {
+				dispatch("ANIMATION_OUT");
+				dispatchCustomEvent("leave");
+			} else {
+				dispatch("UNMOUNT");
+				dispatchCustomEvent("after-leave");
+			}
+		}
+	}, { immediate: true });
+	/**
+	* Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
+	* event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
+	* make sure we only trigger ANIMATION_END for the currently active animation.
+	*/
+	const handleAnimationEnd = (event) => {
+		const currentAnimationName = getAnimationName(node.value);
+		const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
+		const directionName = state.value === "mounted" ? "enter" : "leave";
+		if (event.target === node.value && isCurrentAnimation) {
+			dispatchCustomEvent(`after-${directionName}`);
+			dispatch("ANIMATION_END");
+			if (!prevPresentRef.value) {
+				const currentFillMode = node.value.style.animationFillMode;
+				node.value.style.animationFillMode = "forwards";
+				timeoutId = ownerWindow?.setTimeout(() => {
+					if (node.value?.style.animationFillMode === "forwards") node.value.style.animationFillMode = currentFillMode;
+				});
+			}
+		}
+		if (event.target === node.value && currentAnimationName === "none") dispatch("ANIMATION_END");
+	};
+	const handleAnimationStart = (event) => {
+		if (event.target === node.value) prevAnimationNameRef.value = getAnimationName(node.value);
+	};
+	const watcher = watch(node, (newNode, oldNode) => {
+		if (newNode) {
+			stylesRef.value = getComputedStyle(newNode);
+			newNode.addEventListener("animationstart", handleAnimationStart);
+			newNode.addEventListener("animationcancel", handleAnimationEnd);
+			newNode.addEventListener("animationend", handleAnimationEnd);
+		} else {
+			dispatch("ANIMATION_END");
+			if (timeoutId !== void 0) ownerWindow?.clearTimeout(timeoutId);
+			oldNode?.removeEventListener("animationstart", handleAnimationStart);
+			oldNode?.removeEventListener("animationcancel", handleAnimationEnd);
+			oldNode?.removeEventListener("animationend", handleAnimationEnd);
+		}
+	}, { immediate: true });
+	const stateWatcher = watch(state, () => {
+		const currentAnimationName = getAnimationName(node.value);
+		prevAnimationNameRef.value = state.value === "mounted" ? currentAnimationName : "none";
+	});
+	onUnmounted(() => {
+		watcher();
+		stateWatcher();
+		if (node.value) {
+			node.value.removeEventListener("animationstart", handleAnimationStart);
+			node.value.removeEventListener("animationcancel", handleAnimationEnd);
+			node.value.removeEventListener("animationend", handleAnimationEnd);
+		}
+		if (timeoutId !== void 0) ownerWindow?.clearTimeout(timeoutId);
+	});
+	return { isPresent: computed(() => ["mounted", "unmountSuspended"].includes(state.value)) };
+}
+function getAnimationName(node) {
+	return node ? getComputedStyle(node).animationName || "none" : "none";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Presence/Presence.js
+var Presence_default = /* @__PURE__ */ defineComponent({
+	name: "Presence",
+	props: {
+		present: {
+			type: Boolean,
+			required: true
+		},
+		forceMount: { type: Boolean }
+	},
+	slots: {},
+	setup(props, { slots, expose }) {
+		const { present, forceMount } = toRefs(props);
+		const node = ref();
+		const { isPresent } = usePresence(present, node);
+		expose({ present: isPresent });
+		let children = slots.default({ present: isPresent.value });
+		children = renderSlotFragments(children || []);
+		const instance = getCurrentInstance();
+		if (children && children?.length > 1) {
+			const componentName = instance?.parent?.type.name ? `<${instance.parent.type.name} />` : "component";
+			throw new Error([
+				`Detected an invalid children for \`${componentName}\` for  \`Presence\` component.`,
+				"",
+				"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",
+				"You can apply a few solutions:",
+				["Provide a single child element so that `presence` directive attach correctly.", "Ensure the first child is an actual element instead of a raw text node or comment node."].map((line) => `  - ${line}`).join("\n")
+			].join("\n"));
+		}
+		return () => {
+			if (forceMount.value || present.value || isPresent.value) return h(slots.default({ present: isPresent.value })[0], { ref: (v) => {
+				const el = unrefElement(v);
+				if (typeof el?.hasAttribute === "undefined") return el;
+				if (el?.hasAttribute("data-reka-popper-content-wrapper")) node.value = el.firstElementChild;
+				else node.value = el;
+				return el;
+			} });
+			else return null;
+		};
+	}
+});
+//#endregion
+export { useStateMachine as n, Presence_default as t };

package/dist/es/chunks/Primitive.js

@@ -0,0 +1,62 @@
+import { Comment, Fragment, cloneVNode, defineComponent, h, mergeProps } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/shared/renderSlotFragments.js
+function renderSlotFragments(children) {
+	if (!children) return [];
+	return children.flatMap((child) => {
+		if (child.type === Fragment) return renderSlotFragments(child.children);
+		return [child];
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Primitive/Slot.js
+var Slot = /* @__PURE__ */ defineComponent({
+	name: "PrimitiveSlot",
+	inheritAttrs: false,
+	setup(_, { attrs, slots }) {
+		return () => {
+			if (!slots.default) return null;
+			const children = renderSlotFragments(slots.default());
+			const firstNonCommentChildrenIndex = children.findIndex((child) => child.type !== Comment);
+			if (firstNonCommentChildrenIndex === -1) return children;
+			const firstNonCommentChildren = children[firstNonCommentChildrenIndex];
+			delete firstNonCommentChildren.props?.ref;
+			const mergedProps = firstNonCommentChildren.props ? mergeProps(attrs, firstNonCommentChildren.props) : attrs;
+			const cloned = cloneVNode({
+				...firstNonCommentChildren,
+				props: {}
+			}, mergedProps);
+			if (children.length === 1) return cloned;
+			children[firstNonCommentChildrenIndex] = cloned;
+			return children;
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Primitive/Primitive.js
+var SELF_CLOSING_TAGS = [
+	"area",
+	"img",
+	"input"
+];
+var Primitive = /* @__PURE__ */ defineComponent({
+	name: "Primitive",
+	inheritAttrs: false,
+	props: {
+		asChild: {
+			type: Boolean,
+			default: false
+		},
+		as: {
+			type: [String, Object],
+			default: "div"
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const asTag = props.asChild ? "template" : props.as;
+		if (typeof asTag === "string" && SELF_CLOSING_TAGS.includes(asTag)) return () => h(asTag, attrs);
+		if (asTag !== "template") return () => h(props.as, attrs, { default: slots.default });
+		return () => h(Slot, attrs, { default: slots.default });
+	}
+});
+//#endregion
+export { Slot as n, renderSlotFragments as r, Primitive as t };

package/dist/es/chunks/ProgressIndicator.js

@@ -0,0 +1,149 @@
+import { t as createContext } from "./createContext.js";
+import { t as isNullish } from "./nullish.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { computed, createBlock, defineComponent, mergeProps, nextTick, openBlock, renderSlot, unref, watch, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Progress/ProgressRoot.js
+var DEFAULT_MAX = 100;
+var [injectProgressRootContext, provideProgressRootContext] = /* @__PURE__ */ createContext("ProgressRoot");
+var isNumber = (v) => typeof v === "number";
+function validateValue(value, max) {
+	if (isNullish(value) || isNumber(value) && !Number.isNaN(value) && value <= max && value >= 0) return value;
+	console.error(`Invalid prop \`value\` of value \`${value}\` supplied to \`ProgressRoot\`. The \`value\` prop must be:
+  - a positive number
+  - less than the value passed to \`max\` (or ${DEFAULT_MAX} if no \`max\` prop is set)
+  - \`null\`  or \`undefined\` if the progress is indeterminate.
+
+Defaulting to \`null\`.`);
+	return null;
+}
+function validateMax(max) {
+	if (isNumber(max) && !Number.isNaN(max) && max > 0) return max;
+	console.error(`Invalid prop \`max\` of value \`${max}\` supplied to \`ProgressRoot\`. Only numbers greater than 0 are valid max values. Defaulting to \`${DEFAULT_MAX}\`.`);
+	return DEFAULT_MAX;
+}
+var ProgressRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "ProgressRoot",
+	props: {
+		modelValue: {
+			type: [Number, null],
+			required: false
+		},
+		max: {
+			type: Number,
+			required: false,
+			default: DEFAULT_MAX
+		},
+		getValueLabel: {
+			type: Function,
+			required: false,
+			default: (value, max) => isNumber(value) ? `${Math.round(value / max * DEFAULT_MAX)}%` : void 0
+		},
+		getValueText: {
+			type: Function,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:modelValue", "update:max"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		useForwardExpose();
+		const modelValue = useVModel(props, "modelValue", emit, { passive: props.modelValue === void 0 });
+		const max = useVModel(props, "max", emit, { passive: props.max === void 0 });
+		watch(() => modelValue.value, async (value) => {
+			const correctedValue = validateValue(value, props.max);
+			if (correctedValue !== value) {
+				await nextTick();
+				modelValue.value = correctedValue;
+			}
+		}, { immediate: true });
+		watch(() => props.max, (newMax) => {
+			const correctedMax = validateMax(props.max);
+			if (correctedMax !== newMax) max.value = correctedMax;
+		}, { immediate: true });
+		const progressState = computed(() => {
+			if (isNullish(modelValue.value)) return "indeterminate";
+			if (modelValue.value === max.value) return "complete";
+			return "loading";
+		});
+		provideProgressRootContext({
+			modelValue,
+			max,
+			progressState
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				"as-child": _ctx.asChild,
+				as: _ctx.as,
+				"aria-valuemax": unref(max),
+				"aria-valuemin": 0,
+				"aria-valuenow": isNumber(unref(modelValue)) ? unref(modelValue) : void 0,
+				"aria-valuetext": _ctx.getValueText?.(unref(modelValue), unref(max)),
+				"aria-label": _ctx.getValueLabel(unref(modelValue), unref(max)),
+				role: "progressbar",
+				"data-state": progressState.value,
+				"data-value": unref(modelValue) ?? void 0,
+				"data-max": unref(max)
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) })]),
+				_: 3
+			}, 8, [
+				"as-child",
+				"as",
+				"aria-valuemax",
+				"aria-valuenow",
+				"aria-valuetext",
+				"aria-label",
+				"data-state",
+				"data-value",
+				"data-max"
+			]);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/Progress/ProgressIndicator.js
+var ProgressIndicator_default = /* @__PURE__ */ defineComponent({
+	__name: "ProgressIndicator",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const rootContext = injectProgressRootContext();
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+				"data-state": unref(rootContext).progressState.value,
+				"data-value": unref(rootContext).modelValue?.value ?? void 0,
+				"data-max": unref(rootContext).max.value
+			}), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, [
+				"data-state",
+				"data-value",
+				"data-max"
+			]);
+		};
+	}
+});
+//#endregion
+export { ProgressRoot_default as n, ProgressIndicator_default as t };

package/dist/es/chunks/RadioGroupRoot.js

@@ -0,0 +1,131 @@
+import { t as createContext } from "./createContext.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as useDirection } from "./useDirection.js";
+import { t as useFormControl } from "./useFormControl.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { t as VisuallyHiddenInput_default } from "./VisuallyHiddenInput.js";
+import { t as RovingFocusGroup_default } from "./RovingFocusGroup.js";
+import { createBlock, createCommentVNode, createVNode, defineComponent, openBlock, renderSlot, toRefs, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RadioGroup/RadioGroupRoot.js
+var [injectRadioGroupRootContext, provideRadioGroupRootContext] = /* @__PURE__ */ createContext("RadioGroupRoot");
+var RadioGroupRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "RadioGroupRoot",
+	props: {
+		modelValue: {
+			type: null,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		loop: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false,
+			default: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { forwardRef, currentElement } = useForwardExpose();
+		const modelValue = useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue,
+			passive: props.modelValue === void 0
+		});
+		const { disabled, loop, orientation, name, required, dir: propDir } = toRefs(props);
+		const dir = useDirection(propDir);
+		const isFormControl = useFormControl(currentElement);
+		provideRadioGroupRootContext({
+			modelValue,
+			changeModelValue: (value) => {
+				modelValue.value = value;
+			},
+			disabled,
+			loop,
+			orientation,
+			name: name?.value,
+			required
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(RovingFocusGroup_default), {
+				"as-child": "",
+				orientation: unref(orientation),
+				dir: unref(dir),
+				loop: unref(loop)
+			}, {
+				default: withCtx(() => [createVNode(unref(Primitive), {
+					ref: unref(forwardRef),
+					role: "radiogroup",
+					"data-disabled": unref(disabled) ? "" : void 0,
+					"as-child": _ctx.asChild,
+					as: _ctx.as,
+					"aria-orientation": unref(orientation),
+					"aria-required": unref(required),
+					dir: unref(dir)
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) }), unref(isFormControl) && unref(name) ? (openBlock(), createBlock(unref(VisuallyHiddenInput_default), {
+						key: 0,
+						required: unref(required),
+						disabled: unref(disabled),
+						value: unref(modelValue),
+						name: unref(name)
+					}, null, 8, [
+						"required",
+						"disabled",
+						"value",
+						"name"
+					])) : createCommentVNode("v-if", true)]),
+					_: 3
+				}, 8, [
+					"data-disabled",
+					"as-child",
+					"as",
+					"aria-orientation",
+					"aria-required",
+					"dir"
+				])]),
+				_: 3
+			}, 8, [
+				"orientation",
+				"dir",
+				"loop"
+			]);
+		};
+	}
+});
+//#endregion
+export { injectRadioGroupRootContext as n, RadioGroupRoot_default as t };

package/dist/es/chunks/RovingFocusGroup.js

@@ -0,0 +1,134 @@
+import { t as createContext } from "./createContext.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as useDirection } from "./useDirection.js";
+import { t as useCollection } from "./Collection.js";
+import { n as EVENT_OPTIONS, r as focusFirst, t as ENTRY_FOCUS } from "./utils2.js";
+import { createBlock, createVNode, defineComponent, openBlock, ref, renderSlot, toRefs, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@6.0.3_/node_modules/reka-ui/dist/RovingFocus/RovingFocusGroup.js
+var [injectRovingFocusGroupContext, provideRovingFocusGroupContext] = /* @__PURE__ */ createContext("RovingFocusGroup");
+var RovingFocusGroup_default = /* @__PURE__ */ defineComponent({
+	__name: "RovingFocusGroup",
+	props: {
+		orientation: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		loop: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		currentTabStopId: {
+			type: [String, null],
+			required: false
+		},
+		defaultCurrentTabStopId: {
+			type: String,
+			required: false
+		},
+		preventScrollOnEntryFocus: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["entryFocus", "update:currentTabStopId"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { loop, orientation, dir: propDir } = toRefs(props);
+		const dir = useDirection(propDir);
+		const currentTabStopId = useVModel(props, "currentTabStopId", emits, {
+			defaultValue: props.defaultCurrentTabStopId,
+			passive: props.currentTabStopId === void 0
+		});
+		const isTabbingBackOut = ref(false);
+		const isClickFocus = ref(false);
+		const focusableItemsCount = ref(0);
+		const { getItems, CollectionSlot } = useCollection({ isProvider: true });
+		function handleFocus(event) {
+			const isKeyboardFocus = !isClickFocus.value;
+			if (event.currentTarget && event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut.value) {
+				const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);
+				event.currentTarget.dispatchEvent(entryFocusEvent);
+				emits("entryFocus", entryFocusEvent);
+				if (!entryFocusEvent.defaultPrevented) {
+					const items = getItems().map((i) => i.ref).filter((i) => i.dataset.disabled !== "");
+					focusFirst([
+						items.find((item) => item.getAttribute("data-active") === ""),
+						items.find((item) => item.getAttribute("data-highlighted") === ""),
+						items.find((item) => item.id === currentTabStopId.value),
+						...items
+					].filter(Boolean), props.preventScrollOnEntryFocus);
+				}
+			}
+			isClickFocus.value = false;
+		}
+		function handleMouseUp() {
+			setTimeout(() => {
+				isClickFocus.value = false;
+			}, 1);
+		}
+		__expose({ getItems });
+		provideRovingFocusGroupContext({
+			loop,
+			dir,
+			orientation,
+			currentTabStopId,
+			onItemFocus: (tabStopId) => {
+				currentTabStopId.value = tabStopId;
+			},
+			onItemShiftTab: () => {
+				isTabbingBackOut.value = true;
+			},
+			onFocusableItemAdd: () => {
+				focusableItemsCount.value++;
+			},
+			onFocusableItemRemove: () => {
+				focusableItemsCount.value--;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(CollectionSlot), null, {
+				default: withCtx(() => [createVNode(unref(Primitive), {
+					tabindex: isTabbingBackOut.value || focusableItemsCount.value === 0 ? -1 : 0,
+					"data-orientation": unref(orientation),
+					as: _ctx.as,
+					"as-child": _ctx.asChild,
+					dir: unref(dir),
+					style: { "outline": "none" },
+					onMousedown: _cache[0] || (_cache[0] = ($event) => isClickFocus.value = true),
+					onMouseup: handleMouseUp,
+					onFocus: handleFocus,
+					onBlur: _cache[1] || (_cache[1] = ($event) => isTabbingBackOut.value = false)
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+					_: 3
+				}, 8, [
+					"tabindex",
+					"data-orientation",
+					"as",
+					"as-child",
+					"dir"
+				])]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+export { injectRovingFocusGroupContext as n, RovingFocusGroup_default as t };