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

package/dist/components/alert/AlertRoot.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,36 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { createContext } from "../../shared/context.js";
+import { useLabeling } from "../../shared/labeling.js";
+import { computed, createBlock, defineComponent, mergeProps, openBlock, renderSlot, unref, useAttrs, withCtx } from "vue";
+//#region src/components/alert/AlertRoot.vue?vue&type=script&setup=true&lang.ts
+var { provideContext, useContext: useAlertContext } = createContext("Alert");
+var AlertRoot_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AlertRoot",
+	inheritAttrs: false,
+	__name: "AlertRoot",
+	props: { as: { default: "div" } },
+	setup(__props) {
+		const props = __props;
+		const { titleId, descriptionId, registerTitle, registerDescription } = useLabeling();
+		provideContext({
+			registerTitle,
+			registerDescription
+		});
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1({
+			"data-part": "alert",
+			role: "alert",
+			"aria-labelledby": titleId.value,
+			"aria-describedby": descriptionId.value
+		}, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { AlertRoot_vue_vue_type_script_setup_true_lang_default as default, provideContext, useAlertContext };

package/dist/components/alert/AlertTitle.js

@@ -0,0 +1,5 @@
+import AlertTitle_vue_vue_type_script_setup_true_lang_default from "./AlertTitle.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/alert/AlertTitle.vue
+var AlertTitle_default = AlertTitle_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AlertTitle_default as default };

package/dist/components/alert/AlertTitle.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    /** 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;
+    };
+};

package/dist/components/alert/AlertTitle.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,29 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useRegisteredId } from "../../shared/labeling.js";
+import { useAlertContext } from "./AlertRoot.vue_vue_type_script_setup_true_lang.js";
+import { createBlock, defineComponent, mergeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/alert/AlertTitle.vue?vue&type=script&setup=true&lang.ts
+var AlertTitle_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AlertTitle",
+	inheritAttrs: false,
+	__name: "AlertTitle",
+	props: { as: { default: "div" } },
+	setup(__props) {
+		const props = __props;
+		const { registerTitle } = useAlertContext();
+		const id = useRegisteredId(registerTitle);
+		const merged = usePartProps(() => ({
+			"data-part": "title",
+			id: id.value
+		}));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { AlertTitle_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/appear/Appear.js

@@ -0,0 +1,5 @@
+import Appear_vue_vue_type_script_setup_true_lang_default from "./Appear.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/appear/Appear.vue
+var Appear_default = Appear_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Appear_default as default };

package/dist/components/appear/Appear.vue.d.ts

@@ -0,0 +1,46 @@
+import type { TransitionStatus } from '../../shared/use-transition-status';
+export interface AppearState {
+    /**
+     * Whether the content is meant to be showing.
+     * @attribute `data-open` while open, `data-closed` otherwise
+     */
+    open: boolean;
+    /**
+     * Where it is in its enter or exit animation.
+     * @attribute `data-enter-from` as it enters, `data-leave-to` as it leaves
+     */
+    transitionStatus: TransitionStatus;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    /** Whether the content is showing. */
+    open?: boolean;
+    /** Whether content that is already showing on the first render animates in. */
+    appear?: boolean;
+    /** Keep the element in the DOM while hidden, marked `hidden`, instead of unmounting it. */
+    keepMounted?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** Whether the content is showing. */
+    open?: boolean;
+    /** Whether content that is already showing on the first render animates in. */
+    appear?: boolean;
+    /** Keep the element in the DOM while hidden, marked `hidden`, instead of unmounting it. */
+    keepMounted?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+}> & Readonly<{}>, {
+    as: string | object;
+    open: boolean;
+    keepMounted: boolean;
+    appear: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default(props: AppearState): unknown;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/appear/Appear.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,63 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { dataAttrs } from "../../shared/data-attrs.js";
+import { popupStateAttrs } from "../../shared/popup-state-attrs.js";
+import { useTransitionStatus } from "../../shared/use-transition-status.js";
+import { useExitAnimation } from "../../shared/use-exit-animation.js";
+import { computed, createBlock, createCommentVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, ref, renderSlot, unref, useAttrs, withCtx } from "vue";
+//#region src/components/appear/Appear.vue?vue&type=script&setup=true&lang.ts
+var Appear_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "Appear",
+	inheritAttrs: false,
+	__name: "Appear",
+	props: {
+		open: {
+			type: Boolean,
+			default: true
+		},
+		appear: {
+			type: Boolean,
+			default: true
+		},
+		keepMounted: {
+			type: Boolean,
+			default: false
+		},
+		as: { default: "div" }
+	},
+	setup(__props) {
+		const props = __props;
+		const element = ref(null);
+		const { mounted, transitionStatus, setMounted } = useTransitionStatus(() => props.open, { animateInitialOpen: props.appear });
+		useExitAnimation({
+			open: () => props.open,
+			mounted,
+			setMounted,
+			element
+		});
+		const state = computed(() => ({
+			open: props.open,
+			transitionStatus: transitionStatus.value
+		}));
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1({
+			"data-part": "appear",
+			...dataAttrs(state.value, popupStateAttrs),
+			hidden: mounted.value ? void 0 : true,
+			ref: (el) => {
+				element.value = el ?? null;
+			}
+		}, attrs));
+		return (_ctx, _cache) => {
+			return unref(mounted) || props.keepMounted ? (openBlock(), createBlock(unref(Part), mergeProps({
+				key: 0,
+				as: props.as
+			}, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(state.value)))]),
+				_: 3
+			}, 16, ["as"])) : createCommentVNode("", true);
+		};
+	}
+});
+//#endregion
+export { Appear_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/async-state/AsyncState.js

@@ -0,0 +1,5 @@
+import AsyncState_vue_vue_type_script_setup_true_lang_default, { resolveAsyncView } from "./AsyncState.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/async-state/AsyncState.vue
+var AsyncState_default = AsyncState_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AsyncState_default as default, resolveAsyncView };

