grassroot
Install

DocsAPI referenceHeadlessradio

radio headless API

The core connector and vanilla mount are always visible. Use the framework choice to inspect native composition, props, outputs, context and hooks for the selected adapter.

Machine APIPlatform contract

@grassroot/ui-headless-core/radio

Core connector and vanilla API

23 exports
View source packages/ui-headless/core/src/radio/index.ts

activateRadioGroup

function
DeclarationView source
activateRadioGroupts
declare function activateRadioGroup(service: RadioGroupService, scope: PartScope, options?: RadioGroupConnectOptions): () => void;
Name
Kind
Type
Requirement
service
parameter
RadioGroupService
required
scope
parameter
PartScope
required
options
parameter
RadioGroupConnectOptions
optional
return
return value
() => void
n/a
Name
service
Kind
parameter
Type
RadioGroupService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
RadioGroupConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
() => void
Requirement
n/a

connectRadioGroup

function
DeclarationView source
connectRadioGroupts
declare function connectRadioGroup(service: RadioGroupService, scope: PartScope, options?: RadioGroupConnectOptions): RadioGroupApi;
Name
Kind
Type
Requirement
service
parameter
RadioGroupService
required
scope
parameter
PartScope
required
options
parameter
RadioGroupConnectOptions
optional
return
return value
RadioGroupApi
n/a
Name
service
Kind
parameter
Type
RadioGroupService
Requirement
required
Name
scope
Kind
parameter
Type
PartScope
Requirement
required
Name
options
Kind
parameter
Type
RadioGroupConnectOptions
Requirement
optional
Name
return
Kind
return value
Type
RadioGroupApi
Requirement
n/a

mountRadioGroup

function
DeclarationView source
mountRadioGroupts
declare function mountRadioGroup(container: HTMLElement, options: MountRadioGroupOptions): RadioGroupMount;
Name
Kind
Type
Requirement
container
parameter
HTMLElement
required
options
parameter
MountRadioGroupOptions
required
return
return value
RadioGroupMount
n/a
Name
container
Kind
parameter
Type
HTMLElement
Requirement
required
Name
options
Kind
parameter
Type
MountRadioGroupOptions
Requirement
required
Name
return
Kind
return value
Type
RadioGroupMount
Requirement
n/a

MountRadioGroupItem

interface
DeclarationView source
MountRadioGroupItemts
interface MountRadioGroupItem extends RadioGroupItem {
  readonly label?: string;
}
Name
Kind
Type
Requirement
label
property
string
optional
Name
label
Kind
property
Type
string
Requirement
optional

MountRadioGroupOptions

interface
DeclarationView source
MountRadioGroupOptionsts
interface MountRadioGroupOptions extends RadioGroupInput {
  readonly items: readonly MountRadioGroupItem[];
  readonly name?: string;
  readonly required?: boolean;
  readonly ariaLabel?: string;
  readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
  readonly onChange?: (event: unknown) => void;
  readonly bare?: boolean;
  readonly renderLabel?: (label: HTMLElement) => void;
  readonly renderDescription?: (description: HTMLElement) => void;
  readonly renderItem?: (label: HTMLElement, item: MountRadioGroupItem) => void;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
bare
property
boolean
optional
items
property
readonly MountRadioGroupItem[]
required
name
property
string
optional
onChange
property
(event: unknown) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
renderDescription
property
(description: HTMLElement) => void
optional
renderItem
property
(label: HTMLElement, item: MountRadioGroupItem) => void
optional
renderLabel
property
(label: HTMLElement) => void
optional
required
property
boolean
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
bare
Kind
property
Type
boolean
Requirement
optional
Name
items
Kind
property
Type
readonly MountRadioGroupItem[]
Requirement
required
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: unknown) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
renderDescription
Kind
property
Type
(description: HTMLElement) => void
Requirement
optional
Name
renderItem
Kind
property
Type
(label: HTMLElement, item: MountRadioGroupItem) => void
Requirement
optional
Name
renderLabel
Kind
property
Type
(label: HTMLElement) => void
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional

radioGroupAnatomy

value
DeclarationView source
radioGroupAnatomyts
export declare const radioGroupAnatomy: readonly ["root", "label", "description", "item", "item-input", "item-control", "item-indicator", "item-label"];

RadioGroupApi

interface
DeclarationView source
RadioGroupApits
interface RadioGroupApi {
  rootProps(): PartProps;
  itemProps(item: RadioGroupItem): PartProps;
  itemInputProps(item: RadioGroupItem): PartProps;
  itemControlProps(item: RadioGroupItem): PartProps;
  itemIndicatorProps(item: RadioGroupItem): PartProps;
  itemLabelProps(item: RadioGroupItem): PartProps;
  labelProps(): PartProps;
  descriptionProps(): PartProps;
  syncNativeChecked(): void;
  readonly value: string | null;
  readonly disabled: boolean;
  readonly readOnly: boolean;
}
Name
Kind
Type
Requirement
descriptionProps
method
() => PartProps
required
disabled
property
boolean
required
itemControlProps
method
(item: RadioGroupItem) => PartProps
required
itemIndicatorProps
method
(item: RadioGroupItem) => PartProps
required
itemInputProps
method
(item: RadioGroupItem) => PartProps
required
itemLabelProps
method
(item: RadioGroupItem) => PartProps
required
itemProps
method
(item: RadioGroupItem) => PartProps
required
labelProps
method
() => PartProps
required
readOnly
property
boolean
required
rootProps
method
() => PartProps
required
syncNativeChecked
method
() => void
required
value
property
string | null
required
Name
descriptionProps
Kind
method
Type
() => PartProps
Requirement
required
Name
disabled
Kind
property
Type
boolean
Requirement
required
Name
itemControlProps
Kind
method
Type
(item: RadioGroupItem) => PartProps
Requirement
required
Name
itemIndicatorProps
Kind
method
Type
(item: RadioGroupItem) => PartProps
Requirement
required
Name
itemInputProps
Kind
method
Type
(item: RadioGroupItem) => PartProps
Requirement
required
Name
itemLabelProps
Kind
method
Type
(item: RadioGroupItem) => PartProps
Requirement
required
Name
itemProps
Kind
method
Type
(item: RadioGroupItem) => PartProps
Requirement
required
Name
labelProps
Kind
method
Type
() => PartProps
Requirement
required
Name
readOnly
Kind
property
Type
boolean
Requirement
required
Name
rootProps
Kind
method
Type
() => PartProps
Requirement
required
Name
syncNativeChecked
Kind
method
Type
() => void
Requirement
required
Name
value
Kind
property
Type
string | null
Requirement
required

RadioGroupChangeDetail

