@youcan/celeste 0.21.2 → 0.22.0

package/dist/cjs/chunks/tooltip-content.cjs

@@ -1,601 +1,11 @@
-const require_clsx = require("./clsx.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime.cjs");
 const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.cjs");
-const require_dist = require("./dist.cjs");
-const require_dist$1 = require("./dist2.cjs");
-const require_DismissableLayer = require("./DismissableLayer.cjs");
-const require_defu = require("./defu.cjs");
-const require_useForwardExpose = require("./useForwardExpose.cjs");
-const require_useForwardProps = require("./useForwardProps.cjs");
-const require_useForwardPropsEmits = require("./useForwardPropsEmits.cjs");
-const require_Presence = require("./Presence.cjs");
-const require_Teleport = require("./Teleport.cjs");
-const require_VisuallyHidden = require("./VisuallyHidden.cjs");
-const require_PopperArrow = require("./PopperArrow.cjs");
-const require_PopperContent = require("./PopperContent.cjs");
-const require_TooltipProvider = require("./TooltipProvider.cjs");
-const require_TooltipRoot = require("./TooltipRoot.cjs");
 const require_compact_button = require("./compact-button.cjs");
 const require_use_delegated_props = require("../use-delegated-props.cjs");
 let vue = require("vue");
-//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/shared/useGraceArea.js
-function useGraceArea(triggerElement, containerElement) {
-	const isPointerInTransit = require_dist.refAutoReset(false, 300);
-	require_dist.tryOnScopeDispose(() => {
-		isPointerInTransit.value = false;
-	});
-	const pointerGraceArea = (0, vue.ref)(null);
-	const pointerExit = require_dist.createEventHook();
-	function handleRemoveGraceArea() {
-		pointerGraceArea.value = null;
-		isPointerInTransit.value = false;
-	}
-	function handleCreateGraceArea(event, hoverTarget) {
-		if (!hoverTarget) return;
-		const currentTarget = event.currentTarget;
-		const exitPoint = {
-			x: event.clientX,
-			y: event.clientY
-		};
-		const paddedExitPoints = getPaddedExitPoints(exitPoint, getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect()), 1);
-		const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
-		const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
-		pointerGraceArea.value = graceArea;
-		isPointerInTransit.value = true;
-	}
-	(0, vue.watchEffect)((cleanupFn) => {
-		if (triggerElement.value && containerElement.value) {
-			const trigger = triggerElement.value;
-			const container = containerElement.value;
-			const handleTriggerLeave = (event) => handleCreateGraceArea(event, container);
-			const handleContentLeave = (event) => handleCreateGraceArea(event, trigger);
-			trigger.addEventListener("pointerleave", handleTriggerLeave);
-			container.addEventListener("pointerleave", handleContentLeave);
-			cleanupFn(() => {
-				trigger.removeEventListener("pointerleave", handleTriggerLeave);
-				container.removeEventListener("pointerleave", handleContentLeave);
-			});
-		}
-	});
-	(0, vue.watchEffect)((cleanupFn) => {
-		if (pointerGraceArea.value) {
-			const handleTrackPointerGrace = (event) => {
-				if (!pointerGraceArea.value || !(event.target instanceof Element)) return;
-				const target = event.target;
-				const pointerPosition = {
-					x: event.clientX,
-					y: event.clientY
-				};
-				const hasEnteredTarget = triggerElement.value?.contains(target) || containerElement.value?.contains(target);
-				const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea.value);
-				const isAnotherGraceAreaTrigger = !!target.closest("[data-grace-area-trigger]");
-				if (hasEnteredTarget) handleRemoveGraceArea();
-				else if (isPointerOutsideGraceArea || isAnotherGraceAreaTrigger) {
-					handleRemoveGraceArea();
-					pointerExit.trigger();
-				}
-			};
-			const ownerDocument = triggerElement.value?.ownerDocument;
-			ownerDocument?.addEventListener("pointermove", handleTrackPointerGrace);
-			cleanupFn(() => ownerDocument?.removeEventListener("pointermove", handleTrackPointerGrace));
-		}
-	});
-	return {
-		isPointerInTransit,
-		onPointerExit: pointerExit.on
-	};
-}
-function getExitSideFromRect(point, rect) {
-	const top = Math.abs(rect.top - point.y);
-	const bottom = Math.abs(rect.bottom - point.y);
-	const right = Math.abs(rect.right - point.x);
-	const left = Math.abs(rect.left - point.x);
-	switch (Math.min(top, bottom, right, left)) {
-		case left: return "left";
-		case right: return "right";
-		case top: return "top";
-		case bottom: return "bottom";
-		default: throw new Error("unreachable");
-	}
-}
-function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
-	const paddedExitPoints = [];
-	switch (exitSide) {
-		case "top":
-			paddedExitPoints.push({
-				x: exitPoint.x - padding,
-				y: exitPoint.y + padding
-			}, {
-				x: exitPoint.x + padding,
-				y: exitPoint.y + padding
-			});
-			break;
-		case "bottom":
-			paddedExitPoints.push({
-				x: exitPoint.x - padding,
-				y: exitPoint.y - padding
-			}, {
-				x: exitPoint.x + padding,
-				y: exitPoint.y - padding
-			});
-			break;
-		case "left":
-			paddedExitPoints.push({
-				x: exitPoint.x + padding,
-				y: exitPoint.y - padding
-			}, {
-				x: exitPoint.x + padding,
-				y: exitPoint.y + padding
-			});
-			break;
-		case "right": paddedExitPoints.push({
-			x: exitPoint.x - padding,
-			y: exitPoint.y - padding
-		}, {
-			x: exitPoint.x - padding,
-			y: exitPoint.y + padding
-		});
-	}
-	return paddedExitPoints;
-}
-function getPointsFromRect(rect) {
-	const { top, right, bottom, left } = rect;
-	return [
-		{
-			x: left,
-			y: top
-		},
-		{
-			x: right,
-			y: top
-		},
-		{
-			x: right,
-			y: bottom
-		},
-		{
-			x: left,
-			y: bottom
-		}
-	];
-}
-function isPointInPolygon(point, polygon) {
-	const { x, y } = point;
-	let inside = false;
-	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-		const xi = polygon[i].x;
-		const yi = polygon[i].y;
-		const xj = polygon[j].x;
-		const yj = polygon[j].y;
-		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
-	}
-	return inside;
-}
-function getHull(points) {
-	const newPoints = points.slice();
-	newPoints.sort((a, b) => {
-		if (a.x < b.x) return -1;
-		else if (a.x > b.x) return 1;
-		else if (a.y < b.y) return -1;
-		else if (a.y > b.y) return 1;
-		else return 0;
-	});
-	return getHullPresorted(newPoints);
-}
-function getHullPresorted(points) {
-	if (points.length <= 1) return points.slice();
-	const upperHull = [];
-	for (let i = 0; i < points.length; i++) {
-		const p = points[i];
-		while (upperHull.length >= 2) {
-			const q = upperHull.at(-1);
-			const r = upperHull[upperHull.length - 2];
-			if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) upperHull.pop();
-			else break;
-		}
-		upperHull.push(p);
-	}
-	upperHull.pop();
-	const lowerHull = [];
-	for (let i = points.length - 1; i >= 0; i--) {
-		const p = points[i];
-		while (lowerHull.length >= 2) {
-			const q = lowerHull.at(-1);
-			const r = lowerHull[lowerHull.length - 2];
-			if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) lowerHull.pop();
-			else break;
-		}
-		lowerHull.push(p);
-	}
-	lowerHull.pop();
-	if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) return upperHull;
-	else return upperHull.concat(lowerHull);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipArrow.js
-var TooltipArrow_default = /* @__PURE__ */ (0, vue.defineComponent)({
-	__name: "TooltipArrow",
-	props: {
-		width: {
-			type: Number,
-			required: false,
-			default: 10
-		},
-		height: {
-			type: Number,
-			required: false,
-			default: 5
-		},
-		asChild: {
-			type: Boolean,
-			required: false
-		},
-		as: {
-			type: null,
-			required: false,
-			default: "svg"
-		}
-	},
-	setup(__props) {
-		const props = __props;
-		require_useForwardExpose.useForwardExpose();
-		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_PopperArrow.PopperArrow_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
-				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
-				_: 3
-			}, 16);
-		};
-	}
-});
-//#endregion
-//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipContentImpl.js
-var TooltipContentImpl_default = /* @__PURE__ */ (0, vue.defineComponent)({
-	__name: "TooltipContentImpl",
-	props: {
-		ariaLabel: {
-			type: String,
-			required: false
-		},
-		asChild: {
-			type: Boolean,
-			required: false,
-			default: void 0
-		},
-		as: {
-			type: null,
-			required: false
-		},
-		side: {
-			type: null,
-			required: false
-		},
-		sideOffset: {
-			type: Number,
-			required: false
-		},
-		align: {
-			type: null,
-			required: false
-		},
-		alignOffset: {
-			type: Number,
-			required: false
-		},
-		avoidCollisions: {
-			type: Boolean,
-			required: false,
-			default: void 0
-		},
-		collisionBoundary: {
-			type: null,
-			required: false
-		},
-		collisionPadding: {
-			type: [Number, Object],
-			required: false
-		},
-		arrowPadding: {
-			type: Number,
-			required: false
-		},
-		sticky: {
-			type: String,
-			required: false
-		},
-		hideWhenDetached: {
-			type: Boolean,
-			required: false,
-			default: void 0
-		},
-		positionStrategy: {
-			type: String,
-			required: false
-		},
-		updatePositionStrategy: {
-			type: String,
-			required: false
-		}
-	},
-	emits: ["escapeKeyDown", "pointerDownOutside"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emits = __emit;
-		const rootContext = require_TooltipRoot.injectTooltipRootContext();
-		const providerContext = require_TooltipProvider.injectTooltipProviderContext();
-		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
-		const ariaLabel = (0, vue.computed)(() => props.ariaLabel || currentElement.value?.textContent);
-		const popperContentProps = (0, vue.computed)(() => {
-			const { ariaLabel: _, ...restProps } = props;
-			return require_defu.defu(restProps, providerContext.content.value ?? {}, {
-				side: "top",
-				sideOffset: 0,
-				align: "center",
-				avoidCollisions: true,
-				collisionBoundary: [],
-				collisionPadding: 0,
-				arrowPadding: 0,
-				sticky: "partial",
-				hideWhenDetached: false
-			});
-		});
-		(0, vue.onMounted)(() => {
-			require_dist$1.useEventListener(window, "scroll", (event) => {
-				if (event.target?.contains(rootContext.trigger.value)) rootContext.onClose();
-			}, { capture: true });
-			require_dist$1.useEventListener(document, require_TooltipRoot.TOOLTIP_OPEN, rootContext.onClose);
-		});
-		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_DismissableLayer.DismissableLayer_default), {
-				"as-child": "",
-				"disable-outside-pointer-events": false,
-				onEscapeKeyDown: _cache[0] || (_cache[0] = ($event) => emits("escapeKeyDown", $event)),
-				onPointerDownOutside: _cache[1] || (_cache[1] = (event) => {
-					if ((0, vue.unref)(rootContext).disableClosingTrigger.value && (0, vue.unref)(rootContext).trigger.value?.contains(event.target)) event.preventDefault();
-					emits("pointerDownOutside", event);
-				}),
-				onFocusOutside: _cache[2] || (_cache[2] = (0, vue.withModifiers)(() => {}, ["prevent"])),
-				onDismiss: _cache[3] || (_cache[3] = ($event) => (0, vue.unref)(rootContext).onClose())
-			}, {
-				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(require_PopperContent.PopperContent_default), (0, vue.mergeProps)({
-					ref: (0, vue.unref)(forwardRef),
-					"data-state": (0, vue.unref)(rootContext).stateAttribute.value
-				}, {
-					..._ctx.$attrs,
-					...popperContentProps.value
-				}, { style: {
-					"--reka-tooltip-content-transform-origin": "var(--reka-popper-transform-origin)",
-					"--reka-tooltip-content-available-width": "var(--reka-popper-available-width)",
-					"--reka-tooltip-content-available-height": "var(--reka-popper-available-height)",
-					"--reka-tooltip-trigger-width": "var(--reka-popper-anchor-width)",
-					"--reka-tooltip-trigger-height": "var(--reka-popper-anchor-height)"
-				} }), {
-					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default"), (0, vue.createVNode)((0, vue.unref)(require_VisuallyHidden.VisuallyHidden_default), {
-						id: (0, vue.unref)(rootContext).contentId,
-						role: "tooltip"
-					}, {
-						default: (0, vue.withCtx)(() => [(0, vue.createTextVNode)((0, vue.toDisplayString)(ariaLabel.value), 1)]),
-						_: 1
-					}, 8, ["id"])]),
-					_: 3
-				}, 16, ["data-state"])]),
-				_: 3
-			});
-		};
-	}
-});
-//#endregion
-//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipContentHoverable.js
-var TooltipContentHoverable_default = /* @__PURE__ */ (0, vue.defineComponent)({
-	__name: "TooltipContentHoverable",
-	props: {
-		ariaLabel: {
-			type: String,
-			required: false
-		},
-		asChild: {
-			type: Boolean,
-			required: false
-		},
-		as: {
-			type: null,
-			required: false
-		},
-		side: {
-			type: null,
-			required: false
-		},
-		sideOffset: {
-			type: Number,
-			required: false
-		},
-		align: {
-			type: null,
-			required: false
-		},
-		alignOffset: {
-			type: Number,
-			required: false
-		},
-		avoidCollisions: {
-			type: Boolean,
-			required: false
-		},
-		collisionBoundary: {
-			type: null,
-			required: false
-		},
-		collisionPadding: {
-			type: [Number, Object],
-			required: false
-		},
-		arrowPadding: {
-			type: Number,
-			required: false
-		},
-		sticky: {
-			type: String,
-			required: false
-		},
-		hideWhenDetached: {
-			type: Boolean,
-			required: false
-		},
-		positionStrategy: {
-			type: String,
-			required: false
-		},
-		updatePositionStrategy: {
-			type: String,
-			required: false
-		}
-	},
-	setup(__props) {
-		const forwardedProps = require_useForwardProps.useForwardProps(__props);
-		const { forwardRef, currentElement } = require_useForwardExpose.useForwardExpose();
-		const { trigger, onClose } = require_TooltipRoot.injectTooltipRootContext();
-		const providerContext = require_TooltipProvider.injectTooltipProviderContext();
-		const { isPointerInTransit, onPointerExit } = useGraceArea(trigger, currentElement);
-		providerContext.isPointerInTransitRef = isPointerInTransit;
-		onPointerExit(() => {
-			onClose();
-		});
-		require_dist$1.useEventListener(currentElement, "pointermove", (event) => {
-			const content = currentElement.value;
-			if (!content || event.pointerType === "touch") return;
-			if (content.ownerDocument.elementsFromPoint?.(event.clientX, event.clientY).some((el) => {
-				if (content.contains(el)) return false;
-				const coveredTrigger = el.closest("[data-grace-area-trigger]");
-				return !!coveredTrigger && coveredTrigger !== trigger.value;
-			})) onClose();
-		});
-		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)(TooltipContentImpl_default, (0, vue.mergeProps)({ ref: (0, vue.unref)(forwardRef) }, (0, vue.unref)(forwardedProps)), {
-				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
-				_: 3
-			}, 16);
-		};
-	}
-});
-//#endregion
-//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipContent.js
-var TooltipContent_default = /* @__PURE__ */ (0, vue.defineComponent)({
-	__name: "TooltipContent",
-	props: {
-		forceMount: {
-			type: Boolean,
-			required: false
-		},
-		ariaLabel: {
-			type: String,
-			required: false
-		},
-		asChild: {
-			type: Boolean,
-			required: false
-		},
-		as: {
-			type: null,
-			required: false
-		},
-		side: {
-			type: null,
-			required: false
-		},
-		sideOffset: {
-			type: Number,
-			required: false
-		},
-		align: {
-			type: null,
-			required: false
-		},
-		alignOffset: {
-			type: Number,
-			required: false
-		},
-		avoidCollisions: {
-			type: Boolean,
-			required: false
-		},
-		collisionBoundary: {
-			type: null,
-			required: false
-		},
-		collisionPadding: {
-			type: [Number, Object],
-			required: false
-		},
-		arrowPadding: {
-			type: Number,
-			required: false
-		},
-		sticky: {
-			type: String,
-			required: false
-		},
-		hideWhenDetached: {
-			type: Boolean,
-			required: false
-		},
-		positionStrategy: {
-			type: String,
-			required: false
-		},
-		updatePositionStrategy: {
-			type: String,
-			required: false
-		}
-	},
-	emits: ["escapeKeyDown", "pointerDownOutside"],
-	setup(__props, { emit: __emit }) {
-		const props = __props;
-		const emits = __emit;
-		const rootContext = require_TooltipRoot.injectTooltipRootContext();
-		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(props, emits);
-		const { forwardRef } = require_useForwardExpose.useForwardExpose();
-		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Presence.Presence_default), { present: _ctx.forceMount || (0, vue.unref)(rootContext).open.value }, {
-				default: (0, vue.withCtx)(() => [((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.resolveDynamicComponent)((0, vue.unref)(rootContext).disableHoverableContent.value ? TooltipContentImpl_default : TooltipContentHoverable_default), (0, vue.mergeProps)({ ref: (0, vue.unref)(forwardRef) }, (0, vue.unref)(forwarded)), {
-					default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
-					_: 3
-				}, 16))]),
-				_: 3
-			}, 8, ["present"]);
-		};
-	}
-});
-//#endregion
-//#region ../../node_modules/.pnpm/reka-ui@2.10.5_vue@3.5.41_typescript@6.0.3_/node_modules/reka-ui/dist/Tooltip/TooltipPortal.js
-var TooltipPortal_default = /* @__PURE__ */ (0, vue.defineComponent)({
-	__name: "TooltipPortal",
-	props: {
-		to: {
-			type: null,
-			required: false
-		},
-		disabled: {
-			type: Boolean,
-			required: false
-		},
-		defer: {
-			type: Boolean,
-			required: false
-		},
-		forceMount: {
-			type: Boolean,
-			required: false
-		}
-	},
-	setup(__props) {
-		const props = __props;
-		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_Teleport.Teleport_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
-				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
-				_: 3
-			}, 16);
-		};
-	}
-});
-//#endregion
+let clsx = require("clsx");
+clsx = require_rolldown_runtime.__toESM(clsx, 1);
+let reka_ui = require("reka-ui");
 //#region src/components/tooltip/tooltip-content.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = { class: "celeste-tooltip-content-box" };
 var _hoisted_2 = {
@@ -654,16 +64,16 @@ var tooltip_content_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/
 			"dismissible",
 			"onDismiss"
 		]);
