@oku-ui/tooltip - npm Package Compare versions

+139

dist/tooltip.d.ts

		import type { PropType, Ref } from 'vue';
		import type { TooltipTriggerElement } from './tooltipTrigger';
		export declare const TOOLTIP_NAME = "OkuTooltip";
		type TooltipInjectValue = {
		contentId: Ref<string>;
		open: Ref<boolean \| undefined>;
		stateAttribute: Ref<'closed' \| 'delayed-open' \| 'instant-open'>;
		trigger: Ref<TooltipTriggerElement \| null>;
		onTriggerChange(trigger: TooltipTriggerElement \| null): void;
		onTriggerEnter(): void;
		onTriggerLeave(): void;
		onOpen(): void;
		onClose(): void;
		disableHoverableContent: Ref<boolean>;
		};
		export declare const tooltipProvide: (props: TooltipInjectValue & {
		scope: import("@oku-ui/provide/dist/createProvide").Scope<TooltipInjectValue>;
		}) => void, useTooltipInject: (consumerName: string, scope: import("@oku-ui/provide/dist/createProvide").Scope<TooltipInjectValue \| undefined>) => TooltipInjectValue;
		export interface TooltipProps {
		open?: boolean;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		defaultOpen?: boolean;
		/**
		* The duration from when the pointer enters the trigger until the tooltip gets opened. This will
		* override the prop with the same name passed to Provider.
		* @defaultValue 700
		*/
		delayDuration?: number;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		disableHoverableContent?: boolean;
		}
		export type TooltipEmits = {
		'update:modelValue': [open: boolean];
		'openChange': [open: boolean];
		};
		export declare const tooltipProps: {
		props: {
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		};
		emits: {
		'update:modelValue': (open: boolean) => boolean;
		openChange: (open: boolean) => boolean;
		};
		};
		export declare const OkuTooltip: import("vue").DefineComponent<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		'update:modelValue': (open: boolean) => boolean;
		openChange: (open: boolean) => boolean;
		}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		}>> & {
		"onUpdate:modelValue"?: ((open: boolean) => any) \| undefined;
		onOpenChange?: ((open: boolean) => any) \| undefined;
		}, {
		asChild: boolean;
		delayDuration: number \| undefined;
		disableHoverableContent: boolean \| undefined;
		modelValue: boolean \| undefined;
		open: boolean \| undefined;
		defaultOpen: boolean;
		}, {}>;
		export {};

+138

dist/tooltip.mjs

		import { computed, defineComponent, h, onBeforeUnmount, ref, toRefs, useModel } from "vue";
		import { primitiveProps } from "@oku-ui/primitive";
		import { useControllable, useId } from "@oku-ui/use-composable";
		import { OkuPopper } from "@oku-ui/popper";
		import { TOOLTIP_OPEN, createTooltipProvide, usePopperScope } from "./utils.mjs";
		import { useTooltipProviderInject } from "./tooltipProvider.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		export const TOOLTIP_NAME = "OkuTooltip";
		export const [tooltipProvide, useTooltipInject] = createTooltipProvide(TOOLTIP_NAME);
		export const tooltipProps = {
		props: {
		modelValue: {
		type: [Boolean],
		default: void 0
		},
		open: {
		type: Boolean,
		default: void 0
		},
		defaultOpen: {
		type: Boolean,
		default: false
		},
		delayDuration: {
		type: Number,
		default: 700
		},
		disableHoverableContent: {
		type: Boolean,
		default: false
		},
		...primitiveProps
		},
		emits: {
		// eslint-disable-next-line unused-imports/no-unused-vars
		"update:modelValue": (open) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		"openChange": (open) => true
		}
		};
		const tooltip = defineComponent({
		name: TOOLTIP_NAME,
		inheritAttrs: false,
		props: {
		...tooltipProps.props,
		...scopeTooltipProps
		},
		emits: tooltipProps.emits,
		setup(props, { slots, emit }) {
		const {
		open: openProp,
		defaultOpen,
		disableHoverableContent: disableHoverableContentProp,
		delayDuration: delayDurationProp
		} = toRefs(props);
		const provideInject = useTooltipProviderInject(TOOLTIP_NAME, props.scopeOkuTooltip);
		const popperScope = usePopperScope(props.scopeOkuTooltip);
		const trigger = ref(null);
		const contentId = useId();
		const openTimerRef = ref(0);
		const disableHoverableContent = computed(() => disableHoverableContentProp.value ?? provideInject.disableHoverableContent.value);
		const delayDuration = computed(() => delayDurationProp.value ?? provideInject.delayDuration.value);
		const wasOpenDelayedRef = ref(false);
		const modelValue = useModel(props, "modelValue");
		const proxyChecked = computed({
		get: () => modelValue.value !== void 0 ? modelValue.value : openProp.value !== void 0 ? openProp.value : void 0,
		set: () => {
		}
		});
		const { state, updateValue } = useControllable({
		prop: computed(() => proxyChecked.value),
		defaultProp: computed(() => defaultOpen.value),
		onChange: (result) => {
		if (result) {
		provideInject.onOpen();
		document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
		} else {
		provideInject.onClose();
		}
		modelValue.value = result;
		emit("openChange", result);
		},
		initialValue: false
		});
		const stateAttribute = computed(() => {
		return state.value ? wasOpenDelayedRef.value ? "delayed-open" : "instant-open" : "closed";
		});
		const handleOpen = () => {
		window.clearTimeout(openTimerRef.value);
		wasOpenDelayedRef.value = false;
		updateValue(true);
		};
		const handleClose = () => {
		window.clearTimeout(openTimerRef.value);
		updateValue(false);
		};
		const handleDelayedOpen = () => {
		window.clearTimeout(openTimerRef.value);
		openTimerRef.value = window.setTimeout(() => {
		wasOpenDelayedRef.value = true;
		updateValue(true);
		}, delayDuration.value);
		};
		onBeforeUnmount(() => {
		window.clearTimeout(openTimerRef.value);
		});
		tooltipProvide({
		scope: props.scopeOkuTooltip,
		contentId: computed(() => contentId),
		open: state,
		stateAttribute,
		trigger,
		onTriggerChange: (value) => {
		trigger.value = value;
		},
		onTriggerEnter: () => {
		if (provideInject.isOpenDelayed.value)
		handleDelayedOpen();
		else
		handleOpen();
		},
		onTriggerLeave: () => {
		if (disableHoverableContent.value) {
		handleClose();
		} else {
		window.clearTimeout(openTimerRef.value);
		}
		},
		onOpen: () => handleOpen(),
		onClose: () => handleClose(),
		disableHoverableContent
		});
		return () => h(OkuPopper, {
		...popperScope
		}, slots);
		}
		});
		export const OkuTooltip = tooltip;

+108

dist/tooltipArrow.d.ts

		import { type PopperArrowElement, type PopperArrowNaviteElement, type PopperArrowProps } from '@oku-ui/popper';
		export type TooltipArrowNaviteElement = PopperArrowNaviteElement;
		export type TooltipArrowElement = PopperArrowElement;
		export interface TooltipArrowProps extends PopperArrowProps {
		}
		export declare const tooltipArrowProps: {
		props: {
		asChild: BooleanConstructor;
		width: {
		type: import("vue").PropType<number>;
		default: number;
		};
		height: {
		type: import("vue").PropType<number>;
		default: number;
		};
		};
		emits: {};
		};
		export declare const OkuTooltipArrow: {
		new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: import("vue").PropType<number>;
		default: number;
		};
		height: {
		type: import("vue").PropType<number>;
		default: number;
		};
		}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}> \| null, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: import("vue").PropType<number>;
		default: number;
		};
		height: {
		type: import("vue").PropType<number>;
		default: number;
		};
		}>>, {
		asChild: boolean;
		height: number;
		width: number;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: import("vue").PropType<number>;
		default: number;
		};
		height: {
		type: import("vue").PropType<number>;
		default: number;
		};
		}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}> \| null, {}, {}, {}, {
		asChild: boolean;
		height: number;
		width: number;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: import("vue").PropType<number>;
		default: number;
		};
		height: {
		type: import("vue").PropType<number>;
		default: number;
		};
		}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}> \| null, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
		asChild: boolean;
		height: number;
		width: number;
		}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
		$props: TooltipArrowNaviteElement;
		});

+41

dist/tooltipArrow.mjs

		import { defineComponent, h, mergeProps, reactive, toRefs } from "vue";
		import { reactiveOmit, useForwardRef } from "@oku-ui/use-composable";
		import { OkuPopperArrow, popperArrowProps } from "@oku-ui/popper";
		import { scopeTooltipProps } from "./types.mjs";
		import { usePopperScope } from "./utils.mjs";
		import { useVisuallyHiddenContentInject } from "./tooltipContentImpl.mjs";
		export const tooltipArrowProps = {
		props: {
		...popperArrowProps.props
		},
		emits: {
		...popperArrowProps.emits
		}
		};
		const ARROW_NAME = "OkuTooltipArrow";
		const tooltipArrow = defineComponent({
		name: ARROW_NAME,
		components: {
		OkuPopperArrow
		},
		inheritAttrs: false,
		props: {
		...tooltipArrowProps.props,
		...scopeTooltipProps
		},
		emits: tooltipArrowProps.emits,
		setup(props, { attrs, slots }) {
		const { scopeOkuTooltip, ...arrowProps } = toRefs(props);
		const _reactive = reactive(arrowProps);
		const reactiveArrowProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const forwardedRef = useForwardRef();
		const popperScope = usePopperScope(scopeOkuTooltip.value);
		const visuallyHiddenContentInject = useVisuallyHiddenContentInject(ARROW_NAME, scopeOkuTooltip.value);
		return () => visuallyHiddenContentInject.isInside.value ? null : h(OkuPopperArrow, {
		...popperScope,
		...mergeProps(attrs, reactiveArrowProps),
		ref: forwardedRef
		}, slots);
		}
		});
		export const OkuTooltipArrow = tooltipArrow;

+506

dist/tooltipContent.d.ts

		import type { PropType } from 'vue';
		import type { PrimitiveProps } from '@oku-ui/primitive';
		import type { TooltipContentImplElement, TooltipContentImplEmits, TooltipContentImplNaviteElement, TooltipContentImplProps } from './tooltipContentImpl';
		export type TooltipContentNaviteElement = TooltipContentImplNaviteElement;
		export type TooltipContentElement = TooltipContentImplElement;
		export interface TooltipContentProps extends PrimitiveProps, TooltipContentImplProps {
		/**
		* Used to force mounting when more control is needed. Useful when
		* controlling animation with React animation libraries.
		*/
		forceMount?: true;
		}
		export type TooltipContentEmits = TooltipContentImplEmits;
		export declare const tooltipContentProps: {
		props: {
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		};
		emits: {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => boolean;
		close: () => boolean;
		};
		};
		export declare const CONTENT_NAME = "OkuTooltipContent";
		export declare const OkuTooltipContent: {
		new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => boolean;
		close: () => boolean;
		}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => boolean;
		close: () => boolean;
		}, string, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
		$props: TooltipContentNaviteElement;
		});

+58

