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

use dominator::{Dom, DomBuilder};
use futures_signals::signal::{always, Always, Signal, SignalExt};
use std::iter::{once, Once};
use web_sys::Element;

pub fn once_cmp(c: DomBuilder<Element>) -> Once<Always<Option<DomBuilder<Element>>>> {
    once(always(Some(c)))
}

pub fn builder_to_dom_signal<T: Signal<Item = DomBuilder<Element>> + Unpin>(
    input: T,
) -> impl Signal<Item = Option<Dom>> {
    input.map(|builder| Some(builder.into_dom()))
}

pub trait ComponentSignal: Signal<Item = Option<Dom>> + Unpin + 'static {}

impl<T> ComponentSignal for T where T: Signal<Item = Option<Dom>> + Unpin + 'static {}

pub type NoSignal = Always<Option<Dom>>;

// pub struct DomOption(pub Option<Dom>);
//
// pub struct ComponentSignal(pub Box<dyn Signal<Item = Option<Dom>> + Unpin>);
//
// impl ComponentSignal {
//     pub fn from_signal<T: Signal<Item = U> + Unpin + 'static, U>(sig: T) -> Self
//     where
//         U: Into<DomOption>,
//     {
//         Self(Box::new(sig.map(|e| e.into().0)))
//     }
// }
//
// impl From<Dom> for DomOption {
//     fn from(v: Dom) -> Self {
//         DomOption(Some(v))
//     }
// }
//
// impl From<Option<Dom>> for DomOption {
//     fn from(v: Option<Dom>) -> Self {
//         DomOption(v)
//     }
// }
//
// impl From<DomBuilder<Element>> for DomOption {
//     fn from(v: DomBuilder<Element>) -> Self {
//         DomOption(Some(v.into_dom()))
//     }
// }
//
// impl From<Dom> for ComponentSignal {
//     fn from(dom_builder: Dom) -> Self {
//         Self(Box::new(always(Some(dom_builder))))
//     }
// }
//
// impl From<DomBuilder<HtmlElement>> for ComponentSignal {
//     fn from(dom_builder: DomBuilder<HtmlElement>) -> Self {
//         Self(Box::new(always(Some(dom_builder.into_dom()))))
//     }
// }