@tamagui/floating 2.0.0-rc.4 → 2.0.0-rc.40

package/src/interactions/useTypeahead.ts

@@ -0,0 +1,173 @@
+import { useLayoutEffect, useMemo, useRef } from 'react'
+import { useEvent } from '@tamagui/use-event'
+import type { ElementProps, FloatingInteractionContext, UseTypeaheadProps } from './types'
+import { clearTimeoutIfSet, stopEvent } from './utils'
+
+// typeahead: character buffer matching against list items
+// ported from floating-ui/react useTypeahead
+export function useTypeahead(
+  context: FloatingInteractionContext,
+  props: UseTypeaheadProps
+): ElementProps {
+  const { open, dataRef } = context
+  const {
+    listRef,
+    activeIndex,
+    onMatch: unstable_onMatch,
+    onTypingChange: unstable_onTypingChange,
+    enabled = true,
+    findMatch = null,
+    resetMs = 750,
+    ignoreKeys = [],
+    selectedIndex = null,
+  } = props
+
+  const timeoutIdRef = useRef(-1)
+  const stringRef = useRef('')
+  const prevIndexRef = useRef<number | null>(selectedIndex ?? activeIndex ?? -1)
+  const matchIndexRef = useRef<number | null>(null)
+
+  // stable callbacks via useEvent
+  const onMatch = useEvent(unstable_onMatch || (() => {}))
+  const onTypingChange = useEvent(unstable_onTypingChange || (() => {}))
+
+  // latest-value refs
+  const findMatchRef = useRef(findMatch)
+  findMatchRef.current = findMatch
+  const ignoreKeysRef = useRef(ignoreKeys)
+  ignoreKeysRef.current = ignoreKeys
+
+  useLayoutEffect(() => {
+    if (open) {
+      clearTimeoutIfSet(timeoutIdRef)
+      matchIndexRef.current = null
+      stringRef.current = ''
+    }
+  }, [open])
+
+  useLayoutEffect(() => {
+    // sync arrow key navigation but not typeahead navigation
+    if (open && stringRef.current === '') {
+      prevIndexRef.current = selectedIndex ?? activeIndex ?? -1
+    }
+  }, [open, selectedIndex, activeIndex])
+
+  const setTypingChange = (value: boolean) => {
+    if (value) {
+      if (!dataRef.current.typing) {
+        dataRef.current.typing = value
+        onTypingChange(value)
+      }
+    } else {
+      if (dataRef.current.typing) {
+        dataRef.current.typing = value
+        onTypingChange(value)
+      }
+    }
+  }
+
+  const onKeyDown = (event: React.KeyboardEvent) => {
+    function getMatchingIndex(
+      list: Array<string | null>,
+      orderedList: Array<string | null>,
+      string: string
+    ) {
+      const str = findMatchRef.current
+        ? findMatchRef.current(orderedList, string)
+        : orderedList.find(
+            (text) => text?.toLocaleLowerCase().indexOf(string.toLocaleLowerCase()) === 0
+          )
+
+      return str ? list.indexOf(str) : -1
+    }
+
+    const listContent = listRef.current
+
+    if (stringRef.current.length > 0 && stringRef.current[0] !== ' ') {
+      if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) {
+        setTypingChange(false)
+      } else if (event.key === ' ') {
+        stopEvent(event)
+      }
+    }
+
+    if (
+      listContent == null ||
+      ignoreKeysRef.current.includes(event.key) ||
+      // character key
+      event.key.length !== 1 ||
+      // modifier key
+      event.ctrlKey ||
+      event.metaKey ||
+      event.altKey
+    ) {
+      return
+    }
+
+    if (open && event.key !== ' ') {
+      stopEvent(event)
+      setTypingChange(true)
+    }
+
+    // bail out if the list contains a word like "llama" or "aaron"
+    const allowRapidSuccessionOfFirstLetter = listContent.every((text) =>
+      text ? text[0]?.toLocaleLowerCase() !== text[1]?.toLocaleLowerCase() : true
+    )
+
+    // allows the user to cycle through items that start with the same letter
+    // in rapid succession
+    if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {
+      stringRef.current = ''
+      prevIndexRef.current = matchIndexRef.current
+    }
+
+    stringRef.current += event.key
+    clearTimeoutIfSet(timeoutIdRef)
+    timeoutIdRef.current = window.setTimeout(() => {
+      stringRef.current = ''
+      prevIndexRef.current = matchIndexRef.current
+      setTypingChange(false)
+    }, resetMs)
+
+    const prevIndex = prevIndexRef.current
+
+    const index = getMatchingIndex(
+      listContent,
+      [
+        ...listContent.slice((prevIndex || 0) + 1),
+        ...listContent.slice(0, (prevIndex || 0) + 1),
+      ],
+      stringRef.current
+    )
+
+    if (index !== -1) {
+      onMatch(index)
+      matchIndexRef.current = index
+    } else if (event.key !== ' ') {
+      stringRef.current = ''
+      setTypingChange(false)
+    }
+  }
+
+  const reference: ElementProps['reference'] = useMemo(
+    () => ({ onKeyDown: onKeyDown as any }),
+    [open, enabled]
+  )
+
+  const floating: ElementProps['floating'] = useMemo(
+    () => ({
+      onKeyDown: onKeyDown as any,
+      onKeyUp(event: React.KeyboardEvent) {
+        if (event.key === ' ') {
+          setTypingChange(false)
+        }
+      },
+    }),
+    [open, enabled]
+  )
+
+  return useMemo(
+    () => (enabled ? { reference, floating } : {}),
+    [enabled, reference, floating]
+  )
+}

