ropav 0.1.7 → 0.1.8

package/dist/combobox.js

@@ -0,0 +1,410 @@
+import './combobox.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 { t as x_default } from "./x.js";
+import { o as splitCompatibilityAttributes, t as composeEventHandlers } from "./attributes2.js";
+import { t as useControlState } from "./useControlState.js";
+import { t as resolveHTMLElementRef } from "./componentRef.js";
+import { t as useFloatingPosition } from "./useFloatingPosition.js";
+import { r as chevrons_up_down_default } from "./useFlatOptionCollection.js";
+import { t as scroll_area_default } from "./scroll-area.js";
+import { t as useEditableOptionList } from "./useEditableOptionList.js";
+import { i as useHiddenSelectChoiceTransaction, n as createSingleNativeChoiceAdapter } from "./nativeChoice.js";
+import { VaporTransition, child, computed, createComponent, createFor, createIf, createSlot, createTemplateRefSetter, defineVaporComponent, extend, next, on, ref, renderEffect, setDynamicProps, setInsertionState, setProp, setTemplateRefBinding, setText, setValue, template, toDisplayString, txt, unref, useId, withModifiers } from "vue";
+//#region src/components/combobox/comboboxModel.ts
+function hasComboboxValue(value) {
+	return value !== null;
+}
+function getComboboxDisplayLabel(options, value) {
+	if (!hasComboboxValue(value)) return "";
+	return options?.find((option) => option.value === value)?.label ?? "";
+}
+//#endregion
+//#region src/components/combobox/useCombobox.ts
+function useComboboxTransaction(props, emitUpdate, inputRef, onFormReset) {
+	const transaction = useHiddenSelectChoiceTransaction({
+		value: {
+			modelValue: () => props.modelValue,
+			defaultValue: () => props.defaultValue ?? null,
+			onChange: emitUpdate
+		},
+		native: {
+			adapter: createSingleNativeChoiceAdapter({
+				emptyValue: null,
+				options: () => props.options
+			}),
+			className: "rp-combobox__native",
+			focusVisible: () => inputRef.value?.focus(),
+			validationMessage: () => props.validationMessage
+		},
+		onFormReset
+	});
+	return {
+		nativeSelectRef: transaction.nativeSelectRef,
+		nativeSelectAttrs: transaction.nativeSelectAttrs,
+		requestValueUpdate: transaction.requestValueUpdate,
+		selectedValue: transaction.value
+	};
+}
+function useCombobox(props, callbacks) {
+	const rootRef = ref(null);
+	const inputRef = ref(null);
+	const dropdownRef = ref(null);
+	const generatedId = useId();
+	const comboboxId = props.id ?? generatedId;
+	const transaction = useComboboxTransaction(props, callbacks.valueChange, inputRef, resetAfterFormReset);
+	const selectedValue = transaction.selectedValue;
+	const control = useControlState(props);
+	const displayLabel = computed(() => getComboboxDisplayLabel(props.options, selectedValue.value));
+	const optionList = useEditableOptionList({
+		baseId: comboboxId,
+		clearable: () => Boolean(props.clearable),
+		disabled: () => control.disabled,
+		filter: () => props.filter,
+		getKey: (option) => option.value,
+		inputRef,
+		isDisabled: (option) => Boolean(option.disabled),
+		items: () => props.options,
+		onSearch: callbacks.search,
+		rootRef,
+		selection: {
+			kind: "single",
+			clear() {
+				if (hasComboboxValue(selectedValue.value)) transaction.requestValueUpdate(null);
+			},
+			displayValue: () => displayLabel.value,
+			hasSelection: () => hasComboboxValue(selectedValue.value),
+			isSelected: (option) => option.value === selectedValue.value,
+			select: (option) => transaction.requestValueUpdate(option.value)
+		}
+	});
+	const { activeDescendantId, canClear, isOpen, renderedOptions, searchValue, visibleOptions } = optionList.state;
+	const { listbox: listboxId, popup: popupId } = optionList.ids;
+	const floating = useFloatingPosition({
+		reference: rootRef,
+		floating: dropdownRef,
+		open: isOpen,
+		placement: "bottom-start"
+	});
+	const placementSide = computed(() => floating.actualPlacement.value.split("-")[0]);
+	const rootClass = computed(() => bem("rp-combobox", {
+		open: isOpen.value,
+		[`size-${props.size}`]: Boolean(props.size),
+		[`radius-${props.radius}`]: Boolean(props.radius),
+		disabled: control.disabled,
+		invalid: control.invalid
+	}));
+	function setDropdownElement(elementRef) {
+		resolveHTMLElementRef(elementRef, popupId, (resolved) => {
+			dropdownRef.value = resolved;
+		});
+	}
+	function resetAfterFormReset() {
+		optionList.actions.resetAfterFormReset();
+	}
+	return {
+		templateRefs: {
+			root: rootRef,
+			input: inputRef,
+			native: transaction.nativeSelectRef
+		},
+		nativeSelectAttrs: transaction.nativeSelectAttrs,
+		isOpen,
+		popupId,
+		listboxId,
+		control,
+		visibleOptions,
+		renderedOptions,
+		activeDescendantId,
+		rootClass,
+		floatingStyle: floating.floatingStyle,
+		actualPlacement: floating.actualPlacement,
+		placementSide,
+		searchValue,
+		displayLabel,
+		canClear,
+		setDropdownElement,
+		toggle: optionList.actions.toggle,
+		selectOption: optionList.actions.selectOption,
+		clearSelection: optionList.actions.clearSelection,
+		onOptionMouseenter: optionList.handlers.onOptionMouseenter,
+		onFocusout: optionList.handlers.onFocusout,
+		onInput: optionList.handlers.onInput,
+		onInputFocus: optionList.handlers.onInputFocus,
+		onInputClick: optionList.handlers.onInputClick,
+		onInputKeydown: optionList.handlers.onInputKeydown
+	};
+}
+//#endregion
+//#region src/components/combobox/combobox.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<option data-v-b9882cdc> ");
+var t1 = template("<button data-v-b9882cdc></button>");
+var t2 = template("No options", 2);
+var t3 = template("<div data-v-b9882cdc>");
+var t4 = template(" ");
+var t5 = template("<div data-v-b9882cdc><select data-v-b9882cdc><option data-v-b9882cdc value></option></select><input data-v-b9882cdc><span data-v-b9882cdc><button data-v-b9882cdc>", 1);
+//#endregion
+//#region src/components/combobox/combobox.vue
+var combobox_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineVaporComponent({
+	name: "RpCombobox",
+	inheritAttrs: false,
+	__name: "combobox",
+	props: {
+		id: {},
+		name: {},
+		form: {},
+		modelValue: { default: void 0 },
+		defaultValue: { default: null },
+		options: { default: () => [] },
+		filter: {
+			type: [Function, Boolean],
+			default: void 0
+		},
+		size: {},
+		radius: {},
+		placeholder: { default: "Search..." },
+		clearable: {
+			type: Boolean,
+			default: false
+		},
+		clearLabel: { default: "Clear selection" },
+		toggleLabel: { default: "Toggle options" },
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		required: {
+			type: Boolean,
+			default: void 0
+		},
+		invalid: {
+			type: Boolean,
+			default: void 0
+		},
+		ariaLabel: {},
+		describedby: {},
+		labelledby: {},
+		inputAttrs: {},
+		validationMessage: {},
+		classNames: {},
+		styles: {}
+	},
+	emits: ["update:modelValue", "search"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { templateRefs, nativeSelectAttrs, isOpen, popupId, listboxId, control, visibleOptions, renderedOptions, activeDescendantId, rootClass, floatingStyle, actualPlacement, placementSide, searchValue, canClear, setDropdownElement, toggle, selectOption, clearSelection, onOptionMouseenter, onFocusout, onInput, onInputFocus, onInputClick, onInputKeydown } = useCombobox(props, {
+			valueChange: (value) => emit("update:modelValue", value),
+			search: (value) => emit("search", value)
+		});
+		const { getPartAttrs, getRootAttrs } = useStylesApi(props, "root");
+		const rootAttrs = computed(() => getRootAttrs({
+			class: rootClass.value,
+			onFocusout,
+			"data-state": isOpen.value ? "open" : "closed",
+			"data-disabled": toPresenceAttribute(control.disabled),
+			"data-invalid": toPresenceAttribute(control.invalid)
+		}));
+		const contentAttrs = computed(() => ({
+			...getPartAttrs("content", {
+				class: "rp-combobox__dropdown",
+				style: floatingStyle.value
+			}),
+			"data-placement": actualPlacement.value,
+			"data-side": placementSide.value
+		}));
+		const visibleInputAttrs = computed(() => {
+			const attrs = props.inputAttrs ?? {};
+			const { compatibilityClass, compatibilityStyle, forwardedAttributes } = splitCompatibilityAttributes(attrs);
+			return {
+				...forwardedAttributes,
+				...getPartAttrs("input", {
+					class: "rp-combobox__input",
+					compatibilityClass,
+					compatibilityStyle
+				}),
+				id: control.id,
+				name: void 0,
+				form: "",
+				type: "text",
+				value: searchValue.value,
+				placeholder: props.placeholder,
+				disabled: control.disabled || void 0,
+				required: void 0,
+				autocomplete: forwardedAttributes.autocomplete ?? "off",
+				role: "combobox",
+				"aria-autocomplete": "list",
+				"aria-expanded": isOpen.value,
+				"aria-haspopup": "listbox",
+				"aria-activedescendant": activeDescendantId.value,
+				"aria-controls": listboxId,
+				"aria-disabled": control.disabled || void 0,
+				"aria-invalid": control.invalid || void 0,
+				"aria-required": control.required || void 0,
+				"aria-label": props.ariaLabel || void 0,
+				"aria-labelledby": control.ariaLabelledby,
+				"aria-describedby": control.ariaDescribedby,
+				"data-state": isOpen.value ? "open" : "closed",
+				"data-disabled": toPresenceAttribute(control.disabled),
+				"data-invalid": toPresenceAttribute(control.invalid),
+				onInput: composeEventHandlers(onInput, attrs.onInput),
+				onFocus: composeEventHandlers(onInputFocus, attrs.onFocus),
+				onClick: composeEventHandlers(onInputClick, attrs.onClick),
+				onKeydown: composeEventHandlers(onInputKeydown, attrs.onKeydown)
+			};
+		});
+		__expose({
+			nativeElement: templateRefs.native,
+			inputElement: templateRefs.input,
+			focus: () => templateRefs.input.value?.focus()
+		});
+		const _setTemplateRef = createTemplateRefSetter();
+		const n28 = t5();
+		const n3 = child(n28);
+		const n4 = next(n3, 1);
+		const n11 = next(n4, 2);
+		const n10 = child(n11, 1);
+		renderEffect(() => {
+			const _control = unref(control);
+			setDynamicProps(n28, [rootAttrs.value]);
+			setDynamicProps(n3, [unref(nativeSelectAttrs), {
+				name: __props.name,
+				form: _control.form,
+				disabled: _control.disabled || void 0,
+				required: _control.required || void 0,
+				tabindex: "-1",
+				"aria-hidden": "true"
+			}]);
+		});
+		setInsertionState(n3, null, 1);
+		createFor(() => __props.options, (_for_item0) => {
+			const n2 = t0();
+			const x2 = txt(n2);
+			renderEffect(() => {
+				const _option = _for_item0.value;
+				setValue(n2, String(_option.value));
+				setProp(n2, "disabled", _option.disabled || void 0);
+				setText(x2, toDisplayString(_option.label));
+			});
+			return n2;
+		}, (option) => option.value, 8);
+		renderEffect(() => {
+			const _templateRefs = unref(templateRefs);
+			_setTemplateRef(n3, _templateRefs.native);
+			setDynamicProps(n4, [visibleInputAttrs.value]);
+			_setTemplateRef(n4, _templateRefs.input);
+			setDynamicProps(n11, [unref(getPartAttrs)("indicator", { class: "rp-combobox__indicator" })]);
+		});
+		setInsertionState(n11, 0);
+		createIf(() => unref(canClear), () => {
+			const n8 = t1();
+			renderEffect(() => setDynamicProps(n8, [
+				{ type: "button" },
+				unref(getPartAttrs)("clear", { class: "rp-combobox__clear" }),
+				{
+					"aria-label": __props.clearLabel,
+					tabindex: "-1"
+				}
+			]));
+			setInsertionState(n8, null, 0);
+			createComponent(unref(x_default));
+			on(n8, "mousedown", withModifiers(() => {}, ["prevent"]));
+			on(n8, "click", withModifiers((e) => unref(clearSelection)(e), ["stop"]));
+			return n8;
+		});
+		renderEffect(() => setDynamicProps(n10, [
+			{ type: "button" },
+			unref(getPartAttrs)("toggle", { class: "rp-combobox__toggle" }),
+			{
+				"aria-label": __props.toggleLabel,
+				"aria-expanded": unref(isOpen),
+				disabled: unref(control).disabled || void 0,
+				tabindex: "-1"
+			}
+		]));
+		setInsertionState(n10, null, 0);
+		createComponent(unref(chevrons_up_down_default));
+		on(n10, "mousedown", withModifiers(() => {}, ["prevent"]));
+		on(n10, "click", withModifiers((e) => unref(toggle)(e), ["stop"]));
+		setInsertionState(n28, null, 3);
+		createComponent(VaporTransition, { name: "rp-combobox-dropdown" }, extend(() => {
+			return createIf(() => unref(isOpen), () => {
+				const n26 = createComponent(scroll_area_default, { $: [() => contentAttrs.value, {
+					id: () => unref(popupId),
+					embedded: "",
+					type: "auto",
+					scrollbars: "y",
+					"viewport-attrs": () => ({
+						role: "listbox",
+						tabindex: -1
+					}),
+					"data-state": () => unref(isOpen) ? "open" : "closed"
+				}] }, extend(() => {
+					return [createIf(() => unref(visibleOptions).length === 0, () => {
+						const n19 = t3();
+						renderEffect(() => setDynamicProps(n19, [unref(getPartAttrs)("empty", { class: "rp-combobox__empty" })]));
+						setInsertionState(n19, null, 0);
+						createSlot("empty", { searchValue: () => unref(searchValue) }, () => {
+							return t2();
+						}, 1);
+						return n19;
+					}, null, 129), createFor(() => unref(renderedOptions), (_for_item0) => {
+						const n25 = t3();
+						renderEffect(() => {
+							const _optionState = _for_item0.value;
+							const _optionState_selected = _optionState.selected;
+							const _optionState_disabled = _optionState.disabled;
+							setDynamicProps(n25, [{
+								id: _optionState.id,
+								role: "option",
+								"aria-selected": _optionState_selected,
+								"aria-disabled": _optionState_disabled || void 0,
+								"data-selected": unref(toPresenceAttribute)(_optionState.selected),
+								"data-highlighted": unref(toPresenceAttribute)(_optionState.active),
+								"data-disabled": unref(toPresenceAttribute)(_optionState.disabled)
+							}, unref(getPartAttrs)("option", { class: ["rp-combobox__option", {
+								"rp-combobox__option--selected": _optionState_selected,
+								"rp-combobox__option--highlighted": _optionState.active,
+								"rp-combobox__option--disabled": _optionState_disabled
+							}] })]);
+						});
+						setInsertionState(n25, null, 0);
+						createSlot("option", {
+							option: () => _for_item0.value.option,
+							selected: () => _for_item0.value.selected,
+							highlighted: () => _for_item0.value.active
+						}, () => {
+							const n24 = t4();
+							renderEffect(() => setText(n24, toDisplayString(_for_item0.value.option.label)));
+							return n24;
+						}, 1);
+						on(n25, "mousedown", withModifiers(() => {}, ["prevent"]));
+						on(n25, "click", () => unref(selectOption)(_for_item0.value.option));
+						on(n25, "mouseenter", () => unref(onOptionMouseenter)(_for_item0.value.option));
+						return n25;
+					}, (optionState) => optionState.option.value, 40)];
+				}, { _: 8 }));
+				setTemplateRefBinding(n26, () => setDropdownElement, _setTemplateRef, void 0, "setDropdownElement");
+				return n26;
+			}, null, 129);
+		}, { _: 8 }));
+		setTemplateRefBinding(n28, () => unref(templateRefs).root);
+		return n28;
+	}
+}), [["__scopeId", "data-v-b9882cdc"]]);
+//#endregion
+//#region src/components/combobox/types.ts
+var comboboxParts = [
+	"root",
+	"input",
+	"indicator",
+	"clear",
+	"toggle",
+	"content",
+	"option",
+	"empty"
+];
+//#endregion
+export { combobox_default as n, comboboxParts as t };

