Skip to main content
On this pageConstants

Ui/Combobox/test

Constants

Anchor

constsource
/**
 * The anchor-positioning Mount this Combobox renders on its items panel.
 *  The panel is always anchored to the input wrapper via Floating UI and
 *  portaled to the document body, or into the enclosing `<dialog>` when
 *  there is one (opt out of portaling with `anchor.portal: false`), so it
 *  escapes ancestor stacking contexts and overflow clipping. The Mount also
 *  installs the `pointerdown`-cancelling capture listener that prevents
 *  input blur on item presses. Exposed so Scene tests can call
 *  `Scene.Mount.resolve(Anchor, CompletedAnchor())`.
 */
const Anchor: LayeredMountDefinitionWithArgs<"Combobox/Anchor", {
  anchor: Struct<{
    gap: optional<Number>
    isPlacementLocked: optional<Boolean>
    offset: optional<Number>
    padding: optional<Union<readonly [
      Number,
      Struct<{
        bottom: optionalKey<unknown>
        left: optionalKey<unknown>
        right: optionalKey<unknown>
        top: optionalKey<unknown>
      }>
    ]>>
    placement: optional<Literals<readonly ["top", "right", "bottom", "left", "top-start", "top-end", "right-start", "right-end", "bottom-start", "bottom-end", "left-start", "left-end"]>>
    portal: optional<Boolean>
  }>
  buttonId: String
}, {
  _tag: "CompletedAnchor"
}> & Readonly<{
  layer: Layer<Handler<"Combobox/Anchor", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }> & {
    anchor: Anchor.AnchorConfig
    buttonId: string
  }, {
    _tag: "CompletedAnchor"
  }>, never, never>
}>

AttachPreventBlur

constsource
/**
 * The Mount this Combobox renders to install a `pointerdown`-cancelling
 *  capture listener that prevents blur on item presses. Exposed so Scene
 *  tests can call
 *  `Scene.Mount.resolve(AttachPreventBlur, CompletedAttachPreventBlur())`.
 */
const AttachPreventBlur: LayeredMountDefinitionNoArgs<"Combobox/AttachPreventBlur", {
  _tag: "CompletedAttachPreventBlur"
}> & Readonly<{
  layer: Layer<Handler<"Combobox/AttachPreventBlur", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }>, {
    _tag: "CompletedAttachPreventBlur"
  }>, never, never>
}>

AttachSelectOnFocus

constsource
/**
 * The Mount this Combobox renders to install the input's select-on-focus
 *  behavior. Exposed so Scene tests can call
 *  `Scene.Mount.resolve(AttachSelectOnFocus, CompletedAttachSelectOnFocus())`.
 */
const AttachSelectOnFocus: LayeredMountDefinitionNoArgs<"Combobox/AttachSelectOnFocus", {
  _tag: "CompletedAttachSelectOnFocus"
}> & Readonly<{
  layer: Layer<Handler<"Combobox/AttachSelectOnFocus", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }>, {
    _tag: "CompletedAttachSelectOnFocus"
  }>, never, never>
}>

ClickItem

constsource
/** Programmatically clicks the active combobox item's DOM element. */
const ClickItem: LayeredCommandDefinitionWithArgs<"Combobox/ClickItem", {
  id: String
  index: Number
}, {
  _tag: "CompletedClickItem"
}> | DefinitionWithArgsNameKeyed<"Combobox/ClickItem", {
  id: String
  index: Number
}, Effect<{
  _tag: "CompletedClickItem"
}, never, Handler<"Combobox/ClickItem", {
  id: string
  index: number
}, {
  _tag: "CompletedClickItem"
}>>> | DefinitionWithArgs<"Combobox/ClickItem", {
  id: String
  index: Number
}, Pick<{
  id: string
  index: number
}, "id" | "index">, Effect<{
  _tag: "CompletedClickItem"
}, never, Handler<"Combobox/ClickItem", {
  id: string
  index: number
}, {
  _tag: "CompletedClickItem"
}>>> & Readonly<{
  layer: Layer<Handler<"Combobox/ClickItem", {
    id: string
    index: number
  }, {
    _tag: "CompletedClickItem"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/ClickItem", {
    id: string
    index: number
  }, {
    _tag: "CompletedClickItem"
  }>
}>

DetectMovementOrAnimationEnd