package/src/interactions/utils.ts

@@ -0,0 +1,234 @@
+// shared utilities for interaction hooks, ported from floating-ui/react
+
+export function getDocument(node: Element | null | undefined): Document {
+  return node?.ownerDocument || document
+}
+
+export function contains(parent?: Element | null, child?: Element | null): boolean {
+  if (!parent || !child) return false
+  const rootNode = child.getRootNode?.()
+  if (parent.contains(child)) return true
+  // shadow DOM support
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next: any = child
+    while (next) {
+      if (parent === next) return true
+      next = next.parentNode || next.host
+    }
+  }
+  return false
+}
+
+function isShadowRoot(node: Node): node is ShadowRoot {
+  return node instanceof ShadowRoot
+}
+
+export function getTarget(event: Event): EventTarget | null {
+  if ('composedPath' in event) {
+    return event.composedPath()[0]
+  }
+  return (event as Event).target
+}
+
+export function activeElement(doc: Document): Element | null {
+  let el = doc.activeElement
+  while (el?.shadowRoot?.activeElement != null) {
+    el = el.shadowRoot.activeElement
+  }
+  return el
+}
+
+export function isHTMLElement(value: unknown): value is HTMLElement {
+  return value instanceof HTMLElement
+}
+
+export function isElement(value: unknown): value is Element {
+  return value instanceof Element
+}
+
+const TYPEABLE_SELECTOR =
+  "input:not([type='hidden']):not([disabled])," +
+  "[contenteditable]:not([contenteditable='false']),textarea:not([disabled])"
+
+export function isTypeableElement(element: unknown): boolean {
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR)
+}
+
+export function isTypeableCombobox(element: Element | null): boolean {
+  if (!element) return false
+  return element.getAttribute('role') === 'combobox' && isTypeableElement(element)
+}
+
+function getPlatform(): string {
+  const uaData = (navigator as any).userAgentData as any
+  if (uaData?.platform) return uaData.platform
+  return navigator.platform
+}
+
+function getUserAgent(): string {
+  const uaData = (navigator as any).userAgentData as any
+  if (uaData && Array.isArray(uaData.brands)) {
+    return uaData.brands.map(({ brand, version }: any) => `${brand}/${version}`).join(' ')
+  }
+  return navigator.userAgent
+}
+
+export function isSafari(): boolean {
+  return /apple/i.test(navigator.vendor)
+}
+
+export function isMac(): boolean {
+  return getPlatform().toLowerCase().startsWith('mac') && !navigator.maxTouchPoints
+}
+
+function isJSDOM(): boolean {
+  return getUserAgent().includes('jsdom/')
+}
+
+export function matchesFocusVisible(element: Element | null): boolean {
+  if (!element || isJSDOM()) return true
+  try {
+    return element.matches(':focus-visible')
+  } catch {
+    return true
+  }
+}
+
+export function isMouseLikePointerType(
+  pointerType: string | undefined,
+  strict?: boolean
+): boolean {
+  const values: Array<string | undefined> = ['mouse', 'pen']
+  if (!strict) {
+    values.push('', undefined)
+  }
+  return values.includes(pointerType)
+}
+
+export function clearTimeoutIfSet(timeoutRef: { current: number }): void {
+  if (timeoutRef.current !== -1) {
+    clearTimeout(timeoutRef.current)
+    timeoutRef.current = -1
+  }
+}
+
+export function stopEvent(event: Event | React.SyntheticEvent): void {
+  event.preventDefault()
+  event.stopPropagation()
+}
+
+export function isVirtualClick(event: MouseEvent | PointerEvent): boolean {
+  if ((event as any).mozInputSource === 0 && event.isTrusted) return true
+  if (isAndroid() && (event as PointerEvent).pointerType) {
+    return event.type === 'click' && event.buttons === 1
+  }
+  return event.detail === 0 && !(event as PointerEvent).pointerType
+}
+
+export function isVirtualPointerEvent(event: PointerEvent): boolean {
+  if (isJSDOM()) return false
+  return (
+    (!isAndroid() && event.width === 0 && event.height === 0) ||
+    (isAndroid() &&
+      event.width === 1 &&
+      event.height === 1 &&
+      event.pressure === 0 &&
+      event.detail === 0 &&
+      event.pointerType === 'mouse') ||
+    (event.width < 1 &&
+      event.height < 1 &&
+      event.pressure === 0 &&
+      event.detail === 0 &&
+      event.pointerType === 'touch')
+  )
+}
+
+function isAndroid(): boolean {
+  const re = /android/i
+  return re.test(getPlatform()) || re.test(getUserAgent())
+}
+
+// focus enqueue helper
+let rafId = 0
+export function enqueueFocus(
+  el: HTMLElement | null,
+  options: { preventScroll?: boolean; cancelPrevious?: boolean; sync?: boolean } = {}
+): void {
+  const { preventScroll = false, cancelPrevious = true, sync = false } = options
+  cancelPrevious && cancelAnimationFrame(rafId)
+  const exec = () => el?.focus({ preventScroll })
+  if (sync) {
+    exec()
+  } else {
+    rafId = requestAnimationFrame(exec)
+  }
+}
+
+// list navigation utilities
+
+type DisabledIndices = Array<number> | ((index: number) => boolean)
+
+export function isListIndexDisabled(
+  listRef: { current: Array<HTMLElement | null> },
+  index: number,
+  disabledIndices?: DisabledIndices
+): boolean {
+  if (typeof disabledIndices === 'function') return disabledIndices(index)
+  if (disabledIndices) return disabledIndices.includes(index)
+  const element = listRef.current[index]
+  return (
+    element == null ||
+    element.hasAttribute('disabled') ||
+    element.getAttribute('aria-disabled') === 'true'
+  )
+}
+
+export function findNonDisabledListIndex(
+  listRef: { current: Array<HTMLElement | null> },
+  {
+    startingIndex = -1,
+    decrement = false,
+    disabledIndices,
+    amount = 1,
+  }: {
+    startingIndex?: number
+    decrement?: boolean
+    disabledIndices?: DisabledIndices
+    amount?: number
+  } = {}
+): number {
+  let index = startingIndex
+  do {
+    index += decrement ? -amount : amount
+  } while (
+    index >= 0 &&
+    index <= listRef.current.length - 1 &&
+    isListIndexDisabled(listRef, index, disabledIndices)
+  )
+  return index
+}
+
+export function getMinListIndex(
+  listRef: { current: Array<HTMLElement | null> },
+  disabledIndices: DisabledIndices | undefined
+): number {
+  return findNonDisabledListIndex(listRef, { disabledIndices })
+}
+
+export function getMaxListIndex(
+  listRef: { current: Array<HTMLElement | null> },
+  disabledIndices: DisabledIndices | undefined
+): number {
+  return findNonDisabledListIndex(listRef, {
+    decrement: true,
+    startingIndex: listRef.current.length,
+    disabledIndices,
+  })
+}
+
+export function isIndexOutOfListBounds(
+  listRef: { current: Array<HTMLElement | null> },
+  index: number
+): boolean {
+  return index < 0 || index >= listRef.current.length
+}