package/dist/components/calendar/calendar.d.ts

@@ -0,0 +1,30 @@
+import { CalendarDaySlotProps, CalendarProps } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<CalendarProps & {
+        "onUpdate:modelValue"?: ((value: Date) => any) | undefined;
+        onChange?: ((value: Date) => any) | undefined;
+        "onUpdate:month"?: ((month: Date) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        focus(): void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        day?(props: CalendarDaySlotProps): unknown;
+        'previous-icon'?(): unknown;
+        'next-icon'?(): unknown;
+    };
+    emit: ((evt: "update:modelValue", value: Date) => void) & ((evt: "change", value: Date) => void) & ((evt: "update:month", month: Date) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/calendar/calendarBehavior.d.ts

@@ -0,0 +1,49 @@
+import { DateAvailabilityOptions } from '../../utils/dateAvailability.js';
+import { CalendarDay, CalendarWeekday, CalendarWeekdayFormat } from './types.js';
+interface CalendarBehaviorOptions extends DateAvailabilityOptions {
+    month: Date;
+    selectedDate: Date | null;
+    today: Date;
+    firstDayOfWeek?: number;
+    weekdayFormat?: CalendarWeekdayFormat;
+    locale?: string;
+    monthFormat?: Intl.DateTimeFormatOptions;
+    fixedWeeks?: boolean;
+    hideOutsideDates?: boolean;
+    disabled?: boolean;
+}
+type CalendarBehaviorAction = {
+    type: 'resolve-focusable';
+    focusedDate: Date;
+} | {
+    type: 'align-month';
+    previousMonth: Date;
+    focusedDate: Date;
+} | {
+    type: 'navigate-month';
+    amount: number;
+    focusedDate: Date;
+} | {
+    type: 'move-focus';
+    date: Date;
+    key: string;
+    shiftKey?: boolean;
+};
+interface CalendarBehaviorTransition {
+    focusedDate: Date;
+    visibleMonth?: Date;
+}
+interface CalendarBehaviorView {
+    days: CalendarDay[];
+    weeks: CalendarDay[][];
+    weekdays: CalendarWeekday[];
+    monthLabel: string;
+    previousDisabled: boolean;
+    nextDisabled: boolean;
+}
+interface CalendarBehavior {
+    view: CalendarBehaviorView;
+    decide: (action: CalendarBehaviorAction) => CalendarBehaviorTransition | null;
+}
+export declare function createCalendarBehavior(options: CalendarBehaviorOptions): CalendarBehavior;
+export {};

package/dist/components/calendar/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Calendar } from './calendar.js';
+export { calendarParts, calendarRadiuses, calendarSizes, calendarWeekdayFormats } from './types.js';
+export type { CalendarDay, CalendarDaySlotProps, CalendarDisabledDates, CalendarPart, CalendarProps, CalendarRadius, CalendarSize, CalendarWeekday, CalendarWeekdayFormat, } from './types.js';

package/dist/components/calendar/index.js

@@ -0,0 +1,3 @@
+import { t as calendar_default } from "../../calendar.js";
+import { i as calendarWeekdayFormats, n as calendarRadiuses, r as calendarSizes, t as calendarParts } from "../../calendar2.js";
+export { calendar_default as Calendar, calendarParts, calendarRadiuses, calendarSizes, calendarWeekdayFormats };

package/dist/components/calendar/types.d.ts

@@ -0,0 +1,53 @@
+import { StylesApiProps } from '../../styles-api.js';
+import { DisabledDateRule } from '../../utils/dateAvailability.js';
+export declare const calendarParts: readonly ["root", "header", "previousControl", "monthLabel", "nextControl", "weekdays", "weekday", "grid", "week", "dayCell", "day"];
+export declare const calendarSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const calendarRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export declare const calendarWeekdayFormats: readonly ["narrow", "short", "long"];
+export type CalendarPart = (typeof calendarParts)[number];
+export type CalendarSize = (typeof calendarSizes)[number];
+export type CalendarRadius = (typeof calendarRadiuses)[number];
+export type CalendarWeekdayFormat = (typeof calendarWeekdayFormats)[number];
+export type CalendarDisabledDates = DisabledDateRule;
+export interface CalendarDay {
+    date: Date;
+    key: string;
+    label: number;
+    ariaLabel: string;
+    outside: boolean;
+    hidden: boolean;
+    selected: boolean;
+    today: boolean;
+    disabled: boolean;
+}
+export interface CalendarWeekday {
+    key: number;
+    label: string;
+    ariaLabel: string;
+}
+export interface CalendarDaySlotProps extends CalendarDay {
+    select: () => void;
+}
+export interface CalendarProps extends StylesApiProps<CalendarPart> {
+    id?: string;
+    modelValue?: Date | null;
+    defaultValue?: Date | null;
+    month?: Date;
+    defaultMonth?: Date;
+    locale?: string;
+    firstDayOfWeek?: number;
+    weekdayFormat?: CalendarWeekdayFormat;
+    monthFormat?: Intl.DateTimeFormatOptions;
+    min?: Date;
+    max?: Date;
+    disabledDates?: CalendarDisabledDates;
+    fixedWeeks?: boolean;
+    hideOutsideDates?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: CalendarSize;
+    radius?: CalendarRadius;
+    ariaLabel?: string;
+    previousLabel?: string;
+    nextLabel?: string;
+}

package/dist/components/calendar/useCalendar.d.ts

@@ -0,0 +1,24 @@
+import { CalendarDay, CalendarProps } from './types.js';
+interface CalendarEmitters {
+    value: (value: Date) => void;
+    month: (month: Date) => void;
+    change: (value: Date) => void;
+}
+export declare function useCalendar(props: Readonly<CalendarProps>, emit: CalendarEmitters): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    selectedDate: import('vue').ComputedRef<Date | null>;
+    visibleMonth: import('vue').ComputedRef<Date>;
+    days: import('vue').ComputedRef<CalendarDay[]>;
+    weeks: import('vue').ComputedRef<CalendarDay[][]>;
+    weekdays: import('vue').ComputedRef<import('./types.js').CalendarWeekday[]>;
+    monthLabel: import('vue').ComputedRef<string>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    previousDisabled: import('vue').ComputedRef<boolean>;
+    nextDisabled: import('vue').ComputedRef<boolean>;
+    focusableDate: import('vue').ComputedRef<Date | null>;
+    selectDate: (day: CalendarDay) => void;
+    navigateMonth: (amount: number) => void;
+    onDayKeydown: (event: KeyboardEvent, day: CalendarDay) => void;
+    onDayFocus: (day: CalendarDay) => void;
+};
+export {};

