@tale-ui/react 0.0.3

package/esm/utils/reason-parts.d.ts

@@ -0,0 +1,33 @@
+export declare const none: "none";
+export declare const triggerPress: "trigger-press";
+export declare const triggerHover: "trigger-hover";
+export declare const triggerFocus: "trigger-focus";
+export declare const outsidePress: "outside-press";
+export declare const itemPress: "item-press";
+export declare const closePress: "close-press";
+export declare const linkPress: "link-press";
+export declare const clearPress: "clear-press";
+export declare const chipRemovePress: "chip-remove-press";
+export declare const trackPress: "track-press";
+export declare const incrementPress: "increment-press";
+export declare const decrementPress: "decrement-press";
+export declare const inputChange: "input-change";
+export declare const inputClear: "input-clear";
+export declare const inputBlur: "input-blur";
+export declare const inputPaste: "input-paste";
+export declare const inputPress: "input-press";
+export declare const focusOut: "focus-out";
+export declare const escapeKey: "escape-key";
+export declare const closeWatcher: "close-watcher";
+export declare const listNavigation: "list-navigation";
+export declare const keyboard: "keyboard";
+export declare const pointer: "pointer";
+export declare const drag: "drag";
+export declare const wheel: "wheel";
+export declare const scrub: "scrub";
+export declare const cancelOpen: "cancel-open";
+export declare const siblingOpen: "sibling-open";
+export declare const disabled: "disabled";
+export declare const imperativeAction: "imperative-action";
+export declare const swipe: "swipe";
+export declare const windowResize: "window-resize";

package/esm/utils/reason-parts.js

@@ -0,0 +1,33 @@
+export const none = 'none';
+export const triggerPress = 'trigger-press';
+export const triggerHover = 'trigger-hover';
+export const triggerFocus = 'trigger-focus';
+export const outsidePress = 'outside-press';
+export const itemPress = 'item-press';
+export const closePress = 'close-press';
+export const linkPress = 'link-press';
+export const clearPress = 'clear-press';
+export const chipRemovePress = 'chip-remove-press';
+export const trackPress = 'track-press';
+export const incrementPress = 'increment-press';
+export const decrementPress = 'decrement-press';
+export const inputChange = 'input-change';
+export const inputClear = 'input-clear';
+export const inputBlur = 'input-blur';
+export const inputPaste = 'input-paste';
+export const inputPress = 'input-press';
+export const focusOut = 'focus-out';
+export const escapeKey = 'escape-key';
+export const closeWatcher = 'close-watcher';
+export const listNavigation = 'list-navigation';
+export const keyboard = 'keyboard';
+export const pointer = 'pointer';
+export const drag = 'drag';
+export const wheel = 'wheel';
+export const scrub = 'scrub';
+export const cancelOpen = 'cancel-open';
+export const siblingOpen = 'sibling-open';
+export const disabled = 'disabled';
+export const imperativeAction = 'imperative-action';
+export const swipe = 'swipe';
+export const windowResize = 'window-resize';

package/esm/utils/reasons.d.ts

@@ -0,0 +1,4 @@
+import * as REASONS from "./reason-parts.js";
+export { REASONS };
+export type TaleUIEventReasons = typeof REASONS;
+export type TaleUIEventReason = TaleUIEventReasons[keyof TaleUIEventReasons];

package/esm/utils/reasons.js

@@ -0,0 +1,2 @@
+import * as REASONS from "./reason-parts.js";
+export { REASONS };

package/esm/utils/resolveClassName.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If the provided className is a string, it will be returned as is.
+ * Otherwise, the function will call the className function with the state as the first argument.
+ *
+ * @param className
+ * @param state
+ */
+export declare function resolveClassName<State>(className: string | ((state: State) => string | undefined) | undefined, state: State): string | undefined;

package/esm/utils/resolveClassName.js

@@ -0,0 +1,10 @@
+/**
+ * If the provided className is a string, it will be returned as is.
+ * Otherwise, the function will call the className function with the state as the first argument.
+ *
+ * @param className
+ * @param state
+ */
+export function resolveClassName(className, state) {
+  return typeof className === 'function' ? className(state) : className;
+}

