v-float 0.9.1 → 0.11.0

package/dist/composables/interactions/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA"}

package/dist/composables/interactions/navigation-strategies.d.ts

@@ -1,36 +0,0 @@
-export type NavigationAction = {
-    type: "navigate";
-    index: number | null;
-} | {
-    type: "close";
-};
-export interface StrategyContext {
-    current: number | null;
-    items: Array<HTMLElement | null>;
-    isRtl: boolean;
-    loop: boolean;
-    allowEscape: boolean;
-    isVirtual: boolean;
-    cols: number;
-    nested: boolean;
-    isDisabled: (index: number) => boolean;
-    findNextEnabled: (start: number, dir: 1 | -1, wrap: boolean) => number | null;
-    getFirstEnabledIndex: () => number | null;
-    getLastEnabledIndex: () => number | null;
-}
-export interface NavigationStrategy {
-    handleKey(key: string, context: StrategyContext): NavigationAction | null;
-}
-export declare class VerticalNavigationStrategy implements NavigationStrategy {
-    handleKey(key: string, context: StrategyContext): NavigationAction | null;
-}
-export declare class HorizontalNavigationStrategy implements NavigationStrategy {
-    handleKey(key: string, context: StrategyContext): NavigationAction | null;
-}
-export declare class GridNavigationStrategy implements NavigationStrategy {
-    private fallbackToLinear;
-    private loopDirection;
-    constructor(fallbackToLinear?: boolean, loopDirection?: "row" | "next");
-    handleKey(key: string, context: StrategyContext): NavigationAction | null;
-}
-//# sourceMappingURL=navigation-strategies.d.ts.map

package/dist/composables/interactions/navigation-strategies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"navigation-strategies.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/navigation-strategies.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAA;AAE7F,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,EAAE,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAChC,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,OAAO,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;IACtC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAA;IAC7E,oBAAoB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACzC,mBAAmB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,gBAAgB,GAAG,IAAI,CAAA;CAC1E;AAkCD,qBAAa,0BAA2B,YAAW,kBAAkB;IACnE,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,gBAAgB,GAAG,IAAI;CAa1E;AAED,qBAAa,4BAA6B,YAAW,kBAAkB;IACrE,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,gBAAgB,GAAG,IAAI;CAY1E;AAED,qBAAa,sBAAuB,YAAW,kBAAkB;IAE7D,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,aAAa;gBADb,gBAAgB,GAAE,OAAe,EACjC,aAAa,GAAE,KAAK,GAAG,MAAc;IAG/C,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,gBAAgB,GAAG,IAAI;CA8K1E"}

package/dist/composables/interactions/polygon.d.ts

@@ -1,38 +0,0 @@
-import { TreeNode } from '../positioning/use-floating-tree';
-import { AnchorElement, FloatingContext, FloatingElement } from '../positioning/use-floating';
-type Point = [number, number];
-type Polygon = Point[];
-export interface SafePolygonOptions {
-    buffer?: number;
-    blockPointerEvents?: boolean;
-    requireIntent?: boolean;
-    onPolygonChange?: (polygon: Polygon) => void;
-}
-export interface CreateSafePolygonHandlerContext {
-    x: number;
-    y: number;
-    placement: FloatingContext["placement"]["value"];
-    elements: {
-        domReference: AnchorElement | null;
-        floating: FloatingElement | null;
-    };
-    buffer: number;
-    onClose: () => void;
-    nodeId?: string;
-    tree?: {
-        nodes: Map<string, TreeNode<FloatingContext>>;
-    };
-}
-/**
- * Generates a safe polygon area that the user can traverse without closing the
- * floating element once leaving the reference element.
- * @see https://floating-ui.com/docs/useHover#safepolygon
- */
-export declare function safePolygon(options?: SafePolygonOptions): {
-    (context: CreateSafePolygonHandlerContext): (event: MouseEvent) => void;
-    __options: {
-        blockPointerEvents: boolean;
-    };
-};
-export {};
-//# sourceMappingURL=polygon.d.ts.map

