@vunset/vue 0.0.0-stage → 1.0.0-rc.2

package/dist/components/scroll-area/ScrollArea.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,178 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { dataAttrs } from "../../shared/data-attrs.js";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, onScopeDispose, openBlock, ref, renderSlot, unref, useAttrs, watch, withCtx } from "vue";
+//#region src/components/scroll-area/ScrollArea.vue?vue&type=script&setup=true&lang.ts
+var OVERFLOW_X_START_VAR = "--scroll-area-overflow-x-start";
+var OVERFLOW_X_END_VAR = "--scroll-area-overflow-x-end";
+var OVERFLOW_Y_START_VAR = "--scroll-area-overflow-y-start";
+var OVERFLOW_Y_END_VAR = "--scroll-area-overflow-y-end";
+var FADE_SIZE_VAR = "--scroll-area-fade-size";
+var DEFAULT_FADE_SIZE = "40px";
+var EDGE_TOLERANCE = 1;
+function fadeGradient(direction, startVar, endVar) {
+	const size = `var(${FADE_SIZE_VAR}, ${DEFAULT_FADE_SIZE})`;
+	return `linear-gradient(${direction}, transparent 0, #000 min(${size}, var(${startVar}, 0px)), #000 calc(100% - min(${size}, var(${endVar}, 0px))), transparent 100%)`;
+}
+/**
+* How far one axis's content runs past its start and end edges, in px. A
+* fractional position left by zoom or smooth scrolling that lands within
+* {@link EDGE_TOLERANCE} of an edge counts as sitting on it.
+*/
+function overflowPast(position, content, box) {
+	const hidden = Math.max(0, content - box);
+	let start = Math.min(Math.max(position, 0), hidden);
+	if (start <= EDGE_TOLERANCE) start = 0;
+	else if (hidden - start <= EDGE_TOLERANCE) start = hidden;
+	return [start, hidden - start];
+}
+function hasChanged(previous, next) {
+	let key;
+	for (key in next) if (previous[key] !== next[key]) return true;
+	return false;
+}
+var ScrollArea_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ScrollArea",
+	inheritAttrs: false,
+	__name: "ScrollArea",
+	props: {
+		axis: { default: "both" },
+		fade: {
+			type: [Boolean, String],
+			default: false
+		},
+		fadeSize: {},
+		overflowThreshold: { default: 0 },
+		as: { default: "div" }
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const viewport = ref(null);
+		const state = ref({
+			hasOverflowX: false,
+			hasOverflowY: false,
+			overflowXStart: false,
+			overflowXEnd: false,
+			overflowYStart: false,
+			overflowYEnd: false
+		});
+		function measure() {
+			const element = viewport.value;
+			if (!element) return;
+			const [xStart, xEnd] = overflowPast(Math.abs(element.scrollLeft), element.scrollWidth, element.clientWidth);
+			const [yStart, yEnd] = overflowPast(element.scrollTop, element.scrollHeight, element.clientHeight);
+			element.style.setProperty(OVERFLOW_X_START_VAR, `${xStart}px`);
+			element.style.setProperty(OVERFLOW_X_END_VAR, `${xEnd}px`);
+			element.style.setProperty(OVERFLOW_Y_START_VAR, `${yStart}px`);
+			element.style.setProperty(OVERFLOW_Y_END_VAR, `${yEnd}px`);
+			const threshold = Math.max(0, props.overflowThreshold);
+			const next = {
+				hasOverflowX: xStart + xEnd > 0,
+				hasOverflowY: yStart + yEnd > 0,
+				overflowXStart: xStart > threshold,
+				overflowXEnd: xEnd > threshold,
+				overflowYStart: yStart > threshold,
+				overflowYEnd: yEnd > threshold
+			};
+			if (hasChanged(state.value, next)) state.value = next;
+		}
+		const rtl = ref(false);
+		function readDirection(element) {
+			rtl.value = getComputedStyle(element).direction === "rtl";
+		}
+		let resizeObserver = null;
+		let mutationObserver = null;
+		function observeContent(element) {
+			if (!resizeObserver) return;
+			resizeObserver.disconnect();
+			resizeObserver.observe(element);
+			for (const child of Array.from(element.children)) resizeObserver.observe(child);
+		}
+		function disconnect() {
+			resizeObserver?.disconnect();
+			resizeObserver = null;
+			mutationObserver?.disconnect();
+			mutationObserver = null;
+		}
+		watch(viewport, (element) => {
+			disconnect();
+			if (!element) return;
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(() => {
+					readDirection(element);
+					measure();
+				});
+				observeContent(element);
+			}
+			if (typeof MutationObserver !== "undefined") {
+				mutationObserver = new MutationObserver(() => {
+					observeContent(element);
+					measure();
+				});
+				mutationObserver.observe(element, { childList: true });
+			}
+			readDirection(element);
+			measure();
+		}, { flush: "post" });
+		watch(() => props.overflowThreshold, measure);
+		onScopeDispose(disconnect);
+		const hooks = computed(() => dataAttrs(state.value, {
+			hasOverflowX: (on) => on ? { "data-has-overflow-x": "" } : null,
+			hasOverflowY: (on) => on ? { "data-has-overflow-y": "" } : null,
+			overflowXStart: (on) => on ? { "data-overflow-x-start": "" } : null,
+			overflowXEnd: (on) => on ? { "data-overflow-x-end": "" } : null,
+			overflowYStart: (on) => on ? { "data-overflow-y-start": "" } : null,
+			overflowYEnd: (on) => on ? { "data-overflow-y-end": "" } : null
+		}));
+		const fadeAxes = computed(() => {
+			if (!props.fade) return null;
+			return props.fade === true ? "both" : props.fade;
+		});
+		const style = computed(() => {
+			const declarations = {
+				overflowX: props.axis === "y" ? "hidden" : "auto",
+				overflowY: props.axis === "x" ? "hidden" : "auto"
+			};
+			if (props.fadeSize !== void 0) declarations[FADE_SIZE_VAR] = typeof props.fadeSize === "number" ? `${props.fadeSize}px` : props.fadeSize;
+			const axes = fadeAxes.value;
+			if (!axes) return declarations;
+			const layers = [];
+			if (axes !== "y") layers.push(fadeGradient(rtl.value ? "to left" : "to right", OVERFLOW_X_START_VAR, OVERFLOW_X_END_VAR));
+			if (axes !== "x") layers.push(fadeGradient("to bottom", OVERFLOW_Y_START_VAR, OVERFLOW_Y_END_VAR));
+			const image = layers.join(", ");
+			declarations.maskImage = image;
+			declarations.WebkitMaskImage = image;
+			declarations.maskRepeat = "no-repeat";
+			declarations.WebkitMaskRepeat = "no-repeat";
+			if (layers.length === 2) {
+				declarations.maskComposite = "intersect";
+				declarations.WebkitMaskComposite = "source-in";
+			}
+			return declarations;
+		});
+		__expose({
+			state,
+			viewport,
+			measure
+		});
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1({
+			...hooks.value,
+			"data-part": "scroll-area",
+			ref: (element) => {
+				viewport.value = element ?? null;
+			},
+			tabindex: state.value.hasOverflowX || state.value.hasOverflowY ? 0 : -1,
+			style: style.value,
+			onScroll: measure
+		}, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(state.value)))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { FADE_SIZE_VAR, OVERFLOW_X_END_VAR, OVERFLOW_X_START_VAR, OVERFLOW_Y_END_VAR, OVERFLOW_Y_START_VAR, ScrollArea_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/select/SelectRoot.js

@@ -0,0 +1,5 @@
+import SelectRoot_vue_vue_type_script_setup_true_lang_default from "./SelectRoot.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/select/SelectRoot.vue
+var SelectRoot_default = SelectRoot_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SelectRoot_default as default };

