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
//!
//! The project aims to enable server side rendering on rust servers in the simplest and lightest way possible.
//!
//! It use an embedded version of the v8 javascript engine (<a href="https://github.com/denoland/rusty_v8" target="_blank">rusty_v8</a>) to parse and evaluate a built bundle file and return a string with the rendered html.
//!
//! Currently it works with Webpack bundler v4.44.2.
//!
//! # Getting started
//! ```toml
//! [dependencies]
//! ssr_rs = "0.3.0"
//! ```
//!
//! # Example
//!
//! To render to string a bundled react project the application should perform the following
//! calls.
//!
//!
//! ```no_run
//! use ssr_rs::Ssr;
//! use std::fs::read_to_string;
//!
//! fn main() {
//! Ssr::create_platform();
//!
//! let source = read_to_string("./path/to/build.js").unwrap();
//!
//! let mut js = Ssr::from(source, "entryPoint").unwrap();
//!
//! let html = js.render_to_string(None).unwrap();
//!
//! assert_eq!(html, "<!doctype html><html>...</html>".to_string());
//! }
//! ```
//! Check how to use it with actix, rocket, warp and other frameworks <a href="https://github.com/Valerioageno/ssr-rs/tree/main/examples" target="_blank">here</a>.
//!
//! # Example with initial props
//!
//! ```no_run
//! use ssr_rs::Ssr;
//! use std::fs::read_to_string;
//!
//! fn main() {
//! Ssr::create_platform();
//!
//! let props = r##"{
//! "params": [
//! "hello",
//! "ciao",
//! "こんにちは"
//! ]
//! }"##;
//!
//! let source = read_to_string("./path/to/build.js").unwrap();
//!
//! let mut js = Ssr::from(source, "entryPoint").unwrap();
//!
//! let html = js.render_to_string(Some(&props)).unwrap();
//!
//! assert_eq!(html, "<!doctype html><html>...</html>".to_string());
//! }
//!```
//!
//! # Example with actix-web
//!
//! > Examples with different web frameworks are available in the <a href="https://github.com/Valerioageno/ssr-rs/blob/main/examples" target="_blank">examples</a> folder.
//!
//! Even though the V8 engine allows accessing the same `isolate` from different threads that is forbidden by this crate for two reasons:
//! 1. rusty_v8 library have not implemented yet the V8 Locker API. Accessing Ssr struct from a different thread will make the V8 engine to panic.
//! 2. Rendering HTML does not need shared state across threads.
//!
//! For this reason parallel computation is a better choice. Following actix-web setup:
//!
//! ```no_run
//! use actix_web::{get, http::StatusCode, App, HttpResponse, HttpServer};
//! use std::cell::RefCell;
//! use std::fs::read_to_string;
//!
//! use ssr_rs::Ssr;
//!
//! thread_local! {
//! static SSR: RefCell<Ssr<'static, 'static>> = RefCell::new(
//! Ssr::from(
//! read_to_string("./client/dist/ssr/index.js").unwrap(),
//! "SSR"
//! ).unwrap()
//! )
//!}
//!
//! #[actix_web::main]
//!async fn main() -> std::io::Result<()> {
//! Ssr::create_platform();
//!
//! HttpServer::new(|| {
//! App::new()
//! .service(index)
//! })
//! .bind("127.0.0.1:8080")?
//! .run()
//! .await
//! }
//!
//! #[get("/")]
//! async fn index() -> HttpResponse {
//! let result = SSR.with(|ssr| ssr.borrow_mut().render_to_string(None).unwrap());
//!
//! HttpResponse::build(StatusCode::OK)
//! .content_type("text/html; charset=utf-8")
//! .body(result)
//! }
//!```
pub use Ssr;