@youcan/celeste 0.6.101 → 0.7.0

package/dist/cjs/chunks/SelectItemAlignedPosition.cjs

@@ -0,0 +1,593 @@
+require("./chunk.cjs");
+const require_clamp = require("./clamp.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_DismissableLayer = require("./DismissableLayer.cjs");
+const require_FocusScope = require("./FocusScope.cjs");
+const require_useFocusGuards = require("./useFocusGuards.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_useForwardProps = require("./useForwardProps.cjs");
+const require_useHideOthers = require("./useHideOthers.cjs");
+const require_useTypeahead = require("./useTypeahead.cjs");
+const require_utils = require("./utils.cjs");
+const require_Collection = require("./Collection.cjs");
+const require_PopperContent = require("./PopperContent.cjs");
+const require_BubbleSelect = require("./BubbleSelect.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Select/SelectPopperPosition.js
+var SelectPopperPosition_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "SelectPopperPosition",
+	props: {
+		memoDependencies: {
+			type: Array,
+			required: false
+		},
+		side: {
+			type: null,
+			required: false
+		},
+		sideOffset: {
+			type: Number,
+			required: false
+		},
+		sideFlip: {
+			type: Boolean,
+			required: false
+		},
+		align: {
+			type: null,
+			required: false,
+			default: "start"
+		},
+		alignOffset: {
+			type: Number,
+			required: false
+		},
+		alignFlip: {
+			type: Boolean,
+			required: false
+		},
+		avoidCollisions: {
+			type: Boolean,
+			required: false
+		},
+		collisionBoundary: {
+			type: null,
+			required: false
+		},
+		collisionPadding: {
+			type: [Number, Object],
+			required: false,
+			default: 10
+		},
+		arrowPadding: {
+			type: Number,
+			required: false
+		},
+		hideShiftedArrow: {
+			type: Boolean,
+			required: false
+		},
+		sticky: {
+			type: String,
+			required: false
+		},
+		hideWhenDetached: {
+			type: Boolean,
+			required: false
+		},
+		positionStrategy: {
+			type: String,
+			required: false
+		},
+		updatePositionStrategy: {
+			type: String,
+			required: false
+		},
+		disableUpdateOnLayoutShift: {
+			type: Boolean,
+			required: false
+		},
+		prioritizePosition: {
+			type: Boolean,
+			required: false
+		},
+		reference: {
+			type: null,
+			required: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const forwarded = require_useForwardProps.useForwardProps(__props);
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperContent.PopperContent_default), (0, vue.mergeProps)((0, vue.unref)(forwarded), { style: {
+				"boxSizing": "border-box",
+				"--reka-select-content-transform-origin": "var(--reka-popper-transform-origin)",
+				"--reka-select-content-available-width": "var(--reka-popper-available-width)",
+				"--reka-select-content-available-height": "var(--reka-popper-available-height)",
+				"--reka-select-trigger-width": "var(--reka-popper-anchor-width)",
+				"--reka-select-trigger-height": "var(--reka-popper-anchor-height)"
+			} }), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16);
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Select/SelectContentImpl.js
+var SelectContentDefaultContextValue = {
+	onViewportChange: () => {},
+	itemTextRefCallback: () => {},
+	itemRefCallback: () => {}
+};
+var [injectSelectContentContext, provideSelectContentContext] = /* @__PURE__ */ require_createContext.createContext("SelectContent");
+var SelectContentImpl_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "SelectContentImpl",
+	props: {
+		position: {
+			type: String,
+			required: false,
+			default: "item-aligned"
+		},
+		bodyLock: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		memoDependencies: {
+			type: Array,
+			required: false
+		},
+		side: {
+			type: null,
+			required: false
+		},
+		sideOffset: {
+			type: Number,
+			required: false
+		},
+		sideFlip: {
+			type: Boolean,
+			required: false
+		},
+		align: {
+			type: null,
+			required: false,
+			default: "start"
+		},
+		alignOffset: {
+			type: Number,
+			required: false
+		},
+		alignFlip: {
+			type: Boolean,
+			required: false
+		},
+		avoidCollisions: {
+			type: Boolean,
+			required: false
+		},
+		collisionBoundary: {
+			type: null,
+			required: false
+		},
+		collisionPadding: {
+			type: [Number, Object],
+			required: false
+		},
+		arrowPadding: {
+			type: Number,
+			required: false
+		},
+		hideShiftedArrow: {
+			type: Boolean,
+			required: false
+		},
+		sticky: {
+			type: String,
+			required: false
+		},
+		hideWhenDetached: {
+			type: Boolean,
+			required: false
+		},
+		positionStrategy: {
+			type: String,
+			required: false
+		},
+		updatePositionStrategy: {
+			type: String,
+			required: false
+		},
+		disableUpdateOnLayoutShift: {
+			type: Boolean,
+			required: false
+		},
+		prioritizePosition: {
+			type: Boolean,
+			required: false
+		},
+		reference: {
+			type: null,
+			required: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		},
+		disableOutsidePointerEvents: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	emits: [
+		"closeAutoFocus",
+		"escapeKeyDown",
+		"pointerDownOutside"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const rootContext = require_BubbleSelect.injectSelectRootContext();
+		require_useFocusGuards.useFocusGuards();
+		require_FocusScope.useBodyScrollLock(props.bodyLock);
+		const { CollectionSlot, getItems } = require_Collection.useCollection();
+		const content = (0, vue.ref)();
+		require_useHideOthers.useHideOthers(content);
+		const { search, handleTypeaheadSearch } = require_useTypeahead.useTypeahead();
+		const viewport = (0, vue.ref)();
+		const selectedItem = (0, vue.ref)();
+		const selectedItemText = (0, vue.ref)();
+		const isPositioned = (0, vue.ref)(false);
+		const firstValidItemFoundRef = (0, vue.ref)(false);
+		const firstSelectedItemInArrayFoundRef = (0, vue.ref)(false);
+		function focusSelectedItem() {
+			if (selectedItem.value && content.value) require_utils.focusFirst([selectedItem.value, content.value]);
+		}
+		(0, vue.watch)(isPositioned, () => {
+			focusSelectedItem();
+		});
+		const { onOpenChange, triggerPointerDownPosRef } = rootContext;
+		(0, vue.watchEffect)((cleanupFn) => {
+			if (!content.value) return;
+			let pointerMoveDelta = {
+				x: 0,
+				y: 0
+			};
+			const handlePointerMove = (event) => {
+				pointerMoveDelta = {
+					x: Math.abs(Math.round(event.pageX) - (triggerPointerDownPosRef.value?.x ?? 0)),
+					y: Math.abs(Math.round(event.pageY) - (triggerPointerDownPosRef.value?.y ?? 0))
+				};
+			};
+			const handlePointerUp = (event) => {
+				if (event.pointerType === "touch") return;
+				if (pointerMoveDelta.x <= 10 && pointerMoveDelta.y <= 10) event.preventDefault();
+				else if (!content.value?.contains(event.target)) onOpenChange(false);
+				document.removeEventListener("pointermove", handlePointerMove);
+				triggerPointerDownPosRef.value = null;
+			};
+			if (triggerPointerDownPosRef.value !== null) {
+				document.addEventListener("pointermove", handlePointerMove);
+				document.addEventListener("pointerup", handlePointerUp, {
+					capture: true,
+					once: true
+				});
+			}
+			cleanupFn(() => {
+				document.removeEventListener("pointermove", handlePointerMove);
+				document.removeEventListener("pointerup", handlePointerUp, { capture: true });
+			});
+		});
+		function handleKeyDown(event) {
+			const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+			if (event.key === "Tab") event.preventDefault();
+			if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key, getItems());
+			if ([
+				"ArrowUp",
+				"ArrowDown",
+				"Home",
+				"End"
+			].includes(event.key)) {
+				let candidateNodes = [...getItems().map((i) => i.ref)];
+				if (["ArrowUp", "End"].includes(event.key)) candidateNodes = candidateNodes.slice().reverse();
+				if (["ArrowUp", "ArrowDown"].includes(event.key)) {
+					const currentElement = event.target;
+					const currentIndex = candidateNodes.indexOf(currentElement);
+					candidateNodes = candidateNodes.slice(currentIndex + 1);
+				}
+				setTimeout(() => require_utils.focusFirst(candidateNodes));
+				event.preventDefault();
+			}
+		}
+		const forwardedProps = require_useForwardProps.useForwardProps((0, vue.computed)(() => {
+			if (props.position === "popper") return props;
+			else return {};
+		}).value);
+		provideSelectContentContext({
+			content,
+			viewport,
+			onViewportChange: (node) => {
+				viewport.value = node;
+			},
+			itemRefCallback: (node, value, disabled) => {
+				const isFirstValidItem = !firstValidItemFoundRef.value && !disabled;
+				const isSelectedItem = require_BubbleSelect.valueComparator(rootContext.modelValue.value, value, rootContext.by);
+				if (rootContext.multiple.value) {
+					if (firstSelectedItemInArrayFoundRef.value) return;
+					if (isSelectedItem || isFirstValidItem) {
+						selectedItem.value = node;
+						if (isSelectedItem) firstSelectedItemInArrayFoundRef.value = true;
+					}
+				} else if (isSelectedItem || isFirstValidItem) selectedItem.value = node;
+				if (isFirstValidItem) firstValidItemFoundRef.value = true;
+			},
+			selectedItem,
+			selectedItemText,
+			onItemLeave: () => {
+				content.value?.focus();
+			},
+			itemTextRefCallback: (node, value, disabled) => {
+				const isFirstValidItem = !firstValidItemFoundRef.value && !disabled;
+				if (require_BubbleSelect.valueComparator(rootContext.modelValue.value, value, rootContext.by) || isFirstValidItem) selectedItemText.value = node;
+			},
+			focusSelectedItem,
+			position: props.position,
+			isPositioned,
+			searchRef: search
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(CollectionSlot), null, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_FocusScope.FocusScope_default), {
+					"as-child": "",
+					onMountAutoFocus: _cache[6] || (_cache[6] = (0, vue.withModifiers)(() => {}, ["prevent"])),
+					onUnmountAutoFocus: _cache[7] || (_cache[7] = (event) => {
+						emits("closeAutoFocus", event);
+						if (event.defaultPrevented) return;
+						(0, vue.unref)(rootContext).triggerElement.value?.focus({ preventScroll: true });
+						event.preventDefault();
+					})
+				}, {
+					default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_DismissableLayer.DismissableLayer_default), {
+						"as-child": "",
+						"disable-outside-pointer-events": _ctx.disableOutsidePointerEvents,
+						onFocusOutside: _cache[2] || (_cache[2] = (0, vue.withModifiers)(() => {}, ["prevent"])),
+						onDismiss: _cache[3] || (_cache[3] = ($event) => (0, vue.unref)(rootContext).onOpenChange(false)),
+						onEscapeKeyDown: _cache[4] || (_cache[4] = ($event) => emits("escapeKeyDown", $event)),
+						onPointerDownOutside: _cache[5] || (_cache[5] = ($event) => emits("pointerDownOutside", $event))
+					}, {
+						default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)(_ctx.position === "popper" ? SelectPopperPosition_default : SelectItemAlignedPosition_default), (0, vue.mergeProps)({
+							..._ctx.$attrs,
+							...(0, vue.unref)(forwardedProps)
+						}, {
+							id: (0, vue.unref)(rootContext).contentId,
+							ref: (vnode) => {
+								if (!vnode) return void 0;
+								const el = (0, vue.unref)(require_dist.unrefElement)(vnode);
+								if (el?.hasAttribute("data-reka-popper-content-wrapper")) content.value = el.firstElementChild;
+								else content.value = el;
+							},
+							role: "listbox",
+							"data-state": (0, vue.unref)(rootContext).open.value ? "open" : "closed",
+							dir: (0, vue.unref)(rootContext).dir.value,
+							style: {
+								display: "flex",
+								flexDirection: "column",
+								outline: "none"
+							},
+							onContextmenu: _cache[0] || (_cache[0] = (0, vue.withModifiers)(() => {}, ["prevent"])),
+							onPlaced: _cache[1] || (_cache[1] = ($event) => isPositioned.value = true),
+							onKeydown: handleKeyDown
+						}), {
+							default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+							_: 3
+						}, 16, [
+							"id",
+							"data-state",
+							"dir",
+							"onKeydown"
+						]))]),
+						_: 3
+					}, 8, ["disable-outside-pointer-events"])]),
+					_: 3
+				})]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Select/SelectItemAlignedPosition.js
+var [injectSelectItemAlignedPositionContext, provideSelectItemAlignedPositionContext] = /* @__PURE__ */ require_createContext.createContext("SelectItemAlignedPosition");
+var SelectItemAlignedPosition_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	inheritAttrs: false,
+	__name: "SelectItemAlignedPosition",
+	props: {
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["placed"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { getItems } = require_Collection.useCollection();
+		const rootContext = require_BubbleSelect.injectSelectRootContext();
+		const contentContext = injectSelectContentContext();
+		const shouldExpandOnScrollRef = (0, vue.ref)(false);
+		const shouldRepositionRef = (0, vue.ref)(true);
+		const contentWrapperElement = (0, vue.ref)();
+		const { forwardRef, currentElement: contentElement } = require_useForwardExpose.useForwardExpose();
+		const { viewport, selectedItem, selectedItemText, focusSelectedItem } = contentContext;
+		function position() {
+			if (rootContext.triggerElement.value && rootContext.valueElement.value && contentWrapperElement.value && contentElement.value && viewport?.value && selectedItem?.value && selectedItemText?.value) {
+				const triggerRect = rootContext.triggerElement.value.getBoundingClientRect();
+				const contentRect = contentElement.value.getBoundingClientRect();
+				const valueNodeRect = rootContext.valueElement.value.getBoundingClientRect();
+				const itemTextRect = selectedItemText.value.getBoundingClientRect();
+				if (rootContext.dir.value !== "rtl") {
+					const itemTextOffset = itemTextRect.left - contentRect.left;
+					const left = valueNodeRect.left - itemTextOffset;
+					const leftDelta = triggerRect.left - left;
+					const minContentWidth = triggerRect.width + leftDelta;
+					const contentWidth = Math.max(minContentWidth, contentRect.width);
+					const rightEdge = window.innerWidth - 10;
+					const clampedLeft = require_clamp.clamp(left, 10, Math.max(10, rightEdge - contentWidth));
+					contentWrapperElement.value.style.minWidth = `${minContentWidth}px`;
+					contentWrapperElement.value.style.left = `${clampedLeft}px`;
+				} else {
+					const itemTextOffset = contentRect.right - itemTextRect.right;
+					const right = window.innerWidth - valueNodeRect.right - itemTextOffset;
+					const rightDelta = window.innerWidth - triggerRect.right - right;
+					const minContentWidth = triggerRect.width + rightDelta;
+					const contentWidth = Math.max(minContentWidth, contentRect.width);
+					const leftEdge = window.innerWidth - 10;
+					const clampedRight = require_clamp.clamp(right, 10, Math.max(10, leftEdge - contentWidth));
+					contentWrapperElement.value.style.minWidth = `${minContentWidth}px`;
+					contentWrapperElement.value.style.right = `${clampedRight}px`;
+				}
+				const items = getItems().map((i) => i.ref);
+				const availableHeight = window.innerHeight - 20;
+				const itemsHeight = viewport.value.scrollHeight;
+				const contentStyles = window.getComputedStyle(contentElement.value);
+				const contentBorderTopWidth = Number.parseInt(contentStyles.borderTopWidth, 10);
+				const contentPaddingTop = Number.parseInt(contentStyles.paddingTop, 10);
+				const contentBorderBottomWidth = Number.parseInt(contentStyles.borderBottomWidth, 10);
+				const contentPaddingBottom = Number.parseInt(contentStyles.paddingBottom, 10);
+				const fullContentHeight = contentBorderTopWidth + contentPaddingTop + itemsHeight + contentPaddingBottom + contentBorderBottomWidth;
+				const minContentHeight = Math.min(selectedItem.value.offsetHeight * 5, fullContentHeight);
+				const viewportStyles = window.getComputedStyle(viewport.value);
+				const viewportPaddingTop = Number.parseInt(viewportStyles.paddingTop, 10);
+				const viewportPaddingBottom = Number.parseInt(viewportStyles.paddingBottom, 10);
+				const topEdgeToTriggerMiddle = triggerRect.top + triggerRect.height / 2 - 10;
+				const triggerMiddleToBottomEdge = availableHeight - topEdgeToTriggerMiddle;
+				const selectedItemHalfHeight = selectedItem.value.offsetHeight / 2;
+				const itemOffsetMiddle = selectedItem.value.offsetTop + selectedItemHalfHeight;
+				const contentTopToItemMiddle = contentBorderTopWidth + contentPaddingTop + itemOffsetMiddle;
+				const itemMiddleToContentBottom = fullContentHeight - contentTopToItemMiddle;
+				if (contentTopToItemMiddle <= topEdgeToTriggerMiddle) {
+					const isLastItem = selectedItem.value === items.at(-1);
+					contentWrapperElement.value.style.bottom = `0px`;
+					const viewportOffsetBottom = contentElement.value.clientHeight - viewport.value.offsetTop - viewport.value.offsetHeight;
+					const height = contentTopToItemMiddle + Math.max(triggerMiddleToBottomEdge, selectedItemHalfHeight + (isLastItem ? viewportPaddingBottom : 0) + viewportOffsetBottom + contentBorderBottomWidth);
+					contentWrapperElement.value.style.height = `${height}px`;
+				} else {
+					const isFirstItem = selectedItem.value === items[0];
+					contentWrapperElement.value.style.top = `0px`;
+					const height = Math.max(topEdgeToTriggerMiddle, contentBorderTopWidth + viewport.value.offsetTop + (isFirstItem ? viewportPaddingTop : 0) + selectedItemHalfHeight) + itemMiddleToContentBottom;
+					contentWrapperElement.value.style.height = `${height}px`;
+					viewport.value.scrollTop = contentTopToItemMiddle - topEdgeToTriggerMiddle + viewport.value.offsetTop;
+				}
+				contentWrapperElement.value.style.margin = `10px 0`;
+				contentWrapperElement.value.style.minHeight = `${minContentHeight}px`;
+				contentWrapperElement.value.style.maxHeight = `${availableHeight}px`;
+				emits("placed");
+				requestAnimationFrame(() => shouldExpandOnScrollRef.value = true);
+			}
+		}
+		const contentZIndex = (0, vue.ref)("");
+		(0, vue.onMounted)(async () => {
+			await (0, vue.nextTick)();
+			position();
+			if (contentElement.value) contentZIndex.value = window.getComputedStyle(contentElement.value).zIndex;
+		});
+		function handleScrollButtonChange(node) {
+			if (node && shouldRepositionRef.value === true) {
+				position();
+				focusSelectedItem?.();
+				shouldRepositionRef.value = false;
+			}
+		}
+		require_dist.useResizeObserver(rootContext.triggerElement, () => {
+			position();
+		});
+		provideSelectItemAlignedPositionContext({
+			contentWrapper: contentWrapperElement,
+			shouldExpandOnScrollRef,
+			onScrollButtonChange: handleScrollButtonChange
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+				ref_key: "contentWrapperElement",
+				ref: contentWrapperElement,
+				style: (0, vue.normalizeStyle)({
+					display: "flex",
+					flexDirection: "column",
+					position: "fixed",
+					zIndex: contentZIndex.value
+				})
+			}, [(0, vue.createVNode)((0, vue.unref)(require_Primitive.Primitive), (0, vue.mergeProps)({
+				ref: (0, vue.unref)(forwardRef),
+				style: {
+					boxSizing: "border-box",
+					maxHeight: "100%"
+				}
+			}, {
+				..._ctx.$attrs,
+				...props
+			}), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
+				_: 3
+			}, 16)], 4);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "SelectContentDefaultContextValue", {
+	enumerable: true,
+	get: function() {
+		return SelectContentDefaultContextValue;
+	}
+});
+Object.defineProperty(exports, "SelectContentImpl_default", {
+	enumerable: true,
+	get: function() {
+		return SelectContentImpl_default;
+	}
+});
+Object.defineProperty(exports, "injectSelectContentContext", {
+	enumerable: true,
+	get: function() {
+		return injectSelectContentContext;
+	}
+});
+Object.defineProperty(exports, "injectSelectItemAlignedPositionContext", {
+	enumerable: true,
+	get: function() {
+		return injectSelectItemAlignedPositionContext;
+	}
+});
+Object.defineProperty(exports, "provideSelectContentContext", {
+	enumerable: true,
+	get: function() {
+		return provideSelectContentContext;
+	}
+});