interface
DeclarationView source
RadioGroupChangeDetailts
interface RadioGroupChangeDetail {
  readonly value: string;
  readonly reason: RadioGroupChangeReason;
}
Name
Kind
Type
Requirement
reason
property
RadioGroupChangeReason
required
value
property
string
required
Name
reason
Kind
property
Type
RadioGroupChangeReason
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

RadioGroupChangeReason

type
DeclarationView source
RadioGroupChangeReasonts
type RadioGroupChangeReason = "pointer" | "keyboard" | "programmatic";

RadioGroupCommand

type
DeclarationView source
RadioGroupCommandts
type RadioGroupCommand = CommandObject & {
  readonly type: "VALUE_CHANGE_REQUEST";
  readonly value: string;
  readonly reason: RadioGroupChangeReason;
};
Name
Kind
Type
Requirement
reason
property
RadioGroupChangeReason
required
type
property
string
required
value
property
string
required
Name
reason
Kind
property
Type
RadioGroupChangeReason
Requirement
required
Name
type
Kind
property
Type
string
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

RadioGroupConnectOptions

interface
DeclarationView source
RadioGroupConnectOptionsts
interface RadioGroupConnectOptions {
  readonly name?: string;
  readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
  readonly onChange?: (event: unknown) => void;
  readonly ariaLabel?: string;
  readonly required?: boolean;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
name
property
string
optional
onChange
property
(event: unknown) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
required
property
boolean
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: unknown) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional

RadioGroupContext

type
DeclarationView source
RadioGroupContextts
type RadioGroupContext = {
  readonly mode: BindingMode;
  readonly value: string | null;
};
Name
Kind
Type
Requirement
mode
property
BindingMode
required
value
property
string | null
required
Name
mode
Kind
property
Type
BindingMode
Requirement
required
Name
value
Kind
property
Type
string | null
Requirement
required

RadioGroupEvent

type
DeclarationView source
RadioGroupEventts
type RadioGroupEvent = {
  readonly type: "SELECT";
  readonly value: string;
  readonly reason: RadioGroupChangeReason;
} | {
  readonly type: "RESET";
};

RadioGroupInput

type
DeclarationView source
RadioGroupInputts
type RadioGroupInput = {
  /** Controlled committed value. Defining it fixes controlled mode at first start. */
  readonly value?: string;
  /** Uncontrolled initial committed value. */
  readonly defaultValue?: string;
  readonly disabled?: boolean;
  readonly readOnly?: boolean;
};
Name
Kind
Type
Requirement
Description
defaultValue
property
string
optional
Uncontrolled initial committed value.
disabled
property
boolean
optional
—
readOnly
property
boolean
optional
—
value
property
string
optional
Controlled committed value. Defining it fixes controlled mode at first start.
Name
defaultValue
Kind
property
Type
string
Requirement
optional
Description
Uncontrolled initial committed value.
Name
disabled
Kind
property
Type
boolean
Requirement
optional
Description
—
Name
readOnly
Kind
property
Type
boolean
Requirement
optional
Description
—
Name
value
Kind
property
Type
string
Requirement
optional
Description
Controlled committed value. Defining it fixes controlled mode at first start.

RadioGroupItem

interface
DeclarationView source
RadioGroupItemts
interface RadioGroupItem {
  readonly value: string;
  readonly disabled?: boolean;
}
Name
Kind
Type
Requirement
disabled
property
boolean
optional
value
property
string
required
Name
disabled
Kind
property
Type
boolean
Requirement
optional
Name
value
Kind
property
Type
string
Requirement
required

radioGroupMachine

value
DeclarationView source
radioGroupMachinets
export declare const radioGroupMachine: RadioGroupMachine;

RadioGroupMount

interface
DeclarationView source
RadioGroupMountts
interface RadioGroupMount {
  readonly service: RadioGroupService;
  readonly connector: RadioGroupApi;
  readonly root: HTMLElement;
  destroy(): void;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
destroy
method
() => void
required
root
property
HTMLElement
required
service
property
RadioGroupService
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
destroy
Kind
method
Type
() => void
Requirement
required
Name
root
Kind
property
Type
HTMLElement
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required

RadioGroupPart

type
DeclarationView source
RadioGroupPartts
type RadioGroupPart = (typeof radioGroupAnatomy)[number];

radioGroupSelectors

value
DeclarationView source
radioGroupSelectorsts
export declare const radioGroupSelectors: {
  value: (snapshot: RadioGroupSnapshot) => string | null;
  isSelected: (snapshot: RadioGroupSnapshot, value: string) => boolean;
};
Name
Kind
Type
Requirement
isSelected
property
(snapshot: RadioGroupSnapshot, value: string) => boolean
required
value
property
(snapshot: RadioGroupSnapshot) => string | null
required
Name
isSelected
Kind
property
Type
(snapshot: RadioGroupSnapshot, value: string) => boolean
Requirement
required
Name
value
Kind
property
Type
(snapshot: RadioGroupSnapshot) => string | null
Requirement
required

RadioGroupService

type
DeclarationView source
RadioGroupServicets
type RadioGroupService = Service<RadioGroupInput, RadioGroupStateValue, RadioGroupContext, RadioGroupEvent, RadioGroupCommand>;

RadioGroupSnapshot

type
DeclarationView source
RadioGroupSnapshotts
type RadioGroupSnapshot = Snapshot<RadioGroupStateValue, RadioGroupContext>;

RadioGroupStateValue

type
DeclarationView source
RadioGroupStateValuets
type RadioGroupStateValue = "ready";

runRadioGroupCommand

function
DeclarationView source
runRadioGroupCommandts
declare function runRadioGroupCommand(command: RadioGroupCommand, options?: Pick<RadioGroupConnectOptions, "onValueChange">): void;
Name
Kind
Type
Requirement
command
parameter
RadioGroupCommand
required
options
parameter
Pick<RadioGroupConnectOptions, "onValueChange">
optional
return
return value
void
n/a
Name
command
Kind
parameter
Type
RadioGroupCommand
Requirement
required
Name
options
Kind
parameter
Type
Pick<RadioGroupConnectOptions, "onValueChange">
Requirement
optional
Name
return
Kind
return value
Type
void
Requirement
n/a

Framework adapters

Each panel keeps its adapter's public vocabulary. React compound exports, Vue composables, standalone Angular declarations, Svelte components, and Solid hooks stay native to their framework.

React example follows below.

React imports

@grassroot/ui-headless-react/radiots
import { Description, Item, ItemControl, ItemIndicator, ItemLabel, Label, RadioGroup, Root } from "@grassroot/ui-headless-react/radio"; // +1 more exports

Vue imports

@grassroot/ui-headless-vue/radiots
<script setup lang="ts">
import { Description, Item, ItemControl, ItemIndicator, ItemLabel, Label, RadioGroupDescription, RadioGroupItem } from "@grassroot/ui-headless-vue/radio"; // +8 more exports
</script>

Angular imports

@grassroot/ui-headless-angular/radiots
import { Component } from "@angular/core";
import { GR_RADIO_GROUP_DECLARATIONS } from "@grassroot/ui-headless-angular/radio";
 
@Component({ standalone: true, imports: [GR_RADIO_GROUP_DECLARATIONS], template: `<!-- compose the radio parts here -->` })
export class Example {}

Svelte imports

@grassroot/ui-headless-svelte/radiots
<script lang="ts">
  import { RadioGroup, RadioGroupDescription, RadioGroupItem, RadioGroupItemControl, RadioGroupItemIndicator, RadioGroupItemLabel, RadioGroupLabel, RadioGroupRoot } from "@grassroot/ui-headless-svelte/radio"; // +1 more exports
</script>

Solid imports

@grassroot/ui-headless-solid/radiots
import { Description, Item, ItemControl, ItemIndicator, ItemLabel, Label, RadioGroupDescription, RadioGroupItem } from "@grassroot/ui-headless-solid/radio"; // +8 more exports

@grassroot/ui-headless-react/radio

React adapter

21 exports
View source packages/ui-headless/react/src/radio/index.ts

Description

value
DeclarationView source
Descriptionts
export declare const Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLSpanElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Item

value
DeclarationView source
Itemts
export declare const Item: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "disabled" | "value"> & {
  readonly value: string;
  readonly disabled?: boolean;
  readonly asChild?: boolean;
  readonly children?: ReactNode;
} & import("react").RefAttributes<HTMLLabelElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

ItemControl

value
DeclarationView source
ItemControlts
export declare const ItemControl: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

ItemIndicator

value
DeclarationView source
ItemIndicatorts
export declare const ItemIndicator: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

ItemInput

value
DeclarationView source
ItemInputts
export declare const ItemInput: import("react").ForwardRefExoticComponent<RadioGroupItemInputProps & import("react").RefAttributes<HTMLInputElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

ItemLabel

value
DeclarationView source
ItemLabelts
export declare const ItemLabel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Label

value
DeclarationView source
Labelts
export declare const Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
  asChild?: boolean;
} & import("react").RefAttributes<HTMLSpanElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

