solid-baseui 0.1.0-alpha.0

package/dist/lib/types/internals/field-constants.d.ts

@@ -0,0 +1,44 @@
+import type { StateAttributesMapping } from './getStateAttributesProps.js';
+export interface FieldValidityState {
+    badInput: boolean;
+    customError: boolean;
+    patternMismatch: boolean;
+    rangeOverflow: boolean;
+    rangeUnderflow: boolean;
+    stepMismatch: boolean;
+    tooLong: boolean;
+    tooShort: boolean;
+    typeMismatch: boolean;
+    valueMissing: boolean;
+    valid: boolean | null;
+}
+export interface FieldValidityData {
+    state: FieldValidityState;
+    error: string;
+    errors: string[];
+    value: unknown;
+    initialValue: unknown;
+}
+export interface FieldState {
+    disabled: boolean;
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean | null;
+    filled: boolean;
+    focused: boolean;
+}
+export declare const DEFAULT_VALIDITY_STATE: FieldValidityState;
+export declare const DEFAULT_FIELD_STATE: FieldState;
+export declare const DEFAULT_FIELD_ROOT_STATE: FieldState;
+export declare const DEFAULT_FIELD_STATE_ATTRIBUTES: {
+    valid: null;
+    touched: false;
+    dirty: false;
+    filled: false;
+    focused: false;
+};
+export declare const DEFAULT_VALIDITY_DATA: FieldValidityData;
+export declare const fieldStateAttributesMapping: StateAttributesMapping<FieldState>;
+export declare const fieldValidityMapping: StateAttributesMapping<FieldState>;
+export declare const VALIDITY_KEYS: readonly ["badInput", "customError", "patternMismatch", "rangeOverflow", "rangeUnderflow", "stepMismatch", "tooLong", "tooShort", "typeMismatch", "valueMissing"];
+export declare function copyNativeValidity(validity: ValidityState): FieldValidityState;

package/dist/lib/types/internals/field-root-context/FieldRootContext.d.ts

@@ -0,0 +1,31 @@
+import { type Accessor } from 'solid-js';
+import { type FieldState, type FieldValidityData } from '../field-constants.js';
+import type { FormValidationMode } from '../form-types.js';
+import type { FieldValidationController } from '../../field/root/createFieldValidation.js';
+export interface FieldControlRegistration {
+    id: string | undefined;
+    name?: string | undefined;
+    value: () => unknown;
+    getValue?: (() => unknown) | undefined;
+    getControl: () => HTMLElement | null;
+}
+export interface FieldRootContextValue {
+    state: Accessor<FieldState>;
+    validityData: Accessor<FieldValidityData>;
+    name: Accessor<string | undefined>;
+    disabled: Accessor<boolean>;
+    invalid: Accessor<boolean>;
+    validationMode: Accessor<FormValidationMode>;
+    shouldValidateOnChange: () => boolean;
+    setTouched: (value: boolean) => void;
+    setDirty: (value: boolean) => void;
+    setFilled: (value: boolean) => void;
+    setFocused: (value: boolean) => void;
+    registerFieldControl: (source: symbol, registration: FieldControlRegistration | undefined) => void;
+    validation: FieldValidationController;
+}
+declare const MISSING_CONTEXT: unique symbol;
+export declare const FieldRootContext: import("solid-js").Context<FieldRootContextValue | typeof MISSING_CONTEXT>;
+export declare function useFieldRootContext(optional: true): FieldRootContextValue;
+export declare function useFieldRootContext(optional?: false): FieldRootContextValue;
+export {};

package/dist/lib/types/internals/field-root-context/index.d.ts

@@ -0,0 +1,2 @@
+export { FieldRootContext, useFieldRootContext, type FieldControlRegistration, type FieldRootContextValue, } from './FieldRootContext.js';
+export type { FieldRootContextValue as FieldRootContextType } from './FieldRootContext.js';

package/dist/lib/types/internals/filter.d.ts