package/dist/composables/interactions/polygon.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/polygon.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAA;AAE3E,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAGlG,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC7B,KAAK,OAAO,GAAG,KAAK,EAAE,CAAA;AAoDtB,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CAC7C;AAED,MAAM,WAAW,+BAA+B;IAC9C,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,SAAS,EAAE,eAAe,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAA;IAChD,QAAQ,EAAE;QACR,YAAY,EAAE,aAAa,GAAG,IAAI,CAAA;QAClC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAA;KACjC,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAA;KAAE,CAAA;CACzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB;cAsCJ,+BAA+B,WAehD,UAAU;;;;EAiVhD"}

package/dist/composables/interactions/use-click.d.ts

@@ -1,120 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { FloatingContext } from '../positioning/use-floating';
-import { TreeNode } from '../positioning/use-floating-tree';
-/**
- * Enables showing/hiding the floating element when clicking the reference element
- * and optionally when clicking outside both the reference and floating elements.
- *
- * This composable provides unified event handlers for both inside click interactions
- * (to open/toggle floating elements) and outside click interactions (to close them).
- *
- * The composable supports both standalone usage with FloatingContext and tree-aware
- * usage with TreeNode<FloatingContext> for complex nested floating UI structures.
- *
- * @param context - The floating context or tree node with open state and change handler.
- * @param options - Configuration options for click behavior.
- *
- * @example Basic standalone usage with outside click enabled
- * ```ts
- * const context = useFloating(...)
- * useClick(context, {
- *   toggle: true,
- *   outsideClick: true,
- *   outsideEvent: 'pointerdown'
- * })
- * ```
- *
- * @example Tree-aware usage for nested floating elements
- * ```ts
- * const tree = useFloatingTree(rootContext)
- * const parentNode = tree.root
- * const childNode = tree.addNode(childContext, parentNode.id)
- *
- * // Tree-aware behavior: child won't close when clicked,
- * // but will close when parent or outside is clicked
- * useClick(childNode, { outsideClick: true })
- * ```
- *
- * @example Custom outside click handler
- * ```ts
- * useClick(context, {
- *   outsideClick: true,
- *   onOutsideClick: (event, context) => {
- *     if (confirm('Close dialog?')) {
- *       context.setOpen(false)
- *     }
- *   }
- * })
- * ```
- */
-export declare function useClick(context: FloatingContext | TreeNode<FloatingContext>, options?: UseClickOptions): void;
-/**
- * Options for configuring the useClick behavior.
- */
-export interface UseClickOptions {
-    /**
-     * Whether the Hook is enabled.
-     * @default true
-     */
-    enabled?: MaybeRefOrGetter<boolean>;
-    /**
-     * The type of event to use to determine a "click" with mouse input.
-     * Keyboard clicks work as normal.
-     * @default 'click'
-     */
-    event?: MaybeRefOrGetter<"click" | "mousedown">;
-    /**
-     * Whether to toggle the open state with repeated clicks.
-     * @default true
-     */
-    toggle?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to ignore the logic for mouse input.
-     * @default false
-     */
-    ignoreMouse?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to ignore keyboard handlers (Enter and Space key functionality).
-     * @default false
-     */
-    ignoreKeyboard?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to ignore touch events.
-     * @default false
-     */
-    ignoreTouch?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to enable outside click detection to close the floating element.
-     * @default false
-     */
-    outsideClick?: MaybeRefOrGetter<boolean>;
-    /**
-     * The event to use for outside click detection.
-     * @default 'pointerdown'
-     */
-    outsideEvent?: MaybeRefOrGetter<"pointerdown" | "mousedown" | "click">;
-    /**
-     * Whether to use capture phase for document outside click listener.
-     * @default true
-     */
-    outsideCapture?: MaybeRefOrGetter<boolean>;
-    /**
-     * Custom function to handle outside clicks.
-     * If provided, this function will be called instead of the default behavior.
-     * The function receives the event and context as parameters.
-     * @param event - The mouse event that triggered the outside click
-     * @param context - The floating context containing refs and state
-     */
-    onOutsideClick?: (event: MouseEvent, context: FloatingContext) => void;
-    /**
-     * Whether to prevent clicks on scrollbars from triggering outside click.
-     * @default true
-     */
-    preventScrollbarClick?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to handle drag events that start inside and end outside.
-     * @default true
-     */
-    handleDragEvents?: MaybeRefOrGetter<boolean>;
-}
-//# sourceMappingURL=use-click.d.ts.map

