ropav 0.3.1 → 0.5.0

package/dist/components/sidebar/sidebar-collapsible-trigger.js

@@ -0,0 +1,70 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { dataAttr } from "../../utils/assertion.js";
+import { useInteractionStates } from "../../composables/use-interaction-states.js";
+import { useSidebarCollapsibleContext, useSidebarContext } from "./sidebar.context.js";
+import { computed, createSlot, defineVaporComponent, on, renderEffect, setAttr, setClass, setInsertionState, setProp, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-collapsible-trigger.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<button data-slot=sidebar-collapsible-trigger type=button>", 1);
+var sidebar_collapsible_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-collapsible-trigger",
+	props: {
+		class: {},
+		isDisabled: {
+			type: Boolean,
+			default: void 0
+		},
+		ariaLabel: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		const collapsible = useSidebarCollapsibleContext();
+		const isDisabled = computed(() => Boolean(props.isDisabled) || collapsible.isDisabled.value);
+		const interaction = useInteractionStates({ isDisabled });
+		const tabindex = computed(() => isDisabled.value ? void 0 : 0);
+		const isControlling = computed(() => !state.isCollapsed.value);
+		const className = computed(() => composeSlotClassName(slots.value.item, props.class));
+		const n1 = t0();
+		renderEffect(() => {
+			const _collapsible = unref(collapsible);
+			const _isControlling = isControlling.value;
+			const _dataAttr = unref(dataAttr);
+			const _isDisabled = isDisabled.value;
+			const _interaction = unref(interaction);
+			const _collapsible_isExpanded = _collapsible.isExpanded;
+			setProp(n1, "id", _collapsible.triggerId.value);
+			setAttr(n1, "aria-controls", _isControlling ? _collapsible.subMenuId.value : void 0);
+			setAttr(n1, "aria-expanded", _isControlling ? _collapsible_isExpanded.value : void 0);
+			setAttr(n1, "aria-label", props.ariaLabel);
+			setClass(n1, className.value);
+			setAttr(n1, "data-collapsed", _dataAttr(unref(state).isCollapsed.value));
+			setAttr(n1, "data-disabled", _dataAttr(_isDisabled));
+			setAttr(n1, "data-expanded", _dataAttr(_collapsible_isExpanded.value));
+			setAttr(n1, "data-focus-visible", _dataAttr(_interaction.isFocusVisible.value));
+			setAttr(n1, "data-focused", _dataAttr(_interaction.isFocused.value));
+			setAttr(n1, "data-hovered", _dataAttr(_interaction.isHovered.value));
+			setAttr(n1, "data-pressed", _dataAttr(_interaction.isPressed.value));
+			setProp(n1, "disabled", _isDisabled || void 0);
+			setProp(n1, "tabindex", tabindex.value);
+		});
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isDisabled: () => isDisabled.value,
+			isExpanded: () => unref(collapsible).isExpanded.value,
+			isFocusVisible: () => unref(interaction).isFocusVisible.value,
+			isFocused: () => unref(interaction).isFocused.value,
+			isHovered: () => unref(interaction).isHovered.value,
+			isPressed: () => unref(interaction).isPressed.value
+		});
+		on(n1, "blur", (e) => unref(interaction).onBlur(e));
+		on(n1, "click", (e) => unref(collapsible).toggle(e));
+		on(n1, "focus", (e) => unref(interaction).onFocus(e));
+		on(n1, "pointerdown", (e) => unref(interaction).onPointerdown(e));
+		on(n1, "pointerenter", (e) => unref(interaction).onPointerenter(e));
+		on(n1, "pointerleave", (e) => unref(interaction).onPointerleave(e));
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_collapsible_trigger_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-collapsible.d.ts