@@ -0,0 +1,18 @@
+export interface Filter {
+    /** Whether the item matches the query anywhere. */
+    contains<Item>(item: Item, query: string, itemToString?: ((item: Item) => string) | undefined): boolean;
+    /** Whether the item starts with the query. */
+    startsWith<Item>(item: Item, query: string, itemToString?: ((item: Item) => string) | undefined): boolean;
+    /** Whether the item ends with the query. */
+    endsWith<Item>(item: Item, query: string, itemToString?: ((item: Item) => string) | undefined): boolean;
+}
+export interface FilterOptions extends Intl.CollatorOptions {
+    /**
+     * The locale to use for string comparison.
+     * Defaults to the user's runtime locale.
+     */
+    locale?: Intl.LocalesArgument | undefined;
+}
+export declare function stringifyLocale(locale?: Intl.LocalesArgument): string;
+/** Matches items against a query using `Intl.Collator` for robust string matching. */
+export declare function getFilter(options?: FilterOptions): Filter;

package/dist/lib/types/internals/form-context/FormContext.d.ts

@@ -0,0 +1,13 @@
+import { type Accessor } from 'solid-js';
+import type { FormErrors, FormValidationMode, RegisteredFormField } from '../form-types.js';
+export interface FormContextValue {
+    errors: Accessor<Readonly<FormErrors>>;
+    validationMode: Accessor<FormValidationMode>;
+    submitAttempted: () => boolean;
+    formElement: () => HTMLFormElement | null;
+    clearError: (name: string | undefined) => void;
+    registerField: (field: RegisteredFormField) => () => void;
+    getFormValues: () => Record<string, unknown>;
+}
+export declare const FormContext: import("solid-js").Context<FormContextValue>;
+export declare function useFormContext(): FormContextValue;

package/dist/lib/types/internals/form-context/index.d.ts

@@ -0,0 +1,3 @@
+export { FormContext, useFormContext, type FormContextValue } from './FormContext.js';
+export type { FormErrors } from '../form-types.js';
+export type { FormErrors as Errors } from '../form-types.js';

package/dist/lib/types/internals/form-types.d.ts

@@ -0,0 +1,11 @@
+export type FormValidationMode = 'onSubmit' | 'onBlur' | 'onChange';
+export type FormErrors = Record<string, string | string[]>;
+export interface RegisteredFormField {
+    readonly token: symbol;
+    name: () => string | undefined;
+    validate: () => void;
+    isInvalid: () => boolean;
+    getControl: () => HTMLElement | null;
+    getValue: () => unknown;
+}
+export declare function hasFormError(errors: Readonly<FormErrors>, name: string | undefined): boolean;

package/dist/lib/types/internals/getStateAttributesProps.d.ts

@@ -0,0 +1,4 @@
+export type StateAttributesMapping<State> = {
+    [Property in keyof State]?: (state: State[Property]) => Record<string, string> | null;
+};
+export declare function getStateAttributesProps<State extends object>(state: State, customMapping?: StateAttributesMapping<State>): Record<string, string>;

package/dist/lib/types/internals/installOwnedEventHandlers.d.ts

@@ -0,0 +1,3 @@
+type OwnedHandler = (this: HTMLElement, event: never) => unknown;
+export declare function installOwnedEventHandlers(element: HTMLElement, handlers: ReadonlyArray<readonly [string, OwnedHandler]>): () => void;
+export {};

package/dist/lib/types/internals/isSolidAccessor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether a function child is Solid's own children accessor rather than a caller's render
+ * callback. Solid compiles dynamic JSX children into a bound reader, so a part that accepts
+ * both `children` and a `(item) => …` render function has to tell the two apart.
+ */
+export declare function isSolidAccessor(value: unknown): value is () => unknown;

package/dist/lib/types/internals/itemEquality.d.ts

