seru 0.1.0

simple image renderer
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

use std::collections::HashMap;

use anyhow::Context;

use crate::{
    core::Value,
    render::{RenderNode, args::Args, components, context::RenderContext},
};

pub type ComponentFunc = fn(
    name: &str,
    args: Args,
    children: Vec<RenderNode>,
    render_context: &RenderContext,
) -> anyhow::Result<RenderNode>;

#[derive(Debug)]
pub struct NativeComponent {
    name: String,
    func: ComponentFunc,
}

impl NativeComponent {
    pub fn new(name: impl Into<String>, func: ComponentFunc) -> Self {
        Self {
            name: name.into(),
            func,
        }
    }
}

pub struct NativeComponentRegistry {
    components: HashMap<String, NativeComponent>,
    render_context: RenderContext,
}

impl NativeComponentRegistry {
    pub fn new(render_context: RenderContext) -> NativeComponentRegistry {
        let mut registry = NativeComponentRegistry {
            components: HashMap::new(),
            render_context,
        };

        registry.register_builtins();
        registry
    }

    fn register_builtins(&mut self) {
        let components = vec![
            NativeComponent::new("Box", components::box_func),
            NativeComponent::new("Column", components::box_func),
            NativeComponent::new("Center", components::box_func),
            NativeComponent::new("Row", components::box_func),
            NativeComponent::new("Stack", components::stack_func),
            NativeComponent::new("Text", components::text_func),
            NativeComponent::new("Image", components::image_func),
            NativeComponent::new("Svg", components::svg_func),
        ];

        for ele in components {
            self.register(ele).expect("dup");
        }
    }

    pub fn has_component(&self, name: &str) -> bool {
        self.components.contains_key(name)
    }

    pub fn register(&mut self, component: NativeComponent) -> anyhow::Result<()> {
        if self.components.contains_key(&component.name) {
            anyhow::bail!("already registered component: {}", component.name);
        }

        self.components.insert(component.name.clone(), component);

        Ok(())
    }

    pub fn create(
        &self,
        name: &str,
        args: HashMap<String, Value>,
        children: Vec<RenderNode>,
    ) -> anyhow::Result<RenderNode> {
        let component = self
            .components
            .get(name)
            .with_context(|| format!("cannot find native component: {}", name))?;

        (component.func)(name, Args::new(args), children, &self.render_context)
    }
}