@bridge-ui/vue 0.0.9 → 0.0.11

package/dist/Components/ToggleGroup/composables/useToggleGroup.js

@@ -0,0 +1,128 @@
+import { mergePartBind as e, useBridgeUIComponent as t, useBridgeUIMergedRegistryClasses as n } from "../../../Utils/index.js";
+import { TOGGLE_GROUP_INJECTION_KEY as r } from "../toggleGroupInjectionKey.js";
+import { computed as i, provide as a, ref as o, useAttrs as s, useId as c } from "vue";
+import { get as l, head as u, isArray as d } from "es-toolkit/compat";
+import { applyToggleGroupSelection as f, getAdjacentTabValue as p, normalizeToggleGroupValue as m } from "@bridge-ui/core/Domain";
+import { toggleGroupColorProps as h, toggleGroupOrientationProps as g, toggleGroupRoundedProps as ee, toggleGroupSizeProps as te, toggleGroupVariantProps as _ } from "@bridge-ui/core/Tokens";
+import { cn as v, mergeBridgeUILayeredClasses as y, splitComponentProps as b } from "@bridge-ui/core/Utils";
+//#region src/Components/ToggleGroup/composables/useToggleGroup.ts
+var x = [
+	"full",
+	"size",
+	"color",
+	"classes",
+	"rounded",
+	"variant",
+	"disabled",
+	"multiple",
+	"customProps",
+	"orientation"
+];
+function S(e, t) {
+	return `${e}-toggle-${t}`;
+}
+function C(e, t) {
+	return d(e) ? u(e) ?? u(t) ?? "" : e || u(t) || "";
+}
+function w(u, d, w, T) {
+	let E = c(), D = s(), O = `bridge-toggle-group${E}`, k = o([]), A = o([]), j = o(""), M = i(() => b({
+		props: {
+			...D,
+			...u
+		},
+		bridgeKeys: x
+	})), { merged: N, entry: P } = t({
+		libDefaults: d,
+		componentName: "ToggleGroup",
+		props: () => M.value.componentProps
+	}), F = i(() => N.value.multiple === !0), I = i(() => N.value.orientation ?? "horizontal"), L = i(() => m(w.value, F.value));
+	function R(e) {
+		if (N.value.disabled || A.value.includes(e)) return;
+		let t = f(L.value, e, F.value);
+		w.value = t, j.value = e, T("update:modelValue", t), T("change", t);
+	}
+	function z(e, t = !1) {
+		return k.value.includes(e) || (k.value = [...k.value, e]), t ? A.value.includes(e) || (A.value = [...A.value, e]) : A.value = A.value.filter((t) => t !== e), j.value === "" && !t && (j.value = e), !F.value && !t && m(w.value, !1) === "" && (w.value = e), () => {
+			k.value = k.value.filter((t) => t !== e), A.value = A.value.filter((t) => t !== e);
+		};
+	}
+	function B(e) {
+		j.value = e, document.getElementById(S(O, e))?.focus();
+	}
+	function V(e) {
+		let t = I.value === "horizontal", n = t ? "ArrowLeft" : "ArrowUp", r = t ? "ArrowRight" : "ArrowDown", i = l(document, "activeElement.id"), a = k.value.find((e) => S(O, e) === i) ?? (j.value || C(L.value, k.value));
+		if (e.key === r || e.key === n) {
+			e.preventDefault();
+			let t = e.key === r ? 1 : -1, n = p(k.value, a, t, new Set(A.value));
+			B(n), F.value || R(n);
+			return;
+		}
+		if (e.key === "Home") {
+			e.preventDefault();
+			let t = k.value.find((e) => !A.value.includes(e)) ?? a;
+			B(t), F.value || R(t);
+			return;
+		}
+		if (e.key === "End") {
+			e.preventDefault();
+			let t = [...k.value].reverse().find((e) => !A.value.includes(e)) ?? a;
+			B(t), F.value || R(t);
+		}
+	}
+	let H = n({
+		entry: P,
+		props: () => M.value.componentProps
+	}), U = i(() => y(te, P.value?.tokens?.size)), W = i(() => y(_, P.value?.tokens?.variant)), G = i(() => y(h, P.value?.tokens?.color)), K = i(() => y(ee, P.value?.tokens?.rounded)), q = i(() => y(g, P.value?.tokens?.orientation)), J = i(() => l(U.value, N.value.size)), Y = i(() => l(W.value, N.value.variant)), X = i(() => l(G.value, N.value.color)), Z = i(() => l(K.value, N.value.rounded)), Q = i(() => l(q.value, N.value.orientation)), $ = i(() => ({
+		toggleItem: R,
+		id: O,
+		focusToggleItem: B,
+		registerToggleItem: z,
+		multiple: F.value,
+		selected: L.value,
+		orientation: I.value,
+		toggleValues: k.value,
+		focusedValue: j.value,
+		full: N.value.full === !0,
+		disabledValues: A.value,
+		disabled: N.value.disabled === !0,
+		tokenClasses: {
+			iconGap: l(J.value, "gap"),
+			itemSize: l(J.value, "item"),
+			iconSize: l(J.value, "icon"),
+			rootSize: l(J.value, "root"),
+			softFill: N.value.variant === "solid",
+			itemVariant: l(Y.value, "item"),
+			rootVariant: l(Y.value, "root"),
+			itemRounded: l(Z.value, "item"),
+			rootRounded: l(Z.value, "root"),
+			itemOrientation: l(Q.value, "item"),
+			colorSelected: l(X.value, "itemSelected"),
+			rootOrientation: l(Q.value, "root"),
+			itemVariantSelected: l(Y.value, "itemSelected"),
+			colorSelectedSoft: l(X.value, "itemSelectedSoft")
+		}
+	}));
+	a(r, $);
+	let ne = i(() => N.value.customProps);
+	return {
+		merged: N,
+		rootBind: i(() => e(ne.value?.root, M.value.inheritedAttrs, {
+			onKeydown: V,
+			"aria-orientation": I.value,
+			role: F.value ? "group" : "radiogroup",
+			"aria-disabled": N.value.disabled === !0 || void 0,
+			class: v({
+				[l(J.value, "root") ?? ""]: !0,
+				[l(Y.value, "root") ?? ""]: !0,
+				[l(Z.value, "root") ?? ""]: !0,
+				[l(Q.value, "root") ?? ""]: !0,
+				[l(H.value, "root") ?? ""]: !0,
+				"w-full": N.value.full === !0,
+				"opacity-50 pointer-events-none": N.value.disabled === !0
+			})
+		})),
+		contextValue: $
+	};
+}
+//#endregion
+export { S as getToggleItemId, w as useToggleGroup };

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

