bits-ui/dist/bits/tooltip/tooltip.svelte.d.ts

The headless components for Svelte.

import { DOMContext, type WritableBoxedValues, type ReadableBoxedValues } from "svelte-toolbelt";
import type { OnChangeFn, RefAttachment, WithRefOpts } from "../../internal/types.js";
import type { FocusEventHandler, MouseEventHandler, PointerEventHandler } from "svelte/elements";
export declare const tooltipAttrs: import("../../internal/attrs.js").CreateBitsAttrsReturn<readonly ["content", "trigger"]>;
interface TooltipProviderStateOpts extends ReadableBoxedValues<{
    delayDuration: number;
    disableHoverableContent: boolean;
    disableCloseOnTriggerClick: boolean;
    disabled: boolean;
    ignoreNonKeyboardFocus: boolean;
    skipDelayDuration: number;
}> {
}
export declare class TooltipProviderState {
    #private;
    static create(opts: TooltipProviderStateOpts): TooltipProviderState;
    readonly opts: TooltipProviderStateOpts;
    isOpenDelayed: boolean;
    isPointerInTransit: import("svelte-toolbelt").WritableBox<boolean>;
    constructor(opts: TooltipProviderStateOpts);
    onOpen: (tooltip: TooltipRootState) => void;
    onClose: (tooltip: TooltipRootState) => void;
    isTooltipOpen: (tooltip: TooltipRootState) => boolean;
}
interface TooltipRootStateOpts extends ReadableBoxedValues<{
    delayDuration: number | undefined;
    disableHoverableContent: boolean | undefined;
    disableCloseOnTriggerClick: boolean | undefined;
    disabled: boolean | undefined;
    ignoreNonKeyboardFocus: boolean | undefined;
    onOpenChangeComplete: OnChangeFn<boolean>;
}>, WritableBoxedValues<{
    open: boolean;
}> {
}
export declare class TooltipRootState {
    #private;
    static create(opts: TooltipRootStateOpts): TooltipRootState;
    readonly opts: TooltipRootStateOpts;
    readonly provider: TooltipProviderState;
    readonly delayDuration: number;
    readonly disableHoverableContent: boolean;
    readonly disableCloseOnTriggerClick: boolean;
    readonly disabled: boolean;
    readonly ignoreNonKeyboardFocus: boolean;
    contentNode: HTMLElement | null;
    triggerNode: HTMLElement | null;
    readonly stateAttr: string;
    constructor(opts: TooltipRootStateOpts, provider: TooltipProviderState);
    handleOpen: () => void;
    handleClose: () => void;
    onTriggerEnter: () => void;
    onTriggerLeave: () => void;
}
interface TooltipTriggerStateOpts extends WithRefOpts, ReadableBoxedValues<{
    disabled: boolean;
}> {
}
export declare class TooltipTriggerState {
    #private;
    static create(opts: TooltipTriggerStateOpts): TooltipTriggerState;
    readonly opts: TooltipTriggerStateOpts;
    readonly root: TooltipRootState;
    readonly attachment: RefAttachment;
    domContext: DOMContext;
    constructor(opts: TooltipTriggerStateOpts, root: TooltipRootState);
    handlePointerUp: () => void;
    readonly props: {
        readonly id: string;
        readonly "aria-describedby": string | undefined;
        readonly "data-state": "closed" | "delayed-open" | "instant-open";
        readonly "data-disabled": "" | undefined;
        readonly "data-delay-duration": `${number}`;
        readonly tabindex: 0 | undefined;
        readonly disabled: boolean;
        readonly onpointerup: PointerEventHandler<HTMLElement>;
        readonly onpointerdown: PointerEventHandler<HTMLElement>;
        readonly onpointermove: PointerEventHandler<HTMLElement>;
        readonly onpointerleave: PointerEventHandler<HTMLElement>;
        readonly onfocus: FocusEventHandler<HTMLElement>;
        readonly onblur: FocusEventHandler<HTMLElement>;
        readonly onclick: MouseEventHandler<HTMLElement>;
    };
}
interface TooltipContentStateOpts extends WithRefOpts, ReadableBoxedValues<{
    onInteractOutside: (e: PointerEvent) => void;
    onEscapeKeydown: (e: KeyboardEvent) => void;
}> {
}
export declare class TooltipContentState {
    static create(opts: TooltipContentStateOpts): TooltipContentState;
    readonly opts: TooltipContentStateOpts;
    readonly root: TooltipRootState;
    readonly attachment: RefAttachment;
    constructor(opts: TooltipContentStateOpts, root: TooltipRootState);
    onInteractOutside: (e: PointerEvent) => void;
    onEscapeKeydown: (e: KeyboardEvent) => void;
    onOpenAutoFocus: (e: Event) => void;
    onCloseAutoFocus: (e: Event) => void;
    readonly snippetProps: {
        open: boolean;
    };
    readonly props: {
        readonly id: string;
        readonly "data-state": "closed" | "delayed-open" | "instant-open";
        readonly "data-disabled": "" | undefined;
        readonly style: {
            readonly pointerEvents: "auto";
            readonly outline: "none";
        };
    };
    readonly popperProps: {
        onInteractOutside: (e: PointerEvent) => void;
        onEscapeKeydown: (e: KeyboardEvent) => void;
        onOpenAutoFocus: (e: Event) => void;
        onCloseAutoFocus: (e: Event) => void;
    };
}
export {};