package/dist/composables/interactions/use-click.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-click.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/use-click.ts"],"names":[],"mappings":"AAEE,OAAO,EAAY,KAAK,gBAAgB,EAA8C,MAAM,KAAK,CAAA;AACjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAA;AAkB7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC,EACpD,OAAO,GAAE,eAAoB,GAC5B,IAAI,CAoQN;AA0CD;;GAEG;AACH,MAAM,WAAW,eAAe;IAG9B;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEnC;;;;OAIG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,GAAG,WAAW,CAAC,CAAA;IAE/C;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAElC;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEvC;;;OAGG;IACH,cAAc,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE1C;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAIvC;;;OAGG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAExC;;;OAGG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC,aAAa,GAAG,WAAW,GAAG,OAAO,CAAC,CAAA;IAEtE;;;OAGG;IACH,cAAc,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE1C;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;IAEtE;;;OAGG;IACH,qBAAqB,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEjD;;;OAGG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;CAC7C"}

package/dist/composables/interactions/use-escape-key.d.ts

@@ -1,57 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { FloatingContext } from '../positioning/use-floating';
-import { TreeNode } from '../positioning/use-floating-tree';
-export interface UseEscapeKeyOptions {
-    /**
-     * Condition to enable the escape key listener.
-     * @default true
-     */
-    enabled?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to use capture phase for document event listeners.
-     * @default false
-     */
-    capture?: boolean;
-    /**
-     * Custom callback function to be executed when the escape key is pressed.
-     * When provided, overrides default behavior.
-     */
-    onEscape?: (event: KeyboardEvent) => void;
-}
-/**
- * A composable to handle the escape key press with tree-aware behavior and composition event handling.
- *
- * When passed a FloatingContext, it will close that floating element by setting open to false.
- * When passed a TreeNode<FloatingContext>, it will find and close the topmost open node in the tree.
- *
- * @param context - The floating context or tree node with open state and change handler.
- * @param options - {@link UseEscapeKeyOptions}
- *
- * @example Basic standalone usage
- * ```ts
- * const context = useFloating(...)
- * useEscapeKey(context) // Closes the floating element on escape
- * ```
- *
- * @example Tree-aware usage
- * ```ts
- * const tree = useFloatingTree(...)
- * const childNode = tree.addNode(...)
- * useEscapeKey(childNode) // Closes the topmost open node in the tree
- * ```
- *
- * @example Custom handler
- * ```ts
- * useEscapeKey(context, {
- *   onEscape: (event) => {
- *     if (hasUnsavedChanges.value) {
- *       showConfirmDialog.value = true
- *     } else {
- *       context.setOpen(false)
- *     }
- *   }
- * })
- * ```
- */
-export declare function useEscapeKey(context: FloatingContext | TreeNode<FloatingContext>, options?: UseEscapeKeyOptions): void;
-//# sourceMappingURL=use-escape-key.d.ts.map

package/dist/composables/interactions/use-escape-key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-escape-key.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/use-escape-key.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,KAAK,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAA;AAO3E,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEnC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;CAC1C;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC,EACpD,OAAO,GAAE,mBAAwB,GAChC,IAAI,CAiCN"}

package/dist/composables/interactions/use-focus-trap.d.ts