@@ -0,0 +1,4 @@
+export { useToggleGroup } from './composables/useToggleGroup';
+export type { ToggleGroupClasses, ToggleGroupColorOverrides, ToggleGroupCustomProps, ToggleGroupEmits, ToggleGroupOrientationOverrides, ToggleGroupOwnProps, ToggleGroupProps, ToggleGroupRoundedOverrides, ToggleGroupSizeOverrides, ToggleGroupSlots, ToggleGroupVariantOverrides, } from './toggleGroup.types';
+export { default as ToggleGroup } from './ToggleGroup.vue';
+export { TOGGLE_GROUP_INJECTION_KEY, type ToggleGroupContextValue, type ToggleGroupTokenClasses, } from './toggleGroupInjectionKey';

package/dist/Components/ToggleGroup/index.js

@@ -0,0 +1,4 @@
+import { TOGGLE_GROUP_INJECTION_KEY as e } from "./toggleGroupInjectionKey.js";
+import { useToggleGroup as t } from "./composables/useToggleGroup.js";
+import n from "./ToggleGroup.js";
+export { e as TOGGLE_GROUP_INJECTION_KEY, n as ToggleGroup, t as useToggleGroup };

package/dist/Components/ToggleGroup/toggleGroup.types.d.ts

@@ -0,0 +1,110 @@
+import { HTMLAttributes, Slot } from 'vue';
+import { ToggleGroupValue } from '@bridge-ui/core/Domain';
+import { ToggleGroupColor, ToggleGroupOrientation, ToggleGroupRounded, ToggleGroupSize, ToggleGroupVariant } from '@bridge-ui/core/Tokens';
+import { MergeHtmlProps, MergeProps } from '@bridge-ui/core/Utils';
+export interface ToggleGroupSizeOverrides {}
+export interface ToggleGroupColorOverrides {}
+export interface ToggleGroupRoundedOverrides {}
+export interface ToggleGroupVariantOverrides {}
+export interface ToggleGroupOrientationOverrides {}
+export interface ToggleGroupClasses {
+    /**
+     * Classes merged onto the root track.
+     */
+    root?: string;
+}
+export interface ToggleGroupCustomProps {
+    /**
+     * Props forwarded to the root element.
+     *
+     * @default undefined
+     */
+    root?: HTMLAttributes;
+}
+export interface ToggleGroupEmits {
+    /**
+     * Emitted when the selected value changes.
+     */
+    change: [value: ToggleGroupValue];
+    /**
+     * Emitted when `v-model` should update.
+     */
+    "update:modelValue": [value: ToggleGroupValue];
+}
+/**
+ * Segmented control root. Compose with `ToggleItem` children.
+ */
+export interface ToggleGroupOwnProps {
+    /**
+     * Classes for toggle group parts.
+     *
+     * @default undefined
+     */
+    classes?: ToggleGroupClasses;
+    /**
+     * Accent color for the selected segment.
+     *
+     * @default "primary"
+     */
+    color?: MergeProps<ToggleGroupColor, ToggleGroupColorOverrides>;
+    /**
+     * Extra props for internal parts.
+     *
+     * @default undefined
+     */
+    customProps?: ToggleGroupCustomProps;
+    /**
+     * Disable the entire group.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Stretch the track to the container width.
+     *
+     * @default false
+     */
+    full?: boolean;
+    /**
+     * Allow selecting more than one segment.
+     *
+     * @default false
+     */
+    multiple?: boolean;
+    /**
+     * Layout orientation of the track.
+     *
+     * @default "horizontal"
+     */
+    orientation?: MergeProps<ToggleGroupOrientation, ToggleGroupOrientationOverrides>;
+    /**
+     * Track and segment roundness.
+     *
+     * @default "md"
+     */
+    rounded?: MergeProps<ToggleGroupRounded, ToggleGroupRoundedOverrides>;
+    /**
+     * Size of the track and segments.
+     *
+     * @default "md"
+     */
+    size?: MergeProps<ToggleGroupSize, ToggleGroupSizeOverrides>;
+    /**
+     * Visual style of the selected segment.
+     *
+     * @default "solid"
+     */
+    variant?: MergeProps<ToggleGroupVariant, ToggleGroupVariantOverrides>;
+}
+export interface ToggleGroupSlots {
+    /**
+     * The children to render (`ToggleItem` segments).
+     */
+    default?: Slot<undefined>;
+}
+export type ToggleGroupProps = MergeHtmlProps<ToggleGroupOwnProps, HTMLAttributes> & {
+    /**
+     * Bound with `v-model` on the component (`defineModel` internally).
+     */
+    modelValue?: ToggleGroupValue;
+};

