@exponential-at/ui-solid 0.0.0-stage → 0.1.0

package/dist/types/behaviors/bubble-input.d.ts

@@ -0,0 +1,35 @@
+import { type Accessor, type JSX } from "solid-js";
+/** Radix's `isFormControl`: the control sits in a <form> (decided once
+ *  mounted; Radix renders its bubble input only then). */
+export declare function createInForm(el: Accessor<HTMLElement | undefined>): Accessor<boolean>;
+/** Radix's bubble-input effect: a state change replays on the hidden input
+ *  (the native setter + a bubbling event) so <form> listeners see it. */
+export declare function bubbleOnChange<T>(input: () => HTMLInputElement | HTMLSelectElement | undefined, value: Accessor<T>, apply: (el: HTMLInputElement | HTMLSelectElement, v: T) => void, event: string, bubbles?: () => boolean): void;
+export declare const setChecked: (el: HTMLInputElement | HTMLSelectElement, v: boolean) => void | undefined;
+/** Radix's hidden checkbox/radio bubble input (inside a <form> only). */
+export declare function BubbleCheck(props: {
+    type: `checkbox` | `radio`;
+    control: HTMLElement | undefined;
+    checked: boolean;
+    name?: string;
+    value: string;
+    disabled: boolean;
+    transformFirst: boolean;
+    bubbles: () => boolean;
+}): JSX.Element;
+export declare function SliderBubble(props: {
+    name?: string;
+    value: number;
+}): JSX.Element;
+/** Radix's visually-hidden native <select> (inside a <form>). */
+export declare function NativeSelect(props: {
+    name: string;
+    value: string | undefined;
+    disabled: boolean;
+    options: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }[];
+    onChange: (v: string) => void;
+}): JSX.Element;

package/dist/types/behaviors/collapsible.d.ts

@@ -0,0 +1,15 @@
+import { type Accessor } from "solid-js";
+/** Radix `CollapsibleContent`'s state: `shown()` = painted (open, or
+ *  closing while its exit animation runs; the painter writes `hidden` and
+ *  drops the children otherwise), `ref` = the content element, `style()` =
+ *  Radix's variables in Radix's order (the measured
+ *  `--radix-collapsible-content-*` appended by the render after a toggle,
+ *  and the mount measurement by the render after mount;
+ *  `transition-duration: 0s; animation-name: none` left in place on an item
+ *  open at mount). `alias` = the outer primitive whose
+ *  `--radix-<alias>-content-*` variables alias them (Accordion: `accordion`). */
+export declare function createCollapsibleContent(open: Accessor<boolean>, alias?: string): {
+    shown: Accessor<boolean>;
+    ref: (el: HTMLElement) => void;
+    style: () => Record<string, string>;
+};

package/dist/types/behaviors/dialog.d.ts