constsource
/** Detects whether the combobox input wrapper moved or the leave animation ended. Whichever comes first; both outcomes signal the Animation block that leave is complete. */
const DetectMovementOrAnimationEnd: LayeredCommandDefinitionWithArgs<"Combobox/DetectMovementOrAnimationEnd", {
  generation: Number
  id: String
}, {
  _tag: "CompletedDetectMovementOrAnimationEnd"
  generation: number
}> | DefinitionWithArgsNameKeyed<"Combobox/DetectMovementOrAnimationEnd", {
  generation: Number
  id: String
}, Effect<{
  _tag: "CompletedDetectMovementOrAnimationEnd"
  generation: number
}, never, Handler<"Combobox/DetectMovementOrAnimationEnd", {
  generation: number
  id: string
}, {
  _tag: "CompletedDetectMovementOrAnimationEnd"
  generation: number
}>>> | DefinitionWithArgs<"Combobox/DetectMovementOrAnimationEnd", {
  generation: Number
  id: String
}, Pick<{
  generation: number
  id: string
}, "id" | "generation">, Effect<{
  _tag: "CompletedDetectMovementOrAnimationEnd"
  generation: number
}, never, Handler<"Combobox/DetectMovementOrAnimationEnd", {
  generation: number
  id: string
}, {
  _tag: "CompletedDetectMovementOrAnimationEnd"
  generation: number
}>>> & Readonly<{
  layer: Layer<Handler<"Combobox/DetectMovementOrAnimationEnd", {
    generation: number
    id: string
  }, {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/DetectMovementOrAnimationEnd", {
    generation: number
    id: string
  }, {
    _tag: "CompletedDetectMovementOrAnimationEnd"
    generation: number
  }>
}>

FocusInput

constsource
/** Moves focus to the combobox input after selection or close. */
const FocusInput: LayeredCommandDefinitionWithArgs<"Combobox/FocusInput", {
  id: String
}, {
  _tag: "CompletedFocusInput"
}> | DefinitionWithArgsNameKeyed<"Combobox/FocusInput", {
  id: String
}, Effect<{
  _tag: "CompletedFocusInput"
}, never, Handler<"Combobox/FocusInput", {
  id: string
}, {
  _tag: "CompletedFocusInput"
}>>> | DefinitionWithArgs<"Combobox/FocusInput", {
  id: String
}, Pick<{
  id: string
}, "id">, Effect<{
  _tag: "CompletedFocusInput"
}, never, Handler<"Combobox/FocusInput", {
  id: string
}, {
  _tag: "CompletedFocusInput"
}>>> & Readonly<{
  layer: Layer<Handler<"Combobox/FocusInput", {
    id: string
  }, {
    _tag: "CompletedFocusInput"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/FocusInput", {
    id: string
  }, {
    _tag: "CompletedFocusInput"
  }>
}>

InertOthers

constsource
/** Marks all elements outside the combobox as inert for modal behavior. */
const InertOthers: LayeredCommandDefinitionWithArgs<"Combobox/InertOthers", {
  id: String
}, {
  _tag: "CompletedInertOthers"
}> | DefinitionWithArgsNameKeyed<"Combobox/InertOthers", {
  id: String
}, Effect<{
  _tag: "CompletedInertOthers"
}, never, Handler<"Combobox/InertOthers", {
  id: string
}, {
  _tag: "CompletedInertOthers"
}>>> | DefinitionWithArgs<"Combobox/InertOthers", {
  id: String
}, Pick<{
  id: string
}, "id">, Effect<{
  _tag: "CompletedInertOthers"
}, never, Handler<"Combobox/InertOthers", {
  id: string
}, {
  _tag: "CompletedInertOthers"
}>>> & Readonly<{
  layer: Layer<Handler<"Combobox/InertOthers", {
    id: string
  }, {
    _tag: "CompletedInertOthers"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/InertOthers", {
    id: string
  }, {
    _tag: "CompletedInertOthers"
  }>
}>

LockScroll

constsource
/** Prevents page scrolling while the combobox popup is open in modal mode. */
const LockScroll: LayeredCommandDefinitionNoArgs<"Combobox/LockScroll", {
  _tag: "CompletedLockScroll"
}> | DefinitionNoArgs<"Combobox/LockScroll", Effect<{
  _tag: "CompletedLockScroll"
}, never, Handler<"Combobox/LockScroll", void, {
  _tag: "CompletedLockScroll"
}>>> & Readonly<{
  toLayer: ToLayer<"Combobox/LockScroll", void, {
    _tag: "CompletedLockScroll"
  }>
}> & Readonly<{
  layer: Layer<Handler<"Combobox/LockScroll", void, {
    _tag: "CompletedLockScroll"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/LockScroll", void, {
    _tag: "CompletedLockScroll"
  }>
}>

