ropav 0.1.7 → 0.1.8

package/dist/file-input.js

@@ -0,0 +1,198 @@
+import './file-input.css';
+import { t as useStylesApi } from "./styles-api.js";
+import { n as toPresenceAttribute } from "./attributes.js";
+import { t as bem } from "./bem.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { o as splitCompatibilityAttributes, t as composeEventHandlers } from "./attributes2.js";
+import { t as useControlState } from "./useControlState.js";
+import { t as useNativeFileSelection } from "./useNativeFileSelection.js";
+import { child, computed, createSlot, defineVaporComponent, next, renderEffect, setDynamicProps, setInsertionState, setStaticTemplateRef, setText, template, toDisplayString, unref } from "vue";
+//#region src/components/file-input/useFileInput.ts
+function useFileInput(props, emitUpdate) {
+	const control = useControlState(props);
+	const { inputRef, files, settleSelection, clear, focus, open } = useNativeFileSelection({
+		modelValue: () => props.modelValue,
+		multiple: () => props.multiple ?? false,
+		disabled: () => control.disabled,
+		validationMessage: () => props.validationMessage,
+		onChange: emitUpdate
+	});
+	const fileNames = computed(() => files.value.map((file) => file.name));
+	const hasFiles = computed(() => files.value.length > 0);
+	const rootClass = computed(() => bem("rp-file-input", {
+		[`size-${props.size}`]: Boolean(props.size),
+		[`radius-${props.radius}`]: Boolean(props.radius),
+		disabled: control.disabled,
+		invalid: control.invalid,
+		valid: control.valid && !control.invalid,
+		filled: hasFiles.value
+	}));
+	const buttonText = computed(() => props.buttonLabel ?? (props.multiple ? "Choose files" : "Choose file"));
+	const displayValue = computed(() => {
+		if (hasFiles.value) return fileNames.value.join(", ");
+		return props.placeholder ?? (props.multiple ? "No files selected" : "No file selected");
+	});
+	function onChange(event) {
+		const input = event.target;
+		settleSelection({
+			status: "accepted",
+			files: input.files ?? []
+		});
+	}
+	return {
+		inputRef,
+		control,
+		files,
+		fileNames,
+		hasFiles,
+		rootClass,
+		buttonText,
+		displayValue,
+		onChange,
+		clear,
+		focus,
+		open
+	};
+}
+//#endregion
+//#region src/components/file-input/file-input.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template(" ");
+var t1 = template("<div data-v-c2dff394><input data-v-c2dff394><span data-v-c2dff394></span><span data-v-c2dff394>", 1);
+//#endregion
+//#region src/components/file-input/file-input.vue
+var file_input_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpFileInput",
+	inheritAttrs: false,
+	__name: "file-input",
+	props: {
+		id: {},
+		name: {},
+		form: {},
+		modelValue: { default: void 0 },
+		accept: { default: void 0 },
+		capture: {
+			type: [Boolean, String],
+			default: void 0
+		},
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		size: {},
+		radius: {},
+		buttonLabel: { default: void 0 },
+		placeholder: { default: void 0 },
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		required: {
+			type: Boolean,
+			default: void 0
+		},
+		invalid: {
+			type: Boolean,
+			default: void 0
+		},
+		valid: {
+			type: Boolean,
+			default: void 0
+		},
+		ariaLabel: {},
+		describedby: {},
+		labelledby: {},
+		inputAttrs: {},
+		validationMessage: {},
+		classNames: {},
+		styles: {}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { inputRef, control, files, fileNames, hasFiles, rootClass, buttonText, displayValue, onChange, clear, focus, open } = useFileInput(props, (value) => emit("update:modelValue", value));
+		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
+		const rootAttrs = computed(() => getRootAttrs({
+			class: rootClass.value,
+			"data-disabled": toPresenceAttribute(control.disabled),
+			"data-invalid": toPresenceAttribute(control.invalid)
+		}));
+		const nativeInputAttrs = computed(() => {
+			const attrs = props.inputAttrs ?? {};
+			const { compatibilityClass, compatibilityStyle, forwardedAttributes } = splitCompatibilityAttributes(attrs);
+			return {
+				...forwardedAttributes,
+				...getPartAttrs("input", {
+					class: "rp-file-input__native",
+					compatibilityClass,
+					compatibilityStyle
+				}),
+				id: control.id,
+				name: props.name,
+				form: control.form ?? forwardedAttributes.form,
+				type: "file",
+				value: void 0,
+				accept: props.accept,
+				capture: props.capture,
+				multiple: props.multiple || void 0,
+				disabled: control.disabled || void 0,
+				required: control.required || void 0,
+				"aria-label": props.ariaLabel || void 0,
+				"aria-labelledby": control.ariaLabelledby,
+				"aria-describedby": control.ariaDescribedby,
+				"aria-invalid": control.invalid || void 0,
+				"aria-required": control.required || void 0,
+				"data-disabled": toPresenceAttribute(control.disabled),
+				"data-invalid": toPresenceAttribute(control.invalid),
+				onChange: composeEventHandlers(onChange, attrs.onChange)
+			};
+		});
+		__expose({
+			nativeElement: inputRef,
+			clear,
+			focus,
+			open
+		});
+		const n9 = t1();
+		const n0 = child(n9);
+		const n4 = next(n0, 1);
+		const n8 = next(n4, 2);
+		setStaticTemplateRef(n0, inputRef, null, "inputRef");
+		renderEffect(() => {
+			setDynamicProps(n9, [rootAttrs.value]);
+			setDynamicProps(n0, [nativeInputAttrs.value]);
+			setDynamicProps(n4, [unref(getPartAttrs)("trigger", { class: "rp-file-input__trigger" }), { "aria-hidden": "true" }]);
+		});
+		setInsertionState(n4, null, 0);
+		createSlot("trigger", {
+			files: () => unref(files),
+			multiple: () => __props.multiple
+		}, () => {
+			const n3 = t0();
+			renderEffect(() => setText(n3, toDisplayString(unref(buttonText))));
+			return n3;
+		}, 1);
+		renderEffect(() => setDynamicProps(n8, [unref(getPartAttrs)("value", { class: ["rp-file-input__value", { "rp-file-input__value--placeholder": !unref(hasFiles) }] }), { "aria-hidden": "true" }]));
+		setInsertionState(n8, null, 0);
+		createSlot("value", {
+			files: () => unref(files),
+			fileNames: () => unref(fileNames),
+			hasFiles: () => unref(hasFiles)
+		}, () => {
+			const n7 = t0();
+			renderEffect(() => setText(n7, toDisplayString(unref(displayValue))));
+			return n7;
+		}, 1);
+		return n9;
+	}
+}), [["__scopeId", "data-v-c2dff394"]]);
+//#endregion
+//#region src/components/file-input/types.ts
+var fileInputParts = [
+	"root",
+	"input",
+	"trigger",
+	"value"
+];
+//#endregion
+export { file_input_default as n, fileInputParts as t };