@@ -0,0 +1,116 @@
+import { type Accessor, type JSX, type ValidComponent } from "solid-js";
+import { type OutsideEvent } from "./dismissable-layer.js";
+import { type StyleObject } from "./style-writer.js";
+export type { OutsideEvent };
+/** Calls a Solid event handler prop (a function or a `[fn, data]` pair). */
+export declare function callHandler<E extends Event>(handler: unknown, event: E): void;
+/** Radix's `composeEventHandlers`: the caller's handler first, ours unless it
+ *  prevented the default. */
+export declare function composeHandlers<E extends Event>(user: unknown, ours: (event: E) => void, checkForDefaultPrevented?: boolean): (event: E) => void;
+/** Calls a Solid `ref` prop (a compiled ref callback) with the element. */
+export declare function callRef(ref: unknown, el: unknown): void;
+/** Every ref callback of `refs` receives the element. */
+export declare function mergeRefs<T>(...refs: unknown[]): (el: T) => void;
+/** A Solid `style` prop (object or string) as a kebab-case object for
+ *  `bindStyle` (React's semantics: the caller's style merges into ours). */
+export declare function styleObject(style: unknown): StyleObject;
+/** Radix `useControllableState` for an overlay's `open`: controlled when
+ *  `open()` is defined, else local from `defaultOpen`; `onOpenChange` fires
+ *  on a change only, BEFORE the parts re-render (Radix calls it before its
+ *  portalled content mounts: a Tooltip's "another tooltip opened" event
+ *  must not reach its own content). */
+export declare function createOpenState(o: {
+    open: () => boolean | undefined;
+    defaultOpen?: boolean;
+    onOpenChange: () => ((open: boolean) => void) | undefined;
+}): [Accessor<boolean>, (next: boolean) => void];
+export declare const stateOf: (open: boolean) => "open" | "closed";
+/** A primitive layer attached in this task (see `layerMountedThisTask`). */
+export declare function noteLayerMount(): void;
+/** Whether a primitive layer attached in this same task: a content created
+ *  now mounts NESTED in it (Radix registers that outer layer one commit
+ *  after this content's first render, so its first `pointer-events` is
+ *  unset). */
+export declare function layerMountedThisTask(): boolean;
+/** The layer's `pointer-events` with that lag applied. */
+export declare function layerPointerEvents(layer: {
+    pointerEvents: (registered: boolean) => string | undefined;
+}, registered: boolean, lag: boolean): string | undefined;
+export interface DialogContextValue {
+    open: Accessor<boolean>;
+    setOpen: (open: boolean) => void;
+    modal: boolean;
+    contentId: string;
+    titleId: string;
+    descriptionId: string;
+    trigger: Accessor<HTMLElement | undefined>;
+    setTrigger: (el: HTMLElement | undefined) => void;
+}
+export declare function useDialogContext(part: string): DialogContextValue;
+export interface DialogRootProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+    children?: JSX.Element;
+}
+/** Radix `Dialog` (Root): renders no element. */
+export declare function DialogRoot(props: DialogRootProps): JSX.Element;
+/** A fresh id: `radix-<n>` keeps the parity rename rule (generated ids). */
+export declare function createId(): string;
+export type AsProps = {
+    as?: ValidComponent;
+    ref?: unknown;
+    onClick?: unknown;
+    children?: JSX.Element;
+    [key: string]: unknown;
+};
+/** Radix `DialogTrigger`: `type="button"`, `aria-haspopup="dialog"`,
+ *  `aria-expanded`, `aria-controls`, `data-state`, a click toggles. */
+export declare function DialogTriggerPart(props: AsProps): JSX.Element;
+/** Radix `DialogClose`: `type="button"`, a click closes. */
+export declare function DialogClosePart(props: AsProps): JSX.Element;
+/** Radix `Portal` as the primitives use it: the children appended to
+ *  `container`, no wrapper. Without a container Radix mounts into
+ *  `document.body` one commit LATER (its `mounted` state): a portal nested
+ *  in another portal's content lands after it, once the outer content's
+ *  effects (`hideOthers`, the focus guards) ran. */
+export declare function DialogPortalPart(props: {
+    container?: HTMLElement | null;
+    children?: JSX.Element;
+}): JSX.Element;
+/** Radix `DialogOverlay` (modal dialogs only): `data-state`, the scroll
+ *  lock, `pointer-events: auto`; present while open (+ its exit animation). */
+export declare function DialogOverlayPart(props: {
+    style?: unknown;
+    ref?: unknown;
+    [key: string]: unknown;
+}): JSX.Element;
+export interface DialogContentPartProps {
+    role?: string;
+    style?: unknown;
+    ref?: unknown;
+    onOpenAutoFocus?: (e: Event) => void;
+    onCloseAutoFocus?: (e: Event) => void;
+    onEscapeKeyDown?: (e: KeyboardEvent) => void;
+    onPointerDownOutside?: (e: OutsideEvent) => void;
+    onFocusOutside?: (e: OutsideEvent) => void;
+    onInteractOutside?: (e: OutsideEvent) => void;
+    onKeyDown?: unknown;
+    children?: JSX.Element;
+    [key: string]: unknown;
+}
+/** Radix `DialogContent` (modal or not, per the Root): `role="dialog"`,
+ *  `id`, `aria-describedby`, `aria-labelledby`, `data-state`,
+ *  `tabindex="-1"`, the layer's `pointer-events`; present while open. */
+export declare function DialogContentPart(props: DialogContentPartProps): JSX.Element;
+/** Radix `DialogTitle`: `<h2 id=titleId>`. */
+export declare function DialogTitlePart(props: {
+    [key: string]: unknown;
+    children?: JSX.Element;
+}): JSX.Element;
+/** Radix `DialogDescription`: `<p id=descriptionId>`. */
+export declare function DialogDescriptionPart(props: {
+    [key: string]: unknown;
+    children?: JSX.Element;
+}): JSX.Element;