package/dist/Components/ToggleGroup/toggleGroupInjectionKey.d.ts

@@ -0,0 +1,79 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { ToggleGroupValue } from '@bridge-ui/core/Domain';
+/**
+ * Merged token classes for the track and segments.
+ */
+export type ToggleGroupTokenClasses = {
+    colorSelected?: string;
+    colorSelectedSoft?: string;
+    iconGap?: string;
+    iconSize?: string;
+    itemOrientation?: string;
+    itemRounded?: string;
+    itemSize?: string;
+    itemVariant?: string;
+    itemVariantSelected?: string;
+    rootOrientation?: string;
+    rootRounded?: string;
+    rootSize?: string;
+    rootVariant?: string;
+    softFill?: boolean;
+};
+/**
+ * Shared toggle group state for `ToggleItem` descendants.
+ */
+export type ToggleGroupContextValue = {
+    /**
+     * Whether the entire group is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Disabled toggle values.
+     */
+    disabledValues: string[];
+    /**
+     * Value that currently owns the roving tab stop.
+     */
+    focusedValue: string;
+    /**
+     * Focus a segment by value (roving tabindex).
+     */
+    focusToggleItem: (value: string) => void;
+    /**
+     * Whether segments stretch to fill the track width.
+     */
+    full: boolean;
+    /**
+     * Stable id prefix for segment ids.
+     */
+    id: string;
+    /**
+     * Whether more than one segment can be selected.
+     */
+    multiple: boolean;
+    /**
+     * Orientation of the track.
+     */
+    orientation: "vertical" | "horizontal";
+    /**
+     * Registers a segment and returns unregister.
+     */
+    registerToggleItem: (value: string, disabled?: boolean) => () => void;
+    /**
+     * Currently selected value(s).
+     */
+    selected: ToggleGroupValue;
+    /**
+     * Applies a segment press (select / toggle).
+     */
+    toggleItem: (value: string) => void;
+    /**
+     * Ordered toggle values (mount order).
+     */
+    toggleValues: string[];
+    /**
+     * Merged token classes for the track and segments.
+     */
+    tokenClasses: ToggleGroupTokenClasses;
+};
+export declare const TOGGLE_GROUP_INJECTION_KEY: InjectionKey<ComputedRef<ToggleGroupContextValue>>;