package/dist/components/async-state/AsyncState.vue.d.ts

@@ -0,0 +1,60 @@
+export type AsyncStatus = 'idle' | 'pending' | 'success' | 'error';
+export type AsyncView = 'content' | 'pending' | 'empty' | 'error' | 'idle';
+export interface AsyncStateSlotProps {
+    /** The `status` it was given. */
+    status: AsyncStatus;
+    /** Which view is showing: `content` whenever there is data, else the one the status calls for. */
+    view: AsyncView;
+    /** Whether it is reloading with `soft-loading`, the content kept under the overlay. */
+    refreshing: boolean;
+}
+export declare function resolveAsyncView(status: AsyncStatus, hasData: boolean, softLoading: boolean): {
+    view: AsyncView;
+    refreshing: boolean;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    /** Where the request is. */
+    status: AsyncStatus;
+    /** What the request returned, to tell content from empty: `null`, an empty array, map, set or plain object is no data. */
+    data?: unknown;
+    /** Whether there is data, when `data` can't tell. Overrides it. */
+    hasData?: boolean;
+    /** Reloading keeps the content on screen under an overlay, instead of replacing it. */
+    softLoading?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** Where the request is. */
+    status: AsyncStatus;
+    /** What the request returned, to tell content from empty: `null`, an empty array, map, set or plain object is no data. */
+    data?: unknown;
+    /** Whether there is data, when `data` can't tell. Overrides it. */
+    hasData?: boolean;
+    /** Reloading keeps the content on screen under an overlay, instead of replacing it. */
+    softLoading?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+}> & Readonly<{}>, {
+    as: string | object;
+    hasData: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    /** The content, whenever there is data. */
+    default(props: AsyncStateSlotProps): unknown;
+    /** Shown while loading with no data yet, or on any reload without `soft-loading`. */
+    pending(props: AsyncStateSlotProps): unknown;
+    /** Shown when the request succeeded with no data. */
+    empty(props: AsyncStateSlotProps): unknown;
+    /** Shown when the request failed and there is no data to keep showing. */
+    error(props: AsyncStateSlotProps): unknown;
+    /** Shown before anything has been asked for. */
+    idle(props: AsyncStateSlotProps): unknown;
+    /** Laid over the content while it reloads with `soft-loading`. */
+    overlay(props: AsyncStateSlotProps): unknown;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/async-state/AsyncState.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,88 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { dataAttrs } from "../../shared/data-attrs.js";
+import Appear_default from "../appear/Appear.js";
+import { computed, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, useAttrs, withCtx } from "vue";
+//#region src/components/async-state/AsyncState.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["data-view", "role"];
+function resolveAsyncView(status, hasData, softLoading) {
+	if (hasData) {
+		const pending = status === "pending";
+		return {
+			view: pending && !softLoading ? "pending" : "content",
+			refreshing: pending && softLoading
+		};
+	}
+	return {
+		view: {
+			pending: "pending",
+			error: "error",
+			success: "empty",
+			idle: "idle"
+		}[status],
+		refreshing: false
+	};
+}
+function present(data) {
+	if (data === null || data === void 0) return false;
+	if (Array.isArray(data)) return data.length > 0;
+	if (data instanceof Map || data instanceof Set) return data.size > 0;
+	if (Object.getPrototypeOf(data) === Object.prototype) return Object.keys(data).length > 0;
+	return true;
+}
+var AsyncState_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AsyncState",
+	inheritAttrs: false,
+	__name: "AsyncState",
+	props: {
+		status: {},
+		data: {},
+		hasData: {
+			type: Boolean,
+			default: void 0
+		},
+		softLoading: { type: Boolean },
+		as: { default: "section" }
+	},
+	setup(__props) {
+		const props = __props;
+		const resolved = computed(() => resolveAsyncView(props.status, props.hasData ?? present(props.data), props.softLoading));
+		const state = computed(() => ({
+			status: props.status,
+			view: resolved.value.view,
+			refreshing: resolved.value.refreshing
+		}));
+		const ROLES = {
+			pending: "status",
+			empty: "status",
+			error: "alert"
+		};
+		const attrs = useAttrs();
+		const merged = computed(() => mergeProps$1({
+			"data-part": "async-state",
+			...dataAttrs(state.value),
+			"aria-busy": props.status === "pending" || void 0
+		}, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, merged.value), {
+				default: withCtx(() => [state.value.view === "content" ? renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(state.value)), void 0, void 0, 0) : _ctx.$slots[state.value.view] ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					"data-part": "async-state-message",
+					"data-view": state.value.view,
+					role: ROLES[state.value.view]
+				}, [renderSlot(_ctx.$slots, state.value.view, normalizeProps(guardReactiveProps(state.value)))], 8, _hoisted_1)) : createCommentVNode("", true), createVNode(Appear_default, {
+					open: state.value.refreshing,
+					appear: false,
+					"data-part": "async-state-overlay",
+					"aria-hidden": "true"
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "overlay", normalizeProps(guardReactiveProps(state.value)))]),
+					_: 3
+				}, 8, ["open"])]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { AsyncState_vue_vue_type_script_setup_true_lang_default as default, resolveAsyncView };