dist/tooltipContent.mjs

		import { computed, defineComponent, h, mergeProps, reactive, toRefs } from "vue";
		import { primitiveProps } from "@oku-ui/primitive";
		import { reactiveOmit, useForwardRef } from "@oku-ui/use-composable";
		import { OkuPresence } from "@oku-ui/presence";
		import { OkuTooltipContentImpl, tooltipContentImplProps } from "./tooltipContentImpl.mjs";
		import { usePortalInject } from "./tooltipPortal.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		import { useTooltipInject } from "./tooltip.mjs";
		import { OkuTooltipContentHoverable } from "./tooltipContentHoverable.mjs";
		export const tooltipContentProps = {
		props: {
		forceMount: {
		type: Boolean,
		default: void 0
		},
		...tooltipContentImplProps.props
		},
		emits: {
		...tooltipContentImplProps.emits
		}
		};
		export const CONTENT_NAME = "OkuTooltipContent";
		const tooltipContent = defineComponent({
		name: CONTENT_NAME,
		inheritAttrs: false,
		props: {
		...tooltipContentProps.props,
		...primitiveProps,
		...scopeTooltipProps
		},
		emits: tooltipContentImplProps.emits,
		setup(props, { attrs, slots }) {
		const { forceMount: forceMountProps, side: sideProps, scopeOkuTooltip, ...contentProps } = toRefs(props);
		const _reactive = reactive(contentProps);
		const reactiveContentProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const portalInject = usePortalInject(CONTENT_NAME, scopeOkuTooltip.value);
		const forceMount = computed(() => forceMountProps.value \|\| portalInject.forceMount?.value);
		const side = computed(() => sideProps.value \|\| "top");
		const forwardedRef = useForwardRef();
		const inject = useTooltipInject(CONTENT_NAME, scopeOkuTooltip.value);
		return () => h(OkuPresence, {
		present: computed(() => forceMount.value \|\| inject.open.value).value
		}, {
		default: () => inject.disableHoverableContent.value ? h(OkuTooltipContentImpl, {
		side: side.value,
		...mergeProps(attrs, reactiveContentProps),
		ref: forwardedRef
		}, {
		default: () => slots.default?.()
		}) : h(OkuTooltipContentHoverable, {
		side: side.value,
		...mergeProps(attrs, reactiveContentProps),
		ref: forwardedRef
		}, slots)
		});
		}
		});
		export const OkuTooltipContent = tooltipContent;

+474

dist/tooltipContentHoverable.d.ts

		import { type TooltipContentImplElement, type TooltipContentImplNaviteElement, type TooltipContentImplProps } from './tooltipContentImpl';
		export type TooltipContentHoverableElementNaviteElement = TooltipContentImplNaviteElement;
		export type TooltipContentHoverableElement = TooltipContentImplElement;
		export interface TooltipContentHoverableProps extends TooltipContentImplProps {
		}
		export declare const tooltipContentHoverableProps: {
		props: {
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		};
		emits: {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => boolean;
		close: () => boolean;
		};
		};
		export declare const OkuTooltipContentHoverable: {
		new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => boolean;
		close: () => boolean;
		}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => boolean;
		close: () => boolean;
		}, string, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
		$props: TooltipContentHoverableElementNaviteElement;
		});

+106

dist/tooltipContentHoverable.mjs

		import { defineComponent, h, mergeProps, ref, watchEffect } from "vue";
		import { primitiveProps } from "@oku-ui/primitive";
		import { useComposedRefs, useForwardRef } from "@oku-ui/use-composable";
		import { OkuTooltipContentImpl, tooltipContentImplProps } from "./tooltipContentImpl.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		import { useTooltipInject } from "./tooltip.mjs";
		import { CONTENT_NAME } from "./tooltipContent.mjs";
		import { useTooltipProviderInject } from "./tooltipProvider.mjs";
		import { getExitSideFromRect, getHull, getPaddedExitPoints, getPointsFromRect, isPointInPolygon } from "./utils.mjs";
		export const tooltipContentHoverableProps = {
		props: {
		...primitiveProps,
		...tooltipContentImplProps.props
		},
		emits: {
		...tooltipContentImplProps.emits
		}
		};
		const NAME = "OkuTooltipContentHoverable";
		const tooltipContentHoverable = defineComponent({
		name: NAME,
		inheritAttrs: false,
		props: {
		...tooltipContentHoverableProps.props,
		...scopeTooltipProps
		},
		emits: tooltipContentHoverableProps.emits,
		setup(props, { attrs, slots }) {
		const inject = useTooltipInject(CONTENT_NAME, props.scopeOkuTooltip);
		const providerInject = useTooltipProviderInject(CONTENT_NAME, props.scopeOkuTooltip);
		const contentRef = ref(null);
		const forwardedRef = useForwardRef();
		const composedRefs = useComposedRefs(forwardedRef, contentRef);
		const pointerGraceArea = ref(null);
		const handleRemoveGraceArea = () => {
		pointerGraceArea.value = null;
		providerInject.onPointerInTransitChange(false);
		};
		const handleCreateGraceArea = (event, hoverTarget) => {
		const currentTarget = event.currentTarget;
		const exitPoint = {
		x: event.clientX,
		y: event.clientY
		};
		const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
		const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
		const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
		const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
		pointerGraceArea.value = graceArea;
		providerInject.onPointerInTransitChange(true);
		};
		watchEffect((onCleanup) => {
		onCleanup(() => {
		handleRemoveGraceArea();
		});
		});
		watchEffect((onCleanup) => {
		if (inject.trigger.value && contentRef.value) {
		const handleTriggerLeave = (event) => {
		if (contentRef.value)
		handleCreateGraceArea(event, contentRef.value);
		};
		const handleContentLeave = (event) => {
		if (inject.trigger.value)
		handleCreateGraceArea(event, inject.trigger.value);
		};
		inject.trigger.value.addEventListener("pointerleave", handleTriggerLeave);
		contentRef.value.addEventListener("pointerleave", handleContentLeave);
		onCleanup(() => {
		inject.trigger.value?.removeEventListener("pointerleave", handleTriggerLeave);
		contentRef.value?.removeEventListener("pointerleave", handleContentLeave);
		});
		}
		});
		watchEffect((onCleanup) => {
		if (pointerGraceArea.value) {
		const handleTrackPointerGrace = (event) => {
		const target = event.target;
		const pointerPosition = {
		x: event.clientX,
		y: event.clientY
		};
		const hasEnteredTarget = inject.trigger.value?.contains(target) \|\| contentRef.value?.contains(target);
		const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea.value);
		if (hasEnteredTarget) {
		handleRemoveGraceArea();
		} else if (isPointerOutsideGraceArea) {
		handleRemoveGraceArea();
		inject.onClose();
		}
		};
		document.addEventListener("pointermove", handleTrackPointerGrace);
		onCleanup(() => {
		document.removeEventListener("pointermove", handleTrackPointerGrace);
		});
		}
		});
		return () => h(OkuTooltipContentImpl, {
		...mergeProps(attrs, props),
		ref: composedRefs
		}, {
		default: () => slots.default?.()
		});
		}
		});
		export const OkuTooltipContentHoverable = tooltipContentHoverable;

+500

dist/tooltipContentImpl.d.ts

		import { type DismissableLayerEmits, type DismissableLayerProps as OkuDismissableLayerProps } from '@oku-ui/dismissable-layer';
		import type { PopperContentProps as OkuPopperContentProps, PopperContentElement, PopperContentEmits, PopperContentNaviteElement } from '@oku-ui/popper';
		declare const useVisuallyHiddenContentInject: (consumerName: string, scope: import("@oku-ui/provide/dist/createProvide").Scope<{
		isInside: import("vue").Ref<boolean>;
		} \| undefined>) => {
		isInside: import("vue").Ref<boolean>;
		};
		export { useVisuallyHiddenContentInject, };
		export type TooltipContentImplNaviteElement = PopperContentNaviteElement;
		export type TooltipContentImplElement = PopperContentElement;
		export type DismissableLayerProps = OkuDismissableLayerProps;
		export type PopperContentProps = OkuPopperContentProps;
		export interface TooltipContentImplProps extends PopperContentProps {
		/**
		* A more descriptive label for accessibility purpose
		*/
		'ariaLabel'?: string;
		}
		export type TooltipContentImplEmits = Omit<PopperContentEmits, 'placed'> & {
		/**
		* Event handler called when the escape key is down.
		* Can be prevented.
		*/
		escapeKeydown: [event: DismissableLayerEmits['escapeKeydown'][0]];
		/**
		* Event handler called when the a `pointerdown` event happens outside of the `Tooltip`.
		* Can be prevented.
		*/
		pointerdownOutside: [event: DismissableLayerEmits['pointerdownOutside'][0]];
		close: [];
		};
		export declare const tooltipContentImplProps: {
		props: {
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		};
		emits: {
		escapeKeydown: (event: DismissableLayerEmits['escapeKeydown'][0]) => boolean;
		pointerdownOutside: (event: DismissableLayerEmits['pointerdownOutside'][0]) => boolean;
		close: () => boolean;
		};
		};
		export declare const OkuTooltipContentImpl: {
		new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		escapeKeydown: (event: DismissableLayerEmits['escapeKeydown'][0]) => boolean;
		pointerdownOutside: (event: DismissableLayerEmits['pointerdownOutside'][0]) => boolean;
		close: () => boolean;
		}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: import("vue").PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: import("vue").PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: import("vue").PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: import("vue").PropType<import("@floating-ui/vue").Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: import("vue").PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: import("vue").PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: import("vue").PropType<"ltr" \| "rtl">;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: import("@oku-ui/dismissable-layer/dist/props").PointerdownOutsideEvent) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		escapeKeydown: (event: DismissableLayerEmits['escapeKeydown'][0]) => boolean;
		pointerdownOutside: (event: DismissableLayerEmits['pointerdownOutside'][0]) => boolean;
		close: () => boolean;
		}, string, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: import("@floating-ui/vue").Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
		$props: TooltipContentImplNaviteElement;
		});

+146

