Enum FormVariant 

pub enum FormVariant {
    Default,
    Inline,
    Stacked,
}

Form component with proper accessibility and validation

The Form component provides accessible form functionality with proper ARIA attributes, validation, error handling, and flexible styling.

Features

• Proper form semantics and accessibility
• Form validation and error handling
• Field state management
• Multiple variants and layouts
• Event handling (submit, reset, change)
• Integration with form controls

Example

use leptos::prelude::*;
use radix_leptos_primitives::*;

#[component]
fn MyForm() -> impl IntoView {
    let (form_data, set_form_data) = create_signal(FormData::default());
    let (errors, set_errors) = create_signal(FormErrors::default());

    let handle_submit = move |e: web_sys::Event| {
        e.prevent_default();
        // Handle form submission
    };

    view! {
        <Form
            on_submit=handle_submit
            data=form_data
            errors=errors
        >
            <FormField name="email" required=true>
                <FormLabel>"Email"</FormLabel>
                <FormInput type="email" />
                <FormError />
            </FormField>
             
            <FormField name="password" required=true>
                <FormLabel>"Password"</FormLabel>
                <FormInput type="password" />
                <FormError />
            </FormField>
             
            <FormSubmit>
                <Button type="submit">"Submit"</Button>
            </FormSubmit>
        </Form>
    }
}

Variants

Default

Inline

Stacked

Implementations

impl FormVariant

pub fn as_str(&self) -> &'static str

Trait Implementations

impl Clone for FormVariant

fn clone(&self) -> FormVariant

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FormVariant

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for FormVariant

fn eq(&self, other: &FormVariant) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for FormVariant

impl StructuralPartialEq for FormVariant