solid-baseui 0.1.0-alpha.0

package/dist/lib/types/internals/overlay/createAnchorPositioning.d.ts

@@ -0,0 +1,57 @@
+import { type Middleware, type Rect, type ReferenceElement, type RootBoundary, type Strategy } from '@floating-ui/dom';
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import { createFloatingPosition } from './createFloatingPosition.js';
+export type AnchorSide = 'top' | 'bottom' | 'left' | 'right' | 'inline-start' | 'inline-end';
+export type AnchorAlign = 'start' | 'center' | 'end';
+export type AnchorBoundary = 'clipping-ancestors' | Element | Element[] | Rect;
+export type OffsetFunction = (data: {
+    side: AnchorSide;
+    align: AnchorAlign;
+    anchor: {
+        width: number;
+        height: number;
+    };
+    positioner: {
+        width: number;
+        height: number;
+    };
+}) => number;
+export type CollisionAvoidance = {
+    side?: 'flip' | 'shift' | 'none' | undefined;
+    align?: 'flip' | 'shift' | 'none' | undefined;
+    fallbackAxisSide?: 'start' | 'end' | 'none' | undefined;
+};
+export interface AnchorPositioningOptions {
+    reference: Accessor<ReferenceElement | null>;
+    floating: Accessor<HTMLElement | null>;
+    mounted: Accessor<boolean>;
+    direction?: Accessor<'ltr' | 'rtl'> | undefined;
+    positionMethod?: Accessor<Strategy> | undefined;
+    side?: Accessor<AnchorSide> | undefined;
+    sideOffset?: Accessor<number | OffsetFunction> | undefined;
+    align?: Accessor<AnchorAlign> | undefined;
+    alignOffset?: Accessor<number | OffsetFunction> | undefined;
+    collisionBoundary?: Accessor<AnchorBoundary | undefined> | undefined;
+    collisionPadding?: Accessor<number | Partial<Record<'top' | 'right' | 'bottom' | 'left', number>>> | undefined;
+    collisionAvoidance?: Accessor<CollisionAvoidance> | undefined;
+    sticky?: Accessor<boolean> | undefined;
+    arrowPadding?: Accessor<number> | undefined;
+    disableAnchorTracking?: Accessor<boolean> | undefined;
+    inlineMiddleware?: Accessor<Middleware | undefined> | undefined;
+    adaptiveOriginMiddleware?: Accessor<Middleware | undefined> | undefined;
+    shiftRootBoundary?: Accessor<RootBoundary | undefined> | undefined;
+    shiftCrossAxis?: Accessor<boolean> | undefined;
+}
+export interface AnchorPositioning {
+    state: ReturnType<typeof createFloatingPosition>['state'];
+    styles: Accessor<JSX.CSSProperties>;
+    arrowStyles: Accessor<JSX.CSSProperties>;
+    renderedSide: Accessor<AnchorSide>;
+    renderedAlign: Accessor<AnchorAlign>;
+    anchorHidden: Accessor<boolean>;
+    arrowUncentered: Accessor<boolean>;
+    setArrowElement(element: Element | null): void;
+    update(): Promise<void>;
+}
+export declare function createAnchorPositioning(options: AnchorPositioningOptions): AnchorPositioning;

package/dist/lib/types/internals/overlay/createAnchoredPopupScrollLock.d.ts

@@ -0,0 +1,12 @@
+import type { Accessor } from 'solid-js';
+export declare function shouldLockAnchoredPopup(options: {
+    enabled: boolean;
+    touchOpen: boolean;
+    positioner: HTMLElement | null;
+}): boolean;
+export declare function createAnchoredPopupScrollLock(options: {
+    enabled: Accessor<boolean>;
+    touchOpen: Accessor<boolean>;
+    positioner: Accessor<HTMLElement | null>;
+    reference: Accessor<Element | null>;
+}): void;

package/dist/lib/types/internals/overlay/createClickInteraction.d.ts