dist/tooltipContentImpl.mjs

		import { defineComponent, h, mergeProps, reactive, ref, toRefs, watchEffect } from "vue";
		import { primitiveProps, propsOmit } from "@oku-ui/primitive";
		import { reactiveOmit, useForwardRef } from "@oku-ui/use-composable";
		import { OkuDismissableLayer } from "@oku-ui/dismissable-layer";
		import { OkuPopperContent, popperContentProps } from "@oku-ui/popper";
		import { OkuSlottable } from "@oku-ui/slot";
		import { OkuVisuallyHidden } from "@oku-ui/visually-hidden";
		import { TOOLTIP_OPEN, createTooltipProvide, usePopperScope } from "./utils.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		import { TOOLTIP_NAME, useTooltipInject } from "./tooltip.mjs";
		const CONTENT_NAME = "OkuTooltipContentImpl";
		const [visuallyHiddenContentProvider, useVisuallyHiddenContentInject] = createTooltipProvide(TOOLTIP_NAME, { isInside: ref(false) });
		export {
		useVisuallyHiddenContentInject
		};
		export const tooltipContentImplProps = {
		props: {
		...popperContentProps.props,
		ariaLabel: {
		type: String,
		default: void 0
		},
		...primitiveProps
		},
		emits: {
		...propsOmit(popperContentProps.emits, ["placed"]),
		// eslint-disable-next-line unused-imports/no-unused-vars
		escapeKeydown: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointerdownOutside: (event) => true,
		close: () => true
		}
		};
		const tooltipContentImpl = defineComponent({
		name: CONTENT_NAME,
		components: {
		OkuDismissableLayer,
		OkuPopperContent,
		OkuSlottable,
		OkuVisuallyHidden
		},
		inheritAttrs: false,
		props: {
		...tooltipContentImplProps.props,
		...primitiveProps,
		...scopeTooltipProps
		},
		emits: tooltipContentImplProps.emits,
		setup(props, { attrs, emit, slots }) {
		const {
		ariaLabel,
		asChild: _asChild,
		scopeOkuTooltip,
		...contentProps
		} = toRefs(props);
		const _reactive = reactive(contentProps);
		const reactiveTooltipProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const inject = useTooltipInject(CONTENT_NAME, scopeOkuTooltip.value);
		const popperScope = usePopperScope(scopeOkuTooltip.value);
		const forwardedRef = useForwardRef();
		watchEffect((onClean) => {
		document.addEventListener(TOOLTIP_OPEN, inject.onClose);
		onClean(() => {
		document.removeEventListener(TOOLTIP_OPEN, inject.onClose);
		});
		});
		watchEffect((onClean) => {
		if (inject.trigger.value) {
		const handleScroll = (event) => {
		const target = event.target;
		if (target?.contains(inject.trigger.value))
		inject.onClose();
		};
		window.addEventListener("scroll", handleScroll, { capture: true });
		onClean(() => {
		window.removeEventListener("scroll", handleScroll, { capture: true });
		});
		}
		});
		visuallyHiddenContentProvider({
		scope: scopeOkuTooltip.value,
		isInside: ref(false)
		});
		const VisuallyHiddenChild = defineComponent({
		inheritAttrs: false,
		props: {
		scope: { type: null, required: false }
		},
		setup(props2, { slots: slots2 }) {
		visuallyHiddenContentProvider({
		scope: props2.scope,
		isInside: ref(true)
		});
		return () => slots2.default?.();
		}
		});
		return () => h(OkuDismissableLayer, {
		asChild: true,
		disableOutsidePointerEvents: false,
		onEscapeKeydown(event) {
		emit("escapeKeydown", event);
		},
		onPointerdownOutside(event) {
		emit("pointerdownOutside", event);
		},
		onFocusOutside(event) {
		event.preventDefault();
		},
		onDismiss() {
		inject.onClose();
		}
		}, {
		default: () => h(OkuPopperContent, {
		"data-state": inject.stateAttribute.value,
		...popperScope,
		...mergeProps(attrs, reactiveTooltipProps),
		"ref": forwardedRef,
		"style": {
		...attrs.style,
		...{
		"--oku-tooltip-content-transform-origin": "var(--oku-popper-transform-origin)",
		"--oku-tooltip-content-available-width": "var(--oku-popper-available-width)",
		"--oku-tooltip-content-available-height": "var(--oku-popper-available-height)",
		"--oku-tooltip-trigger-width": "var(--oku-popper-anchor-width)",
		"--oku-tooltip-trigger-height": "var(--oku-popper-anchor-height)"
		}
		}
		}, {
		default: () => [
		h(OkuSlottable, {}, slots),
		h(VisuallyHiddenChild, {
		scope: props.scopeOkuTooltip
		}, {
		default: () => h(OkuVisuallyHidden, {
		id: inject.contentId.value,
		role: "tooltip"
		}, {
		default: () => ariaLabel.value \|\| slots.default?.()
		})
		})
		]
		})
		});
		}
		});
		export const OkuTooltipContentImpl = tooltipContentImpl;

+123

dist/tooltipPortal.d.ts

		import type { PropType, Ref } from 'vue';
		import type { PortalProps as OkuPortalProps, PortalElement, PortalElementNaviteElement } from '@oku-ui/portal';
		export type TooltipPortalElement = PortalElement;
		export type TooltipPortalNaviteElement = PortalElementNaviteElement;
		type PortalProvide = {
		forceMount?: Ref<true \| undefined>;
		};
		declare const usePortalInject: (consumerName: string, scope: import("@oku-ui/provide/dist/createProvide").Scope<PortalProvide \| undefined>) => PortalProvide;
		export { usePortalInject };
		type PortalProps = OkuPortalProps;
		export interface TooltipPortalProps {
		/**
		* Specify a container element to portal the content into.
		*/
		container?: PortalProps['container'];
		/**
		* Used to force mounting when more control is needed. Useful when
		* controlling animation with React animation libraries.
		*/
		forceMount?: true;
		}
		export declare const tooltipPortalProps: {
		props: {
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		};
		};
		export declare const OkuTooltipPortal: {
		new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
		$props: TooltipPortalNaviteElement;
		});

+52

dist/tooltipPortal.mjs

		import { computed, defineComponent, h, toRefs } from "vue";
		import { primitiveProps } from "@oku-ui/primitive";
		import { OkuPortal } from "@oku-ui/portal";
		import { OkuPresence } from "@oku-ui/presence";
		import { createTooltipProvide } from "./utils.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		import { useTooltipInject } from "./tooltip.mjs";
		const PORTAL_NAME = "OkuTooltipPortal";
		const [portalProvider, usePortalInject] = createTooltipProvide(PORTAL_NAME, {
		forceMount: void 0
		});
		export { usePortalInject };
		export const tooltipPortalProps = {
		props: {
		container: {
		type: Object,
		default: void 0
		},
		forceMount: {
		type: Boolean,
		default: void 0
		},
		...primitiveProps
		}
		};
		const tooltipPortal = defineComponent({
		name: PORTAL_NAME,
		inheritAttrs: false,
		props: {
		...tooltipPortalProps.props,
		...scopeTooltipProps
		},
		setup(props, { slots }) {
		const { container, forceMount, scopeOkuTooltip } = toRefs(props);
		const inject = useTooltipInject(PORTAL_NAME, scopeOkuTooltip.value);
		portalProvider({
		scope: scopeOkuTooltip.value,
		forceMount
		});
		return () => h(OkuPresence, {
		present: computed(() => forceMount.value \|\| inject.open.value).value
		}, {
		default: () => h(OkuPortal, {
		asChild: true,
		container: container.value
		}, {
		default: () => slots.default?.()
		})
		});
		}
		});
		export const OkuTooltipPortal = tooltipPortal;

+88

dist/tooltipProvider.d.ts

		import type { Ref } from 'vue';
		type TooltipProviderProvideValue = {
		isOpenDelayed: Ref<boolean>;
		delayDuration: Ref<number>;
		onOpen(): void;
		onClose(): void;
		onPointerInTransitChange(inTransit: boolean): void;
		isPointerInTransitRef: Ref<boolean>;
		disableHoverableContent: Ref<boolean>;
		};
		export declare const tooltipProviderProvide: (props: TooltipProviderProvideValue & {
		scope: import("@oku-ui/provide/dist/createProvide").Scope<TooltipProviderProvideValue>;
		}) => void, useTooltipProviderInject: (consumerName: string, scope: import("@oku-ui/provide/dist/createProvide").Scope<TooltipProviderProvideValue \| undefined>) => TooltipProviderProvideValue;
		export interface TooltipProviderProps {
		/**
		* The duration from when the pointer enters the trigger until the tooltip gets opened.
		* @defaultValue 700
		*/
		delayDuration?: number;
		/**
		* How much time a user has to enter another trigger without incurring a delay again.
		* @defaultValue 300
		*/
		skipDelayDuration?: number;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		disableHoverableContent?: boolean;
		}
		export declare const tooltipProviderProps: {
		props: {
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		};
		};
		export declare const OkuTooltipProvider: import("vue").DefineComponent<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>[] \| undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		}>>, {
		delayDuration: number;
		skipDelayDuration: number;
		disableHoverableContent: boolean;
		}, {}>;
		export {};

+71

dist/tooltipProvider.mjs

		import { defineComponent, onBeforeUnmount, onMounted, ref, toRefs } from "vue";
		import { DEFAULT_DELAY_DURATION, createTooltipProvide } from "./utils.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		const PROVIDER_NAME = "TooltipProvider";
		export const [tooltipProviderProvide, useTooltipProviderInject] = createTooltipProvide(PROVIDER_NAME);
		export const tooltipProviderProps = {
		props: {
		delayDuration: {
		type: Number,
		default: DEFAULT_DELAY_DURATION
		},
		skipDelayDuration: {
		type: Number,
		default: 300
		},
		disableHoverableContent: {
		type: Boolean,
		default: false
		}
		}
		};
		const NAME = "OkuTooltipProvider";
		const tooltipProvider = defineComponent({
		name: NAME,
		inheritAttrs: false,
		props: {
		...tooltipProviderProps.props,
		...scopeTooltipProps
		},
		setup(props, { slots }) {
		const {
		delayDuration,
		disableHoverableContent,
		scopeOkuTooltip,
		skipDelayDuration
		} = toRefs(props);
		const isOpenDelayed = ref(true);
		const isPointerInTransitRef = ref(false);
		const skipDelayTimerRef = ref(0);
		const skipDelayTimer = ref();
		onMounted(() => {
		skipDelayTimer.value = skipDelayTimerRef.value;
		});
		onBeforeUnmount(() => {
		window.clearTimeout(skipDelayTimer.value);
		});
		tooltipProviderProvide({
		scope: scopeOkuTooltip.value,
		isOpenDelayed,
		delayDuration,
		onOpen() {
		window.clearTimeout(skipDelayTimerRef.value);
		isOpenDelayed.value = false;
		},
		onClose() {
		window.clearTimeout(skipDelayTimerRef.value);
		skipDelayTimerRef.value = window.setTimeout(
		() => isOpenDelayed.value = false,
		skipDelayDuration.value
		);
		},
		isPointerInTransitRef,
		onPointerInTransitChange(inTransit) {
		isPointerInTransitRef.value = inTransit;
		},
		disableHoverableContent
		});
		return () => slots.default?.();
		}
		});
		export const OkuTooltipProvider = tooltipProvider;

+111

dist/tooltipTrigger.d.ts

		import type { OkuElement } from '@oku-ui/primitive';
		export type TooltipTriggerNaviteElement = OkuElement<'button'>;
		export type TooltipTriggerElement = HTMLButtonElement;
		export interface TooltipTriggerProps {
		}
		export declare const tooltipTriggerProps: {
		props: {
		asChild: BooleanConstructor;
		};
		emits: {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		};
		};
		export declare const OkuTooltipTrigger: {
		new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, {
		asChild: boolean;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		asChild: boolean;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
		scopeOkuTooltip: {
		type: import("vue").PropType<import("@oku-ui/provide/dist/createProvide").Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		}, string, {
		asChild: boolean;
		}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
		$props: TooltipTriggerNaviteElement;
		});

+111

