ropav 0.0.6 → 0.0.8

package/dist/tabs.js

@@ -0,0 +1,513 @@
+import './tabs.css';
+import { t as useRequiredInject } from "./useRequiredInject.js";
+import { t as bem } from "./bem.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { computed, createIf, createSlot, defineVaporComponent, onBeforeUnmount, onMounted, provide, ref, renderEffect, setDynamicProps, setInsertionState, shallowRef, template, unref, useId, watch } from "vue";
+//#region src/components/tabs/useTabs.ts
+var TABLIST_SELECTOR = ".rp-tabs-list";
+var TRIGGER_SELECTOR = ".rp-tabs-trigger";
+var DEFAULT_SIZE = "md";
+var DEFAULT_VARIANT = "line";
+var DEFAULT_ORIENTATION = "horizontal";
+var DEFAULT_PLACEMENT = "left";
+var DEFAULT_ACTIVATION_MODE = "automatic";
+var tabsKey = Symbol("tabs");
+var ORIENTATION_NAVIGATION_KEYS = {
+	horizontal: {
+		ArrowRight: 1,
+		ArrowLeft: -1
+	},
+	vertical: {
+		ArrowDown: 1,
+		ArrowUp: -1
+	}
+};
+function optionalAttr(value) {
+	return value || void 0;
+}
+function toTabsState(active) {
+	return active ? "active" : "inactive";
+}
+function getDefaultAlign(orientation) {
+	return orientation === "vertical" ? "left" : "center";
+}
+function getAriaProps(label, labelledby, describedby) {
+	return {
+		"aria-label": optionalAttr(label),
+		"aria-labelledby": optionalAttr(labelledby),
+		"aria-describedby": optionalAttr(describedby)
+	};
+}
+function getOrientationClasses(disabled, orientation) {
+	return {
+		disabled,
+		[orientation]: true
+	};
+}
+function getPlacementClasses(orientation, placement) {
+	return { [`placement-${placement}`]: orientation === "vertical" };
+}
+function getStateClasses(active) {
+	return {
+		active,
+		inactive: !active
+	};
+}
+function getTriggerClasses(active, disabled, orientation, placement, align) {
+	return {
+		...getStateClasses(active),
+		...getOrientationClasses(disabled, orientation),
+		...getPlacementClasses(orientation, placement),
+		...align ? { [`align-${align}`]: true } : {}
+	};
+}
+function findRegistration(entries, value) {
+	if (value == null) return void 0;
+	return entries.find((entry) => entry.value === value);
+}
+function upsertRegistration(entries, entry) {
+	const index = entries.findIndex((current) => current.id === entry.id);
+	if (index < 0) return [...entries, entry];
+	const nextEntries = entries.slice();
+	nextEntries[index] = entry;
+	return nextEntries;
+}
+function useTabsRegistry() {
+	const items = shallowRef([]);
+	return {
+		items,
+		register(entry) {
+			items.value = upsertRegistration(items.value, entry);
+		},
+		unregister(id) {
+			items.value = items.value.filter((item) => item.id !== id);
+		}
+	};
+}
+function useTabsRegistration(getRegistration, register, unregister, watchSource) {
+	const registeredId = ref(null);
+	function syncRegistration() {
+		const registration = getRegistration();
+		if (registeredId.value && registeredId.value !== registration.id) unregister(registeredId.value);
+		register(registration);
+		registeredId.value = registration.id;
+	}
+	onMounted(syncRegistration);
+	watch(watchSource, syncRegistration);
+	onBeforeUnmount(() => {
+		if (registeredId.value) unregister(registeredId.value);
+	});
+}
+function getTabsTrigger(event, list) {
+	const target = event.target;
+	const trigger = target instanceof Element ? target.closest(TRIGGER_SELECTOR) : void 0;
+	return trigger?.closest(TABLIST_SELECTOR) === list ? trigger : void 0;
+}
+function getTabsTriggers(list) {
+	return Array.from(list.querySelectorAll(TRIGGER_SELECTOR)).filter((trigger) => trigger.closest(TABLIST_SELECTOR) === list && !trigger.disabled);
+}
+function getNextTrigger(list, currentTrigger, key, orientation) {
+	const triggers = getTabsTriggers(list);
+	const currentIndex = triggers.indexOf(currentTrigger);
+	if (currentIndex === -1 || triggers.length === 0) return void 0;
+	if (key === "Home") return triggers[0];
+	if (key === "End") return triggers[triggers.length - 1];
+	const direction = ORIENTATION_NAVIGATION_KEYS[orientation][key];
+	if (!direction) return void 0;
+	return triggers[(currentIndex + direction + triggers.length) % triggers.length];
+}
+function useTabsItem(componentName, props, suffix) {
+	const group = useRequiredInject(tabsKey, componentName);
+	const generatedId = useId();
+	const id = computed(() => props.id ?? `${generatedId}-${suffix}`);
+	const isSelected = computed(() => group.isSelected(props.value));
+	return {
+		group,
+		id,
+		isSelected,
+		state: computed(() => toTabsState(isSelected.value))
+	};
+}
+function useTabs(props, emitUpdate) {
+	const triggerRegistry = useTabsRegistry();
+	const contentRegistry = useTabsRegistry();
+	const { items: triggers, unregister: unregisterTrigger } = triggerRegistry;
+	const { items: contents, register: registerContent, unregister: unregisterContent } = contentRegistry;
+	const isControlled = computed(() => props.modelValue !== void 0);
+	const uncontrolledValue = ref(props.defaultValue ?? null);
+	const isDisabled = computed(() => Boolean(props.disabled));
+	const size = computed(() => props.size ?? DEFAULT_SIZE);
+	const variant = computed(() => props.variant ?? DEFAULT_VARIANT);
+	const orientation = computed(() => props.orientation ?? DEFAULT_ORIENTATION);
+	const placement = computed(() => props.placement ?? DEFAULT_PLACEMENT);
+	const align = computed(() => props.align);
+	const activationMode = computed(() => props.activationMode ?? DEFAULT_ACTIVATION_MODE);
+	const selectedValue = computed(() => isControlled.value ? props.modelValue ?? null : uncontrolledValue.value);
+	const firstEnabledTrigger = computed(() => triggers.value.find((trigger) => !trigger.disabled));
+	const selectedEnabledTrigger = computed(() => {
+		const trigger = findRegistration(triggers.value, selectedValue.value);
+		return trigger && !trigger.disabled ? trigger : void 0;
+	});
+	const rootClass = computed(() => bem("rp-tabs", `size-${size.value}`, variant.value, getOrientationClasses(isDisabled.value, orientation.value), getPlacementClasses(orientation.value, placement.value)));
+	const rootProps = computed(() => ({
+		id: props.id,
+		class: rootClass.value,
+		"data-disabled": optionalAttr(isDisabled.value),
+		"data-size": size.value,
+		"data-variant": variant.value,
+		"data-orientation": orientation.value,
+		"data-placement": optionalAttr(orientation.value === "vertical" ? placement.value : void 0),
+		"data-activation-mode": activationMode.value,
+		...getAriaProps(props.ariaLabel, props.labelledby, props.describedby)
+	}));
+	const slotProps = computed(() => ({
+		value: selectedValue.value,
+		size: size.value,
+		variant: variant.value,
+		disabled: isDisabled.value,
+		placement: placement.value,
+		align: align.value ?? getDefaultAlign(orientation.value),
+		select: selectValue
+	}));
+	function syncUncontrolledValue() {
+		if (isControlled.value || isDisabled.value) return;
+		const selectedTrigger = findRegistration(triggers.value, selectedValue.value);
+		if (selectedValue.value != null && !selectedTrigger?.disabled) return;
+		uncontrolledValue.value = firstEnabledTrigger.value?.value ?? null;
+	}
+	function setValue(value) {
+		if (isDisabled.value || value === selectedValue.value) return;
+		if (!isControlled.value) uncontrolledValue.value = value;
+		emitUpdate(value);
+	}
+	function selectValue(value) {
+		const trigger = findRegistration(triggers.value, value);
+		if (isDisabled.value || trigger?.disabled) return;
+		setValue(value);
+	}
+	const getFocusableValue = () => selectedEnabledTrigger.value?.value ?? firstEnabledTrigger.value?.value ?? null;
+	const getTriggerId = (value) => findRegistration(triggers.value, value)?.id;
+	const getContentId = (value) => findRegistration(contents.value, value)?.id;
+	const getTriggerValue = (id) => triggers.value.find((trigger) => trigger.id === id)?.value;
+	function registerTrigger(registration) {
+		triggerRegistry.register(registration);
+		syncUncontrolledValue();
+	}
+	function onListKeydown(event) {
+		const list = event.currentTarget;
+		if (!list || isDisabled.value) return;
+		const trigger = getTabsTrigger(event, list);
+		if (!trigger) return;
+		const nextTrigger = getNextTrigger(list, trigger, event.key, orientation.value);
+		if (!nextTrigger) return;
+		event.preventDefault();
+		nextTrigger.focus();
+		const nextValue = getTriggerValue(nextTrigger.id);
+		if (nextValue !== void 0 && activationMode.value === "automatic") selectValue(nextValue);
+	}
+	provide(tabsKey, {
+		get selectedValue() {
+			return selectedValue.value;
+		},
+		get disabled() {
+			return isDisabled.value;
+		},
+		get size() {
+			return size.value;
+		},
+		get variant() {
+			return variant.value;
+		},
+		get orientation() {
+			return orientation.value;
+		},
+		get placement() {
+			return placement.value;
+		},
+		get align() {
+			return align.value;
+		},
+		get activationMode() {
+			return activationMode.value;
+		},
+		get unmountOnExit() {
+			return Boolean(props.unmountOnExit);
+		},
+		get ariaLabel() {
+			return props.ariaLabel;
+		},
+		get describedby() {
+			return props.describedby;
+		},
+		get labelledby() {
+			return props.labelledby;
+		},
+		isSelected(value) {
+			return selectedValue.value === value;
+		},
+		selectValue,
+		getFocusableValue,
+		getTriggerId,
+		getContentId,
+		getTriggerValue,
+		registerTrigger,
+		unregisterTrigger,
+		registerContent,
+		unregisterContent,
+		onListKeydown
+	});
+	return {
+		rootClass,
+		rootProps,
+		slotProps,
+		selectedValue,
+		selectValue
+	};
+}
+function useTabsList(props) {
+	const group = useRequiredInject(tabsKey, "RpTabsList");
+	const rootClass = computed(() => bem("rp-tabs-list", group.variant, getOrientationClasses(group.disabled, group.orientation), getPlacementClasses(group.orientation, group.placement)));
+	return {
+		rootClass,
+		rootProps: computed(() => ({
+			id: props.id,
+			class: rootClass.value,
+			role: "tablist",
+			"data-disabled": optionalAttr(group.disabled),
+			"data-variant": group.variant,
+			"data-orientation": group.orientation,
+			"data-placement": optionalAttr(group.orientation === "vertical" ? group.placement : void 0),
+			"aria-orientation": group.orientation,
+			...getAriaProps(props.ariaLabel ?? group.ariaLabel, props.ariaLabelledby ?? group.labelledby, props.ariaDescribedby ?? group.describedby),
+			onKeydown: group.onListKeydown
+		})),
+		slotProps: computed(() => ({
+			disabled: group.disabled,
+			variant: group.variant,
+			orientation: group.orientation,
+			placement: group.placement
+		}))
+	};
+}
+function useTabsTrigger(props) {
+	const { group, id, isSelected, state } = useTabsItem("RpTabsTrigger", props, "tab");
+	const isDisabled = computed(() => Boolean(group.disabled || props.disabled));
+	const isFocusable = computed(() => group.getFocusableValue() === props.value && !isDisabled.value);
+	const align = computed(() => props.align ?? group.align);
+	const effectiveAlign = computed(() => align.value ?? getDefaultAlign(group.orientation));
+	const rootClass = computed(() => bem("rp-tabs-trigger", `size-${group.size}`, group.variant, getTriggerClasses(isSelected.value, isDisabled.value, group.orientation, group.placement, align.value)));
+	const rootProps = computed(() => ({
+		id: id.value,
+		class: rootClass.value,
+		role: "tab",
+		type: "button",
+		disabled: optionalAttr(isDisabled.value),
+		tabIndex: isFocusable.value ? 0 : -1,
+		"data-state": state.value,
+		"data-disabled": optionalAttr(isDisabled.value),
+		"data-variant": group.variant,
+		"data-align": optionalAttr(align.value),
+		"aria-selected": isSelected.value,
+		"aria-controls": group.getContentId(props.value),
+		"aria-disabled": optionalAttr(isDisabled.value),
+		onClick: select,
+		onFocus,
+		onKeydown
+	}));
+	const slotProps = computed(() => ({
+		value: props.value,
+		selected: isSelected.value,
+		size: group.size,
+		variant: group.variant,
+		disabled: isDisabled.value,
+		align: effectiveAlign.value,
+		select
+	}));
+	useTabsRegistration(() => ({
+		id: id.value,
+		value: props.value,
+		disabled: isDisabled.value
+	}), group.registerTrigger, group.unregisterTrigger, () => [
+		id.value,
+		props.value,
+		isDisabled.value
+	]);
+	function select() {
+		if (!isDisabled.value) group.selectValue(props.value);
+	}
+	function onFocus() {
+		if (group.activationMode === "automatic") select();
+	}
+	function onKeydown(event) {
+		if (event.key !== "Enter" && event.key !== " ") return;
+		event.preventDefault();
+		select();
+	}
+	return {
+		id,
+		state,
+		isSelected,
+		isDisabled,
+		rootClass,
+		rootProps,
+		slotProps,
+		select
+	};
+}
+function useTabsContent(props) {
+	const { group, id, isSelected, state } = useTabsItem("RpTabsContent", props, "tabpanel");
+	const shouldUnmountOnExit = computed(() => props.unmountOnExit ?? group.unmountOnExit);
+	const shouldRenderContent = computed(() => !shouldUnmountOnExit.value || isSelected.value);
+	const rootClass = computed(() => bem("rp-tabs-content", getStateClasses(isSelected.value), { vertical: group.orientation === "vertical" }));
+	const rootProps = computed(() => ({
+		id: id.value,
+		class: rootClass.value,
+		role: "tabpanel",
+		tabIndex: 0,
+		hidden: optionalAttr(!isSelected.value),
+		"data-state": state.value,
+		...getAriaProps(props.ariaLabel, props.ariaLabelledby ?? group.getTriggerId(props.value), props.ariaDescribedby)
+	}));
+	const slotProps = computed(() => ({
+		value: props.value,
+		selected: isSelected.value
+	}));
+	useTabsRegistration(() => ({
+		id: id.value,
+		value: props.value
+	}), group.registerContent, group.unregisterContent, () => [id.value, props.value]);
+	return {
+		id,
+		state,
+		isSelected,
+		shouldRenderContent,
+		rootClass,
+		rootProps,
+		slotProps
+	};
+}
+//#endregion
+//#region src/components/tabs/tabs.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0$3 = template("<div data-v-32e41419>", 1);
+//#endregion
+//#region src/components/tabs/tabs.vue
+var tabs_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpTabs",
+	__name: "tabs",
+	props: {
+		id: {},
+		modelValue: { default: void 0 },
+		defaultValue: { default: void 0 },
+		size: { default: "md" },
+		variant: { default: "line" },
+		orientation: { default: "horizontal" },
+		placement: { default: "left" },
+		align: {},
+		activationMode: { default: "automatic" },
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		unmountOnExit: {
+			type: Boolean,
+			default: false
+		},
+		ariaLabel: {},
+		describedby: {},
+		labelledby: {}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { rootProps, slotProps } = useTabs(props, (value) => {
+			emit("update:modelValue", value);
+		});
+		const n1 = t0$3();
+		renderEffect(() => setDynamicProps(n1, [unref(rootProps)]));
+		setInsertionState(n1, null, 0);
+		createSlot("default", { $: [() => unref(slotProps)] }, null, 1);
+		return n1;
+	}
+}), [["__scopeId", "data-v-32e41419"]]);
+//#endregion
+//#region src/components/tabs/tabs-content.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0$2 = template("<section data-v-3ff419c3>", 1);
+//#endregion
+//#region src/components/tabs/tabs-content.vue
+var tabs_content_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpTabsContent",
+	__name: "tabs-content",
+	props: {
+		id: {},
+		value: {},
+		unmountOnExit: {
+			type: Boolean,
+			default: void 0
+		},
+		ariaLabel: {},
+		ariaDescribedby: {},
+		ariaLabelledby: {}
+	},
+	setup(__props) {
+		const { rootProps, slotProps, shouldRenderContent } = useTabsContent(__props);
+		return createIf(() => unref(shouldRenderContent), () => {
+			const n3 = t0$2();
+			renderEffect(() => setDynamicProps(n3, [unref(rootProps)]));
+			setInsertionState(n3, null, 0);
+			createSlot("default", { $: [() => unref(slotProps)] }, null, 1);
+			return n3;
+		});
+	}
+}), [["__scopeId", "data-v-3ff419c3"]]);
+//#endregion
+//#region src/components/tabs/tabs-list.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0$1 = template("<div data-v-7f168d05>", 1);
+//#endregion
+//#region src/components/tabs/tabs-list.vue
+var tabs_list_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpTabsList",
+	__name: "tabs-list",
+	props: {
+		id: {},
+		ariaLabel: {},
+		ariaDescribedby: {},
+		ariaLabelledby: {}
+	},
+	setup(__props) {
+		const { rootProps, slotProps } = useTabsList(__props);
+		const n1 = t0$1();
+		renderEffect(() => setDynamicProps(n1, [unref(rootProps)]));
+		setInsertionState(n1, null, 0);
+		createSlot("default", { $: [() => unref(slotProps)] }, null, 1);
+		return n1;
+	}
+}), [["__scopeId", "data-v-7f168d05"]]);
+//#endregion
+//#region src/components/tabs/tabs-trigger.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<button data-v-4adec360>", 1);
+//#endregion
+//#region src/components/tabs/tabs-trigger.vue
+var tabs_trigger_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpTabsTrigger",
+	__name: "tabs-trigger",
+	props: {
+		id: {},
+		value: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		align: {}
+	},
+	setup(__props) {
+		const { rootProps, slotProps } = useTabsTrigger(__props);
+		const n1 = t0();
+		renderEffect(() => setDynamicProps(n1, [unref(rootProps)]));
+		setInsertionState(n1, null, 0);
+		createSlot("default", { $: [() => unref(slotProps)] }, null, 1);
+		return n1;
+	}
+}), [["__scopeId", "data-v-4adec360"]]);
+//#endregion
+export { useTabs as a, useTabsTrigger as c, tabs_default as i, tabs_list_default as n, useTabsContent as o, tabs_content_default as r, useTabsList as s, tabs_trigger_default as t };