package/src/middleware/inner.ts

@@ -0,0 +1,141 @@
+import * as ReactDOM from 'react-dom'
+import { detectOverflow, offset } from '@floating-ui/react-dom'
+import type { Middleware, MiddlewareState } from '@floating-ui/react-dom'
+
+// ported from floating-ui/react/_deprecated-inner.ts
+// positions the floating element so an inner list item aligns with the reference
+
+export interface InnerProps {
+  listRef: React.RefObject<Array<HTMLElement | null>>
+  index: number | null
+  offset?: number
+  overflowRef: React.RefObject<any>
+  onFallbackChange?: null | ((fallback: boolean) => void)
+  padding?: number
+  minItemsVisible?: number
+  referenceOverflowThreshold?: number
+  scrollRef?: React.RefObject<HTMLElement | null>
+}
+
+function getArgsWithCustomFloatingHeight(state: MiddlewareState, height: number) {
+  return {
+    ...state,
+    rects: {
+      ...state.rects,
+      floating: {
+        ...state.rects.floating,
+        height,
+      },
+    },
+  }
+}
+
+export const inner = (props: InnerProps): Middleware => ({
+  name: 'inner',
+  options: props,
+  async fn(state: MiddlewareState) {
+    const {
+      listRef,
+      overflowRef,
+      onFallbackChange,
+      offset: innerOffset = 0,
+      index = 0,
+      minItemsVisible = 4,
+      referenceOverflowThreshold = 0,
+      scrollRef,
+      padding = 0,
+    } = props
+
+    const {
+      rects,
+      elements: { floating },
+    } = state
+
+    const item = listRef.current?.[index ?? 0]
+    const scrollEl = scrollRef?.current || floating
+
+    const clientTop = floating.clientTop || scrollEl.clientTop
+    const floatingIsBordered = floating.clientTop !== 0
+    const scrollElIsBordered = scrollEl.clientTop !== 0
+    const floatingIsScrollEl = floating === scrollEl
+
+    if (!item || index == null) {
+      onFallbackChange?.(true)
+      return {}
+    }
+
+    // use the offset middleware to compute the y position that aligns
+    // the selected item's center with the reference's center
+    const nextArgs = {
+      ...state,
+      ...(await offset(
+        -item.offsetTop -
+          floating.clientTop -
+          rects.reference.height / 2 -
+          item.offsetHeight / 2 -
+          innerOffset
+      ).fn(state)),
+    }
+
+    const detectOverflowOptions = { padding }
+
+    const overflow = await detectOverflow(
+      getArgsWithCustomFloatingHeight(
+        nextArgs,
+        scrollEl.scrollHeight + clientTop + floating.clientTop
+      ),
+      detectOverflowOptions
+    )
+
+    const refOverflow = await detectOverflow(nextArgs, {
+      ...detectOverflowOptions,
+      elementContext: 'reference',
+    })
+
+    const diffY = Math.max(0, overflow.top)
+    const nextY = nextArgs.y + diffY
+    const isScrollable = scrollEl.scrollHeight > scrollEl.clientHeight
+    const rounder = isScrollable ? (v: number) => v : Math.round
+
+    const maxHeight = rounder(
+      Math.max(
+        0,
+        scrollEl.scrollHeight +
+          ((floatingIsBordered && floatingIsScrollEl) || scrollElIsBordered
+            ? clientTop * 2
+            : 0) -
+          diffY -
+          Math.max(0, overflow.bottom)
+      )
+    )
+
+    scrollEl.style.maxHeight = `${maxHeight}px`
+    scrollEl.scrollTop = diffY
+
+    // check if we should fall back to standard positioning
+    if (onFallbackChange) {
+      const shouldFallback =
+        scrollEl.offsetHeight <
+          item.offsetHeight * Math.min(minItemsVisible, listRef.current?.length ?? 0) -
+            1 ||
+        refOverflow.top >= -referenceOverflowThreshold ||
+        refOverflow.bottom >= -referenceOverflowThreshold
+
+      ReactDOM.flushSync(() => onFallbackChange(shouldFallback))
+    }
+
+    if (overflowRef) {
+      ;(overflowRef as any).current = await detectOverflow(
+        getArgsWithCustomFloatingHeight(
+          { ...nextArgs, y: nextY },
+          scrollEl.offsetHeight + clientTop + floating.clientTop
+        ),
+        detectOverflowOptions
+      )
+    }
+
+    return {
+      y: nextY,
+    }
+  },
+})