@@ -1,41 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { FloatingContext } from '../positioning/use-floating';
-import { TreeNode } from '../positioning/use-floating-tree';
-export interface UseFocusTrapOptions {
-    /** Enables the focus trap when true. @default true */
-    enabled?: MaybeRefOrGetter<boolean>;
-    /** When true, hides/inerts content outside the trap. @default false */
-    modal?: MaybeRefOrGetter<boolean>;
-    /** When true, inserts hidden focus guards to aid wrap-around. @default true */
-    guards?: MaybeRefOrGetter<boolean>;
-    /** Wrap order preference when cycling with Tab. @default ['content'] */
-    order?: MaybeRefOrGetter<Array<"content" | "reference" | "floating">>;
-    /** Initial focus target policy on activation. @default 'first' */
-    initialFocus?: MaybeRefOrGetter<number | HTMLElement | (() => HTMLElement | null) | "first" | "last">;
-    /** Returns focus to previously focused element on deactivate. @default true */
-    returnFocus?: MaybeRefOrGetter<boolean>;
-    /** Restores focus to nearest tabbable if active node disappears. @default false */
-    restoreFocus?: MaybeRefOrGetter<boolean>;
-    /** On non-modal, close when focus escapes the trap. @default false */
-    closeOnFocusOut?: MaybeRefOrGetter<boolean>;
-    /** Pass preventScroll to focus operations. @default true */
-    preventScroll?: MaybeRefOrGetter<boolean>;
-    /** Apply `inert` (when supported) to outside elements while modal. @default false */
-    outsideElementsInert?: MaybeRefOrGetter<boolean>;
-}
-export interface UseFocusTrapReturn {
-    cleanup: () => void;
-}
-/**
- * Traps keyboard focus within the floating element, optionally in a modal manner.
- *
- * Supports nested traps; only the deepest open node activates trapping when used with a tree.
- * Provides optional focus guards, initial focus, focus return, and close-on-escape behavior.
- *
- * @param context - FloatingContext or TreeNode<FloatingContext> to trap within
- * @param options - Configuration options controlling trap behavior
- * @returns Cleanup API
- */
-export declare function useFocusTrap(context: FloatingContext | TreeNode<FloatingContext>, options?: UseFocusTrapOptions): UseFocusTrapReturn;
-export type { FloatingContext };
-//# sourceMappingURL=use-focus-trap.d.ts.map

package/dist/composables/interactions/use-focus-trap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-focus-trap.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/use-focus-trap.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,gBAAgB,EAOtB,MAAM,KAAK,CAAA;AACZ,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAA;AAY3E,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACnC,uEAAuE;IACvE,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACjC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAClC,wEAAwE;IACxE,KAAK,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC,CAAC,CAAA;IACrE,kEAAkE;IAClE,YAAY,CAAC,EAAE,gBAAgB,CAC7B,MAAM,GAAG,WAAW,GAAG,CAAC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,OAAO,GAAG,MAAM,CACrE,CAAA;IACD,+EAA+E;IAC/E,WAAW,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACvC,mFAAmF;IACnF,YAAY,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACxC,sEAAsE;IACtE,eAAe,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAC3C,4DAA4D;IAC5D,aAAa,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACzC,qFAAqF;IACrF,oBAAoB,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAMD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC,EACpD,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CA+cpB;AAMD,YAAY,EAAE,eAAe,EAAE,CAAA"}

package/dist/composables/interactions/use-focus.d.ts

@@ -1,60 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { FloatingContext } from '../positioning/use-floating';
-import { Tree } from '../positioning/use-floating-tree';
-/**
- * Enables showing/hiding the floating element when the reference element receives or loses focus.
- *
- * Keyboard-only interaction hook. Compose with `useClick`, `useHover`, `useEscapeKey` for a complete UX.
- *
- * Tree-aware behavior is enabled by providing a `tree` option and passing the corresponding
- * FloatingContext (i.e., the node's `.data`). IDs are only relevant for tree-aware usage and are
- * automatically assigned when using `useFloatingTree().addNode(...)`.
- *
- * @param context - The floating context for this element (not a TreeNode).
- * @param options - Configuration options. Provide `tree` to enable tree-aware behavior.
- *
- * @example Standalone
- * ```ts
- * const ctx = useFloating(...)
- * useFocus(ctx)
- * ```
- *
- * @example Tree-aware
- * ```ts
- * const tree = useFloatingTree(rootAnchor, rootFloating)
- * const parent = tree.root
- * const child = tree.addNode(childAnchor, childFloating, { parentId: parent.id })
- *
- * useFocus(parent.data, { tree })
- * useFocus(child.data, { tree })
- * ```
- */
-export declare function useFocus(context: FloatingContext, options?: UseFocusOptions): UseFocusReturn;
-export interface UseFocusOptions {
-    /**
-     * Whether focus event listeners are enabled
-     * @default true
-     */
-    enabled?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether the open state only changes if the focus event is considered
-     * visible (`:focus-visible` CSS selector).
-     * @default true
-     */
-    requireFocusVisible?: MaybeRefOrGetter<boolean>;
-    /**
-     * When provided, enables tree-aware focus handling.
-     */
-    tree?: Tree<FloatingContext>;
-}
-/**
- * Return value of the useFocus composable
- */
-export interface UseFocusReturn {
-    /**
-     * Cleanup function that removes all event listeners and clears pending timeouts.
-     * Useful for manual cleanup in testing scenarios.
-     */
-    cleanup: () => void;
-}
-//# sourceMappingURL=use-focus.d.ts.map