package/dist/textarea.js

@@ -1,5 +1,6 @@
 import './textarea.css';
-import { n as bem, t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
+import { t as bem } from "./bem.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
 import { t as useControlState } from "./useControlState.js";
 import { child, computed, createInvoker, createTemplateRefSetter, defineVaporComponent, delegateEvents, nextTick, onMounted, ref, renderEffect, setAttr, setClass, setProp, setValue, template, unref, watch } from "vue";
 //#region src/components/textarea/useTextarea.ts
@@ -206,5 +207,3 @@ var textarea_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PUR
 }), [["__scopeId", "data-v-6c62dc31"]]);
 //#endregion
 export { textarea_default as t };
-
-//# sourceMappingURL=textarea.js.map

package/dist/tooltip.js

@@ -1,6 +1,7 @@
 import './tooltip.css';
+import { t as bem } from "./bem.js";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
 import { n as getComponentCustomColor, r as isComponentPresetColor } from "./componentColors.js";
-import { n as bem, t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper.js";
 import { VaporTransition, applyVShow, computed, createComponent, createIf, createInvoker, createSlot, defineVaporComponent, delegateEvents, extend, isRef, on, onBeforeUnmount, onMounted, ref, renderEffect, setAttr, setClass, setInsertionState, setProp, setStyle, setText, template, toDisplayString, unref, useId, useSlots, watch } from "vue";
 //#region src/composables/useDelayedOpen.ts
 function readOption(value, fallback) {
@@ -380,5 +381,3 @@ var tooltip_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE
 }), [["__scopeId", "data-v-13c39164"]]);
 //#endregion
 export { useDelayedOpen as n, tooltip_default as t };
