@bridge-ui/vue 0.0.10 → 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/composables/useTooltip.d.ts

@@ -1,5 +1,5 @@
 import { ComponentPublicInstance, Ref } from 'vue';
-import { LibDefaultsShape, MergeLibDefaults } from '@bridge-ui/core';
+import { LibDefaultsShape, MergeLibDefaults } from '@bridge-ui/core/Utils';
 import { TooltipOwnProps, TooltipProps } from '../tooltip.types';
 type TooltipLibDefaults = LibDefaultsShape<TooltipOwnProps, "size" | "arrow" | "color" | "offset" | "rounded" | "strategy" | "openDelay" | "placement" | "closeDelay" | "teleportTo">;
 type TooltipMerged = MergeLibDefaults<TooltipOwnProps, TooltipLibDefaults>;
@@ -19,14 +19,14 @@ export declare function useTooltip(props: TooltipOwnProps, libDefaults: TooltipL
     show: import('vue').ComputedRef<boolean>;
     merged: import('vue').ComputedRef<TooltipMerged>;
     mounted: Ref<boolean, boolean>;
-    rootBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<object, "class", import('vue').HTMLAttributes | undefined, Omit<Omit<TooltipProps, "color" | "offset" | "size" | "classes" | "customProps" | "rounded" | "disabled" | "placement" | "teleportTo" | "strategy" | "content" | "arrow" | "closeDelay" | "openDelay">, "anchorEl" | "onShowChange">>>;
+    rootBind: import('vue').ComputedRef<import('@bridge-ui/core/Utils').MergePartBind<object, "class", import('vue').HTMLAttributes | undefined, Omit<Omit<TooltipProps, "color" | "offset" | "size" | "classes" | "customProps" | "rounded" | "disabled" | "placement" | "teleportTo" | "strategy" | "content" | "arrow" | "closeDelay" | "openDelay">, "anchorEl" | "onShowChange">>>;
     tooltipId: string;
     arrowBind: import('vue').ComputedRef<({
         "aria-hidden": boolean;
         class: string;
     } & object & Record<"class", string>) | null>;
     isPortaled: import('vue').ComputedRef<boolean>;
-    triggerBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<{
+    triggerBind: import('vue').ComputedRef<import('@bridge-ui/core/Utils').MergePartBind<{
         onBlur: () => void;
         onFocus: () => void;
         onKeydown: (event: KeyboardEvent) => void;
@@ -35,7 +35,7 @@ export declare function useTooltip(props: TooltipOwnProps, libDefaults: TooltipL
         "aria-describedby": string | undefined;
         class: string;
     }, "class", import('vue').HTMLAttributes | undefined, {}>>;
-    contentBind: import('vue').ComputedRef<import('@bridge-ui/core').MergePartBind<{
+    contentBind: import('vue').ComputedRef<import('@bridge-ui/core/Utils').MergePartBind<{
         id: string;
         role: string;
         style: {