@@ -0,0 +1,24 @@
+import type { SidebarCollapsibleProps, SidebarCollapsibleSlotProps } from "./sidebar.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<SidebarCollapsibleProps & {
+        onExpandedChange?: ((isExpanded: boolean) => any) | undefined;
+        "onUpdate:isExpanded"?: ((isExpanded: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarCollapsibleSlotProps) => unknown;
+    };
+    emit: ((evt: "expandedChange", isExpanded: boolean) => void) & ((evt: "update:isExpanded", isExpanded: boolean) => 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/sidebar/sidebar-collapsible.js

@@ -0,0 +1,78 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { dataAttr } from "../../utils/assertion.js";
+import { useId as useId$1 } from "../../composables/use-id.js";
+import { useControllableState } from "../../composables/use-controllable-state.js";
+import { provideSidebarCollapsibleContext, useSidebarContext } from "./sidebar.context.js";
+import { computed, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-collapsible.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=sidebar-collapsible>", 1);
+var sidebar_collapsible_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-collapsible",
+	props: {
+		class: {},
+		isExpanded: {
+			type: Boolean,
+			default: void 0
+		},
+		defaultExpanded: {
+			type: Boolean,
+			default: void 0
+		},
+		isDisabled: {
+			type: Boolean,
+			default: void 0
+		}
+	},
+	emits: ["expandedChange", "update:isExpanded"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { slots, state } = useSidebarContext();
+		const id = useId$1();
+		const triggerId = computed(() => `${id.value}-trigger`);
+		const subMenuId = computed(() => `${id.value}-submenu`);
+		const isDisabled = computed(() => Boolean(props.isDisabled));
+		const { setState, state: expanded } = useControllableState({
+			defaultValue: props.defaultExpanded ?? false,
+			onValueChange: (isExpanded) => {
+				emit("update:isExpanded", isExpanded);
+				emit("expandedChange", isExpanded);
+			},
+			value: () => props.isExpanded
+		});
+		const isExpanded = computed(() => !state.isCollapsed.value && expanded.value);
+		const toggle = () => {
+			if (isDisabled.value) return;
+			if (state.isCollapsed.value) {
+				state.open();
+				setState(true);
+				return;
+			}
+			setState(!expanded.value);
+		};
+		provideSidebarCollapsibleContext({
+			isDisabled,
+			isExpanded,
+			subMenuId,
+			toggle,
+			triggerId
+		});
+		const n1 = t0();
+		renderEffect(() => {
+			const _dataAttr = unref(dataAttr);
+			setClass(n1, unref(composeSlotClassName)(unref(slots).group, props.class));
+			setAttr(n1, "data-collapsed", _dataAttr(unref(state).isCollapsed.value));
+			setAttr(n1, "data-disabled", _dataAttr(isDisabled.value));
+			setAttr(n1, "data-expanded", _dataAttr(isExpanded.value));
+		});
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isDisabled: () => isDisabled.value,
+			isExpanded: () => isExpanded.value
+		});
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_collapsible_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-content.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarContentProps, SidebarPartSlotProps } from "./sidebar.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<SidebarContentProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-content.js

@@ -0,0 +1,37 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { provideSeparatorContext } from "../separator/separator.context.js";
+import scroll_shadow_root_default from "../scroll-shadow/scroll-shadow-root.js";
+import { useSidebarContext } from "./sidebar.context.js";
+import { computed, createComponent, createSlot, defineVaporComponent, extend, unref } from "vue";
+//#region src/components/sidebar/sidebar-content.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var sidebar_content_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-content",
+	props: {
+		class: {},
+		showScrollShadow: {
+			type: Boolean,
+			default: true
+		},
+		scrollShadowSize: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		provideSeparatorContext({ elementType: "div" });
+		const className = computed(() => composeSlotClassName(slots.value.content, props.class));
+		return createComponent(scroll_shadow_root_default, {
+			class: () => className.value,
+			"data-slot": "sidebar-content",
+			"is-enabled": () => props.showScrollShadow,
+			size: () => props.scrollShadowSize
+		}, extend(() => {
+			return createSlot("default", {
+				isCollapsed: () => unref(state).isCollapsed.value,
+				isMobile: () => unref(state).isMobile.value,
+				isOpen: () => unref(state).isOpen.value
+			}, null, 36);
+		}, { _: 8 }), true);
+	}
+});
+//#endregion
+export { sidebar_content_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-footer.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarFooterProps, SidebarPartSlotProps } from "./sidebar.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<SidebarFooterProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-footer.js

