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
125
126
127
128

use crate::router::RouterContext;
use crate::target::{Mapper, Target};
use wasm_bindgen::JsValue;
use yew::prelude::*;

#[derive(Debug)]
#[doc(hidden)]
pub struct NavigationTarget<T>
where
    T: Target,
{
    pub target: T,
    pub state: JsValue,
}

impl<T> NavigationTarget<T>
where
    T: Target,
{
    pub fn map<F, U>(self, f: F) -> NavigationTarget<U>
    where
        F: FnOnce(T) -> U,
        U: Target,
    {
        NavigationTarget {
            target: f(self.target),
            state: self.state,
        }
    }
}

#[derive(Clone, Debug, PartialEq)]
pub struct ScopeContext<C>
where
    C: Target,
{
    pub(crate) upwards: Callback<NavigationTarget<C>>,
    pub(crate) collect: Callback<C, String>,
}

impl<C> ScopeContext<C>
where
    C: Target,
{
    pub(crate) fn push(&self, target: C) {
        self.upwards.emit(NavigationTarget {
            target,
            state: JsValue::null(),
        });
    }

    pub(crate) fn push_with(&self, target: C, state: JsValue) {
        self.upwards.emit(NavigationTarget { target, state })
    }

    pub(crate) fn collect(&self, target: C) -> String {
        self.collect.emit(target)
    }
}

#[derive(Clone, Debug, PartialEq, Properties)]
pub struct ScopeProps<P, C>
where
    P: Target,
    C: Target,
{
    pub mapper: Callback<(), Mapper<P, C>>,

    #[prop_or_default]
    pub children: Children,
}

/// A component, translating down to the next level.
#[function_component(Scope)]
pub fn scope<P, C>(props: &ScopeProps<P, C>) -> Html
where
    P: Target + 'static,
    C: Target + 'static,
{
    let router = use_context::<RouterContext<P>>()
        .expect("Must be nested under a Router or Nested component of the parent type");

    let parent = use_context::<ScopeContext<P>>()
        .expect("Must be nested under a Router or Nested component of the parent type");

    let Mapper { downwards, upwards } = props.mapper.emit(());

    let scope = use_memo((parent.clone(), upwards), |(parent, upwards)| {
        ScopeContext {
            upwards: {
                let parent = parent.upwards.clone();
                let upwards = upwards.clone();
                Callback::from(move |child: NavigationTarget<C>| {
                    parent.emit(child.map(|child| upwards.emit(child)));
                })
            },
            collect: {
                let parent = parent.collect.clone();
                let upwards = upwards.clone();
                Callback::from(move |child: C| parent.emit(upwards.emit(child)))
            },
        }
    });

    let base = router.base.clone();
    let active = router.active();

    let context = use_memo(
        (
            base,
            scope.clone(),
            active.clone().and_then(|p| downwards.emit(p)),
        ),
        |(base, scope, target)| RouterContext {
            base: base.clone(),
            scope: scope.clone(),
            active_target: target.clone(),
        },
    );

    html!(
        <ContextProvider<RouterContext<C>> context={(*context).clone()}>
            <ContextProvider<ScopeContext<C>> context={(*scope).clone()}>
                { for props.children.iter() }
            </ContextProvider<ScopeContext<C>>>
        </ContextProvider<RouterContext<C>>>
    )
}