package/dist/hover-card.css

@@ -0,0 +1,80 @@
+@layer ropav.components {
+.rp-hover-card[data-v-55e74041] {
+    position: relative;
+    display: inline-flex;
+    font-family: var(--rp-font-family);
+    vertical-align: middle;
+}
+.rp-hover-card__content[data-v-55e74041] {
+    --_rp-hover-card-main-axis-offset: var(--rp-spacing-2);
+    --_rp-hover-card-cross-axis-offset: 0px;
+    --_rp-hover-card-radius: var(--rp-radius-sm);
+    --_rp-hover-card-arrow-size: 0.5rem;
+    position: absolute;
+    z-index: 100;
+    box-sizing: border-box;
+    width: max-content;
+    max-width: min(22rem, 100vw - var(--rp-spacing-6));
+    padding: var(--rp-spacing-4);
+    color: var(--rp-color-text);
+    font-family: var(--rp-font-family);
+    font-size: var(--rp-font-size-md);
+    line-height: var(--rp-line-height-md);
+    overflow-wrap: anywhere;
+    background-color: var(--rp-color-default);
+    border: var(--rp-border-width-thin) solid var(--rp-color-default-border);
+    border-radius: var(--_rp-hover-card-radius);
+    box-shadow: var(--rp-shadow-base);
+}
+.rp-hover-card--target[data-v-55e74041] {
+    display: contents;
+}
+.rp-hover-card__arrow[data-v-55e74041] {
+    background-color: inherit;
+    border: inherit;
+    rotate: 45deg;
+}
+.rp-hover-card__arrow[data-side=top][data-v-55e74041] {
+    border-top-color: transparent;
+    border-left-color: transparent;
+}
+.rp-hover-card__arrow[data-side=right][data-v-55e74041] {
+    border-top-color: transparent;
+    border-right-color: transparent;
+}
+.rp-hover-card__arrow[data-side=bottom][data-v-55e74041] {
+    border-right-color: transparent;
+    border-bottom-color: transparent;
+}
+.rp-hover-card__arrow[data-side=left][data-v-55e74041] {
+    border-bottom-color: transparent;
+    border-left-color: transparent;
+}
+.rp-hover-card__arrow[data-v-55e74041] {
+    position: absolute;
+    box-sizing: border-box;
+    width: var(--_rp-hover-card-arrow-size);
+    height: var(--_rp-hover-card-arrow-size);
+    pointer-events: none;
+}
+.rp-hover-card__arrow[data-side=top][data-v-55e74041] {
+    bottom: calc(-1 * var(--_rp-hover-card-arrow-size) / 2);
+}
+.rp-hover-card__arrow[data-side=right][data-v-55e74041] {
+    left: calc(-1 * var(--_rp-hover-card-arrow-size) / 2);
+}
+.rp-hover-card__arrow[data-side=bottom][data-v-55e74041] {
+    top: calc(-1 * var(--_rp-hover-card-arrow-size) / 2);
+}
+.rp-hover-card__arrow[data-side=left][data-v-55e74041] {
+    right: calc(-1 * var(--_rp-hover-card-arrow-size) / 2);
+}
+.rp-hover-card-content-enter-active[data-v-55e74041],
+  .rp-hover-card-content-leave-active[data-v-55e74041] {
+    transition: opacity var(--rp-transition-fast);
+}
+.rp-hover-card-content-enter-from[data-v-55e74041],
+  .rp-hover-card-content-leave-to[data-v-55e74041] {
+    opacity: 0;
+}
+}

