cinnog 0.6.0

Data layer and helper methods for static site generation with Leptos
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

use crate::datalayer::Datalayer;
use crate::world::DataWorld;
use bevy_app::{App, Plugins};
use bevy_ecs::bundle::Bundle;
use bevy_ecs::prelude;
use bevy_ecs::prelude::{EntityWorldMut, IntoSystem, SystemInput, World};
use leptos::prelude::*;
use leptos_axum::generate_route_list_with_exclusions_and_ssg_and_context;
#[cfg(feature = "development")]
use leptos_axum::LeptosRoutes;
use std::sync::{Arc, Mutex};

/// The static site generator.
///
/// You can manipulate the datalayer through adding [`Plugins`] and [`Resource`]s to the generator.
pub struct Generator {
    /// The Bevy [`App`] that holds the ECS world used as datalayer
    pub app: App,
}

impl Generator {
    /// Create a new, empty [`Generator`]
    pub fn new() -> Self {
        Generator { app: App::new() }
    }

    /// Insert a [`Resource`] to the [`Generator`]
    pub fn insert_resource<R: prelude::Resource>(&mut self, value: R) -> &mut Self {
        self.app.insert_resource(value);
        self
    }

    /// Add ECS [`Plugins`] to the [`Generator`]
    pub fn add_plugins<M>(&mut self, plugins: impl Plugins<M>) -> &mut Self {
        self.app.add_plugins(plugins);
        self
    }

    /// Build the static site.
    ///
    /// If the `development` feature is enabled, this method will serve the static site using
    /// axum server.
    pub async fn build<IV>(&mut self, shell_fn: fn(LeptosOptions) -> IV) -> std::io::Result<()>
    where
        IV: IntoView + 'static,
    {
        self.app.update();
        let world = std::mem::replace(self.app.world_mut(), World::new());
        let datalayer = Datalayer::new(world);
        let data = Arc::new(Mutex::new(datalayer));
        let data_for_route_generation = data.clone();

        let conf = get_configuration(None).unwrap();
        let leptos_options = conf.leptos_options.clone();

        #[cfg_attr(not(feature = "development"), allow(unused_variables))]
        let (routes, static_data_map) = generate_route_list_with_exclusions_and_ssg_and_context(
            move || shell_fn(leptos_options.clone()),
            None,
            move || provide_context(data_for_route_generation.clone()),
        );

        static_data_map.generate(&conf.leptos_options).await;

        #[cfg(feature = "development")]
        {
            use axum::Router;

            let addr = conf.leptos_options.site_addr;
            println!("listening on http://{}", &addr);

            let app = Router::new()
                .leptos_routes_with_context(
                    &conf.leptos_options,
                    routes,
                    move || provide_context(data.clone()),
                    {
                        let leptos_options = conf.leptos_options.clone();
                        move || shell_fn(leptos_options.clone())
                    },
                )
                .fallback(leptos_axum::file_and_error_handler(shell_fn))
                .with_state(conf.leptos_options);
            let listener = tokio::net::TcpListener::bind(&addr).await?;
            axum::serve(listener, app.into_make_service())
                .await
                .expect("Failed to start development server");
        }
        Ok(())
    }
}

impl DataWorld for Generator {
    fn run<S, In, Out, Marker>(&mut self, system: S, input: In::Inner<'_>) -> Out
    where
        S: IntoSystem<In, Out, Marker> + 'static,
        Out: 'static,
        In: SystemInput + 'static,
    {
        self.app
            .world_mut()
            .run_system_cached_with(system, input)
            .expect("Failed to execute system")
    }

    fn get_resource<R: prelude::Resource + Clone>(&self) -> Option<R> {
        self.app.world().get_resource::<R>().cloned()
    }

    fn spawn<B: Bundle>(&mut self, bundle: B) -> EntityWorldMut<'_> {
        self.app.world_mut().spawn(bundle)
    }
}

impl Default for Generator {
    fn default() -> Self {
        Self::new()
    }
}