dist/tooltipTrigger.mjs

		import { defineComponent, h, mergeProps, reactive, ref, toRefs, watchEffect } from "vue";
		import { Primitive, primitiveProps } from "@oku-ui/primitive";
		import { reactiveOmit, useComposedRefs, useForwardRef } from "@oku-ui/use-composable";
		import { OkuPopperAnchor } from "@oku-ui/popper";
		import { composeEventHandlers } from "@oku-ui/utils";
		import { usePopperScope } from "./utils.mjs";
		import { scopeTooltipProps } from "./types.mjs";
		import { useTooltipProviderInject } from "./tooltipProvider.mjs";
		import { useTooltipInject } from "./tooltip.mjs";
		const TRIGGER_NAME = "OkuTooltipTrigger";
		export const tooltipTriggerProps = {
		props: {
		...primitiveProps
		},
		emits: {
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointermove: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointerleave: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointerdown: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		focus: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		blur: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		click: (event) => true
		}
		};
		const tooltipTrigger = defineComponent({
		name: TRIGGER_NAME,
		inheritAttrs: false,
		props: {
		...tooltipTriggerProps.props,
		...scopeTooltipProps
		},
		emits: tooltipTriggerProps.emits,
		setup(props, { attrs, slots, emit }) {
		const { scopeOkuTooltip, ...triggerProps } = toRefs(props);
		const _reactive = reactive(triggerProps);
		const reactiveTriggerProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const inject = useTooltipInject(TRIGGER_NAME, scopeOkuTooltip.value);
		const providerInject = useTooltipProviderInject(TRIGGER_NAME, scopeOkuTooltip.value);
		const popperScope = usePopperScope(scopeOkuTooltip.value);
		const buttonRef = ref(null);
		const forwardedRef = useForwardRef();
		const composedRefs = useComposedRefs(buttonRef, forwardedRef, (el) => {
		inject.onTriggerChange(el);
		});
		const isPointerDownRef = ref(false);
		const hasPointerMoveOpenedRef = ref(false);
		const handlePointerUp = () => {
		isPointerDownRef.value = false;
		};
		watchEffect((onCleanup) => {
		onCleanup(() => {
		document.removeEventListener("pointerup", handlePointerUp);
		});
		});
		return () => h(OkuPopperAnchor, {
		asChild: true,
		...popperScope
		}, {
		default: () => h(Primitive.button, {
		// We purposefully avoid adding `type=button` here because tooltip triggers are also
		// commonly anchors and the anchor `type` attribute signifies MIME type.
		"aria-describedby": inject.open.value ? inject.contentId.value : void 0,
		"data-state": inject.stateAttribute.value,
		...mergeProps(attrs, reactiveTriggerProps),
		"ref": composedRefs,
		"onPointermove": composeEventHandlers((el) => {
		emit("pointermove", el);
		}, (event) => {
		if (event.pointerType === "touch")
		return;
		if (!hasPointerMoveOpenedRef.value && !providerInject.isPointerInTransitRef.value) {
		inject.onTriggerEnter();
		hasPointerMoveOpenedRef.value = true;
		}
		}),
		"onPointerleave": composeEventHandlers((el) => {
		emit("pointerleave", el);
		}, () => {
		inject.onTriggerLeave();
		hasPointerMoveOpenedRef.value = false;
		}),
		"onPointerdown": composeEventHandlers((el) => {
		emit("pointerdown", el);
		}, () => {
		isPointerDownRef.value = true;
		document.addEventListener("pointerup", handlePointerUp, { once: true });
		}),
		"onFocus": composeEventHandlers((el) => {
		emit("focus", el);
		}, () => {
		if (!isPointerDownRef.value)
		inject.onOpen();
		}),
		"onBlur": composeEventHandlers((el) => {
		emit("blur", el);
		}, inject.onClose),
		"onClick": composeEventHandlers((el) => {
		emit("click", el);
		}, inject.onClose)
		}, {
		default: () => slots.default?.()
		})
		});
		}
		});
		export const OkuTooltipTrigger = tooltipTrigger;

+17

dist/types.d.ts

		import type { Scope } from '@oku-ui/provide';
		import type { TooltipContentProps } from './tooltipContent';
		export type Point = {
		x: number;
		y: number;
		};
		export type Polygon = Point[];
		export type Side = NonNullable<TooltipContentProps['side']>;
		export type ScopeTooltip<T> = T & {
		scopeOkuTooltip?: Scope;
		};
		export declare const scopeTooltipProps: {
		scopeOkuTooltip: {
		type: import("vue").PropType<Scope<any>>;
		required: boolean;
		};
		};

+6

dist/types.mjs

		import { ScopePropObject } from "@oku-ui/provide";
		export const scopeTooltipProps = {
		scopeOkuTooltip: {
		...ScopePropObject
		}
		};

+18

dist/utils.d.ts

		import type { Point, Polygon, Side } from './types';
		export declare const createTooltipProvide: <ProvideValueType extends object \| null>(rootComponentName: string, defaultValue?: ProvideValueType \| undefined) => readonly [(props: ProvideValueType & {
		scope: import("@oku-ui/provide/dist/createProvide").Scope<ProvideValueType>;
		}) => void, (consumerName: string, scope: import("@oku-ui/provide/dist/createProvide").Scope<ProvideValueType \| undefined>) => ProvideValueType], createTooltipScope: import("@oku-ui/provide/dist/createProvide").CreateScope;
		export declare const DEFAULT_DELAY_DURATION = 700;
		export declare const TOOLTIP_OPEN = "tooltip.open";
		export declare const usePopperScope: (scope: import("@oku-ui/provide/dist/createProvide").Scope<any>) => {
		[__scopeProp: string]: import("@oku-ui/provide/dist/createProvide").Scope<any>;
		};
		export declare function getExitSideFromRect(point: Point, rect: DOMRect): Side;
		export declare function getPaddedExitPoints(exitPoint: Point, exitSide: Side, padding?: number): Point[];
		export declare function getPointsFromRect(rect: DOMRect): {
		x: number;
		y: number;
		}[];
		export declare function isPointInPolygon(point: Point, polygon: Polygon): boolean;
		export declare function getHull<P extends Point>(points: Readonly<Array<P>>): Array<P>;
		export declare function getHullPresorted<P extends Point>(points: Readonly<Array<P>>): Array<P>;

+131

dist/utils.mjs

		import { createProvideScope } from "@oku-ui/provide";
		import { createPopperScope } from "@oku-ui/popper";
		export const [createTooltipProvide, createTooltipScope] = createProvideScope("Tooltip", [
		createPopperScope
		]);
		export const DEFAULT_DELAY_DURATION = 700;
		export const TOOLTIP_OPEN = "tooltip.open";
		export const usePopperScope = createPopperScope();
		export function getExitSideFromRect(point, rect) {
		const top = Math.abs(rect.top - point.y);
		const bottom = Math.abs(rect.bottom - point.y);
		const right = Math.abs(rect.right - point.x);
		const left = Math.abs(rect.left - point.x);
		switch (Math.min(top, bottom, right, left)) {
		case left:
		return "left";
		case right:
		return "right";
		case top:
		return "top";
		case bottom:
		return "bottom";
		default:
		throw new Error("unreachable");
		}
		}
		export function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
		const paddedExitPoints = [];
		switch (exitSide) {
		case "top":
		paddedExitPoints.push(
		{ x: exitPoint.x - padding, y: exitPoint.y + padding },
		{ x: exitPoint.x + padding, y: exitPoint.y + padding }
		);
		break;
		case "bottom":
		paddedExitPoints.push(
		{ x: exitPoint.x - padding, y: exitPoint.y - padding },
		{ x: exitPoint.x + padding, y: exitPoint.y - padding }
		);
		break;
		case "left":
		paddedExitPoints.push(
		{ x: exitPoint.x + padding, y: exitPoint.y - padding },
		{ x: exitPoint.x + padding, y: exitPoint.y + padding }
		);
		break;
		case "right":
		paddedExitPoints.push(
		{ x: exitPoint.x - padding, y: exitPoint.y - padding },
		{ x: exitPoint.x - padding, y: exitPoint.y + padding }
		);
		break;
		}
		return paddedExitPoints;
		}
		export function getPointsFromRect(rect) {
		const { top, right, bottom, left } = rect;
		return [
		{ x: left, y: top },
		{ x: right, y: top },
		{ x: right, y: bottom },
		{ x: left, y: bottom }
		];
		}
		export function isPointInPolygon(point, polygon) {
		const { x, y } = point;
		let inside = false;
		for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
		const xi = polygon[i].x;
		const yi = polygon[i].y;
		const xj = polygon[j].x;
		const yj = polygon[j].y;
		const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
		if (intersect)
		inside = !inside;
		}
		return inside;
		}
		export function getHull(points) {
		const newPoints = points.slice();
		newPoints.sort((a, b) => {
		if (a.x < b.x)
		return -1;
		else if (a.x > b.x)
		return 1;
		else if (a.y < b.y)
		return -1;
		else if (a.y > b.y)
		return 1;
		else
		return 0;
		});
		return getHullPresorted(newPoints);
		}
		export function getHullPresorted(points) {
		if (points.length <= 1)
		return points.slice();
		const upperHull = [];
		for (let i = 0; i < points.length; i++) {
		const p = points[i];
		while (upperHull.length >= 2) {
		const q = upperHull[upperHull.length - 1];
		const r = upperHull[upperHull.length - 2];
		if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))
		upperHull.pop();
		else
		break;
		}
		upperHull.push(p);
		}
		upperHull.pop();
		const lowerHull = [];
		for (let i = points.length - 1; i >= 0; i--) {
		const p = points[i];
		while (lowerHull.length >= 2) {
		const q = lowerHull[lowerHull.length - 1];
		const r = lowerHull[lowerHull.length - 2];
		if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))
		lowerHull.pop();
		else
		break;
		}
		lowerHull.push(p);
		}
		lowerHull.pop();
		if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y)
		return upperHull;
		else
		return upperHull.concat(lowerHull);
		}

+12

-1082