package/dist/composables/interactions/use-focus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-focus.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/use-focus.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,gBAAgB,EAOtB,MAAM,KAAK,CAAA;AACZ,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,IAAI,EAAY,MAAM,6CAA6C,CAAA;AAmBjF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,EACxB,OAAO,GAAE,eAAoB,GAC5B,cAAc,CAsMhB;AAMD,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEnC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE/C;;OAEG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB"}

package/dist/composables/interactions/use-hover.d.ts

@@ -1,78 +0,0 @@
-import { MaybeRef } from 'vue';
-import { TreeNode } from '../positioning/use-floating-tree';
-import { FloatingContext } from '../positioning/use-floating';
-import { SafePolygonOptions } from './polygon';
-export interface UseHoverOptions {
-    /**
-     * Whether hover event listeners are enabled.
-     * @default true
-     */
-    enabled?: MaybeRef<boolean>;
-    /**
-     * Delay in milliseconds before showing/hiding the floating element.
-     * Can be a single number for both open and close, or an object
-     * specifying different delays.
-     * @default 0
-     */
-    delay?: MaybeRef<number | {
-        open?: number;
-        close?: number;
-    }>;
-    /**
-     * Time in milliseconds the pointer must rest within the reference
-     * element before opening the floating element.
-     * this option is ignored if an open delay is specified.
-     * @default 0
-     */
-    restMs?: MaybeRef<number>;
-    /**
-     * Whether hover events should only trigger for mouse like pointers (mouse, pen ,stylus ..etc).
-     * @default false
-     */
-    mouseOnly?: MaybeRef<boolean>;
-    /**
-     * Enable floating-ui style safe polygon algorithm that keeps the
-     * floating element open while the pointer traverses the rectangle/triangle
-     * region between the reference and floating elements.
-     * – `true` → enabled with defaults
-     * – `false | undefined` → disabled (current behaviour)
-     * – `SafePolygonOptions` → enabled with custom buffer
-     */
-    safePolygon?: MaybeRef<boolean | SafePolygonOptions>;
-}
-/**
- * Enables showing/hiding the floating element when hovering the reference element
- * with enhanced behaviors like delayed open/close, rest detection, and custom
- * exit handling.
- *
- * The composable supports both standalone usage with FloatingContext and tree-aware
- * usage with TreeNode<FloatingContext> for complex nested floating UI structures.
- *
- * @param context - The floating context or tree node with open state and change handler
- * @param options - Configuration options for hover behavior
- *
- * @example Basic standalone usage
- * ```ts
- * const context = useFloating(...)
- * useHover(context, {
- *   delay: { open: 100, close: 300 },
- *   restMs: 150
- * })
- * ```
- *
- * @example Tree-aware usage for nested floating elements
- * ```ts
- * const tree = useFloatingTree(rootContext)
- * const parentNode = tree.root
- * const childNode = tree.addNode(childContext, parentNode.id)
- *
- * // Tree-aware behavior: child hover won't end when hovering over child,
- * // but will end when hovering outside the entire hierarchy
- * useHover(childNode, {
- *   delay: { close: 300 },
- *   safePolygon: true
- * })
- * ```
- */
-export declare function useHover(context: FloatingContext | TreeNode<FloatingContext>, options?: UseHoverOptions): void;
-//# sourceMappingURL=use-hover.d.ts.map

package/dist/composables/interactions/use-hover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-hover.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/use-hover.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,QAAQ,EAKd,MAAM,KAAK,CAAA;AACZ,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAA;AAE3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAClE,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,WAAW,CAAA;AAWhE,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;IAE3B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAE5D;;;;;OAKG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IAEzB;;;OAGG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;IAE7B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,QAAQ,CAAC,OAAO,GAAG,kBAAkB,CAAC,CAAA;CACrD;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC,EACpD,OAAO,GAAE,eAAoB,GAC5B,IAAI,CA8ON"}

