@quidgest/ui 0.17.9 → 0.19.0

package/esm/components/QSidebar/QSidebarAnchor.d.ts

@@ -1,215 +1,29 @@
-import { QSidebarAnchorProps } from '.';
-import { nextTick } from 'vue';
-type __VLS_Props = QSidebarAnchorProps;
-type __VLS_PublicProps = {
+import { SidebarItemRegistration } from './context';
+/** Internal props for the anchor strip (not part of the public package API). */
+type QSidebarAnchorProps = {
+    /**
+     * Width of the anchor section in pixels.
+     *
+     * @category Presentation
+     */
+    anchorWidth?: number;
+    /**
+     * Currently active sidebar item value.
+     *
+     * @category State
+     */
     modelValue?: string;
-} & __VLS_Props;
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: Partial<Record<string, (_: {
-        item: import('./types').QSidebarAnchorItemConfig;
-    }) => any>>;
-    refs: {
-        itemRefs: (({
-            $: import('vue').ComponentInternalInstance;
-            $data: {};
-            $props: {
-                readonly modelValue?: boolean | undefined;
-                readonly id?: string | undefined;
-                readonly class?: string | unknown[] | undefined;
-                readonly label?: string | undefined;
-                readonly variant?: import('..').QButtonVariant | undefined;
-                readonly color?: string | undefined;
-                readonly borderless?: boolean | undefined;
-                readonly elevated?: boolean | undefined;
-                readonly block?: boolean | undefined;
-                readonly size?: import('..').QButtonSize | undefined;
-                readonly iconPos?: import('..').QButtonIconPosition | undefined;
-                readonly pill?: boolean | undefined;
-                readonly disabled?: boolean | undefined;
-                readonly loading?: boolean | undefined;
-                readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-            $attrs: import('vue').Attrs;
-            $refs: {
-                [x: string]: unknown;
-            };
-            $slots: Readonly<{
-                [name: string]: import('vue').Slot<any> | undefined;
-            }>;
-            $root: import('vue').ComponentPublicInstance | null;
-            $parent: import('vue').ComponentPublicInstance | null;
-            $host: Element | null;
-            $emit: (event: "update:modelValue", value: boolean) => void;
-            $el: HTMLButtonElement;
-            $options: import('vue').ComponentOptionsBase<Readonly<{
-                modelValue?: boolean;
-            } & import('../../types/component').QBaseComponentProps & {
-                label?: string;
-                variant?: import('..').QButtonVariant;
-                color?: string;
-                borderless?: boolean;
-                elevated?: boolean;
-                block?: boolean;
-                size?: import('..').QButtonSize;
-                iconPos?: import('..').QButtonIconPosition;
-                pill?: boolean;
-                disabled?: boolean;
-                loading?: boolean;
-            }> & Readonly<{
-                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-                "update:modelValue": (value: boolean) => any;
-            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-                beforeCreate?: (() => void) | (() => void)[];
-                created?: (() => void) | (() => void)[];
-                beforeMount?: (() => void) | (() => void)[];
-                mounted?: (() => void) | (() => void)[];
-                beforeUpdate?: (() => void) | (() => void)[];
-                updated?: (() => void) | (() => void)[];
-                activated?: (() => void) | (() => void)[];
-                deactivated?: (() => void) | (() => void)[];
-                beforeDestroy?: (() => void) | (() => void)[];
-                beforeUnmount?: (() => void) | (() => void)[];
-                destroyed?: (() => void) | (() => void)[];
-                unmounted?: (() => void) | (() => void)[];
-                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-            };
-            $forceUpdate: () => void;
-            $nextTick: typeof nextTick;
-            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-        } & Readonly<{}> & Omit<Readonly<{
-            modelValue?: boolean;
-        } & import('../../types/component').QBaseComponentProps & {
-            label?: string;
-            variant?: import('..').QButtonVariant;
-            color?: string;
-            borderless?: boolean;
-            elevated?: boolean;
-            block?: boolean;
-            size?: import('..').QButtonSize;
-            iconPos?: import('..').QButtonIconPosition;
-            pill?: boolean;
-            disabled?: boolean;
-            loading?: boolean;
-        }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-        }>, never> & {} & import('vue').ComponentCustomProperties & {} & {
-            $slots: {
-                default?(_: {}): any;
-            };
-        }) | null)[];
-    };
-    rootEl: HTMLDivElement;
+    /**
+     * Registered sidebar items used to position the active indicator.
+     *
+     * @category Configuration
+     */
+    items: SidebarItemRegistration[];
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
-} & {
-    "click:item": (id: string) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    "onClick:item"?: ((id: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    itemRefs: (({
-        $: import('vue').ComponentInternalInstance;
-        $data: {};
-        $props: {
-            readonly modelValue?: boolean | undefined;
-            readonly id?: string | undefined;
-            readonly class?: string | unknown[] | undefined;
-            readonly label?: string | undefined;
-            readonly variant?: import('..').QButtonVariant | undefined;
-            readonly color?: string | undefined;
-            readonly borderless?: boolean | undefined;
-            readonly elevated?: boolean | undefined;
-            readonly block?: boolean | undefined;
-            readonly size?: import('..').QButtonSize | undefined;
-            readonly iconPos?: import('..').QButtonIconPosition | undefined;
-            readonly pill?: boolean | undefined;
-            readonly disabled?: boolean | undefined;
-            readonly loading?: boolean | undefined;
-            readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
-        $attrs: import('vue').Attrs;
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import('vue').Slot<any> | undefined;
-        }>;
-        $root: import('vue').ComponentPublicInstance | null;
-        $parent: import('vue').ComponentPublicInstance | null;
-        $host: Element | null;
-        $emit: (event: "update:modelValue", value: boolean) => void;
-        $el: HTMLButtonElement;
-        $options: import('vue').ComponentOptionsBase<Readonly<{
-            modelValue?: boolean;
-        } & import('../../types/component').QBaseComponentProps & {
-            label?: string;
-            variant?: import('..').QButtonVariant;
-            color?: string;
-            borderless?: boolean;
-            elevated?: boolean;
-            block?: boolean;
-            size?: import('..').QButtonSize;
-            iconPos?: import('..').QButtonIconPosition;
-            pill?: boolean;
-            disabled?: boolean;
-            loading?: boolean;
-        }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-            "update:modelValue": (value: boolean) => any;
-        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
-            beforeCreate?: (() => void) | (() => void)[];
-            created?: (() => void) | (() => void)[];
-            beforeMount?: (() => void) | (() => void)[];
-            mounted?: (() => void) | (() => void)[];
-            beforeUpdate?: (() => void) | (() => void)[];
-            updated?: (() => void) | (() => void)[];
-            activated?: (() => void) | (() => void)[];
-            deactivated?: (() => void) | (() => void)[];
-            beforeDestroy?: (() => void) | (() => void)[];
-            beforeUnmount?: (() => void) | (() => void)[];
-            destroyed?: (() => void) | (() => void)[];
-            unmounted?: (() => void) | (() => void)[];
-            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
-            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
-    } & Readonly<{}> & Omit<Readonly<{
-        modelValue?: boolean;
-    } & import('../../types/component').QBaseComponentProps & {
-        label?: string;
-        variant?: import('..').QButtonVariant;
-        color?: string;
-        borderless?: boolean;
-        elevated?: boolean;
-        block?: boolean;
-        size?: import('..').QButtonSize;
-        iconPos?: import('..').QButtonIconPosition;
-        pill?: boolean;
-        disabled?: boolean;
-        loading?: boolean;
-    }> & Readonly<{
-        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    }>, never> & {} & import('vue').ComponentCustomProperties & {} & {
-        $slots: {
-            default?(_: {}): any;
-        };
-    }) | null)[];
+declare const _default: import('vue').DefineComponent<QSidebarAnchorProps, {
+    itemsEl: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<QSidebarAnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    items: HTMLDivElement;
 }, HTMLDivElement>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
 //# sourceMappingURL=QSidebarAnchor.vue.d.ts.map

package/esm/components/QSidebar/QSidebarAnchor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QSidebarAnchor.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QSidebar/QSidebarAnchor.vue"],"names":[],"mappings":"AA8BA;AA+HC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,GAAG,CAAA;AAG5C,OAAO,EAAE,QAAQ,EAAc,MAAM,KAAK,CAAA;AAE1C,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAmFxC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAoFT,OAAO,IAA6B;;;UAZoC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAyD+qgB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;EAxC73gB;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAwBmvgB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;kBAf53gB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"QSidebarAnchor.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QSidebar/QSidebarAnchor.vue"],"names":[],"mappings":"AAaA;AAyIC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAA;AAKxD,gFAAgF;AAChF,KAAK,mBAAmB,GAAG;IAC1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;OAIG;IACH,KAAK,EAAE,uBAAuB,EAAE,CAAA;CAChC,CAAA;;;;;;AAgJF,wBASG"}

package/esm/components/QSidebar/QSidebarAnchor.vue.js

@@ -1,80 +1,68 @@
-import { QIcon as e } from "../QIcon/index.js";
-import { QToggle as t } from "../QToggle/index.js";
-import { Fragment as n, createBlock as r, createCommentVNode as i, createElementBlock as a, createElementVNode as o, defineComponent as s, mergeModels as c, mergeProps as l, nextTick as u, normalizeStyle as d, openBlock as f, ref as p, renderList as m, renderSlot as h, unref as g, useModel as _, watch as v, withCtx as y } from "vue";
+import { computed as e, createElementBlock as t, createElementVNode as n, defineComponent as r, nextTick as i, normalizeStyle as a, openBlock as o, ref as s, useTemplateRef as c, watch as l } from "vue";
 //#region src/components/QSidebar/QSidebarAnchor.vue?vue&type=script&setup=true&lang.ts
-var b = { class: "q-sidebar__items" }, x = /*@__PURE__*/ s({
+var u = {
+	ref: "items",
+	class: "q-sidebar__items"
+}, d = /*@__PURE__*/ r({
 	__name: "QSidebarAnchor",
-	props: /*@__PURE__*/ c({
-		panels: {},
+	props: {
 		anchorWidth: {},
-		showLabels: { type: Boolean }
-	}, {
 		modelValue: {},
-		modelModifiers: {}
-	}),
-	emits: /*@__PURE__*/ c(["click:item"], ["update:modelValue"]),
-	setup(s, { emit: c }) {
-		let x = s, S = c, C = _(s, "modelValue"), w = p({
+		items: {}
+	},
+	setup(r, { expose: d }) {
+		let f = r;
+		d({ itemsEl: c("items") });
+		let p = e(() => {
+			if (f.anchorWidth !== void 0) return { width: `${f.anchorWidth}px` };
+		}), m = s({
 			height: "0",
 			transform: "translateY(0)",
 			opacity: "0",
 			transition: "transform 0.3s ease, height 0.3s ease, opacity 0.2s ease"
-		}), T = p([]);
-		function E(e) {
-			C.value = C.value === e ? void 0 : e, S("click:item", e);
+		});
+		function h(e) {
+			let t = e.anchorRef.value;
+			return t ? "$el" in t ? t.$el : t : null;
 		}
-		function D() {
-			if (!C.value) {
-				w.value = {
-					...w.value,
-					opacity: "0",
-					height: "0"
-				};
+		function g() {
+			m.value = {
+				...m.value,
+				opacity: "0",
+				height: "0"
+			};
+		}
+		function _() {
+			if (!f.modelValue) {
+				g();
+				return;
+			}
+			let e = f.items.findIndex((e) => e.value === f.modelValue);
+			if (e === -1) {
+				g();
+				return;
+			}
+			let t = h(f.items[e]);
+			if (!t) {
+				g();
 				return;
 			}
-			let e = x.panels?.findIndex((e) => e.id === C.value) ?? -1;
-			if (e === -1 || !T.value[e]) return;
-			let t = T.value[e].$el || T.value[e];
-			if (!t) return;
-			let n = e === T.value.length - 1 ? t.offsetHeight : t.offsetHeight - 1, r = t.offsetTop;
-			w.value = {
-				...w.value,
+			let n = e === f.items.length - 1 ? t.offsetHeight : t.offsetHeight - 1, r = t.offsetTop;
+			m.value = {
+				...m.value,
 				height: `${n}px`,
 				transform: `translateY(${r}px)`,
 				opacity: "1"
 			};
 		}
-		return v(C, () => u(D), { immediate: !0 }), (c, u) => (f(), a("div", {
+		return l(() => [f.modelValue, f.items.length], () => i(_), { immediate: !0 }), (e, r) => (o(), t("div", {
 			class: "q-sidebar-anchor",
-			style: d({ width: x.anchorWidth + "px" })
-		}, [o("div", b, [o("div", {
+			style: a(p.value)
+		}, [n("div", u, [n("div", {
 			class: "q-sidebar__indicator",
-			style: d(w.value)
-		}, null, 4), (f(!0), a(n, null, m(s.panels, (n) => (f(), r(g(t), {
-			key: n.id,
-			ref_for: !0,
-			ref_key: "itemRefs",
-			ref: T,
-			"data-testid": "q-sidebar-panel-button",
-			"model-value": C.value === n.id,
-			label: x.showLabels ? n.title : void 0,
-			title: x.showLabels ? void 0 : n.title,
-			"icon-pos": "top",
-			class: "q-sidebar__item",
-			onClick: () => E(n.id)
-		}, {
-			default: y(() => [h(c.$slots, n.id, { item: n }, () => [n.icon ? (f(), r(g(e), l({
-				key: 0,
-				ref_for: !0
-			}, n.icon), null, 16)) : i("v-if", !0)])]),
-			_: 2
-		}, 1032, [
-			"model-value",
-			"label",
-			"title",
-			"onClick"
-		]))), 128))])], 4));
+			style: a(m.value)
+		}, null, 4)], 512)], 4));
 	}
 });
 //#endregion
-export { x as default };
+export { d as default };

package/esm/components/QSidebar/QSidebarItem.d.ts

@@ -0,0 +1,213 @@
+import { QSidebarItemProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        anchor?(_: {}): any;
+        'header.prepend'?(_: {}): any;
+        header?(_: {}): any;
+        'header.append'?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        anchor: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: boolean | undefined;
+                readonly id?: string | undefined;
+                readonly class?: string | unknown[] | undefined;
+                readonly label?: string | undefined;
+                readonly variant?: import('..').QButtonVariant | undefined;
+                readonly color?: string | undefined;
+                readonly borderless?: boolean | undefined;
+                readonly elevated?: boolean | undefined;
+                readonly block?: boolean | undefined;
+                readonly size?: import('..').QButtonSize | undefined;
+                readonly iconPos?: import('..').QButtonIconPosition | undefined;
+                readonly pill?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly loading?: boolean | undefined;
+                readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "update:modelValue", value: boolean) => void;
+            $el: HTMLButtonElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                modelValue?: boolean;
+            } & import('../../types/component').QBaseComponentProps & {
+                label?: string;
+                variant?: import('..').QButtonVariant;
+                color?: string;
+                borderless?: boolean;
+                elevated?: boolean;
+                block?: boolean;
+                size?: import('..').QButtonSize;
+                iconPos?: import('..').QButtonIconPosition;
+                pill?: boolean;
+                disabled?: boolean;
+                loading?: boolean;
+            }> & Readonly<{
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (value: boolean) => any;
+            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<{
+            modelValue?: boolean;
+        } & import('../../types/component').QBaseComponentProps & {
+            label?: string;
+            variant?: import('..').QButtonVariant;
+            color?: string;
+            borderless?: boolean;
+            elevated?: boolean;
+            block?: boolean;
+            size?: import('..').QButtonSize;
+            iconPos?: import('..').QButtonIconPosition;
+            pill?: boolean;
+            disabled?: boolean;
+            loading?: boolean;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        }>, never> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<QSidebarItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<QSidebarItemProps> & Readonly<{}>, {
+    showGrip: boolean;
+    initialWidth: import('./types').QSidebarPanelSize;
+    minWidth: import('./types').QSidebarPanelSize;
+    maxWidth: import('./types').QSidebarPanelSize;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    anchor: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: boolean | undefined;
+            readonly id?: string | undefined;
+            readonly class?: string | unknown[] | undefined;
+            readonly label?: string | undefined;
+            readonly variant?: import('..').QButtonVariant | undefined;
+            readonly color?: string | undefined;
+            readonly borderless?: boolean | undefined;
+            readonly elevated?: boolean | undefined;
+            readonly block?: boolean | undefined;
+            readonly size?: import('..').QButtonSize | undefined;
+            readonly iconPos?: import('..').QButtonIconPosition | undefined;
+            readonly pill?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly loading?: boolean | undefined;
+            readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "update:modelValue", value: boolean) => void;
+        $el: HTMLButtonElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: boolean;
+        } & import('../../types/component').QBaseComponentProps & {
+            label?: string;
+            variant?: import('..').QButtonVariant;
+            color?: string;
+            borderless?: boolean;
+            elevated?: boolean;
+            block?: boolean;
+            size?: import('..').QButtonSize;
+            iconPos?: import('..').QButtonIconPosition;
+            pill?: boolean;
+            disabled?: boolean;
+            loading?: boolean;
+        }> & Readonly<{
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (value: boolean) => any;
+        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<{
+        modelValue?: boolean;
+    } & import('../../types/component').QBaseComponentProps & {
+        label?: string;
+        variant?: import('..').QButtonVariant;
+        color?: string;
+        borderless?: boolean;
+        elevated?: boolean;
+        block?: boolean;
+        size?: import('..').QButtonSize;
+        iconPos?: import('..').QButtonIconPosition;
+        pill?: boolean;
+        disabled?: boolean;
+        loading?: boolean;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, never> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=QSidebarItem.vue.d.ts.map

package/esm/components/QSidebar/QSidebarItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QSidebarItem.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QSidebar/QSidebarItem.vue"],"names":[],"mappings":"AAkEA;AAiLC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgGjD,iBAAS,cAAc;WAiMT,OAAO,IAA6B;;wBAhBrB,GAAG;kCACO,GAAG;wBACb,GAAG;iCACM,GAAG;yBACX,GAAG;wBACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmEi2S,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;EAnDt/S;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6B42S,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;OArBr/S,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}