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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Denis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,86 @@
-# Temporary Holding Version
+# @vunset/vue
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Headless, unstyled Vue 3 components. They already work: keyboard, focus,
+ARIA, open and close, the fiddly parts. What they look like is up to you.
+Nothing ships with styles, so there's nothing to override.
+
+If you'd rather start from something styled, see
+[`@vunset/ui`](https://www.npmjs.com/package/@vunset/ui), which is built on this
+package.
+
+## Install
+
+```sh
+npm install @vunset/vue
+```
+
+Using Nuxt? Install [`@vunset/nuxt`](https://www.npmjs.com/package/@vunset/nuxt)
+instead: it registers every component for you.
+
+## Usage
+
+Each component comes in parts: a root that holds the state, and the pieces
+inside it.
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue';
+import { SwitchRoot, SwitchThumb } from '@vunset/vue';
+
+const enabled = ref(false);
+</script>
+
+<template>
+  <label>
+    <SwitchRoot v-model="enabled" native class="switch">
+      <SwitchThumb class="switch-thumb" />
+    </SwitchRoot>
+    Notifications
+  </label>
+</template>
+```
+
+Every part reports its state through `data-*` attributes, so you style it with
+plain CSS, or as Tailwind variants:
+
+```css
+.switch[data-checked] {
+  background: #16a34a;
+}
+```
+
+```vue
+<SwitchRoot class="w-10 rounded-full bg-gray-200 data-checked:bg-green-600" />
+```
+
+Every part takes an `as` prop for the element it renders: a tag, or a component
+of your own.
+
+## Charts and data tables
+
+These have their own entry points, because they need a library you may not want
+in every app. Install it only if you use them:
+
+```sh
+npm install @tanstack/charts       # for @vunset/vue/chart
+npm install @tanstack/vue-table    # for @vunset/vue/data-table
+```
+
+```ts
+import { ChartArea } from '@vunset/vue/chart';
+import { DataTable } from '@vunset/vue/data-table';
+```
+
+## Helpers
+
+`@vunset/vue` re-exports everything in
+[`@vunset/utils`](https://www.npmjs.com/package/@vunset/utils), so
+`formatDate`, `formatNumber` and the rest import from here too.
+
+## Documentation
+
+[vunset.com/get-started](https://vunset.com/get-started)
+
+## License
+
+MIT

package/dist/chart.d.ts

@@ -0,0 +1,11 @@
+export { default as ChartRoot, type ChartCurve, type ChartSide, type ChartTooltipSeries, type ChartTooltipSlotProps } from './components/chart/ChartRoot.vue';
+export { default as ChartArea } from './components/chart/ChartArea.vue';
+export { default as ChartLine } from './components/chart/ChartLine.vue';
+export { default as ChartBar } from './components/chart/ChartBar.vue';
+export { default as ChartAxis } from './components/chart/ChartAxis.vue';
+export { default as ChartGrid } from './components/chart/ChartGrid.vue';
+export { default as ChartCrosshair } from './components/chart/ChartCrosshair.vue';
+export { default as ChartTooltip } from './components/chart/ChartTooltip.vue';
+export { default as ChartLegend } from './components/chart/ChartLegend.vue';
+export { default as ChartDonut } from './components/chart/ChartDonut.vue';
+export { type ChartSeries } from './components/chart/use-chart-series';

package/dist/chart.js

@@ -0,0 +1,11 @@
+import ChartRoot_default from "./components/chart/ChartRoot.js";
+import ChartArea_default from "./components/chart/ChartArea.js";
+import ChartLine_default from "./components/chart/ChartLine.js";
+import ChartBar_default from "./components/chart/ChartBar.js";
+import ChartAxis_default from "./components/chart/ChartAxis.js";
+import ChartGrid_default from "./components/chart/ChartGrid.js";
+import ChartCrosshair_default from "./components/chart/ChartCrosshair.js";
+import ChartTooltip_default from "./components/chart/ChartTooltip.js";
+import ChartLegend_default from "./components/chart/ChartLegend.js";
+import ChartDonut_default from "./components/chart/ChartDonut.js";
+export { ChartArea_default as ChartArea, ChartAxis_default as ChartAxis, ChartBar_default as ChartBar, ChartCrosshair_default as ChartCrosshair, ChartDonut_default as ChartDonut, ChartGrid_default as ChartGrid, ChartLegend_default as ChartLegend, ChartLine_default as ChartLine, ChartRoot_default as ChartRoot, ChartTooltip_default as ChartTooltip };

package/dist/components/accordion/AccordionHeader.js

@@ -0,0 +1,5 @@
+import AccordionHeader_vue_vue_type_script_setup_true_lang_default from "./AccordionHeader.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/accordion/AccordionHeader.vue
+var AccordionHeader_default = AccordionHeader_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AccordionHeader_default as default };

package/dist/components/accordion/AccordionHeader.vue.d.ts

@@ -0,0 +1,23 @@
+type __VLS_Props = {
+    /** Element or component to render: a heading at the page's level, `h3` by default. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    open: boolean;
+    disabled: boolean;
+    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/accordion/AccordionHeader.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,27 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useCollapsibleContext } from "../../shared/use-collapsible.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/accordion/AccordionHeader.vue?vue&type=script&setup=true&lang.ts
+var AccordionHeader_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AccordionHeader",
+	inheritAttrs: false,
+	__name: "AccordionHeader",
+	props: { as: { default: "h3" } },
+	setup(__props) {
+		const props = __props;
+		const { rootProps, state } = useCollapsibleContext();
+		const merged = usePartProps(() => ({
+			...rootProps.value,
+			"data-part": "accordion-header"
+		}));
+		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 { AccordionHeader_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/accordion/AccordionItem.js

@@ -0,0 +1,5 @@
+import AccordionItem_vue_vue_type_script_setup_true_lang_default from "./AccordionItem.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/accordion/AccordionItem.vue
+var AccordionItem_default = AccordionItem_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AccordionItem_default as default };

package/dist/components/accordion/AccordionItem.vue.d.ts

@@ -0,0 +1,28 @@
+import { type AccordionValue } from './use-accordion';
+type __VLS_Props = {
+    /** Names the item in the root's value. Generated when not given. */
+    value?: AccordionValue;
+    /** Keeps this item's trigger from opening or closing it; arrow keys skip it. */
+    disabled?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    open: boolean;
+    disabled: boolean;
+    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/accordion/AccordionItem.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,33 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { provideCollapsibleContext } from "../../shared/use-collapsible.js";
+import { useAccordionItem } from "./use-accordion.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, toRef, unref, withCtx } from "vue";
+//#region src/components/accordion/AccordionItem.vue?vue&type=script&setup=true&lang.ts
+var AccordionItem_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AccordionItem",
+	inheritAttrs: false,
+	__name: "AccordionItem",
+	props: {
+		value: {},
+		disabled: { type: Boolean },
+		as: { default: "div" }
+	},
+	setup(__props) {
+		const props = __props;
+		const api = useAccordionItem({
+			value: toRef(() => props.value),
+			disabled: toRef(() => props.disabled)
+		});
+		provideCollapsibleContext(api);
+		const merged = usePartProps(api.rootProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value)))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { AccordionItem_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/accordion/AccordionRoot.js

@@ -0,0 +1,5 @@
+import AccordionRoot_vue_vue_type_script_setup_true_lang_default from "./AccordionRoot.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/accordion/AccordionRoot.vue
+var AccordionRoot_default = AccordionRoot_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AccordionRoot_default as default };

package/dist/components/accordion/AccordionRoot.vue.d.ts

@@ -0,0 +1,48 @@
+import type { Orientation } from '../../shared/use-roving-focus';
+import { type AccordionValue } from './use-accordion';
+type __VLS_Props = {
+    /** The open items' values, bound with `v-model`. Always an array. */
+    modelValue?: AccordionValue[];
+    /** The open items at first, when no `v-model` owns them. */
+    defaultValue?: AccordionValue[];
+    /** Let more than one item be open at a time. Otherwise opening one closes the others. */
+    multiple?: boolean;
+    /** Disables every item. */
+    disabled?: boolean;
+    /** Which arrow keys move between the triggers: Up/Down, or Left/Right for a horizontal one. */
+    orientation?: Orientation;
+    /** Whether arrow keys wrap past the first and last trigger. */
+    loop?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    disabled: boolean;
+    orientation: Orientation;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("./use-accordion").UseAccordionReturn, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: AccordionValue[]) => any;
+    "update:modelValue": (value: AccordionValue[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((value: AccordionValue[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: AccordionValue[]) => any) | undefined;
+}>, {
+    defaultValue: AccordionValue[];
+    orientation: Orientation;
+    as: string | object;
+    modelValue: AccordionValue[];
+    disabled: boolean;
+    loop: boolean;
+    multiple: 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/accordion/AccordionRoot.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,57 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { provideAccordionContext, useAccordion } from "./use-accordion.js";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, toRef, unref, useAttrs, withCtx } from "vue";
+//#region src/components/accordion/AccordionRoot.vue?vue&type=script&setup=true&lang.ts
+var AccordionRoot_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AccordionRoot",
+	inheritAttrs: false,
+	__name: "AccordionRoot",
+	props: {
+		modelValue: { default: void 0 },
+		defaultValue: { default: void 0 },
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		orientation: { default: "vertical" },
+		loop: {
+			type: Boolean,
+			default: true
+		},
+		as: { default: "div" }
+	},
+	emits: ["update:modelValue", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const api = useAccordion({
+			value: toRef(() => props.modelValue),
+			defaultValue: toRef(() => props.defaultValue),
+			multiple: toRef(() => props.multiple),
+			disabled: toRef(() => props.disabled),
+			orientation: toRef(() => props.orientation),
+			loop: toRef(() => props.loop),
+			onChange: (value) => {
+				emit("update:modelValue", value);
+				emit("change", value);
+			}
+		});
+		provideAccordionContext(api);
+		__expose(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)))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { AccordionRoot_vue_vue_type_script_setup_true_lang_default as default };

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

@@ -0,0 +1,43 @@
+import { type ComputedRef, type MaybeRefOrGetter, type WritableComputedRef } from 'vue';
+import { useRovingItems } from '../../shared/use-roving-items';
+import { type UseCollapsibleReturn } from '../../shared/use-collapsible';
+import type { Orientation } from '../../shared/use-roving-focus';
+export type AccordionValue = string | number;
+export interface AccordionState {
+    /** Whether every item ignores interaction. */
+    disabled: boolean;
+    /** Which arrow keys move between the triggers. */
+    orientation: Orientation;
+}
+export interface UseAccordionOptions {
+    /** The open items. Supplying this makes the value controlled. */
+    value?: MaybeRefOrGetter<AccordionValue[] | undefined>;
+    defaultValue?: MaybeRefOrGetter<AccordionValue[] | undefined>;
+    /** Let more than one item be open at a time. @default false */
+    multiple?: MaybeRefOrGetter<boolean | undefined>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    /** Which arrow keys move between triggers. @default 'vertical' */
+    orientation?: MaybeRefOrGetter<Orientation | undefined>;
+    /** @default true */
+    loop?: MaybeRefOrGetter<boolean | undefined>;
+    onChange?: (value: AccordionValue[]) => void;
+}
+export interface UseAccordionReturn {
+    value: WritableComputedRef<AccordionValue[]>;
+    state: ComputedRef<AccordionState>;
+    rootProps: ComputedRef<Record<string, unknown>>;
+    isOpen: (item: AccordionValue) => boolean;
+    setOpen: (item: AccordionValue, open: boolean) => void;
+    /** @internal */ disabled: () => boolean;
+    /** @internal */ registry: ReturnType<typeof useRovingItems<AccordionValue>>;
+    /** @internal */ onTriggerKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useAccordion(options?: UseAccordionOptions): UseAccordionReturn;
+export declare const provideAccordionContext: (value: UseAccordionReturn) => UseAccordionReturn, useAccordionContext: () => UseAccordionReturn;
+export interface UseAccordionItemOptions {
+    /** Identifies the item in the root's value. Generated when omitted. */
+    value?: MaybeRefOrGetter<AccordionValue | undefined>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+}
+/** One item: a collapsible whose open state belongs to the accordion. */
+export declare function useAccordionItem(options?: UseAccordionItemOptions): UseCollapsibleReturn;

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

@@ -0,0 +1,126 @@
+import { dataAttrs } from "../../shared/data-attrs.js";
+import { useControlled } from "../../shared/use-controlled.js";
+import { createContext } from "../../shared/context.js";
+import { useCollapsible } from "../../shared/use-collapsible.js";
+import { useRovingItems } from "../../shared/use-roving-items.js";
+import { computed, onScopeDispose, ref, toValue, useId, watch } from "vue";
+//#region src/components/accordion/use-accordion.ts
+function useAccordion(options = {}) {
+	const multiple = () => toValue(options.multiple) ?? false;
+	const disabled = () => toValue(options.disabled) ?? false;
+	const orientation = () => toValue(options.orientation) ?? "vertical";
+	const loop = () => toValue(options.loop) ?? true;
+	const value = useControlled({
+		value: () => toValue(options.value),
+		defaultValue: () => toValue(options.defaultValue) ?? [],
+		onChange: options.onChange,
+		prop: "modelValue",
+		empty: () => [],
+		name: "useAccordion",
+		label: "value"
+	});
+	const registry = useRovingItems();
+	const isOpen = (item) => value.value.includes(item);
+	function setOpen(item, open) {
+		if (open === isOpen(item)) return;
+		if (!open) value.value = value.value.filter((entry) => entry !== item);
+		else value.value = multiple() ? [...value.value, item] : [item];
+	}
+	function onTriggerKeydown(event) {
+		const vertical = orientation() === "vertical";
+		const triggers = registry.ordered.value.filter((item) => !item.disabled && item.element).map((item) => item.element);
+		const current = triggers.indexOf(event.currentTarget);
+		if (current === -1) return;
+		let next;
+		switch (event.key) {
+			case vertical ? "ArrowDown" : "ArrowRight":
+				next = current + 1;
+				break;
+			case vertical ? "ArrowUp" : "ArrowLeft":
+				next = current - 1;
+				break;
+			case "Home":
+				next = 0;
+				break;
+			case "End":
+				next = triggers.length - 1;
+				break;
+			default: return;
+		}
+		event.preventDefault();
+		if (loop()) next = (next + triggers.length) % triggers.length;
+		triggers[Math.min(Math.max(next, 0), triggers.length - 1)].focus();
+	}
+	const state = computed(() => ({
+		disabled: disabled(),
+		orientation: orientation()
+	}));
+	return {
+		value,
+		state,
+		rootProps: computed(() => ({
+			...dataAttrs(state.value),
+			"data-part": "accordion"
+		})),
+		isOpen,
+		setOpen,
+		disabled,
+		registry,
+		onTriggerKeydown
+	};
+}
+var { provideContext: provideAccordionContext, useContext: useAccordionContext } = createContext("Accordion");
+/** One item: a collapsible whose open state belongs to the accordion. */
+function useAccordionItem(options = {}) {
+	const accordion = useAccordionContext();
+	const generatedValue = useId();
+	const triggerId = useId();
+	const trigger = ref(null);
+	const value = computed(() => toValue(options.value) ?? generatedValue);
+	const disabled = computed(() => accordion.disabled() || (toValue(options.disabled) ?? false));
+	const collapsible = useCollapsible({
+		open: () => accordion.isOpen(value.value),
+		onChange: (open) => accordion.setOpen(value.value, open),
+		disabled
+	});
+	watch([
+		value,
+		disabled,
+		trigger
+	], ([current, isDisabled, element]) => {
+		accordion.registry.register({
+			id: triggerId,
+			value: current,
+			disabled: isDisabled,
+			element
+		});
+	}, { immediate: true });
+	onScopeDispose(() => accordion.registry.unregister(triggerId));
+	const triggerProps = computed(() => ({
+		...collapsible.triggerProps.value,
+		"data-part": "accordion-trigger",
+		id: triggerId,
+		ref: (el) => {
+			trigger.value = el ?? null;
+		},
+		onKeydown: accordion.onTriggerKeydown
+	}));
+	const panelProps = computed(() => ({
+		...collapsible.panelProps.value,
+		"data-part": "accordion-panel",
+		role: "region",
+		"aria-labelledby": triggerId
+	}));
+	const rootProps = computed(() => ({
+		...collapsible.rootProps.value,
+		"data-part": "accordion-item"
+	}));
+	return {
+		...collapsible,
+		rootProps,
+		triggerProps,
+		panelProps
+	};
+}
+//#endregion
+export { provideAccordionContext, useAccordion, useAccordionContext, useAccordionItem };

package/dist/components/alert/AlertDescription.js

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

package/dist/components/alert/AlertDescription.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/AlertDescription.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/AlertDescription.vue?vue&type=script&setup=true&lang.ts
+var AlertDescription_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AlertDescription",
+	inheritAttrs: false,
+	__name: "AlertDescription",
+	props: { as: { default: "div" } },
+	setup(__props) {
+		const props = __props;
+		const { registerDescription } = useAlertContext();
+		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")]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { AlertDescription_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/alert/AlertRoot.js

@@ -0,0 +1,5 @@
+import AlertRoot_vue_vue_type_script_setup_true_lang_default, { provideContext, useAlertContext } from "./AlertRoot.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/alert/AlertRoot.vue
+var AlertRoot_default = AlertRoot_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { AlertRoot_default as default, provideContext, useAlertContext };

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

@@ -0,0 +1,24 @@
+import type { RegisterId } from '../../shared/labeling';
+export interface AlertContext {
+    registerTitle: RegisterId;
+    registerDescription: RegisterId;
+}
+export declare const provideContext: (value: AlertContext) => AlertContext, useAlertContext: () => AlertContext;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    /** Element or component to render. */
+    as?: string | object;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    /** Element or component to render. */
+    as?: string | object;
+}> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};