@@ -0,0 +1,17 @@
+export type ItemEqualityComparer<Item = unknown, Value = Item> = (itemValue: Item, selectedValue: Value) => boolean;
+/** Reference identity, the default used when no custom comparator is provided. */
+export declare function defaultItemEquality<Item, Value>(itemValue: Item, selectedValue: Value): boolean;
+/**
+ * Nullish values always compare by identity so a custom comparator never has to guard against
+ * `null` placeholders or an unselected value.
+ */
+export declare function compareItemEquality<Item, Value>(itemValue: Item, selectedValue: Value, comparer: ItemEqualityComparer<Item, Value>): boolean;
+export declare function selectedValueIncludes<Item, Value>(selectedValues: readonly Item[] | undefined | null, itemValue: Value, comparer: ItemEqualityComparer<Value, Item>): boolean;
+export declare function findItemIndex<Item, Value>(itemValues: readonly Item[] | undefined | null, selectedValue: Value, comparer: ItemEqualityComparer<Item, Value>): number;
+/**
+ * Resolves the index the popup anchors its highlight to. Only multiple selection unwraps the
+ * array, because an array can itself be a valid single-selection value.
+ */
+export declare function findSelectionIndex<Item, Value>(itemValues: readonly Item[] | undefined | null, selectedValue: Value | readonly Value[] | null | undefined, comparer: ItemEqualityComparer<Item, Value>, multiple: boolean): number | null;
+export declare function removeItem<Item, Value>(selectedValues: readonly Item[], itemValue: Value, comparer: ItemEqualityComparer<Value, Item>): Item[];
+export declare function areItemArraysEqual<Item, Value>(first: readonly Item[], second: readonly Value[], comparer: ItemEqualityComparer<Item, Value>): boolean;

package/dist/lib/types/internals/labelable-provider/LabelableContext.d.ts

@@ -0,0 +1,18 @@
+import { type Accessor } from 'solid-js';
+export interface LabelableContextValue {
+    controlId: Accessor<string | null | undefined>;
+    labelId: Accessor<string | undefined>;
+    messageIds: Accessor<readonly string[]>;
+    registerControlId: (source: symbol, id: string | null | undefined) => void;
+    registerLabelId: (id: string | undefined) => () => void;
+    registerMessageId: (source: symbol, id: string | undefined) => void;
+    getAriaDescribedBy: (externalValue: string | undefined) => string | undefined;
+}
+export declare const LabelableContext: import("solid-js").Context<LabelableContextValue>;
+export declare function useLabelableContext(): LabelableContextValue;
+export interface CreateLabelableContextOptions {
+    controlId?: string | null | undefined;
+    labelId?: string | undefined;
+    parent?: LabelableContextValue | undefined;
+}
+export declare function createLabelableContext(options?: CreateLabelableContextOptions): LabelableContextValue;

package/dist/lib/types/internals/labelable-provider/LabelableProvider.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from '@solidjs/web';
+export interface LabelableProviderProps {
+    children?: JSX.Element;
+    controlId?: string | null | undefined;
+    labelId?: string | undefined;
+}
+/** Provides the internal accessible label and description graph. */
+export declare function LabelableProvider(props: LabelableProviderProps): JSX.Element;
+export declare namespace LabelableProvider {
+    type Props = LabelableProviderProps;
+}

package/dist/lib/types/internals/labelable-provider/index.d.ts

@@ -0,0 +1,2 @@
+export { LabelableContext, createLabelableContext, useLabelableContext, type CreateLabelableContextOptions, type LabelableContextValue, } from './LabelableContext.js';
+export { LabelableProvider, type LabelableProviderProps } from './LabelableProvider.js';

package/dist/lib/types/internals/mergeStyleValue.d.ts

@@ -0,0 +1,8 @@
+import type { JSX } from '@solidjs/web';
+/**
+ * Merges functional styles a part owns with the caller's `style` value, which wins.
+ *
+ * Unlike `mergeStyles` this accepts the resolved `StyleValue` shape, where a caller may pass a
+ * CSS string; the internal object is serialized ahead of it so the string still overrides.
+ */
+export declare function mergeStyleValue(internal: JSX.CSSProperties, external: JSX.CSSProperties | string | false | undefined): JSX.CSSProperties | string | undefined;

package/dist/lib/types/internals/mergeStyles.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from '@solidjs/web';
+/**
+ * Merges style objects with external values taking precedence. Call this from a
+ * memo when either input is reactive.
+ */
+export declare function mergeStyles(internalStyle: JSX.CSSProperties | undefined, externalStyle: JSX.CSSProperties | undefined): JSX.CSSProperties | undefined;

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

