v-float 0.10.0 → 0.11.0

package/dist/index.d.mts

@@ -0,0 +1,688 @@
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from "vue";
+import { AutoUpdateOptions, Middleware, Middleware as Middleware$1, MiddlewareData, Padding, Placement, Placement as Placement$1, Strategy, Strategy as Strategy$1, autoPlacement, flip, hide, offset, shift, size } from "@floating-ui/dom";
+
+//#region src/types.d.ts
+/**
+ * Minimal VirtualElement interface compatible with Floating UI expectations.
+ * Provides a bounding client rect and an optional context element for layout.
+ */
+interface VirtualElement {
+  getBoundingClientRect: () => DOMRect;
+  /**
+   * Optional context element used by Floating UI to resolve layout metrics.
+   */
+  contextElement?: Element;
+}
+/**
+ * Primary interaction reasons for open state changes. Minimal and extensible.
+ */
+type OpenChangeReason = "anchor-click" | "keyboard-activate" | "outside-pointer" | "focus" | "blur" | "hover" | "escape-key" | "programmatic";
+//#endregion
+//#region src/composables/positioning/use-floating.d.ts
+type AnchorElement = HTMLElement | VirtualElement | null;
+type FloatingElement = HTMLElement | null;
+type FloatingStyles = {
+  position: Strategy$1;
+  top: string;
+  left: string;
+  transform?: string;
+  "will-change"?: string;
+} & {
+  [key: `--${string}`]: any;
+};
+interface UseFloatingOptions {
+  placement?: MaybeRefOrGetter<Placement$1 | undefined>;
+  strategy?: MaybeRefOrGetter<Strategy$1 | undefined>;
+  transform?: MaybeRefOrGetter<boolean | undefined>;
+  middlewares?: MaybeRefOrGetter<Middleware$1[]>;
+  autoUpdate?: boolean | AutoUpdateOptions;
+  open?: Ref<boolean>;
+  onOpenChange?: (open: boolean, reason: OpenChangeReason, event?: Event) => void;
+}
+interface FloatingRefs {
+  anchorEl: Ref<AnchorElement>;
+  floatingEl: Ref<FloatingElement>;
+  arrowEl: Ref<HTMLElement | null>;
+  setAnchor: (value: AnchorElement) => void;
+  setFloating: (value: FloatingElement) => void;
+  setArrow: (value: HTMLElement | null) => void;
+}
+interface FloatingState {
+  open: Readonly<Ref<boolean>>;
+  setOpen: (open: boolean, reason?: OpenChangeReason, event?: Event) => void;
+}
+interface FloatingPosition {
+  x: Readonly<Ref<number>>;
+  y: Readonly<Ref<number>>;
+  strategy: Readonly<Ref<Strategy$1>>;
+  placement: Readonly<Ref<Placement$1>>;
+  middlewareData: Readonly<Ref<MiddlewareData>>;
+  isPositioned: Readonly<Ref<boolean>>;
+  styles: Readonly<Ref<FloatingStyles>>;
+  update: () => void;
+}
+interface FloatingRoot {
+  refs: FloatingRefs;
+  state: FloatingState;
+  position: FloatingPosition;
+}
+interface FloatingContext extends FloatingRoot {
+  /**
+   * Deprecated flat aliases kept during the grouped-return transition.
+   */
+  open: FloatingState["open"];
+  setOpen: FloatingState["setOpen"];
+  x: FloatingPosition["x"];
+  y: FloatingPosition["y"];
+  strategy: FloatingPosition["strategy"];
+  placement: FloatingPosition["placement"];
+  middlewareData: FloatingPosition["middlewareData"];
+  isPositioned: FloatingPosition["isPositioned"];
+  floatingStyles: FloatingPosition["styles"];
+  update: FloatingPosition["update"];
+}
+declare function useFloating(anchorEl: Ref<AnchorElement>, floatingEl: Ref<FloatingElement>, options?: UseFloatingOptions): FloatingContext;
+//#endregion
+//#region src/composables/interactions/use-click.d.ts
+/**
+ * Enables showing/hiding the floating element when clicking the anchor element
+ * and optionally when clicking outside both the anchor 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).
+ *
+ * @param context - The floating context with open state and change handler.
+ * @param options - Configuration options for click behavior.
+ *
+ * @example Basic usage with outside click enabled
+ * ```ts
+ * const context = useFloating(...)
+ * useClick(context, {
+ *   toggle: true,
+ *   closeOnOutsideClick: true,
+ *   outsideClickEvent: 'pointerdown'
+ * })
+ * ```
+ *
+ * @example Custom outside click handler
+ * ```ts
+ * useClick(context, {
+ *   closeOnOutsideClick: true,
+ *   onOutsideClick: (event) => {
+ *     if (confirm("Close dialog?")) {
+ *       context.setOpen(false)
+ *     }
+ *   },
+ * })
+ * ```
+ */
+declare function useClick(context: UseClickContext, options?: UseClickOptions): void;
+interface UseClickContext {
+  refs: FloatingContext["refs"];
+  state?: FloatingContext["state"];
+  open?: FloatingContext["open"];
+  setOpen?: FloatingContext["setOpen"];
+}
+/**
+ * Options for configuring the useClick behavior.
+ */
+interface UseClickOptions {
+  /**
+   * Whether the composable is enabled.
+   * @default true
+   */
+  enabled?: MaybeRefOrGetter<boolean>;
+  /**
+   * The type of event to use to determine a "click" with mouse input.
+   * This option does not effect keyboard interactions.
+   * @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 close the floating element when clicking outside.
+   * @default false
+   */
+  closeOnOutsideClick?: MaybeRefOrGetter<boolean>;
+  /**
+   * The event to use for outside click detection.
+   * @default 'pointerdown'
+   */
+  outsideClickEvent?: 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.
+   * @param event - The mouse event that triggered the outside click
+   */
+  onOutsideClick?: (event: MouseEvent) => void;
+  /**
+   * Whether to ignore clicks on scrollbars (prevent them from closing the floating element).
+   * @default true
+   */
+  ignoreScrollbar?: MaybeRefOrGetter<boolean>;
+  /**
+   * Whether to ignore outside clicks that are part of a drag sequence
+   * (where the drag started inside the floating element and ended outside).
+   * @default true
+   */
+  ignoreDrag?: MaybeRefOrGetter<boolean>;
+}
+//#endregion
+//#region src/composables/positioning/use-arrow.d.ts
+interface UseArrowReturn {
+  arrowX: ComputedRef<number>;
+  arrowY: ComputedRef<number>;
+  arrowStyles: ComputedRef<Record<string, string>>;
+}
+interface UseArrowOptions {
+  element?: Ref<HTMLElement | null>;
+  offset?: string;
+}
+declare function useArrow(context: FloatingContext, options: UseArrowOptions & {
+  element: Ref<HTMLElement | null>;
+}): UseArrowReturn;
+declare function useArrow(arrowEl: Ref<HTMLElement | null>, context: FloatingContext, options?: Omit<UseArrowOptions, "element">): UseArrowReturn;
+//#endregion
+//#region src/composables/positioning/client-point/types.d.ts
+interface Coordinates {
+  x: number | null;
+  y: number | null;
+}
+type AxisConstraint = "x" | "y" | "both";
+type TrackingMode = "follow" | "static";
+interface PointerEventData {
+  type: "pointerdown" | "pointermove" | "pointerenter";
+  coordinates: Coordinates;
+  originalEvent: PointerEvent;
+}
+interface TrackingContext {
+  isOpen: boolean;
+}
+interface VirtualElementFactoryOptions {
+  coordinates: Coordinates;
+  referenceElement?: HTMLElement | null;
+  baselineCoordinates?: Coordinates | null;
+  axis?: AxisConstraint;
+}
+interface VirtualElementFactoryContract {
+  create(options: VirtualElementFactoryOptions): VirtualElement;
+}
+//#endregion
+//#region src/composables/positioning/client-point/tracking-strategies.d.ts
+declare abstract class TrackingStrategy {
+  abstract readonly name: TrackingMode;
+  protected lastKnownCoordinates: Coordinates | null;
+  abstract process(event: PointerEventData, context: TrackingContext): Coordinates | null;
+  abstract getRequiredEvents(): PointerEventData["type"][];
+  getCoordinatesForOpening(): Coordinates | null;
+  onClose(): void;
+  reset(): void;
+}
+declare class FollowTracker extends TrackingStrategy {
+  readonly name: "follow";
+  getRequiredEvents(): PointerEventData["type"][];
+  process(event: PointerEventData, context: TrackingContext): Coordinates | null;
+}
+declare class StaticTracker extends TrackingStrategy {
+  readonly name: "static";
+  private triggerCoordinates;
+  getRequiredEvents(): PointerEventData["type"][];
+  process(event: PointerEventData, context: TrackingContext): Coordinates | null;
+  getCoordinatesForOpening(): Coordinates | null;
+  reset(): void;
+  onClose(): void;
+}
+//#endregion
+//#region src/composables/positioning/client-point/virtual-element-factory.d.ts
+declare class VirtualElementFactory implements VirtualElementFactoryContract {
+  private static readonly DEFAULT_DIMENSIONS;
+  create(options: VirtualElementFactoryOptions): VirtualElement;
+  private buildConfiguration;
+  private buildBoundingRect;
+  private getReferenceRect;
+  private resolvePosition;
+  private resolveAxisCoordinate;
+  private calculateSize;
+  private buildDOMRect;
+}
+//#endregion
+//#region src/composables/positioning/use-client-point.d.ts
+interface UseClientPointOptions {
+  pointerTarget?: Ref<HTMLElement | null>;
+  enabled?: MaybeRefOrGetter<boolean>;
+  axis?: MaybeRefOrGetter<AxisConstraint>;
+  x?: MaybeRefOrGetter<number | null>;
+  y?: MaybeRefOrGetter<number | null>;
+  trackingMode?: TrackingMode;
+}
+interface UseClientPointReturn {
+  coordinates: Readonly<Ref<{
+    x: number | null;
+    y: number | null;
+  }>>;
+  updatePosition: (x: number, y: number) => void;
+}
+interface UseClientPointContext {
+  refs: {
+    anchorEl: Ref<AnchorElement>;
+  };
+  state?: FloatingContext["state"];
+  open?: FloatingContext["open"];
+  setOpen?: FloatingContext["setOpen"];
+  position?: Pick<FloatingContext["position"], "update">;
+  update?: () => void;
+}
+declare function useClientPoint(context: UseClientPointContext, options?: UseClientPointOptions): UseClientPointReturn;
+declare function useClientPoint(pointerTarget: Ref<HTMLElement | null>, context: UseClientPointContext, options?: Omit<UseClientPointOptions, "pointerTarget">): UseClientPointReturn;
+//#endregion
+//#region src/composables/interactions/use-escape-key.d.ts
+interface UseEscapeKeyContext {
+  state?: FloatingContext["state"];
+  open?: FloatingContext["open"];
+  setOpen?: FloatingContext["setOpen"];
+}
+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;
+  /**
+   * Whether to call preventDefault on the escape key event before handling it.
+   * @default false
+   */
+  preventDefault?: 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 composition event handling.
+ *
+ * When triggered, it will close the floating element by setting open to false.
+ *
+ * @param context - The floating context with open state and change handler.
+ * @param options - {@link UseEscapeKeyOptions}
+ *
+ * @example Basic usage
+ * ```ts
+ * const context = useFloating(...)
+ * useEscapeKey(context) // Closes the floating element on escape
+ * ```
+ *
+ * @example Custom handler
+ * ```ts
+ * useEscapeKey(context, {
+ *   onEscape: (event) => {
+ *     if (hasUnsavedChanges.value) {
+ *       showConfirmDialog.value = true
+ *     } else {
+ *       context.setOpen(false)
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function useEscapeKey(context: UseEscapeKeyContext, options?: UseEscapeKeyOptions): void;
+//#endregion
+//#region src/composables/interactions/use-focus.d.ts
+/**
+ * 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.
+ *
+ * @param context - The floating context with open state and change handler
+ * @param options - Configuration options
+ *
+ * @example
+ * ```ts
+ * const ctx = useFloating(...)
+ * useFocus(ctx)
+ * ```
+ */
+declare function useFocus(context: UseFocusContext, options?: UseFocusOptions): UseFocusReturn;
+interface UseFocusContext {
+  refs: FloatingContext["refs"];
+  state?: FloatingContext["state"];
+  open?: FloatingContext["open"];
+  setOpen?: FloatingContext["setOpen"];
+}
+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>;
+}
+/**
+ * Return value of the useFocus composable
+ */
+interface UseFocusReturn {
+  /**
+   * Cleanup function that removes all event listeners and clears pending timeouts.
+   * Useful for manual cleanup in testing scenarios.
+   */
+  cleanup: () => void;
+}
+//#endregion
+//#region src/composables/interactions/use-focus-trap.d.ts
+interface UseFocusTrapContext {
+  refs: FloatingContext["refs"];
+  state?: FloatingContext["state"];
+  open?: FloatingContext["open"];
+  setOpen?: FloatingContext["setOpen"];
+}
+interface UseFocusTrapOptions {
+  /**
+   * Determines if the focus trap should be enabled.
+   * When `true`, the focus trap is active.
+   * @default true
+   */
+  enabled?: MaybeRefOrGetter<boolean>;
+  /**
+   * When `true`, content outside the trap will be hidden from accessibility
+   * trees (via `aria-hidden`) and potentially made inert (via `inert` attribute
+   * if `outsideElementsInert` is `true` and supported).
+   * This mimics modal behavior.
+   * @default false
+   */
+  modal?: MaybeRefOrGetter<boolean>;
+  /**
+   * Specifies the element that should receive initial focus when the trap is activated.
+   * - `undefined` or omitted: Focuses the first tabbable element within the trap.
+   * - CSS selector string: Queries and focuses the first matching element.
+   * - `HTMLElement`: Focuses the specific provided HTML element.
+   * - `Function`: A function that returns an `HTMLElement` or `false`. The returned
+   *   element will receive focus.
+   * - `false`: Prevents any initial focus from being set by the trap.
+   */
+  initialFocus?: HTMLElement | (() => HTMLElement | false) | string | false;
+  /**
+   * When `true`, focus will be returned to the element that was focused
+   * immediately before the trap was activated, upon deactivation.
+   * @default true
+   */
+  returnFocus?: MaybeRefOrGetter<boolean>;
+  /**
+   * When `true` and the trap is not `modal`, the trap will deactivate (and potentially close
+   * the associated component) if focus moves outside the defined trap elements.
+   * @default false
+   */
+  closeOnFocusOut?: MaybeRefOrGetter<boolean>;
+  /**
+   * Controls whether the browser should scroll to the focused element.
+   * Passed directly to the `focus()` method's `preventScroll` option.
+   * @default true
+   */
+  preventScroll?: MaybeRefOrGetter<boolean>;
+  /**
+   * When `true` and `modal` is `true`, applies the `inert` attribute (if supported
+   * by the browser) to elements outside the focus trap to prevent user interaction
+   * and assistive technology access.
+   * @default false
+   */
+  outsideElementsInert?: MaybeRefOrGetter<boolean>;
+  /**
+   * An optional error handler function that will be called if there's an
+   * issue during the focus trap activation process.
+   * @param error - The error object.
+   */
+  onError?: (error: unknown) => void;
+}
+interface UseFocusTrapReturn {
+  /** Check if the focus trap is currently active */
+  isActive: ComputedRef<boolean>;
+  /** Manually activate the focus trap (if enabled and open) */
+  activate: () => void;
+  /** Manually deactivate the focus trap */
+  deactivate: () => void;
+}
+/**
+ * Creates a focus trap for a floating element using focus-trap library.
+ * Manages focus containment, modal behavior, and accessibility features.
+ *
+ * @param context - Floating context containing floating element refs
+ * @param options - Configuration options for the focus trap
+ * @returns Object with isActive state, and manual control methods
+ */
+declare function useFocusTrap(context: UseFocusTrapContext, options?: UseFocusTrapOptions): UseFocusTrapReturn;
+//#endregion
+//#region src/composables/interactions/polygon/geometry.d.ts
+type Point = [number, number];
+type Polygon = Point[];
+//#endregion
+//#region src/composables/interactions/polygon/bridge.d.ts
+interface SafePolygonOptions {
+  buffer?: number;
+  requireIntent?: boolean;
+  onPolygonChange?: (polygon: Polygon) => void;
+}
+//#endregion
+//#region src/composables/interactions/use-hover.d.ts
+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.
+ *
+ * @param context - The floating context with open state and change handler
+ * @param options - Configuration options for hover behavior
+ *
+ * @example Basic usage
+ * ```ts
+ * const context = useFloating(...)
+ * useHover(context, {
+ *   delay: { open: 100, close: 300 },
+ *   restMs: 150
+ * })
+ * ```
+ */
+declare function useHover(context: FloatingContext, options?: UseHoverOptions): void;
+//#endregion
+//#region src/composables/interactions/use-list-navigation.d.ts
+/**
+ * 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).
+ */
+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">;
+}
+interface UseListNavigationReturn {
+  cleanup: () => void;
+}
+declare function useListNavigation(context: FloatingContext, options: UseListNavigationOptions): UseListNavigationReturn;
+//#endregion
+//#region src/composables/middlewares/arrow.d.ts
+/**
+ * Options for configuring arrow positioning within floating elements
+ */
+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
+ */
+declare function arrow(options: ArrowMiddlewareOptions): Middleware$1;
+//#endregion
+export { AnchorElement, type AxisConstraint, type Coordinates, FloatingContext, FloatingElement, FloatingPosition, FloatingRefs, FloatingRoot, FloatingState, FloatingStyles, FollowTracker, type Middleware, type Placement, StaticTracker, type Strategy, type TrackingMode, TrackingStrategy, UseArrowOptions, UseArrowReturn, UseClickContext, UseClickOptions, UseClientPointContext, UseClientPointOptions, UseClientPointReturn, UseEscapeKeyContext, UseEscapeKeyOptions, UseFloatingOptions, UseFocusContext, UseFocusOptions, UseFocusReturn, UseFocusTrapContext, UseFocusTrapOptions, UseFocusTrapReturn, UseHoverOptions, UseListNavigationOptions, UseListNavigationReturn, VirtualElementFactory, arrow, autoPlacement, flip, hide, offset, shift, size, useArrow, useClick, useClientPoint, useEscapeKey, useFloating, useFocus, useFocusTrap, useHover, useListNavigation };
+//# sourceMappingURL=index.d.mts.map