package/dist/Components/ToggleGroup/toggleGroupInjectionKey.js

@@ -0,0 +1,4 @@
+//#region src/Components/ToggleGroup/toggleGroupInjectionKey.ts
+var e = Symbol("bridge-toggle-group");
+//#endregion
+export { e as TOGGLE_GROUP_INJECTION_KEY };

package/dist/Components/ToggleItem/ToggleItem.js

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

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

@@ -0,0 +1,11 @@
+import { ToggleItemOwnProps, ToggleItemSlots } from './toggleItem.types';
+type __VLS_Slots = ToggleItemSlots;
+declare const __VLS_base: import('vue').DefineComponent<ToggleItemOwnProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ToggleItemOwnProps> & Readonly<{}>, {}, {}, {}, {}, 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/ToggleItem/ToggleItem.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,24 @@
+import e from "../Icon/Icon.js";
+import { useToggleItem as t } from "./composables/useToggleItem.js";
+import { createBlock as n, createCommentVNode as r, createElementBlock as i, defineComponent as a, guardReactiveProps as o, mergeProps as s, normalizeProps as c, openBlock as l, renderSlot as u, unref as d } from "vue";
+//#region src/Components/ToggleItem/ToggleItem.vue?vue&type=script&setup=true&lang.ts
+var f = /*@__PURE__*/ a({
+	inheritAttrs: !1,
+	__name: "ToggleItem",
+	props: {
+		classes: {},
+		customProps: {},
+		disabled: { type: Boolean },
+		startIcon: {},
+		value: {}
+	},
+	setup(a) {
+		let { merged: f, iconSize: p, rootBind: m, startIconBind: h } = t(a);
+		return (t, a) => (l(), i("button", c(o(d(m))), [d(f).startIcon ? (l(), n(d(e), s({
+			key: 0,
+			size: d(p)
+		}, d(h), { icon: d(f).startIcon }), null, 16, ["size", "icon"])) : r("", !0), u(t.$slots, "default")], 16));
+	}
+});
+//#endregion
+export { f as default };

package/dist/Components/ToggleItem/composables/useToggleItem.d.ts

@@ -0,0 +1,19 @@
+import { IconSize } from '@bridge-ui/core/Tokens';
+import { ToggleItemOwnProps, ToggleItemProps } from '../toggleItem.types';
+export declare function useToggleItem(props: ToggleItemOwnProps): {
+    merged: import('vue').ComputedRef<ToggleItemOwnProps>;
+    iconSize: import('vue').ComputedRef<keyof IconSize>;
+    rootBind: import('vue').ComputedRef<import('@bridge-ui/core/Utils').MergePartBind<{
+        type: string;
+        onClick: (event: PointerEvent) => void;
+        disabled: boolean;
+        tabindex: number;
+        role: string;
+        id: string;
+        "aria-pressed": boolean;
+        "aria-checked": boolean;
+        class: string;
+    }, "class", import('vue').ButtonHTMLAttributes | undefined, Omit<ToggleItemProps, "value" | "classes" | "customProps" | "disabled" | "startIcon">>>;
+    selected: import('vue').ComputedRef<boolean>;
+    startIconBind: import('vue').ComputedRef<import('@bridge-ui/core/Utils').MergePartBind<object, "class", Partial<Omit<import('../../Icon').IconProps, "icon">> | undefined, {}>>;
+};