package/dist/composables/interactions/use-list-navigation.d.ts

@@ -1,109 +0,0 @@
-import { MaybeRefOrGetter, Ref } from 'vue';
-import { FloatingContext } from '../positioning/use-floating';
-import { TreeNode } from '../positioning/use-floating-tree';
-/**
- * Options for configuring list-style keyboard/mouse navigation behavior.
- *
- * This interface drives how items in a floating list/grid are navigated,
- * focused, and announced (including support for virtual focus).
- */
-export interface UseListNavigationOptions {
-    /**
-     * Reactive collection of list item elements in DOM order.
-     * Null entries are allowed while items mount/unmount.
-     */
-    listRef: Ref<Array<HTMLElement | null>>;
-    /**
-     * The currently active (navigated) index. Null means no active item.
-     */
-    activeIndex?: MaybeRefOrGetter<number | null>;
-    /**
-     * Callback invoked when navigation sets a new active index.
-     */
-    onNavigate?: (index: number | null) => void;
-    /**
-     * Whether navigation behavior is enabled.
-     */
-    enabled?: MaybeRefOrGetter<boolean>;
-    /**
-     * If true, arrow-key navigation wraps from end-to-start and vice versa.
-     */
-    loop?: MaybeRefOrGetter<boolean>;
-    /**
-     * Primary navigation orientation.
-     * - "vertical": Up/Down to navigate
-     * - "horizontal": Left/Right to navigate
-     * - "both": Grid navigation (supports cols/itemSizes)
-     */
-    orientation?: MaybeRefOrGetter<"vertical" | "horizontal" | "both">;
-    /**
-     * Indices that should be treated as disabled and skipped by navigation.
-     * Can be an array of indices or a predicate.
-     */
-    disabledIndices?: Array<number> | ((index: number) => boolean);
-    /**
-     * If true, hovering an item moves the active index to that item.
-     */
-    focusItemOnHover?: MaybeRefOrGetter<boolean>;
-    /**
-     * If true, pressing an arrow key when closed opens and moves focus.
-     */
-    openOnArrowKeyDown?: MaybeRefOrGetter<boolean>;
-    /**
-     * Controls automatic scrolling when the active item changes.
-     * true for default "nearest" behavior or a custom ScrollIntoViewOptions.
-     */
-    scrollItemIntoView?: boolean | ScrollIntoViewOptions;
-    /**
-     * Index to prefer when opening (e.g., currently selected option).
-     */
-    selectedIndex?: MaybeRefOrGetter<number | null>;
-    /**
-     * Controls focusing an item when the list opens.
-     * - true: always focus an item
-     * - false: never focus an item
-     * - "auto": focus based on input modality/heuristics
-     */
-    focusItemOnOpen?: MaybeRefOrGetter<boolean | "auto">;
-    /**
-     * Whether this list is nested inside another navigable list.
-     * Affects cross-orientation close/open key handling.
-     */
-    nested?: MaybeRefOrGetter<boolean>;
-    /**
-     * Parent list orientation when nested, for cross-navigation behavior.
-     */
-    parentOrientation?: MaybeRefOrGetter<"vertical" | "horizontal" | "both">;
-    /**
-     * Right-to-left layout flag affecting horizontal arrow semantics.
-     */
-    rtl?: MaybeRefOrGetter<boolean>;
-    /**
-     * Enables virtual focus mode (aria-activedescendant) instead of DOM focus.
-     */
-    virtual?: MaybeRefOrGetter<boolean>;
-    /**
-     * Receives the HTMLElement corresponding to the virtual active item.
-     * Used for aria-activedescendant and screen reader announcement.
-     */
-    virtualItemRef?: Ref<HTMLElement | null>;
-    /**
-     * Column count for grid navigation when orientation is "both".
-     */
-    cols?: MaybeRefOrGetter<number>;
-    /**
-     * If true, allows escaping to a null active index via keyboard (e.g., ArrowDown on last).
-     */
-    allowEscape?: MaybeRefOrGetter<boolean>;
-    /**
-     * Defines the wrapping behavior for grid navigation when moving horizontally past the end of a row.
-     * - "row": Wraps to the start of the *same* row (default).
-     * - "next": Moves to the start of the *next* row (or previous row if moving left).
-     */
-    gridLoopDirection?: MaybeRefOrGetter<"row" | "next">;
-}
-export interface UseListNavigationReturn {
-    cleanup: () => void;
-}
-export declare function useListNavigation(context: FloatingContext | TreeNode<FloatingContext>, options: UseListNavigationOptions): UseListNavigationReturn;
-//# sourceMappingURL=use-list-navigation.d.ts.map

