@quidgest/ui 0.22.0 → 0.23.0

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

@@ -1,14 +1,15 @@
 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, createCommentVNode as i, createElementBlock as a, createElementVNode as o, defineComponent as s, mergeModels as c, nextTick as l, normalizeClass as u, normalizeStyle as d, onBeforeUnmount as f, openBlock as p, provide as m, ref as h, renderSlot as g, shallowRef as _, toRef as v, unref as y, useModel as b, useTemplateRef as x, watch as S } from "vue";
+import { QOverflow as n } from "../QOverflow/index.js";
+import { TabsSymbol as r } from "./context.js";
+import { computed as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createVNode as c, defineComponent as l, mergeModels as u, nextTick as d, normalizeClass as f, normalizeStyle as p, onBeforeUnmount as m, openBlock as h, provide as g, ref as _, renderSlot as v, shallowRef as y, toRef as b, unref as x, useModel as S, useTemplateRef as C, watch as w, withCtx as T } from "vue";
 //#region src/components/QTabs/QTabs.vue?vue&type=script&setup=true&lang.ts
-var C = ["id"], w = {
+var E = ["id"], D = {
 	ref: "tabListHost",
 	class: "q-tabs__list"
-}, T = ["aria-orientation"], E = { class: "q-tabs__panels" }, D = /*@__PURE__*/ s({
+}, O = { class: "q-tabs__panels" }, k = /*@__PURE__*/ l({
 	__name: "QTabs",
-	props: /*@__PURE__*/ c({
+	props: /*@__PURE__*/ u({
 		id: {},
 		class: {},
 		direction: { default: "horizontal" },
@@ -20,168 +21,188 @@ var C = ["id"], w = {
 		modelModifiers: {}
 	}),
 	emits: ["update:modelValue"],
-	setup(s) {
-		let c = s, D = b(s, "modelValue"), O = x("tabListHost"), k = x("tabListEl"), A = _([]), j = h({
+	setup(l) {
+		let u = l, k = S(l, "modelValue"), A = C("tabListHost"), j = C("overflowRef"), M = i(() => j.value?.contentEl ?? null), N = y([]), P = _({
 			width: "0",
 			height: "0",
 			transform: "translate(0, 0)",
 			opacity: "0"
-		}), M = h(!1), N = null, { active: P } = t({
-			active: D,
+		}), F = _(!1), I = null, { active: L } = t({
+			active: k,
 			required: !0
 		});
-		S(P, (e) => {
-			D.value = e;
-		}), e({ QTab: { disabled: v(c, "disabled") } });
-		let F = r(() => [
+		w(L, (e) => {
+			k.value = e;
+		}), e({ QTab: { disabled: b(u, "disabled") } });
+		let R = i(() => [
 			"q-tabs",
-			`q-tabs--${c.direction}`,
-			`q-tabs--${c.variant}`,
-			`q-tabs--align-${c.align}`,
-			M.value ? "q-tabs--indicator-ready" : void 0,
-			c.class
+			`q-tabs--${u.direction}`,
+			`q-tabs--${u.variant}`,
+			`q-tabs--align-${u.align}`,
+			F.value ? "q-tabs--indicator-ready" : void 0,
+			u.class
 		]);
-		function I(e) {
+		function z() {
+			let e = M.value;
+			e && (e.setAttribute("role", "tablist"), e.setAttribute("aria-orientation", u.direction));
+		}
+		function B(e) {
 			let t = e.tabRef.value;
 			return t ? "$el" in t ? t.$el : t : null;
 		}
-		function L() {
-			M.value = !1, j.value = {
-				...j.value,
+		function V() {
+			F.value = !1, P.value = {
+				...P.value,
 				opacity: "0",
 				width: "0",
 				height: "0"
 			};
 		}
-		function R() {
-			if (c.variant !== "line" || !D.value) {
-				L();
+		function H() {
+			if (u.variant !== "line" || !k.value) {
+				V();
 				return;
 			}
-			let e = A.value.find((e) => e.value === D.value);
+			let e = N.value.find((e) => e.value === k.value);
 			if (!e) {
-				L();
+				V();
 				return;
 			}
-			let t = I(e);
+			let t = B(e);
 			if (!t) {
-				L();
+				V();
 				return;
 			}
-			let n = c.direction === "horizontal", r = M.value;
-			n ? j.value = {
+			let n = u.direction === "horizontal", r = F.value;
+			n ? P.value = {
 				width: `${t.offsetWidth}px`,
-				height: "4px",
+				height: "var(--q-tabs-indicator-thickness)",
 				transform: `translate(${t.offsetLeft}px, 0)`,
 				opacity: "1"
-			} : j.value = {
-				width: "4px",
+			} : P.value = {
+				width: "var(--q-tabs-indicator-thickness)",
 				height: `${t.offsetHeight}px`,
 				transform: `translate(0, ${t.offsetTop}px)`,
 				opacity: "1"
-			}, r || l(() => {
-				j.value.opacity === "1" && (M.value = !0);
+			}, r || d(() => {
+				P.value.opacity === "1" && (F.value = !0);
 			});
 		}
-		function z() {
-			if (c.variant !== "line") {
-				N?.disconnect();
+		function U() {
+			if (!k.value) return;
+			let e = N.value.find((e) => e.value === k.value);
+			if (!e) return;
+			let t = B(e);
+			t && j.value?.scrollElementIntoView(t);
+		}
+		function W() {
+			if (u.variant !== "line") {
+				I?.disconnect();
 				return;
 			}
-			N ? N.disconnect() : N = new ResizeObserver(() => {
-				R();
+			I ? I.disconnect() : I = new ResizeObserver(() => {
+				H();
 			});
-			let e = O.value;
-			e && N.observe(e);
-			for (let e of A.value) {
-				let t = I(e);
-				t && N.observe(t);
+			let e = A.value;
+			e && I.observe(e);
+			for (let e of N.value) {
+				let t = B(e);
+				t && I.observe(t);
 			}
 		}
-		function B() {
-			return A.value.filter((e) => !y(e.disabled));
+		function G() {
+			return N.value.filter((e) => !x(e.disabled));
 		}
-		function V() {
-			let e = B();
-			e.length && (e.some((e) => e.value === D.value) || (D.value = e[0].value));
+		function K() {
+			let e = G();
+			e.length && (e.some((e) => e.value === k.value) || (k.value = e[0].value));
 		}
-		let H;
-		function U() {
-			H ||= l(() => {
-				H = void 0, V();
+		let q;
+		function J() {
+			q ||= d(() => {
+				q = void 0, K();
 			});
 		}
-		function W(e) {
-			if (A.value = [...A.value, e], !D.value) {
-				V();
+		function Y(e) {
+			if (N.value = [...N.value, e], !k.value) {
+				K();
 				return;
 			}
-			U();
+			J();
 		}
-		function G(e) {
-			A.value = A.value.filter((t) => t.value !== e);
+		function X(e) {
+			N.value = N.value.filter((t) => t.value !== e);
 		}
-		function K(e, t) {
+		function Z(e, t) {
 			if (e === t) return;
-			let n = A.value.findIndex((t) => t.value === e);
+			let n = N.value.findIndex((t) => t.value === e);
 			if (n !== -1) {
-				if (A.value = A.value.map((e, r) => r === n ? {
+				if (N.value = N.value.map((e, r) => r === n ? {
 					...e,
 					value: t
-				} : e), D.value === e || D.value === t) {
-					D.value = t;
+				} : e), k.value === e || k.value === t) {
+					k.value = t;
 					return;
 				}
-				V();
+				K();
 			}
 		}
-		function q(e, t) {
-			let n = B();
+		function Q(e, t) {
+			let n = G();
 			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 = B()[0];
+		function $() {
+			let e = G()[0];
 			e && (e.select(), e.focus());
 		}
-		function Y() {
-			let e = B(), t = e[e.length - 1];
+		function ee() {
+			let e = G(), t = e[e.length - 1];
 			t && (t.select(), t.focus());
 		}
-		return S(() => A.value.map((e) => [e.value, y(e.disabled)]), () => U()), S(() => [
-			D.value,
-			A.value.length,
-			c.direction,
-			c.variant,
-			c.align
-		], () => l(R), { immediate: !0 }), S(() => [A.value.length, c.variant], () => l(z), { immediate: !0 }), f(() => {
-			N?.disconnect(), N = null;
-		}), m(n, {
-			tabListEl: k,
-			direction: r(() => c.direction),
-			register: W,
-			unregister: G,
-			updateValue: K,
-			focusAdjacent: q,
-			focusFirst: J,
-			focusLast: Y
-		}), (e, t) => (p(), a("div", {
-			id: c.id,
-			class: u(F.value)
-		}, [o("div", w, [o("div", {
-			ref_key: "tabListEl",
-			ref: k,
-			class: "q-tabs__tablist",
-			role: "tablist",
-			"aria-orientation": c.direction
-		}, null, 8, T), c.variant === "line" ? (p(), a("div", {
-			key: 0,
-			class: "q-tabs__indicator",
-			"aria-hidden": "true",
-			style: d(j.value)
-		}, null, 4)) : i("v-if", !0)], 512), o("div", E, [g(e.$slots, "default")])], 10, C));
+		return w(() => N.value.map((e) => [e.value, x(e.disabled)]), () => J()), w(() => [
+			k.value,
+			N.value.length,
+			u.direction,
+			u.variant,
+			u.align
+		], () => d(() => {
+			H(), U();
+		}), { immediate: !0 }), w(() => [N.value.length, u.variant], () => d(W), { immediate: !0 }), w(() => [M.value, u.direction], () => z(), {
+			immediate: !0,
+			flush: "post"
+		}), m(() => {
+			I?.disconnect(), I = null;
+		}), g(r, {
+			tabListEl: M,
+			direction: i(() => u.direction),
+			register: Y,
+			unregister: X,
+			updateValue: Z,
+			focusAdjacent: Q,
+			focusFirst: $,
+			focusLast: ee
+		}), (e, t) => (h(), o("div", {
+			id: u.id,
+			class: f(R.value)
+		}, [s("div", D, [c(x(n), {
+			ref_key: "overflowRef",
+			ref: j,
+			class: "q-tabs__overflow",
+			direction: u.direction,
+			"scroll-mode": "item",
+			"content-class": "q-tabs__tablist"
+		}, {
+			default: T(() => [u.variant === "line" ? (h(), o("div", {
+				key: 0,
+				class: "q-tabs__indicator",
+				"aria-hidden": "true",
+				style: p(P.value)
+			}, null, 4)) : a("v-if", !0)]),
+			_: 1
+		}, 8, ["direction"])], 512), s("div", O, [v(e.$slots, "default")])], 10, E));
 	}
 });
 //#endregion
-export { D as default };
+export { k as default };

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

@@ -41,7 +41,8 @@ export type TabsContext = {
     /**
      * DOM element with `role="tablist"` that owns teleported tab triggers.
      *
-     * The line indicator lives on the outer `.q-tabs__list` host, not here.
+     * This is the composed `QOverflow` content track (`.q-tabs__tablist`). The line
+     * indicator is an `aria-hidden` sibling inside the same track so it scrolls with tabs.
      */
     tabListEl: Ref<HTMLElement | null>;
     /**

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

@@ -1 +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;;;;;GAKG;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,MAAM,EAAE,GAAG,CAAC;QAAE,GAAG,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,WAAW,GAAG,IAAI,CAAC,CAAA;IAEvD;;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,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAEzD;;;;;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"}
+{"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;;;;;GAKG;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,MAAM,EAAE,GAAG,CAAC;QAAE,GAAG,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,WAAW,GAAG,IAAI,CAAC,CAAA;IAEvD;;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;;;;;OAKG;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,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IAEzD;;;;;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/index.d.ts

@@ -16,7 +16,94 @@ declare const QTabs: {
         align: import('./types').QTabsAlign;
     }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
         tabListHost: HTMLDivElement;
-        tabListEl: HTMLDivElement;
+        overflowRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly id?: string | undefined;
+                readonly class?: string | unknown[] | undefined;
+                readonly direction?: import('..').QOverflowDirection | undefined;
+                readonly arrowPlacement?: import('..').QOverflowArrowPlacement | undefined;
+                readonly arrowVisibility?: import('..').QOverflowArrowVisibility | undefined;
+                readonly scrollMode?: import('..').QOverflowScrollMode | undefined;
+                readonly scrollStep?: number | undefined;
+                readonly remapWheel?: boolean | undefined;
+                readonly contentClass?: string | unknown[] | undefined;
+                readonly icons?: typeof import('../QOverflow/constants').DEFAULT_ICONS | undefined;
+                readonly texts?: import('..').QOverflowTexts | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                viewportRef: HTMLDivElement;
+                contentRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').QOverflowProps> & Readonly<{}>, {
+                contentEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                scrollElementIntoView: (element: HTMLElement) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                icons: typeof import('../QOverflow/constants').DEFAULT_ICONS;
+                texts: import('..').QOverflowTexts;
+                direction: import('..').QOverflowDirection;
+                arrowPlacement: import('..').QOverflowArrowPlacement;
+                arrowVisibility: import('..').QOverflowArrowVisibility;
+                scrollMode: import('..').QOverflowScrollMode;
+                scrollStep: number;
+                remapWheel: boolean;
+            }, {}, 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<{
+            icons: typeof import('../QOverflow/constants').DEFAULT_ICONS;
+            texts: import('..').QOverflowTexts;
+            direction: import('..').QOverflowDirection;
+            arrowPlacement: import('..').QOverflowArrowPlacement;
+            arrowVisibility: import('..').QOverflowArrowVisibility;
+            scrollMode: import('..').QOverflowScrollMode;
+            scrollStep: number;
+            remapWheel: boolean;
+        }> & Omit<Readonly<import('..').QOverflowProps> & Readonly<{}>, "contentEl" | "scrollElementIntoView" | ("icons" | "texts" | "direction" | "arrowPlacement" | "arrowVisibility" | "scrollMode" | "scrollStep" | "remapWheel")> & {
+            contentEl: HTMLElement | null;
+            scrollElementIntoView: (element: HTMLElement) => void;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                prev?(_: {
+                    disabled: boolean;
+                    onClick: () => void;
+                }): any;
+                default?(_: {}): any;
+                next?(_: {
+                    disabled: boolean;
+                    onClick: () => void;
+                }): any;
+            };
+        }) | null;
     }, HTMLDivElement, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
@@ -77,11 +164,12 @@ declare const QTab: {
                 readonly borderless?: boolean | undefined;
                 readonly elevated?: boolean | undefined;
                 readonly block?: boolean | undefined;
-                readonly size?: import('..').QButtonSize | undefined;
+                readonly size?: import('../../types/component').QComponentSize | undefined;
                 readonly iconPos?: import('..').QButtonIconPosition | undefined;
                 readonly pill?: boolean | undefined;
                 readonly disabled?: boolean | undefined;
                 readonly loading?: boolean | undefined;
+                readonly tabindex?: number | undefined;
                 readonly onClick?: ((event: Event) => any) | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: import('vue').Attrs;
@@ -101,7 +189,6 @@ declare const QTab: {
             }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
                 click: (event: Event) => any;
             }, string, {
-                size: import('..').QButtonSize;
                 variant: import('..').QButtonVariant;
                 color: string;
                 iconPos: import('..').QButtonIconPosition;
@@ -126,13 +213,12 @@ declare const QTab: {
             $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 & {} & {
+        }>, "variant" | "color" | "iconPos"> & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: {
                 default?(_: {}): any;
                 append?(_: {}): any;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/index.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0B,CAAA;AACrC,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAOy30B,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAPt90B,CAAA;AAGnC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;AAGtB,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QTabs/index.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAQw30B,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EARp90B,CAAA;AACrC,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAOy30B,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAPt90B,CAAA;AAGnC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;AAGtB,cAAc,SAAS,CAAA"}

package/esm/components/QToggle/QToggle.vue.js

@@ -16,7 +16,8 @@ var d = /*@__PURE__*/ r({
 		iconPos: {},
 		pill: { type: Boolean },
 		disabled: { type: Boolean },
-		loading: { type: Boolean }
+		loading: { type: Boolean },
+		tabindex: {}
 	}, {
 		modelValue: { type: Boolean },
 		modelModifiers: {}

package/esm/components/QToggle/index.d.ts

@@ -8,11 +8,12 @@ declare const QToggle: {
         borderless?: boolean;
         elevated?: boolean;
         block?: boolean;
-        size?: import('..').QButtonSize;
+        size?: import('../../types/component').QComponentSize;
         iconPos?: import('..').QButtonIconPosition;
         pill?: boolean;
         disabled?: boolean;
         loading?: boolean;
+        tabindex?: number;
     }> & Readonly<{
         "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
@@ -33,11 +34,12 @@ declare const QToggle: {
         borderless?: boolean;
         elevated?: boolean;
         block?: boolean;
-        size?: import('..').QButtonSize;
+        size?: import('../../types/component').QComponentSize;
         iconPos?: import('..').QButtonIconPosition;
         pill?: boolean;
         disabled?: boolean;
         loading?: boolean;
+        tabindex?: number;
     }> & Readonly<{
         "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     }>, {}, {}, {}, {}, {}>;
@@ -53,11 +55,12 @@ declare const QToggle: {
     borderless?: boolean;
     elevated?: boolean;
     block?: boolean;
-    size?: import('..').QButtonSize;
+    size?: import('../../types/component').QComponentSize;
     iconPos?: import('..').QButtonIconPosition;
     pill?: boolean;
     disabled?: boolean;
     loading?: boolean;
+    tabindex?: number;
 }> & Readonly<{
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {

package/esm/components/QToggle/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QToggle/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4B,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAE,CAAA;AAGlB,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QToggle/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4B,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAE,CAAA;AAGlB,cAAc,SAAS,CAAA"}

package/esm/components/QToggleGroup/QToggleGroup.vue.js

@@ -11,6 +11,7 @@ var m = /*@__PURE__*/ i({
 		block: { type: Boolean },
 		borderless: { type: Boolean },
 		elevated: { type: Boolean },
+		size: {},
 		disabled: { type: Boolean },
 		multiple: { type: Boolean },
 		required: { type: Boolean }

package/esm/components/QToggleGroup/QToggleGroupItem.vue.js

@@ -19,6 +19,7 @@ var d = /*@__PURE__*/ i({
 		pill: { type: Boolean },
 		disabled: { type: Boolean },
 		loading: { type: Boolean },
+		tabindex: {},
 		value: {}
 	},
 	setup(i) {

package/esm/components/QToggleGroup/index.d.ts

@@ -5,6 +5,7 @@ declare const QToggleGroup: {
         block?: boolean;
         borderless?: boolean;
         elevated?: boolean;
+        size?: import('../../types/component').QComponentSize;
         disabled?: boolean;
     } & {
         multiple?: boolean;
@@ -26,6 +27,7 @@ declare const QToggleGroup: {
         block?: boolean;
         borderless?: boolean;
         elevated?: boolean;
+        size?: import('../../types/component').QComponentSize;
         disabled?: boolean;
     } & {
         multiple?: boolean;
@@ -42,6 +44,7 @@ declare const QToggleGroup: {
     block?: boolean;
     borderless?: boolean;
     elevated?: boolean;
+    size?: import('../../types/component').QComponentSize;
     disabled?: boolean;
 } & {
     multiple?: boolean;

package/esm/components/QToggleGroup/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QToggleGroup/index.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;EAAqC,CAAA;AAG3D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAA;AAGzC,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QToggleGroup/index.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;EAAqC,CAAA;AAG3D,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAA;AAGzC,cAAc,SAAS,CAAA"}

package/esm/components/QTooltip/types.d.ts

@@ -1,4 +1,4 @@
-import { Appearance, Placement, Trigger } from '../../composables/overlay';
+import { Appearance, Placement, Trigger } from '../../utils/overlay';
 import { Selector } from '../../utils/getElement';
 import { Icon } from '../QIcon';
 import { QBaseComponentProps } from '../../types/component';

package/esm/components/QTooltip/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QTooltip/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG;IACjD;;;;OAIG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;;OAIG;IACH,IAAI,CAAC,EAAE,IAAI,CAAA;IAEX;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,UAAU,CAAA;IAEvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IAEd;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QTooltip/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG;IACjD;;;;OAIG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;;OAIG;IACH,IAAI,CAAC,EAAE,IAAI,CAAA;IAEX;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,UAAU,CAAA;IAEvB;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;IAEd;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA"}

package/esm/components/__internal__/QClearButton/QClearButton.vue.js

@@ -24,7 +24,7 @@ var p = /*@__PURE__*/ o({
 			variant: "ghost",
 			color: "neutral",
 			borderless: "",
-			tabindex: "-1",
+			tabindex: -1,
 			onClick: m
 		}, {
 			default: f(() => [a(d(t), l(s(o.icons.clear)), null, 16)]),

package/esm/composables/useSafeTriangle/index.d.ts

@@ -1,4 +1,4 @@
-import { Placement } from '../overlay';
+import { Placement } from '../../utils/overlay';
 import { Ref } from 'vue';
 type UseSafeTriangleOptions = {
     enabled: Ref<boolean>;

package/esm/composables/useSafeTriangle/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/useSafeTriangle/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAW3C,OAAO,EAA+B,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAE3D,KAAK,sBAAsB,GAAG;IAC7B,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACrB,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;IACzB,aAAa,EAAE,MAAM,OAAO,GAAG,IAAI,CAAA;IACnC,cAAc,EAAE,MAAM,OAAO,GAAG,IAAI,CAAA;IACpC,cAAc,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IACxC,mBAAmB,EAAE,MAAM,OAAO,CAAA;IAClC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,iFAAiF;IACjF,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3D,CAAA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB;;;;;;;wBA4HnC,MAAM,YAAY,MAAM;;;;;EA0DnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/useSafeTriangle/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAWpD,OAAO,EAA+B,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAE3D,KAAK,sBAAsB,GAAG;IAC7B,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACrB,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;IACzB,aAAa,EAAE,MAAM,OAAO,GAAG,IAAI,CAAA;IACnC,cAAc,EAAE,MAAM,OAAO,GAAG,IAAI,CAAA;IACpC,cAAc,EAAE,MAAM,WAAW,GAAG,IAAI,CAAA;IACxC,mBAAmB,EAAE,MAAM,OAAO,CAAA;IAClC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,iFAAiF;IACjF,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3D,CAAA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB;;;;;;;wBA4HnC,MAAM,YAAY,MAAM;;;;;EA0DnD"}