PortalBackdrop

constsource
/**
 * The backdrop-portaling Mount this Combobox renders. Exposed so Scene tests can
 *  call `Scene.Mount.resolve(PortalBackdrop, CompletedPortalBackdrop())` to
 *  acknowledge the mount produced by the rendered backdrop.
 */
const PortalBackdrop: LayeredMountDefinitionNoArgs<"Combobox/PortalBackdrop", {
  _tag: "CompletedPortalBackdrop"
}> & Readonly<{
  layer: Layer<Handler<"Combobox/PortalBackdrop", Readonly<{
    element: Element
    viewStateChanges: Stream<"Live" | "Paused">
  }>, {
    _tag: "CompletedPortalBackdrop"
  }>, never, never>
}>

RestoreInert

constsource
/** Removes the inert attribute from elements outside the combobox. */
const RestoreInert: LayeredCommandDefinitionWithArgs<"Combobox/RestoreInert", {
  id: String
}, {
  _tag: "CompletedRestoreInert"
}> | DefinitionWithArgsNameKeyed<"Combobox/RestoreInert", {
  id: String
}, Effect<{
  _tag: "CompletedRestoreInert"
}, never, Handler<"Combobox/RestoreInert", {
  id: string
}, {
  _tag: "CompletedRestoreInert"
}>>> | DefinitionWithArgs<"Combobox/RestoreInert", {
  id: String
}, Pick<{
  id: string
}, "id">, Effect<{
  _tag: "CompletedRestoreInert"
}, never, Handler<"Combobox/RestoreInert", {
  id: string
}, {
  _tag: "CompletedRestoreInert"
}>>> & Readonly<{
  layer: Layer<Handler<"Combobox/RestoreInert", {
    id: string
  }, {
    _tag: "CompletedRestoreInert"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/RestoreInert", {
    id: string
  }, {
    _tag: "CompletedRestoreInert"
  }>
}>

ScrollItemIntoView

constsource
/** Scrolls the active combobox item into view after keyboard navigation. */
const ScrollItemIntoView: LayeredCommandDefinitionWithArgs<"Combobox/ScrollItemIntoView", {
  id: String
  index: Number
}, {
  _tag: "CompletedScrollItemIntoView"
}> | DefinitionWithArgsNameKeyed<"Combobox/ScrollItemIntoView", {
  id: String
  index: Number
}, Effect<{
  _tag: "CompletedScrollItemIntoView"
}, never, Handler<"Combobox/ScrollItemIntoView", {
  id: string
  index: number
}, {
  _tag: "CompletedScrollItemIntoView"
}>>> | DefinitionWithArgs<"Combobox/ScrollItemIntoView", {
  id: String
  index: Number
}, Pick<{
  id: string
  index: number
}, "id" | "index">, Effect<{
  _tag: "CompletedScrollItemIntoView"
}, never, Handler<"Combobox/ScrollItemIntoView", {
  id: string
  index: number
}, {
  _tag: "CompletedScrollItemIntoView"
}>>> & Readonly<{
  layer: Layer<Handler<"Combobox/ScrollItemIntoView", {
    id: string
    index: number
  }, {
    _tag: "CompletedScrollItemIntoView"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/ScrollItemIntoView", {
    id: string
    index: number
  }, {
    _tag: "CompletedScrollItemIntoView"
  }>
}>

UnlockScroll

constsource
/** Re-enables page scrolling after the combobox popup closes. */
const UnlockScroll: LayeredCommandDefinitionNoArgs<"Combobox/UnlockScroll", {
  _tag: "CompletedUnlockScroll"
}> | DefinitionNoArgs<"Combobox/UnlockScroll", Effect<{
  _tag: "CompletedUnlockScroll"
}, never, Handler<"Combobox/UnlockScroll", void, {
  _tag: "CompletedUnlockScroll"
}>>> & Readonly<{
  toLayer: ToLayer<"Combobox/UnlockScroll", void, {
    _tag: "CompletedUnlockScroll"
  }>
}> & Readonly<{
  layer: Layer<Handler<"Combobox/UnlockScroll", void, {
    _tag: "CompletedUnlockScroll"
  }>, never, never>
}> & Readonly<{
  toLayer: ToLayer<"Combobox/UnlockScroll", void, {
    _tag: "CompletedUnlockScroll"
  }>
}>