package/dist/Components/ToggleItem/composables/useToggleItem.js

@@ -0,0 +1,80 @@
+import { mergePartBind as e, useBridgeUIComponent as t, useBridgeUIMergedRegistryClasses as n } from "../../../Utils/index.js";
+import { TOGGLE_GROUP_INJECTION_KEY as r } from "../../ToggleGroup/toggleGroupInjectionKey.js";
+import { getToggleItemId as i } from "../../ToggleGroup/composables/useToggleGroup.js";
+import { computed as a, inject as o, onBeforeUnmount as s, onMounted as c, useAttrs as l, watch as u } from "vue";
+import { get as d } from "es-toolkit/compat";
+import { isToggleGroupItemSelected as f } from "@bridge-ui/core/Domain";
+import { cn as p, splitComponentProps as m } from "@bridge-ui/core/Utils";
+//#region src/Components/ToggleItem/composables/useToggleItem.ts
+var h = [
+	"value",
+	"classes",
+	"disabled",
+	"startIcon",
+	"customProps"
+];
+function g(g) {
+	let _ = l(), v = o(r, null);
+	if (!v) throw Error("ToggleItem must be used within a ToggleGroup provider");
+	let y = v, b = a(() => m({
+		props: {
+			..._,
+			...g
+		},
+		bridgeKeys: h
+	})), { merged: x, entry: S } = t({
+		componentName: "ToggleItem",
+		props: () => b.value.componentProps
+	}), C = a(() => x.value.value), w = a(() => y.value.disabled || x.value.disabled === !0), T = a(() => f(y.value.selected, C.value, y.value.multiple)), E = null;
+	function D() {
+		E?.(), E = y.value.registerToggleItem(C.value, x.value.disabled === !0);
+	}
+	c(D), u([C, () => x.value.disabled], D), s(() => {
+		E?.(), E = null;
+	});
+	let O = n({
+		entry: S,
+		props: () => b.value.componentProps
+	});
+	function k(e) {
+		w.value || (y.value.toggleItem(C.value), b.value.inheritedAttrs.onClick?.(e));
+	}
+	let A = a(() => x.value.customProps);
+	return {
+		merged: x,
+		iconSize: a(() => y.value.tokenClasses.iconSize ?? "md"),
+		rootBind: a(() => {
+			let t = y.value, n = t.focusedValue ? t.focusedValue === C.value : T.value;
+			return e(A.value?.root, b.value.inheritedAttrs, {
+				type: "button",
+				onClick: k,
+				disabled: w.value,
+				tabindex: n ? 0 : -1,
+				role: t.multiple ? "button" : "radio",
+				id: i(t.id, C.value),
+				"aria-pressed": T.value && t.multiple,
+				"aria-checked": T.value && !t.multiple,
+				class: p({
+					"inline-flex cursor-pointer items-center justify-center transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary-500/40 disabled:pointer-events-none disabled:opacity-50": !0,
+					[t.tokenClasses.iconGap ?? ""]: !0,
+					[t.tokenClasses.itemSize ?? ""]: !0,
+					[t.tokenClasses.itemVariant ?? ""]: !0,
+					[t.tokenClasses.itemRounded ?? ""]: !0,
+					[t.tokenClasses.itemOrientation ?? ""]: !0,
+					[t.tokenClasses.itemVariantSelected ?? ""]: T.value,
+					[t.tokenClasses.colorSelected ?? ""]: T.value,
+					[t.tokenClasses.colorSelectedSoft ?? ""]: T.value && t.tokenClasses.softFill === !0,
+					[d(O.value, "root") ?? ""]: !0,
+					"flex-1": t.full
+				})
+			});
+		}),
+		selected: T,
+		startIconBind: a(() => e(A.value?.startIcon, {}, p({
+			"shrink-0": !0,
+			[d(O.value, "startIcon") ?? ""]: !0
+		})))
+	};
+}
+//#endregion
+export { g as useToggleItem };

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