package/dist/components/color-picker/useColorPickerDrag.d.ts

@@ -11,6 +11,6 @@ interface UseColorPickerDragOptions {
     updateFromPointer: (pointer: ColorPickerPointerCoordinates, rect: DOMRect) => void;
 }
 export declare function useColorPickerDrag({ target, focusTarget, readonly, isGeometryValid, updateFromPointer, }: UseColorPickerDragOptions): {
-    onPointerDown: (event: PointerEvent) => void;
+    onPointerDown: (event: PointerEvent) => boolean;
 };
 export {};

package/dist/components/color-picker/useColorPickerSaturation.d.ts

@@ -15,7 +15,7 @@ export declare function useColorPickerSaturation({ modelValue, hue, readonly, on
         value: number;
     }>;
     normalizedHue: import('vue').ComputedRef<number>;
-    onPointerDown: (event: PointerEvent) => void;
+    onPointerDown: (event: PointerEvent) => boolean;
     onAxisKeydown: (event: KeyboardEvent, axis: ColorPickerAxis) => void;
     onAxisInput: (event: Event, axis: ColorPickerAxis) => void;
 };

package/dist/components/color-picker/useColorPickerSlider.d.ts

@@ -14,7 +14,7 @@ export declare function useColorPickerSlider({ variant, value, readonly, onChang
         value: number;
         outputValue: number;
     }>;
-    onPointerDown: (event: PointerEvent) => void;
+    onPointerDown: (event: PointerEvent) => boolean;
     onKeydown: (event: KeyboardEvent) => void;
 };
 export {};