dist/index.d.ts

		@@ -1,1082 +0,12 @@
		import * as vue from 'vue';
		import { PropType } from 'vue';
		import * as _oku_ui_provide from '@oku-ui/provide';
		import { OkuElement, PrimitiveProps } from '@oku-ui/primitive';
		import { PortalElement, PortalElementNaviteElement, PortalProps as PortalProps$1 } from '@oku-ui/portal';
		import * as _floating_ui_vue from '@floating-ui/vue';
		import { DismissableLayerEmits } from '@oku-ui/dismissable-layer';
		import { PopperContentNaviteElement, PopperContentElement, PopperContentEmits, PopperContentProps as PopperContentProps$1, PopperArrowNaviteElement, PopperArrowElement, PopperArrowProps } from '@oku-ui/popper';

		type TooltipTriggerNaviteElement = OkuElement<'button'>;
		type TooltipTriggerElement = HTMLButtonElement;
		interface TooltipTriggerProps {
		}
		declare const tooltipTriggerProps: {
		props: {
		asChild: BooleanConstructor;
		};
		emits: {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		};
		};
		declare const OkuTooltipTrigger: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, {
		asChild: boolean;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		asChild: boolean;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		}, string, {
		asChild: boolean;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipTriggerNaviteElement;
		});

		interface TooltipProps {
		open?: boolean;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		defaultOpen?: boolean;
		/**
		* The duration from when the pointer enters the trigger until the tooltip gets opened. This will
		* override the prop with the same name passed to Provider.
		* @defaultValue 700
		*/
		delayDuration?: number;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		disableHoverableContent?: boolean;
		}
		type TooltipEmits = {
		'update:modelValue': [open: boolean];
		'openChange': [open: boolean];
		};
		declare const tooltipProps: {
		props: {
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		};
		emits: {
		'update:modelValue': (open: boolean) => boolean;
		openChange: (open: boolean) => boolean;
		};
		};
		declare const OkuTooltip: vue.DefineComponent<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		'update:modelValue': (open: boolean) => boolean;
		openChange: (open: boolean) => boolean;
		}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		}>> & {
		"onUpdate:modelValue"?: ((open: boolean) => any) \| undefined;
		onOpenChange?: ((open: boolean) => any) \| undefined;
		}, {
		asChild: boolean;
		delayDuration: number \| undefined;
		disableHoverableContent: boolean \| undefined;
		modelValue: boolean \| undefined;
		open: boolean \| undefined;
		defaultOpen: boolean;
		}, {}>;

		interface TooltipProviderProps {
		/**
		* The duration from when the pointer enters the trigger until the tooltip gets opened.
		* @defaultValue 700
		*/
		delayDuration?: number;
		/**
		* How much time a user has to enter another trigger without incurring a delay again.
		* @defaultValue 300
		*/
		skipDelayDuration?: number;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		disableHoverableContent?: boolean;
		}
		declare const tooltipProviderProps: {
		props: {
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		};
		};
		declare const OkuTooltipProvider: vue.DefineComponent<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>[] \| undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		}>>, {
		delayDuration: number;
		skipDelayDuration: number;
		disableHoverableContent: boolean;
		}, {}>;

		type TooltipPortalElement = PortalElement;
		type TooltipPortalNaviteElement = PortalElementNaviteElement;
		type PortalProps = PortalProps$1;
		interface TooltipPortalProps {
		/**
		* Specify a container element to portal the content into.
		*/
		container?: PortalProps['container'];
		/**
		* Used to force mounting when more control is needed. Useful when
		* controlling animation with React animation libraries.
		*/
		forceMount?: true;
		}
		declare const tooltipPortalProps: {
		props: {
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		};
		};
		declare const OkuTooltipPortal: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipPortalNaviteElement;
		});

		type TooltipContentImplNaviteElement = PopperContentNaviteElement;
		type TooltipContentImplElement = PopperContentElement;
		type PopperContentProps = PopperContentProps$1;
		interface TooltipContentImplProps extends PopperContentProps {
		/**
		* A more descriptive label for accessibility purpose
		*/
		'ariaLabel'?: string;
		}
		type TooltipContentImplEmits = Omit<PopperContentEmits, 'placed'> & {
		/**
		* Event handler called when the escape key is down.
		* Can be prevented.
		*/
		escapeKeydown: [event: DismissableLayerEmits['escapeKeydown'][0]];
		/**
		* Event handler called when the a `pointerdown` event happens outside of the `Tooltip`.
		* Can be prevented.
		*/
		pointerdownOutside: [event: DismissableLayerEmits['pointerdownOutside'][0]];
		close: [];
		};

		type TooltipContentNaviteElement = TooltipContentImplNaviteElement;
		type TooltipContentElement = TooltipContentImplElement;
		interface TooltipContentProps extends PrimitiveProps, TooltipContentImplProps {
		/**
		* Used to force mounting when more control is needed. Useful when
		* controlling animation with React animation libraries.
		*/
		forceMount?: true;
		}
		type TooltipContentEmits = TooltipContentImplEmits;
		declare const tooltipContentProps: {
		props: {
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		};
		emits: {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => boolean;
		close: () => boolean;
		};
		};
		declare const OkuTooltipContent: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => boolean;
		close: () => boolean;
		}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: _floating_ui_vue.Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: _floating_ui_vue.Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => boolean;
		close: () => boolean;
		}, string, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: _floating_ui_vue.Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipContentNaviteElement;
		});

		type TooltipArrowNaviteElement = PopperArrowNaviteElement;
		type TooltipArrowElement = PopperArrowElement;
		interface TooltipArrowProps extends PopperArrowProps {
		}
		declare const tooltipArrowProps: {
		props: {
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		};
		emits: {};
		};
		declare const OkuTooltipArrow: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}> \| null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, {
		asChild: boolean;
		height: number;
		width: number;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}> \| null, {}, {}, {}, {
		asChild: boolean;
		height: number;
		width: number;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}> \| null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
		asChild: boolean;
		height: number;
		width: number;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipArrowNaviteElement;
		});

		export { OkuTooltip, OkuTooltipArrow, OkuTooltipContent, OkuTooltipPortal, OkuTooltipProvider, OkuTooltipTrigger, type TooltipArrowElement, type TooltipArrowNaviteElement, type TooltipArrowProps, type TooltipContentElement, type TooltipContentEmits, type TooltipContentNaviteElement, type TooltipContentProps, type TooltipEmits, type TooltipPortalElement, type TooltipPortalProps, type TooltipProps, type TooltipProviderProps, type TooltipTriggerElement, type TooltipTriggerNaviteElement, type TooltipTriggerProps, tooltipArrowProps, tooltipContentProps, tooltipPortalProps, tooltipProps, tooltipProviderProps, tooltipTriggerProps };
		export { OkuTooltip, tooltipProps, } from './tooltip';
		export type { TooltipEmits, TooltipProps, } from './tooltip';
		export { OkuTooltipProvider, tooltipProviderProps, } from './tooltipProvider';
		export type { TooltipProviderProps, } from './tooltipProvider';
		export { OkuTooltipTrigger, tooltipTriggerProps, } from './tooltipTrigger';
		export type { TooltipTriggerElement, TooltipTriggerNaviteElement, TooltipTriggerProps, } from './tooltipTrigger';
		export { OkuTooltipPortal, tooltipPortalProps, } from './tooltipPortal';
		export type { TooltipPortalProps, TooltipPortalElement, } from './tooltipPortal';
		export { OkuTooltipContent, tooltipContentProps, } from './tooltipContent';
		export type { TooltipContentElement, TooltipContentNaviteElement, TooltipContentProps, TooltipContentEmits, } from './tooltipContent';
		export { OkuTooltipArrow, tooltipArrowProps, } from './tooltipArrow';
		export type { TooltipArrowElement, TooltipArrowNaviteElement, TooltipArrowProps, } from './tooltipArrow';

+24

-816

