@quidgest/ui 0.17.9 → 0.18.0

package/esm/components/QTabs/QTab.d.ts

@@ -0,0 +1,172 @@
+import { DEFAULT_TEXTS } from './constants';
+import { QTabProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'title.prepend'?(_: {}): any;
+        'title.append'?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {
+        tabBtn: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                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 onClick?: ((event: Event) => 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: "click", event: Event) => void;
+            $el: HTMLButtonElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').QButtonProps> & Readonly<{
+                onClick?: ((event: Event) => any) | undefined;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+                click: (event: Event) => any;
+            }, string, {
+                size: import('..').QButtonSize;
+                variant: import('..').QButtonVariant;
+                color: string;
+                iconPos: import('..').QButtonIconPosition;
+            }, {}, 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<{
+            size: import('..').QButtonSize;
+            variant: import('..').QButtonVariant;
+            color: string;
+            iconPos: import('..').QButtonIconPosition;
+        }> & Omit<Readonly<import('..').QButtonProps> & Readonly<{
+            onClick?: ((event: Event) => any) | undefined;
+        }>, "size" | "variant" | "color" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+                append?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<QTabProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<QTabProps> & Readonly<{}>, {
+    texts: typeof DEFAULT_TEXTS;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    tabBtn: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            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 onClick?: ((event: Event) => 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: "click", event: Event) => void;
+        $el: HTMLButtonElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('..').QButtonProps> & Readonly<{
+            onClick?: ((event: Event) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            click: (event: Event) => any;
+        }, string, {
+            size: import('..').QButtonSize;
+            variant: import('..').QButtonVariant;
+            color: string;
+            iconPos: import('..').QButtonIconPosition;
+        }, {}, 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<{
+        size: import('..').QButtonSize;
+        variant: import('..').QButtonVariant;
+        color: string;
+        iconPos: import('..').QButtonIconPosition;
+    }> & Omit<Readonly<import('..').QButtonProps> & Readonly<{
+        onClick?: ((event: Event) => any) | undefined;
+    }>, "size" | "variant" | "color" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+            append?(_: {}): 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=QTab.vue.d.ts.map

package/esm/components/QTabs/QTab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QTab.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTab.vue"],"names":[],"mappings":"AAyCA;AAqMC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAW3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAiJzC,iBAAS,cAAc;WAoHT,OAAO,IAA6B;;iCAbZ,GAAG;gCACJ,GAAG;yBACV,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmEqnX,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;EAnD3wX;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6BioX,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;OArB1wX,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"}

package/esm/components/QTabs/QTab.vue.js

@@ -0,0 +1,122 @@
+import { useGroupItem as e } from "../../composables/useGroup/index.js";
+import { DEFAULT_TEXTS as t } from "../__internal__/QRequiredIndicator/constants.js";
+import { QButton as n } from "../QButton/index.js";
+import { QRequiredIndicator as r } from "../__internal__/QRequiredIndicator/index.js";
+import { useId as i } from "../../composables/uid.js";
+import { TabsSymbol as a } from "./context.js";
+import { Fragment as o, Teleport as s, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as p, defineComponent as m, inject as h, normalizeClass as g, onBeforeMount as _, onBeforeUnmount as v, openBlock as y, renderSlot as b, toDisplayString as x, toRef as S, unref as C, useTemplateRef as w, vShow as T, withCtx as E, withDirectives as D } from "vue";
+//#region src/components/QTabs/QTab.vue?vue&type=script&setup=true&lang.ts
+var O = { class: "q-tab__title" }, k = { class: "q-tab__title-text" }, A = [
+	"id",
+	"aria-labelledby",
+	"tabindex"
+], j = /*@__PURE__*/ m({
+	__name: "QTab",
+	props: {
+		id: {},
+		class: {},
+		title: {},
+		required: { type: Boolean },
+		disabled: { type: Boolean },
+		value: {},
+		texts: { default: () => t }
+	},
+	setup(t) {
+		let m = t, j = h(a, void 0);
+		if (!j) throw Error("QTab: Failed to retrieve tabs context. Ensure the component is used within a QTabs context.");
+		let M = i(S(m, "value")), N = i(), P = i(), F = e(M);
+		if (!F) throw Error("QTab: Failed to retrieve group item. Ensure the component is used within a QTabs context.");
+		let I = w("tabBtn"), L = c(() => j.tabListEl.value), R = c(() => !!m.disabled), z = c(() => {
+			if (!R.value) return F.isActive.value ? 0 : -1;
+		}), B = c(() => [
+			"q-tab",
+			{
+				"q-tab--active": F.isActive.value,
+				"q-tab--disabled": R.value
+			},
+			m.class
+		]);
+		function V() {
+			(I.value?.$el)?.focus?.();
+		}
+		function H() {
+			R.value || F?.isActive.value || F?.toggle();
+		}
+		function U() {
+			H();
+		}
+		function W(e) {
+			let t = j?.direction.value === "horizontal";
+			if (t && e.key === "ArrowRight" || !t && e.key === "ArrowDown") {
+				e.preventDefault(), j?.focusAdjacent(M.value, 1);
+				return;
+			}
+			if (t && e.key === "ArrowLeft" || !t && e.key === "ArrowUp") {
+				e.preventDefault(), j?.focusAdjacent(M.value, -1);
+				return;
+			}
+			if (e.key === "Home") {
+				e.preventDefault(), j?.focusFirst();
+				return;
+			}
+			e.key === "End" && (e.preventDefault(), j?.focusLast());
+		}
+		return _(() => {
+			j.register({
+				value: M.value,
+				disabled: R,
+				focus: V,
+				select: H
+			});
+		}), v(() => {
+			j.unregister(M.value);
+		}), (e, t) => (y(), d(o, null, [L.value ? (y(), l(s, {
+			key: 0,
+			to: L.value
+		}, [p(C(n), {
+			id: C(N),
+			ref: "tabBtn",
+			borderless: "",
+			role: "tab",
+			variant: "text",
+			class: g(B.value),
+			disabled: R.value,
+			"data-value": C(M),
+			"aria-selected": C(F).isActive.value,
+			"aria-controls": C(P),
+			"aria-required": m.required || void 0,
+			tabindex: z.value,
+			onClick: U,
+			onKeydown: W
+		}, {
+			default: E(() => [f("span", O, [
+				b(e.$slots, "title.prepend"),
+				f("span", k, x(m.title), 1),
+				m.required ? (y(), l(C(r), {
+					key: 0,
+					announce: "",
+					texts: m.texts
+				}, null, 8, ["texts"])) : u("v-if", !0),
+				b(e.$slots, "title.append")
+			])]),
+			_: 3
+		}, 8, [
+			"id",
+			"class",
+			"disabled",
+			"data-value",
+			"aria-selected",
+			"aria-controls",
+			"aria-required",
+			"tabindex"
+		])], 8, ["to"])) : u("v-if", !0), D(f("div", {
+			id: C(P),
+			class: "q-tabs__panel",
+			role: "tabpanel",
+			"aria-labelledby": C(N),
+			tabindex: C(F).isActive.value ? 0 : void 0
+		}, [b(e.$slots, "default")], 8, A), [[T, C(F).isActive.value]])], 64));
+	}
+});
+//#endregion
+export { j as default };

package/esm/components/QTabs/QTab2.vue.js

@@ -0,0 +1,5 @@
+import e from "./QTab.vue.js";
+//#region src/components/QTabs/QTab.vue
+var t = e;
+//#endregion
+export { t as default };

package/esm/components/QTabs/QTabs.d.ts

@@ -0,0 +1,35 @@
+import { QTabsProps } from './types';
+type __VLS_Props = QTabsProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        tabListEl: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+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;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    variant: import('./types').QTabsVariant;
+    direction: import('./types').QTabsDirection;
+    align: import('./types').QTabsAlign;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    tabListEl: 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=QTabs.vue.d.ts.map

package/esm/components/QTabs/QTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTabs.vue"],"names":[],"mappings":"AAcA;AA6KC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAMzC,KAAK,WAAW,GAAG,UAAU,CAAC;AAkJ/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAqCT,OAAO,IAA6B;;yBAXrB,GAAG;;;;;;EAgB/B;AAYD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;kBAUnB,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"}

package/esm/components/QTabs/QTabs.vue.js

@@ -0,0 +1,83 @@
+import { provideDefaults as e } from "../../composables/defaults.js";
+import { useGroup as t } from "../../composables/useGroup/index.js";
+import { TabsSymbol as n } from "./context.js";
+import { computed as r, createElementBlock as i, createElementVNode as a, defineComponent as o, mergeModels as s, normalizeClass as c, openBlock as l, provide as u, renderSlot as d, shallowRef as f, toRef as p, unref as m, useModel as h, useTemplateRef as g, watch as _ } from "vue";
+//#region src/components/QTabs/QTabs.vue?vue&type=script&setup=true&lang.ts
+var v = ["id"], y = ["aria-orientation"], b = { class: "q-tabs__panels" }, x = /*@__PURE__*/ o({
+	__name: "QTabs",
+	props: /*@__PURE__*/ s({
+		id: {},
+		class: {},
+		direction: { default: "horizontal" },
+		align: { default: "start" },
+		variant: { default: "line" },
+		disabled: { type: Boolean }
+	}, {
+		modelValue: {},
+		modelModifiers: {}
+	}),
+	emits: ["update:modelValue"],
+	setup(o) {
+		let s = o, x = h(o, "modelValue"), S = g("tabListEl"), C = f([]), { active: w } = t({
+			active: x,
+			required: !0
+		});
+		_(w, (e) => {
+			x.value = e;
+		}), e({ QTab: { disabled: p(s, "disabled") } });
+		let T = r(() => [
+			"q-tabs",
+			`q-tabs--${s.direction}`,
+			`q-tabs--${s.variant}`,
+			`q-tabs--align-${s.align}`,
+			s.class
+		]);
+		function E() {
+			return C.value.filter((e) => !m(e.disabled));
+		}
+		function D() {
+			let e = E();
+			e.length && (e.some((e) => e.value === x.value) || (x.value = e[0].value));
+		}
+		function O(e) {
+			C.value = [...C.value, e], D();
+		}
+		function k(e) {
+			C.value = C.value.filter((t) => t.value !== e);
+		}
+		function A(e, t) {
+			let n = E();
+			if (!n.length) return;
+			let r = n.findIndex((t) => t.value === e), i = n[r === -1 ? 0 : (r + t + n.length) % n.length];
+			i.select(), i.focus();
+		}
+		function j() {
+			let e = E()[0];
+			e && (e.select(), e.focus());
+		}
+		function M() {
+			let e = E(), t = e[e.length - 1];
+			t && (t.select(), t.focus());
+		}
+		return _(() => C.value.map((e) => [e.value, m(e.disabled)]), () => D()), u(n, {
+			tabListEl: S,
+			direction: r(() => s.direction),
+			register: O,
+			unregister: k,
+			focusAdjacent: A,
+			focusFirst: j,
+			focusLast: M
+		}), (e, t) => (l(), i("div", {
+			id: s.id,
+			class: c(T.value)
+		}, [a("div", {
+			ref_key: "tabListEl",
+			ref: S,
+			class: "q-tabs__list",
+			role: "tablist",
+			"aria-orientation": s.direction
+		}, null, 8, y), a("div", b, [d(e.$slots, "default")])], 10, v));
+	}
+});
+//#endregion
+export { x as default };

package/esm/components/QTabs/QTabs2.vue.js

@@ -0,0 +1,5 @@
+import e from "./QTabs.vue.js";
+//#region src/components/QTabs/QTabs.vue
+var t = e;
+//#endregion
+export { t as default };

package/esm/components/QTabs/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Default accessible strings for {@link QTab}.
+ */
+export { DEFAULT_TEXTS } from '../__internal__/QRequiredIndicator/constants';
+//# sourceMappingURL=constants.d.ts.map

package/esm/components/QTabs/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAA"}

package/esm/components/QTabs/context.d.ts

@@ -0,0 +1,78 @@
+import { ComputedRef, InjectionKey, Ref } from 'vue';
+import { QTabsDirection } from './types';
+/**
+ * Metadata registered by each {@link QTab} with its parent {@link QTabs}.
+ *
+ * Used for keyboard navigation, default selection, and focusing tab triggers.
+ */
+export type TabRegistration = {
+    /**
+     * Identity of the tab, matching the value used by `v-model` on `QTabs`.
+     */
+    value: string;
+    /**
+     * Whether the tab is currently disabled.
+     *
+     * Stored as a computed so the parent can react when the prop changes.
+     */
+    disabled: ComputedRef<boolean>;
+    /**
+     * Moves DOM focus to this tab's trigger button.
+     */
+    focus: () => void;
+    /**
+     * Activates this tab if it is enabled and not already selected.
+     */
+    select: () => void;
+};
+/**
+ * Provide/inject context shared between {@link QTabs} and its {@link QTab} children.
+ *
+ * Handles tablist targeting (for teleporting triggers), registration, and keyboard focus movement.
+ */
+export type TabsContext = {
+    /**
+     * DOM element that hosts the tablist (`role="tablist"`).
+     *
+     * Each `QTab` teleports its trigger button into this element.
+     */
+    tabListEl: Ref<HTMLElement | null>;
+    /**
+     * Current layout orientation of the tab list.
+     *
+     * Drives which arrow keys move focus (Left/Right vs Up/Down).
+     */
+    direction: ComputedRef<QTabsDirection>;
+    /**
+     * Registers a tab with the parent so it participates in selection and keyboard navigation.
+     *
+     * @param tab - Tab metadata to register.
+     */
+    register: (tab: TabRegistration) => void;
+    /**
+     * Removes a previously registered tab (typically on unmount).
+     *
+     * @param value - The tab `value` to remove.
+     */
+    unregister: (value: string) => void;
+    /**
+     * Activates and focuses the next or previous enabled tab relative to `currentValue`.
+     *
+     * @param currentValue - Value of the tab that currently has focus.
+     * @param delta - Direction to move (`1` for next, `-1` for previous). Wraps around.
+     */
+    focusAdjacent: (currentValue: string, delta: number) => void;
+    /**
+     * Activates and focuses the first enabled tab.
+     */
+    focusFirst: () => void;
+    /**
+     * Activates and focuses the last enabled tab.
+     */
+    focusLast: () => void;
+};
+/**
+ * Injection key for the {@link TabsContext} provided by `QTabs`.
+ */
+export declare const TabsSymbol: InjectionKey<TabsContext>;
+//# sourceMappingURL=context.d.ts.map

package/esm/components/QTabs/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG;IAC7B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;;;OAIG;IACH,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAE9B;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAA;IAEjB;;OAEG;IACH,MAAM,EAAE,MAAM,IAAI,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACzB;;;;OAIG;IACH,SAAS,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAElC;;;;OAIG;IACH,SAAS,EAAE,WAAW,CAAC,cAAc,CAAC,CAAA;IAEtC;;;;OAIG;IACH,QAAQ,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAA;IAExC;;;;OAIG;IACH,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAEnC;;;;;OAKG;IACH,aAAa,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAE5D;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAA;IAEtB;;OAEG;IACH,SAAS,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,WAAW,CAAoB,CAAA"}

package/esm/components/QTabs/context.js

@@ -0,0 +1,4 @@
+//#region src/components/QTabs/context.ts
+var e = Symbol("q-tabs");
+//#endregion
+export { e as TabsSymbol };