@youcan/celeste 0.6.102 → 0.7.0

package/dist/components/text-input/text-input.d.ts

@@ -4,33 +4,37 @@ export interface TextInputProps extends /* @vue-ignore */ InputHTMLAttributes {
     size?: 'xs' | 'sm' | 'md';
     hasError?: boolean;
 }
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<TextInputProps & {
+type __VLS_Props = TextInputProps;
+type __VLS_ModelProps = {
     modelValue?: string | number;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_7: {}, __VLS_15: {}, __VLS_23: {}, __VLS_31: {}, __VLS_39: {}, __VLS_55: {};
+type __VLS_Slots = {} & {
+    leadingIcon?: (props: typeof __VLS_7) => any;
+} & {
+    leadingNode?: (props: typeof __VLS_15) => any;
+} & {
+    leadingInlineNode?: (props: typeof __VLS_23) => any;
+} & {
+    trailingIcon?: (props: typeof __VLS_31) => any;
+} & {
+    trailingNode?: (props: typeof __VLS_39) => any;
+} & {
+    trailingInlineNode?: (props: typeof __VLS_55) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string | number | undefined) => any;
-}, string, import('vue').PublicProps, Readonly<TextInputProps & {
-    modelValue?: string | number;
-}> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string | number | undefined) => any) | undefined;
 }>, {
     size: "xs" | "sm" | "md";
     type: "text" | "email" | "password" | "search" | "tel" | "url";
     hasError: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    leadingIcon?: (props: {}) => any;
-} & {
-    leadingNode?: (props: {}) => any;
-} & {
-    leadingInlineNode?: (props: {}) => any;
-} & {
-    trailingIcon?: (props: {}) => any;
-} & {
-    trailingNode?: (props: {}) => any;
-} & {
-    trailingInlineNode?: (props: {}) => any;
-}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/textarea/textarea.d.ts

@@ -1,23 +1,24 @@
 import { TextareaHTMLAttributes } from 'vue';
 export interface TextAreaProps {
     class?: TextareaHTMLAttributes['class'];
-    placeholder: string;
+    placeholder?: string;
     showCount?: boolean;
     disabled?: boolean;
     maxLength?: TextareaHTMLAttributes['maxlength'];
 }
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: import('vue').DefineComponent<TextAreaProps & {
+type __VLS_Props = TextAreaProps;
+type __VLS_ModelProps = {
     modelValue?: string;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string | undefined) => any;
-}, string, import('vue').PublicProps, Readonly<TextAreaProps & {
-    modelValue?: string;
-}> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
 }>, {
     disabled: boolean;
     placeholder: string;
     showCount: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/tooltip/tooltip-content.d.ts

@@ -1,5 +1,5 @@
+import { TooltipContentProps as PrimitiveProps } from 'reka-ui';
 import { HTMLAttributes } from 'vue';
-import { TooltipContentProps as PrimitiveProps } from 'radix-vue';
 export interface TooltipContentProps extends PrimitiveProps {
     class?: HTMLAttributes['class'];
     size?: 'xs' | 'sm' | 'md';
@@ -10,9 +10,11 @@ export interface TooltipContentProps extends PrimitiveProps {
     dismissible?: boolean;
     onDismiss?: () => void;
 }
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<TooltipContentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TooltipContentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;
     pointerDownOutside: (event: Event) => any;
 }, string, import('vue').PublicProps, Readonly<TooltipContentProps> & Readonly<{
@@ -22,9 +24,10 @@ declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<Toolti
     size: "xs" | "sm" | "md";
     variant: "light" | "dark";
     sideOffset: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
-}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/tooltip/tooltip-provider.d.ts

@@ -1,13 +1,16 @@
-import { TooltipProviderProps as PrimitiveProps } from 'radix-vue';
+import { TooltipProviderProps as PrimitiveProps } from 'reka-ui';
 export interface TooltipProviderProps extends PrimitiveProps {
 }
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {
+    delayDuration: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<TooltipProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {
-    delayDuration: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
-}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/tooltip/tooltip-root.d.ts

@@ -1,15 +1,18 @@
-import { TooltipRootProps as PrimitiveProps } from 'radix-vue';
+import { TooltipRootProps as PrimitiveProps } from 'reka-ui';
 export interface TooltipRootProps extends PrimitiveProps {
 }
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<TooltipRootProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TooltipRootProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
 }, string, import('vue').PublicProps, Readonly<TooltipRootProps> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
-}>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/tooltip/tooltip-trigger.d.ts

@@ -1,11 +1,14 @@
-import { TooltipTriggerProps as PrimitiveProps } from 'radix-vue';
+import { TooltipTriggerProps as PrimitiveProps } from 'reka-ui';
 export interface TooltipTriggerProps extends PrimitiveProps {
 }
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
-}>;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/tooltip/tooltip.d.ts