package/dist/components/badge/Badge.js

@@ -0,0 +1,5 @@
+import Badge_vue_vue_type_script_setup_true_lang_default from "./Badge.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/badge/Badge.vue
+var Badge_default = Badge_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Badge_default as default };

package/dist/components/badge/Badge.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    /** 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;
+    };
+};

package/dist/components/badge/Badge.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,23 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { computed, createBlock, defineComponent, mergeProps, openBlock, renderSlot, unref, useAttrs, withCtx } from "vue";
+//#region src/components/badge/Badge.vue?vue&type=script&setup=true&lang.ts
+var Badge_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "Badge",
+	inheritAttrs: false,
+	__name: "Badge",
+	props: { as: { default: "span" } },
+	setup(__props) {
+		const props = __props;
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1({ "data-part": "badge" }, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { Badge_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/button/Button.js

@@ -0,0 +1,5 @@
+import Button_vue_vue_type_script_setup_true_lang_default from "./Button.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/button/Button.vue
+var Button_default = Button_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { Button_default as default };

package/dist/components/button/Button.vue.d.ts

@@ -0,0 +1,28 @@
+type __VLS_Props = {
+    /** Blocks clicks and removes the button from the tab order. */
+    disabled?: boolean;
+    /** Native `type`. The `button` default keeps it from submitting a form. */
+    type?: 'button' | 'submit' | 'reset';
+    /** Keeps a disabled button focusable, using `aria-disabled` instead of `disabled`. */
+    focusableWhenDisabled?: boolean;
+    /** Element or component to render. Anything but a native button gets `role="button"` and Enter/Space keys. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("./use-button").UseButtonReturn, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    type: "button" | "submit" | "reset";
+    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/button/Button.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,50 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { useButton } from "./use-button.js";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, useAttrs, withCtx } from "vue";
+//#region src/components/button/Button.vue?vue&type=script&setup=true&lang.ts
+var Button_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "Button",
+	inheritAttrs: false,
+	__name: "Button",
+	props: {
+		disabled: { type: Boolean },
+		type: { default: "button" },
+		focusableWhenDisabled: { type: Boolean },
+		as: { default: "button" }
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const attrs = useAttrs();
+		const navigates = computed(() => attrs.href !== void 0 || attrs.to !== void 0 || props.as === "a");
+		const inertLink = computed(() => Boolean(props.disabled) && navigates.value);
+		const dynamicTag = computed(() => {
+			if (inertLink.value) return null;
+			return props.as && props.as !== "button" ? props.as : null;
+		});
+		const api = useButton({
+			disabled: () => props.disabled,
+			type: () => props.type,
+			native: () => dynamicTag.value === null,
+			link: () => navigates.value && !inertLink.value,
+			focusableWhenDisabled: () => props.focusableWhenDisabled
+		});
+		__expose(api);
+		const merged = computed(() => {
+			const next = mergeProps$1(api.rootProps.value, attrs);
+			if (inertLink.value) {
+				delete next.href;
+				delete next.to;
+			}
+			return next;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: dynamicTag.value ?? "button" }, merged.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value)))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { Button_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/button/use-button.d.ts

@@ -0,0 +1,20 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+export interface ButtonState {
+    disabled: boolean;
+}
+export interface UseButtonOptions {
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    /** Only ever set on a real `<button>`. @default 'button' */
+    type?: MaybeRefOrGetter<'button' | 'submit' | 'reset' | undefined>;
+    /** Whether a real `<button>` is being rendered. @default true */
+    native?: MaybeRefOrGetter<boolean | undefined>;
+    /** Whether the element navigates. @default false */
+    link?: MaybeRefOrGetter<boolean | undefined>;
+    /** Keep a disabled button in the tab order. @default false */
+    focusableWhenDisabled?: MaybeRefOrGetter<boolean | undefined>;
+}
+export interface UseButtonReturn {
+    state: ComputedRef<ButtonState>;
+    rootProps: ComputedRef<Record<string, unknown>>;
+}
+export declare function useButton(options?: UseButtonOptions): UseButtonReturn;

