@bridge-ui/vue 0.0.1-beta.7 → 0.0.2

package/dist/Components/TabPanel/tabPanel.types.d.ts

@@ -0,0 +1,48 @@
+import { HTMLAttributes, Slot } from 'vue';
+import { MergeHtmlProps } from '@bridge-ui/core';
+export interface TabPanelClasses {
+    /**
+     * Classes merged onto the panel root.
+     */
+    root?: string;
+}
+export interface TabPanelCustomProps {
+    /**
+     * Props forwarded to the panel root.
+     */
+    root?: HTMLAttributes;
+}
+/**
+ * Tab panel (`role="tabpanel"`). Visibility follows the matching `Tab` `value`.
+ */
+export interface TabPanelOwnProps {
+    /**
+     * Classes for panel parts.
+     *
+     * @default undefined
+     */
+    classes?: TabPanelClasses;
+    /**
+     * Props forwarded to each panel part.
+     *
+     * @default undefined
+     */
+    customProps?: TabPanelCustomProps;
+    /**
+     * When set, overrides `Tabs` `keepMounted` for this panel.
+     *
+     * @default undefined
+     */
+    keepMounted?: boolean;
+    /**
+     * Stable value matching a `Tab`.
+     */
+    value: string;
+}
+export interface TabPanelSlots {
+    /**
+     * The panel content.
+     */
+    default?: Slot<undefined>;
+}
+export type TabPanelProps = MergeHtmlProps<TabPanelOwnProps, HTMLAttributes>;

package/dist/Components/Tabs/Tabs.js

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

package/dist/Components/Tabs/Tabs.vue.d.ts

