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

package/dist/components/popover/PopoverDescription.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 { usePopoverContext } from "./use-popover.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/popover/PopoverDescription.vue?vue&type=script&setup=true&lang.ts
+var PopoverDescription_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "PopoverDescription",
+	inheritAttrs: false,
+	__name: "PopoverDescription",
+	props: { as: { default: "p" } },
+	setup(__props) {
+		const props = __props;
+		const { state, registerDescription } = usePopoverContext();
+		const id = useRegisteredId(registerDescription);
+		const merged = usePartProps(() => ({
+			"data-part": "description",
+			id: id.value
+		}));
+		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 { PopoverDescription_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/popover/PopoverRoot.js

@@ -0,0 +1,5 @@
+import PopoverRoot_vue_vue_type_script_setup_true_lang_default from "./PopoverRoot.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/popover/PopoverRoot.vue
+var PopoverRoot_default = PopoverRoot_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { PopoverRoot_default as default };

package/dist/components/popover/PopoverRoot.vue.d.ts

@@ -0,0 +1,75 @@
+import { type PopoverState } from './use-popover';
+import type { Align, Side } from '../../shared/use-positioning';
+type __VLS_Props = {
+    /** Whether the popover is open, bound with `v-model:open`. */
+    open?: boolean;
+    /** Opens at first, when no `v-model:open` owns it. */
+    defaultOpen?: boolean;
+    /** Which side of the trigger the popover prefers. */
+    side?: Side;
+    /** How the popover lines up along that side. */
+    align?: Align;
+    /** The gap between the trigger and the popover, in pixels. */
+    sideOffset?: number;
+    /** A shift along the side, in pixels. */
+    alignOffset?: number;
+    /** The least room kept from the viewport's edges, in pixels. */
+    collisionPadding?: number;
+    /** Sides to try, in order, when the preferred one does not fit. */
+    fallbackSides?: Side[];
+    /** Allow dropping to the perpendicular axis as a last resort. @default true */
+    fallbackAxis?: boolean;
+    /** Stay anchored and slide instead of flipping. */
+    sticky?: boolean;
+    /** `true` traps focus, locks scroll and makes the page inert; `'trap-focus'` only traps focus. */
+    modal?: boolean | 'trap-focus';
+    /** Closes on Escape. */
+    escapeKey?: boolean;
+    /** Closes on a press outside the popover and its trigger. */
+    outsidePress?: boolean;
+    /** Moves focus into the popover when it opens, and back to the trigger when it closes. */
+    autoFocus?: boolean;
+    /** Also opens while a mouse rests on the trigger, and stays open while it is on the popover. A tap still opens it. */
+    openOnHover?: boolean;
+    /** With `open-on-hover`: how long the mouse rests on the trigger before it opens, in milliseconds. @default 200 */
+    delay?: number;
+    /** With `open-on-hover`: how long after the mouse leaves before it closes, in milliseconds. @default 150 */
+    closeDelay?: number;
+};
+type __VLS_Slots = {
+    /**
+     * The popover's state.
+     * @slotOnly The root renders no element of its own: the trigger and the popup carry these as attributes.
+     */
+    default(props: PopoverState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("./use-popover").UsePopoverReturn, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (open: boolean) => any;
+    "update:open": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((open: boolean) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+    sticky: boolean;
+    side: Side;
+    open: boolean;
+    align: Align;
+    defaultOpen: boolean;
+    modal: boolean | "trap-focus";
+    escapeKey: boolean;
+    outsidePress: boolean;
+    autoFocus: boolean;
+    sideOffset: number;
+    alignOffset: number;
+    collisionPadding: number;
+    fallbackSides: Side[];
+    fallbackAxis: 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/popover/PopoverRoot.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,85 @@
+import { providePopoverContext, usePopover } from "./use-popover.js";
+import { defineComponent, guardReactiveProps, normalizeProps, renderSlot, toRef, unref } from "vue";
+//#region src/components/popover/PopoverRoot.vue?vue&type=script&setup=true&lang.ts
+var PopoverRoot_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "PopoverRoot",
+	__name: "PopoverRoot",
+	props: {
+		open: {
+			type: Boolean,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			default: false
+		},
+		side: { default: "bottom" },
+		align: { default: "center" },
+		sideOffset: { default: 8 },
+		alignOffset: { default: 0 },
+		collisionPadding: { default: 8 },
+		fallbackSides: { default: void 0 },
+		fallbackAxis: {
+			type: Boolean,
+			default: void 0
+		},
+		sticky: {
+			type: Boolean,
+			default: void 0
+		},
+		modal: {
+			type: [Boolean, String],
+			default: false
+		},
+		escapeKey: {
+			type: Boolean,
+			default: true
+		},
+		outsidePress: {
+			type: Boolean,
+			default: true
+		},
+		autoFocus: {
+			type: Boolean,
+			default: true
+		},
+		openOnHover: { type: Boolean },
+		delay: {},
+		closeDelay: {}
+	},
+	emits: ["update:open", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const api = usePopover({
+			open: toRef(() => props.open),
+			defaultOpen: toRef(() => props.defaultOpen),
+			side: toRef(() => props.side),
+			align: toRef(() => props.align),
+			sideOffset: toRef(() => props.sideOffset),
+			alignOffset: toRef(() => props.alignOffset),
+			collisionPadding: toRef(() => props.collisionPadding),
+			fallbackSides: toRef(() => props.fallbackSides),
+			fallbackAxis: toRef(() => props.fallbackAxis),
+			sticky: toRef(() => props.sticky),
+			modal: toRef(() => props.modal),
+			escapeKey: toRef(() => props.escapeKey),
+			outsidePress: toRef(() => props.outsidePress),
+			autoFocus: toRef(() => props.autoFocus),
+			openOnHover: toRef(() => props.openOnHover),
+			delay: toRef(() => props.delay),
+			closeDelay: toRef(() => props.closeDelay),
+			onChange: (open) => {
+				emit("update:open", open);
+				emit("change", open);
+			}
+		});
+		providePopoverContext(api);
+		__expose(api);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value)));
+		};
+	}
+});
+//#endregion
+export { PopoverRoot_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/popover/PopoverTitle.js

@@ -0,0 +1,5 @@
+import PopoverTitle_vue_vue_type_script_setup_true_lang_default from "./PopoverTitle.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/popover/PopoverTitle.vue
+var PopoverTitle_default = PopoverTitle_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { PopoverTitle_default as default };

package/dist/components/popover/PopoverTitle.vue.d.ts

@@ -0,0 +1,23 @@
+import { type PopoverState } from './use-popover';
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    /**
+     * The popover's state.
+     * @slotOnly The element carries only `data-part="title"` and the id the popup is labeled by.
+     */
+    default(props: PopoverState): 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/popover/PopoverTitle.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 { usePopoverContext } from "./use-popover.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/popover/PopoverTitle.vue?vue&type=script&setup=true&lang.ts
+var PopoverTitle_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "PopoverTitle",
+	inheritAttrs: false,
+	__name: "PopoverTitle",
+	props: { as: { default: "h2" } },
+	setup(__props) {
+		const props = __props;
+		const { state, registerTitle } = usePopoverContext();
+		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", normalizeProps(guardReactiveProps(unref(state))))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { PopoverTitle_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/popover/PopoverTrigger.js

@@ -0,0 +1,5 @@
+import PopoverTrigger_vue_vue_type_script_setup_true_lang_default from "./PopoverTrigger.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/popover/PopoverTrigger.vue
+var PopoverTrigger_default = PopoverTrigger_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { PopoverTrigger_default as default };

package/dist/components/popover/PopoverTrigger.vue.d.ts

@@ -0,0 +1,24 @@
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    open: 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/popover/PopoverTrigger.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 { usePopoverContext } from "./use-popover.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/popover/PopoverTrigger.vue?vue&type=script&setup=true&lang.ts
+var PopoverTrigger_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "PopoverTrigger",
+	inheritAttrs: false,
+	__name: "PopoverTrigger",
+	props: { as: { default: "button" } },
+	setup(__props) {
+		const props = __props;
+		const { triggerProps, state } = usePopoverContext();
+		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 { PopoverTrigger_vue_vue_type_script_setup_true_lang_default as default };

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

@@ -0,0 +1,60 @@
+import { type ComputedRef, type MaybeRefOrGetter, type Ref, type WritableComputedRef } from 'vue';
+import { type RegisterId } from '../../shared/labeling';
+import { type TransitionStatus } from '../../shared/use-transition-status';
+import { type Align, type Side, type UsePositioningOptions } from '../../shared/use-positioning';
+export interface PopoverState {
+    /**
+     * Whether the popover is open.
+     * @attribute `data-open` while open, `data-closed` otherwise
+     */
+    open: boolean;
+    /**
+     * The side of the trigger the popover ended up on.
+     * @attribute `data-side="…"`
+     */
+    side: Side;
+    /**
+     * How the popover lines up along that side.
+     * @attribute `data-align="…"`
+     */
+    align: Align;
+    /**
+     * Where the popover is in its enter or exit animation.
+     * @attribute `data-enter-from` as it enters, `data-leave-to` as it leaves
+     */
+    transitionStatus: TransitionStatus;
+}
+export interface UsePopoverOptions extends UsePositioningOptions {
+    open?: MaybeRefOrGetter<boolean | undefined>;
+    defaultOpen?: MaybeRefOrGetter<boolean | undefined>;
+    /** `true` also locks scroll and makes the page inert; `'trap-focus'` only traps focus. */
+    modal?: MaybeRefOrGetter<boolean | 'trap-focus' | undefined>;
+    /** Close when Escape is pressed. */
+    escapeKey?: MaybeRefOrGetter<boolean | undefined>;
+    /** Close on a press outside the popup. */
+    outsidePress?: MaybeRefOrGetter<boolean | undefined>;
+    /** Move focus into the popup when it opens. */
+    autoFocus?: MaybeRefOrGetter<boolean | undefined>;
+    /** Also open while a mouse rests on the trigger, staying open while it is on the popup. A tap still opens it. */
+    openOnHover?: MaybeRefOrGetter<boolean | undefined>;
+    /** With `openOnHover`: how long the mouse rests on the trigger before it opens, in milliseconds. @default 200 */
+    delay?: MaybeRefOrGetter<number | undefined>;
+    /** With `openOnHover`: how long after the mouse leaves before it closes, time to cross to the popup. @default 150 */
+    closeDelay?: MaybeRefOrGetter<number | undefined>;
+    onChange?: (open: boolean) => void;
+}
+export interface UsePopoverReturn {
+    open: WritableComputedRef<boolean>;
+    state: ComputedRef<PopoverState>;
+    present: Ref<boolean>;
+    triggerProps: ComputedRef<Record<string, unknown>>;
+    positionerProps: ComputedRef<Record<string, unknown>>;
+    popupProps: ComputedRef<Record<string, unknown>>;
+    arrowProps: ComputedRef<Record<string, unknown>>;
+    closeProps: ComputedRef<Record<string, unknown>>;
+    registerTitle: RegisterId;
+    registerDescription: RegisterId;
+    anchorRef: Ref<HTMLElement | null>;
+}
+export declare function usePopover(options?: UsePopoverOptions): UsePopoverReturn;
+export declare const providePopoverContext: (value: UsePopoverReturn) => UsePopoverReturn, usePopoverContext: () => UsePopoverReturn;

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

@@ -0,0 +1,160 @@
+import { dataAttrs } from "../../shared/data-attrs.js";
+import { useControlled } from "../../shared/use-controlled.js";
+import { createContext } from "../../shared/context.js";
+import { anchoredStateAttrs } from "../../shared/popup-state-attrs.js";
+import { useTransitionStatus } from "../../shared/use-transition-status.js";
+import { useExitAnimation } from "../../shared/use-exit-animation.js";
+import { useLabeling } from "../../shared/labeling.js";
+import { provideSurface } from "../../shared/surface.js";
+import { usePositioning } from "../../shared/use-positioning.js";
+import { useDismiss } from "../../shared/use-dismiss.js";
+import { useFocusTrap } from "../../shared/use-focus-trap.js";
+import { useScrollLock } from "../../shared/use-scroll-lock.js";
+import { useInertBackground } from "../../shared/use-inert-background.js";
+import { elementOf } from "../../shared/element-of.js";
+import { computed, onScopeDispose, ref, toValue, useId, watch } from "vue";
+//#region src/components/popover/use-popover.ts
+function usePopover(options = {}) {
+	const triggerId = useId();
+	const popupId = useId();
+	const { titleId, descriptionId, registerTitle, registerDescription } = useLabeling();
+	const open = useControlled({
+		value: () => toValue(options.open),
+		defaultValue: () => toValue(options.defaultOpen) ?? false,
+		onChange: options.onChange,
+		prop: "open",
+		empty: false,
+		name: "usePopover",
+		label: "open"
+	});
+	const { mounted, transitionStatus, setMounted } = useTransitionStatus(() => open.value);
+	const positioning = usePositioning({
+		...options,
+		enabled: () => mounted.value
+	});
+	const triggerEl = positioning.anchorRef;
+	const popupEl = positioning.popupRef;
+	const surfaceEl = ref(null);
+	const state = computed(() => ({
+		open: open.value,
+		side: positioning.renderedSide.value,
+		align: positioning.renderedAlign.value,
+		transitionStatus: transitionStatus.value
+	}));
+	const hooks = computed(() => dataAttrs(state.value, { ...anchoredStateAttrs }));
+	const modal = () => toValue(options.modal) ?? false;
+	const isModal = () => modal() === true;
+	useDismiss({
+		enabled: () => mounted.value,
+		elements: () => [popupEl.value, triggerEl.value],
+		escapeKey: () => toValue(options.escapeKey) ?? true,
+		outsidePress: () => toValue(options.outsidePress) ?? true,
+		onDismiss: () => {
+			open.value = false;
+		}
+	});
+	const byHover = ref(false);
+	let hoverTimer;
+	const clearHoverTimer = () => clearTimeout(hoverTimer);
+	const hovers = (event) => (toValue(options.openOnHover) ?? false) && event.pointerType !== "touch";
+	function onHoverEnter(event) {
+		if (!hovers(event)) return;
+		clearHoverTimer();
+		if (open.value) return;
+		hoverTimer = setTimeout(() => {
+			byHover.value = true;
+			open.value = true;
+		}, toValue(options.delay) ?? 200);
+	}
+	function onHoverLeave(event) {
+		if (!hovers(event)) return;
+		clearHoverTimer();
+		if (!open.value || !byHover.value) return;
+		hoverTimer = setTimeout(() => {
+			open.value = false;
+		}, toValue(options.closeDelay) ?? 150);
+	}
+	watch(open, (isOpen) => {
+		if (!isOpen) byHover.value = false;
+	});
+	onScopeDispose(clearHoverTimer);
+	useFocusTrap({
+		enabled: () => open.value,
+		container: surfaceEl,
+		ready: () => positioning.isPositioned.value,
+		modal: () => modal() !== false,
+		autoFocus: () => (toValue(options.autoFocus) ?? true) && !byHover.value,
+		returnFocus: true,
+		returnFallback: () => triggerEl.value
+	});
+	useScrollLock(() => mounted.value && isModal());
+	useInertBackground(() => open.value && isModal(), surfaceEl);
+	useExitAnimation({
+		open: () => open.value,
+		mounted,
+		setMounted,
+		element: surfaceEl
+	});
+	const triggerProps = computed(() => ({
+		...hooks.value,
+		"data-part": "trigger",
+		id: triggerId,
+		type: "button",
+		"aria-haspopup": "dialog",
+		"aria-expanded": open.value,
+		"aria-controls": mounted.value ? popupId : void 0,
+		ref: (el) => {
+			triggerEl.value = elementOf(el);
+		},
+		onClick() {
+			clearHoverTimer();
+			if (open.value && byHover.value) byHover.value = false;
+			else open.value = !open.value;
+		},
+		onPointerenter: onHoverEnter,
+		onPointerleave: onHoverLeave
+	}));
+	const popupProps = computed(() => ({
+		...hooks.value,
+		id: popupId,
+		role: "dialog",
+		"aria-modal": isModal() || void 0,
+		"aria-labelledby": titleId.value,
+		"aria-describedby": descriptionId.value,
+		ref: (el) => {
+			surfaceEl.value = el ?? null;
+		},
+		onPointerenter: (event) => hovers(event) && clearHoverTimer(),
+		onPointerleave: onHoverLeave
+	}));
+	const closeProps = computed(() => ({
+		"data-part": "close",
+		type: "button",
+		onClick() {
+			open.value = false;
+		}
+	}));
+	provideSurface({
+		present: mounted,
+		state,
+		popupProps,
+		positionerProps: positioning.positionerProps,
+		arrowProps: positioning.arrowProps
+	});
+	return {
+		open,
+		state,
+		present: mounted,
+		triggerProps,
+		positionerProps: positioning.positionerProps,
+		popupProps,
+		arrowProps: positioning.arrowProps,
+		closeProps,
+		registerTitle,
+		registerDescription,
+		anchorRef: triggerEl
+	};
+}
+var { provideContext: providePopoverContext, useContext: usePopoverContext } = createContext("Popover");
+//#endregion
+export { providePopoverContext, usePopover, usePopoverContext };

package/dist/components/progress/ProgressIndicator.js

@@ -0,0 +1,5 @@
+import ProgressIndicator_vue_vue_type_script_setup_true_lang_default from "./ProgressIndicator.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/progress/ProgressIndicator.vue
+var ProgressIndicator_default = ProgressIndicator_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ProgressIndicator_default as default };

package/dist/components/progress/ProgressIndicator.vue.d.ts

@@ -0,0 +1,22 @@
+import { type GaugeState } from '../../shared/use-gauge';
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    /**
+     * @slotOnly The element carries only `data-status`; it draws from the root's CSS variables.
+     */
+    default(props: GaugeState): 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/progress/ProgressIndicator.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 { useGaugeContext } from "../../shared/use-gauge.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/progress/ProgressIndicator.vue?vue&type=script&setup=true&lang.ts
+var ProgressIndicator_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ProgressIndicator",
+	inheritAttrs: false,
+	__name: "ProgressIndicator",
+	props: { as: { default: "div" } },
+	setup(__props) {
+		const props = __props;
+		const { indicatorProps, state } = useGaugeContext();
+		const merged = usePartProps(indicatorProps);
+		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 { ProgressIndicator_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/progress/ProgressLabel.js

@@ -0,0 +1,5 @@
+import ProgressLabel_vue_vue_type_script_setup_true_lang_default from "./ProgressLabel.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/progress/ProgressLabel.vue
+var ProgressLabel_default = ProgressLabel_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ProgressLabel_default as default };

package/dist/components/progress/ProgressLabel.vue.d.ts

@@ -0,0 +1,22 @@
+import { type GaugeState } from '../../shared/use-gauge';
+type __VLS_Props = {
+    /** The id the progress is labeled by. Generated when not given. */
+    id?: string;
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    /** @slotOnly The element carries only the id the progress is labeled by. */
+    default(props: GaugeState): 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/progress/ProgressLabel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,34 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { useGaugeContext } from "../../shared/use-gauge.js";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, onBeforeUnmount, openBlock, renderSlot, unref, useAttrs, useId, withCtx } from "vue";
+//#region src/components/progress/ProgressLabel.vue?vue&type=script&setup=true&lang.ts
+var ProgressLabel_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ProgressLabel",
+	inheritAttrs: false,
+	__name: "ProgressLabel",
+	props: {
+		id: {},
+		as: { default: "span" }
+	},
+	setup(__props) {
+		const props = __props;
+		const { registerLabel, state } = useGaugeContext();
+		const generatedId = useId();
+		const id = props.id ?? generatedId;
+		onBeforeUnmount(registerLabel(id));
+		const attrs = useAttrs();
+		const merged = computed(() => mergeProps$1({
+			"data-part": "label",
+			id
+		}, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, merged.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(state))))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { ProgressLabel_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/progress/ProgressRoot.js

@@ -0,0 +1,5 @@
+import ProgressRoot_vue_vue_type_script_setup_true_lang_default from "./ProgressRoot.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/progress/ProgressRoot.vue
+var ProgressRoot_default = ProgressRoot_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ProgressRoot_default as default };