Struct ModuleBuilder 

pub struct ModuleBuilder<S: State> { /* private fields */ }

Fluent builder for constructing a ModuleDefinition.

Example

use hypen_server::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Clone, Default, Serialize, Deserialize)]
struct Counter { count: i32 }

#[derive(Deserialize)]
struct AddPayload { amount: i32 }

let module = ModuleBuilder::new("Counter")
    .state(Counter { count: 0 })
    .ui(r#"Column { Text("Count: ${state.count}") }"#)
    .on_action::<()>("increment", |state, _, _ctx| {
        state.count += 1;
    })
    .on_action::<AddPayload>("add", |state, payload, _ctx| {
        state.count += payload.amount;
    })
    .build();

Implementations

impl<S: State> ModuleBuilder<S>

pub fn new(name: impl Into<String>) -> Self

pub fn state(self, initial: S) -> Self

Set the initial state for this module.

pub fn ui(self, source: impl Into<String>) -> Self

Set the Hypen DSL template as an inline string.

.ui(r#"
    Column {
        Text("Count: ${state.count}")
        Button("@actions.increment") { Text("+") }
    }
"#)

pub fn ui_file(self, path: impl Into<String>) -> Self

Load the Hypen DSL template from a file path.

The file will be read when the module is instantiated.

pub fn on_action<A>( self, name: impl Into<String>, handler: impl Fn(&mut S, A, Option<&GlobalContext>) + Send + Sync + 'static, ) -> Self

where A: DeserializeOwned + 'static,

Register an action handler with a typed payload.

The type parameter A determines how the action payload is deserialized. Use () for actions that don’t carry a payload.

Examples

// No payload — use ()
.on_action::<()>("increment", |state, _, _ctx| {
    state.count += 1;
})

// Typed payload — any Deserialize type
#[derive(Deserialize)]
struct SetValue { value: i32 }

.on_action::<SetValue>("set_value", |state, payload, _ctx| {
    state.count = payload.value;
})

// Raw JSON access
.on_action::<serde_json::Value>("raw", |state, raw, _ctx| {
    if let Some(n) = raw.as_i64() { state.count = n as i32; }
})

pub fn on_created<F>(self, handler: F) -> Self

where F: Fn(&S, Option<&GlobalContext>) + Send + Sync + 'static,

Called when the module is first mounted.

pub fn on_destroyed<F>(self, handler: F) -> Self

where F: Fn(&S, Option<&GlobalContext>) + Send + Sync + 'static,

Called when the module is destroyed/unmounted.

pub fn on_error<F>(self, handler: F) -> Self

where F: Fn(&ErrorContext) -> ErrorResult + Send + Sync + 'static,

Register an error handler for this module.

pub fn persist(self) -> Self

Mark this module as persistent (survives route changes).

pub fn build(self) -> ModuleDefinition<S>

Consume the builder and produce an immutable ModuleDefinition.