package/dist/cjs/chunks/TabsRoot.cjs

@@ -0,0 +1,114 @@
+require("./chunk.cjs");
+const require_createContext = require("./createContext.cjs");
+const require_dist = require("./dist.cjs");
+const require_Primitive = require("./Primitive.cjs");
+const require_useDirection = require("./useDirection.cjs");
+const require_useForwardExpose = require("./useForwardExpose.cjs");
+const require_useId = require("./useId.cjs");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Tabs/TabsRoot.js
+var [injectTabsRootContext, provideTabsRootContext] = /* @__PURE__ */ require_createContext.createContext("TabsRoot");
+var TabsRoot_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "TabsRoot",
+	props: {
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		orientation: {
+			type: String,
+			required: false,
+			default: "horizontal"
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		activationMode: {
+			type: String,
+			required: false,
+			default: "automatic"
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		unmountOnHide: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { orientation, unmountOnHide, dir: propDir } = (0, vue.toRefs)(props);
+		const dir = require_useDirection.useDirection(propDir);
+		require_useForwardExpose.useForwardExpose();
+		const modelValue = require_dist.useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue,
+			passive: props.modelValue === void 0
+		});
+		const tabsList = (0, vue.ref)();
+		const contentIds = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
+		provideTabsRootContext({
+			modelValue,
+			changeModelValue: (value) => {
+				modelValue.value = value;
+			},
+			orientation,
+			dir,
+			unmountOnHide,
+			activationMode: props.activationMode,
+			baseId: require_useId.useId(void 0, "reka-tabs"),
+			tabsList,
+			contentIds,
+			registerContent: (value) => {
+				contentIds.value = new Set([...contentIds.value, value]);
+			},
+			unregisterContent: (value) => {
+				const newSet = new Set(contentIds.value);
+				newSet.delete(value);
+				contentIds.value = newSet;
+			}
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Primitive.Primitive), {
+				dir: (0, vue.unref)(dir),
+				"data-orientation": (0, vue.unref)(orientation),
+				"as-child": _ctx.asChild,
+				as: _ctx.as
+			}, {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", { modelValue: (0, vue.unref)(modelValue) })]),
+				_: 3
+			}, 8, [
+				"dir",
+				"data-orientation",
+				"as-child",
+				"as"
+			]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "TabsRoot_default", {
+	enumerable: true,
+	get: function() {
+		return TabsRoot_default;
+	}
+});
+Object.defineProperty(exports, "injectTabsRootContext", {
+	enumerable: true,
+	get: function() {
+		return injectTabsRootContext;
+	}
+});