package/dist/composables/interactions/use-list-navigation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-list-navigation.d.ts","sourceRoot":"","sources":["../../../src/composables/interactions/use-list-navigation.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,GAAG,EAKT,MAAM,KAAK,CAAA;AACZ,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAA;AAY3E;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAA;IAEvC;;OAEG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAE7C;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAE3C;;OAEG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEnC;;OAEG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEhC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,UAAU,GAAG,YAAY,GAAG,MAAM,CAAC,CAAA;IAElE;;;OAGG;IACH,eAAe,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAA;IAE9D;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE5C;;OAEG;IACH,kBAAkB,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE9C;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAA;IAEpD;;OAEG;IACH,aAAa,CAAC,EAAE,gBAAgB,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAE/C;;;;;OAKG;IACH,eAAe,CAAC,EAAE,gBAAgB,CAAC,OAAO,GAAG,MAAM,CAAC,CAAA;IAEpD;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAElC;;OAEG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,CAAC,UAAU,GAAG,YAAY,GAAG,MAAM,CAAC,CAAA;IAExE;;OAEG;IACH,GAAG,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE/B;;OAEG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEnC;;;OAGG;IACH,cAAc,CAAC,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAExC;;OAEG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAE/B;;OAEG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAEvC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,CAAC,KAAK,GAAG,MAAM,CAAC,CAAA;CACrD;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC,EACpD,OAAO,EAAE,wBAAwB,GAChC,uBAAuB,CA+VzB"}

package/dist/composables/middlewares/arrow.d.ts

@@ -1,25 +0,0 @@
-import { Middleware, Padding } from '@floating-ui/dom';
-import { Ref } from 'vue';
-/**
- * Options for configuring arrow positioning within floating elements
- */
-export interface ArrowMiddlewareOptions {
-    /**
-     * Padding to apply around the arrow element
-     */
-    padding?: Padding;
-    /**
-     * Reference to the arrow element
-     */
-    element: Ref<HTMLElement | null>;
-}
-/**
- * Positions an inner element of the floating element such that it is centered to the anchor element.
- *
- * This middleware is used to position arrow elements within floating elements.
- *
- * @param options - The arrow options including padding and element reference
- * @returns A middleware function for arrow positioning
- */
-export declare function arrow(options: ArrowMiddlewareOptions): Middleware;
-//# sourceMappingURL=arrow.d.ts.map

package/dist/composables/middlewares/arrow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../../../src/composables/middlewares/arrow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE3D,OAAO,EAAE,KAAK,GAAG,EAAW,MAAM,KAAK,CAAA;AAMvC;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;OAEG;IACH,OAAO,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CACjC;AAMD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,sBAAsB,GAAG,UAAU,CAcjE"}

package/dist/composables/middlewares/index.d.ts

@@ -1,4 +0,0 @@
-export type { Middleware, Placement, Strategy } from '@floating-ui/dom';
-export { autoPlacement, flip, hide, offset, shift, size } from '@floating-ui/dom';
-export { arrow } from './arrow';
-//# sourceMappingURL=index.d.ts.map

package/dist/composables/middlewares/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/middlewares/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACjF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA"}

package/dist/composables/positioning/index.d.ts

@@ -1,5 +0,0 @@
-export * from './use-arrow';
-export * from './use-client-point';
-export * from './use-floating';
-export * from './use-floating-tree';
-//# sourceMappingURL=index.d.ts.map

package/dist/composables/positioning/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composables/positioning/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA"}