ページとリンク

use hypersig::Route;

hypersig::routes! {
    fn pages(Router<()>);
    // error[E0080]: evaluation panicked: the route's `{name}` segments differ
    // in number from the values of its parameter type
    const MEMBER: Route<i32> = "/members" => member;
}

use axum::Router;
use hypersig::html::{a, each, h1, li, p, ul};
use hypersig::{Page, Route, RouterExt, Signals};
use serde::{Deserialize, Serialize};

#[derive(Signals, Serialize, Deserialize, Clone)]
struct Member {
    id: i32,
    name: String,
}

#[derive(Signals, Serialize, Deserialize)]
struct Team {
    members: Vec<Member>,
}

#[derive(Signals, Serialize, Deserialize)]
struct Profile {
    name: String,
}

hypersig::routes! {
    fn pages(Router<()>);
    const TEAM: Route = "/" => team;
    const MEMBER: Route<i32> = "/members/{id}" => member;
}

fn members() -> Vec<Member> {
    vec![
        Member {
            id: 1,
            name: "Ada".to_owned(),
        },
        Member {
            id: 2,
            name: "Grace".to_owned(),
        },
    ]
}

async fn team((): (), (): ()) -> Page<Team> {
    Page::new("Team", Team { members: members() })
        .child(h1().text("Team"))
        .child(ul().child(each(Team::members(), |member| {
            li().child(
                a().href(MEMBER.link_with(member.at(Member::id())))
                    .bind_text(member.at(Member::name())),
            )
        })))
}

async fn member((): (), id: i32) -> Option<Page<Profile>> {
    let member = members().into_iter().find(|member| member.id == id)?;
    Some(
        Page::new(member.name.clone(), Profile { name: member.name })
            .child(h1().bind_text(Profile::name()))
            .child(p().child(a().href(TEAM.link()).text("Back to the team"))),
    )
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let app = pages(Router::new()).hypersig_runtime();
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await?;
    axum::serve(listener, app).await
}

use hypersig::Route;
use hypersig::html::a;

#[derive(Signals, Serialize, Deserialize)]
struct Search {
    team: String,
}

hypersig::routes! {
    fn pages(Router<()>);
    const MEMBER: Route<(String, i32)> = "/teams/{team}/members/{id}" => member;
}

// Literal parameters give a fixed href, percent-encoded on the server.
let fixed = a::<Search>().href(MEMBER.link_with(("red team", 7)));
assert_eq!(fixed.render(), r#"<a href="/teams/red%20team/members/7"></a>"#);

// A parameter that reads a signal is kept up to date in the browser.
let bound = a().href(MEMBER.link_with((Search::team(), 7)));
assert!(bound.render().contains("data-hs-attr"));

use hypersig::Route;
use hypersig::html::a;

hypersig::routes! {
    fn pages(Router<()>);
    const ORG: Route<String> = "/orgs/{org}" => org;
    // The child repeats the parent's path and parameters, then adds its own.
    const MEMBER: Route<(String, i32)> = "/orgs/{org}/members/{id}" in ORG => member;
}

let link = a::<Org>().href(MEMBER.link_with(("acme", 9)));
assert_eq!(link.render(), r#"<a href="/orgs/acme/members/9"></a>"#);

use hypersig::{Expr, Route, Search, Signals};

#[derive(Signals, Search, Serialize, Deserialize)]
struct Filter {
    q: String,
    page: i32,
    tag: Option<String>,
}

hypersig::routes! {
    fn pages(Router<()>);
    // `team` receives `(String, Filter)`.
    const TEAM: Route<String, Filter> = "/teams/{team}" => team;
}

let first = Filter { q: "rust".to_owned(), page: 1, tag: None };
let link = a::<Filter>().href(TEAM.link_with(("red", &first)));
assert_eq!(link.render(), r#"<a href="/teams/red?page=1&amp;q=rust"></a>"#);

// A field can come from a signal, here the page the reader is on.
let next = Expr::lit(&first).with(Filter::page(), Filter::page() + 1);
let _ = a().href(TEAM.link_with(("red", next)));

use hypersig::html::button;
use hypersig::{Action, PageResponse, Patches, Route};

#[derive(Signals, Serialize, Deserialize)]
struct Draft {
    saving: bool,
}

hypersig::routes! {
    fn pages(Router<()>);
    const POST: Route<i32> = "/posts/{id}" => post;
    const OLD_POST: Route<i32> = "/p/{id}" => old_post;
}

const PUBLISH: Action<Draft> = Action::post("/publish");

// A page handler answers an old address with a redirect.
async fn old_post((): (), id: i32) -> PageResponse {
    PageResponse::redirect(POST.url(id))
}

// An action sends the browser to the page it created.
async fn publish((): (), (): ()) -> Patches<Draft> {
    let id = 7;
    Patches::from(Draft::saving().patch(false)).navigate(POST.url(id))
}

// A button leaves the page after setting a signal.
let _back = button::<Draft>().on_click(Draft::saving().set(false).then(POST.link_with(&1).navigate()));

use hypersig::{Action, Expr, Page, Patches, Route, Search, Signals};

// `/fruit` without a query string leaves `q` as `None`.
#[derive(Signals, Search, Serialize, Deserialize, Default)]
struct Filter {
    q: Option<String>,
}

#[derive(Signals, Serialize, Deserialize)]
struct Fruit {
    query: String,
    matches: Vec<String>,
}

hypersig::routes! {
    fn pages(Router<()>);
    const FRUIT: Route<(), Filter> = "/fruit" => fruit;
}

const SEARCH: Action<Fruit, String> = Action::post("/search");

fn find(q: &str) -> Vec<String> {
    ["apple", "fig", "kiwi"].into_iter().filter(|name| name.contains(q)).map(String::from).collect()
}

// The page renders what the query string names, so Back and Forward load it again.
async fn fruit((): (), filter: Filter) -> Page<Fruit> {
    let q = filter.q.unwrap_or_default();
    let matches = find(&q);
    let query = Fruit::query();
    let shown = Expr::lit(&Filter::default()).with(Filter::q(), query.some());
    Page::new("Fruit", Fruit { query: q, matches }).child(
        input().bind(query).on_debounced(
            Event::Input,
            Duration::from_millis(250),
            // Each pause in typing replaces the URL rather than adding an entry.
            SEARCH.call_with(query).then(FRUIT.link_with(shown).replace_url()),
        ),
    )
}

const CLEAR: Action<Fruit> = Action::post("/clear");

// An action changes the URL too, here as a new entry after emptying the search.
async fn clear((): (), (): ()) -> Patches<Fruit> {
    let empty = Fruit::query().patch(String::new()).and(Fruit::matches().patch(find("")));
    Patches::from(empty).push_url(FRUIT.url(Filter::default()))
}