euv_core/reactive/form/

impl.rs

//! `App::use_form` and the matching `HookContext::form`
//! factory. Identical pattern to the profiler factory —
//! see `reactive/profiler/handle.rs` for prior art and the
//! reasoning behind the downcast-ref + index-increment
//! implementation.
use super::*;

impl HookContextFormExt for HookContext {
    fn form() -> FormState {
        let hook_context: HookContext = Self::current();
        let Ok(mut inner) = hook_context.get_inner().try_borrow_mut() else {
            return FormState::new(
                Signal::create(HashMap::new()),
                Signal::create(HashMap::new()),
                Signal::create(HashSet::new()),
                Signal::create(false),
            );
        };
        let index: usize = inner.get_hook_index();
        inner.set_hook_index(index + 1);
        if index < inner.get_hooks().len()
            && let Some(existing) = inner.get_hooks()[index].downcast_ref::<FormState>()
        {
            return existing.clone();
        }
        let state: FormState = FormState::new(
            Signal::create(HashMap::new()),
            Signal::create(HashMap::new()),
            Signal::create(HashSet::new()),
            Signal::create(false),
        );
        if index < inner.get_hooks().len() {
            inner.get_mut_hooks()[index] = Box::new(state.clone());
        } else {
            inner.get_mut_hooks().push(Box::new(state.clone()));
        }
        state
    }
}