package/dist/components/button/use-button.js

@@ -0,0 +1,47 @@
+import { dataAttrs } from "../../shared/data-attrs.js";
+import { dispatchClickWithModifiers } from "../../shared/dispatch-click-with-modifiers.js";
+import { computed, toValue } from "vue";
+//#region src/components/button/use-button.ts
+function useButton(options = {}) {
+	const disabled = () => toValue(options.disabled) ?? false;
+	const native = () => toValue(options.native) ?? true;
+	const link = () => toValue(options.link) ?? false;
+	const focusableWhenDisabled = () => toValue(options.focusableWhenDisabled) ?? false;
+	const state = computed(() => ({ disabled: disabled() }));
+	const hooks = computed(() => dataAttrs(state.value));
+	const needsKeyboard = () => !native() && !link();
+	return {
+		state,
+		rootProps: computed(() => ({
+			"data-part": "button",
+			...hooks.value,
+			type: native() ? toValue(options.type) ?? "button" : void 0,
+			disabled: native() && !focusableWhenDisabled() ? disabled() || void 0 : void 0,
+			"aria-disabled": disabled() && (!native() || focusableWhenDisabled()) ? "true" : void 0,
+			role: needsKeyboard() ? "button" : void 0,
+			tabindex: needsKeyboard() ? disabled() && !focusableWhenDisabled() ? -1 : 0 : void 0,
+			onClickCapture(event) {
+				if (disabled()) {
+					event.preventDefault();
+					event.stopImmediatePropagation();
+				}
+			},
+			onKeydown(event) {
+				if (disabled() || !needsKeyboard()) return;
+				if (event.key === "Enter") {
+					event.preventDefault();
+					dispatchClickWithModifiers(event.currentTarget, event, { bubbles: true });
+					return;
+				}
+				if (event.key === " ") event.preventDefault();
+			},
+			onKeyup(event) {
+				if (disabled() || !needsKeyboard() || event.key !== " ") return;
+				event.preventDefault();
+				dispatchClickWithModifiers(event.currentTarget, event, { bubbles: true });
+			}
+		}))
+	};
+}
+//#endregion
+export { useButton };