package/src/useFloating.tsx

@@ -1,6 +1,7 @@
 import React from 'react'
 
 import * as Floating from './Floating'
+import type { PopupTriggerMap } from './interactions/PopupTriggerMap'
 
 export type UseFloatingFn = typeof Floating.useFloating
 
@@ -16,11 +17,22 @@ export type UseFloatingReturn = Floating.UseFloatingReturn & {
   context?: any
   getFloatingProps?: (props: { ref: any; [key: string]: any }) => any
   getReferenceProps?: (props: { ref: any; [key: string]: any }) => any
+  // extended by useFloatingContext for hoverable popovers/tooltips
+  open?: boolean
+  onHoverReference?: (event: any) => void
+  onLeaveReference?: () => void
+  triggerElements?: PopupTriggerMap
 }
 
-export const FloatingOverrideContext = React.createContext<UseFloatingFn | null>(null)
+export type UseFloatingOverrideFn = (props?: UseFloatingProps) => UseFloatingReturn
+
+export const FloatingOverrideContext = React.createContext<UseFloatingOverrideFn | null>(
+  null
+)
 
 export const useFloating = (props: UseFloatingProps): UseFloatingReturn => {
+  'use no memo'
+
   const context = React.useContext(FloatingOverrideContext)
   return (context || Floating.useFloating)?.({
     ...props,

package/types/Floating.native.d.ts

@@ -1,6 +1,7 @@
 import type { ComputePositionReturn } from '@floating-ui/react-native';
 import type { RefObject } from 'react';
 export declare const autoUpdate: () => void;
+export declare const getOverflowAncestors: () => never[];
 export * from '@floating-ui/react-native';
 export declare const platform: null;
 export declare type UseFloatingReturn = Data & {

package/types/Floating.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Floating.native.d.ts","sourceRoot":"","sources":["../src/Floating.native.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,eAAO,MAAM,UAAU,YAAW,CAAA;AAElC,cAAc,2BAA2B,CAAA;AAEzC,eAAO,MAAM,QAAQ,MAAO,CAAA;AAE5B,MAAM,CAAC,OAAO,MAAM,iBAAiB,GAAG,IAAI,GAAG;IAC7C,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,YAAY,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IACjC,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IAC9B,IAAI,EAAE;QACJ,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;QACzB,QAAQ,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;QACxB,YAAY,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;QAC5B,YAAY,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;QACjC,WAAW,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;QAChC,eAAe,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;KACrC,CAAA;IACD,QAAQ,EAAE;QACR,SAAS,EAAE,GAAG,CAAA;QACd,QAAQ,EAAE,GAAG,CAAA;QACb,YAAY,EAAE,GAAG,CAAA;KAClB,CAAA;IACD,WAAW,EAAE;QACX,QAAQ,EAAE,CAAC,KAAK,EAAE;YAChB,WAAW,EAAE;gBACX,aAAa,EAAE;oBACb,CAAC,EAAE,MAAM,CAAA;oBACT,CAAC,EAAE,MAAM,CAAA;iBACV,CAAA;aACF,CAAA;SACF,KAAK,IAAI,CAAA;QACV,mBAAmB,EAAE,EAAE,CAAA;KACxB,CAAA;CACF,CAAA;AAED,KAAK,IAAI,GAAG,IAAI,CAAC,qBAAqB,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG;IACnD,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACjB,CAAA"}
+{"version":3,"file":"Floating.native.d.ts","sourceRoot":"","sources":["../src/Floating.native.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,eAAO,MAAM,UAAU,YAAW,CAAA;AAClC,eAAO,MAAM,oBAAoB,eAAW,CAAA;AAE5C,cAAc,2BAA2B,CAAA;AAEzC,eAAO,MAAM,QAAQ,MAAO,CAAA;AAE5B,MAAM,CAAC,OAAO,MAAM,iBAAiB,GAAG,IAAI,GAAG;IAC7C,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,YAAY,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IACjC,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;IAC9B,IAAI,EAAE;QACJ,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;QACzB,QAAQ,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;QACxB,YAAY,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;QAC5B,YAAY,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;QACjC,WAAW,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;QAChC,eAAe,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAA;KACrC,CAAA;IACD,QAAQ,EAAE;QACR,SAAS,EAAE,GAAG,CAAA;QACd,QAAQ,EAAE,GAAG,CAAA;QACb,YAAY,EAAE,GAAG,CAAA;KAClB,CAAA;IACD,WAAW,EAAE;QACX,QAAQ,EAAE,CAAC,KAAK,EAAE;YAChB,WAAW,EAAE;gBACX,aAAa,EAAE;oBACb,CAAC,EAAE,MAAM,CAAA;oBACT,CAAC,EAAE,MAAM,CAAA;iBACV,CAAA;aACF,CAAA;SACF,KAAK,IAAI,CAAA;QACV,mBAAmB,EAAE,EAAE,CAAA;KACxB,CAAA;CACF,CAAA;AAED,KAAK,IAAI,GAAG,IAAI,CAAC,qBAAqB,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG;IACnD,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACjB,CAAA"}

package/types/index.d.ts

@@ -1,4 +1,19 @@
 export type { AlignedPlacement, Alignment, ArrowOptions, AutoPlacementOptions, AutoUpdateOptions, Axis, Boundary, ClientRectObject, ComputePositionConfig, ComputePositionReturn, Coords, DetectOverflowOptions, Dimensions, ElementContext, ElementRects, Elements, FlipOptions, FloatingElement, HideOptions, InlineOptions, Length, Middleware, MiddlewareData, MiddlewareReturn, MiddlewareState, NodeScroll, OffsetOptions, Padding, Placement, Platform, Rect, ReferenceElement, ReferenceType, RootBoundary, ShiftOptions, Side, SideObject, SizeOptions, Strategy, UseFloatingData, UseFloatingOptions, VirtualElement, } from './Floating';
-export { arrow, autoPlacement, autoUpdate, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size, } from './Floating';
-export { useFloating, FloatingOverrideContext, type UseFloatingReturn, type UseFloatingProps, type UseFloatingFn, } from './useFloating';
+export { arrow, autoPlacement, autoUpdate, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size, } from './Floating';
+export { useFloating, FloatingOverrideContext, type UseFloatingReturn, type UseFloatingProps, type UseFloatingFn, type UseFloatingOverrideFn, } from './useFloating';
+export { useFloating as useFloatingRaw } from './Floating';
+export { createFloatingEvents } from './interactions/createFloatingEvents';
+export { PopupTriggerMap } from './interactions/PopupTriggerMap';
+export { useInteractions } from './interactions/useInteractions';
+export { useHover } from './interactions/useHover';
+export { safePolygon } from './interactions/safePolygon';
+export { useFocus } from './interactions/useFocus';
+export { useRole } from './interactions/useRole';
+export { useClick } from './interactions/useClick';
+export { useListNavigation } from './interactions/useListNavigation';
+export { useTypeahead } from './interactions/useTypeahead';
+export { useInnerOffset } from './interactions/useInnerOffset';
+export { FloatingDelayGroup, useDelayGroup, useDelayGroupContext, } from './interactions/useDelayGroup';
+export { inner } from './middleware/inner';
+export type { ElementProps, FloatingEvents, FloatingInteractionContext, OpenChangeReason, UseHoverProps, HandleCloseFn, SafePolygonOptions, UseFocusProps, UseRoleProps, UseClickProps, UseListNavigationProps, UseTypeaheadProps, UseInnerOffsetProps, Delay, } from './interactions/types';
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,SAAS,EACT,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,IAAI,EACJ,QAAQ,EACR,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,MAAM,EACN,qBAAqB,EACrB,UAAU,EACV,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,eAAe,EACf,WAAW,EACX,aAAa,EACb,MAAM,EACN,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,aAAa,EACb,OAAO,EACP,SAAS,EACT,QAAQ,EACR,IAAI,EACJ,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,WAAW,EACX,QAAQ,EACR,eAAe,EACf,kBAAkB,EAClB,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,KAAK,EACL,aAAa,EACb,UAAU,EACV,cAAc,EACd,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,UAAU,EACV,MAAM,EACN,QAAQ,EACR,KAAK,EACL,IAAI,GACL,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,SAAS,EACT,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,IAAI,EACJ,QAAQ,EACR,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,MAAM,EACN,qBAAqB,EACrB,UAAU,EACV,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,eAAe,EACf,WAAW,EACX,aAAa,EACb,MAAM,EACN,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,aAAa,EACb,OAAO,EACP,SAAS,EACT,QAAQ,EACR,IAAI,EACJ,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,WAAW,EACX,QAAQ,EACR,eAAe,EACf,kBAAkB,EAClB,cAAc,GACf,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,KAAK,EACL,aAAa,EACb,UAAU,EACV,cAAc,EACd,IAAI,EACJ,oBAAoB,EACpB,IAAI,EACJ,MAAM,EACN,UAAU,EACV,MAAM,EACN,QAAQ,EACR,KAAK,EACL,IAAI,GACL,MAAM,YAAY,CAAA;AAEnB,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,qBAAqB,GAC3B,MAAM,eAAe,CAAA;AAItB,OAAO,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,YAAY,CAAA;AAG1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAG1E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAGhE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAC9D,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,oBAAoB,GACrB,MAAM,8BAA8B,CAAA;AAGrC,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAG1C,YAAY,EACV,YAAY,EACZ,cAAc,EACd,0BAA0B,EAC1B,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,aAAa,EACb,YAAY,EACZ,aAAa,EACb,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,GACN,MAAM,sBAAsB,CAAA"}

package/types/interactions/PopupTriggerMap.d.ts

@@ -0,0 +1,8 @@
+export declare class PopupTriggerMap {
+    private map;
+    private elements;
+    add(id: string, element: Element): void;
+    delete(id: string): void;
+    hasElement(element: Element): boolean;
+}
+//# sourceMappingURL=PopupTriggerMap.d.ts.map

package/types/interactions/PopupTriggerMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PopupTriggerMap.d.ts","sourceRoot":"","sources":["../../src/interactions/PopupTriggerMap.ts"],"names":[],"mappings":"AAKA,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAA6B;IACxC,OAAO,CAAC,QAAQ,CAAqB;IAErC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAShC,MAAM,CAAC,EAAE,EAAE,MAAM;IAQjB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;CAGtC"}

package/types/interactions/createFloatingEvents.d.ts

@@ -0,0 +1,7 @@
+export type FloatingEvents = {
+    emit(event: string, data?: any): void;
+    on(event: string, handler: (data?: any) => void): void;
+    off(event: string, handler: (data?: any) => void): void;
+};
+export declare function createFloatingEvents(): FloatingEvents;
+//# sourceMappingURL=createFloatingEvents.d.ts.map

package/types/interactions/createFloatingEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFloatingEvents.d.ts","sourceRoot":"","sources":["../../src/interactions/createFloatingEvents.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;IACrC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI,CAAA;IACtD,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI,CAAA;CACxD,CAAA;AAED,wBAAgB,oBAAoB,IAAI,cAAc,CAuBrD"}

package/types/interactions/safePolygon.d.ts

@@ -0,0 +1,4 @@
+import type { HandleCloseFn, SafePolygonOptions } from './types';
+export type { SafePolygonOptions };
+export declare function safePolygon(options?: SafePolygonOptions): HandleCloseFn;
+//# sourceMappingURL=safePolygon.d.ts.map

package/types/interactions/safePolygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safePolygon.d.ts","sourceRoot":"","sources":["../../src/interactions/safePolygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAgChE,YAAY,EAAE,kBAAkB,EAAE,CAAA;AAoFlC,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,aAAa,CA+X3E"}