@@ -0,0 +1,20 @@
+import { type Accessor } from 'solid-js';
+import { type BaseUIEventReason } from '../reasons.js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+export interface ClickInteractionOptions {
+    context: FloatingRootStore;
+    enabled?: Accessor<boolean> | undefined;
+    event?: Accessor<'click' | 'mousedown' | 'mousedown-only'> | undefined;
+    toggle?: Accessor<boolean> | undefined;
+    ignoreMouse?: Accessor<boolean> | undefined;
+    stickIfOpen?: Accessor<boolean> | undefined;
+    touchOpenDelay?: Accessor<number> | undefined;
+    /** The change reason reported for the press. Defaults to `trigger-press`. */
+    reason?: Accessor<BaseUIEventReason> | undefined;
+}
+export interface ClickInteractionHandlers {
+    onPointerDown(event: PointerEvent): void;
+    onMouseDown(event: MouseEvent): void;
+    onClick(event: MouseEvent | PointerEvent): void;
+}
+export declare function createClickInteraction(options: ClickInteractionOptions): ClickInteractionHandlers;

package/dist/lib/types/internals/overlay/createClientPoint.d.ts

@@ -0,0 +1,12 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+export type ClientPointAxis = 'none' | 'x' | 'y' | 'both';
+export interface ClientPointOptions {
+    context: FloatingRootStore;
+    axis: Accessor<ClientPointAxis>;
+    enabled?: Accessor<boolean> | undefined;
+}
+export interface ClientPointHandlers {
+    onMouseMove(event: MouseEvent): void;
+}
+export declare function createClientPoint(options: ClientPointOptions): ClientPointHandlers;

package/dist/lib/types/internals/overlay/createContextMenuInteraction.d.ts

@@ -0,0 +1,17 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+export interface ContextMenuInteractionOptions {
+    context: FloatingRootStore;
+    enabled?: Accessor<boolean> | undefined;
+    longPressDelay?: Accessor<number> | undefined;
+    moveThreshold?: Accessor<number> | undefined;
+    protectedElements?: Accessor<Array<Element | null | undefined>> | undefined;
+}
+export interface ContextMenuInteractionHandlers {
+    onContextMenu(event: MouseEvent): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchMove(event: TouchEvent): void;
+    onTouchEnd(): void;
+    onTouchCancel(): void;
+}
+export declare function createContextMenuInteraction(options: ContextMenuInteractionOptions): ContextMenuInteractionHandlers;

package/dist/lib/types/internals/overlay/createDelayGroup.d.ts

@@ -0,0 +1,18 @@
+import { type Accessor } from 'solid-js';
+import type { HoverDelay } from './createHoverInteraction.js';
+export interface DelayGroup {
+    delay: Accessor<{
+        open: number;
+        close: number;
+    }>;
+    currentId: Accessor<DelayGroupId | null>;
+    isInstant(id: DelayGroupId): boolean;
+    subscribe(id: DelayGroupId, closeSibling: () => void, setInstant?: ((instant: boolean) => void) | undefined): () => void;
+    open(id: DelayGroupId, owner?: (() => void) | undefined): void;
+    close(id: DelayGroupId): void;
+}
+export type DelayGroupId = string | symbol;
+export declare function createDelayGroup(options: {
+    delay: Accessor<HoverDelay | undefined>;
+    timeout?: Accessor<number> | undefined;
+}): DelayGroup;

package/dist/lib/types/internals/overlay/createDismiss.d.ts