@@ -0,0 +1,24 @@
+import { TabsOwnProps, TabsSlots } from './tabs.types';
+type __VLS_Slots = TabsSlots;
+type __VLS_Props = TabsOwnProps;
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: unknown[]) => any;
+    change: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+}>, {
+    keepMounted: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Tabs/Tabs.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,73 @@
+import { resolveNamedSlot as e } from "../../Utils/slotOrProp.js";
+import t from "../Tab/Tab.js";
+import n from "../TabList/TabList.js";
+import r from "../TabPanel/TabPanel.js";
+import { useTabs as i } from "./composables/useTabs.js";
+import { Fragment as a, computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createSlots as u, createTextVNode as d, createVNode as f, defineComponent as p, guardReactiveProps as m, mergeModels as h, normalizeProps as g, openBlock as _, renderList as v, resolveDynamicComponent as y, toDisplayString as b, unref as x, useModel as S, useSlots as C, withCtx as w } from "vue";
+//#region src/Components/Tabs/Tabs.vue?vue&type=script&setup=true&lang.ts
+var T = /* @__PURE__ */ p({
+	inheritAttrs: !1,
+	__name: "Tabs",
+	props: /* @__PURE__ */ h({
+		activation: {},
+		classes: {},
+		color: {},
+		customProps: {},
+		keepMounted: {
+			type: Boolean,
+			default: !0
+		},
+		orientation: {},
+		size: {},
+		variant: {}
+	}, {
+		modelValue: { default: "" },
+		modelModifiers: {}
+	}),
+	emits: /* @__PURE__ */ h(["change", "update:modelValue"], ["update:modelValue"]),
+	setup(p, { emit: h }) {
+		let T = C(), E = h, { rootBind: D, tabItems: O } = i(p, {
+			size: "md",
+			variant: "line",
+			color: "primary",
+			keepMounted: !0,
+			activation: "automatic",
+			orientation: "horizontal"
+		}, S(p, "modelValue"), E), k = o(() => O.value.length > 0);
+		return (i, o) => (_(), l("div", g(m(x(D))), [k.value ? (_(), l(a, { key: 0 }, [f(n, null, {
+			default: w(() => [(_(!0), l(a, null, v(x(O), (e) => (_(), s(t, {
+				key: e.value,
+				value: e.value,
+				"end-icon": e.endIcon,
+				disabled: e.disabled,
+				"start-icon": e.startIcon
+			}, u({
+				default: w(() => [typeof e.label == "string" ? (_(), l(a, { key: 0 }, [d(b(e.label), 1)], 64)) : (_(), s(y(e.label), { key: 1 }))]),
+				_: 2
+			}, [e.slots?.start ? {
+				name: "start",
+				fn: w(() => [(_(), s(y(e.slots.start)))]),
+				key: "0"
+			} : void 0, e.slots?.end ? {
+				name: "end",
+				fn: w(() => [(_(), s(y(e.slots.end)))]),
+				key: "1"
+			} : void 0]), 1032, [
+				"value",
+				"end-icon",
+				"disabled",
+				"start-icon"
+			]))), 128))]),
+			_: 1
+		}), (_(!0), l(a, null, v(x(O), (e) => (_(), s(r, {
+			key: e.value,
+			value: e.value,
+			"keep-mounted": e.keepMounted
+		}, {
+			default: w(() => [(_(), s(y(e.panel)))]),
+			_: 2
+		}, 1032, ["value", "keep-mounted"]))), 128))], 64)) : c("", !0), (_(), s(y(x(e)(x(T), "default"))))], 16));
+	}
+});
+//#endregion
+export { T as default };

package/dist/Components/Tabs/composables/useTabs.d.ts

@@ -0,0 +1,39 @@
+import { Ref, SetupContext } from 'vue';
+import { LibDefaultsShape, MergeLibDefaults } from '@bridge-ui/core';
+import { TabsEmits, TabsOwnProps, TabsProps } from '../tabs.types';
+import { TabsContextValue, TabsItemEntry } from '../tabsInjectionKey';
+type TabsLibDefaults = LibDefaultsShape<TabsOwnProps, "size" | "color" | "variant" | "activation" | "keepMounted" | "orientation">;
+type TabsMerged = MergeLibDefaults<TabsOwnProps, TabsLibDefaults>;
+export declare function useTabs(props: TabsOwnProps, libDefaults: TabsLibDefaults, model: Ref<string | undefined>, emit: SetupContext<TabsEmits>["emit"]): {
+    merged: import('vue').ComputedRef<TabsMerged>;
+    rootBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<{
+        class: string;
+    }, "class", import('vue').HTMLAttributes | undefined, Omit<TabsProps, "color" | "orientation" | "size" | "classes" | "customProps" | "variant" | "keepMounted" | "activation">>>;
+    tabItems: Ref<{
+        disabled?: boolean | undefined;
+        endIcon?: import('@lucide/vue').LucideIcon | undefined;
+        keepMounted?: boolean | undefined;
+        label: string | (() => import('vue').VNodeChild);
+        panel: () => import('vue').VNodeChild;
+        slots?: {
+            end?: (() => import('vue').VNodeChild) | undefined;
+            start?: (() => import('vue').VNodeChild) | undefined;
+        } | undefined;
+        startIcon?: import('@lucide/vue').LucideIcon | undefined;
+        value: string;
+    }[], TabsItemEntry[] | {
+        disabled?: boolean | undefined;
+        endIcon?: import('@lucide/vue').LucideIcon | undefined;
+        keepMounted?: boolean | undefined;
+        label: string | (() => import('vue').VNodeChild);
+        panel: () => import('vue').VNodeChild;
+        slots?: {
+            end?: (() => import('vue').VNodeChild) | undefined;
+            start?: (() => import('vue').VNodeChild) | undefined;
+        } | undefined;
+        startIcon?: import('@lucide/vue').LucideIcon | undefined;
+        value: string;
+    }[]>;
+    contextValue: import('vue').ComputedRef<TabsContextValue>;
+};
+export {};

package/dist/Components/Tabs/composables/useTabs.js

@@ -0,0 +1,99 @@
+import { mergePartBind as e, useBridgeUIComponent as t, useBridgeUIMergedRegistryClasses as n } from "../../../Utils/index.js";
+import { TABS_INJECTION_KEY as r } from "../tabsInjectionKey.js";
+import { computed as i, provide as a, ref as o, useAttrs as s, useId as c } from "vue";
+import { get as l } from "es-toolkit/compat";
+import { cn as u, getTabId as d, mergeBridgeUILayeredClasses as f, splitComponentProps as p } from "@bridge-ui/core";
+import { colorProps as m, orientationProps as h, sizeProps as g, variantProps as _ } from "@bridge-ui/core/Components/Tabs";
+//#region src/Components/Tabs/composables/useTabs.ts
+var v = [
+	"size",
+	"color",
+	"classes",
+	"variant",
+	"activation",
+	"customProps",
+	"keepMounted",
+	"orientation"
+];
+function y(y, b, x, S) {
+	let C = c(), w = s(), T = `bridge-tabs${C}`, E = o([]), D = o([]), O = o([]), k = i(() => p({
+		bridgeKeys: v,
+		props: {
+			...w,
+			...y
+		}
+	})), { merged: A, entry: j } = t({
+		libDefaults: b,
+		componentName: "Tabs",
+		props: () => k.value.componentProps
+	}), M = i(() => x.value ?? "");
+	function N(e) {
+		D.value.includes(e) || (x.value = e, S("update:modelValue", e), S("change", e));
+	}
+	function P(e, t = !1) {
+		return E.value.includes(e) || (E.value = [...E.value, e]), t ? D.value.includes(e) || (D.value = [...D.value, e]) : D.value = D.value.filter((t) => t !== e), (x.value ?? "") === "" && !t && (x.value = e), () => {
+			E.value = E.value.filter((t) => t !== e), D.value = D.value.filter((t) => t !== e);
+		};
+	}
+	function F(e) {
+		document.getElementById(d(T, e))?.focus();
+	}
+	function I(e) {
+		let t = O.value.findIndex((t) => t.value === e.value);
+		if (t === -1) O.value = [...O.value, e];
+		else {
+			let n = [...O.value];
+			n[t] = e, O.value = n;
+		}
+		return (x.value ?? "") === "" && !e.disabled && (x.value = e.value), () => {
+			O.value = O.value.filter((t) => t.value !== e.value);
+		};
+	}
+	let L = n({
+		entry: j,
+		props: () => k.value.componentProps
+	}), R = i(() => f(g, j.value?.customProps?.size)), z = i(() => f(_, j.value?.customProps?.variant)), B = i(() => f(m, j.value?.customProps?.color)), V = i(() => f(h, j.value?.customProps?.orientation)), H = i(() => l(R.value, A.value.size)), U = i(() => l(z.value, A.value.variant)), W = i(() => l(B.value, A.value.color)), G = i(() => l(V.value, A.value.orientation)), K = i(() => ({
+		focusTab: F,
+		id: T,
+		setSelected: N,
+		registerTab: P,
+		registerTabItem: I,
+		selected: M.value,
+		tabItems: O.value,
+		tabValues: E.value,
+		disabledValues: D.value,
+		keepMounted: A.value.keepMounted !== !1,
+		activation: A.value.activation ?? "automatic",
+		orientation: A.value.orientation ?? "horizontal",
+		tokenClasses: {
+			tabSize: l(H.value, "tab"),
+			iconGap: l(H.value, "gap"),
+			iconSize: l(H.value, "icon"),
+			listSize: l(H.value, "list"),
+			panelSize: l(H.value, "panel"),
+			tabVariant: l(U.value, "tab"),
+			listVariant: l(U.value, "list"),
+			tabOrientation: l(G.value, "tab"),
+			colorSelected: l(W.value, "tabSelected"),
+			listOrientation: l(G.value, "list"),
+			rootOrientation: l(G.value, "root"),
+			panelOrientation: l(G.value, "panel"),
+			tabVariantSelected: l(U.value, "tabSelected"),
+			colorSelectedSoft: l(W.value, "tabSelectedSoft"),
+			softFill: A.value.variant === "pill" || A.value.variant === "solid"
+		}
+	}));
+	a(r, K);
+	let q = i(() => A.value.customProps);
+	return {
+		merged: A,
+		rootBind: i(() => e(q.value?.root, k.value.inheritedAttrs, { class: u({
+			[l(G.value, "root") ?? ""]: !0,
+			[l(L.value, "root") ?? ""]: !0
+		}) })),
+		tabItems: O,
+		contextValue: K
+	};
+}
+//#endregion
+export { y as useTabs };

package/dist/Components/Tabs/index.d.ts

@@ -0,0 +1,4 @@
+export { useTabs } from './composables/useTabs';
+export type { TabsClasses, TabsColorOverrides, TabsCustomProps, TabsEmits, TabsOrientationOverrides, TabsOwnProps, TabsProps, TabsSizeOverrides, TabsSlots, TabsVariantOverrides, } from './tabs.types';
+export { default as Tabs } from './Tabs.vue';
+export { TABS_INJECTION_KEY, type TabsContextValue, type TabsItemEntry, type TabsTokenClasses, } from './tabsInjectionKey';

package/dist/Components/Tabs/index.js

@@ -0,0 +1,4 @@
+import { TABS_INJECTION_KEY as e } from "./tabsInjectionKey.js";
+import { useTabs as t } from "./composables/useTabs.js";
+import n from "./Tabs.js";
+export { e as TABS_INJECTION_KEY, n as Tabs, t as useTabs };

package/dist/Components/Tabs/tabs.types.d.ts

@@ -0,0 +1,93 @@
+import { HTMLAttributes, Slot } from 'vue';
+import { MergeHtmlProps, MergeProps, TabsActivation, TabsColor, TabsOrientation, TabsSize, TabsVariant } from '@bridge-ui/core';
+export interface TabsSizeOverrides {}
+export interface TabsColorOverrides {}
+export interface TabsVariantOverrides {}
+export interface TabsOrientationOverrides {}
+export interface TabsClasses {
+    /**
+     * Classes merged onto the root.
+     */
+    root?: string;
+}
+export interface TabsCustomProps {
+    /**
+     * Props forwarded to the root element.
+     */
+    root?: HTMLAttributes;
+}
+export interface TabsEmits {
+    /**
+     * Emitted when the selected tab changes.
+     */
+    change: [value: string];
+    /**
+     * Emitted when `v-model` should update.
+     */
+    "update:modelValue": [value: string];
+}
+/**
+ * Tabs context root. Compose with `TabList`, `Tab`, and `TabPanel`.
+ */
+export interface TabsOwnProps {
+    /**
+     * Keyboard activation: `automatic` selects on arrow focus; `manual` needs Enter/Space.
+     *
+     * @default "automatic"
+     */
+    activation?: TabsActivation;
+    /**
+     * Classes for tabs parts.
+     *
+     * @default undefined
+     */
+    classes?: TabsClasses;
+    /**
+     * Accent color for the selected tab.
+     *
+     * @default "primary"
+     */
+    color?: MergeProps<TabsColor, TabsColorOverrides>;
+    /**
+     * Props forwarded to each tabs part.
+     *
+     * @default undefined
+     */
+    customProps?: TabsCustomProps;
+    /**
+     * When true, inactive panels stay mounted (hidden).
+     *
+     * @default true
+     */
+    keepMounted?: boolean;
+    /**
+     * Layout orientation of the tab list.
+     *
+     * @default "horizontal"
+     */
+    orientation?: MergeProps<TabsOrientation, TabsOrientationOverrides>;
+    /**
+     * Size of the tab list and triggers.
+     *
+     * @default "md"
+     */
+    size?: MergeProps<TabsSize, TabsSizeOverrides>;
+    /**
+     * Visual style of the tab list / selected tab.
+     *
+     * @default "line"
+     */
+    variant?: MergeProps<TabsVariant, TabsVariantOverrides>;
+}
+export interface TabsSlots {
+    /**
+     * The children to render (`TabList`, `TabPanel`, etc.).
+     */
+    default?: Slot<undefined>;
+}
+export type TabsProps = MergeHtmlProps<TabsOwnProps, HTMLAttributes> & {
+    /**
+     * Bound with `v-model` on the component (`defineModel` internally).
+     */
+    modelValue?: string;
+};

package/dist/Components/Tabs/tabsInjectionKey.d.ts

@@ -0,0 +1,121 @@
+import { LucideIcon } from '@lucide/vue';
+import { ComputedRef, InjectionKey, VNodeChild } from 'vue';
+import { TabsActivation } from '@bridge-ui/core';
+/**
+ * Merged token classes for triggers / list / panel.
+ */
+export type TabsTokenClasses = {
+    colorSelected?: string;
+    colorSelectedSoft?: string;
+    iconGap?: string;
+    iconSize?: string;
+    listOrientation?: string;
+    listSize?: string;
+    listVariant?: string;
+    panelOrientation?: string;
+    panelSize?: string;
+    rootOrientation?: string;
+    softFill?: boolean;
+    tabOrientation?: string;
+    tabSize?: string;
+    tabVariant?: string;
+    tabVariantSelected?: string;
+};
+/**
+ * Declarative tab + panel registered by `TabItem`.
+ */
+export type TabsItemEntry = {
+    /**
+     * Whether the tab is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Optional trailing Lucide icon on the tab trigger.
+     */
+    endIcon?: LucideIcon;
+    /**
+     * When set, overrides `Tabs` `keepMounted` for this panel.
+     */
+    keepMounted?: boolean;
+    /**
+     * Trigger label content (string or render function).
+     */
+    label: string | (() => VNodeChild);
+    /**
+     * Panel content render function.
+     */
+    panel: () => VNodeChild;
+    /**
+     * Custom start / end adornment render functions for the tab trigger.
+     */
+    slots?: {
+        end?: () => VNodeChild;
+        start?: () => VNodeChild;
+    };
+    /**
+     * Optional leading Lucide icon on the tab trigger.
+     */
+    startIcon?: LucideIcon;
+    /**
+     * Stable value matching the tab / panel pair.
+     */
+    value: string;
+};
+/**
+ * Shared tabs state for `TabList` / `Tab` / `TabPanel` / `TabItem` descendants.
+ */
+export type TabsContextValue = {
+    /**
+     * Keyboard activation mode.
+     */
+    activation: TabsActivation;
+    /**
+     * Disabled tab values.
+     */
+    disabledValues: string[];
+    /**
+     * Focus a tab by value (roving tabindex).
+     */
+    focusTab: (value: string) => void;
+    /**
+     * Stable id prefix for tab / panel pairing.
+     */
+    id: string;
+    /**
+     * Whether panels stay mounted when inactive.
+     */
+    keepMounted: boolean;
+    /**
+     * Orientation of the tab list.
+     */
+    orientation: "vertical" | "horizontal";
+    /**
+     * Registers a tab trigger and returns unregister.
+     */
+    registerTab: (value: string, disabled?: boolean) => () => void;
+    /**
+     * Registers a declarative `TabItem` (label + panel) and returns unregister.
+     */
+    registerTabItem: (entry: TabsItemEntry) => () => void;
+    /**
+     * Currently selected tab value.
+     */
+    selected: string;
+    /**
+     * Selects a tab by value.
+     */
+    setSelected: (value: string) => void;
+    /**
+     * Declarative items from `TabItem` children (mount order).
+     */
+    tabItems: TabsItemEntry[];
+    /**
+     * Ordered tab values (mount order).
+     */
+    tabValues: string[];
+    /**
+     * Merged token classes for triggers / list / panel.
+     */
+    tokenClasses: TabsTokenClasses;
+};
+export declare const TABS_INJECTION_KEY: InjectionKey<ComputedRef<TabsContextValue>>;

package/dist/Components/Tabs/tabsInjectionKey.js

@@ -0,0 +1,4 @@
+//#region src/Components/Tabs/tabsInjectionKey.ts
+var e = Symbol("bridge-tabs");
+//#endregion
+export { e as TABS_INJECTION_KEY };

package/dist/Utils/index.d.ts

@@ -43,5 +43,7 @@ export declare function resolveFieldAdornmentIconSize(fieldSize?: keyof FormFiel
  */
 export declare function resolveVnodeRefElement(element: null | Element | ComponentPublicInstance): null | HTMLElement;
 export { hasNamedSlot, hasSlotOrProp, isPropPresent, resolveNamedSlot, resolveSlotOrProp, } from './slotOrProp';
+export { useBreakpoint } from './useBreakpoint';
+export type { UseBreakpointOptions } from './useBreakpoint';
 export { useHoldRepeat } from './useHoldRepeat';
 export type { HoldRepeatAction, UseHoldRepeatOptions, } from './useHoldRepeat';

package/dist/Utils/index.js

@@ -1,39 +1,40 @@
 import { useBridgeUI as e } from "../Provider/useBridgeUI.js";
 import { hasNamedSlot as t, hasSlotOrProp as n, isPropPresent as r, resolveNamedSlot as i, resolveSlotOrProp as a } from "./slotOrProp.js";
-import { useHoldRepeat as o } from "./useHoldRepeat.js";
-import { computed as s, defineComponent as c, toValue as l, unref as u } from "vue";
-import { get as d, isNil as f } from "es-toolkit/compat";
-import { createMergePartBind as p } from "@bridge-ui/core";
-import { mergeBridgeUILayeredClasses as m, mergePropsWithBridgeUIDefaults as h } from "@bridge-ui/core/Utils";
+import { useBreakpoint as o } from "./useBreakpoint.js";
+import { useHoldRepeat as s } from "./useHoldRepeat.js";
+import { computed as c, defineComponent as l, toValue as u, unref as d } from "vue";
+import { get as f, isNil as p } from "es-toolkit/compat";
+import { createMergePartBind as m } from "@bridge-ui/core";
+import { mergeBridgeUILayeredClasses as h, mergePropsWithBridgeUIDefaults as g } from "@bridge-ui/core/Utils";
 //#region src/Utils/index.ts
-function g(e) {
-	return c({
+function _(e) {
+	return l({
 		name: "HeadlessTestComponent",
 		setup() {
 			return e(), () => null;
 		}
 	});
 }
-var _ = p("class");
-function v({ props: t, libDefaults: n, componentName: r }) {
-	let i = e(), a = s(() => f(i) ? null : u(i.components));
+var v = m("class");
+function y({ props: t, libDefaults: n, componentName: r }) {
+	let i = e(), a = c(() => p(i) ? null : d(i.components));
 	return {
-		entry: s(() => d(a.value, r)),
+		entry: c(() => f(a.value, r)),
 		bridge: i,
-		merged: s(() => h({
+		merged: c(() => g({
 			libDefaults: n,
 			componentName: r,
-			props: l(t),
+			props: u(t),
 			components: a.value
 		})),
 		components: a
 	};
 }
-function y({ entry: e, props: t }) {
-	return s(() => m(d(e.value, "classes"), l(t).classes));
+function b({ entry: e, props: t }) {
+	return c(() => h(f(e.value, "classes"), u(t).classes));
 }
-function b(e) {
-	return d({
+function x(e) {
+	return f({
 		xs: "xs",
 		sm: "sm",
 		md: "md",
@@ -43,7 +44,7 @@ function b(e) {
 		"2xl": "lg"
 	}, e ?? "md");
 }
-function x(e) {
+function S(e) {
 	if (e instanceof HTMLElement) return e;
 	if (e && "$el" in e) {
 		let t = e.$el;
@@ -52,4 +53,4 @@ function x(e) {
 	return null;
 }
 //#endregion
-export { g as defineHeadlessComponent, t as hasNamedSlot, n as hasSlotOrProp, r as isPropPresent, _ as mergePartBind, b as resolveFieldAdornmentIconSize, i as resolveNamedSlot, a as resolveSlotOrProp, x as resolveVnodeRefElement, v as useBridgeUIComponent, y as useBridgeUIMergedRegistryClasses, o as useHoldRepeat };
+export { _ as defineHeadlessComponent, t as hasNamedSlot, n as hasSlotOrProp, r as isPropPresent, v as mergePartBind, x as resolveFieldAdornmentIconSize, i as resolveNamedSlot, a as resolveSlotOrProp, S as resolveVnodeRefElement, o as useBreakpoint, y as useBridgeUIComponent, b as useBridgeUIMergedRegistryClasses, s as useHoldRepeat };

package/dist/Utils/useBreakpoint.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BreakpointObserverOptions, BreakpointSnapshot } from '@bridge-ui/core';
+export type UseBreakpointOptions = BreakpointObserverOptions;
+/**
+ * Reactive viewport breakpoints aligned with Tailwind `--breakpoint-*` tokens.
+ *
+ * Returns a reactive object — call helpers on the object (do not destructure
+ * them) so updates stay reactive in script.
+ *
+ * Falls back to `BridgeUIProvider` `global.mobileBreakpoint` and
+ * `global.breakpoints`. Composable options win when passed.
+ *
+ * On the server (and before mount), `mobile` is `true` at width `0`.
+ *
+ * @example
+ * const breakpoint = useBreakpoint();
+ * // :align="breakpoint.mobile ? 'bottom-center' : 'middle-center'"
+ */
+export declare function useBreakpoint(options?: MaybeRefOrGetter<undefined | UseBreakpointOptions>): BreakpointSnapshot;

package/dist/Utils/useBreakpoint.js

@@ -0,0 +1,35 @@
+import { useBridgeUI as e } from "../Provider/useBridgeUI.js";
+import { onBeforeUnmount as t, reactive as n, toValue as r, watch as i } from "vue";
+import { isEmpty as a, isNil as o } from "es-toolkit/compat";
+import { buildBreakpointSnapshot as s, createBreakpointObserver as c, resolveBreakpoints as l } from "@bridge-ui/core";
+import { toMerged as u } from "es-toolkit/object";
+//#region src/Utils/useBreakpoint.ts
+function d(d) {
+	let f = e(), p = n(s(0, 0, l(), "sm")), m, h;
+	function g(e) {
+		Object.assign(p, e);
+	}
+	function _(e) {
+		let t = u(f?.global.value.breakpoints ?? {}, e?.breakpoints ?? {});
+		return {
+			breakpoints: a(t) ? void 0 : t,
+			mobileBreakpoint: o(e?.mobileBreakpoint) ? f?.global.value.mobileBreakpoint : e.mobileBreakpoint
+		};
+	}
+	function v(e) {
+		h?.(), h = void 0, m = c(_(e)), g(m.getSnapshot()), h = m.subscribe(() => {
+			o(m) || g(m.getSnapshot());
+		});
+	}
+	return v(r(d)), i(() => [
+		r(d),
+		f?.global.value.breakpoints,
+		f?.global.value.mobileBreakpoint
+	], () => {
+		v(r(d));
+	}, { deep: !0 }), t(() => {
+		h?.(), h = void 0, m = void 0;
+	}), p;
+}
+//#endregion
+export { d as useBreakpoint };