package/esm/utils/resolveRef.d.ts

@@ -0,0 +1,5 @@
+/**
+ * If the provided argument is a ref object, returns its `current` value.
+ * Otherwise, returns the argument itself.
+ */
+export declare function resolveRef<T extends HTMLElement | null | undefined>(maybeRef: T | React.RefObject<T>): T;

package/esm/utils/resolveRef.js

@@ -0,0 +1,10 @@
+/**
+ * If the provided argument is a ref object, returns its `current` value.
+ * Otherwise, returns the argument itself.
+ */
+export function resolveRef(maybeRef) {
+  if (maybeRef == null) {
+    return maybeRef;
+  }
+  return 'current' in maybeRef ? maybeRef.current : maybeRef;
+}

package/esm/utils/resolveStyle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If the provided style is an object, it will be returned as is.
+ * Otherwise, the function will call the style function with the state as the first argument.
+ *
+ * @param style
+ * @param state
+ */
+export declare function resolveStyle<State>(style: React.CSSProperties | ((state: State) => React.CSSProperties | undefined) | undefined, state: State): import("react").CSSProperties | undefined;

package/esm/utils/resolveStyle.js

@@ -0,0 +1,10 @@
+/**
+ * If the provided style is an object, it will be returned as is.
+ * Otherwise, the function will call the style function with the state as the first argument.
+ *
+ * @param style
+ * @param state
+ */
+export function resolveStyle(style, state) {
+  return typeof style === 'function' ? style(state) : style;
+}

package/esm/utils/resolveValueLabel.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+type ItemRecord = Record<string, React.ReactNode>;
+type ItemsInput = ItemRecord | ReadonlyArray<LabeledItem> | ReadonlyArray<Group<any>> | undefined;
+interface LabeledItem {
+  value: any;
+  label: React.ReactNode;
+}
+export interface Group<Item = any> {
+  [key: string]: unknown;
+  items: ReadonlyArray<Item>;
+}
+export declare function isGroupedItems(items: ReadonlyArray<any | Group<any>> | undefined): items is ReadonlyArray<Group<any>>;
+/**
+ * Checks if the items array contains an item with a null value that has a non-null label.
+ */
+export declare function hasNullItemLabel(items: ItemsInput): boolean;
+export declare function stringifyAsLabel(item: any, itemToStringLabel?: (item: any) => string): string;
+export declare function stringifyAsValue(item: any, itemToStringValue?: (item: any) => string): string;
+export declare function resolveSelectedLabel(value: any, items: ItemsInput, itemToStringLabel?: (item: any) => string): React.ReactNode;
+export declare function resolveMultipleLabels(values: any[], items: ItemsInput, itemToStringLabel?: (item: any) => string): React.ReactNode;
+export {};

package/esm/utils/resolveValueLabel.js