@@ -0,0 +1,24 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useSidebarContext } from "./sidebar.context.js";
+import { createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-footer.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=sidebar-footer>", 1);
+var sidebar_footer_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-footer",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		const n1 = t0();
+		renderEffect(() => setClass(n1, unref(composeSlotClassName)(unref(slots).footer, props.class)));
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isMobile: () => unref(state).isMobile.value,
+			isOpen: () => unref(state).isOpen.value
+		});
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_footer_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-group-label.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarGroupLabelProps, SidebarPartSlotProps } from "./sidebar.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<SidebarGroupLabelProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-group-label.js

@@ -0,0 +1,32 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { dataAttr } from "../../utils/assertion.js";
+import { useSidebarContext, useSidebarGroupContext } from "./sidebar.context.js";
+import { createSlot, defineVaporComponent, onScopeDispose, renderEffect, setAttr, setClass, setInsertionState, setProp, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-group-label.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=sidebar-group-label>", 1);
+var sidebar_group_label_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-group-label",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		const group = useSidebarGroupContext();
+		const unregister = group?.registerLabel();
+		onScopeDispose(() => unregister?.(), true);
+		const n1 = t0();
+		renderEffect(() => {
+			setProp(n1, "id", unref(group)?.labelId.value);
+			setClass(n1, unref(composeSlotClassName)(unref(slots).groupLabel, props.class));
+			setAttr(n1, "data-collapsed", unref(dataAttr)(unref(state).isCollapsed.value));
+		});
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isMobile: () => unref(state).isMobile.value,
+			isOpen: () => unref(state).isOpen.value
+		});
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_group_label_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-group.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarGroupProps, SidebarPartSlotProps } from "./sidebar.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<SidebarGroupProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-group.js

@@ -0,0 +1,48 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { dataAttr } from "../../utils/assertion.js";
+import { useId as useId$1 } from "../../composables/use-id.js";
+import { provideSidebarGroupContext, useSidebarContext } from "./sidebar.context.js";
+import { computed, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, shallowRef, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-group.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=sidebar-group role=group>", 1);
+var sidebar_group_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-group",
+	props: {
+		class: {},
+		ariaLabel: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		const labelId = useId$1();
+		const labels = shallowRef(0);
+		provideSidebarGroupContext({
+			labelId,
+			registerLabel: () => {
+				labels.value += 1;
+				return () => {
+					labels.value -= 1;
+				};
+			}
+		});
+		const labelledBy = computed(() => labels.value > 0 ? labelId.value : void 0);
+		const n1 = t0();
+		renderEffect(() => {
+			const _labelledBy = labelledBy.value;
+			const _props = props;
+			setAttr(n1, "aria-label", _labelledBy ? void 0 : _props.ariaLabel);
+			setAttr(n1, "aria-labelledby", _labelledBy);
+			setClass(n1, unref(composeSlotClassName)(unref(slots).group, _props.class));
+			setAttr(n1, "data-collapsed", unref(dataAttr)(unref(state).isCollapsed.value));
+		});
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isMobile: () => unref(state).isMobile.value,
+			isOpen: () => unref(state).isOpen.value
+		});
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_group_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-header.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarHeaderProps, SidebarPartSlotProps } from "./sidebar.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<SidebarHeaderProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-header.js

@@ -0,0 +1,24 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useSidebarContext } from "./sidebar.context.js";
+import { createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-header.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=sidebar-header>", 1);
+var sidebar_header_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-header",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		const n1 = t0();
+		renderEffect(() => setClass(n1, unref(composeSlotClassName)(unref(slots).header, props.class)));
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isMobile: () => unref(state).isMobile.value,
+			isOpen: () => unref(state).isOpen.value
+		});
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_header_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-inset.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarInsetProps, SidebarPartSlotProps } from "./sidebar.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<SidebarInsetProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-inset.js

@@ -0,0 +1,24 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useSidebarContext } from "./sidebar.context.js";
+import { createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-inset.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<div data-slot=sidebar-inset>", 1);
+var sidebar_inset_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-inset",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots, state } = useSidebarContext();
+		const n1 = t0();
+		renderEffect(() => setClass(n1, unref(composeSlotClassName)(unref(slots).inset, props.class)));
+		setInsertionState(n1);
+		createSlot("default", {
+			isCollapsed: () => unref(state).isCollapsed.value,
+			isMobile: () => unref(state).isMobile.value,
+			isOpen: () => unref(state).isOpen.value
+		});
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_inset_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-item-icon.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarItemIconProps } from "./sidebar.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<SidebarItemIconProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-item-icon.js