@@ -0,0 +1,49 @@
+import type { VirtualElement } from '@floating-ui/dom';
+import type { BaseUIChangeEventDetails } from '../createBaseUIEventDetails.js';
+import type { TransitionStatus } from '../stateAttributesMapping.js';
+import { type EventEmitter } from './eventEmitter.js';
+import { PopupTriggerMap } from './PopupTriggerMap.js';
+import { ReactiveStore } from './ReactiveStore.js';
+export type FloatingReference = Element | VirtualElement;
+export interface FloatingOpenChangeEvent {
+    open: boolean;
+    reason: string;
+    nativeEvent: Event;
+    nested: boolean;
+    triggerElement: Element | undefined;
+}
+export interface FloatingEvents {
+    openchange: FloatingOpenChangeEvent;
+}
+export interface FloatingRootState {
+    open: boolean;
+    transitionStatus: TransitionStatus;
+    domReferenceElement: Element | null;
+    referenceElement: FloatingReference | null;
+    positionReference: FloatingReference | null;
+    floatingElement: HTMLElement | null;
+    floatingId: string | undefined;
+}
+export interface FloatingRootContext {
+    data: Record<string, unknown> & {
+        openEvent?: Event | undefined;
+    };
+    events: EventEmitter<FloatingEvents>;
+    nested: boolean;
+    nodeId: string | undefined;
+    triggerElements: PopupTriggerMap;
+    onOpenChange: (open: boolean, details: BaseUIChangeEventDetails<string>) => void;
+}
+export declare class FloatingRootStore extends ReactiveStore<FloatingRootState, FloatingRootContext> {
+    constructor(options: {
+        floatingId?: string | undefined;
+        nested?: boolean | undefined;
+        nodeId?: string | undefined;
+        triggerElements?: PopupTriggerMap | undefined;
+        onOpenChange: (open: boolean, details: BaseUIChangeEventDetails<string>) => void;
+    });
+    referenceElement(): FloatingReference | null;
+    syncOpenEvent(open: boolean, event: Event | undefined): void;
+    dispatchOpenChange(open: boolean, details: BaseUIChangeEventDetails<string>): void;
+    setOpen(open: boolean, details: BaseUIChangeEventDetails<string>): void;
+}

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

@@ -0,0 +1,48 @@
+import { type Accessor } from 'solid-js';
+import { type EventEmitter } from './eventEmitter.js';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+export interface FloatingNode {
+    id: string | undefined;
+    parentId: string | null;
+    context?: FloatingRootStore | undefined;
+}
+export interface FloatingTreeEvents {
+    openchange: {
+        node: FloatingNode;
+        open: boolean;
+    };
+    close: {
+        event: Event | undefined;
+        reason: string;
+    };
+    itemhover: {
+        nodeId: string | undefined;
+        target: Element | null;
+    };
+    menuopenchange: {
+        open: boolean;
+        nodeId: string | undefined;
+        parentNodeId: string | null;
+        reason: string | null;
+    };
+}
+export declare class FloatingTreeStore {
+    readonly nodes: FloatingNode[];
+    readonly events: EventEmitter<FloatingTreeEvents>;
+    addNode(node: FloatingNode): void;
+    removeNode(node: FloatingNode): void;
+}
+declare const MISSING_TREE: unique symbol;
+export declare const FloatingTreeContext: import("solid-js").Context<FloatingTreeStore | typeof MISSING_TREE>;
+export declare const FloatingParentNodeContext: import("solid-js").Context<string | null>;
+export declare function useFloatingTree(external?: FloatingTreeStore): FloatingTreeStore | undefined;
+export declare function useFloatingParentNodeId(): string | null;
+export declare function createFloatingNode(options: {
+    tree: FloatingTreeStore | Accessor<FloatingTreeStore>;
+    context?: Accessor<FloatingRootStore | undefined> | undefined;
+    id?: string | undefined;
+    parentId?: string | null | Accessor<string | null> | undefined;
+}): FloatingNode;
+export declare function getNodeChildren(nodes: FloatingNode[], id: string | undefined, onlyOpenChildren?: boolean): FloatingNode[];
+export declare function getNodeAncestors(nodes: FloatingNode[], id: string | undefined): FloatingNode[];
+export {};

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