impl FormState {
    /// Returns a `Signal` clone of the `values` map.
    ///
    /// Read with `.get()` inside a render closure to
    /// subscribe to value changes. Callers needing a
    /// single field's value should use
    /// `FormState::field(name)` instead, which is a
    /// convenience that avoids re-reading the whole map.
    pub fn values(&self) -> Signal<HashMap<&'static str, String>> {
        self.get_values().clone()
    }

    /// Returns a `Signal` clone of the `errors` map.
    pub fn errors(&self) -> Signal<HashMap<&'static str, String>> {
        self.get_errors().clone()
    }

    /// Returns a `Signal` clone of the `touched` set.
    pub fn touched(&self) -> Signal<HashSet<&'static str>> {
        self.get_touched().clone()
    }

    /// Returns a `Signal<bool>` clone of the `submitting`
    /// flag.
    pub fn submitting(&self) -> Signal<bool> {
        self.get_submitting().clone()
    }

    /// Returns the current value of the named field, or
    /// `""` if the field has never been set.
    ///
    /// This is a snapshot read, not a subscription —
    /// callers inside a render closure that want to
    /// re-render on value changes should use
    /// `state.values().get().get(name).cloned().unwrap_or_default()`
    /// instead, so the closure actually subscribes.
    pub fn field(&self, name: &'static str) -> String {
        self.get_values()
            .get()
            .get(name)
            .cloned()
            .unwrap_or_default()
    }

    /// Returns the current error for the named field, or
    /// `""` if the field has no error.
    ///
    /// Snapshot read — see `field` for the subscription
    /// caveat.
    pub fn error(&self, name: &'static str) -> String {
        self.get_errors()
            .get()
            .get(name)
            .cloned()
            .unwrap_or_default()
    }

    /// Returns `true` if the user has interacted with the
    /// named field.
    pub fn is_touched(&self, name: &'static str) -> bool {
        self.get_touched().get().contains(name)
    }

    /// Sets the value of the named field.
    ///
    /// Marks the field as touched (mirroring the
    /// `oninput` event that triggered the call) and
    /// clears any prior error for the field. The error
    /// clear is a UX choice — the next `validate` call
    /// will repopulate it if the new value is still
    /// invalid.
    pub fn set_field(&self, name: &'static str, value: &str) {
        let mut current: HashMap<&'static str, String> = self.get_values().get();
        current.insert(name, value.to_string());
        self.get_values().set(current);

        let mut touched: HashSet<&'static str> = self.get_touched().get();
        touched.insert(name);
        self.get_touched().set(touched);

        let mut errors: HashMap<&'static str, String> = self.get_errors().get();
        errors.remove(name);
        self.get_errors().set(errors);
    }

    /// Marks the named field as touched without changing
    /// its value. Used by `onblur` handlers — "the user
    /// left this field, so it counts as interacted".
    pub fn touch(&self, name: &'static str) {
        let mut touched: HashSet<&'static str> = self.get_touched().get();
        touched.insert(name);
        self.get_touched().set(touched);
    }

    /// Runs every validator in `validators` and updates the
    /// `errors` signal.
    ///
    /// Returns `true` if every field validated
    /// successfully (i.e. every validator returned
    /// `None`), `false` otherwise. The errors signal is
    /// always updated, regardless of return value —
    /// callers should call `validate` and then branch on
    /// the boolean.
    ///
    /// Fields with no validator are silently skipped —
    /// they cannot produce an error.
    ///
    /// # Arguments
    ///
    /// - `&HashMap<&'static str, Validator>` -
    ///   Per-field validator map. Each validator is a
    ///   closure that takes the current value and
    ///   returns `Some(error_message)` or `None`.
    pub fn validate(&self, validators: &HashMap<&'static str, Validator>) -> bool {
        let values: HashMap<&'static str, String> = self.get_values().get();
        let mut next_errors: HashMap<&'static str, String> = HashMap::new();
        let mut all_valid: bool = true;
        for (name, validator) in validators.iter() {
            let current_value: &str = values.get(name).map(String::as_str).unwrap_or("");
            if let Some(error_message) = validator(current_value) {
                if !error_message.is_empty() {
                    all_valid = false;
                }
                next_errors.insert(name, error_message);
            }
        }
        self.get_errors().set(next_errors);
        all_valid
    }

    /// Runs the user-supplied submit handler if all
    /// validators pass.
    ///
    /// Sets `submitting` to `true` for the duration of the
    /// call (so a `disabled={state.submitting().get()}`
    /// button stays disabled until the handler returns),
    /// then resets it to `false`. If validators were
    /// supplied AND at least one field failed validation,
    /// the submit handler is NOT invoked and `submitting`
    /// is left `false`.
    ///
    /// Returns `true` if the handler was invoked,
    /// `false` if validation failed and the handler was
    /// skipped.
    ///
    /// # Arguments
    ///
    /// - `&HashMap<&'static str, Validator>` -
    ///   Validators to run before invoking the handler.
    ///   Pass an empty map to skip validation entirely
    ///   (the handler always runs).
    /// - `impl FnOnce(&HashMap<&'static str, String>)` -
    ///   The submit handler. Receives the current values
    ///   map by reference — clone what you need to keep
    ///   past the call.
    pub fn submit<F>(&self, validators: &HashMap<&'static str, Validator>, on_submit: F) -> bool
    where
        F: FnOnce(&HashMap<&'static str, String>),
    {
        let all_valid: bool = if validators.is_empty() {
            true
        } else {
            self.validate(validators)
        };
        if !all_valid {
            return false;
        }
        self.get_submitting().set(true);
        let snapshot: HashMap<&'static str, String> = self.get_values().get();
        on_submit(&snapshot);
        self.get_submitting().set(false);
        true
    }

    /// Clears values, errors, and touched state. Leaves
    /// `submitting` untouched (it should already be
    /// `false`).
    ///
    /// Useful for "form submitted successfully, reset for
    /// the next entry" UX flows.
    pub fn reset(&self) {
        self.get_values().set(HashMap::new());
        self.get_errors().set(HashMap::new());
        self.get_touched().set(HashSet::new());
    }

    /// Returns the number of fields that currently have
    /// a non-empty error. Useful for "submit button stays
    /// disabled until form is valid" without re-running
    /// validation.
    pub fn error_count(&self) -> usize {
        self.get_errors()
            .get()
            .values()
            .filter(|message: &&String| !message.is_empty())
            .count()
    }
}