package/dist/components/calendar/CalendarDay.js

@@ -0,0 +1,5 @@
+import CalendarDay_vue_vue_type_script_setup_true_lang_default from "./CalendarDay.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/calendar/CalendarDay.vue
+var CalendarDay_default = CalendarDay_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { CalendarDay_default as default };

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

@@ -0,0 +1,33 @@
+type __VLS_Props = {
+    /** The day it stands for. Without it, it renders every day of its `CalendarWeek`. */
+    value?: Date;
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_7: {
+    date: Date;
+    selected: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    inRange: boolean;
+    preview: boolean;
+    outside: boolean;
+    today: boolean;
+    weekend: boolean;
+    disabled: boolean;
+    highlighted: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => 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/calendar/CalendarDay.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,36 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { useCalendarContext } from "./use-calendar.js";
+import { useCalendarWeek } from "./CalendarWeek.vue_vue_type_script_setup_true_lang.js";
+import { Fragment, computed, createBlock, createElementBlock, createTextVNode, defineComponent, mergeProps, openBlock, renderList, renderSlot, toDisplayString, unref, useAttrs, withCtx } from "vue";
+//#region src/components/calendar/CalendarDay.vue?vue&type=script&setup=true&lang.ts
+var CalendarDay_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "CalendarDay",
+	inheritAttrs: false,
+	__name: "CalendarDay",
+	props: {
+		value: {},
+		as: { default: "button" }
+	},
+	setup(__props) {
+		const props = __props;
+		const calendar = useCalendarContext();
+		const week = useCalendarWeek();
+		const attrs = useAttrs();
+		if (process.env.NODE_ENV !== "production" && props.value === void 0 && !week) console.warn("[CalendarDay] Without a `value` it renders the days of its `CalendarWeek`, and it is not inside one.");
+		const dates = computed(() => props.value ? [props.value] : week?.() ?? []);
+		return (_ctx, _cache) => {
+			return openBlock(true), createElementBlock(Fragment, null, renderList(dates.value, (date) => {
+				return openBlock(), createBlock(unref(Part), mergeProps({
+					as: props.as,
+					key: date.getTime()
+				}, { ref_for: true }, unref(mergeProps$1)(unref(calendar).getDayProps(date), unref(attrs))), {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "default", mergeProps({ ref_for: true }, unref(calendar).getDayState(date)), () => [createTextVNode(toDisplayString(date.getDate()), 1)])]),
+					_: 2
+				}, 1040, ["as"]);
+			}), 128);
+		};
+	}
+});
+//#endregion
+export { CalendarDay_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/calendar/CalendarGrid.js

@@ -0,0 +1,5 @@
+import CalendarGrid_vue_vue_type_script_setup_true_lang_default from "./CalendarGrid.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/calendar/CalendarGrid.vue
+var CalendarGrid_default = CalendarGrid_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { CalendarGrid_default as default };