package/dist/components/combobox/combobox.d.ts

@@ -0,0 +1,29 @@
+import { ComboboxEmptySlotProps, ComboboxOptionSlotProps, ComboboxProps } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<ComboboxProps & {
+        onSearch?: ((searchValue: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        inputElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        focus: () => void | undefined;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?(props: ComboboxOptionSlotProps): unknown;
+        empty?(props: ComboboxEmptySlotProps): unknown;
+    };
+    emit: ((evt: "search", searchValue: string) => void) & ((evt: "update:modelValue", value: string | number | null) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/combobox/comboboxModel.d.ts

@@ -0,0 +1,4 @@
+import { ComboboxOption } from './types.js';
+export type ComboboxValue = string | number | null;
+export declare function hasComboboxValue(value: ComboboxValue): value is string | number;
+export declare function getComboboxDisplayLabel(options: readonly ComboboxOption[] | undefined, value: ComboboxValue): string;

package/dist/components/combobox/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Combobox } from './combobox.js';
+export { comboboxParts } from './types.js';
+export type { ComboboxEmptySlotProps, ComboboxFilter, ComboboxOption, ComboboxOptionSlotProps, ComboboxPart, ComboboxProps, ComboboxRadius, ComboboxSize, } from './types.js';

package/dist/components/combobox/index.js

@@ -0,0 +1,2 @@
+import { n as combobox_default, t as comboboxParts } from "../../combobox.js";
+export { combobox_default as Combobox, comboboxParts };