package/dist/hover-card.js

@@ -0,0 +1,402 @@
+import './hover-card.css';
+import { t as useStylesApi } from "./styles-api.js";
+import { n as toPresenceAttribute } from "./attributes.js";
+import { t as bem } from "./bem.js";
+import { t as isElement } from "./query.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { n as observeComposedAncestry, t as getComposedAncestry } from "./ancestry.js";
+import { n as useOverlayZIndex, r as useOverlayLayer } from "./useOverlayZIndex.js";
+import { t as getFloatingOffsetStyle } from "./floatingOffset.js";
+import { t as useFloatingPosition } from "./useFloatingPosition.js";
+import { t as useFloatingTargetLifecycle } from "./useFloatingTargetLifecycle.js";
+import { n as useTeleportTarget } from "./useTeleportTarget.js";
+import { t as getElementDirection } from "./direction.js";
+import { n as useHoverDisclosureWithExternalDismissal } from "./useHoverDisclosure.js";
+import { VaporTeleport, VaporTransition, applyVShow, computed, createComponent, createIf, createSlot, createTemplateRefSetter, defineVaporComponent, extend, onBeforeUnmount, readonly, ref, renderEffect, setAttr, setDynamicProps, setInsertionState, setStyle, setTemplateRefBinding, template, toValue, unref, useId, useSlots, watch } from "vue";
+//#region src/internal/composables/useElementDirection.ts
+var directionAttributeFilter = [
+	"class",
+	"dir",
+	"style"
+];
+function getMutationObserverConstructor(element) {
+	return element.ownerDocument.defaultView?.MutationObserver ?? globalThis.MutationObserver;
+}
+function observeDirectionAttributes(element, onChange) {
+	const observers = /* @__PURE__ */ new Map();
+	const ancestry = [element, ...getComposedAncestry(element)];
+	for (const node of ancestry) {
+		if (!isElement(node)) continue;
+		const MutationObserverConstructor = getMutationObserverConstructor(node);
+		if (!MutationObserverConstructor) continue;
+		let observer = observers.get(MutationObserverConstructor);
+		if (!observer) {
+			observer = new MutationObserverConstructor(onChange);
+			observers.set(MutationObserverConstructor, observer);
+		}
+		observer.observe(node, {
+			attributes: true,
+			attributeFilter: directionAttributeFilter
+		});
+	}
+	return () => {
+		for (const observer of observers.values()) observer.disconnect();
+	};
+}
+function useElementDirection(elementSource) {
+	const direction = ref("ltr");
+	let disconnectElement;
+	function readDirection(element) {
+		direction.value = element ? getElementDirection(element) : "ltr";
+	}
+	function connectElement(element) {
+		disconnectElement?.();
+		disconnectElement = void 0;
+		readDirection(element);
+		if (!element) return;
+		const target = element;
+		let disconnectAttributes;
+		function reconnectAttributes() {
+			disconnectAttributes?.();
+			disconnectAttributes = observeDirectionAttributes(target, () => readDirection(target));
+			readDirection(target);
+		}
+		reconnectAttributes();
+		const disconnectAncestry = observeComposedAncestry(() => [target], reconnectAttributes, {
+			deferWhileDisconnected: true,
+			notifyOnDisconnect: true
+		});
+		disconnectElement = () => {
+			disconnectAttributes?.();
+			disconnectAncestry();
+		};
+	}
+	const stopSourceWatch = watch(() => toValue(elementSource), connectElement, {
+		immediate: true,
+		flush: "post"
+	});
+	onBeforeUnmount(() => {
+		stopSourceWatch();
+		disconnectElement?.();
+	});
+	return readonly(direction);
+}
+//#endregion
+//#region src/components/hover-card/useHoverCardDisclosure.ts
+function useHoverCardDisclosure(options, layerOptions) {
+	const { disclosure, dismissalHandlers } = useHoverDisclosureWithExternalDismissal(options);
+	const layer = useOverlayLayer({
+		active: disclosure.isOpen,
+		baseZIndex: layerOptions.baseZIndex,
+		element: layerOptions.element
+	});
+	onBeforeUnmount(layer.connectInteraction({
+		inside: layerOptions.inside,
+		escapeKeyDown: dismissalHandlers.escapeKeyDown,
+		pointerDownOutside: dismissalHandlers.pointerDownOutside
+	}));
+	return {
+		...disclosure,
+		zIndex: layer.zIndex
+	};
+}
+//#endregion
+//#region src/components/hover-card/useHoverCard.ts
+var DEFAULT_PLACEMENT = "bottom-start";
+var HOVER_CARD_OFFSET_PROPERTIES = {
+	mainAxis: "--_rp-hover-card-main-axis-offset",
+	crossAxis: "--_rp-hover-card-cross-axis-offset"
+};
+function useHoverCard(props, onOpenChange) {
+	const slots = useSlots();
+	const generatedId = useId();
+	const rootRef = ref(null);
+	const contentRef = ref(null);
+	const arrowRef = ref(null);
+	const hoverCardId = computed(() => props.id ?? `${generatedId}-hover-card`);
+	const placement = computed(() => props.placement ?? DEFAULT_PLACEMENT);
+	const teleportTo = useTeleportTarget(() => props.teleportTo);
+	const { isExplicitTarget, reference, targetElement } = useFloatingTargetLifecycle({
+		target: () => props.target,
+		fallback: rootRef
+	});
+	const contentDirection = useElementDirection(computed(() => {
+		const currentReference = reference.value;
+		if (isElement(currentReference)) return currentReference;
+		return isElement(currentReference?.contextElement) ? currentReference.contextElement : rootRef.value;
+	}));
+	const hasContent = computed(() => Boolean(slots.content || isExplicitTarget.value && slots.default));
+	const disclosureDisabled = computed(() => Boolean(props.disabled || !hasContent.value));
+	const baseZIndex = useOverlayZIndex({
+		baseZIndex: () => props.baseZIndex,
+		defaultBaseZIndex: 100,
+		aboveParent: false
+	});
+	const disclosure = useHoverCardDisclosure({
+		open: () => props.open,
+		defaultOpen: props.defaultOpen,
+		openDelay: () => props.openDelay,
+		closeDelay: () => props.closeDelay,
+		disabled: disclosureDisabled,
+		openOnFocus: () => props.openOnFocus,
+		closeOnEscape: () => props.closeOnEscape,
+		touchBehavior: () => props.touchBehavior,
+		interactionTarget: reference,
+		contentTarget: contentRef,
+		onOpenChange
+	}, {
+		baseZIndex,
+		element: contentRef,
+		inside: () => [rootRef.value, targetElement.value]
+	});
+	const isVisible = disclosure.isOpen;
+	const shouldRenderContent = computed(() => !disclosure.isDisabled.value && (Boolean(props.keepMounted) || disclosure.isOpen.value));
+	const shouldShowContent = computed(() => !props.keepMounted || disclosure.isOpen.value);
+	const floating = useFloatingPosition({
+		reference,
+		floating: contentRef,
+		arrow: arrowRef,
+		open: isVisible,
+		placement,
+		strategy: () => props.strategy ?? "absolute",
+		offset: () => props.offset,
+		flip: () => props.flip !== false,
+		flipOptions: () => props.flipOptions,
+		shift: () => props.shift !== false,
+		collisionPadding: () => props.collisionPadding ?? 8,
+		autoUpdateOptions: () => props.autoUpdateOptions,
+		restartKey: contentDirection
+	});
+	const placementSide = computed(() => floating.actualPlacement.value.split("-")[0]);
+	const rootClass = computed(() => bem("rp-hover-card", {
+		[`placement-${floating.actualPlacement.value}`]: true,
+		target: isExplicitTarget.value,
+		open: isVisible.value,
+		disabled: disclosure.isDisabled.value,
+		arrow: props.arrow
+	}));
+	const contentStyle = computed(() => ({
+		...floating.floatingStyle.value,
+		...getFloatingOffsetStyle(props.offset, HOVER_CARD_OFFSET_PROPERTIES),
+		zIndex: disclosure.zIndex.value
+	}));
+	const contentSlotProps = computed(() => ({
+		isOpen: isVisible.value,
+		open: disclosure.open,
+		close: disclosure.close,
+		toggle: disclosure.toggle
+	}));
+	return {
+		rootRef,
+		contentRef,
+		arrowRef,
+		hoverCardId,
+		isDisabled: disclosure.isDisabled,
+		isVisible,
+		isTargetMode: isExplicitTarget,
+		state: disclosure.state,
+		shouldRenderContent,
+		shouldShowContent,
+		rootClass,
+		contentStyle,
+		contentDirection,
+		contentSlotProps,
+		actualPlacement: floating.actualPlacement,
+		placementSide,
+		arrowStyle: floating.arrowStyle,
+		teleportTo
+	};
+}
+//#endregion
+//#region src/components/hover-card/hover-card.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span data-v-55e74041 class=rp-hover-card__arrow aria-hidden=true>");
+var t1 = template("<div data-v-55e74041>");
+var t2 = template("<span data-v-55e74041>", 1);
+//#endregion
+//#region src/components/hover-card/hover-card.vue
+var hover_card_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpHoverCard",
+	inheritAttrs: false,
+	__name: "hover-card",
+	props: {
+		id: {},
+		baseZIndex: {},
+		open: {
+			type: Boolean,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			default: false
+		},
+		openDelay: { default: 700 },
+		closeDelay: { default: 300 },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		openOnFocus: {
+			type: Boolean,
+			default: true
+		},
+		closeOnEscape: {
+			type: Boolean,
+			default: true
+		},
+		touchBehavior: { default: "none" },
+		keepMounted: {
+			type: Boolean,
+			default: false
+		},
+		target: {},
+		placement: { default: "bottom-start" },
+		strategy: { default: "absolute" },
+		offset: {},
+		flip: {
+			type: Boolean,
+			default: true
+		},
+		flipOptions: {},
+		shift: {
+			type: Boolean,
+			default: true
+		},
+		collisionPadding: { default: 8 },
+		autoUpdateOptions: {},
+		arrow: {
+			type: Boolean,
+			default: false
+		},
+		teleport: {
+			type: Boolean,
+			default: true
+		},
+		teleportTo: {},
+		classNames: {},
+		styles: {}
+	},
+	emits: ["update:open", "openChange"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { rootRef, contentRef, arrowRef, hoverCardId, isDisabled, isTargetMode, state, shouldRenderContent, shouldShowContent, rootClass, contentStyle, contentDirection, contentSlotProps, actualPlacement, placementSide, arrowStyle, teleportTo } = useHoverCard(props, (open, details) => {
+			emit("update:open", open);
+			emit("openChange", open, details);
+		});
+		const templateRefs = {
+			root: rootRef,
+			content: contentRef,
+			arrow: arrowRef
+		};
+		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
+		const rootAttrs = computed(() => getRootAttrs({
+			class: rootClass.value,
+			"data-state": state.value,
+			"data-disabled": toPresenceAttribute(isDisabled.value)
+		}));
+		const publicTriggerProps = computed(() => {
+			const partAttrs = getPartAttrs("trigger");
+			return {
+				...props.classNames?.trigger !== void 0 ? { class: partAttrs.class } : {},
+				...props.styles?.trigger !== void 0 ? { style: partAttrs.style } : {},
+				"data-state": state.value,
+				"data-disabled": toPresenceAttribute(isDisabled.value)
+			};
+		});
+		const contentAttrs = computed(() => ({
+			...getPartAttrs("content", {
+				class: "rp-hover-card__content",
+				style: contentStyle.value
+			}),
+			"data-state": state.value,
+			"data-placement": actualPlacement.value
+		}));
+		const _setTemplateRef = createTemplateRefSetter();
+		const n16 = t2();
+		renderEffect(() => setDynamicProps(n16, [rootAttrs.value]));
+		setInsertionState(n16, null, 0);
+		createIf(() => !unref(isTargetMode), () => {
+			return createSlot("default", {
+				triggerProps: () => publicTriggerProps.value,
+				isOpen: () => unref(contentSlotProps).isOpen,
+				open: () => unref(contentSlotProps).open,
+				close: () => unref(contentSlotProps).close,
+				toggle: () => unref(contentSlotProps).toggle
+			}, null, 1);
+		});
+		setInsertionState(n16, null, 1);
+		createComponent(VaporTeleport, {
+			to: () => unref(teleportTo),
+			disabled: () => !__props.teleport
+		}, () => {
+			return createComponent(VaporTransition, { name: "rp-hover-card-content" }, extend(() => {
+				return createIf(() => unref(shouldRenderContent), () => {
+					const n13 = t1();
+					renderEffect(() => setDynamicProps(n13, [
+						{ id: unref(hoverCardId) },
+						contentAttrs.value,
+						{
+							dir: unref(contentDirection),
+							"data-side": unref(placementSide)
+						}
+					]));
+					setInsertionState(n13, null, 0);
+					createSlot("content", {
+						isOpen: () => unref(contentSlotProps).isOpen,
+						open: () => unref(contentSlotProps).open,
+						close: () => unref(contentSlotProps).close,
+						toggle: () => unref(contentSlotProps).toggle
+					}, () => {
+						return createIf(() => unref(isTargetMode), () => {
+							return createSlot("default", {
+								triggerProps: () => publicTriggerProps.value,
+								isOpen: () => unref(contentSlotProps).isOpen,
+								open: () => unref(contentSlotProps).open,
+								close: () => unref(contentSlotProps).close,
+								toggle: () => unref(contentSlotProps).toggle
+							}, null, 1);
+						}, null, 129);
+					}, 1);
+					setInsertionState(n13, null, 1);
+					createIf(() => __props.arrow, () => {
+						const n12 = t0();
+						renderEffect(() => {
+							setAttr(n12, "data-side", unref(placementSide));
+							setStyle(n12, unref(arrowStyle));
+							_setTemplateRef(n12, templateRefs.arrow);
+						});
+						return n12;
+					});
+					applyVShow(n13, () => unref(shouldShowContent));
+					setTemplateRefBinding(n13, () => templateRefs.content, _setTemplateRef);
+					return n13;
+				}, null, 129);
+			}, { _: 8 }));
+		});
+		setTemplateRefBinding(n16, () => templateRefs.root);
+		return n16;
+	}
+}), [["__scopeId", "data-v-55e74041"]]);
+//#endregion
+//#region src/components/hover-card/types.ts
+var hoverCardPlacements = [
+	"top-start",
+	"top",
+	"top-end",
+	"right-start",
+	"right",
+	"right-end",
+	"bottom-start",
+	"bottom",
+	"bottom-end",
+	"left-start",
+	"left",
+	"left-end"
+];
+var hoverCardParts = [
+	"root",
+	"trigger",
+	"content"
+];
+//#endregion
+export { hoverCardPlacements as n, hover_card_default as r, hoverCardParts as t };