@aihu/primitives

function createCollection()

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

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

Create a context token.

function defineCheckbox()

Register all checkbox custom elements (idempotent).

function defineCollection(tag = "aihu-collection")

Register `<aihu-collection>` (idempotent).

function defineConfigProvider(tag = "aihu-config-provider")

Register `<aihu-config-provider>` (idempotent).

function defineInput(tag = "aihu-input")

Register `<aihu-input>` (idempotent).

function defineLabel(tag = "aihu-label")

Register `<aihu-label>` (idempotent).

function definePresenceGate(tag = "aihu-presence-gate")

Register `<aihu-presence-gate>` (idempotent — safe to call repeatedly).

function defineRadioGroup()

Register all radio-group custom elements (idempotent).

function defineRovingFocus(tag = "aihu-roving-focus")

Register `<aihu-roving-focus>` (idempotent).

function defineSeparator(tag = "aihu-separator")

Register `<aihu-separator>` (idempotent).

function defineSwitch()

Register all switch custom elements (idempotent).

function defineTextarea(tag = "aihu-textarea")

Register `<aihu-textarea>` (idempotent).

function defineTooltip(prefix = "aihu")

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 AihuButton

const AihuCheckboxIndicator

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

const AihuCheckboxRoot

const AihuCollection

const AihuConfigProvider

const AihuDialogBackdrop

const AihuDialogClose

const AihuDialogContent

const AihuDialogDescription

const AihuDialogRoot

const AihuDialogTitle

const AihuDialogTrigger

const AihuFormControl

const AihuInput

const AihuLabel

const AihuPresenceGate

const AihuRadioGroupIndicator

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

const AihuRadioGroupItem

const AihuRadioGroupRoot

const AihuRovingFocus

`<aihu-roving-focus>` — WAI-ARIA roving-tabindex container.

const AihuSeparator

`<aihu-separator>` — headless separator (WAI-ARIA APG Separator, static variant).

const AihuSwitchRoot

const AihuSwitchThumb

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

const AihuTextarea

const AihuTextControlBase

const AihuTooltipContent

const AihuTooltipRoot

const AihuTooltipTrigger

const attachHiddenInput

const ButtonType

const checkboxContext

Headless checkbox — `<aihu-checkbox-root>` (state owner) + presentational `<aihu-checkbox-indicator>`.

const collectionContext

`<aihu-collection>` — descendant-registration substrate (the Radix `Collection` pattern) implemented over the DOM-walk context.

const configContext

`<aihu-config-provider>` — app-level config propagated via reactive DOM context.

const createFocusTrap

const defineButton

const defineDialog

const defineFormControl

const dialogContext

const DialogContextValue

const FocusTrap

const formControlContext

const FormControlContextValue

const HiddenInputOptions

const presenceContext

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

const radioGroupContext

Headless radio group — `<aihu-radio-group-root>` (state owner, EXTENDS `AihuRovingFocus`) + `<aihu-radio-group-item>` (role="radio") + presentational `<aihu-radio-group-indicator>`.

const radioGroupItemContext

const switchContext

Headless switch — `<aihu-switch-root>` (state owner) + presentational `<aihu-switch-thumb>`.

const tooltipContext

Headless tooltip — `<aihu-tooltip-root>` + `<aihu-tooltip-trigger>` + `<aihu-tooltip-content>`.

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 DomContext<T> {
  readonly _key: symbol
  readonly _name: string
  readonly _default: T | undefined
}

Opaque token identifying a context slot.

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 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 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';