bitboss-ui 3.0.0-beta.63 → 3.0.0-beta.65

package/dist/components/BbTable/utils.d.ts

@@ -158,9 +158,20 @@ export declare const mergeRowClasses: <Item>(global: RowClasses<Item> | undefine
 export declare const mergeCellClasses: (base: Classes, global?: ColumnClasses, column?: ColumnClasses, content?: any, key?: string, item?: any) => Classes;
 /** Estimated width of `text` on one line, in em. */
 export declare const textEm: (text: string) => number;
+/** The per-character table runs up to 8% short of Arial on short values
+ * (measured on the corpus): a unit is reserved with that margin. It is the
+ * ESTIMATE's margin: after mount the real widths raise a reservation past it
+ * (`profileValues`' `measure`), never below it. */
+export declare const UNIT_MARGIN = 1.08;
+/** The estimate reads only some of `count` rows (`sampleForEstimate`). */
+export declare const estimateSamples: (count: number) => boolean;
 export declare const sampleForEstimate: <T>(rows: readonly T[]) => readonly T[];
 /** What a column's values say, apart from its label and padding: figured
- * once per set of values, so a resize re-runs only `estimateFromProfile`. */
+ * once per set of values, so a resize re-runs only `estimateFromProfile`.
+ * `units`, `coreUnits`, `token`, `proseUnits` and `proseWord` are
+ * RESERVATIONS: the estimate with its margin, raised to the measured width
+ * where one is known. The rest is estimate only (comfort widths, and the
+ * pre-corpus floor `squeeze` is what rendered before, by definition). */
 export type ColumnProfile = {
     p75: number;
     p90: number;
@@ -172,12 +183,79 @@ export type ColumnProfile = {
     token: number;
     /** The widest unit of a prose column's short values. */
     proseUnits: number;
+    /** The longest word a prose column holds (up to 8em, no margin). */
+    proseWord: number;
     /** Share of long spaced values, figures excluded, and as Q9.1b counted. */
     spaced: number;
     spacedLegacy: number;
+    /** Most values are long and spaced: the column wraps by design. */
+    prose: boolean;
+    /** A short column's 95th-percentile unit, past which a value is a rare
+     * outlier (`Infinity`: fewer than 20 values, or prose). */
+    usual: number;
+};
+/** A value's real widths, in em of the body text (`--bb-fs`), measured once
+ * the table has rendered: the whole value on one line, and its widest
+ * space-separated run. */
+export type MeasuredText = {
+    whole?: number;
+    word?: number;
+};
+/** Looks up a value's measured widths (`undefined`: not measured). */
+export type MeasureLookup = (text: string) => MeasuredText | undefined;
+/** The whole px a measured width reserves: at least 0.05px above the real
+ * width, which a box of exactly that width wraps in some engine at some
+ * zoom (and `Math.floor` of it wraps in every engine). */
+export declare const reservePx: (px: number) => number;
+/**
+ * The header spacer's px for a fitted floor (`--floor`): the text share of
+ * `floorEm` (the padding `padEm` apart), rounded DOWN so the floors still sum
+ * under the room. The epsilon keeps a floor that IS a reserved whole px at
+ * it: `(n / em + pad) - pad` comes back a hair under `n / em` for about one
+ * n in three, and flooring that would drop a held value's px.
+ */
+export declare const floorTextPx: (floorEm: number, padEm: number, em: number) => number;
+/** A text's runs between the spaces a line breaks at (a no-break space
+ * joins: `1.234,56\u00a0€` is one run), as measured and looked up. */
+export declare const breakRuns: (text: string) => string[];
+/**
+ * Profile a column's display values; `null` when none has text.
+ *
+ * `measure` gives the real widths the browser measured (in em of the body
+ * text, already rounded up, see `reservePx`). Each reservation is the larger
+ * of the estimate with its margin and the measured width of the part the
+ * value is held by (`cellRole`): the whole value for `line`/`token`, its
+ * longest run for `word`. RAISE ONLY: a font narrower than the estimate
+ * keeps the estimate, so without `measure` (the server, the first render)
+ * the numbers are exactly the estimate's.
+ */
+export declare const profileValues: (values: readonly string[], measure?: MeasureLookup) => ColumnProfile | null;
+/**
+ * The internal classes a body cell of an estimated column carries: how the
+ * fit holds its value (`--line`: whole, with spaces; `--token`: whole, one
+ * run; `--word`: by its longest word), and `--outlier` for a short column's
+ * rare outlier. From the estimate only, so the server writes the same
+ * classes; the table root's hold level (`fitFloors`' `hold`) turns them on.
+ * Not public API, like `--fluid`.
+ */
+export declare const cellRole: (text: string, profile: {
+    prose: boolean;
+    usual: number;
+}) => string[];
+/**
+ * The texts worth measuring in a column: every value that could be the
+ * widest of a reservation (within 1.5x of the estimated widest), whole for a
+ * value held whole, by its space-separated runs otherwise (`runs` also feed
+ * `token`, the longest unbreakable run). Same-shape values (every date of a
+ * column) are all candidates: the estimate cannot rank them, the font can.
+ *
+ * `prose` is the column profile's (`profileValues`, over every value, the
+ * call `cellRole` follows); by default it is figured the same way here.
+ */
+export declare const measureCandidates: (values: readonly string[], prose?: boolean) => {
+    whole: string[];
+    runs: string[];
 };
-/** Profile a column's display values; `null` when none has text. */
-export declare const profileValues: (values: readonly string[]) => ColumnProfile | null;
 /** One column's estimate, in em of the body text, cell padding included. */
 export type TrackEstimate = {
     /** Short values: the width they fit on one line (capped). */
@@ -229,16 +307,36 @@ export declare function estimateTrack(values: string[], label: string, padEm?: n
 }, 
 /** The padding the pre-corpus floor was figured with (`squeeze`). */
 legacyPadEm?: number): TrackEstimate;
-/** `estimateTrack` from a column's `profileValues`. */
+/** A heading measured in the header's own type, in em of the body text:
+ * `one` on one line, `two` the wider line of its most balanced split. */
+export type MeasuredLabel = {
+    one: number;
+    two: number;
+};
+/** `estimateTrack` from a column's `profileValues`. `labelMeasured` raises
+ * the label's widths to the measured ones (never lowers them). */
 export declare function estimateFromProfile(p: ColumnProfile | null, label: string, padEm?: number, headerExtraEm?: number, labelType?: {
     scale: number;
     spacingEm: number;
-}, legacyPadEm?: number): TrackEstimate;
+}, legacyPadEm?: number, labelMeasured?: MeasuredLabel): TrackEstimate;
+/**
+ * How much of what the estimate holds the fit's floors still cover, so the
+ * table root may promise it (index.css: held cells floor their own track):
+ * - `units`: every held value whole (`--line`/`--token`), every `--word` by
+ *   its word;
+ * - `core`: the same without the rare outliers (`--outlier`);
+ * - `words`: a single-run value whole (`--token`), the rest by its words;
+ * - `none`: nothing (the floors went below the longest runs).
+ */
+export type HoldLevel = 'units' | 'core' | 'words' | 'none';
 /** `fitFloors`' answer: each column's floor, and the columns whose heading
- * is given two lines to keep the table from scrolling. */
+ * is given two lines to keep the table from scrolling. `stage` is the stage
+ * the fit stopped at (6 split as 6a/6b/6c in `hold`). */
 export type FittedFloors = {
     floors: Record<string, number>;
     wrapLabels: Set<string>;
+    stage: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    hold: HoldLevel;
 };
 /**
  * Fit the estimated columns into the room left for them (same unit as the
@@ -257,5 +355,14 @@ export type FittedFloors = {
  * 7. Even that does not fit: the table scrolls anyway, so nothing is
  *    squeezed for it — short values at `hard`, prose at its floor, headings
  *    on one line.
+ *
+ * `hold` says what the floors still cover, for the table root to promise:
+ * `units` at every stage but 6 (each floor is at least `hard` or `wrapped`,
+ * which reserve every held value), `core` at 6 while the outliers alone give
+ * way, `words` while the floors stay above every column's longest run
+ * (`token`: a single-run value is whole there), `none` past that. A held
+ * cell floors its own track (index.css), so its reservation must never
+ * exceed its column's floor at that level, or a table that fitted would
+ * start to scroll; estimatedFloors.node.test.ts checks exactly that.
  */
 export declare function fitFloors(estimates: Record<string, TrackEstimate>, available: number): FittedFloors;