package/dist/components/select/SelectRoot.vue.d.ts

@@ -0,0 +1,116 @@
+import { type ModelModifiers } from '../../shared/model-modifiers';
+import { type ListboxItem, type ListboxOption, type ListboxOptionValue, type ListboxOrder, type ListboxPresetItem } from '../../shared/use-listbox';
+import type { Align, Side } from '../../shared/use-positioning';
+type __VLS_Props = {
+    /** The selection, bound with `v-model`: a value, an array when `multiple`, or `null`. */
+    modelValue?: ListboxOptionValue | ListboxOptionValue[] | null;
+    /** `v-model.optional` writes `undefined` once the value is emptied. */
+    modelModifiers?: ModelModifiers;
+    /** The selection at first, when no `v-model` owns it. */
+    defaultValue?: ListboxOptionValue | ListboxOptionValue[] | null;
+    /** The options: values, `{ value, label, disabled }` objects, or `{ label, options }` groups. */
+    options?: ListboxItem[];
+    /** Lets more than one option be chosen; the model becomes an array. */
+    multiple?: boolean;
+    /** Puts a search box in the popup, for `SelectSearch`. */
+    searchable?: boolean;
+    /** Whether the whole selection can be dropped at once. */
+    clearable?: boolean;
+    /** How many of the chosen options the trigger names before the rest collapse into a count. */
+    flatten?: number;
+    /** Whether choosing an option closes the popup. Defaults to on for a single select. */
+    closeOnSelect?: boolean;
+    /** Place the popup so the chosen option sits on the trigger. Ignored while `searchable`. */
+    alignWithTrigger?: boolean;
+    /** Ignores interaction. Inside a `FieldRoot`, follows the field. */
+    disabled?: boolean;
+    /** Opens no popup and changes nothing, but stays focusable. */
+    readOnly?: boolean;
+    /** Needs a selection. Announced and styled, not enforced. */
+    required?: boolean;
+    /** Marks the selection invalid, for styling through `data-invalid`. */
+    invalid?: boolean;
+    /** The form field name; the selection is submitted through hidden inputs. */
+    name?: string;
+    /** The trigger's id. Inside a `FieldRoot`, the field's control id. */
+    id?: string;
+    /** Whether the popup is open, bound with `v-model:open`. */
+    open?: boolean;
+    /** Whether arrow keys wrap past the ends of the list. */
+    loop?: boolean;
+    /** Render only the options near the scroll position, for long flat lists. Needs `maxHeight`. */
+    virtual?: boolean;
+    /** Caps the list, which then scrolls. A number is pixels. */
+    maxHeight?: number | string;
+    /** `selected-first` lifts what is selected to the top of its group, each time the popup opens. */
+    order?: ListboxOrder;
+    /** Named sets of values, shown by `SelectPresets`. Multiple only. A group (`{ label, presets, collapsed }`) folds away from its heading. */
+    presets?: ListboxPresetItem[];
+    /** Names the presets outside a group, so they fold like one. */
+    presetsLabel?: string;
+    /** Which key on an option holds its value. */
+    valueKey?: string;
+    /** Which key on an option holds its text. */
+    labelKey?: string;
+    /** Replaces the built-in search, a case-insensitive match on the label. */
+    filter?: (option: ListboxOption, query: string) => boolean;
+    /** Which side of the trigger the popup prefers. */
+    side?: Side;
+    /** How the popup lines up along that side. */
+    align?: Align;
+    /** The gap between the trigger and the popup, in pixels. */
+    sideOffset?: number;
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    mode: import("../..").ListboxMode;
+    open: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+    multiple: boolean;
+    searchable: boolean;
+    creating: boolean;
+    filled: boolean;
+    empty: boolean;
+    alignedToItem: boolean;
+    side: Side;
+    align: Align;
+    transitionStatus: import("../..").TransitionStatus;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: ListboxOptionValue | ListboxOptionValue[] | null | undefined) => any;
+    "update:open": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ListboxOptionValue | ListboxOptionValue[] | null | undefined) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+    required: boolean;
+    invalid: boolean;
+    as: string | object;
+    modelValue: ListboxOptionValue | ListboxOptionValue[] | null;
+    options: ListboxItem[];
+    disabled: boolean;
+    open: boolean;
+    readOnly: boolean;
+    loop: boolean;
+    multiple: boolean;
+    searchable: boolean;
+    clearable: boolean;
+    flatten: number;
+    closeOnSelect: boolean;
+    alignWithTrigger: boolean;
+}, {}, {}, {}, 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/select/SelectRoot.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,133 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { applyModelModifiers } from "../../shared/model-modifiers.js";
+import { provideListboxContext, useListbox } from "../../shared/use-listbox.js";
+import { Fragment, computed, createBlock, createElementBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderList, renderSlot, toRef, unref, useAttrs, withCtx } from "vue";
+//#region src/components/select/SelectRoot.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["name", "value"];
+var SelectRoot_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "SelectRoot",
+	inheritAttrs: false,
+	__name: "SelectRoot",
+	props: {
+		modelValue: { default: void 0 },
+		modelModifiers: {},
+		defaultValue: {},
+		options: { default: () => [] },
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		searchable: {
+			type: Boolean,
+			default: false
+		},
+		clearable: {
+			type: Boolean,
+			default: true
+		},
+		flatten: { default: void 0 },
+		closeOnSelect: {
+			type: Boolean,
+			default: void 0
+		},
+		alignWithTrigger: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		readOnly: {
+			type: Boolean,
+			default: false
+		},
+		required: {
+			type: Boolean,
+			default: false
+		},
+		invalid: {
+			type: Boolean,
+			default: false
+		},
+		name: {},
+		id: {},
+		open: {
+			type: Boolean,
+			default: void 0
+		},
+		loop: {
+			type: Boolean,
+			default: true
+		},
+		virtual: { type: Boolean },
+		maxHeight: {},
+		order: {},
+		presets: {},
+		presetsLabel: {},
+		valueKey: {},
+		labelKey: {},
+		filter: {},
+		side: {},
+		align: {},
+		sideOffset: {},
+		as: { default: "div" }
+	},
+	emits: ["update:modelValue", "update:open"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const api = useListbox({
+			mode: "select",
+			value: toRef(() => props.modelValue),
+			defaultValue: toRef(() => props.defaultValue),
+			options: toRef(() => props.options),
+			multiple: toRef(() => props.multiple),
+			searchable: toRef(() => props.searchable),
+			clearable: toRef(() => props.clearable),
+			flatten: toRef(() => props.flatten),
+			closeOnSelect: toRef(() => props.closeOnSelect),
+			alignWithTrigger: toRef(() => props.alignWithTrigger),
+			disabled: toRef(() => props.disabled),
+			readOnly: toRef(() => props.readOnly),
+			required: toRef(() => props.required),
+			invalid: toRef(() => props.invalid),
+			name: toRef(() => props.name),
+			id: toRef(() => props.id),
+			open: toRef(() => props.open),
+			loop: toRef(() => props.loop),
+			virtual: toRef(() => props.virtual),
+			maxHeight: toRef(() => props.maxHeight),
+			order: toRef(() => props.order),
+			presets: toRef(() => props.presets),
+			presetsLabel: toRef(() => props.presetsLabel),
+			valueKey: toRef(() => props.valueKey),
+			labelKey: toRef(() => props.labelKey),
+			filter: props.filter,
+			side: toRef(() => props.side),
+			align: toRef(() => props.align),
+			sideOffset: toRef(() => props.sideOffset),
+			onChange: (value) => emit("update:modelValue", applyModelModifiers(value, props.modelModifiers)),
+			onOpenChange: (open) => emit("update:open", open)
+		});
+		provideListboxContext(api);
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1(api.rootProps.value, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value))), (openBlock(true), createElementBlock(Fragment, null, renderList(unref(api).hiddenInputs.value, (hidden, index) => {
+					return openBlock(), createElementBlock("input", {
+						key: index,
+						type: "hidden",
+						name: hidden.name,
+						value: hidden.value
+					}, null, 8, _hoisted_1);
+				}), 128))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { SelectRoot_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/select/SelectSearch.js

@@ -0,0 +1,5 @@
+import SelectSearch_vue_vue_type_script_setup_true_lang_default from "./SelectSearch.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/select/SelectSearch.vue
+var SelectSearch_default = SelectSearch_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SelectSearch_default as default };