@@ -1,4 +1,4 @@
-import { TooltipContentProps, TooltipRootProps } from 'radix-vue';
+import { TooltipContentProps, TooltipRootProps } from 'reka-ui';
 import { HTMLAttributes } from 'vue';
 export interface TooltipProps extends TooltipRootProps, TooltipContentProps {
     class?: HTMLAttributes['class'];
@@ -9,9 +9,11 @@ export interface TooltipProps extends TooltipRootProps, TooltipContentProps {
     description?: string;
     dismissible?: boolean;
 }
-declare const _default: typeof __VLS_export;
-export default _default;
-declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<TooltipProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare var __VLS_22: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<TooltipProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
 }, string, import('vue').PublicProps, Readonly<TooltipProps> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
@@ -20,9 +22,10 @@ declare const __VLS_export: __VLS_WithSlots<import('vue').DefineComponent<Toolti
     variant: "light" | "dark";
     sideOffset: number;
     delayDuration: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
-}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/es/chunks/BubbleSelect.js

@@ -0,0 +1,290 @@
+import { t as isEqual } from "./ohash.D__AXeF1.js";
+import { t as createContext } from "./createContext.js";
+import { t as isNullish } from "./nullish.js";
+import { s as useVModel } from "./dist.js";
+import { t as useDirection } from "./useDirection.js";
+import { t as useFormControl } from "./useFormControl.js";
+import { t as useCollection } from "./Collection.js";
+import { t as VisuallyHidden_default } from "./VisuallyHidden.js";
+import { t as PopperRoot_default } from "./PopperRoot.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeProps, openBlock, ref, renderList, renderSlot, toRefs, unref, watch, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Select/utils.js
+var OPEN_KEYS = [
+	" ",
+	"Enter",
+	"ArrowUp",
+	"ArrowDown"
+];
+var SELECTION_KEYS = [" ", "Enter"];
+function valueComparator(value, currentValue, comparator) {
+	if (value === void 0) return false;
+	else if (Array.isArray(value)) return value.some((val) => compare(val, currentValue, comparator));
+	else return compare(value, currentValue, comparator);
+}
+function compare(value, currentValue, comparator) {
+	if (value === void 0 || currentValue === void 0) return false;
+	if (typeof value === "string") return value === currentValue;
+	if (typeof comparator === "function") return comparator(value, currentValue);
+	if (typeof comparator === "string") return value?.[comparator] === currentValue?.[comparator];
+	return isEqual(value, currentValue);
+}
+function shouldShowPlaceholder(value) {
+	return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Select/SelectRoot.js
+var _hoisted_1 = ["value"];
+var [injectSelectRootContext, provideSelectRootContext] = /* @__PURE__ */ createContext("SelectRoot");
+var SelectRoot_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "SelectRoot",
+	props: {
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false
+		},
+		defaultValue: {
+			type: null,
+			required: false
+		},
+		modelValue: {
+			type: null,
+			required: false,
+			default: void 0
+		},
+		nullableValue: {
+			type: String,
+			required: false,
+			default: ""
+		},
+		by: {
+			type: [String, Function],
+			required: false
+		},
+		dir: {
+			type: String,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false
+		},
+		autocomplete: {
+			type: String,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		}
+	},
+	emits: ["update:modelValue", "update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const { required, disabled, multiple, dir: propDir } = toRefs(props);
+		const modelValue = useVModel(props, "modelValue", emits, {
+			defaultValue: props.defaultValue ?? (multiple.value ? [] : void 0),
+			passive: props.modelValue === void 0,
+			deep: true
+		});
+		const open = useVModel(props, "open", emits, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		const triggerElement = ref();
+		const valueElement = ref();
+		const triggerPointerDownPosRef = ref({
+			x: 0,
+			y: 0
+		});
+		const isEmptyModelValue = computed(() => {
+			if (multiple.value && Array.isArray(modelValue.value)) return modelValue.value?.length === 0;
+			else return isNullish(modelValue.value);
+		});
+		useCollection({ isProvider: true });
+		const dir = useDirection(propDir);
+		const isFormControl = useFormControl(triggerElement);
+		const optionsSet = ref(/* @__PURE__ */ new Set());
+		const nativeSelectKey = computed(() => {
+			return Array.from(optionsSet.value).map((option) => option.value).join(";");
+		});
+		function handleValueChange(value) {
+			if (multiple.value) {
+				const array = Array.isArray(modelValue.value) ? [...modelValue.value] : [];
+				const index = array.findIndex((i) => compare(i, value, props.by));
+				index === -1 ? array.push(value) : array.splice(index, 1);
+				modelValue.value = [...array];
+			} else modelValue.value = value;
+		}
+		function getOption(value) {
+			return Array.from(optionsSet.value).find((option) => valueComparator(value, option.value, props.by));
+		}
+		provideSelectRootContext({
+			triggerElement,
+			onTriggerChange: (node) => {
+				triggerElement.value = node;
+			},
+			valueElement,
+			onValueElementChange: (node) => {
+				valueElement.value = node;
+			},
+			contentId: "",
+			modelValue,
+			onValueChange: handleValueChange,
+			by: props.by,
+			open,
+			multiple,
+			required,
+			onOpenChange: (value) => {
+				open.value = value;
+			},
+			dir,
+			triggerPointerDownPosRef,
+			disabled,
+			isEmptyModelValue,
+			optionsSet,
+			onOptionAdd: (option) => {
+				const existingOption = getOption(option.value);
+				if (existingOption) optionsSet.value.delete(existingOption);
+				optionsSet.value.add(option);
+			},
+			onOptionRemove: (option) => {
+				const existingOption = getOption(option.value);
+				if (existingOption) optionsSet.value.delete(existingOption);
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(PopperRoot_default), null, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", {
+					modelValue: unref(modelValue),
+					open: unref(open)
+				}), unref(isFormControl) && _ctx.name ? (openBlock(), createBlock(BubbleSelect_default, {
+					key: nativeSelectKey.value,
+					"aria-hidden": "true",
+					tabindex: "-1",
+					multiple: unref(multiple),
+					required: unref(required),
+					name: _ctx.name,
+					autocomplete: _ctx.autocomplete,
+					disabled: unref(disabled),
+					value: unref(modelValue)
+				}, {
+					default: withCtx(() => [unref(isNullish)(unref(modelValue)) ? (openBlock(), createElementBlock("option", {
+						key: 0,
+						value: _ctx.nullableValue
+					}, null, 8, _hoisted_1)) : createCommentVNode("v-if", true), (openBlock(true), createElementBlock(Fragment, null, renderList(Array.from(optionsSet.value), (option) => {
+						return openBlock(), createElementBlock("option", mergeProps({ key: option.value ?? "" }, { ref_for: true }, option), null, 16);
+					}), 128))]),
+					_: 1
+				}, 8, [
+					"multiple",
+					"required",
+					"name",
+					"autocomplete",
+					"disabled",
+					"value"
+				])) : createCommentVNode("v-if", true)]),
+				_: 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/BubbleSelect.js
+var BubbleSelect_default = /* @__PURE__ */ defineComponent({
+	__name: "BubbleSelect",
+	props: {
+		autocomplete: {
+			type: String,
+			required: false
+		},
+		autofocus: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		form: {
+			type: String,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		size: {
+			type: Number,
+			required: false
+		},
+		value: {
+			type: null,
+			required: false
+		}
+	},
+	setup(__props) {
+		const props = __props;
+		const selectElement = ref();
+		const rootContext = injectSelectRootContext();
+		watch(() => props.value, (cur, prev) => {
+			const selectProto = window.HTMLSelectElement.prototype;
+			const setValue = Object.getOwnPropertyDescriptor(selectProto, "value").set;
+			if (cur !== prev && setValue && selectElement.value) {
+				const event = new Event("change", { bubbles: true });
+				setValue.call(selectElement.value, cur);
+				selectElement.value.dispatchEvent(event);
+			}
+		});
+		/**
+		* Form autofill will trigger an `input` event on the `select` element.
+		* We listen to that event and update our internal state to support it.
+		*/
+		function handleInput(event) {
+			rootContext.onValueChange(event.target.value);
+		}
+		/**
+		* We purposefully use a `select` here to support form autofill as much
+		* as possible.
+		*
+		* We purposefully do not add the `value` attribute here to allow the value
+		* to be set programmatically and bubble to any parent form `onChange` event.
+		*
+		* We use `VisuallyHidden` rather than `display: "none"` because Safari autofill
+		* won't work otherwise.
+		*/
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(VisuallyHidden_default), { "as-child": "" }, {
+				default: withCtx(() => [createElementVNode("select", mergeProps({
+					ref_key: "selectElement",
+					ref: selectElement
+				}, props, { onInput: handleInput }), [renderSlot(_ctx.$slots, "default")], 16)]),
+				_: 3
+			});
+		};
+	}
+});
+//#endregion
+export { SELECTION_KEYS as a, OPEN_KEYS as i, injectSelectRootContext as n, shouldShowPlaceholder as o, provideSelectRootContext as r, valueComparator as s, SelectRoot_default as t };