@@ -0,0 +1,2 @@
+import type { JSX } from '@solidjs/web';
+export declare function FocusGuard(props: JSX.HTMLAttributes<HTMLSpanElement>): JSX.Element;

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

@@ -0,0 +1,30 @@
+import { type Accessor, type Ref } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+import { type FloatingTreeStore } from './FloatingTree.js';
+export type InteractionType = 'keyboard' | 'mouse' | 'touch' | 'pen' | '';
+export type FocusResolver = boolean | HTMLElement | {
+    current: HTMLElement | null;
+} | null | ((interactionType: InteractionType) => boolean | HTMLElement | null | undefined);
+export interface FocusManagerProps {
+    children: JSX.Element;
+    context: FloatingRootStore;
+    tree?: FloatingTreeStore | undefined;
+    disabled?: boolean | undefined;
+    initialFocus?: FocusResolver | undefined;
+    returnFocus?: FocusResolver | undefined;
+    restoreFocus?: boolean | 'popup' | undefined;
+    modal?: boolean | undefined;
+    closeOnFocusOut?: boolean | undefined;
+    openInteractionType?: InteractionType | null | undefined;
+    nextFocusableElement?: HTMLElement | Accessor<HTMLElement | null> | null | undefined;
+    previousFocusableElement?: HTMLElement | Accessor<HTMLElement | null> | null | undefined;
+    beforeContentGuardRef?: Ref<HTMLSpanElement>;
+    getInsideElements?: (() => Array<Element | null | undefined>) | undefined;
+    /**
+     * The control focus is managed against, when it is not the popup store's active trigger.
+     * A combobox anchors on the input it is typed into while the trigger merely opens the popup.
+     */
+    referenceElement?: Accessor<Element | null> | undefined;
+}
+export declare function FocusManager(props: FocusManagerProps): JSX.Element;

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

@@ -0,0 +1,6 @@
+import type { JSX } from '@solidjs/web';
+export interface InternalBackdropProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    cutout?: Element | null | undefined;
+    open?: boolean | undefined;
+}
+export declare function InternalBackdrop(props: InternalBackdropProps): JSX.Element;

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

@@ -0,0 +1,47 @@
+import { type Accessor } from 'solid-js';
+import type { BaseUIChangeEventDetails } from '../createBaseUIEventDetails.js';
+import { PopupTriggerMap } from './PopupTriggerMap.js';
+import type { PopupStoreState, PopupTriggerStore } from './PopupStore.js';
+export interface PopupHandleStore {
+    readonly context: {
+        triggerElements: PopupTriggerMap;
+    };
+    setOpen(open: boolean, details: BaseUIChangeEventDetails<string>): unknown;
+}
+export declare class DetachedPopupStore<Payload = unknown> implements PopupHandleStore, PopupTriggerStore<Payload> {
+    readonly context: {
+        triggerElements: PopupTriggerMap;
+    };
+    readonly state: PopupStoreState<Payload>;
+    setOpen(_open: boolean, _details: BaseUIChangeEventDetails<string>): void;
+    open(): boolean;
+    activeTriggerId(): string | null;
+    isTriggerActive(_triggerId: string | undefined): boolean;
+    triggerPopupId(_triggerId: string | undefined): string | undefined;
+    registerTrigger(id: string, element: Element): () => void;
+    forwardTriggerData(_id: string, _element: Element, _triggerState?: Partial<PopupStoreState<Payload>>): void;
+}
+export interface PopupHandleStoreProvider<Store> {
+    readonly store: Store;
+    readonly serverStore: Store;
+    subscribeStore(listener: () => void): () => void;
+}
+export declare class BasePopupHandle<Store extends PopupHandleStore = PopupHandleStore> {
+    private readonly componentName;
+    private readonly throwOnMissingTrigger;
+    private readonly attachedStores;
+    private readonly listeners;
+    private readonly fallbackStore;
+    protected attachedStore: Store | null;
+    private overlapWarningFrame;
+    constructor(componentName: string, throwOnMissingTrigger?: boolean, fallbackStore?: Store);
+    get store(): Store;
+    get serverStore(): Store;
+    subscribeStore(listener: () => void): () => void;
+    attachStore(store: Store): () => void;
+    protected openByTrigger(triggerId: string | null | undefined): void;
+    protected closePopup(): void;
+    private setActiveStore;
+}
+export declare function createPopupHandleStore<Store>(handle: Accessor<PopupHandleStoreProvider<Store> | undefined>): Accessor<Store | undefined>;
+export declare function attachPopupHandle<Store extends PopupHandleStore>(handle: Accessor<BasePopupHandle<Store> | undefined>, store: Store): void;

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