package/dist/components/select/SelectSearch.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/select/SelectSearch.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,21 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useListboxContext } from "../../shared/use-listbox.js";
+import { createBlock, defineComponent, mergeProps, openBlock, unref } from "vue";
+//#region src/components/select/SelectSearch.vue?vue&type=script&setup=true&lang.ts
+var SelectSearch_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "SelectSearch",
+	inheritAttrs: false,
+	__name: "SelectSearch",
+	props: { as: { default: "input" } },
+	setup(__props) {
+		const props = __props;
+		const { searchProps } = useListboxContext();
+		const merged = usePartProps(searchProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), null, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { SelectSearch_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/select/SelectTrigger.js

@@ -0,0 +1,5 @@
+import SelectTrigger_vue_vue_type_script_setup_true_lang_default from "./SelectTrigger.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/select/SelectTrigger.vue
+var SelectTrigger_default = SelectTrigger_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SelectTrigger_default as default };

package/dist/components/select/SelectTrigger.vue.d.ts

@@ -0,0 +1,35 @@
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    mode: import("../..").ListboxMode;
+    open: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+    multiple: boolean;
+    searchable: boolean;
+    creating: boolean;
+    filled: boolean;
+    empty: boolean;
+    alignedToItem: boolean;
+    side: import("../..").Side;
+    align: import("../..").Align;
+    transitionStatus: import("../..").TransitionStatus;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, 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/select/SelectTrigger.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,24 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useListboxContext } from "../../shared/use-listbox.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/select/SelectTrigger.vue?vue&type=script&setup=true&lang.ts
+var SelectTrigger_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "SelectTrigger",
+	inheritAttrs: false,
+	__name: "SelectTrigger",
+	props: { as: { default: "div" } },
+	setup(__props) {
+		const props = __props;
+		const { triggerProps, state } = useListboxContext();
+		const merged = usePartProps(triggerProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(state))))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { SelectTrigger_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/select/SelectValue.js

@@ -0,0 +1,5 @@
+import SelectValue_vue_vue_type_script_setup_true_lang_default from "./SelectValue.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/select/SelectValue.vue
+var SelectValue_default = SelectValue_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { SelectValue_default as default };

package/dist/components/select/SelectValue.vue.d.ts

@@ -0,0 +1,52 @@
+import { type ListboxState, type RenderedOption } from '../../shared/use-listbox';
+type __VLS_Props = {
+    /** Shown while nothing is selected. */
+    placeholder?: string;
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    default(props: ListboxState & {
+        /**
+         * Every selected option.
+         * @attribute none
+         */
+        selected: RenderedOption[];
+        /**
+         * The selected options the trigger names, up to the root's `flatten`.
+         * @attribute none
+         */
+        visible: RenderedOption[];
+        /**
+         * How many selected options `visible` leaves out.
+         * @attribute none
+         */
+        hiddenCount: number;
+        /**
+         * Whether `visible` leaves any out.
+         * @attribute none
+         */
+        collapsed: boolean;
+        /**
+         * The selection as one line of text: "Vue, TypeScript", or "Vue and 2 more".
+         * @attribute none
+         */
+        summary: string;
+        /**
+         * The `placeholder` prop.
+         * @attribute none
+         */
+        placeholder: string | undefined;
+    }): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, 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/select/SelectValue.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,42 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useListboxContext } from "../../shared/use-listbox.js";
+import { createBlock, createElementBlock, defineComponent, mergeProps, openBlock, renderSlot, toDisplayString, unref, withCtx } from "vue";
+//#region src/components/select/SelectValue.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 0,
+	"data-part": "placeholder"
+};
+var _hoisted_2 = {
+	key: 1,
+	"data-part": "summary"
+};
+var SelectValue_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "SelectValue",
+	inheritAttrs: false,
+	__name: "SelectValue",
+	props: {
+		placeholder: {},
+		as: { default: "span" }
+	},
+	setup(__props) {
+		const props = __props;
+		const { valueProps, state, selectedOptions, visibleOptions, hiddenCount, collapsed, summary } = useListboxContext();
+		const merged = usePartProps(valueProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", mergeProps({
+					selected: unref(selectedOptions),
+					visible: unref(visibleOptions),
+					hiddenCount: unref(hiddenCount),
+					collapsed: unref(collapsed),
+					summary: unref(summary),
+					placeholder: props.placeholder
+				}, unref(state)), () => [!unref(state).filled ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(props.placeholder), 1)) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(unref(summary)), 1))])]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { SelectValue_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/surface/Addon.js

@@ -0,0 +1,5 @@
+import Addon_vue_vue_type_script_setup_true_lang_default from "./Addon.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/surface/Addon.vue
+var Addon_default = Addon_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Addon_default as default };

package/dist/components/surface/Addon.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    /** Which end of the control it sits at, as `data-side`. */
+    side?: 'start' | 'end';
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, 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;
+    };
+};