dist/index.mjs

		@@ -1,816 +0,24 @@
		import { defineComponent, toRefs, ref, onMounted, onBeforeUnmount, computed, useModel, h, reactive, watchEffect, mergeProps } from 'vue';
		import { primitiveProps, Primitive, propsOmit } from '@oku-ui/primitive';
		import { useId, useControllable, reactiveOmit, useForwardRef, useComposedRefs } from '@oku-ui/use-composable';
		import { createPopperScope, OkuPopper, OkuPopperAnchor, popperContentProps, OkuPopperContent, popperArrowProps, OkuPopperArrow } from '@oku-ui/popper';
		import { createProvideScope, ScopePropObject } from '@oku-ui/provide';
		import { composeEventHandlers } from '@oku-ui/utils';
		import { OkuPortal } from '@oku-ui/portal';
		import { OkuPresence } from '@oku-ui/presence';
		import { OkuDismissableLayer } from '@oku-ui/dismissable-layer';
		import { OkuSlottable } from '@oku-ui/slot';
		import { OkuVisuallyHidden } from '@oku-ui/visually-hidden';

		const [createTooltipProvide, createTooltipScope] = createProvideScope("Tooltip", [
		createPopperScope
		]);
		const DEFAULT_DELAY_DURATION = 700;
		const TOOLTIP_OPEN = "tooltip.open";
		const usePopperScope = createPopperScope();
		function getExitSideFromRect(point, rect) {
		const top = Math.abs(rect.top - point.y);
		const bottom = Math.abs(rect.bottom - point.y);
		const right = Math.abs(rect.right - point.x);
		const left = Math.abs(rect.left - point.x);
		switch (Math.min(top, bottom, right, left)) {
		case left:
		return "left";
		case right:
		return "right";
		case top:
		return "top";
		case bottom:
		return "bottom";
		default:
		throw new Error("unreachable");
		}
		}
		function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
		const paddedExitPoints = [];
		switch (exitSide) {
		case "top":
		paddedExitPoints.push(
		{ x: exitPoint.x - padding, y: exitPoint.y + padding },
		{ x: exitPoint.x + padding, y: exitPoint.y + padding }
		);
		break;
		case "bottom":
		paddedExitPoints.push(
		{ x: exitPoint.x - padding, y: exitPoint.y - padding },
		{ x: exitPoint.x + padding, y: exitPoint.y - padding }
		);
		break;
		case "left":
		paddedExitPoints.push(
		{ x: exitPoint.x + padding, y: exitPoint.y - padding },
		{ x: exitPoint.x + padding, y: exitPoint.y + padding }
		);
		break;
		case "right":
		paddedExitPoints.push(
		{ x: exitPoint.x - padding, y: exitPoint.y - padding },
		{ x: exitPoint.x - padding, y: exitPoint.y + padding }
		);
		break;
		}
		return paddedExitPoints;
		}
		function getPointsFromRect(rect) {
		const { top, right, bottom, left } = rect;
		return [
		{ x: left, y: top },
		{ x: right, y: top },
		{ x: right, y: bottom },
		{ x: left, y: bottom }
		];
		}
		function isPointInPolygon(point, polygon) {
		const { x, y } = point;
		let inside = false;
		for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
		const xi = polygon[i].x;
		const yi = polygon[i].y;
		const xj = polygon[j].x;
		const yj = polygon[j].y;
		const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
		if (intersect)
		inside = !inside;
		}
		return inside;
		}
		function getHull(points) {
		const newPoints = points.slice();
		newPoints.sort((a, b) => {
		if (a.x < b.x)
		return -1;
		else if (a.x > b.x)
		return 1;
		else if (a.y < b.y)
		return -1;
		else if (a.y > b.y)
		return 1;
		else
		return 0;
		});
		return getHullPresorted(newPoints);
		}
		function getHullPresorted(points) {
		if (points.length <= 1)
		return points.slice();
		const upperHull = [];
		for (let i = 0; i < points.length; i++) {
		const p = points[i];
		while (upperHull.length >= 2) {
		const q = upperHull[upperHull.length - 1];
		const r = upperHull[upperHull.length - 2];
		if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))
		upperHull.pop();
		else
		break;
		}
		upperHull.push(p);
		}
		upperHull.pop();
		const lowerHull = [];
		for (let i = points.length - 1; i >= 0; i--) {
		const p = points[i];
		while (lowerHull.length >= 2) {
		const q = lowerHull[lowerHull.length - 1];
		const r = lowerHull[lowerHull.length - 2];
		if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))
		lowerHull.pop();
		else
		break;
		}
		lowerHull.push(p);
		}
		lowerHull.pop();
		if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y)
		return upperHull;
		else
		return upperHull.concat(lowerHull);
		}

		const scopeTooltipProps = {
		scopeOkuTooltip: {
		...ScopePropObject
		}
		};

		const PROVIDER_NAME = "TooltipProvider";
		const [tooltipProviderProvide, useTooltipProviderInject] = createTooltipProvide(PROVIDER_NAME);
		const tooltipProviderProps = {
		props: {
		delayDuration: {
		type: Number,
		default: DEFAULT_DELAY_DURATION
		},
		skipDelayDuration: {
		type: Number,
		default: 300
		},
		disableHoverableContent: {
		type: Boolean,
		default: false
		}
		}
		};
		const NAME$1 = "OkuTooltipProvider";
		const tooltipProvider = defineComponent({
		name: NAME$1,
		inheritAttrs: false,
		props: {
		...tooltipProviderProps.props,
		...scopeTooltipProps
		},
		setup(props, { slots }) {
		const {
		delayDuration,
		disableHoverableContent,
		scopeOkuTooltip,
		skipDelayDuration
		} = toRefs(props);
		const isOpenDelayed = ref(true);
		const isPointerInTransitRef = ref(false);
		const skipDelayTimerRef = ref(0);
		const skipDelayTimer = ref();
		onMounted(() => {
		skipDelayTimer.value = skipDelayTimerRef.value;
		});
		onBeforeUnmount(() => {
		window.clearTimeout(skipDelayTimer.value);
		});
		tooltipProviderProvide({
		scope: scopeOkuTooltip.value,
		isOpenDelayed,
		delayDuration,
		onOpen() {
		window.clearTimeout(skipDelayTimerRef.value);
		isOpenDelayed.value = false;
		},
		onClose() {
		window.clearTimeout(skipDelayTimerRef.value);
		skipDelayTimerRef.value = window.setTimeout(
		() => isOpenDelayed.value = false,
		skipDelayDuration.value
		);
		},
		isPointerInTransitRef,
		onPointerInTransitChange(inTransit) {
		isPointerInTransitRef.value = inTransit;
		},
		disableHoverableContent
		});
		return () => slots.default?.();
		}
		});
		const OkuTooltipProvider = tooltipProvider;

		const TOOLTIP_NAME = "OkuTooltip";
		const [tooltipProvide, useTooltipInject] = createTooltipProvide(TOOLTIP_NAME);
		const tooltipProps = {
		props: {
		modelValue: {
		type: [Boolean],
		default: void 0
		},
		open: {
		type: Boolean,
		default: void 0
		},
		defaultOpen: {
		type: Boolean,
		default: false
		},
		delayDuration: {
		type: Number,
		default: 700
		},
		disableHoverableContent: {
		type: Boolean,
		default: false
		},
		...primitiveProps
		},
		emits: {
		// eslint-disable-next-line unused-imports/no-unused-vars
		"update:modelValue": (open) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		"openChange": (open) => true
		}
		};
		const tooltip = defineComponent({
		name: TOOLTIP_NAME,
		inheritAttrs: false,
		props: {
		...tooltipProps.props,
		...scopeTooltipProps
		},
		emits: tooltipProps.emits,
		setup(props, { slots, emit }) {
		const {
		open: openProp,
		defaultOpen,
		disableHoverableContent: disableHoverableContentProp,
		delayDuration: delayDurationProp
		} = toRefs(props);
		const provideInject = useTooltipProviderInject(TOOLTIP_NAME, props.scopeOkuTooltip);
		const popperScope = usePopperScope(props.scopeOkuTooltip);
		const trigger = ref(null);
		const contentId = useId();
		const openTimerRef = ref(0);
		const disableHoverableContent = computed(() => disableHoverableContentProp.value ?? provideInject.disableHoverableContent.value);
		const delayDuration = computed(() => delayDurationProp.value ?? provideInject.delayDuration.value);
		const wasOpenDelayedRef = ref(false);
		const modelValue = useModel(props, "modelValue");
		const proxyChecked = computed({
		get: () => modelValue.value !== void 0 ? modelValue.value : openProp.value !== void 0 ? openProp.value : void 0,
		set: () => {
		}
		});
		const { state, updateValue } = useControllable({
		prop: computed(() => proxyChecked.value),
		defaultProp: computed(() => defaultOpen.value),
		onChange: (result) => {
		if (result) {
		provideInject.onOpen();
		document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
		} else {
		provideInject.onClose();
		}
		modelValue.value = result;
		emit("openChange", result);
		},
		initialValue: false
		});
		const stateAttribute = computed(() => {
		return state.value ? wasOpenDelayedRef.value ? "delayed-open" : "instant-open" : "closed";
		});
		const handleOpen = () => {
		window.clearTimeout(openTimerRef.value);
		wasOpenDelayedRef.value = false;
		updateValue(true);
		};
		const handleClose = () => {
		window.clearTimeout(openTimerRef.value);
		updateValue(false);
		};
		const handleDelayedOpen = () => {
		window.clearTimeout(openTimerRef.value);
		openTimerRef.value = window.setTimeout(() => {
		wasOpenDelayedRef.value = true;
		updateValue(true);
		}, delayDuration.value);
		};
		onBeforeUnmount(() => {
		window.clearTimeout(openTimerRef.value);
		});
		tooltipProvide({
		scope: props.scopeOkuTooltip,
		contentId: computed(() => contentId),
		open: state,
		stateAttribute,
		trigger,
		onTriggerChange: (value) => {
		trigger.value = value;
		},
		onTriggerEnter: () => {
		if (provideInject.isOpenDelayed.value)
		handleDelayedOpen();
		else
		handleOpen();
		},
		onTriggerLeave: () => {
		if (disableHoverableContent.value) {
		handleClose();
		} else {
		window.clearTimeout(openTimerRef.value);
		}
		},
		onOpen: () => handleOpen(),
		onClose: () => handleClose(),
		disableHoverableContent
		});
		return () => h(OkuPopper, {
		...popperScope
		}, slots);
		}
		});
		const OkuTooltip = tooltip;

		const TRIGGER_NAME = "OkuTooltipTrigger";
		const tooltipTriggerProps = {
		props: {
		...primitiveProps
		},
		emits: {
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointermove: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointerleave: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointerdown: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		focus: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		blur: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		click: (event) => true
		}
		};
		const tooltipTrigger = defineComponent({
		name: TRIGGER_NAME,
		inheritAttrs: false,
		props: {
		...tooltipTriggerProps.props,
		...scopeTooltipProps
		},
		emits: tooltipTriggerProps.emits,
		setup(props, { attrs, slots, emit }) {
		const { scopeOkuTooltip, ...triggerProps } = toRefs(props);
		const _reactive = reactive(triggerProps);
		const reactiveTriggerProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const inject = useTooltipInject(TRIGGER_NAME, scopeOkuTooltip.value);
		const providerInject = useTooltipProviderInject(TRIGGER_NAME, scopeOkuTooltip.value);
		const popperScope = usePopperScope(scopeOkuTooltip.value);
		const buttonRef = ref(null);
		const forwardedRef = useForwardRef();
		const composedRefs = useComposedRefs(buttonRef, forwardedRef, (el) => {
		inject.onTriggerChange(el);
		});
		const isPointerDownRef = ref(false);
		const hasPointerMoveOpenedRef = ref(false);
		const handlePointerUp = () => {
		isPointerDownRef.value = false;
		};
		watchEffect((onCleanup) => {
		onCleanup(() => {
		document.removeEventListener("pointerup", handlePointerUp);
		});
		});
		return () => h(OkuPopperAnchor, {
		asChild: true,
		...popperScope
		}, {
		default: () => h(Primitive.button, {
		// We purposefully avoid adding `type=button` here because tooltip triggers are also
		// commonly anchors and the anchor `type` attribute signifies MIME type.
		"aria-describedby": inject.open.value ? inject.contentId.value : void 0,
		"data-state": inject.stateAttribute.value,
		...mergeProps(attrs, reactiveTriggerProps),
		"ref": composedRefs,
		"onPointermove": composeEventHandlers((el) => {
		emit("pointermove", el);
		}, (event) => {
		if (event.pointerType === "touch")
		return;
		if (!hasPointerMoveOpenedRef.value && !providerInject.isPointerInTransitRef.value) {
		inject.onTriggerEnter();
		hasPointerMoveOpenedRef.value = true;
		}
		}),
		"onPointerleave": composeEventHandlers((el) => {
		emit("pointerleave", el);
		}, () => {
		inject.onTriggerLeave();
		hasPointerMoveOpenedRef.value = false;
		}),
		"onPointerdown": composeEventHandlers((el) => {
		emit("pointerdown", el);
		}, () => {
		isPointerDownRef.value = true;
		document.addEventListener("pointerup", handlePointerUp, { once: true });
		}),
		"onFocus": composeEventHandlers((el) => {
		emit("focus", el);
		}, () => {
		if (!isPointerDownRef.value)
		inject.onOpen();
		}),
		"onBlur": composeEventHandlers((el) => {
		emit("blur", el);
		}, inject.onClose),
		"onClick": composeEventHandlers((el) => {
		emit("click", el);
		}, inject.onClose)
		}, {
		default: () => slots.default?.()
		})
		});
		}
		});
		const OkuTooltipTrigger = tooltipTrigger;

		const PORTAL_NAME = "OkuTooltipPortal";
		const [portalProvider, usePortalInject] = createTooltipProvide(PORTAL_NAME, {
		forceMount: void 0
		});
		const tooltipPortalProps = {
		props: {
		container: {
		type: Object,
		default: void 0
		},
		forceMount: {
		type: Boolean,
		default: void 0
		},
		...primitiveProps
		}
		};
		const tooltipPortal = defineComponent({
		name: PORTAL_NAME,
		inheritAttrs: false,
		props: {
		...tooltipPortalProps.props,
		...scopeTooltipProps
		},
		setup(props, { slots }) {
		const { container, forceMount, scopeOkuTooltip } = toRefs(props);
		const inject = useTooltipInject(PORTAL_NAME, scopeOkuTooltip.value);
		portalProvider({
		scope: scopeOkuTooltip.value,
		forceMount
		});
		return () => h(OkuPresence, {
		present: computed(() => forceMount.value \|\| inject.open.value).value
		}, {
		default: () => h(OkuPortal, {
		asChild: true,
		container: container.value
		}, {
		default: () => slots.default?.()
		})
		});
		}
		});
		const OkuTooltipPortal = tooltipPortal;

		const CONTENT_NAME$1 = "OkuTooltipContentImpl";
		const [visuallyHiddenContentProvider, useVisuallyHiddenContentInject] = createTooltipProvide(TOOLTIP_NAME, { isInside: ref(false) });
		const tooltipContentImplProps = {
		props: {
		...popperContentProps.props,
		ariaLabel: {
		type: String,
		default: void 0
		},
		...primitiveProps
		},
		emits: {
		...propsOmit(popperContentProps.emits, ["placed"]),
		// eslint-disable-next-line unused-imports/no-unused-vars
		escapeKeydown: (event) => true,
		// eslint-disable-next-line unused-imports/no-unused-vars
		pointerdownOutside: (event) => true,
		close: () => true
		}
		};
		const tooltipContentImpl = defineComponent({
		name: CONTENT_NAME$1,
		components: {
		OkuDismissableLayer,
		OkuPopperContent,
		OkuSlottable,
		OkuVisuallyHidden
		},
		inheritAttrs: false,
		props: {
		...tooltipContentImplProps.props,
		...primitiveProps,
		...scopeTooltipProps
		},
		emits: tooltipContentImplProps.emits,
		setup(props, { attrs, emit, slots }) {
		const {
		ariaLabel,
		asChild: _asChild,
		scopeOkuTooltip,
		...contentProps
		} = toRefs(props);
		const _reactive = reactive(contentProps);
		const reactiveTooltipProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const inject = useTooltipInject(CONTENT_NAME$1, scopeOkuTooltip.value);
		const popperScope = usePopperScope(scopeOkuTooltip.value);
		const forwardedRef = useForwardRef();
		watchEffect((onClean) => {
		document.addEventListener(TOOLTIP_OPEN, inject.onClose);
		onClean(() => {
		document.removeEventListener(TOOLTIP_OPEN, inject.onClose);
		});
		});
		watchEffect((onClean) => {
		if (inject.trigger.value) {
		const handleScroll = (event) => {
		const target = event.target;
		if (target?.contains(inject.trigger.value))
		inject.onClose();
		};
		window.addEventListener("scroll", handleScroll, { capture: true });
		onClean(() => {
		window.removeEventListener("scroll", handleScroll, { capture: true });
		});
		}
		});
		visuallyHiddenContentProvider({
		scope: scopeOkuTooltip.value,
		isInside: ref(false)
		});
		const VisuallyHiddenChild = defineComponent({
		inheritAttrs: false,
		props: {
		scope: { type: null, required: false }
		},
		setup(props2, { slots: slots2 }) {
		visuallyHiddenContentProvider({
		scope: props2.scope,
		isInside: ref(true)
		});
		return () => slots2.default?.();
		}
		});
		return () => h(OkuDismissableLayer, {
		asChild: true,
		disableOutsidePointerEvents: false,
		onEscapeKeydown(event) {
		emit("escapeKeydown", event);
		},
		onPointerdownOutside(event) {
		emit("pointerdownOutside", event);
		},
		onFocusOutside(event) {
		event.preventDefault();
		},
		onDismiss() {
		inject.onClose();
		}
		}, {
		default: () => h(OkuPopperContent, {
		"data-state": inject.stateAttribute.value,
		...popperScope,
		...mergeProps(attrs, reactiveTooltipProps),
		"ref": forwardedRef,
		"style": {
		...attrs.style,
		...{
		"--oku-tooltip-content-transform-origin": "var(--oku-popper-transform-origin)",
		"--oku-tooltip-content-available-width": "var(--oku-popper-available-width)",
		"--oku-tooltip-content-available-height": "var(--oku-popper-available-height)",
		"--oku-tooltip-trigger-width": "var(--oku-popper-anchor-width)",
		"--oku-tooltip-trigger-height": "var(--oku-popper-anchor-height)"
		}
		}
		}, {
		default: () => [
		h(OkuSlottable, {}, slots),
		h(VisuallyHiddenChild, {
		scope: props.scopeOkuTooltip
		}, {
		default: () => h(OkuVisuallyHidden, {
		id: inject.contentId.value,
		role: "tooltip"
		}, {
		default: () => ariaLabel.value \|\| slots.default?.()
		})
		})
		]
		})
		});
		}
		});
		const OkuTooltipContentImpl = tooltipContentImpl;

		const tooltipContentHoverableProps = {
		props: {
		...primitiveProps,
		...tooltipContentImplProps.props
		},
		emits: {
		...tooltipContentImplProps.emits
		}
		};
		const NAME = "OkuTooltipContentHoverable";
		const tooltipContentHoverable = defineComponent({
		name: NAME,
		inheritAttrs: false,
		props: {
		...tooltipContentHoverableProps.props,
		...scopeTooltipProps
		},
		emits: tooltipContentHoverableProps.emits,
		setup(props, { attrs, slots }) {
		const inject = useTooltipInject(CONTENT_NAME, props.scopeOkuTooltip);
		const providerInject = useTooltipProviderInject(CONTENT_NAME, props.scopeOkuTooltip);
		const contentRef = ref(null);
		const forwardedRef = useForwardRef();
		const composedRefs = useComposedRefs(forwardedRef, contentRef);
		const pointerGraceArea = ref(null);
		const handleRemoveGraceArea = () => {
		pointerGraceArea.value = null;
		providerInject.onPointerInTransitChange(false);
		};
		const handleCreateGraceArea = (event, hoverTarget) => {
		const currentTarget = event.currentTarget;
		const exitPoint = {
		x: event.clientX,
		y: event.clientY
		};
		const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
		const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
		const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
		const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
		pointerGraceArea.value = graceArea;
		providerInject.onPointerInTransitChange(true);
		};
		watchEffect((onCleanup) => {
		onCleanup(() => {
		handleRemoveGraceArea();
		});
		});
		watchEffect((onCleanup) => {
		if (inject.trigger.value && contentRef.value) {
		const handleTriggerLeave = (event) => {
		if (contentRef.value)
		handleCreateGraceArea(event, contentRef.value);
		};
		const handleContentLeave = (event) => {
		if (inject.trigger.value)
		handleCreateGraceArea(event, inject.trigger.value);
		};
		inject.trigger.value.addEventListener("pointerleave", handleTriggerLeave);
		contentRef.value.addEventListener("pointerleave", handleContentLeave);
		onCleanup(() => {
		inject.trigger.value?.removeEventListener("pointerleave", handleTriggerLeave);
		contentRef.value?.removeEventListener("pointerleave", handleContentLeave);
		});
		}
		});
		watchEffect((onCleanup) => {
		if (pointerGraceArea.value) {
		const handleTrackPointerGrace = (event) => {
		const target = event.target;
		const pointerPosition = {
		x: event.clientX,
		y: event.clientY
		};
		const hasEnteredTarget = inject.trigger.value?.contains(target) \|\| contentRef.value?.contains(target);
		const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea.value);
		if (hasEnteredTarget) {
		handleRemoveGraceArea();
		} else if (isPointerOutsideGraceArea) {
		handleRemoveGraceArea();
		inject.onClose();
		}
		};
		document.addEventListener("pointermove", handleTrackPointerGrace);
		onCleanup(() => {
		document.removeEventListener("pointermove", handleTrackPointerGrace);
		});
		}
		});
		return () => h(OkuTooltipContentImpl, {
		...mergeProps(attrs, props),
		ref: composedRefs
		}, {
		default: () => slots.default?.()
		});
		}
		});
		const OkuTooltipContentHoverable = tooltipContentHoverable;

		const tooltipContentProps = {
		props: {
		forceMount: {
		type: Boolean,
		default: void 0
		},
		...tooltipContentImplProps.props
		},
		emits: {
		...tooltipContentImplProps.emits
		}
		};
		const CONTENT_NAME = "OkuTooltipContent";
		const tooltipContent = defineComponent({
		name: CONTENT_NAME,
		inheritAttrs: false,
		props: {
		...tooltipContentProps.props,
		...primitiveProps,
		...scopeTooltipProps
		},
		emits: tooltipContentImplProps.emits,
		setup(props, { attrs, slots }) {
		const { forceMount: forceMountProps, side: sideProps, scopeOkuTooltip, ...contentProps } = toRefs(props);
		const _reactive = reactive(contentProps);
		const reactiveContentProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const portalInject = usePortalInject(CONTENT_NAME, scopeOkuTooltip.value);
		const forceMount = computed(() => forceMountProps.value \|\| portalInject.forceMount?.value);
		const side = computed(() => sideProps.value \|\| "top");
		const forwardedRef = useForwardRef();
		const inject = useTooltipInject(CONTENT_NAME, scopeOkuTooltip.value);
		return () => h(OkuPresence, {
		present: computed(() => forceMount.value \|\| inject.open.value).value
		}, {
		default: () => inject.disableHoverableContent.value ? h(OkuTooltipContentImpl, {
		side: side.value,
		...mergeProps(attrs, reactiveContentProps),
		ref: forwardedRef
		}, {
		default: () => slots.default?.()
		}) : h(OkuTooltipContentHoverable, {
		side: side.value,
		...mergeProps(attrs, reactiveContentProps),
		ref: forwardedRef
		}, slots)
		});
		}
		});
		const OkuTooltipContent = tooltipContent;

		const tooltipArrowProps = {
		props: {
		...popperArrowProps.props
		},
		emits: {
		...popperArrowProps.emits
		}
		};
		const ARROW_NAME = "OkuTooltipArrow";
		const tooltipArrow = defineComponent({
		name: ARROW_NAME,
		components: {
		OkuPopperArrow
		},
		inheritAttrs: false,
		props: {
		...tooltipArrowProps.props,
		...scopeTooltipProps
		},
		emits: tooltipArrowProps.emits,
		setup(props, { attrs, slots }) {
		const { scopeOkuTooltip, ...arrowProps } = toRefs(props);
		const _reactive = reactive(arrowProps);
		const reactiveArrowProps = reactiveOmit(_reactive, (key, _value) => key === void 0);
		const forwardedRef = useForwardRef();
		const popperScope = usePopperScope(scopeOkuTooltip.value);
		const visuallyHiddenContentInject = useVisuallyHiddenContentInject(ARROW_NAME, scopeOkuTooltip.value);
		return () => visuallyHiddenContentInject.isInside.value ? null : h(OkuPopperArrow, {
		...popperScope,
		...mergeProps(attrs, reactiveArrowProps),
		ref: forwardedRef
		}, slots);
		}
		});
		const OkuTooltipArrow = tooltipArrow;

		export { OkuTooltip, OkuTooltipArrow, OkuTooltipContent, OkuTooltipPortal, OkuTooltipProvider, OkuTooltipTrigger, tooltipArrowProps, tooltipContentProps, tooltipPortalProps, tooltipProps, tooltipProviderProps, tooltipTriggerProps };
		export {
		OkuTooltip,
		tooltipProps
		} from "./tooltip.mjs";
		export {
		OkuTooltipProvider,
		tooltipProviderProps
		} from "./tooltipProvider.mjs";
		export {
		OkuTooltipTrigger,
		tooltipTriggerProps
		} from "./tooltipTrigger.mjs";
		export {
		OkuTooltipPortal,
		tooltipPortalProps
		} from "./tooltipPortal.mjs";
		export {
		OkuTooltipContent,
		tooltipContentProps
		} from "./tooltipContent.mjs";
		export {
		OkuTooltipArrow,
		tooltipArrowProps
		} from "./tooltipArrow.mjs";