@@ -0,0 +1,37 @@
+import { type Accessor } from 'solid-js';
+import { type JSX, type ValidComponent } from '@solidjs/web';
+import type { BaseUIChangeEventDetails } from '../createBaseUIEventDetails.js';
+export interface PortalFocusManagerState {
+    modal: boolean;
+    open: boolean;
+    closeOnFocusOut: boolean;
+    domReference: Element | null;
+    onOpenChange(open: boolean, details: BaseUIChangeEventDetails<string>): void;
+}
+export interface PopupPortalContextValue {
+    portalNode: Accessor<HTMLElement | null>;
+    focusManagerState: Accessor<PortalFocusManagerState | null>;
+    setFocusManagerState(state: PortalFocusManagerState | null): void;
+    beforeInside: Accessor<HTMLSpanElement | null>;
+    afterInside: Accessor<HTMLSpanElement | null>;
+    beforeOutside: Accessor<HTMLSpanElement | null>;
+    afterOutside: Accessor<HTMLSpanElement | null>;
+    setBeforeInside(element: HTMLSpanElement): void;
+    setAfterInside(element: HTMLSpanElement): void;
+    setBeforeOutside(element: HTMLSpanElement): void;
+    setAfterOutside(element: HTMLSpanElement): void;
+}
+declare const MISSING_PORTAL: unique symbol;
+export declare const PopupPortalContext: import("solid-js").Context<PopupPortalContextValue | typeof MISSING_PORTAL>;
+export declare function usePopupPortalContext(): PopupPortalContextValue | undefined;
+type ContainerRef = {
+    current: HTMLElement | ShadowRoot | null;
+};
+export type PopupPortalContainer = HTMLElement | ShadowRoot | ContainerRef | Accessor<HTMLElement | ShadowRoot | null> | null;
+export interface PopupPortalProps extends JSX.HTMLAttributes<HTMLDivElement> {
+    as?: ValidComponent | undefined;
+    container?: PopupPortalContainer | undefined;
+    lite?: boolean | undefined;
+}
+export declare function PopupPortal(props: PopupPortalProps): JSX.Element;
+export {};

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