-
-//# sourceMappingURL=tooltip.js.map

package/dist/useButtonColor.js

@@ -29,5 +29,3 @@ function getButtonColorStyle(color) {
 }
 //#endregion
 export { loader_circle_default as n, getButtonColorStyle as t };
-
-//# sourceMappingURL=useButtonColor.js.map

package/dist/useClickOutside.js

@@ -0,0 +1,24 @@
+import { onBeforeUnmount, onMounted, watch } from "vue";
+//#region src/composables/useClickOutside.ts
+function useClickOutside(target, active, callback) {
+	let isListening = false;
+	let stopWatch;
+	function handler(e) {
+		if (target.value && !target.value.contains(e.target)) callback();
+	}
+	function setListening(value) {
+		if (typeof document === "undefined" || value === isListening) return;
+		isListening = value;
+		if (value) document.addEventListener("click", handler, true);
+		else document.removeEventListener("click", handler, true);
+	}
+	onMounted(() => {
+		stopWatch = watch(active, setListening, { immediate: true });
+	});
+	onBeforeUnmount(() => {
+		stopWatch?.();
+		setListening(false);
+	});
+}
+//#endregion
+export { useClickOutside as t };

package/dist/useCollapse.js

@@ -0,0 +1,92 @@
+import { t as bem } from "./bem.js";
+import { computed, ref, toValue, useId } from "vue";
+//#region src/components/collapse/useCollapse.ts
+var DEFAULT_ROLE = "region";
+function optionValue(value) {
+	return toValue(value);
+}
+function useCollapse(options = {}, emitOpenChange) {
+	const generatedId = useId();
+	const uncontrolledOpen = ref(false);
+	const id = computed(() => optionValue(options.id) ?? `${generatedId}-collapse`);
+	const controlledOpen = computed(() => optionValue(options.open));
+	const isDisabled = computed(() => Boolean(optionValue(options.disabled)));
+	const isOpen = computed(() => Boolean(controlledOpen.value ?? uncontrolledOpen.value));
+	const state = computed(() => isOpen.value ? "open" : "closed");
+	const shouldRenderContent = computed(() => !optionValue(options.unmountOnExit) || isOpen.value);
+	const rootClass = computed(() => bem("rp-collapse", {
+		open: isOpen.value,
+		closed: !isOpen.value,
+		disabled: isDisabled.value
+	}));
+	const rootProps = computed(() => ({
+		class: rootClass.value,
+		"data-state": state.value,
+		"data-disabled": isDisabled.value || void 0
+	}));
+	const contentSlotProps = computed(() => ({
+		isOpen: isOpen.value,
+		open,
+		close,
+		toggle
+	}));
+	const triggerProps = computed(() => ({
+		type: "button",
+		disabled: isDisabled.value || void 0,
+		"aria-controls": id.value,
+		"aria-expanded": isOpen.value,
+		"aria-disabled": isDisabled.value || void 0,
+		onClick: onTriggerClick
+	}));
+	const contentProps = computed(() => ({
+		class: "rp-collapse__content",
+		id: id.value,
+		role: optionValue(options.role) ?? DEFAULT_ROLE,
+		"data-state": state.value,
+		"aria-hidden": isOpen.value ? void 0 : "true",
+		"aria-label": optionValue(options.ariaLabel) || void 0,
+		"aria-labelledby": optionValue(options.ariaLabelledby) || void 0,
+		"aria-describedby": optionValue(options.ariaDescribedby) || void 0
+	}));
+	const triggerSlotProps = computed(() => ({
+		triggerProps: triggerProps.value,
+		...contentSlotProps.value
+	}));
+	function setOpen(nextOpen) {
+		if (isDisabled.value || nextOpen === isOpen.value) return;
+		if (controlledOpen.value === void 0) uncontrolledOpen.value = nextOpen;
+		options.onOpenChange?.(nextOpen);
+		emitOpenChange?.(nextOpen);
+	}
+	function open() {
+		setOpen(true);
+	}
+	function close() {
+		setOpen(false);
+	}
+	function toggle() {
+		setOpen(!isOpen.value);
+	}
+	function onTriggerClick() {
+		toggle();
+	}
+	return {
+		id,
+		state,
+		isDisabled,
+		isOpen,
+		shouldRenderContent,
+		rootClass,
+		rootProps,
+		triggerProps,
+		contentProps,
+		triggerSlotProps,
+		contentSlotProps,
+		setOpen,
+		open,
+		close,
+		toggle
+	};
+}
+//#endregion
+export { useCollapse as t };

package/dist/useControlState.js

@@ -38,5 +38,3 @@ function useControlState(options = {}) {
 }
 //#endregion
 export { useControlState as t };
-
-//# sourceMappingURL=useControlState.js.map

package/dist/useRequiredInject.js

@@ -0,0 +1,9 @@
+import { inject } from "vue";
+//#region src/composables/useRequiredInject.ts
+function useRequiredInject(key, componentName) {
+	const value = inject(key);
+	if (value == null) throw new Error(`[Ropav] <${componentName}> must be used inside its parent provider component.`);
+	return value;
+}
+//#endregion
+export { useRequiredInject as t };

package/dist/x.js

@@ -0,0 +1,12 @@
+import { defineVaporComponent, markRaw, template } from "vue";
+//#region ~icons/lucide/x
+var t0 = template("<svg viewBox=\"0 0 24 24\"width=1.2em height=1.2em><path fill=none stroke=currentColor stroke-linecap=round stroke-linejoin=round stroke-width=2 d=\"M18 6L6 18M6 6l12 12\">", 3, 1);
+function render(_ctx) {
+	return t0();
+}
+var x_default = markRaw(defineVaporComponent({
+	name: "lucide-x",
+	render
+}));
+//#endregion
+export { x_default as t };