@aihu/primitives

function attachHiddenInput(host: HTMLElement, opts: HiddenInputOptions): () => void

Attach a visually-hidden native input to `host`, kept in sync with the provided signals by a single effect.

function createCollection(): CollectionContextValue

The registration mechanism, usable standalone (roving-focus reuses it).

function createDomContext<T>(name: string, defaultValue?: T): DomContext<T>

Create a context token.

function createFocusTrap(container: Element, options: FocusTrapOptions = {}): FocusTrap

function defineButton(tag: string): typeof AihuButton

Register a concrete button tag backed by `AihuButton` (idempotent).

function defineCheckbox(): void

Register all checkbox custom elements (idempotent; a no-op without a DOM).

function defineCollection(tag = 'aihu-collection'): void

Register `<aihu-collection>` (idempotent; a no-op without a DOM).

function defineConfigProvider(tag = 'aihu-config-provider'): void

Register `<aihu-config-provider>` (idempotent; a no-op without a DOM).

function defineDialog(prefix = 'aihu'): void

Register all dialog custom elements under `<prefix>-dialog-*` (idempotent per prefix).

function defineFormControl(tag = 'aihu-form-control'): void

Register `<aihu-form-control>` (idempotent; a no-op without a DOM).

function defineInput(tag = 'aihu-input'): void

Register `<aihu-input>` (idempotent; a no-op without a DOM).

function defineLabel(tag = 'aihu-label'): void

Register `<aihu-label>` (idempotent; a no-op without a DOM).

function definePopover(prefix = 'aihu'): void

Register all popover custom elements under `<prefix>-popover-*` (idempotent per prefix).

function definePresenceGate(tag = 'aihu-presence-gate'): void

Register `<aihu-presence-gate>` (idempotent — safe to call repeatedly; a no-op without a DOM).

function defineRadioGroup(): void

Register all radio-group custom elements (idempotent; a no-op without a DOM).

function defineRovingFocus(tag = 'aihu-roving-focus'): void

Register `<aihu-roving-focus>` (idempotent; a no-op without a DOM).

function defineSeparator(tag = 'aihu-separator'): void

Register `<aihu-separator>` (idempotent; a no-op without a DOM).

function defineSlider(): void

Register all slider custom elements (idempotent; a no-op without a DOM).

function defineSwitch(): void

Register all switch custom elements (idempotent; a no-op without a DOM).

function defineTextarea(tag = 'aihu-textarea'): void

Register `<aihu-textarea>` (idempotent; a no-op without a DOM).

function defineTooltip(prefix = 'aihu'): void

Register all tooltip custom elements under `<prefix>-tooltip-*` (idempotent per prefix).

function injectContext<T>(from: Element, ctx: DomContext<T>): T | Read<T>

Resolve `ctx` for `from` by walking UP the DOM from `from.parentNode`, crossing `ShadowRoot` boundaries (`ShadowRoot → .host`), nearest-wins.

function injectValue<T>(from: Element, ctx: DomContext<T>): T

Like `injectContext`, but for the common case where a context carries a raw (non-signal) value — typically an object whose fields are themselves signals.

function provideContext<T>(host: Element, ctx: DomContext<T>, value: T | Read<T>): void

Provide `value` for `ctx` on `host`.

const checkboxContext

const collectionContext

const configContext

const dialogContext

const formControlContext

const HTMLElementBase: typeof HTMLElement

`HTMLElement` in a DOM; an inert, throw-on-construct placeholder elsewhere.

const popoverContext

const presenceContext

Context carrying the gate's `present` signal to descendants.

const radioGroupContext

const radioGroupItemContext

const sliderContext

const switchContext

const tooltipContext

class AihuButton extends HTMLElementBase

class AihuCheckboxIndicator extends HTMLElementBase

Presentational styling hook: mirrors the root's state, hidden from AT.

class AihuCheckboxRoot extends HTMLElementBase

class AihuCollection extends HTMLElementBase

class AihuConfigProvider extends HTMLElementBase

class AihuDialogBackdrop extends DialogPiece

class AihuDialogClose extends DialogPiece

class AihuDialogContent extends DialogPiece

class AihuDialogDescription extends DialogPiece

class AihuDialogRoot extends HTMLElementBase

class AihuDialogTitle extends DialogPiece

class AihuDialogTrigger extends DialogPiece

class AihuFormControl extends HTMLElementBase

class AihuInput extends AihuTextControlBase

class AihuLabel extends HTMLElementBase

class AihuPopoverContent extends PopoverPiece

class AihuPopoverRoot extends HTMLElementBase

class AihuPopoverTrigger extends PopoverPiece

class AihuPresenceGate extends HTMLElementBase

class AihuRadioGroupIndicator extends HTMLElementBase

Presentational styling hook: mirrors its enclosing ITEM's state (nearest `radioGroupItemContext` provider), hidden from AT.

class AihuRadioGroupItem extends HTMLElementBase

class AihuRadioGroupRoot extends AihuRovingFocus

class AihuRovingFocus extends HTMLElementBase

class AihuSeparator extends HTMLElementBase

class AihuSliderRoot extends HTMLElementBase

class AihuSwitchRoot extends HTMLElementBase

class AihuSwitchThumb extends HTMLElementBase

Presentational styling hook: mirrors the root's state, hidden from AT.

class AihuTextarea extends AihuTextControlBase

abstract class AihuTextControlBase extends HTMLElementBase