@@ -0,0 +1,89 @@
+import { type Accessor } from 'solid-js';
+import type { Middleware } from '@floating-ui/dom';
+import type { BaseUIChangeEventDetails } from '../createBaseUIEventDetails.js';
+import type { TransitionStatus } from '../stateAttributesMapping.js';
+import { FloatingRootStore } from './FloatingRootStore.js';
+import { PopupTriggerMap } from './PopupTriggerMap.js';
+import { ReactiveStore } from './ReactiveStore.js';
+export type PopupInteractionProps = Record<string, unknown>;
+export interface PopupStoreState<Payload> {
+    open: boolean;
+    mounted: boolean;
+    transitionStatus: TransitionStatus;
+    triggerCount: number;
+    preventUnmountingOnClose: boolean;
+    payload: Payload | undefined;
+    activeTriggerId: string | null;
+    activeTriggerElement: Element | null;
+    popupElement: HTMLElement | null;
+    popupId: string | undefined;
+    positionerElement: HTMLElement | null;
+    activeTriggerProps: PopupInteractionProps;
+    inactiveTriggerProps: PopupInteractionProps;
+    popupProps: PopupInteractionProps;
+    instantType: 'delay' | 'dismiss' | 'focus' | undefined;
+    adaptiveOriginMiddleware: Middleware | undefined;
+    closeDelay: number;
+}
+export interface PopupStoreContext<Details extends BaseUIChangeEventDetails<string>> {
+    triggerElements: PopupTriggerMap;
+    floatingRoot: FloatingRootStore;
+    floatingId: string | undefined;
+    controlledOpen: Accessor<boolean | undefined>;
+    controlledTriggerId: Accessor<string | null | undefined>;
+    onOpenChange: Accessor<((open: boolean, details: Details) => void) | undefined>;
+    onOpenChangeComplete: Accessor<((open: boolean) => void) | undefined>;
+}
+export interface PopupStoreOptions<Details extends BaseUIChangeEventDetails<string>> {
+    floatingId?: string | undefined;
+    nodeId?: string | undefined;
+    nested?: boolean | undefined;
+    controlledOpen?: Accessor<boolean | undefined> | undefined;
+    controlledTriggerId?: Accessor<string | null | undefined> | undefined;
+    onOpenChange?: Accessor<((open: boolean, details: Details) => void) | undefined> | undefined;
+    onOpenChangeComplete?: Accessor<((open: boolean) => void) | undefined> | undefined;
+}
+export interface PopupTriggerStore<Payload = unknown> {
+    readonly context: {
+        triggerElements: PopupTriggerMap;
+    };
+    readonly state: PopupStoreState<Payload>;
+    open(): boolean;
+    activeTriggerId(): string | null;
+    isTriggerActive(triggerId: string | undefined): boolean;
+    triggerPopupId(triggerId: string | undefined): string | undefined;
+    registerTrigger(id: string, element: Element, triggerState?: Partial<PopupStoreState<Payload>>): () => void;
+    forwardTriggerData(id: string, element: Element, triggerState?: Partial<PopupStoreState<Payload>>): void;
+}
+export declare class PopupStore<Payload = unknown, Details extends BaseUIChangeEventDetails<string> = BaseUIChangeEventDetails<string>> extends ReactiveStore<PopupStoreState<Payload>, PopupStoreContext<Details>> {
+    private resolvedActiveTriggerId;
+    private closeOnActiveTriggerUnmount;
+    private readonly triggerState;
+    constructor(options?: PopupStoreOptions<Details>);
+    open(): boolean;
+    activeTriggerId(): string | null;
+    activeTriggerElement(): Element | null;
+    popupId(): string | undefined;
+    isTriggerActive(triggerId: string | undefined): boolean;
+    isOpenedByTrigger(triggerId: string | undefined): boolean;
+    isMountedByTrigger(triggerId: string | undefined): boolean;
+    triggerPopupId(triggerId: string | undefined): string | undefined;
+    configureTriggerUnmount(options: {
+        closeOnActiveTriggerUnmount?: boolean | undefined;
+    }): void;
+    setOpen(open: boolean, details: Details): boolean;
+    protected shouldCommitOpenChange(_open: boolean, _details: Details): boolean;
+    registerTrigger(id: string, element: Element, triggerState?: Partial<PopupStoreState<Payload>>): () => void;
+    forwardTriggerData(id: string, element: Element, triggerState?: Partial<PopupStoreState<Payload>>): void;
+    reconcileTriggers(): void;
+    setPopupElement(element: HTMLElement | null): void;
+    setPopupId(id: string | undefined): void;
+    setPositionerElement(element: HTMLElement | null): void;
+    setInteractionProps(props: {
+        activeTriggerProps: PopupInteractionProps;
+        inactiveTriggerProps: PopupInteractionProps;
+        popupProps: PopupInteractionProps;
+    }): void;
+    clearInteractionProps(): void;
+}
+export declare function createTriggerRegistration<Payload>(store: Accessor<PopupTriggerStore<Payload> | undefined>, id: Accessor<string | undefined>, element: Accessor<Element | null>, triggerState?: Accessor<Partial<PopupStoreState<Payload>>>): void;

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

@@ -0,0 +1,11 @@
+export declare class PopupTriggerMap {
+    private readonly idMap;
+    add(id: string, element: Element): void;
+    delete(id: string): void;
+    getById(id: string): Element | undefined;
+    hasElement(element: Element): boolean;
+    hasMatchingElement(predicate: (element: Element) => boolean): boolean;
+    entries(): IterableIterator<[string, Element]>;
+    elements(): IterableIterator<Element>;
+    get size(): number;
+}

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