@@ -0,0 +1,27 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+import { type FloatingTreeStore } from './FloatingTree.js';
+export type OutsidePressType = 'intentional' | 'sloppy';
+export type OutsidePressEvent = OutsidePressType | {
+    mouse: OutsidePressType;
+    touch: OutsidePressType;
+};
+export interface DismissOptions {
+    context: FloatingRootStore;
+    tree?: Accessor<FloatingTreeStore | undefined> | undefined;
+    enabled?: Accessor<boolean> | undefined;
+    escapeKey?: Accessor<boolean> | undefined;
+    outsidePress?: Accessor<boolean | ((event: MouseEvent | TouchEvent | PointerEvent) => boolean)> | undefined;
+    outsidePressEvent?: Accessor<OutsidePressEvent> | undefined;
+    referencePress?: Accessor<boolean> | undefined;
+    bubbles?: Accessor<boolean | {
+        escapeKey?: boolean | undefined;
+        outsidePress?: boolean | undefined;
+    }> | undefined;
+    insideElements?: Accessor<Element[]> | undefined;
+}
+export interface DismissHandlers {
+    onReferencePress(event: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+}
+export declare function createDismiss(options: DismissOptions): DismissHandlers;

package/dist/lib/types/internals/overlay/createFloatingPosition.d.ts

@@ -0,0 +1,22 @@
+import { type AutoUpdateOptions, type ComputePositionReturn, type Middleware, type Placement, type ReferenceElement, type Strategy } from '@floating-ui/dom';
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+export interface FloatingPositionState extends ComputePositionReturn {
+    isPositioned: boolean;
+}
+export interface FloatingPositionOptions {
+    reference: Accessor<ReferenceElement | null>;
+    floating: Accessor<HTMLElement | null>;
+    open?: Accessor<boolean | undefined> | undefined;
+    placement?: Accessor<Placement> | undefined;
+    strategy?: Accessor<Strategy> | undefined;
+    middleware?: Accessor<Array<Middleware | null | undefined>> | undefined;
+    transform?: Accessor<boolean> | undefined;
+    autoUpdate?: Accessor<AutoUpdateOptions | false> | undefined;
+}
+export interface FloatingPosition {
+    state: Accessor<FloatingPositionState>;
+    styles: Accessor<JSX.CSSProperties>;
+    update(): Promise<void>;
+}
+export declare function createFloatingPosition(options: FloatingPositionOptions): FloatingPosition;

package/dist/lib/types/internals/overlay/createFocusInteraction.d.ts

@@ -0,0 +1,14 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+export interface FocusInteractionOptions {
+    context: FloatingRootStore;
+    enabled?: Accessor<boolean> | undefined;
+    delay?: Accessor<number> | undefined;
+    visibleOnly?: Accessor<boolean> | undefined;
+}
+export interface FocusInteractionHandlers {
+    onFocus(event: FocusEvent): void;
+    onBlur(event: FocusEvent): void;
+    onPointerLeave(): void;
+}
+export declare function createFocusInteraction(options: FocusInteractionOptions): FocusInteractionHandlers;

package/dist/lib/types/internals/overlay/createHoverInteraction.d.ts

@@ -0,0 +1,30 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+import type { FloatingTreeStore } from './FloatingTree.js';
+import type { SafePolygonFactory } from './safePolygon.js';
+import type { Placement } from '@floating-ui/dom';
+export type HoverDelay = number | {
+    open?: number | undefined;
+    close?: number | undefined;
+};
+export interface HoverInteractionOptions {
+    context: FloatingRootStore;
+    reference: Accessor<Element | null>;
+    floating: Accessor<HTMLElement | null>;
+    tree?: Accessor<FloatingTreeStore | undefined> | undefined;
+    enabled?: Accessor<boolean> | undefined;
+    floatingEnabled?: Accessor<boolean> | undefined;
+    delay?: Accessor<HoverDelay> | undefined;
+    restMs?: Accessor<number> | undefined;
+    restOnly?: Accessor<boolean> | undefined;
+    handleClose?: Accessor<SafePolygonFactory | undefined> | undefined;
+    placement?: Accessor<Placement | undefined> | undefined;
+    mouseOnly?: Accessor<boolean> | undefined;
+    shouldOpen?: ((event: MouseEvent, trigger: Element) => boolean) | undefined;
+    blockPointerEventsScope?: Accessor<HTMLElement | null> | undefined;
+    guardStaleOpen?: Accessor<boolean> | undefined;
+}
+export interface HoverInteractionControls {
+    cancelPendingOpen(): void;
+}
+export declare function createHoverInteraction(options: HoverInteractionOptions): HoverInteractionControls;

package/dist/lib/types/internals/overlay/createInitialPositioning.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+/** Keeps coordinate transitions disabled through the first positioned paint of each open. */
+export declare function createInitialPositioning(open: Accessor<boolean>, positioned: Accessor<boolean>): Accessor<boolean>;

package/dist/lib/types/internals/overlay/createListNavigation.d.ts

@@ -0,0 +1,26 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+import { type DisabledIndices } from './compositeNavigation.js';
+export interface ListNavigationOptions {
+    context: FloatingRootStore;
+    list: Accessor<Array<HTMLElement | null>>;
+    activeIndex: Accessor<number | null>;
+    onNavigate(index: number | null, event: Event | undefined): void;
+    enabled?: Accessor<boolean> | undefined;
+    selectedIndex?: Accessor<number | null> | undefined;
+    orientation?: Accessor<'horizontal' | 'vertical' | 'both'> | undefined;
+    rtl?: Accessor<boolean> | undefined;
+    loopFocus?: Accessor<boolean> | undefined;
+    allowEscape?: Accessor<boolean> | undefined;
+    virtual?: Accessor<boolean> | undefined;
+    openOnArrowKeyDown?: Accessor<boolean> | undefined;
+    focusItemOnHover?: Accessor<boolean> | undefined;
+    disabledIndices?: Accessor<DisabledIndices | undefined> | undefined;
+    cols?: Accessor<number> | undefined;
+}
+export interface ListNavigationHandlers {
+    onKeyDown(event: KeyboardEvent): void;
+    onItemPointerMove(event: PointerEvent, index: number): void;
+    onItemPointerLeave(event: PointerEvent): void;
+}
+export declare function createListNavigation(options: ListNavigationOptions): ListNavigationHandlers;

package/dist/lib/types/internals/overlay/createPopupAutoResize.d.ts

@@ -0,0 +1,18 @@
+import { type Accessor } from 'solid-js';
+import type { AnchorSide } from './createAnchorPositioning.js';
+export interface Dimensions {
+    width: number;
+    height: number;
+}
+export declare function getCssDimensions(element: Element): Dimensions;
+export declare function createPopupAutoResize(options: {
+    popup: Accessor<HTMLElement | null>;
+    positioner: Accessor<HTMLElement | null>;
+    mounted: Accessor<boolean>;
+    content: Accessor<unknown>;
+    side: Accessor<AnchorSide>;
+    direction?: Accessor<'ltr' | 'rtl'> | undefined;
+    onMeasureLayout?: (() => void) | undefined;
+    onMeasureLayoutComplete?: ((previous: Dimensions | null, next: Dimensions) => void) | undefined;
+}): void;
+export declare function calculateActivationDirection(from: Element, to: Element): string;

package/dist/lib/types/internals/overlay/createPopupPresence.d.ts

@@ -0,0 +1,18 @@
+import { type Accessor } from 'solid-js';
+import type { BaseUIChangeEventDetails } from '../createBaseUIEventDetails.js';
+import type { TransitionStatus } from '../stateAttributesMapping.js';
+import type { PopupStore } from './PopupStore.js';
+export interface PopupPresence {
+    mounted: Accessor<boolean>;
+    /**
+     * The live transition status. It changes in the same update as `mounted`, so a part that renders
+     * because the popup just mounted already reads `'starting'` and can emit `data-starting-style`
+     * on its first paint. Reading the store's mirrored copy instead leaves the attribute one flush
+     * late, which a forced layout before that flush turns into a skipped entry animation.
+     */
+    transitionStatus: Accessor<TransitionStatus>;
+    forceUnmount(): void;
+}
+export declare function createPopupPresence<Payload, Details extends BaseUIChangeEventDetails<string>>(store: PopupStore<Payload, Details>, element: Accessor<HTMLElement | null>, options?: {
+    onUnmount?: (() => void) | undefined;
+}): PopupPresence;

package/dist/lib/types/internals/overlay/createSwipeDismiss.d.ts

@@ -0,0 +1,107 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+export interface SwipeProgressDetails {
+    deltaX: number;
+    deltaY: number;
+    direction: SwipeDirection | undefined;
+}
+export interface SwipeStartDetails {
+    nativeEvent: PointerEvent | TouchEvent;
+    direction: SwipeDirection | undefined;
+}
+export interface SwipeReleaseDetails {
+    event: PointerEvent | TouchEvent;
+    direction: SwipeDirection | undefined;
+    deltaX: number;
+    deltaY: number;
+    velocityX: number;
+    velocityY: number;
+    releaseVelocityX: number;
+    releaseVelocityY: number;
+}
+export interface SwipeThresholdDetails {
+    element: HTMLElement;
+    direction: SwipeDirection;
+}
+export interface SwipeDismissOptions {
+    enabled: Accessor<boolean>;
+    directions: Accessor<SwipeDirection[]>;
+    element: Accessor<HTMLElement | null>;
+    movementCssVars: {
+        x: string;
+        y: string;
+    };
+    /**
+     * The minimum distance (in pixels) the pointer must travel from the initial swipe point
+     * before the gesture is considered a dismiss.
+     * @default 40
+     */
+    swipeThreshold?: number | ((details: SwipeThresholdDetails) => number) | undefined;
+    /**
+     * If provided, swiping will only begin once this returns true. The predicate is evaluated on
+     * start and on subsequent move events while the pointer is down.
+     */
+    canStart?: ((position: {
+        x: number;
+        y: number;
+    }, details: SwipeStartDetails) => boolean) | undefined;
+    /**
+     * If true, swiping won't start when the gesture begins within a scrollable element.
+     * @default false
+     */
+    ignoreScrollableAncestors?: boolean | undefined;
+    /**
+     * If false, touch interactions can start swiping on interactive elements that are ignored
+     * during pointer swipes.
+     * @default true
+     */
+    ignoreSelectorWhenTouch?: boolean | undefined;
+    /**
+     * Whether to apply drag transform and movement styles to the element imperatively during a
+     * swipe. Disable for event-only usage where the consumer drives styling itself.
+     * @default true
+     */
+    trackDrag?: boolean | undefined;
+    onSwipeStart?: ((event: PointerEvent | TouchEvent) => void) | undefined;
+    onProgress?: ((progress: number, details?: SwipeProgressDetails) => void) | undefined;
+    onCancel?: ((event: PointerEvent | TouchEvent) => void) | undefined;
+    onSwipingChange?: ((swiping: boolean) => void) | undefined;
+    /**
+     * Called when the swipe interaction ends. Returning `true` or `false` overrides the default
+     * dismissal behavior.
+     */
+    onRelease?: ((details: SwipeReleaseDetails) => boolean | void) | undefined;
+    onDismiss?: ((event: PointerEvent | TouchEvent, details: {
+        direction: SwipeDirection;
+    }) => void) | undefined;
+}
+export interface SwipeDismissHandlers {
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    onPointerCancel(event: PointerEvent): void;
+}
+export interface SwipeTouchHandlers {
+    onTouchStart(event: TouchEvent): void;
+    onTouchMove(event: TouchEvent): void;
+    onTouchEnd(event: TouchEvent): void;
+    onTouchCancel(event: TouchEvent): void;
+}
+export interface SwipeDismiss {
+    swiping: Accessor<boolean>;
+    swipeDirection: Accessor<SwipeDirection | undefined>;
+    dragDismissed: Accessor<boolean>;
+    pointerHandlers: SwipeDismissHandlers;
+    touchHandlers: SwipeTouchHandlers;
+    moveNative(event: TouchEvent, currentTarget: HTMLElement): void;
+    getDragStyles(): JSX.CSSProperties;
+    reset(): void;
+}
+export declare function getDisplacement(direction: SwipeDirection, deltaX: number, deltaY: number): number;
+export declare function getElementTransform(element: HTMLElement): {
+    x: number;
+    y: number;
+    scale: number;
+};
+export declare function createSwipeDismiss(options: SwipeDismissOptions): SwipeDismiss;

package/dist/lib/types/internals/overlay/createTypeahead.d.ts

@@ -0,0 +1,20 @@
+import { type Accessor } from 'solid-js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+import { type DisabledIndices } from './compositeNavigation.js';
+export interface TypeaheadOptions {
+    context: FloatingRootStore;
+    list: Accessor<Array<string | null>>;
+    elements?: Accessor<Array<HTMLElement | null>> | undefined;
+    activeIndex: Accessor<number | null>;
+    selectedIndex?: Accessor<number | null> | undefined;
+    disabledIndices?: Accessor<DisabledIndices | undefined> | undefined;
+    enabled?: Accessor<boolean> | undefined;
+    resetMs?: Accessor<number> | undefined;
+    onMatch(index: number): void;
+    onTyping?: ((typing: boolean) => void) | undefined;
+}
+export interface TypeaheadHandlers {
+    onKeyDown(event: KeyboardEvent): void;
+    onBlur(event: FocusEvent): void;
+}
+export declare function createTypeahead(options: TypeaheadOptions): TypeaheadHandlers;

package/dist/lib/types/internals/overlay/dom.d.ts

@@ -0,0 +1,19 @@
+export type FocusableElement = HTMLElement | SVGElement;
+export declare function ownerDocument(node?: Node | Document | null): Document;
+export declare function ownerWindow(node?: Node | Document | null): Window;
+export declare function activeElement(documentNode: Document): Element | null;
+export declare function contains(parent?: Element | null, child?: Element | null): boolean;
+export declare function getEventTarget(event: Event): EventTarget | null;
+export declare function isEventTargetWithin(event: Event, node?: Node | null): boolean;
+export declare function isElement(value: unknown): value is Element;
+export declare function isHTMLElement(value: unknown): value is HTMLElement;
+export declare function isShadowRoot(value: unknown): value is ShadowRoot;
+export declare function isElementVisible(element: Element | null, styles?: CSSStyleDeclaration | null): boolean;
+export declare function getFloatingFocusElement(floating: HTMLElement | null): HTMLElement | null;
+export declare function isTypeableElement(element: unknown): element is HTMLElement;
+/**
+ * Whether the element, or an ancestor of it, is something the user can operate directly. Used to
+ * leave a press on a nested control alone instead of redirecting it to the owning input.
+ */
+export declare function isInteractiveElement(element: Element | null): boolean;
+export declare function isTypeableCombobox(element: Element | null): boolean;

package/dist/lib/types/internals/overlay/eventEmitter.d.ts

@@ -0,0 +1,7 @@
+export interface EventEmitter<Events extends object> {
+    emit<Key extends keyof Events>(event: Key, data: Events[Key]): void;
+    on<Key extends keyof Events>(event: Key, listener: (data: Events[Key]) => void): () => void;
+    off<Key extends keyof Events>(event: Key, listener: (data: Events[Key]) => void): void;
+    clear(): void;
+}
+export declare function createEventEmitter<Events extends object>(): EventEmitter<Events>;

package/dist/lib/types/internals/overlay/getElementAtPoint.d.ts

@@ -0,0 +1,8 @@
+type ElementFromPointRoot = Node & Partial<Pick<Document, 'elementFromPoint'>>;
+/**
+ * `Document.elementFromPoint` retargets shadow content to the shadow host, which then fails
+ * `contains()` checks against a popup inside that shadow root, so callers pass `getRootNode()`
+ * (a document or a shadow root) rather than `ownerDocument()`.
+ */
+export declare function getElementAtPoint(root: ElementFromPointRoot | null | undefined, x: number, y: number): Element | null;
+export {};

package/dist/lib/types/internals/overlay/index.d.ts

@@ -0,0 +1,37 @@
+export * from './adaptiveOrigin.js';
+export * from './compositeNavigation.js';
+export * from './createAnchorPositioning.js';
+export * from './createAnchoredPopupScrollLock.js';
+export * from './createClickInteraction.js';
+export * from './createClientPoint.js';
+export * from './createContextMenuInteraction.js';
+export * from './createDelayGroup.js';
+export * from './createDismiss.js';
+export * from './createFloatingPosition.js';
+export * from './createFocusInteraction.js';
+export * from './createHoverInteraction.js';
+export * from './createInitialPositioning.js';
+export * from './createListNavigation.js';
+export * from './createPopupAutoResize.js';
+export * from './createPopupPresence.js';
+export * from './createTypeahead.js';
+export * from './dom.js';
+export * from './eventEmitter.js';
+export * from './FloatingRootStore.js';
+export * from './FloatingTree.js';
+export * from './FocusGuard.js';
+export * from './FocusManager.js';
+export * from './inlineRect.js';
+export * from './InternalBackdrop.js';
+export * from './markOthers.js';
+export * from './PopupHandle.js';
+export * from './popupStateMapping.js';
+export * from './PopupPortal.js';
+export * from './PopupStore.js';
+export * from './PopupTriggerMap.js';
+export * from './PopupViewport.js';
+export * from './ReactiveStore.js';
+export * from './safePolygon.js';
+export * from './scrollLock.js';
+export * from './tabbable.js';
+export * from './TriggerFocusGuards.js';

package/dist/lib/types/internals/overlay/inlineRect.d.ts

@@ -0,0 +1,32 @@
+import type { Middleware } from '@floating-ui/dom';
+import { type Accessor } from 'solid-js';
+export interface InlineRectCoords {
+    x: number;
+    y: number;
+    lineIndex?: number | undefined;
+    element: Element;
+}
+interface RectLike {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+interface ClientRectLike extends RectLike {
+    x: number;
+    y: number;
+}
+export declare function getInlineRectCoords(element: Element, clientX: number, clientY: number): InlineRectCoords | undefined;
+export declare function getInlineReferenceRect(reference: {
+    getClientRects(): ArrayLike<RectLike>;
+}, placement: string, coords: InlineRectCoords | undefined): ClientRectLike | null;
+export interface InlineRectState {
+    coords: Accessor<InlineRectCoords | undefined>;
+    clear(): void;
+    update(element: Element, clientX: number, clientY: number): InlineRectCoords | undefined;
+    middleware: Middleware;
+}
+export declare function createInlineRect(): InlineRectState;
+export {};

package/dist/lib/types/internals/overlay/markOthers.d.ts

@@ -0,0 +1,6 @@
+export interface MarkOthersOptions {
+    ariaHidden?: boolean | undefined;
+    inert?: boolean | undefined;
+    mark?: boolean | undefined;
+}
+export declare function markOthers(uncorrectedAvoidElements: Element[], options?: MarkOthersOptions): () => void;

package/dist/lib/types/internals/overlay/popupStateMapping.d.ts

@@ -0,0 +1,46 @@
+import { type TransitionStatus } from '../stateAttributesMapping.js';
+export declare enum CommonPopupDataAttributes {
+    open = "data-open",
+    closed = "data-closed",
+    startingStyle = "data-starting-style",
+    endingStyle = "data-ending-style",
+    anchorHidden = "data-anchor-hidden",
+    side = "data-side",
+    align = "data-align"
+}
+export declare enum CommonTriggerDataAttributes {
+    popupOpen = "data-popup-open",
+    pressed = "data-pressed"
+}
+export declare const triggerOpenStateMapping: {
+    open: (value: boolean) => {
+        'data-popup-open': string;
+    } | null;
+};
+export declare const pressableTriggerOpenStateMapping: {
+    open: (value: boolean) => {
+        'data-popup-open': string;
+        'data-pressed': string;
+    } | null;
+};
+export declare const popupStateMapping: {
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};
+export declare const popupTransitionStateMapping: {
+    transitionStatus(value: TransitionStatus): Record<string, string> | null;
+    open: (value: boolean) => {
+        'data-open': string;
+    } | {
+        'data-closed': string;
+    };
+    anchorHidden: (value: boolean) => {
+        'data-anchor-hidden': string;
+    } | null;
+};

package/dist/lib/types/internals/overlay/safePolygon.d.ts

@@ -0,0 +1,24 @@
+import type { Placement } from '@floating-ui/dom';
+import type { FloatingTreeStore } from './FloatingTree.js';
+export interface SafePolygonContext {
+    x: number | null;
+    y: number | null;
+    placement: Placement | null;
+    elements: {
+        domReference: Element | null;
+        floating: HTMLElement | null;
+    };
+    onClose(): void;
+    nodeId: string | undefined;
+    tree?: FloatingTreeStore | undefined;
+}
+export interface SafePolygonOptions {
+    blockPointerEvents?: boolean | undefined;
+}
+export type SafePolygonHandler = ((event: MouseEvent) => void) & {
+    cancel(): void;
+};
+export type SafePolygonFactory = ((context: SafePolygonContext) => SafePolygonHandler) & {
+    options: SafePolygonOptions;
+};
+export declare function safePolygon(options?: SafePolygonOptions): SafePolygonFactory;

package/dist/lib/types/internals/overlay/scrollLock.d.ts

@@ -0,0 +1,10 @@
+import { type Accessor } from 'solid-js';
+export declare class ScrollLockManager {
+    private count;
+    private restore;
+    private lockTimer;
+    private unlockTimer;
+    acquire(reference: Element | null): () => void;
+    private lock;
+}
+export declare function createScrollLock(enabled: Accessor<boolean>, reference?: Accessor<Element | null>): void;