@@ -0,0 +1,108 @@
+'use client';
+
+import * as React from 'react';
+import { serializeValue } from "./serializeValue.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export function isGroupedItems(items) {
+  return items != null && items.length > 0 && typeof items[0] === 'object' && items[0] != null && 'items' in items[0];
+}
+
+/**
+ * Checks if the items array contains an item with a null value that has a non-null label.
+ */
+export function hasNullItemLabel(items) {
+  if (!Array.isArray(items)) {
+    return items != null && 'null' in items;
+  }
+  const arrayItems = items;
+  if (isGroupedItems(arrayItems)) {
+    for (const group of arrayItems) {
+      for (const item of group.items) {
+        if (item && item.value == null && item.label != null) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  for (const item of arrayItems) {
+    if (item && item.value == null && item.label != null) {
+      return true;
+    }
+  }
+  return false;
+}
+export function stringifyAsLabel(item, itemToStringLabel) {
+  if (itemToStringLabel && item != null) {
+    return itemToStringLabel(item) ?? '';
+  }
+  if (item && typeof item === 'object') {
+    if ('label' in item && item.label != null) {
+      return String(item.label);
+    }
+    if ('value' in item) {
+      return String(item.value);
+    }
+  }
+  return serializeValue(item);
+}
+export function stringifyAsValue(item, itemToStringValue) {
+  if (itemToStringValue && item != null) {
+    return itemToStringValue(item) ?? '';
+  }
+  if (item && typeof item === 'object' && 'value' in item && 'label' in item) {
+    return serializeValue(item.value);
+  }
+  return serializeValue(item);
+}
+export function resolveSelectedLabel(value, items, itemToStringLabel) {
+  function fallback() {
+    return stringifyAsLabel(value, itemToStringLabel);
+  }
+  if (itemToStringLabel && value != null) {
+    return itemToStringLabel(value);
+  }
+
+  // Custom object with explicit label takes precedence
+  if (value && typeof value === 'object' && 'label' in value && value.label != null) {
+    return value.label;
+  }
+
+  // Items provided as plain record map
+  if (items && !Array.isArray(items)) {
+    return items[value] ?? fallback();
+  }
+
+  // Items provided as array (flat or grouped)
+  if (Array.isArray(items)) {
+    const arrayItems = items;
+    const flatItems = isGroupedItems(arrayItems) ? arrayItems.flatMap(group => group.items) : arrayItems;
+    if (value == null || typeof value !== 'object') {
+      const match = flatItems.find(item => item.value === value);
+      if (match && match.label != null) {
+        return match.label;
+      }
+      return fallback();
+    }
+
+    // Object without explicit label: try matching by its `value` property
+    if ('value' in value) {
+      const match = flatItems.find(item => item && item.value === value.value);
+      if (match && match.label != null) {
+        return match.label;
+      }
+    }
+  }
+  return fallback();
+}
+export function resolveMultipleLabels(values, items, itemToStringLabel) {
+  return values.reduce((acc, value, index) => {
+    if (index > 0) {
+      acc.push(', ');
+    }
+    acc.push(/*#__PURE__*/_jsx(React.Fragment, {
+      children: resolveSelectedLabel(value, items, itemToStringLabel)
+    }, index));
+    return acc;
+  }, []);
+}

package/esm/utils/scrollable.d.ts

@@ -0,0 +1,4 @@
+export type ScrollAxis = 'horizontal' | 'vertical';
+export declare function isScrollable(element: HTMLElement, axis: ScrollAxis): boolean;
+export declare function hasScrollableAncestor(target: HTMLElement, root: HTMLElement, axes: ScrollAxis[]): boolean;
+export declare function findScrollableTouchTarget(target: EventTarget | null, root: HTMLElement, axis?: ScrollAxis): HTMLElement | null;

package/esm/utils/scrollable.js

@@ -0,0 +1,32 @@
+import { getComputedStyle, isHTMLElement } from '@floating-ui/utils/dom';
+export function isScrollable(element, axis) {
+  const style = getComputedStyle(element);
+  if (axis === 'vertical') {
+    const overflowY = style.overflowY;
+    return (overflowY === 'auto' || overflowY === 'scroll') && element.scrollHeight > element.clientHeight;
+  }
+  const overflowX = style.overflowX;
+  return (overflowX === 'auto' || overflowX === 'scroll') && element.scrollWidth > element.clientWidth;
+}
+export function hasScrollableAncestor(target, root, axes) {
+  let node = target;
+  while (node && node !== root) {
+    for (const axis of axes) {
+      if (isScrollable(node, axis)) {
+        return true;
+      }
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+export function findScrollableTouchTarget(target, root, axis = 'vertical') {
+  let node = isHTMLElement(target) ? target : null;
+  while (node && node !== root) {
+    if (isScrollable(node, axis)) {
+      return node;
+    }
+    node = node.parentElement;
+  }
+  return isScrollable(root, axis) ? root : null;
+}

package/esm/utils/serializeValue.d.ts

@@ -0,0 +1 @@
+export declare function serializeValue(value: unknown): string;

package/esm/utils/serializeValue.js

@@ -0,0 +1,13 @@
+export function serializeValue(value) {
+  if (value == null) {
+    return '';
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}

package/esm/utils/stateAttributesMapping.d.ts

@@ -0,0 +1,14 @@
+import type { TransitionStatus } from "./useTransitionStatus.js";
+export declare enum TransitionStatusDataAttributes {
+  /**
+   * Present when the component is animating in.
+   */
+  startingStyle = "data-starting-style",
+  /**
+   * Present when the component is animating out.
+   */
+  endingStyle = "data-ending-style",
+}
+export declare const transitionStatusMapping: {
+  transitionStatus(value: TransitionStatus): Record<string, string> | null;
+};

package/esm/utils/stateAttributesMapping.js

@@ -0,0 +1,28 @@
+export let TransitionStatusDataAttributes = /*#__PURE__*/function (TransitionStatusDataAttributes) {
+  /**
+   * Present when the component is animating in.
+   */
+  TransitionStatusDataAttributes["startingStyle"] = "data-starting-style";
+  /**
+   * Present when the component is animating out.
+   */
+  TransitionStatusDataAttributes["endingStyle"] = "data-ending-style";
+  return TransitionStatusDataAttributes;
+}({});
+const STARTING_HOOK = {
+  [TransitionStatusDataAttributes.startingStyle]: ''
+};
+const ENDING_HOOK = {
+  [TransitionStatusDataAttributes.endingStyle]: ''
+};
+export const transitionStatusMapping = {
+  transitionStatus(value) {
+    if (value === 'starting') {
+      return STARTING_HOOK;
+    }
+    if (value === 'ending') {
+      return ENDING_HOOK;
+    }
+    return null;
+  }
+};

package/esm/utils/styles.d.ts

@@ -0,0 +1,4 @@
+export declare const styleDisableScrollbar: {
+  className: string;
+  getElement(nonce?: string): import("react/jsx-runtime").JSX.Element;
+};

package/esm/utils/styles.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const DISABLE_SCROLLBAR_CLASS_NAME = 'tale-ui-disable-scrollbar';
+export const styleDisableScrollbar = {
+  className: DISABLE_SCROLLBAR_CLASS_NAME,
+  getElement(nonce) {
+    return /*#__PURE__*/_jsx("style", {
+      nonce: nonce,
+      href: DISABLE_SCROLLBAR_CLASS_NAME,
+      precedence: "tale-ui:low",
+      children: `.${DISABLE_SCROLLBAR_CLASS_NAME}{scrollbar-width:none}.${DISABLE_SCROLLBAR_CLASS_NAME}::-webkit-scrollbar{display:none}`
+    });
+  }
+};
+if (process.env.NODE_ENV !== "production") styleDisableScrollbar.getElement.displayName = "styleDisableScrollbar.getElement";

package/esm/utils/types.d.ts

@@ -0,0 +1,63 @@
+import type * as React from 'react';
+import type { TaleUIEvent, ComponentRenderFn, HTMLProps } from "../types/index.js";
+export type { HTMLProps, TaleUIEvent, ComponentRenderFn };
+export interface FloatingUIOpenChangeDetails {
+  open: boolean;
+  reason: string;
+  nativeEvent: Event;
+  nested: boolean;
+  triggerElement?: Element | undefined;
+}
+type WithPreventTaleUIHandler<T> = T extends ((event: infer E) => any) ? E extends React.SyntheticEvent<Element, Event> ? (event: TaleUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
+/**
+ * Adds a `preventTaleUIHandler` method to all event handlers.
+ */
+export type WithTaleUIEvent<T> = { [K in keyof T]: WithPreventTaleUIHandler<T[K]> };
+/**
+ * Props shared by all Tale UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+export type TaleUIComponentProps<ElementType extends React.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithTaleUIEvent<React.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked'> & {
+  /**
+   * CSS class applied to the element, or a function that
+   * returns a class based on the component’s state.
+   */
+  className?: string | ((state: State) => string | undefined) | undefined;
+  /**
+   * Allows you to replace the component’s HTML element
+   * with a different tag, or compose it with another component.
+   *
+   * Accepts a `ReactElement` or a function that returns the element to render.
+   */
+  render?: React.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+  /**
+   * Style applied to the element, or a function that
+   * returns a style object based on the component’s state.
+   */
+  style?: React.CSSProperties | ((state: State) => React.CSSProperties | undefined) | undefined;
+};
+export interface NativeButtonProps {
+  /**
+   * Whether the component renders a native `<button>` element when replacing it
+   * via the `render` prop.
+   * Set to `false` if the rendered element is not a button (e.g. `<div>`).
+   * @default true
+   */
+  nativeButton?: boolean | undefined;
+}
+export interface NonNativeButtonProps {
+  /**
+   * Whether the component renders a native `<button>` element when replacing it
+   * via the `render` prop.
+   * Set to `true` if the rendered element is a native button.
+   * @default false
+   */
+  nativeButton?: boolean | undefined;
+}
+/**
+ * Simplifies the display of a type (without modifying it).
+ * Taken from https://effectivetypescript.com/2022/02/25/gentips-4-display/
+ */
+export type Simplify<T> = T extends Function ? T : { [K in keyof T]: T[K] };
+export type RequiredExcept<T, K extends keyof T> = Required<Omit<T, K>> & Pick<T, K>;
+export type Orientation = 'horizontal' | 'vertical';

package/esm/utils/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils/useAnchorPositioning.d.ts

@@ -0,0 +1,204 @@
+import * as React from 'react';
+import { type Rect } from '@floating-ui/utils';
+import { useFloating, type FloatingRootContext, type VirtualElement, type Padding, type FloatingContext, type Side as PhysicalSide, type Middleware, type FloatingTreeStore } from "../floating-ui-react/index.js";
+export type Side = 'top' | 'bottom' | 'left' | 'right' | 'inline-end' | 'inline-start';
+export type Align = 'start' | 'center' | 'end';
+export type Boundary = 'clipping-ancestors' | Element | Element[] | Rect;
+export type OffsetFunction = (data: {
+  side: Side;
+  align: Align;
+  anchor: {
+    width: number;
+    height: number;
+  };
+  positioner: {
+    width: number;
+    height: number;
+  };
+}) => number;
+interface SideFlipMode {
+  /**
+   * How to avoid collisions on the side axis.
+   */
+  side?: 'flip' | 'none' | undefined;
+  /**
+   * How to avoid collisions on the align axis.
+   */
+  align?: 'flip' | 'shift' | 'none' | undefined;
+  /**
+   * If both sides on the preferred axis do not fit, determines whether to fallback
+   * to a side on the perpendicular axis and which logical side to prefer.
+   */
+  fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
+}
+interface SideShiftMode {
+  /**
+   * How to avoid collisions on the side axis.
+   */
+  side?: 'shift' | 'none' | undefined;
+  /**
+   * How to avoid collisions on the align axis.
+   */
+  align?: 'shift' | 'none' | undefined;
+  /**
+   * If both sides on the preferred axis do not fit, determines whether to fallback
+   * to a side on the perpendicular axis and which logical side to prefer.
+   */
+  fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
+}
+export type CollisionAvoidance = SideFlipMode | SideShiftMode;
+/**
+ * Provides standardized anchor positioning behavior for floating elements. Wraps Floating UI's
+ * `useFloating` hook.
+ */
+export declare function useAnchorPositioning(params: useAnchorPositioning.Parameters): useAnchorPositioning.ReturnValue;
+export interface UseAnchorPositioningSharedParameters {
+  /**
+   * An element to position the popup against.
+   * By default, the popup will be positioned against the trigger.
+   */
+  anchor?: Element | null | VirtualElement | React.RefObject<Element | null> | (() => Element | VirtualElement | null) | undefined;
+  /**
+   * Determines which CSS `position` property to use.
+   * @default 'absolute'
+   */
+  positionMethod?: 'absolute' | 'fixed' | undefined;
+  /**
+   * Which side of the anchor element to align the popup against.
+   * May automatically change to avoid collisions.
+   * @default 'bottom'
+   */
+  side?: Side | undefined;
+  /**
+   * Distance between the anchor and the popup in pixels.
+   * Also accepts a function that returns the distance to read the dimensions of the anchor
+   * and positioner elements, along with its side and alignment.
+   *
+   * The function takes a `data` object parameter with the following properties:
+   * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
+   * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
+   * - `data.side`: which side of the anchor element the positioner is aligned against.
+   * - `data.align`: how the positioner is aligned relative to the specified side.
+   *
+   * @example
+   * ```jsx
+   * <Positioner
+   *   sideOffset={({ side, align, anchor, positioner }) => {
+   *     return side === 'top' || side === 'bottom'
+   *       ? anchor.height
+   *       : anchor.width;
+   *   }}
+   * />
+   * ```
+   *
+   * @default 0
+   */
+  sideOffset?: number | OffsetFunction | undefined;
+  /**
+   * How to align the popup relative to the specified side.
+   * @default 'center'
+   */
+  align?: Align | undefined;
+  /**
+   * Additional offset along the alignment axis in pixels.
+   * Also accepts a function that returns the offset to read the dimensions of the anchor
+   * and positioner elements, along with its side and alignment.
+   *
+   * The function takes a `data` object parameter with the following properties:
+   * - `data.anchor`: the dimensions of the anchor element with properties `width` and `height`.
+   * - `data.positioner`: the dimensions of the positioner element with properties `width` and `height`.
+   * - `data.side`: which side of the anchor element the positioner is aligned against.
+   * - `data.align`: how the positioner is aligned relative to the specified side.
+   *
+   * @example
+   * ```jsx
+   * <Positioner
+   *   alignOffset={({ side, align, anchor, positioner }) => {
+   *     return side === 'top' || side === 'bottom'
+   *       ? anchor.width
+   *       : anchor.height;
+   *   }}
+   * />
+   * ```
+   *
+   * @default 0
+   */
+  alignOffset?: number | OffsetFunction | undefined;
+  /**
+   * An element or a rectangle that delimits the area that the popup is confined to.
+   * @default 'clipping-ancestors'
+   */
+  collisionBoundary?: Boundary | undefined;
+  /**
+   * Additional space to maintain from the edge of the collision boundary.
+   * @default 5
+   */
+  collisionPadding?: Padding | undefined;
+  /**
+   * Whether to maintain the popup in the viewport after
+   * the anchor element was scrolled out of view.
+   * @default false
+   */
+  sticky?: boolean | undefined;
+  /**
+   * Minimum distance to maintain between the arrow and the edges of the popup.
+   *
+   * Use it to prevent the arrow element from hanging out of the rounded corners of a popup.
+   * @default 5
+   */
+  arrowPadding?: number | undefined;
+  /**
+   * Whether to disable the popup from tracking any layout shift of its positioning anchor.
+   * @default false
+   */
+  disableAnchorTracking?: boolean | undefined;
+  /**
+   * Determines how to handle collisions when positioning the popup.
+   *
+   * @example
+   * ```jsx
+   * <Positioner
+   *   collisionAvoidance={{
+   *     side: 'shift',
+   *     align: 'shift',
+   *     fallbackAxisSide: 'none',
+   *   }}
+   * />
+   * ```
+   *
+   */
+  collisionAvoidance?: CollisionAvoidance | undefined;
+}
+export interface UseAnchorPositioningParameters extends useAnchorPositioning.SharedParameters {
+  keepMounted?: boolean | undefined;
+  trackCursorAxis?: 'none' | 'x' | 'y' | 'both' | undefined;
+  floatingRootContext?: FloatingRootContext | undefined;
+  mounted: boolean;
+  disableAnchorTracking: boolean;
+  nodeId?: string | undefined;
+  adaptiveOrigin?: Middleware | undefined;
+  collisionAvoidance: CollisionAvoidance;
+  shiftCrossAxis?: boolean | undefined;
+  lazyFlip?: boolean | undefined;
+  externalTree?: FloatingTreeStore | undefined;
+}
+export interface UseAnchorPositioningReturnValue {
+  positionerStyles: React.CSSProperties;
+  arrowStyles: React.CSSProperties;
+  arrowRef: React.RefObject<Element | null>;
+  arrowUncentered: boolean;
+  side: Side;
+  align: Align;
+  physicalSide: PhysicalSide;
+  anchorHidden: boolean;
+  refs: ReturnType<typeof useFloating>['refs'];
+  context: FloatingContext;
+  isPositioned: boolean;
+  update: () => void;
+}
+export declare namespace useAnchorPositioning {
+  type SharedParameters = UseAnchorPositioningSharedParameters;
+  type Parameters = UseAnchorPositioningParameters;
+  type ReturnValue = UseAnchorPositioningReturnValue;
+}
+export {};