package/dist/es/chunks/CollapsibleRoot.js

@@ -0,0 +1,78 @@
+import { t as createContext } from "./createContext.js";
+import { s as useVModel } from "./dist.js";
+import { t as Primitive } from "./Primitive.js";
+import { t as useForwardExpose } from "./useForwardExpose.js";
+import { createBlock, defineComponent, openBlock, renderSlot, toRefs, unref, withCtx } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Collapsible/CollapsibleRoot.js
+var [injectCollapsibleRootContext, provideCollapsibleRootContext] = /* @__PURE__ */ createContext("CollapsibleRoot");
+var CollapsibleRoot_default = /* @__PURE__ */ defineComponent({
+	__name: "CollapsibleRoot",
+	props: {
+		defaultOpen: {
+			type: Boolean,
+			required: false,
+			default: false
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		unmountOnHide: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		asChild: {
+			type: Boolean,
+			required: false
+		},
+		as: {
+			type: null,
+			required: false
+		}
+	},
+	emits: ["update:open"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const open = useVModel(props, "open", __emit, {
+			defaultValue: props.defaultOpen,
+			passive: props.open === void 0
+		});
+		const { disabled, unmountOnHide } = toRefs(props);
+		provideCollapsibleRootContext({
+			contentId: "",
+			disabled,
+			open,
+			unmountOnHide,
+			onOpenToggle: () => {
+				if (disabled.value) return;
+				open.value = !open.value;
+			}
+		});
+		__expose({ open });
+		useForwardExpose();
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				as: _ctx.as,
+				"as-child": props.asChild,
+				"data-state": unref(open) ? "open" : "closed",
+				"data-disabled": unref(disabled) ? "" : void 0
+			}, {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", { open: unref(open) })]),
+				_: 3
+			}, 8, [
+				"as",
+				"as-child",
+				"data-state",
+				"data-disabled"
+			]);
+		};
+	}
+});
+//#endregion
+export { injectCollapsibleRootContext as n, CollapsibleRoot_default as t };