package/dist/types/behaviors/dismissable-layer.d.ts

@@ -0,0 +1,48 @@
+import { type Accessor } from "solid-js";
+export interface Layer {
+    el?: HTMLElement;
+    parent?: Layer;
+    kids: Set<Layer>;
+}
+export declare const LAYERS: Layer[];
+export declare const MODAL_LAYERS: Layer[];
+export declare const LayerContext: import("solid-js").Context<Layer | undefined>;
+/** Inside this layer or one it opened (Radix checks the React tree, where a
+ *  portalled child layer still sits under its parent). */
+export declare function layerContains(layer: Layer, target: Node | null): boolean;
+export interface OutsideEvent {
+    target: EventTarget | null;
+    detail: {
+        originalEvent: Event;
+    };
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+}
+export declare const outsideEvent: (originalEvent: Event) => OutsideEvent;
+export interface LayerOptions {
+    disableOutsidePointerEvents?: Accessor<boolean>;
+    onEscapeKeyDown?: (e: KeyboardEvent) => void;
+    onPointerDownOutside?: (e: OutsideEvent) => void;
+    onFocusOutside?: (e: OutsideEvent) => void;
+    onInteractOutside?: (e: OutsideEvent) => void;
+    onDismiss: () => void;
+}
+/** Radix `DismissableLayer` on `el` (call `attach(el)` once it is in the
+ *  document): Escape (the highest layer only), a pointer down outside, a
+ *  focus outside; a modal layer turns the body's pointer events off.
+ *  `pointerEvents()` = the layer's own `pointer-events` (Radix's value). */
+export declare function createLayer(o: LayerOptions): {
+    layer: Layer;
+    attach: (el: HTMLElement) => void;
+    pointerEvents: (registered: boolean) => string | undefined;
+};
+/** Radix's DismissableLayer: Escape, a pointerdown outside (and, unless
+ *  `keepOnFocusOutside`, focus moving outside) dismiss. `isInside` widens
+ *  "inside" (the trigger of a non-modal popover). */
+export declare function dismissable(opts: {
+    layer: () => HTMLElement | undefined;
+    onDismiss: () => void;
+    isInside?: (target: Node) => boolean;
+    keepOnFocusOutside?: boolean;
+    onOutside?: () => void;
+}): void;

package/dist/types/behaviors/drag-to-dismiss.d.ts

@@ -0,0 +1,10 @@
+import { type Accessor } from "solid-js";
+/** Drawer drag-to-dismiss: a drag toward the drawer's edge past 80 px (or a
+ *  flick) closes it; anything less springs back. */
+export declare function createDragToDismiss(side: Accessor<string>, enabled: Accessor<boolean>, onDismiss: () => void, reducedMotion: Accessor<boolean>): {
+    setPanel: (el: HTMLElement) => HTMLElement;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent) => void;
+    onPointerCancel: () => void;
+};

package/dist/types/behaviors/element-size.d.ts

@@ -0,0 +1,7 @@
+import { type Accessor } from "solid-js";
+/** Radix's `useSize`: the element's border-box size once mounted, then
+ *  followed by a ResizeObserver (undefined before the first measure). */
+export declare function createElementSize(el: Accessor<HTMLElement | undefined>): Accessor<{
+    width: number;
+    height: number;
+} | undefined>;

package/dist/types/behaviors/focus-guards.d.ts