RadioGroup

value
DeclarationView source
RadioGroupts
export declare const RadioGroup: {
  Root: import("react").ForwardRefExoticComponent<RadioGroupRootProps & import("react").RefAttributes<HTMLDivElement>>;
  RootProvider: import("react").ForwardRefExoticComponent<RadioGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
  Item: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "disabled" | "value"> & {
    readonly value: string;
    readonly disabled?: boolean;
    readonly asChild?: boolean;
    readonly children?: import("react").ReactNode;
  } & import("react").RefAttributes<HTMLLabelElement>>;
  ItemInput: import("react").ForwardRefExoticComponent<RadioGroupItemInputProps & import("react").RefAttributes<HTMLInputElement>>;
  ItemControl: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLElement>>;
  ItemIndicator: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLElement>>;
  ItemLabel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLElement>>;
  Label: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
  Description: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
    asChild?: boolean;
  } & import("react").RefAttributes<HTMLSpanElement>>;
};
Name
Kind
Type
Requirement
Description
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLSpanElement>>
required
Item
property
import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "disabled" | "value"> & { readonly value: string; readonly disabled?: boolean; readonly asChild?: boolean; readonly children?: import("react").ReactNode; } & import("react").RefAttributes<HTMLLabelElement>>
required
ItemControl
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLElement>>
required
ItemIndicator
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLElement>>
required
ItemInput
property
import("react").ForwardRefExoticComponent<RadioGroupItemInputProps & import("react").RefAttributes<HTMLInputElement>>
required
ItemLabel
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLElement>>
required
Label
property
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLSpanElement>>
required
Root
property
import("react").ForwardRefExoticComponent<RadioGroupRootProps & import("react").RefAttributes<HTMLDivElement>>
required
RootProvider
property
import("react").ForwardRefExoticComponent<RadioGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>
required
Name
Description
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLSpanElement>>
Requirement
required
Name
Item
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref">, "disabled" | "value"> & { readonly value: string; readonly disabled?: boolean; readonly asChild?: boolean; readonly children?: import("react").ReactNode; } & import("react").RefAttributes<HTMLLabelElement>>
Requirement
required
Name
ItemControl
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLElement>>
Requirement
required
Name
ItemIndicator
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLElement>>
Requirement
required
Name
ItemInput
Kind
property
Type
import("react").ForwardRefExoticComponent<RadioGroupItemInputProps & import("react").RefAttributes<HTMLInputElement>>
Requirement
required
Name
ItemLabel
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLElement>>
Requirement
required
Name
Label
Kind
property
Type
import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & { asChild?: boolean; } & import("react").RefAttributes<HTMLSpanElement>>
Requirement
required
Name
Root
Kind
property
Type
import("react").ForwardRefExoticComponent<RadioGroupRootProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required
Name
RootProvider
Kind
property
Type
import("react").ForwardRefExoticComponent<RadioGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>
Requirement
required

RadioGroupContext

value
DeclarationView source
RadioGroupContextts
export declare const RadioGroupContext: import("react").Context<RadioGroupContextValue | null>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

RadioGroupContextValue