+4

-2

package.json

		{
		"name": "@oku-ui/tooltip",
		"type": "module",
		"version": "0.6.0",
		"version": "0.6.1",
		"license": "MIT",
		@@ -35,3 +35,3 @@ "source": "src/index.ts",
		"dependencies": {
		"@floating-ui/vue": "^1.0.2",
		"@floating-ui/vue": "^1.0.3",
		"@oku-ui/dismissable-layer": "latest",
		@@ -58,4 +58,6 @@ "@oku-ui/popper": "latest",
		"release": "pnpm build && pnpm bumpp --commit='version(tooltip): release %s' --no-tag && pnpm publish",
		"release:beta": "pnpm release --tag beta",
		"release:alpha": "pnpm release --tag alpha",
		"clean": "rimraf ./dist && rimraf ./node_modules"
		}
		}

-1082

dist/index.d.mts

		import * as vue from 'vue';
		import { PropType } from 'vue';
		import * as _oku_ui_provide from '@oku-ui/provide';
		import { OkuElement, PrimitiveProps } from '@oku-ui/primitive';
		import { PortalElement, PortalElementNaviteElement, PortalProps as PortalProps$1 } from '@oku-ui/portal';
		import * as _floating_ui_vue from '@floating-ui/vue';
		import { DismissableLayerEmits } from '@oku-ui/dismissable-layer';
		import { PopperContentNaviteElement, PopperContentElement, PopperContentEmits, PopperContentProps as PopperContentProps$1, PopperArrowNaviteElement, PopperArrowElement, PopperArrowProps } from '@oku-ui/popper';

		type TooltipTriggerNaviteElement = OkuElement<'button'>;
		type TooltipTriggerElement = HTMLButtonElement;
		interface TooltipTriggerProps {
		}
		declare const tooltipTriggerProps: {
		props: {
		asChild: BooleanConstructor;
		};
		emits: {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		};
		};
		declare const OkuTooltipTrigger: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, {
		asChild: boolean;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		asChild: boolean;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		}>> & {
		onFocus?: ((event: FocusEvent) => any) \| undefined;
		onBlur?: ((event: FocusEvent) => any) \| undefined;
		onClick?: ((event: MouseEvent) => any) \| undefined;
		onPointerdown?: ((event: PointerEvent) => any) \| undefined;
		onPointermove?: ((event: PointerEvent) => any) \| undefined;
		onPointerleave?: ((event: PointerEvent) => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		pointermove: (event: PointerEvent) => boolean;
		pointerleave: (event: PointerEvent) => boolean;
		pointerdown: (event: PointerEvent) => boolean;
		focus: (event: FocusEvent) => boolean;
		blur: (event: FocusEvent) => boolean;
		click: (event: MouseEvent) => boolean;
		}, string, {
		asChild: boolean;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipTriggerNaviteElement;
		});

		interface TooltipProps {
		open?: boolean;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		defaultOpen?: boolean;
		/**
		* The duration from when the pointer enters the trigger until the tooltip gets opened. This will
		* override the prop with the same name passed to Provider.
		* @defaultValue 700
		*/
		delayDuration?: number;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		disableHoverableContent?: boolean;
		}
		type TooltipEmits = {
		'update:modelValue': [open: boolean];
		'openChange': [open: boolean];
		};
		declare const tooltipProps: {
		props: {
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		};
		emits: {
		'update:modelValue': (open: boolean) => boolean;
		openChange: (open: boolean) => boolean;
		};
		};
		declare const OkuTooltip: vue.DefineComponent<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		'update:modelValue': (open: boolean) => boolean;
		openChange: (open: boolean) => boolean;
		}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		modelValue: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		open: {
		type: PropType<boolean \| undefined>;
		default: undefined;
		};
		defaultOpen: {
		type: PropType<boolean>;
		default: boolean;
		};
		delayDuration: {
		type: PropType<number \| undefined>;
		default: number;
		};
		disableHoverableContent: {
		type: PropType<boolean \| undefined>;
		default: boolean;
		};
		}>> & {
		"onUpdate:modelValue"?: ((open: boolean) => any) \| undefined;
		onOpenChange?: ((open: boolean) => any) \| undefined;
		}, {
		asChild: boolean;
		delayDuration: number \| undefined;
		disableHoverableContent: boolean \| undefined;
		modelValue: boolean \| undefined;
		open: boolean \| undefined;
		defaultOpen: boolean;
		}, {}>;

		interface TooltipProviderProps {
		/**
		* The duration from when the pointer enters the trigger until the tooltip gets opened.
		* @defaultValue 700
		*/
		delayDuration?: number;
		/**
		* How much time a user has to enter another trigger without incurring a delay again.
		* @defaultValue 300
		*/
		skipDelayDuration?: number;
		/**
		* When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
		* @defaultValue false
		*/
		disableHoverableContent?: boolean;
		}
		declare const tooltipProviderProps: {
		props: {
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		};
		};
		declare const OkuTooltipProvider: vue.DefineComponent<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>[] \| undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		delayDuration: {
		type: NumberConstructor;
		default: number;
		};
		skipDelayDuration: {
		type: NumberConstructor;
		default: number;
		};
		disableHoverableContent: {
		type: BooleanConstructor;
		default: boolean;
		};
		}>>, {
		delayDuration: number;
		skipDelayDuration: number;
		disableHoverableContent: boolean;
		}, {}>;

		type TooltipPortalElement = PortalElement;
		type TooltipPortalNaviteElement = PortalElementNaviteElement;
		type PortalProps = PortalProps$1;
		interface TooltipPortalProps {
		/**
		* Specify a container element to portal the content into.
		*/
		container?: PortalProps['container'];
		/**
		* Used to force mounting when more control is needed. Useful when
		* controlling animation with React animation libraries.
		*/
		forceMount?: true;
		}
		declare const tooltipPortalProps: {
		props: {
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		};
		};
		declare const OkuTooltipPortal: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		container: {
		type: PropType<HTMLElement \| null \| undefined>;
		default: undefined;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
		asChild: boolean;
		forceMount: true \| undefined;
		container: HTMLElement \| null \| undefined;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipPortalNaviteElement;
		});

		type TooltipContentImplNaviteElement = PopperContentNaviteElement;
		type TooltipContentImplElement = PopperContentElement;
		type PopperContentProps = PopperContentProps$1;
		interface TooltipContentImplProps extends PopperContentProps {
		/**
		* A more descriptive label for accessibility purpose
		*/
		'ariaLabel'?: string;
		}
		type TooltipContentImplEmits = Omit<PopperContentEmits, 'placed'> & {
		/**
		* Event handler called when the escape key is down.
		* Can be prevented.
		*/
		escapeKeydown: [event: DismissableLayerEmits['escapeKeydown'][0]];
		/**
		* Event handler called when the a `pointerdown` event happens outside of the `Tooltip`.
		* Can be prevented.
		*/
		pointerdownOutside: [event: DismissableLayerEmits['pointerdownOutside'][0]];
		close: [];
		};

		type TooltipContentNaviteElement = TooltipContentImplNaviteElement;
		type TooltipContentElement = TooltipContentImplElement;
		interface TooltipContentProps extends PrimitiveProps, TooltipContentImplProps {
		/**
		* Used to force mounting when more control is needed. Useful when
		* controlling animation with React animation libraries.
		*/
		forceMount?: true;
		}
		type TooltipContentEmits = TooltipContentImplEmits;
		declare const tooltipContentProps: {
		props: {
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		};
		emits: {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => boolean;
		close: () => boolean;
		};
		};
		declare const OkuTooltipContent: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => boolean;
		close: () => boolean;
		}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: _floating_ui_vue.Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, {}, {}, {}, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: _floating_ui_vue.Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		ariaLabel: {
		type: StringConstructor;
		default: undefined;
		};
		side: {
		type: PropType<"top" \| "right" \| "bottom" \| "left">;
		required: boolean;
		default: string;
		validator: (value: "top" \| "right" \| "bottom" \| "left") => boolean;
		};
		sideOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		align: {
		type: PropType<"start" \| "center" \| "end">;
		required: boolean;
		default: string;
		validator: (value: "start" \| "center" \| "end") => boolean;
		};
		alignOffset: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		arrowPadding: {
		type: NumberConstructor;
		required: boolean;
		default: number;
		};
		avoidCollisions: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		collisionBoundary: {
		type: PropType<(Element \| null) \| (Element \| null)[]>;
		required: boolean;
		default: () => never[];
		};
		collisionPadding: {
		type: PropType<_floating_ui_vue.Padding>;
		required: boolean;
		default: number;
		};
		sticky: {
		type: PropType<"partial" \| "always">;
		required: boolean;
		default: string;
		};
		hideWhenDetached: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		updatePositionStrategy: {
		type: PropType<"always" \| "optimized">;
		required: boolean;
		default: string;
		};
		layoutShift: {
		type: BooleanConstructor;
		required: boolean;
		default: boolean;
		};
		dir: {
		type: PropType<"ltr" \| "rtl">;
		};
		forceMount: {
		type: PropType<true \| undefined>;
		default: undefined;
		};
		}>> & {
		onEscapeKeydown?: ((event: KeyboardEvent) => any) \| undefined;
		onPointerdownOutside?: ((event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => any) \| undefined;
		onClose?: (() => any) \| undefined;
		}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
		escapeKeydown: (event: KeyboardEvent) => boolean;
		pointerdownOutside: (event: CustomEvent<{
		originalEvent: PointerEvent;
		}>) => boolean;
		close: () => boolean;
		}, string, {
		align: "start" \| "center" \| "end";
		ariaLabel: string;
		asChild: boolean;
		side: "top" \| "right" \| "bottom" \| "left";
		sideOffset: number;
		alignOffset: number;
		arrowPadding: number;
		avoidCollisions: boolean;
		collisionBoundary: (Element \| null) \| (Element \| null)[];
		collisionPadding: _floating_ui_vue.Padding;
		sticky: "partial" \| "always";
		hideWhenDetached: boolean;
		updatePositionStrategy: "always" \| "optimized";
		layoutShift: boolean;
		forceMount: true \| undefined;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipContentNaviteElement;
		});

		type TooltipArrowNaviteElement = PopperArrowNaviteElement;
		type TooltipArrowElement = PopperArrowElement;
		interface TooltipArrowProps extends PopperArrowProps {
		}
		declare const tooltipArrowProps: {
		props: {
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		};
		emits: {};
		};
		declare const OkuTooltipArrow: {
		new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}> \| null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, {
		asChild: boolean;
		height: number;
		width: number;
		}, true, {}, {}, {
		P: {};
		B: {};
		D: {};
		C: {};
		M: {};
		Defaults: {};
		}, Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}> \| null, {}, {}, {}, {
		asChild: boolean;
		height: number;
		width: number;
		}>;
		__isFragment?: undefined;
		__isTeleport?: undefined;
		__isSuspense?: undefined;
		} & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
		scopeOkuTooltip: {
		type: vue.PropType<_oku_ui_provide.Scope<any>>;
		required: boolean;
		};
		asChild: BooleanConstructor;
		width: {
		type: vue.PropType<number>;
		default: number;
		};
		height: {
		type: vue.PropType<number>;
		default: number;
		};
		}>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
		[key: string]: any;
		}> \| null, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
		asChild: boolean;
		height: number;
		width: number;
		}, {}, string, {}> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
		$props: TooltipArrowNaviteElement;
		});

		export { OkuTooltip, OkuTooltipArrow, OkuTooltipContent, OkuTooltipPortal, OkuTooltipProvider, OkuTooltipTrigger, type TooltipArrowElement, type TooltipArrowNaviteElement, type TooltipArrowProps, type TooltipContentElement, type TooltipContentEmits, type TooltipContentNaviteElement, type TooltipContentProps, type TooltipEmits, type TooltipPortalElement, type TooltipPortalProps, type TooltipProps, type TooltipProviderProps, type TooltipTriggerElement, type TooltipTriggerNaviteElement, type TooltipTriggerProps, tooltipArrowProps, tooltipContentProps, tooltipPortalProps, tooltipProps, tooltipProviderProps, tooltipTriggerProps };

@oku-ui/tooltip - npm Package Compare versions

New alerts

Improved metrics

Worsened metrics

Dependency changes