@@ -0,0 +1,16 @@
+import type { JSX } from '@solidjs/web';
+import type { BaseUIChangeEventDetails } from '../createBaseUIEventDetails.js';
+import type { AnchorSide } from './createAnchorPositioning.js';
+import type { PopupStore } from './PopupStore.js';
+export interface PopupViewportState {
+    activationDirection: string | undefined;
+    transitioning: boolean;
+}
+export interface PopupViewportProps<Payload, Details extends BaseUIChangeEventDetails<string>> {
+    store: PopupStore<Payload, Details>;
+    side: AnchorSide;
+    direction?: 'ltr' | 'rtl' | undefined;
+    children?: JSX.Element;
+    onStateChange?: ((state: PopupViewportState) => void) | undefined;
+}
+export declare function PopupViewport<Payload, Details extends BaseUIChangeEventDetails<string>>(props: PopupViewportProps<Payload, Details>): JSX.Element;

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

@@ -0,0 +1,26 @@
+import { type Accessor } from 'solid-js';
+type Listener<State> = (state: State) => void;
+/** Synchronous imperative state with a Solid accessor bridge. */
+export declare class ReactiveStore<State extends object, Context = Record<never, never>> {
+    state: State;
+    readonly context: Context;
+    private readonly listeners;
+    private readonly revision;
+    private readonly setRevision;
+    private updateTick;
+    constructor(state: State, context: Context);
+    subscribe: (listener: Listener<State>) => (() => void);
+    track(): State;
+    access<Value>(selector: (state: State) => Value): Accessor<Value>;
+    setState(nextState: State): void;
+    update(changes: Partial<State>): void;
+    set<Key extends keyof State>(key: Key, value: State[Key]): void;
+    notifyAll(): void;
+}
+export declare class NullReactiveStore<State extends object, Context = Record<never, never>> extends ReactiveStore<State, Context> {
+    setState(_nextState: State): void;
+    update(_changes: Partial<State>): void;
+    set<Key extends keyof State>(_key: Key, _value: State[Key]): void;
+    notifyAll(): void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { type Accessor, type Ref } from 'solid-js';
+import type { JSX } from '@solidjs/web';
+import type { FloatingRootStore } from './FloatingRootStore.js';
+export interface TriggerFocusGuardsProps {
+    children: JSX.Element;
+    context: FloatingRootStore;
+    enabled: boolean;
+    trigger: Accessor<HTMLElement | null>;
+    positioner: Accessor<HTMLElement | null>;
+    beforeContentGuard?: Accessor<HTMLElement | null> | undefined;
+    beforeGuardRef?: Ref<HTMLSpanElement>;
+    afterGuardRef?: Ref<HTMLSpanElement>;
+}
+export declare function TriggerFocusGuards(props: TriggerFocusGuardsProps): JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { Middleware } from '@floating-ui/dom';
+export declare const adaptiveOrigin: Middleware;

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

@@ -0,0 +1,20 @@
+export type DisabledIndices = ReadonlyArray<number> | ((index: number) => boolean);
+export declare function isListIndexDisabled(list: ReadonlyArray<HTMLElement | null>, index: number, disabledIndices?: DisabledIndices | undefined): boolean;
+export declare function findNonDisabledListIndex(list: ReadonlyArray<HTMLElement | null>, options?: {
+    startingIndex?: number | undefined;
+    decrement?: boolean | undefined;
+    amount?: number | undefined;
+    disabledIndices?: DisabledIndices | undefined;
+}): number;
+export declare function getMinListIndex(list: ReadonlyArray<HTMLElement | null>, disabledIndices?: DisabledIndices): number;
+export declare function getMaxListIndex(list: ReadonlyArray<HTMLElement | null>, disabledIndices?: DisabledIndices): number;
+export declare function getNavigatedIndex(options: {
+    list: ReadonlyArray<HTMLElement | null>;
+    currentIndex: number;
+    key: string;
+    orientation?: 'horizontal' | 'vertical' | 'both' | undefined;
+    rtl?: boolean | undefined;
+    loop?: boolean | undefined;
+    cols?: number | undefined;
+    disabledIndices?: DisabledIndices | undefined;
+}): number;