package/dist/components/BbTable/utils.js

@@ -180,116 +180,169 @@ var n = /^-?\d*\.?\d+px$/, r = (e) => {
 	}
 	let r = Math.min(10, Math.max(t, e.p90));
 	return Math.max(t, Math.min(r, 6)) + n;
-}, B = 1e3, V = 1e3, H = (e) => {
-	if (e.length <= 2e3) return e;
+}, B = 1e3, V = 1e3, H = (e) => e > 2e3, U = (e) => {
+	if (!H(e.length)) return e;
 	let t = e.slice(0, B), n = (e.length - B) / V;
 	for (let r = 0; r < V; r++) t.push(e[B + Math.floor(r * n)]);
 	return t;
-}, U = (e) => {
-	let t = 0;
-	for (let n of e) n > t && (t = n);
-	return t;
-}, W = (e) => {
-	let t = e.map((e) => e.trim()).filter(Boolean);
-	if (!t.length) return null;
-	let n = t.map(I), r = n.map((e) => e.width).sort((e, t) => e - t), i = n.map((e) => e.unit).sort((e, t) => e - t), a = C(i, .95), o = 0, s = 0;
-	return t.forEach((e, t) => {
-		e.length <= 24 || !/\s/.test(e) || (s++, n[t].figures || o++);
+}, W = (e) => Math.ceil(e + .05), G = (e, t, n) => Math.floor(Math.max(0, e - t) * n + 1e-4), K = 8, q = 20, J = /[ \t\n]/, Y = (e) => e.split(/[ \t\n]+/).filter(Boolean), X = (e, t, n) => (n ? t.width <= E : t.unit > 0 && t.unit >= t.width - 1e-9) ? J.test(e) ? "line" : "token" : n ? t.word > 0 && t.word <= K ? "word" : null : t.word > 0 && t.word <= t.unit ? "word" : null, Z = (e, t) => {
+	let n = 0, r = 0;
+	return e.forEach((e, i) => {
+		e.length <= 24 || !/\s/.test(e) || (r++, t[i].figures || n++);
+	}), {
+		spaced: n / e.length,
+		spacedLegacy: r / e.length
+	};
+}, Q = (e, t) => {
+	let n = e.map((e) => e.trim()).filter(Boolean);
+	if (!n.length) return null;
+	let r = n.map(I), i = r.map((e) => e.width).sort((e, t) => e - t), a = r.map((e) => e.unit).sort((e, t) => e - t), o = C(a, .95), s = Z(n, r), c = s.spaced >= .5, l = a.length >= q, u = 0, d = 0, f = 0, p = 0, m = 0, h = 0;
+	return n.forEach((e, n) => {
+		let i = r[n];
+		i.word > h && (h = i.word);
+		let a = t?.(e), s = a?.word ?? (J.test(e) ? void 0 : a?.whole);
+		if (i.unit > 0) {
+			let e = i.unit >= i.width - 1e-9, t = Math.max(i.unit * k, (e ? a?.whole : s) ?? 0);
+			t > u && (u = t), (!l || i.unit <= o) && t > d && (d = t), i.width <= E && t > p && (p = t);
+		}
+		if (i.word <= O) {
+			let e = Math.max(i.word * k, s ?? 0);
+			e > f && (f = e);
+		}
+		i.word <= K && s && s > m && (m = s);
+	}), {
+		p75: C(i, .75),
+		p90: C(i, .9),
+		longestWord: h,
+		units: u,
+		coreUnits: d,
+		token: f,
+		proseUnits: p,
+		proseWord: Math.max(m, Math.min(K, h)),
+		...s,
+		prose: c,
+		usual: l && !c ? o : Infinity
+	};
+}, ee = (e, t) => {
+	let n = e.trim();
+	if (!n) return [];
+	let r = I(n), i = X(n, r, t.prose);
+	if (!i) return [];
+	let a = `bb-table__cell--${i}`;
+	return r.unit > t.usual ? [a, "bb-table__cell--outlier"] : [a];
+}, $ = 1.5, te = (e, t) => {
+	let n = e.map((e) => e.trim()).filter(Boolean), r = [...new Set(n)], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
+	if (!r.length) return {
+		whole: [],
+		runs: []
+	};
+	let o = r.map(I);
+	t ??= Z(n, n.map(I)).spaced >= .5;
+	let s = 0, c = 0, l = 0;
+	o.forEach((e) => {
+		e.unit > s && (s = e.unit), e.word <= O && e.word > c && (c = e.word), e.word <= K && e.word > l && (l = e.word);
+	});
+	let u = (e, t) => {
+		if (!J.test(e)) return void a.add(e);
+		for (let n of Y(e)) S(n) * $ >= t.word && a.add(n);
+	};
+	return r.forEach((e, n) => {
+		let r = o[n], a = X(e, r, t);
+		if (!a) {
+			r.word <= O && r.word * $ >= c && u(e, r);
+			return;
+		}
+		(r.unit * $ >= s || r.word * $ >= c || t && r.word * $ >= l) && (a === "word" ? u(e, r) : (i.add(e), a === "line" && u(e, r)));
 	}), {
-		p75: C(r, .75),
-		p90: C(r, .9),
-		longestWord: U(n.map((e) => e.word)),
-		units: i.at(-1),
-		coreUnits: i.length >= 20 ? U(i.filter((e) => e <= a)) : i.at(-1),
-		token: U(n.map((e) => e.word <= O ? e.word : 0)),
-		proseUnits: U(n.map((e) => e.width <= E ? e.unit : 0)),
-		spaced: o / t.length,
-		spacedLegacy: s / t.length
+		whole: [...i],
+		runs: [...a]
 	};
 };
-function G(e, t, n = 1.5, r = 0, i = {
+function ne(e, t, n = 1.5, r = 0, i = {
 	scale: 1,
 	spacingEm: 0
-}, a = n) {
-	let o = (e, t) => (t * 1.08 + i.spacingEm * [...e].length) * i.scale + r, s = o(t, S(t)), c = w(t).length > 1 && S(t) > L ? o(t, R(t)) : s;
+}, a = n, o) {
+	let s = (e, t) => (t * 1.08 + i.spacingEm * [...e].length) * i.scale + r, c = Math.max(s(t, S(t)), o ? o.one + r : 0), l = w(t).length > 1 && S(t) > L ? Math.max(s(t, R(t)), o ? o.two + r : 0) : c;
 	if (!e) return {
-		min: s + n,
-		target: s + n,
-		hard: s + n,
-		wrapped: c + n,
-		squeeze: s + a,
-		label: s + n,
-		labelWrap: c + n,
+		min: c + n,
+		target: c + n,
+		hard: c + n,
+		wrapped: l + n,
+		squeeze: c + a,
+		label: c + n,
+		labelWrap: l + n,
 		token: n,
-		core: c + n,
+		core: l + n,
 		kind: "short"
 	};
-	let l = z(e, s, a), u = e.units * k, d = e.token * k + n;
-	if (e.spaced >= .5) {
-		let t = Math.min(30, Math.max(10, e.p75 / 3)), r = Math.min(16, Math.max(10, s, e.longestWord)), i = e.proseUnits * k, a = Math.min(8, e.longestWord), o = Math.max(s, a, i), u = Math.max(c, a, i), f = Math.max(t, r);
+	let u = z(e, c, a), d = e.units, f = e.token + n;
+	if (e.prose) {
+		let t = Math.min(30, Math.max(10, e.p75 / 3)), r = Math.min(16, Math.max(10, c, e.longestWord)), i = e.proseUnits, a = e.proseWord, o = Math.max(c, a, i), s = Math.max(l, a, i), d = Math.max(t, r, o);
 		return {
 			min: r + n,
-			target: f + n,
+			target: d + n,
 			hard: o + n,
-			wrapped: u + n,
-			squeeze: l,
-			label: s + n,
-			labelWrap: c + n,
-			token: Math.min(d, o + n),
-			core: u + n,
+			wrapped: s + n,
+			squeeze: u,
+			label: c + n,
+			labelWrap: l + n,
+			token: Math.min(f, o + n),
+			core: s + n,
 			kind: "prose"
 		};
 	}
-	let f = e.p90, p = Math.max(Math.min(10, f), s, u), m = Math.min(22, Math.max(p, f)), h = Math.max(u, Math.min(10, f, 6)), g = Math.max(c, e.coreUnits * k, Math.min(10, f, 6)) + n;
+	let p = e.p90, m = Math.max(Math.min(10, p), c, d), h = Math.min(22, Math.max(m, p)), g = Math.max(d, Math.min(10, p, 6)), _ = Math.max(l, e.coreUnits, Math.min(10, p, 6)) + n;
 	return {
-		min: p + n,
-		target: m + n,
-		hard: Math.max(s, h) + n,
-		wrapped: Math.max(c, h) + n,
-		squeeze: l,
-		label: s + n,
-		labelWrap: c + n,
-		token: Math.min(d, Math.max(c, h) + n),
-		core: g,
+		min: m + n,
+		target: h + n,
+		hard: Math.max(c, g) + n,
+		wrapped: Math.max(l, g) + n,
+		squeeze: u,
+		label: c + n,
+		labelWrap: l + n,
+		token: Math.min(f, Math.max(l, g) + n),
+		core: _,
 		kind: "short"
 	};
 }
-function K(e, t) {
-	let n = Object.keys(e), r = (t) => e[t], i = (e) => r(e).kind === "prose", a = n.filter((e) => !i(e)), o = n.filter(i), s = (e) => i(e) ? r(e).target : r(e).min, c = (e) => Math.max(r(e).hard, r(e).target / 2), l = (e) => Math.max(r(e).wrapped, r(e).target / 2), u = (e, t) => e.reduce((e, n) => e + t(n), 0), d = {}, f = /* @__PURE__ */ new Set(), p = () => ({
+function re(e, t) {
+	let n = Object.keys(e), r = (t) => e[t], i = (e) => r(e).kind === "prose", a = n.filter((e) => !i(e)), o = n.filter(i), s = (e) => i(e) ? r(e).target : r(e).min, c = (e) => Math.max(r(e).hard, r(e).target / 2), l = (e) => Math.max(r(e).wrapped, r(e).target / 2), u = (e, t) => e.reduce((e, n) => e + t(n), 0), d = {}, f = /* @__PURE__ */ new Set(), p = (e, t = "units") => ({
 		floors: d,
-		wrapLabels: f
+		wrapLabels: f,
+		stage: e,
+		hold: t
 	}), m = (e, t, n, r) => {
 		let i = u(e, n), a = u(e, r), o = i === a ? 1 : Math.max(0, Math.min(1, (t - a) / (i - a)));
 		for (let t of e) d[t] = r(t) + (n(t) - r(t)) * o;
 	}, h = (e) => r(e).hard;
 	if (!(t > 0) || u(n, s) <= t) {
 		for (let e of n) d[e] = s(e);
-		return p();
+		return p(1);
 	}
 	if (u(a, h) + u(o, s) <= t) {
 		for (let e of o) d[e] = s(e);
-		return m(a, t - u(o, s), s, h), p();
+		return m(a, t - u(o, s), s, h), p(2);
 	}
 	if (u(a, h) + u(o, c) <= t) {
 		for (let e of a) d[e] = h(e);
-		return m(o, t - u(a, h), s, c), p();
+		return m(o, t - u(a, h), s, c), p(3);
 	}
 	let g = (e) => i(e) ? l(e) : r(e).wrapped, _ = (e) => i(e) ? c(e) : h(e), v = () => {
 		for (let e of n) d[e] < r(e).label - 1e-9 && r(e).labelWrap < r(e).label && f.add(e);
 	};
-	if (u(n, g) <= t) return m(n, t, _, g), v(), p();
+	if (u(n, g) <= t) return m(n, t, _, g), v(), p(4);
 	if (u(a, g) + u(o, (e) => r(e).wrapped) <= t) {
 		for (let e of a) d[e] = g(e);
-		return m(o, t - u(a, g), g, (e) => r(e).wrapped), v(), p();
+		return m(o, t - u(a, g), g, (e) => r(e).wrapped), v(), p(5);
 	}
 	let y = (e) => Math.max(Math.min(r(e).wrapped, r(e).squeeze), r(e).labelWrap);
 	if (u(n, (e) => Math.max(r(e).squeeze, r(e).labelWrap)) <= t + .1 * n.length) {
-		if (u(n, (e) => r(e).core) <= t) return m(n, t, (e) => r(e).wrapped, (e) => r(e).core), v(), p();
-		let e = (e) => Math.max(y(e), Math.min(r(e).wrapped, r(e).token));
-		return u(n, e) <= t ? m(n, t, (e) => r(e).wrapped, e) : m(n, t, e, y), v(), p();
+		if (u(n, (e) => r(e).core) <= t) return m(n, t, (e) => r(e).wrapped, (e) => r(e).core), v(), p(6, "core");
+		let e = (e) => Math.max(y(e), Math.min(r(e).wrapped, r(e).token)), i = u(n, e) <= t;
+		return i ? m(n, t, (e) => r(e).wrapped, e) : m(n, t, e, y), v(), p(6, i ? "words" : "none");
 	}
 	for (let e of n) d[e] = _(e);
-	return p();
+	return p(7);
 }
 //#endregion
-export { a as applyFixedTableColumns, m as cellsLabelText, p as columnKeyToSlotName, o as completeColumnOrder, G as estimateFromProfile, K as fitFloors, l as lockColumnOrder, v as mergeCellClasses, g as mergeHeaderClasses, _ as mergeRowClasses, c as moveColumnKey, s as orderColumns, W as profileValues, r as readResolvedTracks, u as reorderRange, h as rowNameText, d as sameColumnOrder, H as sampleForEstimate, S as textEm };
+export { k as UNIT_MARGIN, a as applyFixedTableColumns, Y as breakRuns, ee as cellRole, m as cellsLabelText, p as columnKeyToSlotName, o as completeColumnOrder, ne as estimateFromProfile, H as estimateSamples, re as fitFloors, G as floorTextPx, l as lockColumnOrder, te as measureCandidates, v as mergeCellClasses, g as mergeHeaderClasses, _ as mergeRowClasses, c as moveColumnKey, s as orderColumns, Q as profileValues, r as readResolvedTracks, u as reorderRange, W as reservePx, h as rowNameText, d as sameColumnOrder, U as sampleForEstimate, S as textEm };

package/dist/components/BbTabs/BbTabs.vue_vue_type_script_setup_true_lang.js

@@ -1,15 +1,17 @@
-import { usePassthrough as e } from "../../composables/usePassthrough.js";
-import { removedPropsFor as t } from "../../deprecation/removedProps.js";
-import { slotKey as n } from "../../utilities/functions/slotKey.js";
-import { warnRemovedAttrs as r } from "../../utilities/functions/warnRemovedAttrs.js";
-import { createTabsContext as i } from "../../composables/useBbTabsContext.js";
-import { omitName as a, pickName as o } from "./tablistName.js";
-import { BB_TABS_LIST_HOST_PARTS as s, BB_TABS_PANELS_HOST_PARTS as c, BB_TABS_PT as l } from "./types.js";
-import u from "./BbTabsList.vue.js";
-import d from "./BbTabsPanels.vue.js";
-import { createElementBlock as f, createSlots as p, createVNode as m, defineComponent as h, guardReactiveProps as g, mergeProps as _, normalizeProps as v, openBlock as y, renderList as b, renderSlot as x, unref as S, useAttrs as C, useSlots as w, withCtx as T } from "vue";
+import { registeredVariantNames as e, usePassthrough as t, variantPt as n } from "../../composables/usePassthrough.js";
+import { removedPropsFor as r } from "../../deprecation/removedProps.js";
+import { slotKey as i } from "../../utilities/functions/slotKey.js";
+import { warnRemovedAttrs as a } from "../../utilities/functions/warnRemovedAttrs.js";
+import { createTabsContext as o } from "../../composables/useBbTabsContext.js";
+import { TABS_VARIANTS as s } from "../../types/TabsVariant.js";
+import { omitName as c, pickName as l } from "./tablistName.js";
+import { BB_TABS_LIST_HOST_PARTS as u, BB_TABS_LIST_PT as d, BB_TABS_PANELS_HOST_PARTS as f, BB_TABS_PT as p } from "./types.js";
+import m from "./BbTabsList.vue.js";
+import h from "./BbTabsPanels.vue.js";
+import { createElementBlock as g, createSlots as _, createVNode as v, defineComponent as y, guardReactiveProps as b, mergeProps as x, normalizeProps as S, openBlock as C, renderList as w, renderSlot as T, unref as E, useAttrs as D, useSlots as O, withCtx as k } from "vue";
 //#region src/components/BbTabs/BbTabs.vue?vue&type=script&setup=true&lang.ts
-var E = ["id"], D = /*@__PURE__*/ h({
+var A = ["id"], j = /*@__PURE__*/ y({
+	mixins: [n(p)],
 	inheritAttrs: !1,
 	__name: "BbTabs",
 	props: {
@@ -33,6 +35,18 @@ var E = ["id"], D = /*@__PURE__*/ h({
 		"pt:panels:disabled": {},
 		"pt:panel:active": {},
 		"pt:panel:disabled": {},
+		"pt:wrapper:pill": {},
+		"pt:wrapper:line": {},
+		"pt:wrapper:none": {},
+		"pt:list:pill": {},
+		"pt:list:line": {},
+		"pt:list:none": {},
+		"pt:item:pill": {},
+		"pt:item:line": {},
+		"pt:item:none": {},
+		"pt:indicator:pill": {},
+		"pt:indicator:line": {},
+		"pt:indicator:none": {},
 		"pt:item": {},
 		pt: {},
 		headers: {},
@@ -71,37 +85,41 @@ var E = ["id"], D = /*@__PURE__*/ h({
 		variant: { default: "pill" }
 	},
 	emits: ["update:modelValue"],
-	setup(h, { emit: D }) {
-		let O = h, k = D;
-		process.env.NODE_ENV !== "production" && r("BbTabs", t("BbTabs"), {
-			slotKeys: () => (O.items ?? []).map((e) => e.value),
+	setup(n, { emit: y }) {
+		let j = n, M = y;
+		process.env.NODE_ENV !== "production" && a("BbTabs", r("BbTabs"), {
+			slotKeys: () => (j.items ?? []).map((e) => e.value),
 			family: "BbTabs"
 		});
-		let A = w(), j = () => (O.items ?? []).some((e) => !!A[n(e.value)]), { id: M, direction: N, block: P, compact: F, disabled: I } = i(O, k), L = C(), R = e({
+		let N = O(), P = () => (j.items ?? []).some((e) => !!N[i(e.value)]), { id: F, direction: I, block: L, compact: R, disabled: z } = o(j, M), B = D(), V = t({
 			component: "BbTabs",
-			attrs: L,
-			props: O,
-			parts: l.parts,
-			states: l.states,
-			active: { disabled: () => !!O.disabled }
-		}), z = () => a(R.rootAttrs), B = (e) => Object.fromEntries(Object.entries(e).map(([e, t]) => [t, e])), V = B(s), H = B(c);
-		return (e, t) => (y(), f("div", _({
-			id: S(M),
+			attrs: B,
+			props: j,
+			parts: p.parts,
+			states: p.states,
+			active: { disabled: () => !!j.disabled },
+			variant: {
+				...p.variant,
+				current: () => j.variant
+			}
+		}), H = [...d.states, ...e(s, "tabsVariants")], U = () => c(V.rootAttrs), W = (e) => Object.fromEntries(Object.entries(e).map(([e, t]) => [t, e])), G = W(u), K = W(f);
+		return (e, t) => (C(), g("div", x({
+			id: E(F),
 			class: ["bb-tabs", {
-				[`bb-tabs--${S(N)}`]: !0,
-				"bb-tabs--block": S(P),
-				"bb-tabs--compact": S(F),
-				"bb-tabs--disabled": S(I),
-				"bb-tabs--no-panels": !j()
+				[`bb-tabs--${E(I)}`]: !0,
+				"bb-tabs--block": E(L),
+				"bb-tabs--compact": E(R),
+				"bb-tabs--disabled": E(z),
+				"bb-tabs--no-panels": !P()
 			}]
-		}, z()), [m(u, _(S(o)(S(L)), { pt: S(R).forwardInstance(S(V)) }), p({ _: 2 }, [b(S(A), (t, n) => ({
+		}, U()), [v(m, x(E(l)(E(B)), { pt: E(V).forwardInstance(E(G), H) }), _({ _: 2 }, [w(E(N), (t, n) => ({
 			name: n,
-			fn: T((t) => [x(e.$slots, n, v(g(t)))])
-		}))]), 1040, ["pt"]), m(d, { pt: S(R).forwardInstance(S(H)) }, p({ _: 2 }, [b(S(A), (t, n) => ({
+			fn: k((t) => [T(e.$slots, n, S(b(t)))])
+		}))]), 1040, ["pt"]), v(h, { pt: E(V).forwardInstance(E(K)) }, _({ _: 2 }, [w(E(N), (t, n) => ({
 			name: n,
-			fn: T((t) => [x(e.$slots, n, v(g(t)))])
-		}))]), 1032, ["pt"])], 16, E));
+			fn: k((t) => [T(e.$slots, n, S(b(t)))])
+		}))]), 1032, ["pt"])], 16, A));
 	}
 });
 //#endregion
-export { D as default };
+export { j as default };