yew-router-nested 0.16.1

A router implementation for the Yew framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

#![recursion_limit = "128"]
//! Provides routing faculties for the Yew web framework.
//!
//! ## Contents
//! This crate consists of multiple types, some independently useful on their own,
//! that are used together to facilitate routing within the Yew framework.
//! Among them are:
//! * RouteService - Hooks into the History API and listens to `PopStateEvent`s to respond to users
//!   clicking the back/forwards buttons.
//! * RouteAgent - A singleton agent that owns a RouteService that provides an easy place for other
//!   components and agents to hook into it.
//! * Switch - A trait/derive macro that allows specification of how enums or structs can be constructed
//! from Routes.
//! * Router - A component connected to the RouteAgent, and is capable of resolving Routes to
//! Switch implementors, so you can use them to render Html.
//! * Route - A struct containing an the route string and state.
//! * RouteButton & RouteLink - Wrapper components around buttons and anchor tags respectively that
//!   allow users to change the route.
//!
//! ## State and Aliases
//! Because the History API allows you to store data along with a route string,
//! most types have at type parameter that allows you to specify which type is being stored.
//! As this behavior is uncommon, aliases using the unit type (`()`) are provided to remove the
//! need to specify the storage type you likely aren't using.
//!
//! If you want to store state using the history API, it is recommended that you generate your own
//! aliases using the `define_router_state` macro.
//! Give it a typename, and it will generate a module containing aliases and functions useful for
//! routing. If you specify your own router_state aliases and functions, you will want to disable
//! the `unit_alias` feature to prevent the default `()` aliases from showing up in the prelude.
//!
//! ## Features
//! This crate has some feature-flags that allow you to not include some parts in your compilation.
//! * "default" - Everything is included by default.
//! * "core" - The fully feature complete ("router", "components", "matchers"), but without
//!   unit_alias.
//! * "unit_alias" - If enabled, a module will be added to the route and expanded within the prelude
//! for aliases of Router types to their `()` variants.
//! * "router" - If enabled, the Router component and its dependent infrastructure (including
//!   "agent") will be included.
//! * "agent" - If enabled, the RouteAgent and its associated types will be included.
//! * "components" - If enabled, the accessory components will be made available.

#![deny(
    missing_docs,
    missing_debug_implementations,
    missing_copy_implementations,
    trivial_casts,
    trivial_numeric_casts,
    unsafe_code,
    unstable_features,
    unused_qualifications
)]
// This will break the project at some point, but it will break yew as well.
// It can be dealt with at the same time.
#![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]

pub use yew_router_route_parser;

#[macro_use]
mod alias;

#[cfg(feature = "service")]
pub mod service;

#[cfg(feature = "agent")]
pub mod agent;

pub mod route;

#[cfg(feature = "components")]
pub mod components;

#[cfg(feature = "router")]
pub mod router;

/// Prelude module that can be imported when working with the yew_router
pub mod prelude {
    pub use super::matcher::Captures;

    #[cfg(feature = "service")]
    pub use crate::route::RouteState;
    #[cfg(feature = "service")]
    pub use crate::service::RouteService;

    #[cfg(feature = "agent")]
    pub use crate::agent::RouteAgent;
    #[cfg(feature = "agent")]
    pub use crate::agent::RouteAgentBridge;
    #[cfg(feature = "agent")]
    pub use crate::agent::RouteAgentDispatcher;

    #[cfg(feature = "components")]
    pub use crate::components::RouterAnchor;
    #[cfg(feature = "components")]
    pub use crate::components::RouterButton;

    #[cfg(feature = "router")]
    pub use crate::router::Router;

    #[cfg(feature = "router")]
    pub use crate::router::RouterState;

    pub use crate::{
        route::Route,
        switch::{Routable, Switch},
    };
    pub use yew_router_macro::Switch;
}

pub use alias::*;

pub mod matcher;

pub use matcher::Captures;

#[cfg(feature = "service")]
pub use crate::route::RouteState;
#[cfg(feature = "router")]
pub use crate::router::RouterState;

pub mod switch;
pub use switch::Switch;
pub use yew_router_macro::Switch;