package/dist/es/chunks/Collection.js

@@ -0,0 +1,73 @@
+import { n as Slot } from "./Primitive.js";
+import { t as usePrimitiveElement } from "./usePrimitiveElement.js";
+import { computed, defineComponent, h, inject, markRaw, provide, ref, watch, watchEffect } from "vue";
+//#region ../../node_modules/.pnpm/reka-ui@2.10.1_vue@3.5.13_typescript@5.9.3_/node_modules/reka-ui/dist/Collection/Collection.js
+var ITEM_DATA_ATTR = "data-reka-collection-item";
+function useCollection(options = {}) {
+	const { key = "", isProvider = false } = options;
+	const injectionKey = `${key}CollectionProvider`;
+	let context;
+	if (isProvider) {
+		const itemMap = ref(/* @__PURE__ */ new Map());
+		context = {
+			collectionRef: ref(),
+			itemMap
+		};
+		provide(injectionKey, context);
+	} else context = inject(injectionKey);
+	const getItems = (includeDisabledItem = false) => {
+		const collectionNode = context.collectionRef.value;
+		if (!collectionNode) return [];
+		const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+		const orderMap = new Map(orderedNodes.map((node, index) => [node, index]));
+		const orderedItems = Array.from(context.itemMap.value.values()).sort((a, b) => (orderMap.get(a.ref) ?? -1) - (orderMap.get(b.ref) ?? -1));
+		if (includeDisabledItem) return orderedItems;
+		else return orderedItems.filter((i) => i.ref.dataset.disabled !== "");
+	};
+	const CollectionSlot = /* @__PURE__ */ defineComponent({
+		name: "CollectionSlot",
+		inheritAttrs: false,
+		setup(_, { slots, attrs }) {
+			const { primitiveElement, currentElement } = usePrimitiveElement();
+			watch(currentElement, () => {
+				context.collectionRef.value = currentElement.value;
+			});
+			return () => h(Slot, {
+				ref: primitiveElement,
+				...attrs
+			}, slots);
+		}
+	});
+	const CollectionItem = /* @__PURE__ */ defineComponent({
+		name: "CollectionItem",
+		inheritAttrs: false,
+		props: { value: { validator: () => true } },
+		setup(props, { slots, attrs }) {
+			const { primitiveElement, currentElement } = usePrimitiveElement();
+			watchEffect((cleanupFn) => {
+				if (currentElement.value) {
+					const key$1 = markRaw(currentElement.value);
+					context.itemMap.value.set(key$1, {
+						ref: currentElement.value,
+						value: props.value
+					});
+					cleanupFn(() => context.itemMap.value.delete(key$1));
+				}
+			});
+			return () => h(Slot, {
+				...attrs,
+				[ITEM_DATA_ATTR]: "",
+				ref: primitiveElement
+			}, slots);
+		}
+	});
+	return {
+		getItems,
+		reactiveItems: computed(() => Array.from(context.itemMap.value.values())),
+		itemMapSize: computed(() => context.itemMap.value.size),
+		CollectionSlot,
+		CollectionItem
+	};
+}
+//#endregion
+export { useCollection as t };