bitboss-ui 3.0.0-beta.2 → 3.0.0-beta.21

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

@@ -5,10 +5,98 @@ export type FixedColumnConfig = number | {
     position: 'left' | 'right';
 };
 /**
- * Applies sticky positioning to fixed table columns.
- * Call after DOM updates (e.g. in watch with flush: 'post') to read layout.
+ * Splits the grid root's *resolved* `grid-template-columns` (one
+ * `getComputedStyle` read) into its px tokens, verbatim. Returns `null` when
+ * any token is not a px length: a table hidden by `display: none` reports its
+ * SPECIFIED template (`max-content auto …`) instead of used values, and the
+ * caller must keep its last good measurement rather than publish keywords.
+ *
+ * Read the root only — a subgrid box reports the literal `subgrid [] [] …`.
  */
-export declare const applyFixedTableColumns: (table: HTMLTableElement, fixedColumns: FixedColumnConfig[]) => void;
+export declare const readResolvedTracks: (root: Element) => string[] | null;
+/**
+ * Applies sticky positioning to fixed table columns — a RECONCILE pass, not a
+ * set-only one: every cell of every processed row ends up with exactly the
+ * inline `position`/`left`/`right` its slot calls for, and nothing else.
+ *
+ * `root` is the grid root (`.bb-table__table`). Offsets are prefix sums of the
+ * resolved track list, so they hold to the subpixel regardless of what sized
+ * the track (frozen width, inherited parent track, content). Call after DOM
+ * updates (e.g. in a `flush: 'post'` watch) and after every re-measure so the
+ * offsets follow the tracks.
+ *
+ * The pass is POSITIONAL (indices into the rendered track list, `select`
+ * included); the table resolves them from `column.fixed` / `fixed-select` /
+ * `fixed-actions` against the RENDERED column list on every change, so the
+ * pin follows the column. Cells are keyed by column, so a reorder MOVES the
+ * cell element — inline styles travel with it. A cell that stops being pinned
+ * (its column un-pinned, hidden, or another column moved into the slot it
+ * used to hold) would keep `position: sticky; left: 0px` and, once the
+ * container scrolls, paint over its neighbours (a stale `left` on a
+ * right-pinned cell would linger too), which is why every non-pinned cell is
+ * cleared and every pinned cell has its opposite side cleared. Clearing an
+ * absent inline property is mutation-free, so the pass is idempotent and
+ * cheap.
+ */
+export declare const applyFixedTableColumns: (root: HTMLElement, fixedColumns: FixedColumnConfig[], 
+/**
+ * The resolved tracks when the caller already holds them (the measure path
+ * just read them; a `virtual` window change moves no track): skips the
+ * `getComputedStyle` read, which forces style on every call.
+ */
+resolvedTracks?: string[] | null, 
+/**
+ * Skip rows whose inline styles were already written for this exact track
+ * list and pin config — the caller opting in to the row stamp below. Only
+ * safe when the CELL ORDER cannot have changed since the last pass, which
+ * is the caller's knowledge, not ours: a reorder can leave the track list
+ * and the config byte-identical while every cell has moved to a different
+ * track. `virtual`'s window-move pass is exactly that case (the rows
+ * change, the columns do not).
+ */
+memoize?: boolean) => void;
+/**
+ * Completes an `order` model against the declared column keys: the
+ * model's keys first (duplicates dropped, first occurrence wins), then every
+ * declared key the model omits, in declaration order. Unknown keys (columns
+ * the consumer currently hides) are kept in place.
+ */
+export declare const completeColumnOrder: (model: readonly string[], declared: readonly string[]) => string[];
+/**
+ * Declared columns in render order — the completed model restricted to the
+ * declared keys. A key declared twice keeps both columns (parity with the
+ * unordered render), adjacent, in declaration order.
+ */
+export declare const orderColumns: <C extends {
+    key: string;
+}>(columns: readonly C[], model: readonly string[]) => C[];
+/**
+ * The write-back. Moves `key` to render index `toIndex` among the RENDERED
+ * columns (the declared keys minus `hidden`) and returns the complete model
+ * to emit: the completed model with exactly ONE entry relocated — what
+ * dragging that entry in a panel listing the complete order (hidden columns
+ * included) would produce. `hidden` is the set of declared keys that render
+ * nothing (`column.hidden`); a key the consumer dropped from `columns`
+ * altogether is simply undeclared and behaves the same way.
+ *
+ * Invariants (each pinned by a unit test):
+ *  1. completeness — a permutation of `completeColumnOrder(model, declared)`,
+ *     no duplicates;
+ *  2. single relocation — `result` without `key` equals the completed model
+ *     without `key`: every other key, hidden ones included, keeps its
+ *     relative order (this IS the "hidden columns keep their slot" guarantee);
+ *  3. render index — among the rendered keys, `key` sits at
+ *     `clamp(toIndex, 0, N - 1)`;
+ *  4. adjacency — `key` lands right AFTER (moving right) / right BEFORE
+ *     (moving left) the visible column it displaces, so a hidden key is never
+ *     caught between the mover and its new neighbour;
+ *  5. stability — an unknown or hidden `key`, or `toIndex` equal to the
+ *     current index, returns the completed model unchanged (callers compare
+ *     against the completed model and emit nothing).
+ */
+export declare const moveColumnKey: (model: readonly string[], declared: readonly string[], key: string, toIndex: number, hidden?: ReadonlySet<string>) => string[];
+/** Sequence equality for the commit guard. */
+export declare const sameColumnOrder: (a: readonly string[], b: readonly string[]) => boolean;
 /**
  * Converts a column key (e.g. "address.nested.value") to a slot-safe name (e.g. "address_nested_value").
  * Thin alias over the shared {@link slotKey} normalizer used across every
@@ -20,7 +108,7 @@ export declare const columnKeyToSlotName: (key: string) => string;
  */
 export declare const mergeHeaderClasses: (base: Classes, global?: Classes, column?: Classes) => Classes;
 /**
- * Accumulates every row-class source for a row's `<tr>`: the table-level
+ * Accumulates every row-class source for a data row: the table-level
  * `rowClass` prop (item function or static), then each column's `rowClass`
  * (resolved with that column's cell content, like `tdClass`), in column order.
  */