@@ -0,0 +1,3 @@
+export { useToggleItem } from './composables/useToggleItem';
+export type { ToggleItemClasses, ToggleItemCustomProps, ToggleItemOwnProps, ToggleItemProps, ToggleItemSlots, } from './toggleItem.types';
+export { default as ToggleItem } from './ToggleItem.vue';

package/dist/Components/ToggleItem/index.js

@@ -0,0 +1,3 @@
+import { useToggleItem as e } from "./composables/useToggleItem.js";
+import t from "./ToggleItem.js";
+export { t as ToggleItem, e as useToggleItem };

package/dist/Components/ToggleItem/toggleItem.types.d.ts

@@ -0,0 +1,64 @@
+import { ButtonHTMLAttributes, Slot } from 'vue';
+import { MergeHtmlProps } from '@bridge-ui/core/Utils';
+import { IconSource } from '../../Adapters/Icon';
+import { IconProps } from '../Icon';
+export interface ToggleItemClasses {
+    /**
+     * Classes merged onto the segment button.
+     */
+    root?: string;
+    /**
+     * Classes merged onto the start icon.
+     */
+    startIcon?: string;
+}
+export interface ToggleItemCustomProps {
+    /**
+     * Props forwarded to the segment button.
+     */
+    root?: ButtonHTMLAttributes;
+    /**
+     * Props forwarded to the start `Icon`.
+     */
+    startIcon?: Partial<Omit<IconProps, "icon">>;
+}
+/**
+ * Toggle group segment (`role="radio"`). Must be used inside `ToggleGroup`.
+ */
+export interface ToggleItemOwnProps {
+    /**
+     * Classes for toggle item parts.
+     *
+     * @default undefined
+     */
+    classes?: ToggleItemClasses;
+    /**
+     * Props forwarded to each toggle item part.
+     *
+     * @default undefined
+     */
+    customProps?: ToggleItemCustomProps;
+    /**
+     * Whether this segment is disabled.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Icon at the inline start.
+     *
+     * @default undefined
+     */
+    startIcon?: IconSource;
+    /**
+     * Value when this segment is selected.
+     */
+    value: string;
+}
+export interface ToggleItemSlots {
+    /**
+     * The label content.
+     */
+    default?: Slot<undefined>;
+}
+export type ToggleItemProps = MergeHtmlProps<ToggleItemOwnProps, ButtonHTMLAttributes>;

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