@@ -0,0 +1,4 @@
+export declare function createGuard(): HTMLSpanElement;
+/** Radix `useFocusGuards`: two focusable spans at the body's edges while
+ *  any overlay that needs them is up. */
+export declare function useFocusGuards(): void;

package/dist/types/behaviors/focus-scope.d.ts

@@ -0,0 +1,20 @@
+import { type Accessor } from "solid-js";
+export declare function tabbables(container: HTMLElement): HTMLElement[];
+export declare function isHidden(node: HTMLElement | null, upTo: HTMLElement): boolean;
+export declare function focusEl(el: HTMLElement | null | undefined, select?: boolean): void;
+export declare function focusFirst(candidates: (HTMLElement | null | undefined)[], select?: boolean): void;
+export declare const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+export declare const AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+/** Radix `FocusScope` on `el`: auto focus on mount (the first tabbable, else
+ *  the container; `onMountAutoFocus` may prevent it), focus back on unmount
+ *  (`onUnmountAutoFocus` may prevent it), `trapped` keeps the focus inside,
+ *  `loop` wraps Tab. Returns the container's keydown handler. */
+export declare function createFocusScope(o: {
+    trapped: Accessor<boolean>;
+    loop: boolean;
+    onMountAutoFocus?: (e: Event) => void;
+    onUnmountAutoFocus?: (e: Event) => void;
+}): {
+    attach: (el: HTMLElement) => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/types/behaviors/grace-area.d.ts

@@ -0,0 +1,10 @@
+export type Point = {
+    x: number;
+    y: number;
+};
+/** Is the point inside the polygon (ray casting, Radix's `isPointInPolygon`)? */
+export declare function inPolygon(point: Point, polygon: Point[]): boolean;
+/** The convex hull of points (Andrew's monotone chain, Radix's `getHull`). */
+export declare function hull(points: Point[]): Point[];
+/** The grace area from the exit point to a hover target's box. */
+export declare function graceArea(exit: Point, from: DOMRect, to: DOMRect): Point[];

package/dist/types/behaviors/image-loading-status.d.ts

@@ -0,0 +1,4 @@
+export type LoadingStatus = `idle` | `loading` | `loaded` | `error`;
+/** Radix Avatar's `useImageLoadingStatus`: a detached `Image` probes the
+ *  src; the <img> paints only once it LOADED. */
+export declare function createImageLoadingStatus(src: () => string | undefined): () => LoadingStatus;

package/dist/types/behaviors/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./style-writer.js";
+export * from "./portal.js";
+export * from "./presence.js";
+export * from "./dismissable-layer.js";
+export * from "./focus-scope.js";
+export * from "./focus-guards.js";
+export * from "./scroll-lock.js";
+export * from "./modal.js";
+export * from "./popper.js";
+export * from "./grace-area.js";
+export * from "./visually-hidden.js";
+export * from "./typeahead.js";
+export * from "./menu.js";
+export * from "./roving-focus.js";
+export * from "./listbox.js";
+export * from "./picker-popover.js";
+export * from "./collapsible.js";
+export * from "./drag-to-dismiss.js";
+export * from "./element-size.js";
+export * from "./bubble-input.js";
+export * from "./slider.js";
+export * from "./image-loading-status.js";
+export * from "./search-match.js";

package/dist/types/behaviors/listbox.d.ts

@@ -0,0 +1,44 @@
+import { type Accessor } from "solid-js";
+export interface ListNavOptions {
+    count: Accessor<number>;
+    isDisabled?: (index: number) => boolean;
+    labelOf?: (index: number) => string;
+    onPick: (index: number) => void;
+    /** Type-ahead (off when a search field owns the keys). */
+    typeahead?: Accessor<boolean>;
+    initial?: number;
+}
+/** React's `useListNavigation`: an active option (aria-activedescendant,
+ *  focus stays where it is), ArrowUp/ArrowDown move it (wrapping, skipping
+ *  disabled), Home/End jump, Enter picks, printable keys type-ahead by label
+ *  when the list owns focus. */
+export declare function createListNavigation(o: ListNavOptions): {
+    active: Accessor<number>;
+    setActive: import("solid-js").Setter<number>;
+    onKeyDown: (e: KeyboardEvent) => void;
+};
+export interface ListNavSyncOptions {
+    count: Accessor<number>;
+    isDisabled?: (index: number) => boolean;
+    labelOf?: (index: number) => string;
+    onPick: (index: number) => void;
+    /** Type-ahead (off when a search field owns the keys). */
+    typeahead?: boolean;
+    initial?: number;
+}
+/** The TimePicker's variant of `createListNavigation`: `typeahead` is a
+ *  constant, the active index is clamped to the count SYNCHRONOUSLY
+ *  (`createComputed`, before the list renders) and `setActive` is a plain
+ *  setter (no updater function). React's `useListNavigation`: an active
+ *  option (aria-activedescendant, focus stays where it is), ArrowUp/ArrowDown
+ *  move it (wrapping, skipping disabled), Home/End jump, Enter picks,
+ *  printable keys type-ahead. */
+export declare function createListNavigationSync(o: ListNavSyncOptions): {
+    active: Accessor<number>;
+    setActive: (i: number) => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+};
+/** Radix Select: the keys that open the content from the trigger, and the
+ *  keys that pick the focused item. */
+export declare const OPEN_KEYS: string[];
+export declare const SELECTION_KEYS: string[];

package/dist/types/behaviors/menu.d.ts

@@ -0,0 +1,95 @@
+import { type Accessor, type JSX } from "solid-js";
+import type { VirtualElement } from "@floating-ui/dom";
+import { type OutsideEvent } from "./dismissable-layer.js";
+import { type Point } from "./grace-area.js";
+import { type Align, type Side } from "./popper.js";
+export declare function useKeyboardTracking(): void;
+/** One menu level's content (Radix `MenuContentImpl`): roving focus over its
+ *  items, typeahead, first/last keys, the pointer grace toward a submenu. */
+export interface MenuLevel {
+    content: () => HTMLElement | undefined;
+    highlighted: Accessor<HTMLElement | undefined>;
+    setHighlighted: (el: HTMLElement | undefined) => void;
+    tabStop: Accessor<HTMLElement | undefined>;
+    setTabStop: (el: HTMLElement | undefined) => void;
+    search: () => string;
+    onItemEnter: (e: PointerEvent) => boolean;
+    onItemLeave: (e: PointerEvent) => void;
+    onTriggerLeave: (e: PointerEvent) => boolean;
+    setGrace: (grace: {
+        area: Point[];
+        side: Side;
+    } | null) => void;
+}
+export declare const MenuLevelContext: import("solid-js").Context<MenuLevel | undefined>;
+export declare const FIRST_KEYS: string[];
+export declare const LAST_KEYS: string[];
+export declare const itemsOf: (content: HTMLElement | undefined) => HTMLElement[];
+export type MenuContentProps = {
+    anchor: Element | VirtualElement | null | undefined;
+    side: Side;
+    align: Align;
+    sideOffset: number;
+    alignOffset?: number;
+    /** The popper's collision padding (default `OVERLAY_PADDING`, the natives';
+     *  the primitive set passes Radix's 0). */
+    collisionPadding?: number;
+    /** A layer registered in this same mount pass is not visible to this
+     *  content's FIRST style (Radix's default-body portals: the outer layer
+     *  registers one commit after the nested content first renders), so its
+     *  `pointer-events` starts unset. The primitive set passes it. */
+    lagParentLayer?: boolean;
+    /** Root content: modal (trap, outside pointer events off, scroll lock,
+     *  aria-hidden), focus to the content on mount. */
+    root: boolean;
+    id?: string;
+    labelledBy?: string;
+    attrs: () => Record<string, unknown>;
+    state: () => string;
+    onDismiss: () => void;
+    onEscapeKeyDown?: (e: KeyboardEvent) => void;
+    onFocusOutside?: (e: OutsideEvent) => void;
+    onInteractOutside?: (e: OutsideEvent) => void;
+    onCloseAutoFocus: (e: Event) => void;
+    /** The reading direction (the popper wrapper's and the content's `dir`). */
+    dir: `ltr` | `rtl`;
+    /** The `--radix-<kind>-content-*` prefix: `dropdown-menu` or `context-menu`. */
+    kind: string;
+    onKeyDown?: (e: KeyboardEvent) => void;
+    setContent?: (el: HTMLElement | undefined) => void;
+    children: JSX.Element;
+};
+export declare function MenuContent(props: MenuContentProps): JSX.Element;
+/** The attributes + behaviour every menu row shares (Radix `MenuItemImpl` +
+ *  `RovingFocusGroupItem`): roving tabindex, `data-highlighted` while
+ *  focused, pointer highlight, arrow keys. */
+export declare function createMenuRow(disabled: Accessor<boolean>): {
+    attrs: () => Record<string, unknown>;
+    handlers: {
+        onFocus: () => void;
+        onBlur: () => void;
+        onPointerMove: (e: PointerEvent) => void;
+        onPointerLeave: (e: PointerEvent) => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+    ref: (node: HTMLElement) => HTMLElement;
+    level: MenuLevel;
+};
+/** A selectable row (Radix `MenuItem`): click / Enter / Space select it, a
+ *  press that started elsewhere selects on release; `onSelect` may prevent
+ *  the `close` (the root menu's). */
+export declare function createSelectable(disabled: Accessor<boolean>, onSelect: (e: Event) => void, close: () => void): {
+    handlers: {
+        onClick: () => void;
+        onPointerDown: () => boolean;
+        onPointerUp: (e: PointerEvent) => void;
+        onKeyDown: (e: KeyboardEvent) => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        onPointerMove: (e: PointerEvent) => void;
+        onPointerLeave: (e: PointerEvent) => void;
+    };
+    attrs: () => Record<string, unknown>;
+    ref: (node: HTMLElement) => HTMLElement;
+    level: MenuLevel;
+};

package/dist/types/behaviors/modal.d.ts

@@ -0,0 +1,3 @@
+/** Radix's modal content: the rest of the page `aria-hidden` (live regions
+ *  and scripts kept), the focus guards, the scroll lock. */
+export declare function useModalEffects(el: HTMLElement, lockScroll: boolean): void;

package/dist/types/behaviors/picker-popover.d.ts

@@ -0,0 +1,22 @@
+import { type JSX } from "solid-js";
+export interface PickerPopoverProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    trigger: () => HTMLElement | undefined;
+    contentId: string;
+    /** The content's own attributes (the part, role, aria-label, overlay…). */
+    attrs: Record<string, unknown>;
+    /** Radix's `onOpenAutoFocus` (the default prevented): where focus goes. */
+    onOpenAutoFocus: (content: HTMLElement) => void;
+    onPointerOver?: (e: PointerEvent) => void;
+    onFocusIn?: (e: FocusEvent) => void;
+    /** The surface's overlay layer (the portal's mount) and reading direction. */
+    portal: HTMLElement | null;
+    dir: `ltr` | `rtl`;
+    children: JSX.Element;
+}
+/** PopoverPrimitive.Portal + Content (align start, `OVERLAY_OFFSET`,
+ *  `OVERLAY_PADDING`), non-modal, inside Radix's `Presence`: a close keeps
+ *  the content (`data-state="closed"`) mounted while its exit animation
+ *  runs, then unmounts it. */
+export declare function PickerPopover(props: PickerPopoverProps): JSX.Element;

package/dist/types/behaviors/popper.d.ts

@@ -0,0 +1,49 @@
+import { type Accessor, type JSX } from "solid-js";
+import { type Middleware, type VirtualElement } from "@floating-ui/dom";
+import { type StyleObject } from "./style-writer.js";
+export type Side = `top` | `right` | `bottom` | `left`;
+export type Align = `start` | `center` | `end`;
+/** Radix Popper's `transformOrigin` middleware (no arrow: always hidden). */
+export declare const transformOrigin: Middleware;
+export interface PopperState {
+    placedSide: Accessor<Side>;
+    placedAlign: Accessor<Align>;
+    isPositioned: Accessor<boolean>;
+    /** The content element (its computed `z-index` goes on the wrapper). */
+    setContent: (el: HTMLElement) => void;
+}
+/** Radix `PopperContent`: the `data-radix-popper-content-wrapper` (fixed,
+ *  translated, `min-width: max-content`, the content's z-index, the
+ *  `--radix-popper-*` variables) around the content `children(state)`.
+ *  Placement = floating-ui with Radix's middleware, auto-updated. */
+export declare function Popper(props: {
+    anchor: Element | VirtualElement | null | undefined;
+    side: Side;
+    align: Align;
+    sideOffset: number;
+    alignOffset?: number;
+    collisionPadding: number;
+    dir?: string;
+    children: (state: PopperState) => JSX.Element;
+}): JSX.Element;
+/** The content's own style the way Radix composes it: `prefix` (a menu's
+ *  `outline`), the dismissable layer's `pointer-events`, the popper's
+ *  `--radix-<kind>-*` variables, then `animation: none` until placed. */
+export declare function popperContentStyle(kind: string, trigger: string, pointerEvents: string | undefined, positioned: boolean, prefix?: StyleObject): StyleObject;
+export interface Placed {
+    side: string;
+    align: string;
+    positioned: boolean;
+}
+/** Radix's PopperContent: the fixed wrapper (`data-radix-popper-content-
+ *  wrapper`, floating-ui's translate, `--radix-popper-*`), the content's
+ *  placed side/align. `content` renders the content element. */
+export declare function popperWrapper(opts: {
+    anchor: () => HTMLElement | undefined;
+    sideOffset: number;
+    align: `start` | `center` | `end`;
+    collisionPadding: number;
+    dir?: () => `ltr` | `rtl` | `auto` | undefined;
+    onPlaced?: () => void;
+    content: (placed: Accessor<Placed>, ref: (el: HTMLElement) => void) => JSX.Element;
+}): HTMLElement;

package/dist/types/behaviors/portal.d.ts

@@ -0,0 +1,11 @@
+import { type JSX } from "solid-js";
+/** A portal WITHOUT a wrapper (Solid's `<Portal>` adds a `<div>`, Radix's
+ *  appends the content itself): the children are inserted before an empty
+ *  text marker appended to `mount`, in mount order. */
+export declare function LayerPortal(props: {
+    mount: HTMLElement | null;
+    children: JSX.Element;
+}): JSX.Element;
+/** Mounts `el` at the end of `container` while the owner lives (Radix's
+ *  Portal: no wrapper element, unlike Solid's <Portal>). */
+export declare function mountIn(container: HTMLElement, el: Node): void;

package/dist/types/behaviors/presence.d.ts

@@ -0,0 +1,7 @@
+import { type Accessor } from "solid-js";
+/** Radix `Presence`: mounted while `present`, and on close until the exit
+ *  animation the closed state starts has ended (none = at once). */
+export declare function createPresence(present: Accessor<boolean>): {
+    mounted: Accessor<boolean>;
+    ref: (el: HTMLElement) => void;
+};

package/dist/types/behaviors/roving-focus.d.ts

@@ -0,0 +1,30 @@
+export type Intent = `first` | `last` | `prev` | `next`;
+export declare const KEY_INTENT: Record<string, Intent>;
+export declare function focusIntent(e: KeyboardEvent, orientation: `horizontal` | `vertical` | undefined, dir: `ltr` | `rtl`): Intent | undefined;
+/** Radix RovingFocusGroup's `focusFirst`: the first candidate that takes
+ *  focus (a candidate already focused stops the walk). */
+export declare function rovingFocusFirst(candidates: (HTMLElement | null | undefined)[]): void;
+/** Radix's RovingFocusGroup: the group's own attributes + handlers, and
+ *  each item's. `items()` = the item elements in order, `focusable(el)`,
+ *  `active(el)` = the selected one (the group's entry focus). */
+export declare function createRovingGroup(opts: {
+    orientation?: `horizontal` | `vertical`;
+    dir: () => `ltr` | `rtl`;
+    loop: boolean;
+    items: () => HTMLElement[];
+    focusable: (el: HTMLElement) => boolean;
+    active: (el: HTMLElement) => boolean;
+}): {
+    group: () => Record<string, unknown>;
+    groupHandlers: {
+        onMouseDown: () => undefined;
+        onFocusIn: (e: FocusEvent) => void;
+        onFocusOut: () => false;
+    };
+    item: (el: () => HTMLElement | undefined, focusable: () => boolean) => {
+        tabindex: () => 0 | -1;
+        onMouseDown: (e: MouseEvent) => void;
+        onFocus: () => HTMLElement | null;
+        onKeyDown: (e: KeyboardEvent) => void;
+    };
+};

package/dist/types/behaviors/scroll-lock.d.ts

@@ -0,0 +1,4 @@
+export declare const LOCK_ATTRIBUTE = "data-scroll-locked";
+/** react-remove-scroll-bar's body lock (the same sheet, the same counter
+ *  attribute) while a modal overlay is up. */
+export declare function useScrollLock(): void;

package/dist/types/behaviors/search-match.d.ts

@@ -0,0 +1,6 @@
+/** Does a row match the query (case-insensitive, label or identifier)?
+ *  The core's `search_matches`. */
+export declare function searchMatches(item: {
+    label?: unknown;
+    identifier?: unknown;
+}, query: string): boolean;

package/dist/types/behaviors/slider.d.ts

@@ -0,0 +1,8 @@
+export declare const PAGE_KEYS: string[];
+export declare const BACK_KEYS: Record<`from-left` | `from-right`, string[]>;
+export declare const linearScale: (input: [number, number], output: [number, number]) => (v: number) => number;
+export declare const decimalCount: (v: number) => number;
+export declare const roundValue: (v: number, decimals: number) => number;
+export declare const clampTo: (v: number, [lo, hi]: [number, number]) => number;
+export declare const percentOf: (v: number, min: number, max: number) => number;
+export declare const inBoundsOffset: (width: number, left: number, direction: number) => number;

package/dist/types/behaviors/style-writer.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from "solid-js";
+export type StyleObject = Record<string, string | undefined>;
+/** React's `setValueForStyles(node, next, prev)` (kebab-case keys): a key
+ *  gone from `next` is cleared, a changed one is written; an existing
+ *  declaration keeps its place in the `style` attribute, a new one appends. */
+export declare function styleWriter(el: HTMLElement): (next: StyleObject) => void;
+/** Write `style()` with React's semantics on `el`, first now, then on change. */
+export declare function bindStyle(el: HTMLElement, style: Accessor<StyleObject>): void;

package/dist/types/behaviors/typeahead.d.ts

@@ -0,0 +1,11 @@
+export declare const wrapArray: <T>(array: T[], start: number) => T[];
+export declare function getNextMatch(values: string[], search: string, currentMatch?: string): string | undefined;
+/** Radix's Select type-ahead: a 1 s buffer, a repeated letter cycles. */
+export declare function radixTypeahead(onSearch: (search: string) => void): {
+    readonly search: string;
+    type: (key: string) => void;
+    reset: () => void;
+};
+export declare function findNextItem<T extends {
+    label: string;
+}>(items: T[], search: string, current: T | undefined): T | undefined;

package/dist/types/behaviors/visually-hidden.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from "solid-js";
+/** Radix `VisuallyHidden` with `role="tooltip"` (its inline style, in its order). */
+export declare function VisuallyHidden(props: {
+    id: string;
+    children: JSX.Element;
+}): JSX.Element;

package/dist/types/bind-attrs.d.ts

@@ -0,0 +1,4 @@
+type Bag = Record<string, unknown>;
+/** Bind `bag()` onto `el` (call it from a `ref`: inside the row's owner). */
+export declare function bindAttrs(el: Element, bag: () => Bag | undefined): void;
+export {};