@askrjs/askr 0.0.9 → 0.0.10

package/dist/foundations/index.d.ts

@@ -1,724 +1,6 @@
+export { ComposeHandlersOptions, ControllableState, DismissableOptions, FocusableOptions, FocusableResult, FormatIdOptions, HoverableOptions, HoverableResult, InteractionPolicyInput, Orientation, PressableOptions, PressableResult, Ref, RovingFocusOptions, RovingFocusResult, applyInteractionPolicy, ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, controllableState, dismissable, focusable, formatId, hoverable, isControlled, makeControllable, mergeInteractionProps, mergeProps, pressable, resolveControllable, rovingFocus, setRef } from './core.js';
 export { L as LayoutComponent, l as layout } from '../layout-BINPv-nz.js';
+export { Collection, CollectionItem, DefaultPortal, Layer, LayerManager, LayerOptions, Portal, Presence, PresenceProps, Slot, SlotProps, createCollection, createLayer, definePortal } from './structures.js';
 import '../types-DxdosFWx.js';
-import { J as JSXElement } from '../jsx-CSWf4VFg.js';
-import { S as State } from '../component-DHAn9JxU.js';
-
-type SlotProps = {
-    asChild: true;
-    children: JSXElement;
-    [key: string]: unknown;
-} | {
-    asChild?: false;
-    children?: unknown;
-};
-/**
- * Slot
- *
- * Structural primitive for prop forwarding patterns.
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. asChild Pattern
- *    When asChild=true, merges props into the single child element.
- *    Child must be a valid JSXElement; non-element children return null.
- *    **Slot props override child props** (injection pattern).
- *
- * 2. Fallback Behavior
- *    When asChild=false, returns a Fragment (structural no-op).
- *    No DOM element is introduced.
- *
- * 3. Type Safety
- *    asChild=true requires exactly one JSXElement child (enforced by type).
- *    Runtime validates with isElement() check.
- */
-declare function Slot(props: SlotProps): JSXElement | null;
-
-interface PresenceProps {
-    present: boolean | (() => boolean);
-    children?: unknown;
-}
-/**
- * Presence
- *
- * Structural policy primitive for conditional mount/unmount.
- * - No timers
- * - No animation coupling
- * - No DOM side-effects
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Present as Function
- *    Accepts boolean OR function to support lazy evaluation patterns.
- *    Function is called once per render. Use boolean form for static values.
- *
- * 2. Children Type
- *    `children` is intentionally `unknown` to remain runtime-agnostic.
- *    The runtime owns child normalization and validation.
- *
- * 3. Immediate Mount/Unmount
- *    No exit animations or transitions. When `present` becomes false,
- *    children are removed immediately. Animation must be layered above
- *    this primitive.
- */
-declare function Presence({ present, children, }: PresenceProps): JSXElement | null;
-
-/**
- * Portal / Host primitive.
- *
- * Foundations remain runtime-agnostic: a portal is an explicit read/write slot.
- * Scheduling and attachment are owned by the runtime when `createPortalSlot`
- * exists; otherwise this falls back to a local slot (deterministic, but does
- * not schedule updates).
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Local Mutable State
- *    Foundations may use local mutable state ONLY to model deterministic slots,
- *    never to coordinate timing, effects, or ordering. The fallback mode uses
- *    closure-local `mounted` and `value` variables which are non-escaping and
- *    deterministic.
- *
- * 2. Return Type Philosophy
- *    Portal call signatures return `unknown` (intentionally opaque). The runtime
- *    owns the concrete type. This prevents foundations from assuming JSX.Element
- *    or DOM node types, maintaining runtime-agnostic portability.
- */
-interface Portal<T = unknown> {
-    /** Mount point — rendered exactly once */
-    (): unknown;
-    /** Render content into the portal */
-    render(props: {
-        children?: T;
-    }): unknown;
-}
-declare function definePortal<T = unknown>(): Portal<T>;
-declare const DefaultPortal: Portal<unknown>;
-
-/**
- * createCollection
- *
- * Ordered descendant registry for coordinating items without DOM queries.
- *
- * INVARIANTS:
- * 1. Registration order determines item order (no DOM queries)
- * 2. Stable ordering across renders (insertion order preserved)
- * 3. Each item may have metadata (type-safe, user-defined)
- * 4. No implicit global state (explicit collection instances)
- * 5. No automatic cleanup (caller controls lifecycle)
- *
- * DESIGN:
- * - Returns a registry API ({ register, items, clear })
- * - Items are stored in insertion order
- * - Registration returns an unregister function
- * - No side effects on registration (pure data structure)
- *
- * USAGE:
- *   const collection = createCollection<HTMLElement, { disabled: boolean }>();
- *   const unregister = collection.register(element, { disabled: false });
- *   const allItems = collection.items();
- *   unregister();
- */
-type CollectionItem<TNode, TMetadata = unknown> = {
-    node: TNode;
-    metadata: TMetadata;
-};
-interface Collection<TNode, TMetadata = unknown> {
-    /**
-     * Register a node with optional metadata.
-     * Returns an unregister function.
-     */
-    register(node: TNode, metadata: TMetadata): () => void;
-    /**
-     * Get all registered items in insertion order.
-     */
-    items(): ReadonlyArray<CollectionItem<TNode, TMetadata>>;
-    /**
-     * Clear all registered items.
-     */
-    clear(): void;
-    /**
-     * Get the count of registered items.
-     */
-    size(): number;
-}
-declare function createCollection<TNode, TMetadata = unknown>(): Collection<TNode, TMetadata>;
-
-/**
- * createLayer
- *
- * Manages stacking order and coordination for overlays (modals, popovers, etc).
- *
- * INVARIANTS:
- * 1. Layers are ordered by registration time (FIFO)
- * 2. Only the top layer handles Escape key
- * 3. Only the top layer handles outside pointer events
- * 4. Nested layers are supported
- * 5. Does not implement portals (orthogonal concern)
- * 6. No automatic DOM insertion (caller controls mounting)
- *
- * DESIGN:
- * - Returns a layer manager with register/unregister API
- * - Each layer has a unique ID and can query if it's the top layer
- * - Escape and outside pointer coordination via callbacks
- * - No z-index management (CSS concern)
- *
- * USAGE:
- *   const manager = createLayer();
- *
- *   const layer = manager.register({
- *     onEscape: () => { ... },
- *     onOutsidePointer: () => { ... }
- *   });
- *
- *   layer.isTop(); // true if this is the topmost layer
- *   layer.unregister();
- */
-interface LayerOptions {
-    /**
-     * Called when Escape is pressed and this is the top layer
-     */
-    onEscape?: () => void;
-    /**
-     * Called when pointer event occurs outside and this is the top layer
-     */
-    onOutsidePointer?: (e: PointerEvent) => void;
-    /**
-     * Optional node reference for outside pointer detection
-     */
-    node?: Node | null;
-}
-interface Layer {
-    /**
-     * Unique layer ID
-     */
-    id: number;
-    /**
-     * Check if this layer is the topmost
-     */
-    isTop(): boolean;
-    /**
-     * Remove this layer from the stack
-     */
-    unregister(): void;
-}
-interface LayerManager {
-    /**
-     * Register a new layer
-     */
-    register(options: LayerOptions): Layer;
-    /**
-     * Get all active layers in order
-     */
-    layers(): ReadonlyArray<Layer>;
-    /**
-     * Manually trigger escape handling on the top layer
-     */
-    handleEscape(): void;
-    /**
-     * Manually trigger outside pointer handling on the top layer
-     */
-    handleOutsidePointer(e: PointerEvent): void;
-}
-declare function createLayer(): LayerManager;
-
-/**
- * composeHandlers
- *
- * Compose two event handlers into one. The first handler runs, and unless it
- * calls `event.preventDefault()` (or sets `defaultPrevented`), the second
- * handler runs. This prevents accidental clobbering of child handlers when
- * injecting props.
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Execution Order
- *    First handler runs before second (injected before base).
- *    This allows injected handlers to prevent default behavior.
- *
- * 2. Default Prevention Check
- *    By default, checks `defaultPrevented` on first argument.
- *    Can be disabled via options.checkDefaultPrevented = false.
- *
- * 3. Undefined Handler Support
- *    Undefined handlers are skipped (no-op). This simplifies usage
- *    where handlers are optional.
- *
- * 4. Type Safety
- *    Args are readonly to prevent mutation. Return type matches input.
- */
-interface ComposeHandlersOptions {
-    /**
-     * When true (default), do not run the second handler if the first prevented default.
-     * When false, always run both handlers.
-     */
-    checkDefaultPrevented?: boolean;
-}
-declare function composeHandlers<A extends readonly unknown[]>(first?: (...args: A) => void, second?: (...args: A) => void, options?: ComposeHandlersOptions): (...args: A) => void;
-
-declare function mergeProps<TBase extends object, TInjected extends object>(base: TBase, injected: TInjected): TInjected & TBase;
-
-/**
- * Tiny aria helpers
- */
-declare function ariaDisabled(disabled?: boolean): {
-    'aria-disabled'?: 'true';
-};
-declare function ariaExpanded(expanded?: boolean): {
-    'aria-expanded'?: 'true' | 'false';
-};
-declare function ariaSelected(selected?: boolean): {
-    'aria-selected'?: 'true' | 'false';
-};
-
-/**
- * Ref composition utilities
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Ref Types Supported
- *    - Callback refs: (value: T | null) => void
- *    - Object refs: { current: T | null }
- *    - null/undefined (no-op)
- *
- * 2. Write Failure Handling
- *    setRef catches write failures (readonly refs) and ignores them.
- *    This is intentional — refs may be readonly in some contexts.
- *
- * 3. Composition Order
- *    composeRefs applies refs in array order (left to right).
- *    All refs are called even if one fails.
- */
-type Ref<T> = ((value: T | null) => void) | {
-    current: T | null;
-} | null | undefined;
-declare function setRef<T>(ref: Ref<T>, value: T | null): void;
-declare function composeRefs<T>(...refs: Array<Ref<T>>): (value: T | null) => void;
-
-interface UseIdOptions {
-    /** Defaults to 'askr' */
-    prefix?: string;
-    /** Stable, caller-provided identity */
-    id: string | number;
-}
-/**
- * useId
- *
- * Formats a stable ID from a caller-provided identity.
- * - Pure and deterministic (no time/randomness/global counters)
- * - SSR-safe
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. No Auto-Generation
- *    Caller must provide the `id`. No random/sequential generation.
- *    This ensures determinism and SSR safety.
- *
- * 2. Format Convention
- *    IDs are formatted as `{prefix}-{id}`.
- *    Default prefix is "askr".
- *
- * 3. Type Coercion
- *    Numbers are coerced to strings via String().
- *    This is deterministic and consistent.
- */
-declare function useId(options: UseIdOptions): string;
-
-/**
- * controllable
- *
- * Small utilities for controlled vs uncontrolled components. These helpers are
- * intentionally minimal and do not manage state themselves; they help component
- * implementations make correct decisions about when to call `onChange` vs
- * update internal state.
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Controlled Detection
- *    A value is "controlled" if it is not `undefined`.
- *    This matches React conventions and is SSR-safe.
- *
- * 2. onChange Timing
- *    - Controlled mode: onChange called immediately, no internal update
- *    - Uncontrolled mode: internal state updated first, then onChange called
- *    This ensures onChange sees the new value in both modes.
- *
- * 3. Value Equality
- *    controllableState uses Object.is() to prevent unnecessary onChange calls.
- *    This is intentional — strict equality, no deep comparison.
- */
-
-declare function isControlled<T>(value: T | undefined): value is T;
-declare function resolveControllable<T>(value: T | undefined, defaultValue: T): {
-    value: T;
-    isControlled: boolean;
-};
-declare function makeControllable<T>(options: {
-    value: T | undefined;
-    defaultValue: T;
-    onChange?: (next: T) => void;
-    setInternal?: (next: T) => void;
-}): {
-    set: (next: T) => void;
-    isControlled: boolean;
-};
-type ControllableState<T> = State<T> & {
-    isControlled: boolean;
-};
-/**
- * controllableState
- *
- * Hook-like primitive that mirrors `state()` semantics while supporting
- * controlled/uncontrolled behavior.
- */
-declare function controllableState<T>(options: {
-    value: T | undefined;
-    defaultValue: T;
-    onChange?: (next: T) => void;
-}): ControllableState<T>;
-
-interface DefaultPreventable {
-    defaultPrevented?: boolean;
-    preventDefault?: () => void;
-}
-interface PropagationStoppable {
-    stopPropagation?: () => void;
-}
-interface KeyboardLikeEvent extends DefaultPreventable, PropagationStoppable {
-    key: string;
-}
-interface PointerLikeEvent extends DefaultPreventable, PropagationStoppable {
-    target?: unknown;
-}
-
-/**
- * pressable
- *
- * Interaction helper that produces VNode props for 'press' semantics.
- * - Pure and deterministic: no DOM construction or mutation here
- * - The runtime owns event attachment and scheduling
- * - This helper returns plain props (handlers) intended to be attached by the runtime
- *
- * Behaviour:
- * - For native buttons: only an `onClick` prop is provided (no ARIA or keyboard shims)
- * - For non-button elements: add `role="button"` and `tabIndex` and keyboard handlers
- * - Activation: `Enter` activates on keydown, `Space` activates on keyup (matches native button)
- * - Disabled: handlers short-circuit and `aria-disabled` is set for all hosts
- *
- * POLICY DECISIONS (LOCKED):
- *
- * 1. Activation Timing (Platform Parity)
- *    - Enter fires on keydown (immediate response)
- *    - Space fires on keyup (allows cancel by moving focus, matches native)
- *    - Space keydown prevents scroll (matches native button behavior)
- *
- * 2. Disabled Enforcement Strategy
- *    - Native buttons: Use HTML `disabled` attribute (platform-enforced non-interactivity)
- *                     AND `aria-disabled` (consistent a11y signaling)
- *    - Non-native: Use `tabIndex=-1` (removes from tab order)
- *                  AND `aria-disabled` (signals disabled state to AT)
- *    - Click handler short-circuits as defense-in-depth (prevents leaked focus issues)
- *
- * 3. Key Repeat Behavior
- *    - Held Enter/Space will fire onPress repeatedly (matches native button)
- *    - No debouncing or repeat prevention (platform parity)
- */
-interface PressableOptions {
-    disabled?: boolean;
-    onPress?: (e: PressEvent) => void;
-    /**
-     * Whether the host is a native button. Defaults to false.
-     */
-    isNativeButton?: boolean;
-}
-
-type PressEvent = DefaultPreventable & PropagationStoppable;
-interface PressableResult {
-    onClick: (e: PressEvent) => void;
-    disabled?: true;
-    role?: 'button';
-    tabIndex?: number;
-    onKeyDown?: (e: KeyboardLikeEvent) => void;
-    onKeyUp?: (e: KeyboardLikeEvent) => void;
-    'aria-disabled'?: 'true';
-}
-declare function pressable({ disabled, onPress, isNativeButton, }: PressableOptions): PressableResult;
-
-/**
- * dismissable
- *
- * THE dismissal primitive. Handles Escape key and outside interactions.
- *
- * INVARIANTS:
- * 1. Returns props that compose via mergeProps (no factories)
- * 2. Disabled state respected exactly once, here
- * 3. No side effects - pure props generation
- * 4. Outside detection requires explicit node reference
- * 5. This is the ONLY dismissal primitive - do not create alternatives
- *
- * DESIGN:
- * - Returns standard event handler props (onKeyDown, onPointerDownCapture)
- * - Composable via mergeProps with other foundations
- * - Caller provides node reference for outside detection
- * - Single onDismiss callback for all dismiss triggers
- *
- * PIT OF SUCCESS:
- * ✓ Can't accidentally bypass (only way to get dismiss behavior)
- * ✓ Can't duplicate (disabled checked once)
- * ✓ Composes via mergeProps (standard props)
- * ✓ Wrong usage is hard (no factories to misuse)
- *
- * USAGE:
- *   const props = dismissable({
- *     node: elementRef,
- *     disabled: false,
- *     onDismiss: () => close()
- *   });
- *
- *   <div ref={elementRef} {...props}>Content</div>
- *
- * MISUSE EXAMPLE (PREVENTED):
- *   ❌ Can't forget to check disabled - checked inside dismissable
- *   ❌ Can't create custom escape handler - this is the only one
- *   ❌ Can't bypass via direct event listeners - mergeProps composes correctly
- */
-interface DismissableOptions {
-    /**
-     * Reference to the element for outside click detection
-     */
-    node?: Node | null;
-    /**
-     * Whether dismiss is disabled
-     */
-    disabled?: boolean;
-    /**
-     * Called when dismiss is triggered (Escape or outside click)
-     */
-    onDismiss?: (trigger: 'escape' | 'outside') => void;
-}
-
-declare function dismissable({ node, disabled, onDismiss, }: DismissableOptions): {
-    onKeyDown: (e: KeyboardLikeEvent) => void;
-    onPointerDownCapture: (e: PointerLikeEvent) => void;
-};
-
-/**
- * focusable
- *
- * Normalize focus-related props for hosts.
- * - No DOM manipulation here; returns props that the runtime may attach.
- */
-interface FocusableOptions {
-    disabled?: boolean;
-    tabIndex?: number | undefined;
-}
-interface FocusableResult {
-    tabIndex?: number;
-    'aria-disabled'?: 'true';
-}
-declare function focusable({ disabled, tabIndex, }: FocusableOptions): FocusableResult;
-
-/**
- * hoverable
- *
- * Produces props for pointer enter/leave handling. Pure and deterministic.
- */
-interface HoverableOptions {
-    disabled?: boolean;
-    onEnter?: (e: HoverEvent) => void;
-    onLeave?: (e: HoverEvent) => void;
-}
-
-type HoverEvent = DefaultPreventable & PropagationStoppable;
-interface HoverableResult {
-    onPointerEnter?: (e: HoverEvent) => void;
-    onPointerLeave?: (e: HoverEvent) => void;
-}
-declare function hoverable({ disabled, onEnter, onLeave, }: HoverableOptions): HoverableResult;
-
-/**
- * rovingFocus
- *
- * Single tab stop navigation with arrow-key control.
- *
- * INVARIANTS:
- * 1. Only one item in the group is reachable via Tab (single tab stop)
- * 2. Arrow keys move focus within the group
- * 3. Orientation determines which arrow keys are active
- * 4. Looping is opt-in
- * 5. Disabled items are skipped
- * 6. Returns props objects, never factories (composes via mergeProps)
- *
- * DESIGN:
- * - Container gets onKeyDown for arrow navigation
- * - Each item gets tabIndex based on current selection
- * - Navigation logic is pure - caller controls focus application
- * - Disabled check happens per-item via predicate
- *
- * PIT OF SUCCESS:
- * ✓ Can't accidentally break tab order (tabIndex assigned correctly)
- * ✓ Can't duplicate navigation logic (single source)
- * ✓ Composes via mergeProps (all standard props)
- * ✓ Type-safe - invalid indices caught at call site
- *
- * USAGE:
- *   const nav = rovingFocus({
- *     currentIndex: 0,
- *     itemCount: 3,
- *     orientation: 'horizontal',
- *     onNavigate: setIndex
- *   });
- *
- *   <div {...nav.container}>
- *     <button {...nav.item(0)}>First</button>
- *     <button {...nav.item(1)}>Second</button>
- *   </div>
- *
- * MISUSE EXAMPLE (PREVENTED):
- *   ❌ Can't forget to set tabIndex - returned in item props
- *   ❌ Can't create conflicting arrow handlers - mergeProps composes
- *   ❌ Can't skip disabled items incorrectly - logic is internal
- */
-
-type Orientation = 'horizontal' | 'vertical' | 'both';
-interface RovingFocusOptions {
-    /**
-     * Current focused index
-     */
-    currentIndex: number;
-    /**
-     * Total number of items
-     */
-    itemCount: number;
-    /**
-     * Navigation orientation
-     * - horizontal: ArrowLeft/ArrowRight
-     * - vertical: ArrowUp/ArrowDown
-     * - both: all arrow keys
-     */
-    orientation?: Orientation;
-    /**
-     * Whether to loop when reaching the end
-     */
-    loop?: boolean;
-    /**
-     * Callback when navigation occurs
-     */
-    onNavigate?: (index: number) => void;
-    /**
-     * Optional disabled state check per index
-     */
-    isDisabled?: (index: number) => boolean;
-}
-interface RovingFocusResult {
-    /**
-     * Props for the container element (composes via mergeProps)
-     */
-    container: {
-        onKeyDown: (e: KeyboardLikeEvent) => void;
-    };
-    /**
-     * Generate props for an item at the given index (composes via mergeProps)
-     */
-    item: (index: number) => {
-        tabIndex: number;
-        'data-roving-index': number;
-    };
-}
-declare function rovingFocus(options: RovingFocusOptions): RovingFocusResult;
-
-/**
- * INTERACTION POLICY (FRAMEWORK LAW)
- *
- * This is THE ONLY way to create interactive elements. Components MUST NOT
- * implement interaction logic directly.
- *
- * INVARIANTS (ENFORCED):
- * 1. "Press" is the semantic. Click/touch/Enter/Space are implementation details.
- * 2. Disabled is enforced exactly once, here. Components may not check disabled.
- * 3. Keyboard handling is automatic. Components may not add onKeyDown for activation.
- * 4. Native elements opt out of polyfills, not semantics.
- * 5. asChild may replace the host element, not interaction behavior.
- * 6. This policy is the SINGLE SOURCE OF TRUTH for interactive behavior.
- *
- * DESIGN:
- * - Single public function: applyInteractionPolicy
- * - Returns props that compose via mergeProps
- * - Delegates to pressable for mechanics
- * - Enforces disabled once and only once
- * - No configuration beyond disabled and native element type
- *
- * PIT OF SUCCESS:
- * ✓ Can't bypass policy (only way to get interaction behavior)
- * ✓ Can't duplicate disabled checks (enforced once, here)
- * ✓ Can't write custom keyboard handlers for buttons (policy owns it)
- * ✓ Composes via mergeProps (standard props)
- * ✓ Wrong usage is impossible (no escape hatch)
- *
- * USAGE:
- *   function Button({ onPress, disabled }) {
- *     const interaction = applyInteractionPolicy({
- *       isNative: true,
- *       disabled,
- *       onPress
- *     });
- *
- *     return <button {...interaction}>Click me</button>;
- *   }
- *
- * MISUSE EXAMPLE (PREVENTED):
- *   ❌ Button checking disabled again:
- *      function Button({ disabled, onPress }) {
- *        if (disabled) return; // NO! Policy handles this
- *        const interaction = applyInteractionPolicy(...);
- *      }
- *
- *   ❌ Custom keyboard handler:
- *      function Button({ onPress }) {
- *        const interaction = applyInteractionPolicy(...);
- *        return <button {...interaction} onKeyDown={...}>; // NO! Policy owns this
- *      }
- *
- *   ❌ Direct event handler:
- *      <button onClick={onPress}>; // NO! Use applyInteractionPolicy
- */
-interface InteractionPolicyInput {
-    /** Whether the host element is a native interactive element (button, a, etc) */
-    isNative: boolean;
-    /** Disabled state - checked ONLY here, never in components */
-    disabled: boolean;
-    /** User-provided press handler - semantic action, not DOM event */
-    onPress?: (e: Event) => void;
-    /** Optional ref to compose */
-    ref?: any;
-}
-/**
- * THE interaction policy. Components MUST use this, NEVER implement
- * interaction logic directly.
- */
-declare function applyInteractionPolicy({ isNative, disabled, onPress, ref, }: InteractionPolicyInput): {
-    disabled: true | undefined;
-    onClick: (e: Event) => void;
-    ref: any;
-} | {
-    'aria-disabled': true | undefined;
-    tabIndex: number;
-    ref: any;
-    onClick: (e: DefaultPreventable & PropagationStoppable) => void;
-    disabled?: true;
-    role?: "button";
-    onKeyDown?: (e: KeyboardLikeEvent) => void;
-    onKeyUp?: (e: KeyboardLikeEvent) => void;
-};
-/**
- * Merge rule for Slot / asChild
- *
- * Precedence:
- *   policy → user → child
- *
- * Event handlers are composed (policy first).
- * Refs are always composed.
- * Policy props MUST take precedence to enforce invariants.
- */
-declare function mergeInteractionProps(childProps: Record<string, any>, policyProps: Record<string, any>, userProps?: Record<string, any>): Record<string, any>;
-
-export { type Collection, type CollectionItem, type ComposeHandlersOptions, type ControllableState, DefaultPortal, type DismissableOptions, type FocusableOptions, type FocusableResult, type HoverableOptions, type HoverableResult, type InteractionPolicyInput, JSXElement, type Layer, type LayerManager, type LayerOptions, type Orientation, type Portal, Presence, type PresenceProps, type PressableOptions, type PressableResult, type Ref, type RovingFocusOptions, type RovingFocusResult, Slot, type SlotProps, applyInteractionPolicy, ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, controllableState, createCollection, createLayer, definePortal, dismissable, focusable, hoverable, isControlled, makeControllable, mergeInteractionProps, mergeProps, pressable, resolveControllable, rovingFocus, setRef, useId };
+export { J as JSXElement } from '../jsx-CSWf4VFg.js';
+import '../component-mtwBWhUr.js';