package/dist/components/BbTable/utils.js

@@ -1,53 +1,88 @@
 import { useLogger as e } from "../../composables/useLogger.js";
 import { slotKey as t } from "../../utilities/functions/slotKey.js";
 //#region src/components/BbTable/utils.ts
-var n = (t, n) => {
-	if (!n.length) return;
-	let r = Array.from(t.querySelectorAll(":scope > thead th"));
-	if (!r.length) return;
-	let { error: i } = e(), a = r.length, o = n.map((e) => ({
+var n = /^-?\d*\.?\d+px$/, r = (e) => {
+	let t = getComputedStyle(e).gridTemplateColumns;
+	if (!t || t === "none") return null;
+	let r = t.trim().split(/\s+/);
+	return r.every((e) => n.test(e)) ? r : null;
+}, i = [
+	"bb-table-expand__row",
+	"bb-table-no-data__row",
+	"bb-table-spacer__row",
+	"bb-table-placeholder__row"
+], a = (t, n, a, o = !1) => {
+	let s = a ?? r(t);
+	if (!s) return;
+	let { error: c } = e(), l = s.length, u = s.map((e) => parseFloat(e)), d = n.map((e) => ({
 		index: typeof e == "number" ? e : e.index,
 		position: typeof e == "number" ? "left" : e.position
-	})).sort((e, t) => e.position === t.position ? e.position === "left" ? e.index - t.index : t.index - e.index : e.position === "left" ? -1 : 1).reduce((e, t) => {
-		let n = r[t.index];
-		if (!n) return i(`BbTable fixedColumns: Cannot affix column at index ${t.index}. Table has ${a} columns (valid indices: 0–${a - 1}).`), e;
-		let { width: o } = n.getBoundingClientRect(), s = e.filter((e) => e.position === t.position).reduce((e, t) => e + t.width, 0);
+	})).sort((e, t) => e.position === t.position ? e.position === "left" ? e.index - t.index : t.index - e.index : e.position === "left" ? -1 : 1), f = d.reduce((e, t) => {
+		let n = u[t.index];
+		if (n === void 0) return c(`BbTable fixed columns: cannot affix the column at rendered index ${t.index}. Table has ${l} columns (valid indices: 0–${l - 1}).`), e;
+		let r = e.filter((e) => e.position === t.position).reduce((e, t) => e + t.width, 0);
 		return e.push({
 			index: t.index,
 			position: t.position,
-			width: Math.floor(o),
-			offset: s
+			width: n,
+			offset: r
 		}), e;
-	}, []);
-	Array.from(t.querySelectorAll(":scope > thead > tr, :scope > tbody > tr")).forEach((e) => {
-		let t = e.querySelectorAll(":scope > td, :scope > th");
-		Array.from(t).some((e) => e.colSpan > 1) || t.length < a || o.forEach((t) => {
-			let n = e.querySelector(`:scope > :nth-child(${t.index + 1})`);
-			n && (n.style.position = "sticky", n.style[t.position] = `${t.offset}px`);
-		});
+	}, []), p = Array.from(t.querySelectorAll(":scope > .bb-table__head > [role=\"row\"], :scope > .bb-table__body > [role=\"row\"]")), m = new Map(f.map((e) => [e.index, e])), h = `${s.join(" ")}|${JSON.stringify(d)}`;
+	p.forEach((e) => {
+		if (!i.some((t) => e.classList.contains(t)) && !(e.children.length < l) && !(o && e.__bbFixedStamp === h)) {
+			for (let t = 0; t < l; t++) {
+				let n = e.children[t];
+				if (!n) continue;
+				let r = m.get(t);
+				if (!r) {
+					n.style.position === "sticky" && (n.style.removeProperty("position"), n.style.removeProperty("left"), n.style.removeProperty("right"));
+					continue;
+				}
+				n.style.position = "sticky", n.style[r.position] = `${r.offset}px`, n.style.removeProperty(r.position === "left" ? "right" : "left");
+			}
+			e.__bbFixedStamp = h;
+		}
 	});
-}, r = (e) => Array.isArray(e) ? e : [e], i = t, a = (e, t, n) => {
-	let i = [...r(e)];
-	return t && i.push(...r(t)), n && i.push(...r(n)), i;
-}, o = (e, t, n, i) => {
-	let a = [], o = (e) => {
-		e && a.push(...r(e));
+}, o = (e, t) => {
+	let n = /* @__PURE__ */ new Set(), r = [];
+	for (let i of [...e, ...t]) n.has(i) || (n.add(i), r.push(i));
+	return r;
+}, s = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		let e = String(t.key), r = n.get(e);
+		r ? r.push(t) : n.set(e, [t]);
+	}
+	return o(t, [...n.keys()]).flatMap((e) => n.get(e) ?? []);
+}, c = (e, t, n, r, i = /* @__PURE__ */ new Set()) => {
+	let a = new Set(t), s = o(e, t), c = s.filter((e) => a.has(e) && !i.has(e)), l = c.indexOf(n);
+	if (l < 0) return s;
+	let u = Math.max(0, Math.min(c.length - 1, r));
+	if (u === l) return s;
+	let d = c[u], f = s.filter((e) => e !== n);
+	return f.splice(f.indexOf(d) + +(u > l), 0, n), f;
+}, l = (e, t) => e.length === t.length && e.every((e, n) => e === t[n]), u = (e) => Array.isArray(e) ? e : [e], d = t, f = (e, t, n) => {
+	let r = [...u(e)];
+	return t && r.push(...u(t)), n && r.push(...u(n)), r;
+}, p = (e, t, n, r) => {
+	let i = [], a = (e) => {
+		e && i.push(...u(e));
 	};
-	return o(typeof e == "function" ? e(i) : e), t.forEach((e, t) => {
-		let r = e.rowClass;
-		r && o(typeof r == "function" ? r(n[t]?.content, String(e.key), i) : r);
-	}), a;
-}, s = (e, t, n, i, a, o) => {
-	let s = [...r(e)], c = (e) => typeof e == "function" ? e(i, a, o) : e;
+	return a(typeof e == "function" ? e(r) : e), t.forEach((e, t) => {
+		let i = e.rowClass;
+		i && a(typeof i == "function" ? i(n[t]?.content, String(e.key), r) : i);
+	}), i;
+}, m = (e, t, n, r, i, a) => {
+	let o = [...u(e)], s = (e) => typeof e == "function" ? e(r, i, a) : e;
 	if (t) {
-		let e = c(t);
-		e && s.push(...r(e));
+		let e = s(t);
+		e && o.push(...u(e));
 	}
 	if (n) {
-		let e = c(n);
-		e && s.push(...r(e));
+		let e = s(n);
+		e && o.push(...u(e));
 	}
-	return s;
+	return o;
 };
 //#endregion
-export { n as applyFixedTableColumns, i as columnKeyToSlotName, s as mergeCellClasses, a as mergeHeaderClasses, o as mergeRowClasses };
+export { a as applyFixedTableColumns, d as columnKeyToSlotName, o as completeColumnOrder, m as mergeCellClasses, f as mergeHeaderClasses, p as mergeRowClasses, c as moveColumnKey, s as orderColumns, r as readResolvedTracks, l as sameColumnOrder };

package/dist/components/BbTabs/types.d.ts

@@ -54,14 +54,6 @@ export type BbTabsInertiaOptions = {
      * Only meaningful in an Inertia context.
      */
     preserveState?: boolean | ((props: Record<string, unknown>) => boolean) | null;
-    /**
-     * Uses history replacement instead of push navigation.
-     *
-     * Prefer `replace` whenever `navigation` is on: the URL still carries the
-     * active tab (deep-linkable, survives reload), but switching tabs does not
-     * stack a history entry per click, so Back leaves the page instead of
-     * walking the user backwards through every tab they visited.
-     */
     replace?: boolean;
 };
 export type BbTabsEvents<K extends string = string> = 

package/dist/components/BbTag/BbTag.vue.d.ts

@@ -1,6 +1,6 @@
 import { BbTagProps, BbTagEvents, BbTagSlots } from './types';
-export type { BbTagProps, BbTagEvents, BbTagSlots };
 type __VLS_Slots = BbTagSlots;
+export type { BbTagProps, BbTagEvents, BbTagSlots };
 declare const __VLS_base: import('vue').DefineComponent<BbTagProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     input: (event: Event) => any;
     click: (event: MouseEvent) => any;

package/dist/components/BbTag/BbTag.vue_vue_type_script_setup_true_lang.js

@@ -1,8 +1,8 @@
-import { removedPropsFor as e } from "../../deprecation/removedProps.js";
-import { warnRemovedAttrs as t } from "../../utilities/functions/warnRemovedAttrs.js";
-import n from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
-import r from "../BbBaseTag/BbBaseTag.vue.js";
-import { config as i } from "virtual:bitboss-ui/config";
+import { useConfig as e } from "../../composables/useConfig.js";
+import { removedPropsFor as t } from "../../deprecation/removedProps.js";
+import { warnRemovedAttrs as n } from "../../utilities/functions/warnRemovedAttrs.js";
+import r from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
+import i from "../BbBaseTag/BbBaseTag.vue.js";
 import { computed as a, createBlock as o, createVNode as s, defineComponent as c, guardReactiveProps as l, mergeProps as u, normalizeProps as d, openBlock as f, ref as p, renderSlot as m, withCtx as h } from "vue";
 //#region src/components/BbTag/BbTag.vue?vue&type=script&setup=true&lang.ts
 var g = /*@__PURE__*/ c({
@@ -60,21 +60,21 @@ var g = /*@__PURE__*/ c({
 		"update:modelValue"
 	],
 	setup(c, { emit: g }) {
-		let _ = c, v = g;
-		process.env.NODE_ENV !== "production" && t("BbTag", e("BbTag"));
-		let y = p(!1), b = a(() => _.persistentHint || y.value), x = a(() => (_.modelValue?.length ?? 0) > 0), S = a(() => _.labelMode ?? i.defaultInputLabelMode), C = {
+		let _ = c, v = g, y = e();
+		process.env.NODE_ENV !== "production" && n("BbTag", t("BbTag"));
+		let b = p(!1), x = a(() => _.persistentHint || b.value), S = a(() => (_.modelValue?.length ?? 0) > 0), C = a(() => _.labelMode ?? y.defaultInputLabelMode), w = {
 			onBlur: (e) => v("blur", e),
 			onChange: (e) => v("change", e),
 			onClick: (e) => v("click", e),
 			onDuplicate: (e) => v("duplicate", e),
 			onFocus: (e) => {
-				y.value = !0, v("focus", e);
+				b.value = !0, v("focus", e);
 			},
 			onActive: () => {
-				y.value = !0, v("active");
+				b.value = !0, v("active");
 			},
 			onInactive: () => {
-				y.value = !1, v("inactive");
+				b.value = !1, v("inactive");
 			},
 			onInput: (e) => v("input", e),
 			onKeydown: (e) => v("keydown", e),
@@ -87,7 +87,7 @@ var g = /*@__PURE__*/ c({
 			onMax: (e) => v("max", e),
 			"onUpdate:modelValue": (e) => v("update:modelValue", e)
 		};
-		return (e, t) => (f(), o(n, {
+		return (e, t) => (f(), o(r, {
 			id: e.id,
 			class: "bb-tag",
 			compact: e.compact,
@@ -95,21 +95,21 @@ var g = /*@__PURE__*/ c({
 			direction: e.direction,
 			errors: e.errors,
 			"has-errors": e.hasErrors,
-			"has-value": x.value,
+			"has-value": S.value,
 			"has-warning": e.hasWarning,
 			"hide-label": e.hideLabel,
 			hint: e.hint,
 			label: e.label,
-			"label-mode": S.value,
+			"label-mode": C.value,
 			"label-position": e.labelPosition,
 			"model-value": e.modelValue,
 			name: e.name,
 			reverse: e.reverse,
-			"show-hint": b.value,
+			"show-hint": x.value,
 			warnings: e.warnings
 		}, {
 			label: h((t) => [m(e.$slots, "label", d(l(t)))]),
-			input: h(({ id: t, hasErrors: n, hasWarning: i, ariaDescribedby: a }) => [s(r, u({
+			input: h(({ id: t, hasErrors: n, hasWarning: r, ariaDescribedby: a }) => [s(i, u({
 				id: t,
 				"append:icon": _["append:icon"],
 				"aria-describedby": a,
@@ -122,7 +122,7 @@ var g = /*@__PURE__*/ c({
 				disabled: e.disabled,
 				divider: e.divider,
 				"has-errors": n,
-				"has-warning": i,
+				"has-warning": r,
 				loading: e.loading,
 				max: e.max,
 				"model-value": e.modelValue,
@@ -131,7 +131,7 @@ var g = /*@__PURE__*/ c({
 				"prepend:icon": _["prepend:icon"],
 				readonly: e.readonly,
 				required: e.required
-			}, C), {
+			}, w), {
 				"prepend-outer": h((t) => [m(e.$slots, "prepend-outer", d(l(t)))]),
 				prepend: h((t) => [m(e.$slots, "prepend", d(l(t)))]),
 				prefix: h((t) => [m(e.$slots, "prefix", d(l(t)))]),

package/dist/components/BbTextInput/BbTextInput.vue.d.ts

@@ -1,6 +1,6 @@
 import { BbTextInputProps, BbTextInputEvents, BbTextInputSlots } from './types';
-export type { BbTextInputProps, BbTextInputEvents, BbTextInputSlots };
 type __VLS_Slots = BbTextInputSlots;
+export type { BbTextInputProps, BbTextInputEvents, BbTextInputSlots };
 declare const __VLS_base: import('vue').DefineComponent<BbTextInputProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     input: (event: Event) => any;
     click: (event: MouseEvent) => any;

package/dist/components/BbTextInput/BbTextInput.vue_vue_type_script_setup_true_lang.js

@@ -1,8 +1,8 @@
-import { useMobile as e } from "../../composables/useMobile.js";
-import t from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
-import { isNotEmpty as n } from "../../utilities/functions/isNotEmpty.js";
-import r from "../BbBaseTextInput/BbBaseTextInput.vue.js";
-import { config as i } from "virtual:bitboss-ui/config";
+import { useConfig as e } from "../../composables/useConfig.js";
+import { useMobile as t } from "../../composables/useMobile.js";
+import n from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
+import { isNotEmpty as r } from "../../utilities/functions/isNotEmpty.js";
+import i from "../BbBaseTextInput/BbBaseTextInput.vue.js";
 import { computed as a, createBlock as o, createSlots as s, createVNode as c, defineComponent as l, guardReactiveProps as u, mergeProps as d, normalizeProps as f, openBlock as p, ref as m, renderSlot as h, unref as g, withCtx as _ } from "vue";
 //#region src/components/BbTextInput/BbTextInput.vue?vue&type=script&setup=true&lang.ts
 var v = /*@__PURE__*/ l({
@@ -56,14 +56,14 @@ var v = /*@__PURE__*/ l({
 		"update:modelValue"
 	],
 	setup(l, { emit: v }) {
-		let y = l, b = v, x = m(!1), S = a(() => y.persistentHint || x.value), { isMobile: C } = e(), w = a(() => !!y.clearable && n(y.modelValue)), T = a(() => n(y.modelValue)), E = a(() => y.labelMode ?? i.defaultInputLabelMode), D = {
+		let y = l, b = v, x = e(), S = m(!1), C = a(() => y.persistentHint || S.value), { isMobile: w } = t(), T = a(() => !!y.clearable && r(y.modelValue)), E = a(() => r(y.modelValue)), D = a(() => y.labelMode ?? x.defaultInputLabelMode), O = {
 			onBlur: (e) => {
-				x.value = !1, b("blur", e);
+				S.value = !1, b("blur", e);
 			},
 			onChange: (e) => b("change", e),
 			onClick: (e) => b("click", e),
 			onFocus: (e) => {
-				x.value = !0, b("focus", e);
+				S.value = !0, b("focus", e);
 			},
 			onInput: (e) => b("input", e),
 			onKeydown: (e) => b("keydown", e),
@@ -75,34 +75,34 @@ var v = /*@__PURE__*/ l({
 			onCompositionend: (e) => b("compositionend", e),
 			"onUpdate:modelValue": (e) => b("update:modelValue", e)
 		};
-		return (e, n) => (p(), o(t, {
+		return (e, t) => (p(), o(n, {
 			id: e.id,
 			class: "bb-text-input",
-			clearable: w.value,
+			clearable: T.value,
 			compact: e.compact,
 			description: e.description,
 			direction: e.direction,
 			disabled: e.disabled,
 			errors: e.errors,
 			"has-errors": e.hasErrors,
-			"has-value": T.value,
+			"has-value": E.value,
 			"has-warning": e.hasWarning,
 			"hide-label": e.hideLabel,
 			hint: e.hint,
 			label: e.label,
-			"label-mode": E.value,
+			"label-mode": D.value,
 			"label-position": e.labelPosition,
 			loading: e.loading,
-			mobile: g(C),
+			mobile: g(w),
 			"model-value": e.modelValue,
 			name: e.name,
 			readonly: e.readonly,
 			reverse: e.reverse,
-			"show-hint": S.value,
+			"show-hint": C.value,
 			warnings: e.warnings
 		}, {
 			label: _((t) => [h(e.$slots, "label", f(u(t)))]),
-			input: _(({ id: t, hasErrors: n, hasWarning: i, ariaDescribedby: a }) => [c(r, d({
+			input: _(({ id: t, hasErrors: n, hasWarning: r, ariaDescribedby: a }) => [c(i, d({
 				id: t,
 				"append:icon": y["append:icon"],
 				"aria-describedby": a,
@@ -113,9 +113,9 @@ var v = /*@__PURE__*/ l({
 				disabled: e.disabled,
 				"emit-masked": e.emitMasked,
 				"has-errors": n,
-				"has-warning": i,
+				"has-warning": r,
 				"input-mode": e.inputMode,
-				"label-mode": E.value,
+				"label-mode": D.value,
 				loading: e.loading,
 				mask: e.mask,
 				"model-value": e.modelValue,
@@ -125,7 +125,7 @@ var v = /*@__PURE__*/ l({
 				readonly: e.readonly,
 				required: e.required,
 				type: e.type
-			}, D), s({
+			}, O), s({
 				"append-outer": _(() => [h(e.$slots, "append-outer")]),
 				append: _(() => [h(e.$slots, "append")]),
 				prepend: _(() => [h(e.$slots, "prepend")]),

package/dist/components/BbTextarea/BbTextarea.vue.d.ts

@@ -1,6 +1,6 @@
 import { BbTextareaProps, BbTextareaEvents, BbTextareaSlots } from './types';
-export type { BbTextareaProps, BbTextareaEvents, BbTextareaSlots };
 type __VLS_Slots = BbTextareaSlots;
+export type { BbTextareaProps, BbTextareaEvents, BbTextareaSlots };
 declare const __VLS_base: import('vue').DefineComponent<BbTextareaProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     input: (event: Event) => any;
     click: (event: MouseEvent) => any;

package/dist/components/BbTextarea/BbTextarea.vue_vue_type_script_setup_true_lang.js

@@ -1,7 +1,7 @@
-import e from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
-import { isNotEmpty as t } from "../../utilities/functions/isNotEmpty.js";
-import n from "../BbBaseTextarea/BbBaseTextarea.vue.js";
-import { config as r } from "virtual:bitboss-ui/config";
+import { useConfig as e } from "../../composables/useConfig.js";
+import t from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
+import { isNotEmpty as n } from "../../utilities/functions/isNotEmpty.js";
+import r from "../BbBaseTextarea/BbBaseTextarea.vue.js";
 import { computed as i, createBlock as a, createVNode as o, defineComponent as s, guardReactiveProps as c, mergeProps as l, normalizeProps as u, openBlock as d, ref as f, renderSlot as p, withCtx as m } from "vue";
 //#region src/components/BbTextarea/BbTextarea.vue?vue&type=script&setup=true&lang.ts
 var h = /*@__PURE__*/ s({
@@ -53,14 +53,14 @@ var h = /*@__PURE__*/ s({
 		"update:modelValue"
 	],
 	setup(s, { emit: h }) {
-		let g = s, _ = h, v = f(!1), y = i(() => g.persistentHint || v.value), b = i(() => !!g.clearable && t(g.modelValue)), x = i(() => t(g.modelValue)), S = i(() => g.labelMode ?? r.defaultInputLabelMode), C = {
+		let g = s, _ = h, v = e(), y = f(!1), b = i(() => g.persistentHint || y.value), x = i(() => !!g.clearable && n(g.modelValue)), S = i(() => n(g.modelValue)), C = i(() => g.labelMode ?? v.defaultInputLabelMode), w = {
 			onBlur: (e) => {
-				v.value = !1, _("blur", e);
+				y.value = !1, _("blur", e);
 			},
 			onChange: (e) => _("change", e),
 			onClick: (e) => _("click", e),
 			onFocus: (e) => {
-				v.value = !0, _("focus", e);
+				y.value = !0, _("focus", e);
 			},
 			onInput: (e) => _("input", e),
 			onKeydown: (e) => _("keydown", e),
@@ -72,59 +72,59 @@ var h = /*@__PURE__*/ s({
 			onCompositionend: (e) => _("compositionend", e),
 			"onUpdate:modelValue": (e) => _("update:modelValue", e)
 		};
-		return (t, r) => (d(), a(e, {
-			id: t.id,
+		return (e, n) => (d(), a(t, {
+			id: e.id,
 			class: "bb-textarea",
-			clearable: b.value,
-			compact: t.compact,
-			description: t.description,
-			direction: t.direction,
-			disabled: t.disabled,
-			errors: t.errors,
-			"has-errors": t.hasErrors,
-			"has-value": x.value,
-			"has-warning": t.hasWarning,
-			"hide-label": t.hideLabel,
-			hint: t.hint,
-			label: t.label,
-			"label-mode": S.value,
-			"label-position": t.labelPosition,
-			loading: t.loading,
-			"model-value": t.modelValue,
-			name: t.name,
-			readonly: t.readonly,
-			reverse: t.reverse,
-			"show-hint": y.value,
-			warnings: t.warnings
+			clearable: x.value,
+			compact: e.compact,
+			description: e.description,
+			direction: e.direction,
+			disabled: e.disabled,
+			errors: e.errors,
+			"has-errors": e.hasErrors,
+			"has-value": S.value,
+			"has-warning": e.hasWarning,
+			"hide-label": e.hideLabel,
+			hint: e.hint,
+			label: e.label,
+			"label-mode": C.value,
+			"label-position": e.labelPosition,
+			loading: e.loading,
+			"model-value": e.modelValue,
+			name: e.name,
+			readonly: e.readonly,
+			reverse: e.reverse,
+			"show-hint": b.value,
+			warnings: e.warnings
 		}, {
-			label: m((e) => [p(t.$slots, "label", u(c(e)))]),
-			input: m(({ id: e, hasErrors: r, hasWarning: i, ariaDescribedby: a }) => [o(n, l({
-				id: e,
+			label: m((t) => [p(e.$slots, "label", u(c(t)))]),
+			input: m(({ id: t, hasErrors: n, hasWarning: i, ariaDescribedby: a }) => [o(r, l({
+				id: t,
 				"append:icon": g["append:icon"],
 				"aria-describedby": a,
-				"auto-grow": t.autoGrow,
-				autocomplete: t.autocomplete,
-				autofocus: t.autofocus,
-				clearable: t.clearable,
-				compact: t.compact,
-				disabled: t.disabled,
-				"has-errors": r,
+				"auto-grow": e.autoGrow,
+				autocomplete: e.autocomplete,
+				autofocus: e.autofocus,
+				clearable: e.clearable,
+				compact: e.compact,
+				disabled: e.disabled,
+				"has-errors": n,
 				"has-warning": i,
-				loading: t.loading,
-				"model-value": t.modelValue,
-				name: t.name,
-				placeholder: t.placeholder,
+				loading: e.loading,
+				"model-value": e.modelValue,
+				name: e.name,
+				placeholder: e.placeholder,
 				"prepend:icon": g["prepend:icon"],
-				readonly: t.readonly,
-				required: t.required,
-				rows: t.rows
-			}, C), {
-				"append-outer": m(() => [p(t.$slots, "append-outer")]),
-				append: m(() => [p(t.$slots, "append")]),
-				prepend: m(() => [p(t.$slots, "prepend")]),
-				"prepend-outer": m(() => [p(t.$slots, "prepend-outer")]),
-				prefix: m((e) => [p(t.$slots, "prefix", u(c(e)))]),
-				suffix: m((e) => [p(t.$slots, "suffix", u(c(e)))]),
+				readonly: e.readonly,
+				required: e.required,
+				rows: e.rows
+			}, w), {
+				"append-outer": m(() => [p(e.$slots, "append-outer")]),
+				append: m(() => [p(e.$slots, "append")]),
+				prepend: m(() => [p(e.$slots, "prepend")]),
+				"prepend-outer": m(() => [p(e.$slots, "prepend-outer")]),
+				prefix: m((t) => [p(e.$slots, "prefix", u(c(t)))]),
+				suffix: m((t) => [p(e.$slots, "suffix", u(c(t)))]),
 				_: 2
 			}, 1040, [
 				"id",

package/dist/components/BbTimePicker/BbTimePicker.vue.d.ts

@@ -19,9 +19,9 @@ declare const __VLS_base: import('vue').DefineComponent<BbTimePickerProps, {}, {
         value: string;
     }) => any) | undefined;
 }>, {
+    adaptive: boolean;
     offset: number;
     transitionDuration: number;
-    adaptive: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;