interface
DeclarationView source
RadioGroupContextValuets
interface RadioGroupContextValue {
  readonly service: RadioGroupService;
  readonly connector: RadioGroupApi;
  readonly scope: PartScope;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
scope
property
PartScope
required
service
property
RadioGroupService
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required

RadioGroupItemInputProps

interface
DeclarationView source
RadioGroupItemInputPropsts
interface RadioGroupItemInputProps extends Omit<ComponentPropsWithoutRef<"input">, "value" | "checked" | "disabled"> {
  readonly value?: string;
  readonly disabled?: boolean;
  readonly asChild?: boolean;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
disabled
property
boolean
optional
value
property
string
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
disabled
Kind
property
Type
boolean
Requirement
optional
Name
value
Kind
property
Type
string
Requirement
optional

RadioGroupRootProps

interface
DeclarationView source
RadioGroupRootPropsts
interface RadioGroupRootProps extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange"> {
  readonly asChild?: boolean;
  readonly value?: RadioGroupInput["value"];
  readonly defaultValue?: RadioGroupInput["defaultValue"];
  readonly disabled?: RadioGroupInput["disabled"];
  readonly readOnly?: RadioGroupInput["readOnly"];
  readonly name?: string;
  readonly required?: boolean;
  readonly ariaLabel?: string;
  readonly id?: string;
  readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
  readonly onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
asChild
property
boolean
optional
children
property
ReactNode
optional
defaultValue
property
RadioGroupInput["defaultValue"]
optional
disabled
property
RadioGroupInput["disabled"]
optional
id
property
string
optional
name
property
string
optional
onChange
property
(event: React.ChangeEvent<HTMLInputElement>) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
readOnly
property
RadioGroupInput["readOnly"]
optional
required
property
boolean
optional
value
property
RadioGroupInput["value"]
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
defaultValue
Kind
property
Type
RadioGroupInput["defaultValue"]
Requirement
optional
Name
disabled
Kind
property
Type
RadioGroupInput["disabled"]
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: React.ChangeEvent<HTMLInputElement>) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
readOnly
Kind
property
Type
RadioGroupInput["readOnly"]
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional
Name
value
Kind
property
Type
RadioGroupInput["value"]
Requirement
optional

RadioGroupRootProviderProps

interface
DeclarationView source
RadioGroupRootProviderPropsts
interface RadioGroupRootProviderProps extends Omit<ComponentPropsWithoutRef<"div">, "defaultValue" | "onChange"> {
  readonly asChild?: boolean;
  readonly value: UseRadioGroupResult;
  readonly children?: ReactNode;
}
Name
Kind
Type
Requirement
asChild
property
boolean
optional
children
property
ReactNode
optional
value
property
UseRadioGroupResult
required
Name
asChild
Kind
property
Type
boolean
Requirement
optional
Name
children
Kind
property
Type
ReactNode
Requirement
optional
Name
value
Kind
property
Type
UseRadioGroupResult
Requirement
required

RadioItemContext

value
DeclarationView source
RadioItemContextts
export declare const RadioItemContext: import("react").Context<RadioGroupItem | null>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

Root

value
DeclarationView source
Rootts
export declare const Root: import("react").ForwardRefExoticComponent<RadioGroupRootProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

RootProvider

value
DeclarationView source
RootProviderts
export declare const RootProvider: import("react").ForwardRefExoticComponent<RadioGroupRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
Name
Kind
Type
Requirement
props
parameter
P
required
return
return value
ReactNode
n/a
Name
props
Kind
parameter
Type
P
Requirement
required
Name
return
Kind
return value
Type
ReactNode
Requirement
n/a

useRadioGroup

function
DeclarationView source
useRadioGroupts
declare function useRadioGroup(input: RadioGroupInput, options?: UseRadioGroupOptions): UseRadioGroupResult;
Name
Kind
Type
Requirement
input
parameter
RadioGroupInput
required
options
parameter
UseRadioGroupOptions
optional
return
return value
UseRadioGroupResult
n/a
Name
input
Kind
parameter
Type
RadioGroupInput
Requirement
required
Name
options
Kind
parameter
Type
UseRadioGroupOptions
Requirement
optional
Name
return
Kind
return value
Type
UseRadioGroupResult
Requirement
n/a

useRadioGroupContext

function
DeclarationView source
useRadioGroupContextts
declare function useRadioGroupContext(partName: string): RadioGroupContextValue;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
RadioGroupContextValue
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
RadioGroupContextValue
Requirement
n/a

UseRadioGroupOptions

interface
DeclarationView source
UseRadioGroupOptionsts
interface UseRadioGroupOptions {
  readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
  readonly onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
  readonly name?: string;
  readonly required?: boolean;
  readonly ariaLabel?: string;
  readonly id?: string;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
id
property
string
optional
name
property
string
optional
onChange
property
(event: ChangeEvent<HTMLInputElement>) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
required
property
boolean
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: ChangeEvent<HTMLInputElement>) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional

UseRadioGroupResult

interface
DeclarationView source
UseRadioGroupResultts
interface UseRadioGroupResult {
  readonly service: RadioGroupService;
  readonly connector: RadioGroupApi;
  readonly scope: PartScope;
  readonly snapshot: RadioGroupSnapshot;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
scope
property
PartScope
required
service
property
RadioGroupService
required
snapshot
property
RadioGroupSnapshot
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required
Name
snapshot
Kind
property
Type
RadioGroupSnapshot
Requirement
required

useRadioItemContext

function
DeclarationView source
useRadioItemContextts
declare function useRadioItemContext(partName: string): RadioGroupItem;
Name
Kind
Type
Requirement
partName
parameter
string
required
return
return value
RadioGroupItem
n/a
Name
partName
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
RadioGroupItem
Requirement
n/a

@grassroot/ui-headless-vue/radio

Vue adapter

23 exports
View source packages/ui-headless/vue/src/radio/index.ts

Description

value
DeclarationView source
Descriptionts
export declare const Description: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Item

value
DeclarationView source
Itemts
export declare const Item: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    required: true;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    required: true;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ItemControl

value
DeclarationView source
ItemControlts
export declare const ItemControl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ItemIndicator

value
DeclarationView source
ItemIndicatorts
export declare const ItemIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ItemInput

value
DeclarationView source
ItemInputts
export declare const ItemInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

ItemLabel

value
DeclarationView source
ItemLabelts
export declare const ItemLabel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Label

value
DeclarationView source
Labelts
export declare const Label: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupChangeDetail

interface
DeclarationView source
RadioGroupChangeDetailts
interface RadioGroupChangeDetail {
  readonly value: string;
  readonly reason: RadioGroupChangeReason;
}
Name
Kind
Type
Requirement
reason
property
RadioGroupChangeReason
required
value
property
string
required
Name
reason
Kind
property
Type
RadioGroupChangeReason
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

RadioGroupContextKey

value
DeclarationView source
RadioGroupContextKeyts
export declare const RadioGroupContextKey: InjectionKey<RadioGroupContextValue>;

RadioGroupDescription

value
DeclarationView source
RadioGroupDescriptionts
export declare const RadioGroupDescription: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupItem

value
DeclarationView source
RadioGroupItemts
export declare const RadioGroupItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    required: true;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    required: true;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupItemControl

value
DeclarationView source
RadioGroupItemControlts
export declare const RadioGroupItemControl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupItemIndicator

value
DeclarationView source
RadioGroupItemIndicatorts
export declare const RadioGroupItemIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupItemInput

value
DeclarationView source
RadioGroupItemInputts
export declare const RadioGroupItemInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupItemLabel

value
DeclarationView source
RadioGroupItemLabelts
export declare const RadioGroupItemLabel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  value: string;
  disabled: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupLabel

value
DeclarationView source
RadioGroupLabelts
export declare const RadioGroupLabel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupRoot

value
DeclarationView source
RadioGroupRootts
export declare const RadioGroupRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: RadioGroupChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: RadioGroupChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  disabled: boolean;
  readOnly: boolean;
  name: string;
  required: boolean;
  ariaLabel: string;
  id: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RadioGroupRootProvider

value
DeclarationView source
RadioGroupRootProviderts
export declare const RadioGroupRootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: RadioGroupChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: RadioGroupChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  disabled: boolean;
  readOnly: boolean;
  name: string;
  required: boolean;
  ariaLabel: string;
  id: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

Root

value
DeclarationView source
Rootts
export declare const Root: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: RadioGroupChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: RadioGroupChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  disabled: boolean;
  readOnly: boolean;
  name: string;
  required: boolean;
  ariaLabel: string;
  id: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

RootProvider

value
DeclarationView source
RootProviderts
export declare const RootProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  valueChange: (_detail: RadioGroupChangeDetail) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | undefined>;
    default: undefined;
  };
  disabled: {
    type: BooleanConstructor;
    default: undefined;
  };
  readOnly: {
    type: BooleanConstructor;
    default: undefined;
  };
  name: {
    type: StringConstructor;
    default: undefined;
  };
  required: {
    type: BooleanConstructor;
    default: undefined;
  };
  ariaLabel: {
    type: StringConstructor;
    default: undefined;
  };
  id: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{
  onValueChange?: ((_detail: RadioGroupChangeDetail) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | undefined;
  defaultValue: string | undefined;
  disabled: boolean;
  readOnly: boolean;
  name: string;
  required: boolean;
  ariaLabel: string;
  id: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

useRadioGroup

function
DeclarationView source
useRadioGroupts
declare function useRadioGroup(input: () => RadioGroupInput, options?: UseRadioGroupOptions): UseRadioGroupResult;
Name
Kind
Type
Requirement
input
parameter
() => RadioGroupInput
required
options
parameter
UseRadioGroupOptions
optional
return
return value
UseRadioGroupResult
n/a
Name
input
Kind
parameter
Type
() => RadioGroupInput
Requirement
required
Name
options
Kind
parameter
Type
UseRadioGroupOptions
Requirement
optional
Name
return
Kind
return value
Type
UseRadioGroupResult
Requirement
n/a

UseRadioGroupOptions

interface
DeclarationView source
UseRadioGroupOptionsts
interface UseRadioGroupOptions {
  readonly name?: string;
  readonly required?: boolean;
  readonly ariaLabel?: string;
  readonly id?: string;
  readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
  readonly onChange?: (event: unknown) => void;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
id
property
string
optional
name
property
string
optional
onChange
property
(event: unknown) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
required
property
boolean
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: unknown) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional

UseRadioGroupResult

interface
DeclarationView source
UseRadioGroupResultts
interface UseRadioGroupResult {
  readonly service: RadioGroupService;
  readonly connector: RadioGroupApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<RadioGroupSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
scope
property
PartScope
required
service
property
RadioGroupService
required
snapshot
property
ShallowRef<RadioGroupSnapshot>
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required
Name
snapshot
Kind
property
Type
ShallowRef<RadioGroupSnapshot>
Requirement
required

@grassroot/ui-headless-angular/radio

Angular adapter

15 exports
View source packages/ui-headless/angular/src/radio/index.ts

createRadioGroupStore

function
DeclarationView source
createRadioGroupStorets
export declare function createRadioGroupStore(initial: RadioGroupInput, options?: CreateRadioGroupStoreOptions): RadioGroupStore;
Name
Kind
Type
Requirement
initial
parameter
RadioGroupInput
required
options
parameter
CreateRadioGroupStoreOptions
optional
return
return value
RadioGroupStore
n/a
Name
initial
Kind
parameter
Type
RadioGroupInput
Requirement
required
Name
options
Kind
parameter
Type
CreateRadioGroupStoreOptions
Requirement
optional
Name
return
Kind
return value
Type
RadioGroupStore
Requirement
n/a

CreateRadioGroupStoreOptions

interface
DeclarationView source
CreateRadioGroupStoreOptionsts
export interface CreateRadioGroupStoreOptions {
    readonly id?: string;
    readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
    readonly onCommit?: () => void;
}
Name
Kind
Type
Requirement
id
property
string
optional
onCommit
property
() => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
onCommit
Kind
property
Type
() => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional

GR_RADIO_GROUP_DECLARATIONS

value
DeclarationView source
GR_RADIO_GROUP_DECLARATIONSts
export declare const GR_RADIO_GROUP_DECLARATIONS: readonly [typeof GrRadioGroupRoot, typeof GrRadioGroupRootProvider, typeof GrRadioGroupItem, typeof GrRadioGroupItemInput, typeof GrRadioGroupItemControl, typeof GrRadioGroupItemIndicator, typeof GrRadioGroupItemLabel, typeof GrRadioGroupLabel, typeof GrRadioGroupDescription];

GrRadioGroupDescription

class
DeclarationView source
GrRadioGroupDescriptionts
export declare class GrRadioGroupDescription implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupDescription, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupDescription, "[grRadioGroupDescription]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupDescription, "[grRadioGroupDescription]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupDescription, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupDescription, "[grRadioGroupDescription]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupDescription, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrRadioGroupItem

class
DeclarationView source
GrRadioGroupItemts
export declare class GrRadioGroupItem implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registered?;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupItem, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupItem, "[grRadioGroupItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
disabled
property
import("@angular/core").InputSignal<boolean | undefined>
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupItem, "[grRadioGroupItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupItem, never>
required
registered
property
any
optional
store
property
any
required
value
property
import("@angular/core").InputSignal<string>
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
disabled
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupItem, "[grRadioGroupItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupItem, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
optional
Name
store
Kind
property
Type
any
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required

GrRadioGroupItemControl

class
DeclarationView source
GrRadioGroupItemControlts
export declare class GrRadioGroupItemControl implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registered?;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupItemControl, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupItemControl, "[grRadioGroupItemControl]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
disabled
property
import("@angular/core").InputSignal<boolean | undefined>
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemControl, "[grRadioGroupItemControl]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupItemControl, never>
required
registered
property
any
optional
store
property
any
required
value
property
import("@angular/core").InputSignal<string>
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
disabled
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemControl, "[grRadioGroupItemControl]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupItemControl, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
optional
Name
store
Kind
property
Type
any
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required

GrRadioGroupItemIndicator

class
DeclarationView source
GrRadioGroupItemIndicatorts
export declare class GrRadioGroupItemIndicator implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registered?;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupItemIndicator, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupItemIndicator, "[grRadioGroupItemIndicator]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
disabled
property
import("@angular/core").InputSignal<boolean | undefined>
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemIndicator, "[grRadioGroupItemIndicator]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupItemIndicator, never>
required
registered
property
any
optional
store
property
any
required
value
property
import("@angular/core").InputSignal<string>
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
disabled
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemIndicator, "[grRadioGroupItemIndicator]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupItemIndicator, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
optional
Name
store
Kind
property
Type
any
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required

GrRadioGroupItemInput

class
DeclarationView source
GrRadioGroupItemInputts
export declare class GrRadioGroupItemInput implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registered?;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupItemInput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupItemInput, "[grRadioGroupItemInput]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
disabled
property
import("@angular/core").InputSignal<boolean | undefined>
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemInput, "[grRadioGroupItemInput]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupItemInput, never>
required
registered
property
any
optional
store
property
any
required
value
property
import("@angular/core").InputSignal<string>
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
disabled
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemInput, "[grRadioGroupItemInput]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupItemInput, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
optional
Name
store
Kind
property
Type
any
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required

GrRadioGroupItemLabel

class
DeclarationView source
GrRadioGroupItemLabelts
export declare class GrRadioGroupItemLabel implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registered?;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupItemLabel, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupItemLabel, "[grRadioGroupItemLabel]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
disabled
property
import("@angular/core").InputSignal<boolean | undefined>
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemLabel, "[grRadioGroupItemLabel]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupItemLabel, never>
required
registered
property
any
optional
store
property
any
required
value
property
import("@angular/core").InputSignal<string>
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
disabled
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupItemLabel, "[grRadioGroupItemLabel]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupItemLabel, never>
Requirement
required
Name
registered
Kind
property
Type
any
Requirement
optional
Name
store
Kind
property
Type
any
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string>
Requirement
required

GrRadioGroupLabel

class
DeclarationView source
GrRadioGroupLabelts
export declare class GrRadioGroupLabel implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupLabel, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrRadioGroupLabel, "[grRadioGroupLabel]", never, {}, {}, never, never, true, never>;
}
Name
Kind
Type
Requirement
consumer
property
any
required
element
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵdir
property
i0.ɵɵDirectiveDeclaration<GrRadioGroupLabel, "[grRadioGroupLabel]", never, {}, {}, never, never, true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupLabel, never>
required
store
property
any
required
Name
consumer
Kind
property
Type
any
Requirement
required
Name
element
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵdir
Kind
property
Type
i0.ɵɵDirectiveDeclaration<GrRadioGroupLabel, "[grRadioGroupLabel]", never, {}, {}, never, never, true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupLabel, never>
Requirement
required
Name
store
Kind
property
Type
any
Requirement
required

GrRadioGroupRoot

class
DeclarationView source
GrRadioGroupRootts
export declare class GrRadioGroupRoot implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<string | undefined>;
    readonly disabled: import("@angular/core").InputSignal<boolean | undefined>;
    readonly readOnly: import("@angular/core").InputSignal<boolean | undefined>;
    readonly name: import("@angular/core").InputSignal<string | undefined>;
    readonly required: import("@angular/core").InputSignal<boolean | undefined>;
    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
    readonly id: import("@angular/core").InputSignal<string | undefined>;
    readonly valueChange: import("@angular/core").OutputEmitterRef<RadioGroupChangeDetail>;
    readonly store: RadioGroupStore;
    private readonly host;
    private readonly last;
    private readonly listeners;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupRoot, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrRadioGroupRoot, "gr-radio-group-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
ariaLabel
property
import("@angular/core").InputSignal<string | undefined>
required
defaultValue
property
import("@angular/core").InputSignal<string | undefined>
required
disabled
property
import("@angular/core").InputSignal<boolean | undefined>
required
host
property
any
required
id
property
import("@angular/core").InputSignal<string | undefined>
required
last
property
any
required
listeners
property
any
required
name
property
import("@angular/core").InputSignal<string | undefined>
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrRadioGroupRoot, "gr-radio-group-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupRoot, never>
required
readOnly
property
import("@angular/core").InputSignal<boolean | undefined>
required
required
property
import("@angular/core").InputSignal<boolean | undefined>
required
store
property
RadioGroupStore
required
Name
ariaLabel
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
defaultValue
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
disabled
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
host
Kind
property
Type
any
Requirement
required
Name
id
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
last
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
name
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrRadioGroupRoot, "gr-radio-group-root", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupRoot, never>
Requirement
required
Name
readOnly
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
required
Kind
property
Type
import("@angular/core").InputSignal<boolean | undefined>
Requirement
required
Name
store
Kind
property
Type
RadioGroupStore
Requirement
required
Name
value
Kind
property
Type
import("@angular/core").InputSignal<string | undefined>
Requirement
required
Name
valueChange
Kind
property
Type
import("@angular/core").OutputEmitterRef<RadioGroupChangeDetail>
Requirement
required

GrRadioGroupRootProvider

class
DeclarationView source
GrRadioGroupRootProviderts
export declare class GrRadioGroupRootProvider implements OnDestroy {
    readonly store: RadioGroupStore;
    private readonly host;
    private readonly listeners;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrRadioGroupRootProvider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrRadioGroupRootProvider, "gr-radio-group-root-provider", never, {}, {}, never, ["*"], true, never>;
}
Name
Kind
Type
Requirement
host
property
any
required
listeners
property
any
required
ngOnDestroy
method
() => void
required
ɵcmp
property
i0.ɵɵComponentDeclaration<GrRadioGroupRootProvider, "gr-radio-group-root-provider", never, {}, {}, never, ["*"], true, never>
required
ɵfac
property
i0.ɵɵFactoryDeclaration<GrRadioGroupRootProvider, never>
required
store
property
RadioGroupStore
required
Name
host
Kind
property
Type
any
Requirement
required
Name
listeners
Kind
property
Type
any
Requirement
required
Name
ngOnDestroy
Kind
method
Type
() => void
Requirement
required
Name
ɵcmp
Kind
property
Type
i0.ɵɵComponentDeclaration<GrRadioGroupRootProvider, "gr-radio-group-root-provider", never, {}, {}, never, ["*"], true, never>
Requirement
required
Name
ɵfac
Kind
property
Type
i0.ɵɵFactoryDeclaration<GrRadioGroupRootProvider, never>
Requirement
required
Name
store
Kind
property
Type
RadioGroupStore
Requirement
required

RADIO_GROUP_STORE

value
DeclarationView source
RADIO_GROUP_STOREts
export declare const RADIO_GROUP_STORE: InjectionToken<RadioGroupStore>;

RadioGroupChangeDetail

interface
DeclarationView source
RadioGroupChangeDetailts
interface RadioGroupChangeDetail {
  readonly value: string;
  readonly reason: RadioGroupChangeReason;
}
Name
Kind
Type
Requirement
reason
property
RadioGroupChangeReason
required
value
property
string
required
Name
reason
Kind
property
Type
RadioGroupChangeReason
Requirement
required
Name
value
Kind
property
Type
string
Requirement
required

RadioGroupStore

interface
DeclarationView source
RadioGroupStorets
export interface RadioGroupStore {
    readonly service: RadioGroupService;
    readonly connector: RadioGroupApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: RadioGroupInput): void;
    setConnectOptions(next: RadioGroupConnectOptions): void;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
scope
property
PartScope
required
service
property
RadioGroupService
required
setConnectOptions
method
(next: RadioGroupConnectOptions) => void
required
start
method
() => void
required
stop
method
() => void
required
sync
method
(input: RadioGroupInput) => void
required
version
property
WritableSignal<number>
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required
Name
setConnectOptions
Kind
method
Type
(next: RadioGroupConnectOptions) => void
Requirement
required
Name
start
Kind
method
Type
() => void
Requirement
required
Name
stop
Kind
method
Type
() => void
Requirement
required
Name
sync
Kind
method
Type
(input: RadioGroupInput) => void
Requirement
required
Name
version
Kind
property
Type
WritableSignal<number>
Requirement
required

@grassroot/ui-headless-svelte/radio

Svelte adapter

19 exports
View source packages/ui-headless/svelte/src/radio/index.ts

createRadioGroup

function
DeclarationView source
createRadioGroupts
export declare function createRadioGroup(inputGetter: () => RadioGroupInput, options?: UseRadioGroupOptions): UseRadioGroupResult;
Name
Kind
Type
Requirement
inputGetter
parameter
() => RadioGroupInput
required
options
parameter
UseRadioGroupOptions
optional
return
return value
UseRadioGroupResult
n/a
Name
inputGetter
Kind
parameter
Type
() => RadioGroupInput
Requirement
required
Name
options
Kind
parameter
Type
UseRadioGroupOptions
Requirement
optional
Name
return
Kind
return value
Type
UseRadioGroupResult
Requirement
n/a

provideRadioGroupContext

function
DeclarationView source
provideRadioGroupContextts
export declare function provideRadioGroupContext(value: RadioGroupContextValue): void;
Name
Kind
Type
Requirement
value
parameter
RadioGroupContextValue
required
return
return value
void
n/a
Name
value
Kind
parameter
Type
RadioGroupContextValue
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

provideRadioItem

function
DeclarationView source
provideRadioItemts
export declare function provideRadioItem(item: RadioGroupItem): void;
Name
Kind
Type
Requirement
item
parameter
RadioGroupItem
required
return
return value
void
n/a
Name
item
Kind
parameter
Type
RadioGroupItem
Requirement
required
Name
return
Kind
return value
Type
void
Requirement
n/a

RADIO_GROUP_CONTEXT_KEY

value
DeclarationView source
RADIO_GROUP_CONTEXT_KEYts
export declare const RADIO_GROUP_CONTEXT_KEY: unique symbol;

RadioGroup

value
DeclarationView source
RadioGroupts
export declare const RadioGroup: {
    Root: import("svelte/legacy").LegacyComponentType;
    RootProvider: import("svelte/legacy").LegacyComponentType;
    Item: import("svelte/legacy").LegacyComponentType;
    ItemInput: import("svelte/legacy").LegacyComponentType;
    ItemControl: import("svelte/legacy").LegacyComponentType;
    ItemIndicator: import("svelte/legacy").LegacyComponentType;
    ItemLabel: import("svelte/legacy").LegacyComponentType;
    Label: import("svelte/legacy").LegacyComponentType;
    Description: import("svelte/legacy").LegacyComponentType;
};
Name
Kind
Type
Requirement
Description
property
import("svelte/legacy").LegacyComponentType
required
Item
property
import("svelte/legacy").LegacyComponentType
required
ItemControl
property
import("svelte/legacy").LegacyComponentType
required
ItemIndicator
property
import("svelte/legacy").LegacyComponentType
required
ItemInput
property
import("svelte/legacy").LegacyComponentType
required
ItemLabel
property
import("svelte/legacy").LegacyComponentType
required
Label
property
import("svelte/legacy").LegacyComponentType
required
Root
property
import("svelte/legacy").LegacyComponentType
required
RootProvider
property
import("svelte/legacy").LegacyComponentType
required
Name
Description
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
Item
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
ItemControl
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
ItemIndicator
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
ItemInput
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
ItemLabel
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
Label
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
Root
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required
Name
RootProvider
Kind
property
Type
import("svelte/legacy").LegacyComponentType
Requirement
required

RadioGroupDescription

value
DeclarationView source
RadioGroupDescriptionts
export declare const RadioGroupDescription: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupItem

value
DeclarationView source
RadioGroupItemts
export declare const RadioGroupItem: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupItemControl

value
DeclarationView source
RadioGroupItemControlts
export declare const RadioGroupItemControl: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupItemIndicator

value
DeclarationView source
RadioGroupItemIndicatorts
export declare const RadioGroupItemIndicator: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupItemInput

value
DeclarationView source
RadioGroupItemInputts
export declare const RadioGroupItemInput: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupItemLabel

value
DeclarationView source
RadioGroupItemLabelts
export declare const RadioGroupItemLabel: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupLabel

value
DeclarationView source
RadioGroupLabelts
export declare const RadioGroupLabel: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupRoot

value
DeclarationView source
RadioGroupRootts
export declare const RadioGroupRoot: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupRootProvider

value
DeclarationView source
RadioGroupRootProviderts
export declare const RadioGroupRootProvider: LegacyComponentType;
Name
Kind
Type
Requirement
args
parameter
Parameters<Component<Record<string, any>>>
optional
return
return value
ReturnType<Component<Record<string, any>, Record<string, any>>>
n/a
Name
args
Kind
parameter
Type
Parameters<Component<Record<string, any>>>
Requirement
optional
Name
return
Kind
return value
Type
ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement
n/a

RadioGroupValueChangeDetail

interface
DeclarationView source
RadioGroupValueChangeDetailts
export interface RadioGroupValueChangeDetail extends RadioGroupChangeDetail {
}

useRadioGroupContext

function
DeclarationView source
useRadioGroupContextts
export declare function useRadioGroupContext(part: string): RadioGroupContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
RadioGroupContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
RadioGroupContextValue
Requirement
n/a

UseRadioGroupOptions

interface
DeclarationView source
UseRadioGroupOptionsts
export interface UseRadioGroupOptions {
    readonly name?: string;
    readonly required?: boolean;
    readonly ariaLabel?: string;
    readonly id?: string;
    readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
    readonly onChange?: (event: unknown) => void;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
id
property
string
optional
name
property
string
optional
onChange
property
(event: unknown) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
required
property
boolean
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: unknown) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional

UseRadioGroupResult

interface
DeclarationView source
UseRadioGroupResultts
export interface UseRadioGroupResult {
    readonly service: RadioGroupService;
    readonly connector: RadioGroupApi;
    readonly scope: PartScope;
    readonly version: () => number;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
scope
property
PartScope
required
service
property
RadioGroupService
required
version
property
() => number
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required
Name
version
Kind
property
Type
() => number
Requirement
required

useRadioItem

function
DeclarationView source
useRadioItemts
export declare function useRadioItem(part: string): RadioGroupItem;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
RadioGroupItem
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
RadioGroupItem
Requirement
n/a

@grassroot/ui-headless-solid/radio

Solid adapter

25 exports
View source packages/ui-headless/solid/src/radio/index.ts

Description

value
DeclarationView source
Descriptionts
export declare const Description: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Item

function
DeclarationView source
Itemts
export declare function RadioGroupItem(props: RadioGroupItemProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
RadioGroupItemProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupItemProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ItemControl

value
DeclarationView source
ItemControlts
export declare const ItemControl: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ItemIndicator

value
DeclarationView source
ItemIndicatorts
export declare const ItemIndicator: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ItemInput

function
DeclarationView source
ItemInputts
export declare function RadioGroupItemInput(props: RadioGroupItemInputProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
RadioGroupItemInputProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupItemInputProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

ItemLabel

value
DeclarationView source
ItemLabelts
export declare const ItemLabel: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

Label

value
DeclarationView source
Labelts
export declare const Label: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupContext

value
DeclarationView source
RadioGroupContextts
export declare const RadioGroupContext: import("solid-js").Context<RadioGroupContextValue | undefined>;

RadioGroupDescription

value
DeclarationView source
RadioGroupDescriptionts
export declare const RadioGroupDescription: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupItem

function
DeclarationView source
RadioGroupItemts
export declare function RadioGroupItem(props: RadioGroupItemProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
RadioGroupItemProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupItemProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupItemControl

value
DeclarationView source
RadioGroupItemControlts
export declare const RadioGroupItemControl: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupItemIndicator

value
DeclarationView source
RadioGroupItemIndicatorts
export declare const RadioGroupItemIndicator: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupItemInput

function
DeclarationView source
RadioGroupItemInputts
export declare function RadioGroupItemInput(props: RadioGroupItemInputProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
RadioGroupItemInputProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupItemInputProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupItemLabel

value
DeclarationView source
RadioGroupItemLabelts
export declare const RadioGroupItemLabel: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupLabel

value
DeclarationView source
RadioGroupLabelts
export declare const RadioGroupLabel: (props: JSX.HTMLAttributes<HTMLSpanElement> & {
    as?: AsProp;
}) => JSX.Element;
Name
Kind
Type
Requirement
props
parameter
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
JSX.HTMLAttributes<HTMLSpanElement> & { as?: AsProp; }
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupRoot

function
DeclarationView source
RadioGroupRootts
export declare function RadioGroupRoot(props: RadioGroupRootProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
RadioGroupRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioGroupRootProvider

value
DeclarationView source
RadioGroupRootProviderts
export declare const RadioGroupRootProvider: typeof RadioGroupRoot;
Name
Kind
Type
Requirement
props
parameter
RadioGroupRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RadioItemContext

value
DeclarationView source
RadioItemContextts
export declare const RadioItemContext: import("solid-js").Context<RadioGroupItem | undefined>;

Root

function
DeclarationView source
Rootts
export declare function RadioGroupRoot(props: RadioGroupRootProps): JSX.Element;
Name
Kind
Type
Requirement
props
parameter
RadioGroupRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

RootProvider

value
DeclarationView source
RootProviderts
export declare const RootProvider: typeof RadioGroupRoot;
Name
Kind
Type
Requirement
props
parameter
RadioGroupRootProps
required
return
return value
JSX.Element
n/a
Name
props
Kind
parameter
Type
RadioGroupRootProps
Requirement
required
Name
return
Kind
return value
Type
JSX.Element
Requirement
n/a

useRadioGroup

function
DeclarationView source
useRadioGroupts
export declare function useRadioGroup(input: Accessor<RadioGroupInput>, options?: UseRadioGroupOptions): UseRadioGroupResult;
Name
Kind
Type
Requirement
input
parameter
Accessor<RadioGroupInput>
required
options
parameter
UseRadioGroupOptions
optional
return
return value
UseRadioGroupResult
n/a
Name
input
Kind
parameter
Type
Accessor<RadioGroupInput>
Requirement
required
Name
options
Kind
parameter
Type
UseRadioGroupOptions
Requirement
optional
Name
return
Kind
return value
Type
UseRadioGroupResult
Requirement
n/a

useRadioGroupContext

function
DeclarationView source
useRadioGroupContextts
export declare function useRadioGroupContext(part: string): RadioGroupContextValue;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
RadioGroupContextValue
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
RadioGroupContextValue
Requirement
n/a

UseRadioGroupOptions

interface
DeclarationView source
UseRadioGroupOptionsts
export interface UseRadioGroupOptions {
    readonly name?: string;
    readonly required?: boolean;
    readonly ariaLabel?: string;
    readonly id?: string;
    readonly onValueChange?: (detail: RadioGroupChangeDetail) => void;
    readonly onChange?: (event: unknown) => void;
}
Name
Kind
Type
Requirement
ariaLabel
property
string
optional
id
property
string
optional
name
property
string
optional
onChange
property
(event: unknown) => void
optional
onValueChange
property
(detail: RadioGroupChangeDetail) => void
optional
required
property
boolean
optional
Name
ariaLabel
Kind
property
Type
string
Requirement
optional
Name
id
Kind
property
Type
string
Requirement
optional
Name
name
Kind
property
Type
string
Requirement
optional
Name
onChange
Kind
property
Type
(event: unknown) => void
Requirement
optional
Name
onValueChange
Kind
property
Type
(detail: RadioGroupChangeDetail) => void
Requirement
optional
Name
required
Kind
property
Type
boolean
Requirement
optional

UseRadioGroupResult

interface
DeclarationView source
UseRadioGroupResultts
export interface UseRadioGroupResult {
    readonly service: RadioGroupService;
    readonly connector: RadioGroupApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<RadioGroupSnapshot>;
}
Name
Kind
Type
Requirement
connector
property
RadioGroupApi
required
scope
property
PartScope
required
service
property
RadioGroupService
required
snapshot
property
Accessor<RadioGroupSnapshot>
required
Name
connector
Kind
property
Type
RadioGroupApi
Requirement
required
Name
scope
Kind
property
Type
PartScope
Requirement
required
Name
service
Kind
property
Type
RadioGroupService
Requirement
required
Name
snapshot
Kind
property
Type
Accessor<RadioGroupSnapshot>
Requirement
required

useRadioItemContext

function
DeclarationView source
useRadioItemContextts
export declare function useRadioItemContext(part: string): RadioGroupItem;
Name
Kind
Type
Requirement
part
parameter
string
required
return
return value
RadioGroupItem
n/a
Name
part
Kind
parameter
Type
string
Requirement
required
Name
return
Kind
return value
Type
RadioGroupItem
Requirement
n/a