@@ -12,15 +12,15 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {
     "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     "onShow-change"?: ((show: boolean) => any) | undefined;
 }>, {
-    color: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').TooltipColor, import('./tooltip.types').TooltipColorOverrides>;
+    color: import('@bridge-ui/core/Utils').MergeProps<import('@bridge-ui/core/Tokens').TooltipColor, import('./tooltip.types').TooltipColorOverrides>;
     offset: number;
-    size: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').TooltipSize, import('./tooltip.types').TooltipSizeOverrides>;
-    rounded: import('@bridge-ui/core').MergeProps<import('@bridge-ui/core').TooltipRounded, import('./tooltip.types').TooltipRoundedOverrides>;
+    size: import('@bridge-ui/core/Utils').MergeProps<import('@bridge-ui/core/Tokens').TooltipSize, import('./tooltip.types').TooltipSizeOverrides>;
+    rounded: import('@bridge-ui/core/Utils').MergeProps<import('@bridge-ui/core/Tokens').TooltipRounded, import('./tooltip.types').TooltipRoundedOverrides>;
     disabled: boolean;
     placement: import('@floating-ui/utils').Placement;
     teleportTo: false | string;
     anchorEl: null | HTMLElement;
-    strategy: import('@bridge-ui/core').PositionStrategy;
+    strategy: import('@bridge-ui/core/Runtime').PositionStrategy;
     arrow: boolean;
     closeDelay: number;
     openDelay: number;

package/dist/Components/Tooltip/Tooltip.vue_vue_type_script_setup_true_lang.js

@@ -1,8 +1,8 @@
-import { hasNamedSlot as e, resolveNamedSlot as t, resolveSlotOrProp as n } from "../../Utils/slotOrProp.js";
-import { useTooltip as r } from "./composables/useTooltip.js";
-import { Fragment as i, Teleport as a, computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, defineComponent as d, mergeModels as f, mergeProps as p, normalizeProps as m, openBlock as h, resolveDynamicComponent as g, unref as _, useModel as v, useSlots as y } from "vue";
+import { hasNamedSlot as e, isPropPresent as t } from "../../Utils/slotOrProp.js";
+import { useTooltip as n } from "./composables/useTooltip.js";
+import { Fragment as r, Teleport as i, computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createElementVNode as l, createTextVNode as u, defineComponent as d, mergeModels as f, mergeProps as p, normalizeProps as m, openBlock as h, renderSlot as g, toDisplayString as _, unref as v, useModel as y, useSlots as b } from "vue";
 //#region src/Components/Tooltip/Tooltip.vue?vue&type=script&setup=true&lang.ts
-var b = /*@__PURE__*/ d({
+var x = /*@__PURE__*/ d({
 	inheritAttrs: !1,
 	__name: "Tooltip",
 	props: /*@__PURE__*/ f({
@@ -40,7 +40,7 @@ var b = /*@__PURE__*/ d({
 	}),
 	emits: /*@__PURE__*/ f(["show-change"], ["update:modelValue"]),
 	setup(d, { emit: f }) {
-		let b = y(), x = f, S = d, C = v(d, "modelValue"), { merged: w, mounted: T, rootBind: E, arrowBind: D, triggerBind: O, contentBind: k, setArrowRef: A, setTriggerRef: j, setContentRef: M } = r(S, {
+		let x = b(), S = f, C = d, w = y(d, "modelValue"), { merged: T, mounted: E, rootBind: D, arrowBind: O, triggerBind: k, contentBind: A, setArrowRef: j, setTriggerRef: M, setContentRef: N } = n(C, {
 			offset: 8,
 			size: "md",
 			arrow: !0,
@@ -52,22 +52,22 @@ var b = /*@__PURE__*/ d({
 			strategy: "fixed",
 			teleportTo: "body"
 		}, {
-			show: C,
+			show: w,
 			onShowChange: (e) => {
-				S.onShowChange?.(e), x("show-change", e);
+				C.onShowChange?.(e), S("show-change", e);
 			}
-		}), N = o(() => e(b, "trigger")), P = o(() => n(b, "default", w.value.content)), F = o(() => w.value.teleportTo === !1), I = o(() => w.value.teleportTo === !1 ? "body" : w.value.teleportTo);
-		return (e, n) => (h(), l(i, null, [N.value ? (h(), l("div", m(p({ key: 0 }, _(E))), [u("div", p({ ref: _(j) }, _(O)), [(h(), s(g(_(t)(_(b), "trigger"))))], 16)], 16)) : c("", !0), (h(), s(a, {
-			to: I.value,
-			disabled: F.value
-		}, [_(T) ? (h(), l("div", p({
+		}), P = a(() => T.value.teleportTo === !1), F = a(() => T.value.teleportTo === !1 ? "body" : T.value.teleportTo);
+		return (n, a) => (h(), c(r, null, [v(e)(v(x), "trigger") ? (h(), c("div", m(p({ key: 0 }, v(D))), [l("div", p({ ref: v(M) }, v(k)), [g(n.$slots, "trigger")], 16)], 16)) : s("", !0), (h(), o(i, {
+			to: F.value,
+			disabled: P.value
+		}, [v(E) ? (h(), c("div", p({
 			key: 0,
-			ref: _(M)
-		}, _(k)), [(h(), s(g(P.value))), _(D) ? (h(), l("div", p({
-			key: 0,
-			ref: _(A)
-		}, _(D)), null, 16)) : c("", !0)], 16)) : c("", !0)], 8, ["to", "disabled"]))], 64));
+			ref: v(N)
+		}, v(A)), [v(e)(v(x), "default") ? g(n.$slots, "default", {}, void 0, void 0, 0) : v(t)(v(T).content) ? (h(), c(r, { key: 1 }, [u(_(v(T).content), 1)], 64)) : s("", !0), v(O) ? (h(), c("div", p({
+			key: 2,
+			ref: v(j)
+		}, v(O)), null, 16)) : s("", !0)], 16)) : s("", !0)], 8, ["to", "disabled"]))], 64));
 	}
 });
 //#endregion
-export { b as default };
+export { x as default };