@quidgest/ui 0.27.1 → 0.28.0

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

@@ -1,4 +1,3 @@
-import { DEFAULT_TEXTS } from './constants';
 import { QTabProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -16,8 +15,13 @@ declare function __VLS_template(): {
                 readonly id?: string | undefined;
                 readonly class?: string | unknown[] | undefined;
                 readonly label?: string | undefined;
+                readonly help?: string | undefined;
+                readonly helpDisplay?: import('../..').QHelpDisplay | undefined;
+                readonly icons?: typeof import('../QButton/constants').DEFAULT_ICONS | undefined;
+                readonly texts?: typeof import('../QButton/constants').DEFAULT_TEXTS | undefined;
                 readonly variant?: import('..').QButtonVariant | undefined;
                 readonly color?: string | undefined;
+                readonly surface?: string | undefined;
                 readonly borderless?: boolean | undefined;
                 readonly elevated?: boolean | undefined;
                 readonly block?: boolean | undefined;
@@ -33,6 +37,8 @@ declare function __VLS_template(): {
             $attrs: import('vue').Attrs;
             $refs: {
                 [x: string]: unknown;
+            } & {
+                buttonEl: HTMLButtonElement;
             };
             $slots: Readonly<{
                 [name: string]: import('vue').Slot<any> | undefined;
@@ -41,15 +47,18 @@ declare function __VLS_template(): {
             $parent: import('vue').ComponentPublicInstance | null;
             $host: Element | null;
             $emit: (event: "click", event: MouseEvent) => void;
-            $el: HTMLButtonElement;
+            $el: any;
             $options: import('vue').ComponentOptionsBase<Readonly<import('..').QButtonProps> & Readonly<{
                 onClick?: ((event: MouseEvent) => any) | undefined;
             }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                 click: (event: MouseEvent) => any;
             }, string, {
-                variant: import('..').QButtonVariant;
                 effect: import('..').QButtonEffect;
                 color: string;
+                variant: import('..').QButtonVariant;
+                icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+                texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+                helpDisplay: import('../..').QHelpDisplay;
                 iconPos: import('..').QButtonIconPosition;
             }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                 beforeCreate?: (() => void) | (() => void)[];
@@ -72,13 +81,16 @@ declare function __VLS_template(): {
             $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<{
-            variant: import('..').QButtonVariant;
             effect: import('..').QButtonEffect;
             color: string;
+            variant: import('..').QButtonVariant;
+            icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+            texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+            helpDisplay: import('../..').QHelpDisplay;
             iconPos: import('..').QButtonIconPosition;
         }> & Omit<Readonly<import('..').QButtonProps> & Readonly<{
             onClick?: ((event: MouseEvent) => any) | undefined;
-        }>, "variant" | "effect" | "color" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
+        }>, "effect" | "color" | "variant" | "icons" | "texts" | "helpDisplay" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
                 default?(_: {}): any;
                 append?(_: {}): any;
@@ -88,9 +100,7 @@ declare function __VLS_template(): {
     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, {
+declare const __VLS_component: import('vue').DefineComponent<QTabProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<QTabProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     tabBtn: ({
         $: import('vue').ComponentInternalInstance;
         $data: {};
@@ -98,8 +108,13 @@ declare const __VLS_component: import('vue').DefineComponent<QTabProps, {}, {},
             readonly id?: string | undefined;
             readonly class?: string | unknown[] | undefined;
             readonly label?: string | undefined;
+            readonly help?: string | undefined;
+            readonly helpDisplay?: import('../..').QHelpDisplay | undefined;
+            readonly icons?: typeof import('../QButton/constants').DEFAULT_ICONS | undefined;
+            readonly texts?: typeof import('../QButton/constants').DEFAULT_TEXTS | undefined;
             readonly variant?: import('..').QButtonVariant | undefined;
             readonly color?: string | undefined;
+            readonly surface?: string | undefined;
             readonly borderless?: boolean | undefined;
             readonly elevated?: boolean | undefined;
             readonly block?: boolean | undefined;
@@ -115,6 +130,8 @@ declare const __VLS_component: import('vue').DefineComponent<QTabProps, {}, {},
         $attrs: import('vue').Attrs;
         $refs: {
             [x: string]: unknown;
+        } & {
+            buttonEl: HTMLButtonElement;
         };
         $slots: Readonly<{
             [name: string]: import('vue').Slot<any> | undefined;
@@ -123,15 +140,18 @@ declare const __VLS_component: import('vue').DefineComponent<QTabProps, {}, {},
         $parent: import('vue').ComponentPublicInstance | null;
         $host: Element | null;
         $emit: (event: "click", event: MouseEvent) => void;
-        $el: HTMLButtonElement;
+        $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<import('..').QButtonProps> & Readonly<{
             onClick?: ((event: MouseEvent) => any) | undefined;
         }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
             click: (event: MouseEvent) => any;
         }, string, {
-            variant: import('..').QButtonVariant;
             effect: import('..').QButtonEffect;
             color: string;
+            variant: import('..').QButtonVariant;
+            icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+            texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+            helpDisplay: import('../..').QHelpDisplay;
             iconPos: import('..').QButtonIconPosition;
         }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
             beforeCreate?: (() => void) | (() => void)[];
@@ -154,13 +174,16 @@ declare const __VLS_component: import('vue').DefineComponent<QTabProps, {}, {},
         $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<{
-        variant: import('..').QButtonVariant;
         effect: import('..').QButtonEffect;
         color: string;
+        variant: import('..').QButtonVariant;
+        icons: typeof import('../QButton/constants').DEFAULT_ICONS;
+        texts: typeof import('../QButton/constants').DEFAULT_TEXTS;
+        helpDisplay: import('../..').QHelpDisplay;
         iconPos: import('..').QButtonIconPosition;
     }> & Omit<Readonly<import('..').QButtonProps> & Readonly<{
         onClick?: ((event: MouseEvent) => any) | undefined;
-    }>, "variant" | "effect" | "color" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
+    }>, "effect" | "color" | "variant" | "icons" | "texts" | "helpDisplay" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: {
             default?(_: {}): any;
             append?(_: {}): any;

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

@@ -1 +1 @@
-{"version":3,"file":"QTab.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTab.vue"],"names":[],"mappings":"AA4CA;AAsNC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAW3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,CAAA;AA+JnC,iBAAS,cAAc;WAsHT,OAAO,IAA6B;;iCAdZ,GAAG;uBACb,GAAG;gCACM,GAAG;yBACV,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAmEi2W,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;EAnDv/W;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6B62W,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;OArBt/W,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"}
+{"version":3,"file":"QTab.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTab.vue"],"names":[],"mappings":"AAmDA;AA+OC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,CAAA;AAyKnC,iBAAS,cAAc;WA+HT,OAAO,IAA6B;;iCAdZ,GAAG;uBACb,GAAG;gCACM,GAAG;yBACV,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA8D8zU,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;EA9Cp9U;AAuBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsB00U,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;OAfn9U,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"}

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

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

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

@@ -1,3 +1,4 @@
+import { DEFAULT_ICONS, DEFAULT_TEXTS } from './constants';
 import { QTabsProps } from '.';
 import { nextTick } from 'vue';
 type __VLS_Props = QTabsProps;
@@ -109,6 +110,8 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
     variant: import('./types').QTabsVariant;
+    icons: typeof DEFAULT_ICONS;
+    texts: typeof DEFAULT_TEXTS;
     direction: import('./types').QTabsDirection;
     align: import('./types').QTabsAlign;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

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

@@ -1 +1 @@
-{"version":3,"file":"QTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTabs.vue"],"names":[],"mappings":"AAyBA;AAocC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,CAAA;AAGnC,OAAO,EAEN,QAAQ,EASR,MAAM,KAAK,CAAA;AAGZ,KAAK,WAAW,GAAG,UAAU,CAAC;AAyY/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAiET,OAAO,IAA6B;;yBAZrB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAgEynB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA/C9wB;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+BooB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;kBArB7wB,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"}
+{"version":3,"file":"QTabs.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/QTabs.vue"],"names":[],"mappings":"AA2BA;AAkcC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAa1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,CAAA;AAGnC,OAAO,EAEN,QAAQ,EASR,MAAM,KAAK,CAAA;AAGZ,KAAK,WAAW,GAAG,UAAU,CAAC;AA8Y/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAqET,OAAO,IAA6B;;yBAZrB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAgEiK,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA/CtT;AAeD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA+B4K,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;kBArBrT,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

@@ -3,50 +3,56 @@ import { useGroup as t } from "../../composables/useGroup/index.js";
 import { useId as n } from "../../composables/useId/index.js";
 import { QOverflow as r } from "../QOverflow/index.js";
 import { useEnabledSelection as i } from "../../composables/useEnabledSelection/index.js";
-import { TabsSymbol as a } from "./context.js";
-import { computed as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, createVNode as u, defineComponent as d, mergeModels as f, nextTick as p, normalizeClass as m, normalizeStyle as h, onBeforeUnmount as g, openBlock as _, provide as v, ref as y, renderSlot as b, shallowRef as x, toRef as S, unref as C, useModel as w, useTemplateRef as T, watch as E, withCtx as D } from "vue";
+import { DEFAULT_ICONS as a, DEFAULT_TEXTS as o } from "./constants.js";
+import { TabsSymbol as s } from "./context.js";
+import { computed as c, createCommentVNode as l, createElementBlock as u, createElementVNode as d, createVNode as f, defineComponent as p, mergeModels as m, nextTick as h, normalizeClass as g, normalizeStyle as _, onBeforeUnmount as v, openBlock as y, provide as b, ref as x, renderSlot as S, shallowRef as C, toRef as w, unref as T, useModel as E, useTemplateRef as D, watch as O, withCtx as k } from "vue";
 //#region src/components/QTabs/QTabs.vue?vue&type=script&setup=true&lang.ts
-var O = ["id"], k = {
+var A = ["id"], j = {
 	ref: "tabListHost",
 	class: "q-tabs__list"
-}, A = { class: "q-tabs__panels" }, j = /*@__PURE__*/ d({
+}, M = { class: "q-tabs__panels" }, N = /*@__PURE__*/ p({
 	__name: "QTabs",
-	props: /*@__PURE__*/ f({
+	props: /*@__PURE__*/ m({
 		id: {},
 		class: {},
 		direction: { default: "horizontal" },
 		align: { default: "start" },
 		variant: { default: "line" },
-		disabled: { type: Boolean }
+		disabled: { type: Boolean },
+		icons: { default: () => a },
+		texts: { default: () => o }
 	}, {
 		modelValue: {},
 		modelModifiers: {}
 	}),
 	emits: ["update:modelValue"],
-	setup(d) {
-		let f = d, j = w(d, "modelValue"), M = n(S(f, "id")), N = T("tabListHost"), P = T("overflowRef"), F = o(() => P.value?.contentEl ?? null), I = x([]), L = y({
+	setup(a) {
+		let o = a, p = E(a, "modelValue"), m = n(w(o, "id")), N = D("tabListHost"), P = D("overflowRef"), F = c(() => P.value?.contentEl ?? null), I = C([]), L = x({
 			width: "0",
 			height: "0",
 			transform: "translate(0, 0)",
 			opacity: "0"
-		}), R = y(!1), z = null, { active: B } = t({
-			active: j,
+		}), R = x(!1), z = null, { active: B } = t({
+			active: p,
 			required: !0
 		});
-		E(B, (e) => {
-			j.value = e;
-		}), e({ QTab: { disabled: S(f, "disabled") } });
-		let V = o(() => [
+		O(B, (e) => {
+			p.value = e;
+		}), e({ QTab: {
+			disabled: w(o, "disabled"),
+			texts: w(o, "texts")
+		} });
+		let V = c(() => [
 			"q-tabs",
-			`q-tabs--${f.direction}`,
-			`q-tabs--${f.variant}`,
-			`q-tabs--align-${f.align}`,
+			`q-tabs--${o.direction}`,
+			`q-tabs--${o.variant}`,
+			`q-tabs--align-${o.align}`,
 			R.value ? "q-tabs--indicator-ready" : void 0,
-			f.class
+			o.class
 		]);
 		function H() {
 			let e = F.value;
-			e && (e.setAttribute("role", "tablist"), e.setAttribute("aria-orientation", f.direction));
+			e && (e.setAttribute("role", "tablist"), e.setAttribute("aria-orientation", o.direction));
 		}
 		function U(e) {
 			let t = e.tabRef.value;
@@ -61,11 +67,11 @@ var O = ["id"], k = {
 			};
 		}
 		function G() {
-			if (f.variant !== "line" || !j.value) {
+			if (o.variant !== "line" || !p.value) {
 				W();
 				return;
 			}
-			let e = I.value.find((e) => e.value === j.value);
+			let e = I.value.find((e) => e.value === p.value);
 			if (!e) {
 				W();
 				return;
@@ -75,7 +81,7 @@ var O = ["id"], k = {
 				W();
 				return;
 			}
-			let n = f.direction === "horizontal", r = R.value;
+			let n = o.direction === "horizontal", r = R.value;
 			n ? L.value = {
 				width: `${t.offsetWidth}px`,
 				height: "var(--q-tabs-indicator-thickness)",
@@ -86,19 +92,19 @@ var O = ["id"], k = {
 				height: `${t.offsetHeight}px`,
 				transform: `translate(0, ${t.offsetTop}px)`,
 				opacity: "1"
-			}, r || p(() => {
+			}, r || h(() => {
 				L.value.opacity === "1" && (R.value = !0);
 			});
 		}
 		function K() {
-			if (!j.value) return;
-			let e = I.value.find((e) => e.value === j.value);
+			if (!p.value) return;
+			let e = I.value.find((e) => e.value === p.value);
 			if (!e) return;
 			let t = U(e);
 			t && P.value?.scrollElementIntoView(t);
 		}
 		function q() {
-			if (f.variant !== "line") {
+			if (o.variant !== "line") {
 				z?.disconnect();
 				return;
 			}
@@ -112,14 +118,14 @@ var O = ["id"], k = {
 				t && z.observe(t);
 			}
 		}
-		let { enabledItems: J, ensureSelection: Y } = i(() => I.value, j), X;
+		let { enabledItems: J, ensureSelection: Y } = i(() => I.value, p), X;
 		function Z() {
-			X ||= p(() => {
+			X ||= h(() => {
 				X = void 0, Y();
 			});
 		}
 		function Q(e) {
-			if (I.value = [...I.value, e], !j.value) {
+			if (I.value = [...I.value, e], !p.value) {
 				Y();
 				return;
 			}
@@ -135,8 +141,8 @@ var O = ["id"], k = {
 				if (I.value = I.value.map((e, r) => r === n ? {
 					...e,
 					value: t
-				} : e), j.value === e || j.value === t) {
-					j.value = t;
+				} : e), p.value === e || p.value === t) {
+					p.value = t;
 					return;
 				}
 				Y();
@@ -156,48 +162,54 @@ var O = ["id"], k = {
 			let e = J.value, t = e[e.length - 1];
 			t && (t.select(), t.focus());
 		}
-		return E(() => I.value.map((e) => [e.value, C(e.disabled)]), () => Z()), E(() => [
-			j.value,
+		return O(() => I.value.map((e) => [e.value, T(e.disabled)]), () => Z()), O(() => [
+			p.value,
 			I.value.length,
-			f.direction,
-			f.variant,
-			f.align
-		], () => p(() => {
+			o.direction,
+			o.variant,
+			o.align
+		], () => h(() => {
 			G(), K();
-		}), { immediate: !0 }), E(() => [I.value.length, f.variant], () => p(q), { immediate: !0 }), E(() => [F.value, f.direction], () => H(), {
+		}), { immediate: !0 }), O(() => [I.value.length, o.variant], () => h(q), { immediate: !0 }), O(() => [F.value, o.direction], () => H(), {
 			immediate: !0,
 			flush: "post"
-		}), g(() => {
+		}), v(() => {
 			z?.disconnect(), z = null;
-		}), v(a, {
+		}), b(s, {
 			tabListEl: F,
-			direction: o(() => f.direction),
+			direction: c(() => o.direction),
 			register: Q,
 			unregister: $,
 			updateValue: ee,
 			focusAdjacent: te,
 			focusFirst: ne,
 			focusLast: re
-		}), (e, t) => (_(), c("div", {
-			id: C(M),
-			class: m(V.value)
-		}, [l("div", k, [u(C(r), {
+		}), (e, t) => (y(), u("div", {
+			id: T(m),
+			class: g(V.value)
+		}, [d("div", j, [f(T(r), {
 			ref_key: "overflowRef",
 			ref: P,
 			class: "q-tabs__overflow",
-			direction: f.direction,
+			direction: o.direction,
 			"scroll-mode": "item",
-			"content-class": "q-tabs__tablist"
+			"content-class": "q-tabs__tablist",
+			icons: o.icons,
+			texts: o.texts
 		}, {
-			default: D(() => [f.variant === "line" ? (_(), c("div", {
+			default: k(() => [o.variant === "line" ? (y(), u("div", {
 				key: 0,
 				class: "q-tabs__indicator",
 				"aria-hidden": "true",
-				style: h(L.value)
-			}, null, 4)) : s("v-if", !0)]),
+				style: _(L.value)
+			}, null, 4)) : l("v-if", !0)]),
 			_: 1
-		}, 8, ["direction"])], 512), l("div", A, [b(e.$slots, "default")])], 10, O));
+		}, 8, [
+			"direction",
+			"icons",
+			"texts"
+		])], 512), d("div", M, [S(e.$slots, "default")])], 10, A));
 	}
 });
 //#endregion
-export { j as default };
+export { N as default };

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

@@ -1,5 +1,27 @@
 /**
- * Default accessible strings for {@link QTab}.
+ * Default icons for {@link QTabs}. Includes the overflow navigation chevrons.
  */
-export { DEFAULT_TEXTS } from '../__internal__/QRequiredIndicator/constants';
+export declare const DEFAULT_ICONS: {
+    back: {
+        icon: string;
+    };
+    forward: {
+        icon: string;
+    };
+    up: {
+        icon: string;
+    };
+    down: {
+        icon: string;
+    };
+};
+/**
+ * Default accessible strings for {@link QTabs}. Includes the tab strings, which the strip
+ * cascades to its tabs, and the overflow back/forward labels.
+ */
+export declare const DEFAULT_TEXTS: {
+    back: string;
+    forward: string;
+    required: string;
+};
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/constants.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;CAEY,CAAA;AAEtC;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;CAGQ,CAAA"}

package/esm/components/QTabs/constants.js

@@ -0,0 +1,9 @@
+import { DEFAULT_TEXTS as e } from "../__internal__/QRequiredIndicator/constants.js";
+import { DEFAULT_ICONS as t, DEFAULT_TEXTS as n } from "../QOverflow/constants.js";
+//#region src/components/QTabs/constants.ts
+var r = { ...t }, i = {
+	...e,
+	...n
+};
+//#endregion
+export { r as DEFAULT_ICONS, i as DEFAULT_TEXTS };