@@ -0,0 +1,20 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { useSidebarContext } from "./sidebar.context.js";
+import { createSlot, defineVaporComponent, renderEffect, setClass, setInsertionState, template, unref } from "vue";
+//#region src/components/sidebar/sidebar-item-icon.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span aria-hidden=true data-slot=sidebar-item-icon>", 1);
+var sidebar_item_icon_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-item-icon",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const { slots } = useSidebarContext();
+		const n1 = t0();
+		renderEffect(() => setClass(n1, unref(composeSlotClassName)(unref(slots).itemIcon, props.class)));
+		setInsertionState(n1);
+		createSlot();
+		return n1;
+	}
+});
+//#endregion
+export { sidebar_item_icon_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-item-indicator.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarItemIndicatorProps } from "./sidebar.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<SidebarItemIndicatorProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: {};
+}>) => 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/sidebar/sidebar-item-indicator.js

@@ -0,0 +1,48 @@
+import { composeSlotClassName } from "../../utils/compose.js";
+import { dataAttr } from "../../utils/assertion.js";
+import icon_chevron_down_default from "../icons/icon-chevron-down.js";
+import { useSidebarCollapsibleContext, useSidebarContext } from "./sidebar.context.js";
+import { computed, createComponent, createIf, createSlot, defineVaporComponent, renderEffect, setAttr, setClass, setInsertionState, template, unref, useSlots } from "vue";
+//#region src/components/sidebar/sidebar-item-indicator.vue?vue&type=script&setup=true&vapor=true&lang.ts
+var t0 = template("<span aria-hidden=true data-slot=sidebar-item-indicator>", 1);
+var sidebar_item_indicator_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PURE__*/ defineVaporComponent({
+	__name: "sidebar-item-indicator",
+	props: { class: {} },
+	setup(__props) {
+		const props = __props;
+		const iconSlots = useSlots();
+		const { slots, state } = useSidebarContext();
+		const collapsible = useSidebarCollapsibleContext();
+		/**
+		* With no icon of its own to render, the built-in chevron carries the class and the state directly,
+		* exactly as `disclosure-indicator.vue` does. That matters inside a button, where the stylesheet
+		* reaches icons through an `svg` selector: a wrapper element would not match it.
+		*
+		* A custom icon does need a wrapper. Reading a slot in Vapor renders it, so the icon cannot be
+		* inspected and handed the class the way React clones it into place.
+		*/
+		const hasCustomIcon = iconSlots.default !== void 0;
+		const className = computed(() => composeSlotClassName(slots.value.itemIndicator, props.class));
+		return createIf(() => hasCustomIcon, () => {
+			const n3 = t0();
+			renderEffect(() => {
+				const _dataAttr = unref(dataAttr);
+				setClass(n3, className.value);
+				setAttr(n3, "data-collapsed", _dataAttr(unref(state).isCollapsed.value));
+				setAttr(n3, "data-expanded", _dataAttr(unref(collapsible).isExpanded.value));
+			});
+			setInsertionState(n3);
+			createSlot();
+			return n3;
+		}, () => {
+			return createComponent(icon_chevron_down_default, {
+				class: () => className.value,
+				"data-collapsed": () => unref(dataAttr)(unref(state).isCollapsed.value),
+				"data-expanded": () => unref(dataAttr)(unref(collapsible).isExpanded.value),
+				"data-slot": "sidebar-item-indicator"
+			}, null, true);
+		}, 261);
+	}
+});
+//#endregion
+export { sidebar_item_indicator_vue_vue_type_script_setup_true_vapor_true_lang_default as default };

package/dist/components/sidebar/sidebar-item-label.d.ts

@@ -0,0 +1,21 @@
+import type { SidebarItemLabelProps, SidebarPartSlotProps } from "./sidebar.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<SidebarItemLabelProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: SidebarPartSlotProps) => unknown;
+    };
+    emit: {};
+}>) => 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];
+}) & {};