-		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(delegated, emits);
+		const forwarded = (0, reka_ui.useForwardPropsEmits)(delegated, emits);
 		function handleDismiss() {
 			props.onDismiss?.();
 		}
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(TooltipPortal_default), { class: "celeste-tooltip-portal" }, {
-				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(TooltipContent_default), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(reka_ui.TooltipPortal), { class: "celeste-tooltip-portal" }, {
+				default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(reka_ui.TooltipContent), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
 					size: __props.size,
 					variant: __props.variant,
-					class: (0, vue.unref)(require_clsx.clsx)("celeste-tooltip-content", props.class)
+					class: (0, vue.unref)(clsx.default)("celeste-tooltip-content", props.class)
 				}), {
 					default: (0, vue.withCtx)(() => [
 						__props.icon ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("i", {
@@ -681,7 +91,7 @@ var tooltip_content_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/
 							icon: "i-celeste-close-line",
 							onClick: handleDismiss
 						})) : (0, vue.createCommentVNode)("", true),
-						(0, vue.createVNode)((0, vue.unref)(TooltipArrow_default), { "as-child": "" }, {
+						(0, vue.createVNode)((0, vue.unref)(reka_ui.TooltipArrow), { "as-child": "" }, {
 							default: (0, vue.withCtx)(() => [..._cache[0] || (_cache[0] = [(0, vue.createElementVNode)("span", { class: "celeste-tooltip-content-arrow" }, null, -1)])]),
 							_: 1
 						})

package/dist/cjs/chunks/tooltip-provider.cjs

@@ -1,5 +1,5 @@
-const require_TooltipProvider = require("./TooltipProvider.cjs");
 let vue = require("vue");
+let reka_ui = require("reka-ui");
 //#endregion
 //#region src/components/tooltip/tooltip-provider.vue
 var tooltip_provider_default = /* @__PURE__ */ (0, vue.defineComponent)({
@@ -16,7 +16,7 @@ var tooltip_provider_default = /* @__PURE__ */ (0, vue.defineComponent)({
 	setup(__props) {
 		const props = __props;
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_TooltipProvider.TooltipProvider_default), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(reka_ui.TooltipProvider), (0, vue.normalizeProps)((0, vue.guardReactiveProps)(props)), {
 				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
 				_: 3
 			}, 16);

package/dist/cjs/chunks/tooltip-root.cjs

@@ -1,7 +1,6 @@
-const require_useForwardPropsEmits = require("./useForwardPropsEmits.cjs");
-const require_TooltipRoot = require("./TooltipRoot.cjs");
 const require_use_delegated_props = require("../use-delegated-props.cjs");
 let vue = require("vue");
+let reka_ui = require("reka-ui");
 //#endregion
 //#region src/components/tooltip/tooltip-root.vue
 var tooltip_root_default = /* @__PURE__ */ (0, vue.defineComponent)({
@@ -20,10 +19,10 @@ var tooltip_root_default = /* @__PURE__ */ (0, vue.defineComponent)({
 		const props = __props;
 		const emits = __emit;
 		const delegatedProps = require_use_delegated_props.useDelegatedProps(props, "open");
-		const forwarded = require_useForwardPropsEmits.useForwardPropsEmits(delegatedProps, emits);
+		const forwarded = (0, reka_ui.useForwardPropsEmits)(delegatedProps, emits);
 		const open = (0, vue.ref)(false);
 		return (_ctx, _cache) => {
-			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_TooltipRoot.TooltipRoot_default), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(reka_ui.TooltipRoot), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
 				open: open.value,
 				"onUpdate:open": _cache[0] || (_cache[0] = ($event) => open.value = $event)
 			}), {