class AihuTooltipContent extends HTMLElementBase

class AihuTooltipRoot extends HTMLElementBase

class AihuTooltipTrigger extends HTMLElementBase

class MissingContextError extends Error

Thrown by `injectContext` when no provider is found and the token has no default.

interface CheckboxContextValue {
  readonly state: Read<CheckboxState>
  readonly disabled: Read<boolean>
}

interface CollectionContextValue {
  /** Register `el`; returns a disposer that unregisters it. */
  register(el: Element): () => void
  /** Registered descendants, kept in DOM order. */
  readonly items: Read<Element[]>
}

interface ConfigContextValue {
  readonly colorScheme: Read<ColorScheme>
  readonly density: Read<Density>
  readonly dir: Read<Direction>
}

interface DialogContextValue {
  readonly open: Read<boolean>
  readonly modal: Read<boolean>
  readonly contentId: Read<string>
  readonly titleId: Read<string | null>
  readonly descriptionId: Read<string | null>
  setTitleId(id: string): void
  setDescriptionId(id: string): void
  setOpen(next: boolean): void
  close(): void
  toggle(): void
}

interface DomContext<T> {
  readonly _key: symbol
  readonly _name: string
  readonly _default: T | undefined
}

Opaque token identifying a context slot.

interface FocusTrap {
  activate(): void
  deactivate(): void
}

interface FocusTrapOptions {
  /**
   * CSS selector, resolved against the container's COMPOSED subtree (so it can
   * match into a nested open shadow root), naming the element to focus on
   * `activate()`. Falls back to the first tabbable — the default behavior —
   * when absent or when the selector matches nothing.
   */
  initialFocus?: string | null
  /**
   * Restore focus to whatever was focused before `activate()` when the trap is
   * deactivated. Defaults to `true`; pass `false` to opt out (the trap then
   * leaves focus wherever it currently is).
   */
  returnFocus?: boolean
}

interface FormControlContextValue {
  readonly disabled: Read<boolean>
  readonly required: Read<boolean>
  readonly invalid: Read<boolean>
  readonly controlId: Read<string>
  readonly describedById: Read<string | null>
  readonly labelId: Read<string | null>
}

interface HiddenInputOptions {
  type: 'checkbox' | 'radio'
  name: Read<string | null>
  value: Read<string>
  checked: Read<boolean>
  required: Read<boolean>
  disabled: Read<boolean>
}

interface PopoverContextValue {
  readonly open: Read<boolean>
  readonly contentId: Read<string>
  readonly placement: Read<Placement>
  /** Resolved position written by the content after each `position()` call. */
  readonly coords: Read<PopoverCoords | null>
  setCoords(next: PopoverCoords): void
  /** Programmatic write — signal + reflected attribute, does NOT emit. */
  setOpen(next: boolean): void
  /** User-driven toggle (trigger click / Enter / Space) — emits. */
  toggle(): void
  /** User-driven close WITHOUT returning focus (outside pointerdown). */
  close(): void
  /** User-driven close that RETURNS focus to the trigger (Escape). */
  dismiss(): void
  registerTrigger(el: Element): void
  registerContent(el: Element): void
  triggerEl(): Element | null
}

interface PopoverCoords {
  x: number
  y: number
  placement: Placement
}

The position the shim actually applied (post viewport-collision flip).

interface RadioGroupContextValue {
  /** Currently selected item value; null when nothing is selected. */
  readonly value: Read<string | null>
  /** Group-effective disabled (own attribute ∥ inherited form-control). */
  readonly disabled: Read<boolean>
  readonly required: Read<boolean>
  /** Programmatic write: signal + reflected `value` attribute. NO event. */
  setValue(next: string | null): void
  /** USER-driven selection of `item` (click path): moves the tab stop to the
   * item WITHOUT stealing focus, selects its value, emits `value-change`. */
  selectItem(item: Element): void
}

interface RadioGroupItemContextValue {
  readonly checked: Read<boolean>
  readonly disabled: Read<boolean>
}

Per-item context so `<aihu-radio-group-indicator>` mirrors its OWN item (nearest-provider-wins walk lands on the enclosing item, not the root).

interface SliderContextValue {
  readonly value: Read<number>
  readonly min: Read<number>
  readonly max: Read<number>
  readonly step: Read<number>
  readonly disabled: Read<boolean>
}

interface SwitchContextValue {
  readonly checked: Read<boolean>
  readonly disabled: Read<boolean>
}

interface TooltipContextValue {
  readonly open: Read<boolean>
  readonly contentId: Read<string>
  readonly placement: Read<Placement>
  readonly openDelay: Read<number>
  readonly closeDelay: Read<number>
  setOpen(next: boolean): void
  /** Schedule open/close honoring the configured delays. */
  scheduleOpen(): void
  scheduleClose(): void
  /** Immediate dismiss (Escape). */
  dismiss(): void
  registerTrigger(el: Element): void
  triggerEl(): Element | null
}

interface TooltipCoords {
  x: number
  y: number
  placement: Placement
}

type ButtonType = 'button' | 'submit' | 'reset'

type CheckboxState = 'checked' | 'unchecked' | 'indeterminate'

type ColorScheme = 'light' | 'dark' | 'system'

type Density = 'comfortable' | 'compact'

type Direction = 'ltr' | 'rtl'

type Orientation = 'horizontal' | 'vertical' | 'both'

type SeparatorOrientation = 'horizontal' | 'vertical'