├── .gitignore
├── Cargo.toml
├── README.md
├── const_str_slice_concat
    ├── Cargo.toml
    └── src
    │   └── lib.rs
├── examples
    ├── gtk
    │   ├── Cargo.toml
    │   └── src
    │   │   ├── main.rs
    │   │   └── tachygtk.rs
    ├── hackernews
    │   ├── .cargo
    │   │   └── config.toml
    │   ├── Cargo.toml
    │   ├── LICENSE
    │   ├── Makefile.toml
    │   ├── README.md
    │   ├── index.html
    │   ├── public
    │   │   └── favicon.ico
    │   ├── src
    │   │   ├── api.rs
    │   │   ├── lib.rs
    │   │   ├── main.rs
    │   │   ├── routes.rs
    │   │   └── routes
    │   │   │   ├── nav.rs
    │   │   │   ├── stories.rs
    │   │   │   ├── story.rs
    │   │   │   └── users.rs
    │   └── style.css
    ├── hackernews_islands_axum
    │   ├── .cargo
    │   │   └── config.wasm.toml
    │   ├── .dockerignore
    │   ├── .gitignore
    │   ├── Cargo.toml
    │   ├── Dockerfile
    │   ├── LICENSE
    │   ├── Makefile.toml
    │   ├── README.md
    │   ├── build-front.sh
    │   ├── public
    │   │   └── favicon.ico
    │   └── src
    │   │   ├── api.rs
    │   │   ├── fallback.rs
    │   │   ├── lib.rs
    │   │   ├── main.rs
    │   │   ├── routes.rs
    │   │   └── routes
    │   │       ├── nav.rs
    │   │       ├── stories.rs
    │   │       ├── story.rs
    │   │       └── users.rs
    ├── hydration
    │   ├── .cargo
    │   │   └── config.toml
    │   ├── .gitignore
    │   ├── Cargo.toml
    │   ├── LICENSE
    │   ├── README.md
    │   ├── assets
    │   │   └── favicon.ico
    │   ├── end2end
    │   │   ├── package-lock.json
    │   │   ├── package.json
    │   │   ├── playwright.config.ts
    │   │   └── tests
    │   │   │   └── example.spec.ts
    │   ├── rust-toolchain.toml
    │   ├── src
    │   │   ├── app.rs
    │   │   ├── lib.rs
    │   │   ├── main.rs
    │   │   └── shell.html
    │   └── style
    │   │   └── main.scss
    └── playground
    │   ├── .cargo
    │       └── config.toml
    │   ├── .gitignore
    │   ├── Cargo.toml
    │   ├── index.html
    │   └── src
    │       └── main.rs
├── next_tuple
    ├── Cargo.toml
    └── src
    │   └── lib.rs
├── rustfmt.toml
├── tachy_maccy
    ├── Cargo.toml
    └── src
    │   ├── component.rs
    │   ├── lib.rs
    │   └── view
    │       ├── component_builder.rs
    │       └── mod.rs
├── tachy_reaccy
    ├── Cargo.toml
    ├── src
    │   ├── arena.rs
    │   ├── async_signal
    │   │   ├── derived.rs
    │   │   ├── mod.rs
    │   │   └── resource.rs
    │   ├── context.rs
    │   ├── effect.rs
    │   ├── lib.rs
    │   ├── memo.rs
    │   ├── notify.rs
    │   ├── render_effect.rs
    │   ├── selector.rs
    │   ├── serde.rs
    │   ├── serialization.rs
    │   ├── shared_context
    │   │   ├── hydrate.rs
    │   │   ├── mod.rs
    │   │   └── ssr.rs
    │   ├── signal
    │   │   ├── arc_signal.rs
    │   │   ├── mod.rs
    │   │   ├── read.rs
    │   │   ├── trigger.rs
    │   │   └── write.rs
    │   ├── signal_traits.rs
    │   ├── source.rs
    │   ├── spawn.rs
    │   └── store
    │   │   ├── indexed.rs
    │   │   ├── keyed.rs
    │   │   ├── mod.rs
    │   │   ├── path.rs
    │   │   └── stored.rs
    └── tests
    │   ├── effect.rs
    │   ├── memo.rs
    │   └── signal.rs
├── tachy_reaccy_macro
    ├── Cargo.toml
    └── src
    │   └── lib.rs
├── tachy_route
    ├── Cargo.toml
    └── src
    │   ├── generate_route_list.rs
    │   ├── lib.rs
    │   ├── location
    │       ├── mod.rs
    │       └── state.rs
    │   ├── matching
    │       ├── mod.rs
    │       ├── param_segments.rs
    │       └── static_segment.rs
    │   ├── reactive
    │       └── mod.rs
    │   ├── render_mode.rs
    │   ├── route
    │       ├── method.rs
    │       ├── mod.rs
    │       └── route_child.rs
    │   ├── router.rs
    │   └── static_render.rs
├── tachydom
    ├── Cargo.toml
    ├── TODO.md
    └── src
    │   ├── async_views
    │       └── mod.rs
    │   ├── dom.rs
    │   ├── error.rs
    │   ├── html
    │       ├── attribute
    │       │   ├── aria.rs
    │       │   ├── custom.rs
    │       │   ├── global.rs
    │       │   ├── key.rs
    │       │   ├── mod.rs
    │       │   └── value.rs
    │       ├── class.rs
    │       ├── element
    │       │   ├── custom.rs
    │       │   ├── elements.rs
    │       │   ├── inner_html.rs
    │       │   └── mod.rs
    │       ├── event.rs
    │       ├── islands.rs
    │       ├── mod.rs
    │       ├── node_ref.rs
    │       ├── property.rs
    │       └── style.rs
    │   ├── hydration.rs
    │   ├── leptos
    │       ├── class.rs
    │       ├── mod.rs
    │       └── style.rs
    │   ├── lib.rs
    │   ├── mathml
    │       └── mod.rs
    │   ├── renderer
    │       ├── dom.rs
    │       ├── mock_dom.rs
    │       └── mod.rs
    │   ├── spawner
    │       └── mod.rs
    │   ├── ssr
    │       └── mod.rs
    │   ├── svg
    │       └── mod.rs
    │   ├── tachy_reaccy
    │       ├── class.rs
    │       ├── mod.rs
    │       ├── node_ref.rs
    │       └── style.rs
    │   └── view
    │       ├── any_view.rs
    │       ├── dynamic.rs
    │       ├── either.rs
    │       ├── error_boundary.rs
    │       ├── iterators.rs
    │       ├── keyed.rs
    │       ├── mod.rs
    │       ├── primitives.rs
    │       ├── static_types.rs
    │       ├── strings.rs
    │       ├── template.rs
    │       └── tuples.rs
└── tachys
    ├── Cargo.toml
    └── src
        ├── children.rs
        ├── component.rs
        ├── for_loop.rs
        ├── hydration_scripts
            ├── hydration_script.js
            ├── island_script.js
            ├── mod.rs
            └── reload_script.js
        ├── lib.rs
        └── show.rs


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Generated by Cargo
 2 | # will have compiled files and executables
 3 | debug/
 4 | target/
 5 | dist/
 6 | 
 7 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 8 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 9 | Cargo.lock
10 | 
11 | # These are backup files generated by rustfmt
12 | **/*.rs.bk
13 | 
14 | # MSVC Windows builds of rustc generate these, which store debugging information
15 | *.pdb
16 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [workspace]
 2 | resolver = "2"
 3 | members = [
 4 | 	"const_str_slice_concat",
 5 | 	"next_tuple",
 6 | 	"tachys",
 7 | 	"tachydom",
 8 | 	"tachy_maccy",
 9 | 	"tachy_reaccy",
10 | 	"tachy_reaccy_macro",
11 | 	"tachy_route",
12 | ]
13 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | **Work on this repo has moved into [the `leptos_0.7` branch of the main Leptos repository](https://github.com/leptos-rs/leptos/tree/leptos_0.7).**
 2 | 
 3 | # tachys
 4 | ### Experimental web UI library for Rust.
 5 | 
 6 | This is a playground and exploration space for the future development of a new renderer Leptos 0.6. It uses the concept of a statically-typed view tree, similar to SwiftUI and introduced to the Rust UI space by [Xilem](https://github.com/linebender/xilem) and [Concoct](https://github.com/concoct-rs/concoct/).
 7 | 
 8 | This has some *serious* advantages that have not been explored by these other libraries with regard to server-side HTML rendering and extremely efficient and robust hydration, as well as compile-time `<template>` tag building etc. 
 9 | 
10 | Feel free to use this or explore or steal ideas, but **do not expect this to be a maintained library.**
11 | 
12 | > The name: ταχύς means “fast” or “swift,” which is both a) true (this is quite fast) and b) a bit of a pun, as the method of using statically-typed views is inspired by SwiftUI.
13 | 


--------------------------------------------------------------------------------
/const_str_slice_concat/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "const_str_slice_concat"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/const_str_slice_concat/src/lib.rs:
--------------------------------------------------------------------------------
  1 | pub(crate) const MAX_TEMPLATE_SIZE: usize = 4096;
  2 | 
  3 | /// Converts a zero-terminated buffer of bytes into a UTF-8 string.
  4 | pub const fn str_from_buffer(buf: &[u8; MAX_TEMPLATE_SIZE]) -> &str {
  5 |     match std::ffi::CStr::from_bytes_until_nul(buf) {
  6 |         Ok(cstr) => match cstr.to_str() {
  7 |             Ok(str) => str,
  8 |             Err(_) => panic!("TEMPLATE FAILURE"),
  9 |         },
 10 |         Err(_) => panic!("TEMPLATE FAILURE"),
 11 |     }
 12 | }
 13 | 
 14 | /// Concatenates any number of static strings in a single one.
 15 | // credit to Rainer Stropek, "Constant fun," Rust Linz, June 2022
 16 | pub const fn const_concat(
 17 |     strs: &'static [&'static str],
 18 | ) -> [u8; MAX_TEMPLATE_SIZE] {
 19 |     let mut buffer = [0; MAX_TEMPLATE_SIZE];
 20 |     let mut position = 0;
 21 |     let mut remaining = strs;
 22 | 
 23 |     while let [current, tail @ ..] = remaining {
 24 |         let x = current.as_bytes();
 25 |         let mut i = 0;
 26 | 
 27 |         // have it iterate over bytes manually, because, again,
 28 |         // no mutable refernces in const fns
 29 |         while i < x.len() {
 30 |             buffer[position] = x[i];
 31 |             position += 1;
 32 |             i += 1;
 33 |         }
 34 | 
 35 |         remaining = tail;
 36 |     }
 37 | 
 38 |     buffer
 39 | }
 40 | 
 41 | /// Converts a zero-terminated buffer of bytes into a UTF-8 string with the given prefix.
 42 | pub const fn const_concat_with_prefix(
 43 |     strs: &'static [&'static str],
 44 |     prefix: &'static str,
 45 |     suffix: &'static str,
 46 | ) -> [u8; MAX_TEMPLATE_SIZE] {
 47 |     let mut buffer = [0; MAX_TEMPLATE_SIZE];
 48 |     let mut position = 0;
 49 |     let mut remaining = strs;
 50 | 
 51 |     while let [current, tail @ ..] = remaining {
 52 |         let x = current.as_bytes();
 53 |         let mut i = 0;
 54 | 
 55 |         // have it iterate over bytes manually, because, again,
 56 |         // no mutable refernces in const fns
 57 |         while i < x.len() {
 58 |             buffer[position] = x[i];
 59 |             position += 1;
 60 |             i += 1;
 61 |         }
 62 | 
 63 |         remaining = tail;
 64 |     }
 65 | 
 66 |     if buffer[0] == 0 {
 67 |         buffer
 68 |     } else {
 69 |         let mut new_buf = [0; MAX_TEMPLATE_SIZE];
 70 |         let prefix = prefix.as_bytes();
 71 |         let suffix = suffix.as_bytes();
 72 |         let mut position = 0;
 73 |         let mut i = 0;
 74 |         while i < prefix.len() {
 75 |             new_buf[position] = prefix[i];
 76 |             position += 1;
 77 |             i += 1;
 78 |         }
 79 |         i = 0;
 80 |         while i < buffer.len() {
 81 |             if buffer[i] == 0 {
 82 |                 break;
 83 |             }
 84 |             new_buf[position] = buffer[i];
 85 |             position += 1;
 86 |             i += 1;
 87 |         }
 88 |         i = 0;
 89 |         while i < suffix.len() {
 90 |             new_buf[position] = suffix[i];
 91 |             position += 1;
 92 |             i += 1;
 93 |         }
 94 | 
 95 |         new_buf
 96 |     }
 97 | }
 98 | 
 99 | /// Converts any number of strings into a UTF-8 string, separated by the given string.
100 | pub const fn const_concat_with_separator(
101 |     strs: &[&str],
102 |     separator: &'static str,
103 | ) -> [u8; MAX_TEMPLATE_SIZE] {
104 |     let mut buffer = [0; MAX_TEMPLATE_SIZE];
105 |     let mut position = 0;
106 |     let mut remaining = strs;
107 | 
108 |     while let [current, tail @ ..] = remaining {
109 |         let x = current.as_bytes();
110 |         let mut i = 0;
111 | 
112 |         // have it iterate over bytes manually, because, again,
113 |         // no mutable refernces in const fns
114 |         while i < x.len() {
115 |             buffer[position] = x[i];
116 |             position += 1;
117 |             i += 1;
118 |         }
119 |         if !x.is_empty() {
120 |             let mut position = 0;
121 |             let separator = separator.as_bytes();
122 |             while i < separator.len() {
123 |                 buffer[position] = separator[i];
124 |                 position += 1;
125 |                 i += 1;
126 |             }
127 |         }
128 | 
129 |         remaining = tail;
130 |     }
131 | 
132 |     buffer
133 | }
134 | 


--------------------------------------------------------------------------------
/examples/gtk/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "gtk"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 7 | 
 8 | [dependencies]
 9 | tachydom = { path = "../../tachydom", features = ["nightly", "reaccy"] }
10 | gtk = { version = "0.5.0", package = "gtk4" }
11 | tachy_reaccy = { path = "../../tachy_reaccy", features = ["glib"] }
12 | 
13 | [workspace]
14 | 


--------------------------------------------------------------------------------
/examples/gtk/src/main.rs:
--------------------------------------------------------------------------------
 1 | use gtk::{prelude::*, Application, ApplicationWindow, Button, Orientation};
 2 | use std::{future::pending, thread, time::Duration};
 3 | use tachy_reaccy::prelude::*;
 4 | use tachydom::view::{keyed::keyed, strings::StrState, Mountable, Render};
 5 | use tachygtk::{button, r#box, Box_, Element, ElementState, TachyGtk};
 6 | mod tachygtk;
 7 | 
 8 | const APP_ID: &str = "dev.leptos.Counter";
 9 | 
10 | fn main() {
11 |     let app = Application::builder().application_id(APP_ID).build();
12 | 
13 |     app.connect_activate(|app| {
14 |         println!("X");
15 |         let view = ui();
16 | 
17 |         // Connect to "activate" signal of `app`
18 |         let mut state = view.build();
19 | 
20 |         let window = ApplicationWindow::builder()
21 |             .application(app)
22 |             .title("TachyGTK")
23 |             .child(&state.0 .0)
24 |             .build();
25 | 
26 |         // Present window
27 |         window.present();
28 | 
29 |         println!("mounting");
30 |     });
31 |     app.run();
32 | }
33 | 
34 | fn ui() -> Box_<impl Render<TachyGtk>> {
35 |     let value = Signal::new(0);
36 |     let rows = Signal::new(vec![1, 2, 3, 4, 5]);
37 | 
38 |     Effect::new(move |_| {
39 |         println!("value = {}", value.get());
40 |     });
41 | 
42 |     // just an example of multithreaded reactivity
43 |     thread::spawn(move || loop {
44 |         thread::sleep(Duration::from_millis(250));
45 |         value.update(|n| *n += 1);
46 |     });
47 | 
48 |     r#box(
49 |         Orientation::Vertical,
50 |         12,
51 |         (
52 |             r#box(
53 |                 Orientation::Vertical,
54 |                 12,
55 |                 (
56 |                     r#box(
57 |                         Orientation::Horizontal,
58 |                         12,
59 |                         (
60 |                             button("-1", move |_| value.update(|n| *n -= 1)),
61 |                             move || value.get().to_string(),
62 |                             button("+1", move |_| value.update(|n| *n += 1)),
63 |                         ),
64 |                     ),
65 |                     //move || (value.get() % 2 == 0).then_some("Even!"),
66 |                 ),
67 |             ),
68 |             r#box(
69 |                 Orientation::Vertical,
70 |                 12,
71 |                 (
72 |                     button("Swap", move |_| {
73 |                         rows.update(|items| {
74 |                             items.swap(1, 3);
75 |                             println!("{items:?}");
76 |                         })
77 |                     }),
78 |                     r#box(Orientation::Vertical, 12, move || {
79 |                         keyed(rows.get(), |k| *k, |v| v.to_string())
80 |                     }),
81 |                 ),
82 |             ),
83 |         ),
84 |     )
85 | }
86 | 


--------------------------------------------------------------------------------
/examples/hackernews/.cargo/config.toml:
--------------------------------------------------------------------------------
1 | [unstable]
2 | build-std = ["std", "panic_abort", "core", "alloc"]
3 | build-std-features = ["panic_immediate_abort"]
4 | 
5 | [build]
6 | rustflags = [
7 | 	"-Zlocation-detail=none",
8 | ]
9 | 


--------------------------------------------------------------------------------
/examples/hackernews/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "hackernews"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [lib]
 7 | crate-type = ["cdylib", "rlib"]
 8 | 
 9 | [profile.release]
10 | opt-level = 'z'   # CSR only
11 | codegen-units = 1
12 | lto = true
13 | 
14 | [dependencies]
15 | actix-files = { version = "0.6", optional = true }
16 | actix-web = { version = "4", optional = true, features = ["macros"] }
17 | console_log = "1"
18 | console_error_panic_hook = "0.1"
19 | cfg-if = "1"
20 | leptos_config = "0.6"
21 | tachys = { path = "../../tachys", features = ["islands", "nightly", "web"] }
22 | tachy_reaccy = { path = "../../tachy_reaccy", features = ["miniserde"] }
23 | tachy_route = { path = "../../tachy_route", features = ["reaccy"] }
24 | log = "0.4"
25 | serde = { version = "1", features = ["derive"] }
26 | gloo-net = { version = "0.2", features = ["http"] }
27 | reqwest = { version = "0.11", features = ["json"] }
28 | tracing = "0.1"
29 | # openssl = { version = "0.10", features = ["v110"] }
30 | wasm-bindgen = "0.2"
31 | web-sys = { version = "0.3", features = ["AbortController", "AbortSignal"] }
32 | send_wrapper = { version = "0.6.0", features = ["futures"] }
33 | futures = "0.3.30"
34 | 
35 | [features]
36 | default = []
37 | csr = []
38 | hydrate = ["tachys/hydration"]
39 | ssr = ["tachys/hydration", "tachys/tokio", "dep:actix-files", "dep:actix-web"]
40 | 
41 | [profile.wasm-release]
42 | inherits = "release"
43 | opt-level = 'z'
44 | lto = true
45 | codegen-units = 1
46 | 
47 | [package.metadata.cargo-all-features]
48 | denylist = ["actix-files", "actix-web", "leptos_actix"]
49 | skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
50 | 
51 | [package.metadata.leptos]
52 | # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
53 | output-name = "hackernews"
54 | # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
55 | site-root = "target/site"
56 | # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
57 | # Defaults to pkg	
58 | site-pkg-dir = "pkg"
59 | # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
60 | style-file = "./style.css"
61 | # [Optional] Files in the asset-dir will be copied to the site-root directory
62 | assets-dir = "public"
63 | # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
64 | site-addr = "127.0.0.1:3000"
65 | # The port to use for automatic reload monitoring
66 | reload-port = 3001
67 | # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
68 | end2end-cmd = "npx playwright test"
69 | #  The browserlist query used for optimizing the CSS.
70 | browserquery = "defaults"
71 | # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head
72 | watch = false
73 | # The environment Leptos will run in, usually either "DEV" or "PROD"
74 | env = "DEV"
75 | # The features to use when compiling the bin target
76 | #
77 | # Optional. Can be over-ridden with the command line parameter --bin-features
78 | bin-features = ["ssr"]
79 | 
80 | # If the --no-default-features flag should be used when compiling the bin target
81 | #
82 | # Optional. Defaults to false.
83 | bin-default-features = false
84 | 
85 | # The features to use when compiling the lib target
86 | #
87 | # Optional. Can be over-ridden with the command line parameter --lib-features
88 | lib-features = ["hydrate"]
89 | 
90 | # If the --no-default-features flag should be used when compiling the lib target
91 | #
92 | # Optional. Defaults to false.
93 | lib-default-features = false
94 | 
95 | lib-profile-release = "wasm-release"
96 | 
97 | [workspace]
98 | 


--------------------------------------------------------------------------------
/examples/hackernews/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Greg Johnston
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/examples/hackernews/Makefile.toml:
--------------------------------------------------------------------------------
1 | extend = [
2 |     { path = "../cargo-make/main.toml" },
3 |     { path = "../cargo-make/cargo-leptos.toml" },
4 | ]
5 | 
6 | [env]
7 | 
8 | CLIENT_PROCESS_NAME = "hackernews"
9 | 


--------------------------------------------------------------------------------
/examples/hackernews/README.md:
--------------------------------------------------------------------------------
1 | # Leptos Hacker News Example
2 | 
3 | This example creates a basic clone of the Hacker News site. It showcases Leptos' ability to create both a client-side rendered app, and a server side rendered app with hydration, in a single repository
4 | 
5 | ## Getting Started
6 | 
7 | See the [Examples README](../README.md) for setup and run instructions.
8 | 


--------------------------------------------------------------------------------
/examples/hackernews/index.html:
--------------------------------------------------------------------------------
1 | <!DOCTYPE html>
2 | <html>
3 | 	<head>
4 | 		<link data-trunk rel="rust" data-wasm-opt="z" data-cargo-features="csr"/>
5 | 		<link data-trunk rel="css" href="./style.css"/>
6 | 	</head>
7 | 	<body></body>
8 | </html>


--------------------------------------------------------------------------------
/examples/hackernews/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gbj/tachys/cc7503c49c6beb977189167c63bd1c6770d39539/examples/hackernews/public/favicon.ico


--------------------------------------------------------------------------------
/examples/hackernews/src/api.rs:
--------------------------------------------------------------------------------
 1 | use serde::{de::DeserializeOwned, Deserialize, Serialize};
 2 | 
 3 | pub fn story(path: &str) -> String {
 4 |     format!("https://node-hnapi.herokuapp.com/{path}")
 5 | }
 6 | 
 7 | pub fn user(path: &str) -> String {
 8 |     format!("https://hacker-news.firebaseio.com/v0/user/{path}.json")
 9 | }
10 | 
11 | #[cfg(not(feature = "ssr"))]
12 | pub async fn fetch_api<T>(path: &str) -> Option<T>
13 | where
14 |     T: DeserializeOwned + Default,
15 | {
16 |     // abort in-flight requests if, e.g., we've navigated away from this page
17 |     // TODO on_cleanup
18 |     /* tachys::on_cleanup(move || {
19 |         if let Some(abort_controller) = abort_controller {
20 |             abort_controller.abort()
21 |         }
22 |     }); */
23 | 
24 |     let abort_controller = web_sys::AbortController::new().ok();
25 |     let abort_signal = abort_controller.as_ref().map(|a| a.signal());
26 | 
27 |     gloo_net::http::Request::get(path)
28 |         .abort_signal(abort_signal.as_ref())
29 |         .send()
30 |         .await
31 |         .map_err(|e| log::error!("{e}"))
32 |         .ok()?
33 |         .json()
34 |         .await
35 |         .ok()
36 | }
37 | 
38 | #[cfg(feature = "ssr")]
39 | pub async fn fetch_api<T>(path: &str) -> Option<T>
40 | where
41 |     T: DeserializeOwned,
42 | {
43 |     reqwest::get(path)
44 |         .await
45 |         .map_err(|e| log::error!("{e}"))
46 |         .ok()?
47 |         .json()
48 |         .await
49 |         .ok()?
50 | }
51 | 
52 | #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Default)]
53 | pub struct Story {
54 |     pub id: usize,
55 |     pub title: String,
56 |     pub points: Option<i32>,
57 |     pub user: Option<String>,
58 |     pub time: usize,
59 |     pub time_ago: String,
60 |     #[serde(alias = "type")]
61 |     pub story_type: String,
62 |     pub url: String,
63 |     #[serde(default)]
64 |     pub domain: String,
65 |     #[serde(default)]
66 |     pub comments: Option<Vec<Comment>>,
67 |     pub comments_count: Option<usize>,
68 | }
69 | 
70 | #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Default)]
71 | pub struct Comment {
72 |     pub id: usize,
73 |     pub level: usize,
74 |     pub user: Option<String>,
75 |     pub time: usize,
76 |     pub time_ago: String,
77 |     pub content: Option<String>,
78 |     pub comments: Vec<Comment>,
79 | }
80 | 
81 | #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Default)]
82 | pub struct User {
83 |     pub created: usize,
84 |     pub id: String,
85 |     pub karma: i32,
86 |     pub about: Option<String>,
87 | }
88 | 


--------------------------------------------------------------------------------
/examples/hackernews/src/lib.rs:
--------------------------------------------------------------------------------
 1 | use tachy_route::{
 2 |     location::{BrowserUrl, RequestUrl},
 3 |     matching::{ParamSegment, StaticSegment},
 4 |     reactive::{reactive_route, ReactiveRouter},
 5 |     route::{PossibleRoutes, RouteDefinition},
 6 |     router::FallbackOrView,
 7 | };
 8 | use tachys::{island, prelude::*, tachydom::dom::body};
 9 | mod api;
10 | mod routes;
11 | use routes::{nav::Nav, stories::Stories, story::Story, users::User};
12 | use tachys::children::Children;
13 | 
14 | #[component]
15 | pub fn App() -> impl RenderHtml<Dom> {
16 |     //provide_meta_context();
17 |     let (is_routing, set_is_routing) = signal(false);
18 | 
19 |     let router = ReactiveRouter(
20 |         {
21 |             #[cfg(feature = "ssr")]
22 |             {
23 |                 use_context::<RequestUrl>().expect(
24 |                     "RequestUrl should have been provided by server \
25 |                      integration.",
26 |                 )
27 |             }
28 |             #[cfg(not(feature = "ssr"))]
29 |             {
30 |                 BrowserUrl::new()
31 |             }
32 |         },
33 |         || {
34 |             (
35 |                 RouteDefinition::new(
36 |                     (StaticSegment("users"), ParamSegment("id")),
37 |                     (),
38 |                     User,
39 |                 ),
40 |                 RouteDefinition::new(
41 |                     (StaticSegment("stories"), ParamSegment("id")),
42 |                     (),
43 |                     Story,
44 |                 ),
45 |                 RouteDefinition::new(
46 |                     ParamSegment("stories"),
47 |                     (),
48 |                     reactive_route(Stories),
49 |                 ),
50 |             )
51 |         },
52 |         || "Not Found",
53 |     );
54 |     view! {
55 |         <Nav/>
56 |         <main>
57 |             {router}
58 |         </main>
59 |     }
60 | 
61 |     /* view! {
62 |         //<Stylesheet id="leptos" href="/pkg/hackernews.css"/>
63 |         //<Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
64 |         //<Meta name="description" content="Leptos implementation of a HackerNews demo."/>
65 |         // adding `set_is_routing` causes the router to wait for async data to load on new pages
66 |         /* <Router set_is_routing>
67 |             // shows a progress bar while async data are loading
68 |             <div class="routing-progress">
69 |                 <RoutingProgress is_routing max_time=std::time::Duration::from_millis(250)/>
70 |             </div>
71 |             <Nav />
72 |             <main>
73 |                 <Routes>
74 |                     <Route path="users/:id" view=User/>
75 |                     <Route path="stories/:id" view=Story/>
76 |                     <Route path=":stories?" view=Stories/>
77 |                 </Routes>
78 |             </main>
79 |         </Router> */
80 |     } */
81 | }
82 | 
83 | #[cfg(feature = "hydrate")]
84 | #[wasm_bindgen::prelude::wasm_bindgen]
85 | pub fn hydrate() {
86 |     //_ = console_log::init_with_level(log::Level::Debug);
87 |     //console_error_panic_hook::set_once();
88 |     /*Root::global_hydrate(|| {
89 |         let root = App();
90 |         let state = root.hydrate_from::<true>(&body());
91 |         std::mem::forget(state);
92 |     });*/
93 |     Root::global_islands(|| ());
94 | }
95 | 


--------------------------------------------------------------------------------
/examples/hackernews/src/routes.rs:
--------------------------------------------------------------------------------
1 | pub mod nav;
2 | pub mod stories;
3 | pub mod story;
4 | pub mod users;
5 | 


--------------------------------------------------------------------------------
/examples/hackernews/src/routes/nav.rs:
--------------------------------------------------------------------------------
 1 | use tachys::prelude::*;
 2 | 
 3 | #[component]
 4 | pub fn Nav() -> impl RenderHtml<Dom> {
 5 |     view! {
 6 |         <header class="header">
 7 |             <nav class="inner">
 8 |                 // TODO use <A> component?
 9 |                 <a href="/home">
10 |                     <strong>"HN"</strong>
11 |                 </a>
12 |                 <a href="/new">
13 |                     <strong>"New"</strong>
14 |                 </a>
15 |                 <a href="/show">
16 |                     <strong>"Show"</strong>
17 |                 </a>
18 |                 <a href="/ask">
19 |                     <strong>"Ask"</strong>
20 |                 </a>
21 |                 <a href="/job">
22 |                     <strong>"Jobs"</strong>
23 |                 </a>
24 |                 <a class="github" href="http://github.com/leptos-rs/leptos" target="_blank" rel="noreferrer">
25 |                     "Built with Leptos"
26 |                 </a>
27 |             </nav>
28 |         </header>
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/examples/hackernews/src/routes/users.rs:
--------------------------------------------------------------------------------
 1 | use crate::api::{self, User};
 2 | use send_wrapper::SendWrapper;
 3 | use std::{collections::HashMap, future::IntoFuture};
 4 | use tachy_reaccy::async_signal::ArcAsyncDerived;
 5 | use tachy_route::{reactive::ReactiveMatchedRoute, route::MatchedRoute};
 6 | use tachys::{
 7 |     prelude::*,
 8 |     tachydom::view::{
 9 |         any_view::IntoAny, either::Either, template::ViewTemplate,
10 |     },
11 | };
12 | 
13 | pub fn User(matched: MatchedRoute) -> impl RenderHtml<Dom> {
14 |     // There's no actual way to navigate from a User to another User,
15 |     // so we're going to do non-reactive accesses here
16 |     let id = matched.param("id").unwrap_or_default().to_owned();
17 |     let user = async move {
18 |         if id.is_empty() {
19 |             None
20 |         } else {
21 |             api::fetch_api::<User>(&api::user(&id)).await
22 |         }
23 |     };
24 |     let user_view = SendWrapper::new(async move {
25 |         match user.await {
26 |                 None => Either::Left(view! { <h1>"User not found."</h1> }),
27 |                 Some(user) => Either::Right(view! {
28 |                     <div>
29 |                         <h1>"User: " {user.id.clone()}</h1>
30 |                         <ul class="meta">
31 |                             <li>
32 |                                 <span class="label">"Created: "</span> {user.created}
33 |                             </li>
34 |                             <li>
35 |                             <span class="label">"Karma: "</span> {user.karma}
36 |                             </li>
37 |                             <li inner_html={user.about.unwrap_or_default()} class="about"></li>
38 |                         </ul>
39 |                         <p class="links">
40 |                             <a href=format!("https://news.ycombinator.com/submitted?id={}", user.id)>"submissions"</a>
41 |                             " | "
42 |                             <a href=format!("https://news.ycombinator.com/threads?id={}", user.id)>"comments"</a>
43 |                         </p>
44 |                     </div>
45 |                 }),
46 |             }
47 |     }).suspend().with_fallback("Loading...");
48 |     view! {
49 |         <div class="user-view">{user_view}</div>
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/.cargo/config.wasm.toml:
--------------------------------------------------------------------------------
 1 | 
 2 | [unstable]
 3 | build-std = ["std", "panic_abort", "core", "alloc"]
 4 | build-std-features = ["panic_immediate_abort"]
 5 | 
 6 | [build]
 7 | rustflags = [
 8 | 	"-Zlocation-detail=none",
 9 | ]
10 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/.dockerignore:
--------------------------------------------------------------------------------
1 | target
2 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/.gitignore:
--------------------------------------------------------------------------------
1 | fly.toml
2 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/Cargo.toml:
--------------------------------------------------------------------------------
  1 | [package]
  2 | name = "hackernews_islands_axum"
  3 | version = "0.1.0"
  4 | edition = "2021"
  5 | 
  6 | [lib]
  7 | crate-type = ["cdylib", "rlib"]
  8 | 
  9 | [profile.release]
 10 | opt-level = 'z'   # CSR only
 11 | codegen-units = 1
 12 | lto = true
 13 | 
 14 | [dependencies]
 15 | console_error_panic_hook = "0.1"
 16 | cfg-if = "1"
 17 | leptos_config = "0.6"
 18 | #tachys = { path = "../../tachys", features = ["hydration", "islands", "nightly", "web"] }
 19 | #tachy_reaccy = { path = "../../tachy_reaccy", features = ["miniserde"] }
 20 | #tachy_route = { path = "../../tachy_route", features = ["reaccy"] }
 21 | tachys = { git = "https://github.com/gbj/tachys", features = ["hydration", "islands", "nightly", "web"] }
 22 | tachy_reaccy = { git = "https://github.com/gbj/tachys", features = ["miniserde"] }
 23 | tachy_route = { git = "https://github.com/gbj/tachys", features = ["reaccy"] }
 24 | serde = { version = "1", features = ["derive"] }
 25 | reqwest = { version = "0.11", features = ["json"] }
 26 | tracing = "0.1"
 27 | # openssl = { version = "0.10", features = ["v110"] }
 28 | wasm-bindgen = "0.2"
 29 | web-sys = { version = "0.3", features = ["AbortController", "AbortSignal"] }
 30 | send_wrapper = { version = "0.6.0", features = ["futures"] }
 31 | futures = "0.3.30"
 32 | axum = { version = "0.7", optional = true, features = ["http2"] }
 33 | tower = { version = "0.4", optional = true }
 34 | tower-http = { version = "0.5", features = [
 35 |   "fs",
 36 |   "compression-br",
 37 | ], optional = true }
 38 | tokio = { version = "1", features = ["full"], optional = true }
 39 | http = { version = "1.0", optional = true }
 40 | rust-embed = { version = "8", features = ["axum"], optional = true }
 41 | mime_guess = { version = "2.0.4", optional = true }
 42 | 
 43 | [features]
 44 | default = []
 45 | hydrate = []
 46 | ssr = ["tachys/tokio", "dep:axum", "dep:http", "dep:tokio", "dep:tower", "dep:tower-http", "dep:rust-embed", "dep:mime_guess"]
 47 | 
 48 | [profile.wasm-release]
 49 | inherits = "release"
 50 | opt-level = 'z'
 51 | lto = true
 52 | codegen-units = 1
 53 | 
 54 | [package.metadata.cargo-all-features]
 55 | denylist = ["actix-files", "actix-web", "leptos_actix"]
 56 | skip_feature_sets = [["ssr", "hydrate"]]
 57 | 
 58 | [package.metadata.leptos]
 59 | # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
 60 | output-name = "hackernews_islands_axum"
 61 | # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 62 | site-root = "target/site"
 63 | # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
 64 | # Defaults to pkg	
 65 | site-pkg-dir = "pkg"
 66 | # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 67 | style-file = "./style.css"
 68 | # [Optional] Files in the asset-dir will be copied to the site-root directory
 69 | assets-dir = "public"
 70 | # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
 71 | site-addr = "127.0.0.1:3000"
 72 | # The port to use for automatic reload monitoring
 73 | reload-port = 3001
 74 | # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
 75 | end2end-cmd = "npx playwright test"
 76 | #  The browserlist query used for optimizing the CSS.
 77 | browserquery = "defaults"
 78 | # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head
 79 | watch = false
 80 | # The environment Leptos will run in, usually either "DEV" or "PROD"
 81 | env = "DEV"
 82 | # The features to use when compiling the bin target
 83 | #
 84 | # Optional. Can be over-ridden with the command line parameter --bin-features
 85 | bin-features = ["ssr"]
 86 | 
 87 | # If the --no-default-features flag should be used when compiling the bin target
 88 | #
 89 | # Optional. Defaults to false.
 90 | bin-default-features = false
 91 | 
 92 | # The features to use when compiling the lib target
 93 | #
 94 | # Optional. Can be over-ridden with the command line parameter --lib-features
 95 | lib-features = ["hydrate"]
 96 | 
 97 | # If the --no-default-features flag should be used when compiling the lib target
 98 | #
 99 | # Optional. Defaults to false.
100 | lib-default-features = false
101 | 
102 | lib-profile-release = "wasm-release"
103 | 
104 | [workspace]
105 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM rustlang/rust:nightly-bullseye as builder
 2 | RUN wget https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz
 3 | RUN mkdir -p /app
 4 | WORKDIR /app
 5 | COPY . .
 6 | RUN cargo update
 7 | RUN cargo build --release --no-default-features --features=ssr
 8 | RUN ls -l /app/target
 9 | 
10 | FROM rustlang/rust:nightly-bullseye as runner
11 | COPY --from=builder /app/target/release/hackernews_islands_axum /app/
12 | COPY --from=builder /app/pkg /app
13 | COPY --from=builder /app/Cargo.toml /app/
14 | WORKDIR /app
15 | ENV RUST_LOG="info"
16 | ENV LEPTOS_OUTPUT_NAME="hackernews_islands_axum"
17 | ENV APP_ENVIRONMENT="production"
18 | ENV LEPTOS_SITE_ADDR="0.0.0.0:8080"
19 | ENV LEPTOS_SITE_ROOT="site"
20 | EXPOSE 8080
21 | CMD ["/app/hackernews_islands_axum"]
22 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Greg Johnston
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/Makefile.toml:
--------------------------------------------------------------------------------
1 | extend = [
2 |     { path = "../cargo-make/main.toml" },
3 |     { path = "../cargo-make/cargo-leptos.toml" },
4 | ]
5 | 
6 | [env]
7 | 
8 | CLIENT_PROCESS_NAME = "hackernews"
9 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/README.md:
--------------------------------------------------------------------------------
1 | # Leptos Hacker News Example
2 | 
3 | This example creates a basic clone of the Hacker News site. It showcases Leptos' ability to create both a client-side rendered app, and a server side rendered app with hydration, in a single repository
4 | 
5 | ## Getting Started
6 | 
7 | See the [Examples README](../README.md) for setup and run instructions.
8 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/build-front.sh:
--------------------------------------------------------------------------------
 1 | mv .cargo/config.wasm.toml .cargo/config.toml
 2 | wasm-pack build --target=web --features=hydrate --release
 3 | cd pkg
 4 | rm *.br
 5 | cp hackernews_islands_axum.js hackernews.unmin.js
 6 | cat hackernews.unmin.js | esbuild > hackernews_islands_axum.js
 7 | brotli hackernews_islands_axum.js
 8 | brotli hackernews_islands_axum_bg.wasm
 9 | brotli style.css
10 | cd ..
11 | mv .cargo/config.toml .cargo/config.wasm.toml
12 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gbj/tachys/cc7503c49c6beb977189167c63bd1c6770d39539/examples/hackernews_islands_axum/public/favicon.ico


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/api.rs:
--------------------------------------------------------------------------------
 1 | use serde::{de::DeserializeOwned, Deserialize, Serialize};
 2 | 
 3 | pub fn story(path: &str) -> String {
 4 |     format!("https://node-hnapi.herokuapp.com/{path}")
 5 | }
 6 | 
 7 | pub fn user(path: &str) -> String {
 8 |     format!("https://hacker-news.firebaseio.com/v0/user/{path}.json")
 9 | }
10 | 
11 | #[cfg(not(feature = "ssr"))]
12 | pub async fn fetch_api<T>(path: &str) -> Option<T>
13 | where
14 |     T: DeserializeOwned + Default,
15 | {
16 |     unreachable!()
17 | }
18 | 
19 | #[cfg(feature = "ssr")]
20 | pub async fn fetch_api<T>(path: &str) -> Option<T>
21 | where
22 |     T: DeserializeOwned,
23 | {
24 |     reqwest::get(path).await.ok()?.json().await.ok()?
25 | }
26 | 
27 | #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Default)]
28 | pub struct Story {
29 |     pub id: usize,
30 |     pub title: String,
31 |     pub points: Option<i32>,
32 |     pub user: Option<String>,
33 |     pub time: usize,
34 |     pub time_ago: String,
35 |     #[serde(alias = "type")]
36 |     pub story_type: String,
37 |     pub url: String,
38 |     #[serde(default)]
39 |     pub domain: String,
40 |     #[serde(default)]
41 |     pub comments: Option<Vec<Comment>>,
42 |     pub comments_count: Option<usize>,
43 | }
44 | 
45 | #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Default)]
46 | pub struct Comment {
47 |     pub id: usize,
48 |     pub level: usize,
49 |     pub user: Option<String>,
50 |     pub time: usize,
51 |     pub time_ago: String,
52 |     pub content: Option<String>,
53 |     pub comments: Vec<Comment>,
54 | }
55 | 
56 | #[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Default)]
57 | pub struct User {
58 |     pub created: usize,
59 |     pub id: String,
60 |     pub karma: i32,
61 |     pub about: Option<String>,
62 | }
63 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/fallback.rs:
--------------------------------------------------------------------------------
  1 | use axum::{
  2 |     body::{Body, Bytes},
  3 |     extract::State,
  4 |     http::{Request, Response, StatusCode, Uri},
  5 |     response::{IntoResponse, Response as AxumResponse},
  6 | };
  7 | use http::header;
  8 | use leptos_config::LeptosOptions;
  9 | use std::borrow::Cow;
 10 | use tower::ServiceExt;
 11 | use tower_http::services::ServeDir;
 12 | 
 13 | #[derive(rust_embed::RustEmbed)]
 14 | #[folder = "pkg/"]
 15 | struct Assets;
 16 | 
 17 | pub async fn file_and_error_handler(
 18 |     uri: Uri,
 19 |     State(_options): State<LeptosOptions>,
 20 |     req: Request<Body>,
 21 | ) -> Response<Body> {
 22 |     let path = uri.path().trim_start_matches("/pkg/"); // split off the first `/`
 23 |     let mime = mime_guess::from_path(path);
 24 | 
 25 |     let accept_encoding = req
 26 |         .headers()
 27 |         .get("accept-encoding")
 28 |         .map(|h| h.to_str().unwrap_or("none"))
 29 |         .unwrap_or("none");
 30 |     let (path, encoding) = if cfg!(debug_assertions) {
 31 |         // during DEV, don't care about the precompression -> faster workflow
 32 |         (Cow::from(path), "none")
 33 |     } else if accept_encoding.contains("br") {
 34 |         (Cow::from(format!("{}.br", path)), "br")
 35 |     } else if accept_encoding.contains("gzip") {
 36 |         (Cow::from(format!("{}.gz", path)), "gzip")
 37 |     } else {
 38 |         (Cow::from(path), "none")
 39 |     };
 40 | 
 41 |     match Assets::get(path.as_ref()) {
 42 |         Some(content) => {
 43 |             let body = Body::from(content.data);
 44 | 
 45 |             match cfg!(debug_assertions) {
 46 |                 true => Response::builder()
 47 |                     .header(
 48 |                         header::CONTENT_TYPE,
 49 |                         mime.first_or_octet_stream().as_ref(),
 50 |                     )
 51 |                     .header(header::CONTENT_ENCODING, encoding)
 52 |                     .body(body)
 53 |                     .unwrap(),
 54 |                 false => Response::builder()
 55 |                     .header(header::CACHE_CONTROL, "max-age=86400")
 56 |                     .header(
 57 |                         header::CONTENT_TYPE,
 58 |                         mime.first_or_octet_stream().as_ref(),
 59 |                     )
 60 |                     .header(header::CONTENT_ENCODING, encoding)
 61 |                     .body(body)
 62 |                     .unwrap(),
 63 |             }
 64 |         }
 65 | 
 66 |         None => {
 67 |             eprintln!(">> Asset {} not found", path);
 68 |             for a in Assets::iter() {
 69 |                 eprintln!("Available asset: {}", a);
 70 |             }
 71 |             (StatusCode::NOT_FOUND, "Not found.").into_response()
 72 |         }
 73 |     }
 74 | }
 75 | 
 76 | /*pub async fn file_and_error_handler(
 77 |     uri: Uri,
 78 |     State(options): State<LeptosOptions>,
 79 |     req: Request<Body>,
 80 | ) -> AxumResponse {
 81 |     let root = options.site_root.clone();
 82 |     let res = get_static_file(uri.clone(), &root).await.unwrap();
 83 | 
 84 |     if res.status() == StatusCode::OK {
 85 |         res.into_response()
 86 |     } else {
 87 |         (StatusCode::NOT_FOUND, "Not found.").into_response()
 88 |     }
 89 | }*/
 90 | 
 91 | async fn get_static_file(
 92 |     uri: Uri,
 93 |     root: &str,
 94 | ) -> Result<Response<Body>, (StatusCode, String)> {
 95 |     let req = Request::builder()
 96 |         .uri(uri.clone())
 97 |         .body(Body::empty())
 98 |         .unwrap();
 99 |     // `ServeDir` implements `tower::Service` so we can call it with `tower::ServiceExt::oneshot`
100 |     // This path is relative to the cargo root
101 |     match ServeDir::new(root).oneshot(req).await {
102 |         Ok(res) => Ok(res.into_response()),
103 |         Err(err) => Err((
104 |             StatusCode::INTERNAL_SERVER_ERROR,
105 |             format!("Something went wrong: {}", err),
106 |         )),
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![allow(non_snake_case)]
 2 | 
 3 | use tachy_route::{
 4 |     location::RequestUrl,
 5 |     matching::{ParamSegment, StaticSegment},
 6 |     reactive::ReactiveRouter,
 7 |     route::RouteDefinition,
 8 | };
 9 | use tachys::prelude::*;
10 | mod api;
11 | mod routes;
12 | use routes::{nav::Nav, stories::Stories, story::Story, users::User};
13 | #[cfg(feature = "ssr")]
14 | pub mod fallback;
15 | 
16 | #[component]
17 | pub fn App() -> impl RenderHtml<Dom> {
18 |     let router = ReactiveRouter(
19 |         use_context::<RequestUrl>().expect(
20 |             "RequestUrl should have been provided by server integration.",
21 |         ),
22 |         || {
23 |             (
24 |                 RouteDefinition::new(
25 |                     (StaticSegment("users"), ParamSegment("id")),
26 |                     (),
27 |                     User,
28 |                 ),
29 |                 RouteDefinition::new(
30 |                     (StaticSegment("stories"), ParamSegment("id")),
31 |                     (),
32 |                     Story,
33 |                 ),
34 |                 RouteDefinition::new(ParamSegment("stories"), (), Stories),
35 |             )
36 |         },
37 |         || "Not Found",
38 |     );
39 |     view! {
40 |         <Nav/>
41 |         <main>
42 |             {router}
43 |         </main>
44 |     }
45 | 
46 |     /* view! {
47 |         //<Stylesheet id="leptos" href="/pkg/hackernews.css"/>
48 |         //<Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
49 |         //<Meta name="description" content="Leptos implementation of a HackerNews demo."/>
50 |         // adding `set_is_routing` causes the router to wait for async data to load on new pages
51 |         /* <Router set_is_routing>
52 |             // shows a progress bar while async data are loading
53 |             <div class="routing-progress">
54 |                 <RoutingProgress is_routing max_time=std::time::Duration::from_millis(250)/>
55 |             </div>
56 |             <Nav />
57 |             <main>
58 |                 <Routes>
59 |                     <Route path="users/:id" view=User/>
60 |                     <Route path="stories/:id" view=Story/>
61 |                     <Route path=":stories?" view=Stories/>
62 |                 </Routes>
63 |             </main>
64 |         </Router> */
65 |     } */
66 | }
67 | 
68 | #[cfg(feature = "hydrate")]
69 | #[wasm_bindgen::prelude::wasm_bindgen]
70 | pub fn hydrate() {
71 |     //_ = console_log::init_with_level(log::Level::Debug);
72 |     //console_error_panic_hook::set_once();
73 |     /*Root::global_hydrate(|| {
74 |         let root = App();
75 |         let state = root.hydrate_from::<true>(&body());
76 |         std::mem::forget(state);
77 |     });*/
78 |     Root::global_islands(|| ());
79 | }
80 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/routes.rs:
--------------------------------------------------------------------------------
1 | pub mod nav;
2 | pub mod stories;
3 | pub mod story;
4 | pub mod users;
5 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/routes/nav.rs:
--------------------------------------------------------------------------------
 1 | use tachys::prelude::*;
 2 | 
 3 | #[component]
 4 | pub fn Nav() -> impl RenderHtml<Dom> {
 5 |     view! {
 6 |         <header class="header">
 7 |             <nav class="inner">
 8 |                 // TODO use <A> component?
 9 |                 <a href="/home">
10 |                     <strong>"HN"</strong>
11 |                 </a>
12 |                 <a href="/new">
13 |                     <strong>"New"</strong>
14 |                 </a>
15 |                 <a href="/show">
16 |                     <strong>"Show"</strong>
17 |                 </a>
18 |                 <a href="/ask">
19 |                     <strong>"Ask"</strong>
20 |                 </a>
21 |                 <a href="/job">
22 |                     <strong>"Jobs"</strong>
23 |                 </a>
24 |                 <a class="github" href="http://github.com/leptos-rs/leptos" target="_blank" rel="noreferrer">
25 |                     "Built with Leptos"
26 |                 </a>
27 |             </nav>
28 |         </header>
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/routes/story.rs:
--------------------------------------------------------------------------------
  1 | use crate::api;
  2 | use tachy_route::{reactive::ReactiveMatchedRoute, route::MatchedRoute};
  3 | //use leptos_meta::*;
  4 | //use leptos_router::*;
  5 | use tachys::{
  6 |     children::Children,
  7 |     island,
  8 |     prelude::*,
  9 |     tachydom::view::{any_view::IntoAny, either::Either},
 10 | };
 11 | 
 12 | pub fn Story(route: MatchedRoute) -> impl RenderHtml<Dom> {
 13 |     let mut path = String::from("item/");
 14 |     let id = route.param("id").unwrap_or_default();
 15 |     let id_is_empty = id.is_empty();
 16 |     path.push_str(id);
 17 |     let story = async move {
 18 |         if id_is_empty {
 19 |             None
 20 |         } else {
 21 |             api::fetch_api::<api::Story>(&api::story(&path)).await
 22 |         }
 23 |     };
 24 | 
 25 |     async move {
 26 |         match story.await {
 27 |             None => Either::Left(view! {  <div class="item-view">"Error loading this story."</div> }),
 28 |             Some(story) => Either::Right(view! {
 29 |                     <div class="item-view">
 30 |                         <div class="item-view-header">
 31 |                         <a href=story.url target="_blank">
 32 |                             <h1>{story.title}</h1>
 33 |                         </a>
 34 |                         <span class="host">
 35 |                             "("{story.domain}")"
 36 |                         </span>
 37 |                         {story.user.map(|user| view! {  <p class="meta">
 38 |                             {story.points}
 39 |                             " points | by "
 40 |                             <a href=format!("/users/{user}")>{user.clone()}</a>
 41 |                             {format!(" {}", story.time_ago)}
 42 |                         </p>})}
 43 |                         </div>
 44 |                         <div class="item-view-comments">
 45 |                         <p class="item-view-comments-header">
 46 |                             {if story.comments_count.unwrap_or_default() > 0 {
 47 |                                 format!("{} comments", story.comments_count.unwrap_or_default())
 48 |                             } else {
 49 |                                 "No comments yet.".into()
 50 |                             }}
 51 |                         </p>
 52 |                         <ul class="comment-children">
 53 |                             {story.comments
 54 |                                 .into_iter()
 55 |                                 .flatten()
 56 |                                 .map(|comment| view! { <Comment comment/> })
 57 |                                 .collect::<Vec<_>>()
 58 |                             }
 59 |                         </ul>
 60 |                     </div>
 61 |                 </div>
 62 |             })
 63 |         }
 64 |     }.suspend()
 65 | }
 66 | 
 67 | #[island]
 68 | pub fn Toggle(children: Children) -> impl RenderHtml<Dom> {
 69 |     let open = ArcRwSignal::new(true);
 70 |     view! {
 71 |         <div class="toggle" class:open={
 72 |             let open = open.clone();
 73 |             move || open.get()
 74 |         }>
 75 |             <a
 76 |                 on:click={
 77 |                     let open = open.clone();
 78 |                     move |_| open.update(|n| *n = !*n)
 79 |                 }
 80 |             >
 81 |                 {let open = open.clone();
 82 |                 move || if open.get() {
 83 |                     "[-]"
 84 |                 } else {
 85 |                     "[+] comments collapsed"
 86 |                 }}
 87 |             </a>
 88 |         </div>
 89 |         <ul
 90 |             class="comment-children"
 91 |             style:display=move || if open.get() {
 92 |                 "block"
 93 |             } else {
 94 |                 "none"
 95 |             }
 96 |         >
 97 |             {children()}
 98 |         </ul>
 99 |     }
100 | }
101 | 
102 | #[component]
103 | pub fn Comment(comment: api::Comment) -> impl RenderHtml<Dom> {
104 |     view! {
105 |         <li class="comment">
106 |             <div class="by">
107 |                 <a href=format!("/users/{}", comment.user.clone().unwrap_or_default())>{comment.user.clone()}</a>
108 |                 {format!(" {}", comment.time_ago)}
109 |             </div>
110 |             <div class="text" inner_html=comment.content.unwrap_or_default()></div>
111 |             {(!comment.comments.is_empty()).then(|| {
112 |                 view! {
113 |                     <Toggle>
114 |                         {comment.comments.into_iter()
115 |                             .map(|comment: api::Comment| view! { <Comment comment /> })
116 |                             .collect::<Vec<_>>()}
117 |                     </Toggle>
118 |                 }
119 |             })}
120 |         </li>
121 |     }
122 | }
123 | 
124 | fn pluralize(n: usize) -> &'static str {
125 |     if n == 1 {
126 |         " reply"
127 |     } else {
128 |         " replies"
129 |     }
130 | }
131 | 


--------------------------------------------------------------------------------
/examples/hackernews_islands_axum/src/routes/users.rs:
--------------------------------------------------------------------------------
 1 | use crate::api::{self, User};
 2 | use tachy_route::route::MatchedRoute;
 3 | use tachys::{prelude::*, tachydom::view::either::Either};
 4 | 
 5 | pub fn User(route: MatchedRoute) -> impl RenderHtml<Dom> {
 6 |     let id = route.param("id").unwrap_or_default().to_owned();
 7 |     let user = async move {
 8 |         if id.is_empty() {
 9 |             None
10 |         } else {
11 |             api::fetch_api::<User>(&api::user(&id)).await
12 |         }
13 |     };
14 |     let user_view = async move {
15 |         match user.await {
16 |                 None => Either::Left(view! { <h1>"User not found."</h1> }),
17 |                 Some(user) => Either::Right(view! {
18 |                     <div>
19 |                         <h1>"User: " {user.id.clone()}</h1>
20 |                         <ul class="meta">
21 |                             <li>
22 |                                 <span class="label">"Created: "</span> {user.created}
23 |                             </li>
24 |                             <li>
25 |                             <span class="label">"Karma: "</span> {user.karma}
26 |                             </li>
27 |                             <li inner_html={user.about.unwrap_or_default()} class="about"></li>
28 |                         </ul>
29 |                         <p class="links">
30 |                             <a href=format!("https://news.ycombinator.com/submitted?id={}", user.id)>"submissions"</a>
31 |                             " | "
32 |                             <a href=format!("https://news.ycombinator.com/threads?id={}", user.id)>"comments"</a>
33 |                         </p>
34 |                     </div>
35 |                 }),
36 |             }
37 |     }.suspend();
38 |     view! {
39 |         <div class="user-view">{user_view}</div>
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/examples/hydration/.cargo/config.toml:
--------------------------------------------------------------------------------
1 | [unstable]
2 | build-std = ["std", "panic_abort", "core", "alloc"]
3 | 
4 | [build]
5 | target = "aarch64-apple-darwin"
6 | 


--------------------------------------------------------------------------------
/examples/hydration/.gitignore:
--------------------------------------------------------------------------------
 1 | # Generated by Cargo
 2 | # will have compiled files and executables
 3 | debug/
 4 | target/
 5 | dist/
 6 | 
 7 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 8 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 9 | Cargo.lock
10 | 
11 | # These are backup files generated by rustfmt
12 | **/*.rs.bk
13 | 
14 | # MSVC Windows builds of rustc generate these, which store debugging information
15 | *.pdb
16 | 


--------------------------------------------------------------------------------
/examples/hydration/Cargo.toml:
--------------------------------------------------------------------------------
  1 | [package]
  2 | name = "hydration_ex"
  3 | version = "0.1.0"
  4 | edition = "2021"
  5 | 
  6 | [lib]
  7 | crate-type = ["cdylib", "rlib"]
  8 | 
  9 | [dependencies]
 10 | actix-files = { version = "0.6", optional = true }
 11 | actix-web = { version = "4", optional = true, features = ["macros"] }
 12 | console_error_panic_hook = "0.1"
 13 | http = { version = "0.2", optional = true }
 14 | tachydom = { path = "../../tachydom", features = ["nightly", "reaccy"] }
 15 | tachy_maccy = { path = "../../tachy_maccy", features = ["nightly"] }
 16 | tachy_reaccy = { path = "../../tachy_reaccy", features = [
 17 | 	"web",
 18 | 	"hydration",
 19 | 	"serde",
 20 | 	"serde-lite",
 21 | 	"miniserde",
 22 | 	"rkyv",
 23 | ] }
 24 | wasm-bindgen = "=0.2.88"
 25 | futures = "0.3.29"
 26 | tokio = { version = "1", features = ["rt"], optional = true }
 27 | wee_alloc = { version = "0.4.5" }
 28 | 
 29 | [features]
 30 | hydrate = ["tachydom/web"]
 31 | ssr = [
 32 | 	"dep:actix-files",
 33 | 	"dep:actix-web",
 34 | 	"dep:tokio",
 35 | 	"tachy_reaccy/tokio",
 36 | 	"tachydom/tokio",
 37 | ]
 38 | 
 39 | # Defines a size-optimized profile for the WASM bundle in release mode
 40 | [profile.wasm-release]
 41 | inherits = "release"
 42 | opt-level = 'z'
 43 | lto = true
 44 | codegen-units = 1
 45 | panic = "abort"
 46 | 
 47 | # Enable max optimizations for dependencies, but not for our code:
 48 | [profile.dev.package."*"]
 49 | opt-level = 3
 50 | 
 51 | [package.metadata.leptos]
 52 | # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
 53 | output-name = "hydration_ex"
 54 | # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 55 | site-root = "target/site"
 56 | # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
 57 | # Defaults to pkg	
 58 | site-pkg-dir = "pkg"
 59 | # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 60 | style-file = "style/main.scss"
 61 | # Assets source dir. All files found here will be copied and synchronized to site-root.
 62 | # The assets-dir cannot have a sub directory with the same name/path as site-pkg-dir.
 63 | #
 64 | # Optional. Env: LEPTOS_ASSETS_DIR.
 65 | assets-dir = "assets"
 66 | # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
 67 | site-addr = "127.0.0.1:3000"
 68 | # The port to use for automatic reload monitoring
 69 | reload-port = 3001
 70 | # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
 71 | #   [Windows] for non-WSL use "npx.cmd playwright test"
 72 | #   This binary name can be checked in Powershell with Get-Command npx
 73 | end2end-cmd = "npx playwright test"
 74 | end2end-dir = "end2end"
 75 | #  The browserlist query used for optimizing the CSS.
 76 | browserquery = "defaults"
 77 | # Set by cargo-leptos watch when building with that tool. Controls whether autoreload JS will be included in the head
 78 | watch = false
 79 | # The environment Leptos will run in, usually either "DEV" or "PROD"
 80 | env = "DEV"
 81 | # The features to use when compiling the bin target
 82 | #
 83 | # Optional. Can be over-ridden with the command line parameter --bin-features
 84 | bin-features = ["ssr"]
 85 | 
 86 | # If the --no-default-features flag should be used when compiling the bin target
 87 | #
 88 | # Optional. Defaults to false.
 89 | bin-default-features = false
 90 | 
 91 | # The features to use when compiling the lib target
 92 | #
 93 | # Optional. Can be over-ridden with the command line parameter --lib-features
 94 | lib-features = ["hydrate"]
 95 | 
 96 | # If the --no-default-features flag should be used when compiling the lib target
 97 | #
 98 | # Optional. Defaults to false.
 99 | lib-default-features = false
100 | 
101 | # The profile to use for the lib target when compiling for release
102 | #
103 | # Optional. Defaults to "release".
104 | lib-profile-release = "wasm-release"
105 | 
106 | [workspace]
107 | 


--------------------------------------------------------------------------------
/examples/hydration/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 henrik
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/examples/hydration/README.md:
--------------------------------------------------------------------------------
 1 | <picture>
 2 |     <source srcset="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_Solid_White.svg" media="(prefers-color-scheme: dark)">
 3 |     <img src="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_RGB.svg" alt="Leptos Logo">
 4 | </picture>
 5 | 
 6 | # Leptos Starter Template
 7 | 
 8 | This is a template for use with the [Leptos](https://github.com/leptos-rs/leptos) web framework and the [cargo-leptos](https://github.com/akesson/cargo-leptos) tool.
 9 | 
10 | ## Creating your template repo
11 | 
12 | If you don't have `cargo-leptos` installed you can install it with
13 | 
14 | `cargo install cargo-leptos`
15 | 
16 | Then run
17 | 
18 | `cargo leptos new --git leptos-rs/start`
19 | 
20 | to generate a new project template (you will be prompted to enter a project name).
21 | 
22 | `cd {projectname}`
23 | 
24 | to go to your newly created project.
25 | 
26 | Of course, you should explore around the project structure, but the best place to start with your application code is in `src/app.rs`.
27 | 
28 | ## Running your project
29 | 
30 | `cargo leptos watch`  
31 | By default, you can access your local project at `http://localhost:3000`
32 | 
33 | ## Installing Additional Tools
34 | 
35 | By default, `cargo-leptos` uses `nightly` Rust, `cargo-generate`, and `sass`. If you run into any trouble, you may need to install one or more of these tools.
36 | 
37 | 1. `rustup toolchain install nightly --allow-downgrade` - make sure you have Rust nightly
38 | 2. `rustup target add wasm32-unknown-unknown` - add the ability to compile Rust to WebAssembly
39 | 3. `cargo install cargo-generate` - install `cargo-generate` binary (should be installed automatically in future)
40 | 4. `npm install -g sass` - install `dart-sass` (should be optional in future)
41 | 
42 | ## Executing a Server on a Remote Machine Without the Toolchain
43 | After running a `cargo leptos build --release` the minimum files needed are:
44 | 
45 | 1. The server binary located in `target/server/release`
46 | 2. The `site` directory and all files within located in `target/site`
47 | 
48 | Copy these files to your remote server. The directory structure should be:
49 | ```text
50 | leptos_start
51 | site/
52 | ```
53 | Set the following environment variables (updating for your project as needed):
54 | ```sh
55 | export LEPTOS_OUTPUT_NAME="leptos_start"
56 | export LEPTOS_SITE_ROOT="site"
57 | export LEPTOS_SITE_PKG_DIR="pkg"
58 | export LEPTOS_SITE_ADDR="127.0.0.1:3000"
59 | export LEPTOS_RELOAD_PORT="3001"
60 | ```
61 | Finally, run the server binary.
62 | 
63 | ## Notes about CSR and Trunk:
64 | Although it is not recommended, you can also run your project without server integration using the feature `csr` and `trunk serve`:
65 | 
66 | `trunk serve --open --features csr`
67 | 
68 | This may be useful for integrating external tools which require a static site, e.g. `tauri`.
69 | 


--------------------------------------------------------------------------------
/examples/hydration/assets/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gbj/tachys/cc7503c49c6beb977189167c63bd1c6770d39539/examples/hydration/assets/favicon.ico


--------------------------------------------------------------------------------
/examples/hydration/end2end/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "end2end",
 3 |   "version": "1.0.0",
 4 |   "lockfileVersion": 2,
 5 |   "requires": true,
 6 |   "packages": {
 7 |     "": {
 8 |       "name": "end2end",
 9 |       "version": "1.0.0",
10 |       "license": "ISC",
11 |       "devDependencies": {
12 |         "@playwright/test": "^1.28.0"
13 |       }
14 |     },
15 |     "node_modules/@playwright/test": {
16 |       "version": "1.28.0",
17 |       "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.28.0.tgz",
18 |       "integrity": "sha512-vrHs5DFTPwYox5SGKq/7TDn/S4q6RA1zArd7uhO6EyP9hj3XgZBBM12ktMbnDQNxh/fL1IUKsTNLxihmsU38lQ==",
19 |       "dev": true,
20 |       "dependencies": {
21 |         "@types/node": "*",
22 |         "playwright-core": "1.28.0"
23 |       },
24 |       "bin": {
25 |         "playwright": "cli.js"
26 |       },
27 |       "engines": {
28 |         "node": ">=14"
29 |       }
30 |     },
31 |     "node_modules/@types/node": {
32 |       "version": "18.11.9",
33 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
34 |       "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
35 |       "dev": true
36 |     },
37 |     "node_modules/playwright-core": {
38 |       "version": "1.28.0",
39 |       "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.28.0.tgz",
40 |       "integrity": "sha512-nJLknd28kPBiCNTbqpu6Wmkrh63OEqJSFw9xOfL9qxfNwody7h6/L3O2dZoWQ6Oxcm0VOHjWmGiCUGkc0X3VZA==",
41 |       "dev": true,
42 |       "bin": {
43 |         "playwright": "cli.js"
44 |       },
45 |       "engines": {
46 |         "node": ">=14"
47 |       }
48 |     }
49 |   },
50 |   "dependencies": {
51 |     "@playwright/test": {
52 |       "version": "1.28.0",
53 |       "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.28.0.tgz",
54 |       "integrity": "sha512-vrHs5DFTPwYox5SGKq/7TDn/S4q6RA1zArd7uhO6EyP9hj3XgZBBM12ktMbnDQNxh/fL1IUKsTNLxihmsU38lQ==",
55 |       "dev": true,
56 |       "requires": {
57 |         "@types/node": "*",
58 |         "playwright-core": "1.28.0"
59 |       }
60 |     },
61 |     "@types/node": {
62 |       "version": "18.11.9",
63 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
64 |       "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
65 |       "dev": true
66 |     },
67 |     "playwright-core": {
68 |       "version": "1.28.0",
69 |       "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.28.0.tgz",
70 |       "integrity": "sha512-nJLknd28kPBiCNTbqpu6Wmkrh63OEqJSFw9xOfL9qxfNwody7h6/L3O2dZoWQ6Oxcm0VOHjWmGiCUGkc0X3VZA==",
71 |       "dev": true
72 |     }
73 |   }
74 | }
75 | 


--------------------------------------------------------------------------------
/examples/hydration/end2end/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "end2end",
 3 |   "version": "1.0.0",
 4 |   "description": "",
 5 |   "main": "index.js",
 6 |   "scripts": {},
 7 |   "keywords": [],
 8 |   "author": "",
 9 |   "license": "ISC",
10 |   "devDependencies": {
11 |     "@playwright/test": "^1.28.0"
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/examples/hydration/end2end/playwright.config.ts:
--------------------------------------------------------------------------------
  1 | import type { PlaywrightTestConfig } from "@playwright/test";
  2 | import { devices } from "@playwright/test";
  3 | 
  4 | /**
  5 |  * Read environment variables from file.
  6 |  * https://github.com/motdotla/dotenv
  7 |  */
  8 | // require('dotenv').config();
  9 | 
 10 | /**
 11 |  * See https://playwright.dev/docs/test-configuration.
 12 |  */
 13 | const config: PlaywrightTestConfig = {
 14 |   testDir: "./tests",
 15 |   /* Maximum time one test can run for. */
 16 |   timeout: 30 * 1000,
 17 |   expect: {
 18 |     /**
 19 |      * Maximum time expect() should wait for the condition to be met.
 20 |      * For example in `await expect(locator).toHaveText();`
 21 |      */
 22 |     timeout: 5000,
 23 |   },
 24 |   /* Run tests in files in parallel */
 25 |   fullyParallel: true,
 26 |   /* Fail the build on CI if you accidentally left test.only in the source code. */
 27 |   forbidOnly: !!process.env.CI,
 28 |   /* Retry on CI only */
 29 |   retries: process.env.CI ? 2 : 0,
 30 |   /* Opt out of parallel tests on CI. */
 31 |   workers: process.env.CI ? 1 : undefined,
 32 |   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
 33 |   reporter: "html",
 34 |   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
 35 |   use: {
 36 |     /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
 37 |     actionTimeout: 0,
 38 |     /* Base URL to use in actions like `await page.goto('/')`. */
 39 |     // baseURL: 'http://localhost:3000',
 40 | 
 41 |     /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
 42 |     trace: "on-first-retry",
 43 |   },
 44 | 
 45 |   /* Configure projects for major browsers */
 46 |   projects: [
 47 |     {
 48 |       name: "chromium",
 49 |       use: {
 50 |         ...devices["Desktop Chrome"],
 51 |       },
 52 |     },
 53 | 
 54 |     {
 55 |       name: "firefox",
 56 |       use: {
 57 |         ...devices["Desktop Firefox"],
 58 |       },
 59 |     },
 60 | 
 61 |     {
 62 |       name: "webkit",
 63 |       use: {
 64 |         ...devices["Desktop Safari"],
 65 |       },
 66 |     },
 67 | 
 68 |     /* Test against mobile viewports. */
 69 |     // {
 70 |     //   name: 'Mobile Chrome',
 71 |     //   use: {
 72 |     //     ...devices['Pixel 5'],
 73 |     //   },
 74 |     // },
 75 |     // {
 76 |     //   name: 'Mobile Safari',
 77 |     //   use: {
 78 |     //     ...devices['iPhone 12'],
 79 |     //   },
 80 |     // },
 81 | 
 82 |     /* Test against branded browsers. */
 83 |     // {
 84 |     //   name: 'Microsoft Edge',
 85 |     //   use: {
 86 |     //     channel: 'msedge',
 87 |     //   },
 88 |     // },
 89 |     // {
 90 |     //   name: 'Google Chrome',
 91 |     //   use: {
 92 |     //     channel: 'chrome',
 93 |     //   },
 94 |     // },
 95 |   ],
 96 | 
 97 |   /* Folder for test artifacts such as screenshots, videos, traces, etc. */
 98 |   // outputDir: 'test-results/',
 99 | 
100 |   /* Run your local dev server before starting the tests */
101 |   // webServer: {
102 |   //   command: 'npm run start',
103 |   //   port: 3000,
104 |   // },
105 | };
106 | 
107 | export default config;
108 | 


--------------------------------------------------------------------------------
/examples/hydration/end2end/tests/example.spec.ts:
--------------------------------------------------------------------------------
 1 | import { test, expect } from "@playwright/test";
 2 | 
 3 | test("homepage has title and links to intro page", async ({ page }) => {
 4 |   await page.goto("http://localhost:3000/");
 5 | 
 6 |   await expect(page).toHaveTitle("Welcome to Leptos");
 7 | 
 8 |   await expect(page.locator("h1")).toHaveText("Welcome to Leptos!");
 9 | });
10 | 


--------------------------------------------------------------------------------
/examples/hydration/rust-toolchain.toml:
--------------------------------------------------------------------------------
1 | 
2 | [toolchain]
3 | channel = "nightly"
4 | 


--------------------------------------------------------------------------------
/examples/hydration/src/app.rs:
--------------------------------------------------------------------------------
  1 | use std::{future::IntoFuture, rc::Rc, sync::Arc};
  2 | use tachy_maccy::view;
  3 | use tachy_reaccy::{
  4 |     async_signal::AsyncState,
  5 |     prelude::*,
  6 |     serialization::{Miniserde, SerdeJson, SerdeLite, Str},
  7 | };
  8 | use tachydom::{
  9 |     async_views::FutureViewExt,
 10 |     dom::log,
 11 |     html::{attribute::global::OnAttribute, element::ElementChild},
 12 |     renderer::dom::Dom,
 13 |     view::RenderHtml,
 14 | };
 15 | 
 16 | #[cfg(feature = "ssr")]
 17 | async fn timer() {
 18 |     tokio::time::sleep(std::time::Duration::from_millis(500)).await;
 19 | }
 20 | #[cfg(not(feature = "ssr"))]
 21 | async fn timer() {}
 22 | 
 23 | /* pub fn my_app() -> impl RenderHtml<Dom> {
 24 |     let count = Signal::new(0);
 25 |     let value = Resource::new(|| async {
 26 |         timer().await;
 27 |         "str".to_string()
 28 |     });
 29 |     let value2 = Resource::serde(|| async {
 30 |         timer().await;
 31 |         "serde_json".to_string()
 32 |     });
 33 |     let value3 = Resource::miniserde(|| async {
 34 |         timer().await;
 35 |         "miniserde".to_string()
 36 |     });
 37 |     let value4 = Resource::serde_lite(|| async {
 38 |         timer().await;
 39 |         "serde_lite".to_string()
 40 |     });
 41 |     let value5 = Resource::rkyv(|| async {
 42 |         timer().await;
 43 |         "serde_lite".to_string()
 44 |     });
 45 | 
 46 |     let a: &str = "hello world";
 47 |     let b: Rc<str> = Rc::from(a);
 48 |     let c: Arc<str> = Arc::from(a);
 49 |     let d = String::from(a);
 50 | 
 51 |     /* view! {
 52 |         /* <button
 53 |             on:click=move |_| {
 54 |                 log("clicked");
 55 |                 count.update(|n| *n += 1)
 56 |             }
 57 |             disabled={
 58 |                 let value = value.clone();
 59 |                 move || value.with(|state| matches!(state, AsyncState::Loading))
 60 |             }
 61 |         >
 62 |             {move || {
 63 |                 let value = value.clone();
 64 |                 async move { (count.get() + value.await).to_string() }
 65 |                     .suspend()
 66 |                     .with_fallback("Loading...")
 67 |                     .track()
 68 |             }}
 69 |         </button> */
 70 |         //{a} {b} {c} {d}
 71 |     } */
 72 |     (
 73 |         async { value.await }.suspend().with_fallback("FromStr..."),
 74 |         async { value2.await }
 75 |             .suspend()
 76 |             .with_fallback("serde_json..."),
 77 |         async { value3.await }
 78 |             .suspend()
 79 |             .with_fallback("miniserde..."),
 80 |         async { value4.await }
 81 |             .suspend()
 82 |             .with_fallback("serde_lite..."),
 83 |     )
 84 | } */
 85 | 
 86 | pub fn my_app() -> impl RenderHtml<Dom> {
 87 |     (
 88 |         EntryComponent(),
 89 |         EntryComponent(),
 90 |         EntryComponent(),
 91 |         EntryComponent(),
 92 |         EntryComponent(),
 93 |         EntryComponent(),
 94 |         EntryComponent(),
 95 |         EntryComponent(),
 96 |     )
 97 | }
 98 | 
 99 | fn EntryComponent() -> impl RenderHtml<Dom> {
100 |     Component2()
101 | }
102 | 
103 | fn Component2() -> impl RenderHtml<Dom> {
104 |     Component3()
105 | }
106 | 
107 | fn Component3() -> impl RenderHtml<Dom> {
108 |     Component4()
109 | }
110 | 
111 | fn Component4() -> impl RenderHtml<Dom> {
112 |     Component5()
113 | }
114 | 
115 | fn Component5() -> impl RenderHtml<Dom> {
116 |     Component6()
117 | }
118 | 
119 | fn Component6() -> impl RenderHtml<Dom> {
120 |     Component7()
121 | }
122 | 
123 | fn Component7() -> impl RenderHtml<Dom> {
124 |     Component8()
125 | }
126 | 
127 | fn Component8() -> impl RenderHtml<Dom> {
128 |     Component9()
129 | }
130 | 
131 | fn Component9() -> impl RenderHtml<Dom> {
132 |     Component10()
133 | }
134 | 
135 | fn Component10() -> impl RenderHtml<Dom> {
136 |     Component11()
137 | }
138 | 
139 | fn Component11() -> impl RenderHtml<Dom> {
140 |     Component12()
141 | }
142 | 
143 | fn Component12() -> impl RenderHtml<Dom> {
144 |     Component13()
145 | }
146 | 
147 | fn Component13() -> impl RenderHtml<Dom> {
148 |     Component14()
149 | }
150 | 
151 | fn Component14() -> impl RenderHtml<Dom> {
152 |     Component15()
153 | }
154 | 
155 | fn Component15() -> impl RenderHtml<Dom> {
156 |     Component16()
157 | }
158 | 
159 | fn Component16() -> impl RenderHtml<Dom> {
160 |     Component17()
161 | }
162 | 
163 | fn Component17() -> impl RenderHtml<Dom> {
164 |     EndComponent()
165 | }
166 | 
167 | fn EndComponent() -> impl RenderHtml<Dom> {
168 |     view! { <p>Test</p> }
169 | }
170 | 


--------------------------------------------------------------------------------
/examples/hydration/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![feature(type_name_of_val)]
 2 | 
 3 | pub mod app;
 4 | use tachy_reaccy::Root;
 5 | use wasm_bindgen::prelude::wasm_bindgen;
 6 | 
 7 | #[cfg(target_arch = "wasm32")]
 8 | extern crate wee_alloc;
 9 | 
10 | #[cfg(target_arch = "wasm32")]
11 | #[global_allocator]
12 | static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
13 | 
14 | #[wasm_bindgen]
15 | pub fn hydrate() {
16 |     use tachydom::{dom::body, view::RenderHtml};
17 |     console_error_panic_hook::set_once();
18 |     Root::global_hydrate(|| {
19 |         let root = crate::app::my_app();
20 |         let state = root.hydrate_from::<true>(&body());
21 |         std::mem::forget(state);
22 |     });
23 | }
24 | 


--------------------------------------------------------------------------------
/examples/hydration/src/main.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(feature = "ssr")]
 2 | #[actix_web::main]
 3 | async fn main() -> std::io::Result<()> {
 4 |     use actix_files::Files;
 5 |     use actix_web::*;
 6 |     use futures::StreamExt;
 7 |     use tachy_reaccy::{Owner, Root};
 8 |     use tachydom::{
 9 |         renderer::dom::Dom,
10 |         view::{Position, PositionState, Render, RenderHtml},
11 |     };
12 | 
13 |     HttpServer::new(move || {
14 |         App::new()
15 |             // serve JS/WASM/CSS from `pkg`
16 |             .service(Files::new("/pkg", "target/site/pkg").show_files_listing())
17 |             // serve other assets from the `assets` directory
18 |             .service(Files::new("/assets", "target/site"))
19 |             .route(
20 |                 "/",
21 |                 web::get().to(|| async {
22 |                     let Root(owner, stream) = Root::global_ssr(move || {
23 | 
24 |                                 let app = hydration_ex::app::my_app();
25 |                                 let app_stream =
26 |                                     app.to_html_stream_out_of_order();
27 |                                 let shared_context =
28 |                                     Owner::shared_context().unwrap();
29 |                                 // TODO nonce
30 |                                 let shared_context = shared_context
31 |                                     .pending_data()
32 |                                     .unwrap()
33 |                                     .map(|chunk| {
34 |                                         format!("<script>{chunk}</script>")
35 |                                     });
36 |                                 futures::stream::select(
37 |                                     app_stream,
38 |                                     shared_context,
39 |                                 )
40 |                     });
41 |                                             HttpResponse::Ok()
42 |                             .content_type(http::header::ContentType::html())
43 |                             .streaming({
44 |                                                                 futures::stream::once(async move {
45 |                                     String::from(
46 |                                         r#"<!DOCTYPE html>
47 |                                             <html>
48 |                                                 <head>
49 |                                                 <script type="module">import('/pkg/hydration_ex.js').then(m => m.default("/pkg/hydration_ex.wasm").then(() => m.hydrate()));</script>
50 |                                                 </head><body>"#,
51 |                                     )
52 |                                 })
53 |                                 .chain(stream)
54 |                                 .chain(futures::stream::once(async move {
55 |                                     String::from("</body></html>")
56 |                                 })).map(|html| Ok(web::Bytes::from(html)) as Result<web::Bytes>)
57 |                                                             })
58 |                 }),
59 |             )
60 |         // serve the favicon from /favicon.ico
61 |         //.wrap(middleware::Compress::default())
62 |     })
63 |     .bind(("127.0.0.1", 8080))?
64 |     .run()
65 |     .await
66 | }
67 | 
68 | #[get("/")]
69 | #[cfg(not(any(feature = "ssr", feature = "csr")))]
70 | pub fn main() {
71 |     // no client-side main function
72 |     // unless we want this to work with e.g., Trunk for pure client-side testing
73 |     // see lib.rs for hydration function instead
74 |     // see optional feature `csr` instead
75 | }
76 | 
77 | #[cfg(all(not(feature = "ssr"), feature = "csr"))]
78 | pub fn main() {
79 |     // a client-side main function is required for using `trunk serve`
80 |     // prefer using `cargo leptos serve` instead
81 |     // to run: `trunk serve --open --features csr`
82 | }
83 | 


--------------------------------------------------------------------------------
/examples/hydration/src/shell.html:
--------------------------------------------------------------------------------
1 | <!DOCTYPE html>
2 | <html>
3 | 	<head></head>
4 | 	<body></body>
5 | </html>


--------------------------------------------------------------------------------
/examples/hydration/style/main.scss:
--------------------------------------------------------------------------------
1 | body {
2 | 	font-family: sans-serif;
3 | 	text-align: center;
4 | }


--------------------------------------------------------------------------------
/examples/playground/.cargo/config.toml:
--------------------------------------------------------------------------------
 1 | [unstable]
 2 | build-std = ["std", "panic_abort", "core", "alloc"]
 3 | build-std-features = ["panic_immediate_abort"]
 4 | 
 5 | [build]
 6 | rustflags = [
 7 | 	"-Clto",
 8 | 	#    "-Zvirtual-function-elimination",
 9 | 	"-Zlocation-detail=none",
10 | 
11 | 


--------------------------------------------------------------------------------
/examples/playground/.gitignore:
--------------------------------------------------------------------------------
1 | target
2 | dist


--------------------------------------------------------------------------------
/examples/playground/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "playground"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | #console_error_panic_hook = "0.1"
 8 | tachys = { version = "0.1.0", path = "../../tachys", features = [
 9 | 	"web",
10 | 	"nightly",
11 | ] }
12 | #tachy_reaccy_macro = { version = "0.1.0", path = "../../tachy_reaccy_macro" }
13 | #tachy_route = { version = "0.1.0", path = "../../tachy_route", default-features = false, features = [
14 | #	"reaccy",
15 | #] }
16 | #tracing = "0.1.40"
17 | #tracing-subscriber-wasm = "0.1.0"
18 | #tracing-subscriber = "0.3.18"
19 | web-sys = "0.3.66"
20 | wee_alloc = { version = "0.4.5" }
21 | 
22 | [profile.release]
23 | opt-level = "z"
24 | debug = false
25 | lto = true
26 | codegen-units = 1
27 | panic = "abort"
28 | strip = true
29 | incremental = false
30 | 
31 | [workspace]
32 | 


--------------------------------------------------------------------------------
/examples/playground/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |         <meta charset="utf-8">
 5 |         <meta name="viewport" content="width=device-width, initial-scale=1">
 6 | 
 7 |        <meta name="color-scheme" content="dark light">
 8 | 
 9 |        <title>Leptos • TodoMVC</title>
10 |         <link data-trunk rel="rust" data-wasm-opt="z" />
11 |         <style>
12 |               .hidden {
13 |                      display: none;
14 |               }
15 |         </style>
16 |   </head>
17 |   <body></body>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/next_tuple/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "next_tuple"
3 | version = "0.1.0"
4 | edition = "2021"
5 | 
6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
7 | 
8 | [dependencies]
9 | 


--------------------------------------------------------------------------------
/next_tuple/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![allow(non_snake_case)]
 2 | 
 3 | pub trait TupleBuilder<Next> {
 4 |     type Output;
 5 | 
 6 |     fn next_tuple(self, next: Next) -> Self::Output;
 7 | }
 8 | 
 9 | pub trait ConcatTuples<Next> {
10 |     type Output;
11 | 
12 |     fn concat(self, next: Next) -> Self::Output;
13 | }
14 | 
15 | macro_rules! impl_tuple_builder {
16 |     ($($ty:ident),* => $last:ident) => {
17 | 		impl<$($ty),*, $last> TupleBuilder<$last> for ($($ty,)*) {
18 | 			type Output = ($($ty,)* $last);
19 | 
20 | 			fn next_tuple(self, next: $last) -> Self::Output {
21 | 				let ($($ty,)*) = self;
22 | 				($($ty,)* next)
23 | 			}
24 | 		}
25 |     };
26 | }
27 | 
28 | impl<A> TupleBuilder<A> for () {
29 |     type Output = (A,);
30 | 
31 |     fn next_tuple(self, next: A) -> Self::Output {
32 |         (next,)
33 |     }
34 | }
35 | 
36 | impl_tuple_builder!(A => B);
37 | impl_tuple_builder!(A, B => C);
38 | impl_tuple_builder!(A, B, C => D);
39 | impl_tuple_builder!(A, B, C, D => E);
40 | impl_tuple_builder!(A, B, C, D, E => F);
41 | impl_tuple_builder!(A, B, C, D, E, F => G);
42 | impl_tuple_builder!(A, B, C, D, E, F, G => H);
43 | impl_tuple_builder!(A, B, C, D, E, F, G, H => I);
44 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I => J);
45 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J => K);
46 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K => L);
47 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L => M);
48 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L, M => N);
49 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L, M, N => O);
50 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O => P);
51 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P => Q);
52 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q => R);
53 | impl_tuple_builder!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R => S);
54 | impl_tuple_builder!(
55 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S => T
56 | );
57 | impl_tuple_builder!(
58 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T => U
59 | );
60 | impl_tuple_builder!(
61 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U => V
62 | );
63 | impl_tuple_builder!(
64 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V => W
65 | );
66 | impl_tuple_builder!(
67 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W => X
68 | );
69 | impl_tuple_builder!(
70 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X => Y
71 | );
72 | impl_tuple_builder!(
73 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y =>
74 |     Z
75 | );
76 | 


--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
1 | imports_granularity = "Crate"
2 | max_width = 80
3 | format_strings = true
4 | group_imports = "One"
5 | format_code_in_doc_comments = true
6 | 


--------------------------------------------------------------------------------
/tachy_maccy/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tachy_maccy"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [lib]
 7 | proc-macro = true
 8 | 
 9 | [dependencies]
10 | attribute-derive = { version = "0.8", features = ["syn-full"] }
11 | convert_case = "0.6.0"
12 | itertools = "0.12"
13 | leptos_hot_reload = "0.6"
14 | prettyplease = "0.2.4"
15 | proc-macro-error = { version = "1", default-features = false }
16 | proc-macro2 = "1"
17 | quote = "1"
18 | rstml = "0.11"
19 | syn = { version = "2", features = ["full"] }
20 | 
21 | [features]
22 | nightly = []
23 | 


--------------------------------------------------------------------------------
/tachy_maccy/src/lib.rs:
--------------------------------------------------------------------------------
  1 | mod component;
  2 | mod view;
  3 | use crate::component::unmodified_fn_name_from_fn_name;
  4 | use component::DummyModel;
  5 | use proc_macro::TokenStream;
  6 | use proc_macro2::TokenTree;
  7 | use proc_macro_error::abort;
  8 | use quote::{quote, ToTokens};
  9 | use syn::{spanned::Spanned, token::Pub, Visibility};
 10 | 
 11 | #[proc_macro_error::proc_macro_error]
 12 | #[proc_macro]
 13 | pub fn view(tokens: TokenStream) -> TokenStream {
 14 |     let tokens: proc_macro2::TokenStream = tokens.into();
 15 |     let mut tokens = tokens.into_iter();
 16 | 
 17 |     let first = tokens.next();
 18 |     let second = tokens.next();
 19 |     let third = tokens.next();
 20 |     let fourth = tokens.next();
 21 |     let global_class = match (&first, &second) {
 22 |         (Some(TokenTree::Ident(first)), Some(TokenTree::Punct(eq)))
 23 |             if *first == "class" && eq.as_char() == '=' =>
 24 |         {
 25 |             match &fourth {
 26 |                 Some(TokenTree::Punct(comma)) if comma.as_char() == ',' => {
 27 |                     third.clone()
 28 |                 }
 29 |                 _ => {
 30 |                     abort!(
 31 |                         second, "To create a scope class with the view! macro you must put a comma `,` after the value";
 32 |                         help = r#"e.g., view!{ class="my-class", <div>...</div>}"#
 33 |                     )
 34 |                 }
 35 |             }
 36 |         }
 37 |         _ => None,
 38 |     };
 39 |     let tokens = if global_class.is_some() {
 40 |         tokens.collect::<proc_macro2::TokenStream>()
 41 |     } else {
 42 |         [first, second, third, fourth]
 43 |             .into_iter()
 44 |             .flatten()
 45 |             .chain(tokens)
 46 |             .collect()
 47 |     };
 48 |     let config = rstml::ParserConfig::default().recover_block(true);
 49 |     let parser = rstml::Parser::new(config);
 50 |     let (nodes, errors) = parser.parse_recoverable(tokens).split_vec();
 51 |     let errors = errors.into_iter().map(|e| e.emit_as_expr_tokens());
 52 |     let nodes_output = view::render_view(&nodes, global_class.as_ref(), None);
 53 |     quote! {
 54 |         {
 55 |             #(#errors;)*
 56 |             #nodes_output
 57 |         }
 58 |     }
 59 |     .into()
 60 | }
 61 | 
 62 | #[proc_macro_error::proc_macro_error]
 63 | #[proc_macro_attribute]
 64 | pub fn component(
 65 |     _args: proc_macro::TokenStream,
 66 |     s: TokenStream,
 67 | ) -> TokenStream {
 68 |     component_macro(s, false)
 69 | }
 70 | 
 71 | #[proc_macro_error::proc_macro_error]
 72 | #[proc_macro_attribute]
 73 | pub fn island(_args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
 74 |     component_macro(s, true)
 75 | }
 76 | 
 77 | fn component_macro(s: TokenStream, island: bool) -> TokenStream {
 78 |     let mut dummy = syn::parse::<DummyModel>(s.clone());
 79 |     let parse_result = syn::parse::<component::Model>(s);
 80 | 
 81 |     if let (Ok(ref mut unexpanded), Ok(model)) = (&mut dummy, parse_result) {
 82 |         let expanded = model.is_island(island).into_token_stream();
 83 |         if !matches!(unexpanded.vis, Visibility::Public(_)) {
 84 |             unexpanded.vis = Visibility::Public(Pub {
 85 |                 span: unexpanded.vis.span(),
 86 |             })
 87 |         }
 88 |         unexpanded.sig.ident =
 89 |             unmodified_fn_name_from_fn_name(&unexpanded.sig.ident);
 90 |         quote! {
 91 |             #expanded
 92 | 
 93 |             #[doc(hidden)]
 94 |             #[allow(non_snake_case, dead_code, clippy::too_many_arguments)]
 95 |             #unexpanded
 96 |         }
 97 |     } else if let Ok(mut dummy) = dummy {
 98 |         dummy.sig.ident = unmodified_fn_name_from_fn_name(&dummy.sig.ident);
 99 |         quote! {
100 |             #[doc(hidden)]
101 |             #[allow(non_snake_case, dead_code, clippy::too_many_arguments)]
102 |             #dummy
103 |         }
104 |     } else {
105 |         quote! {}
106 |     }
107 |     .into()
108 | }
109 | 


--------------------------------------------------------------------------------
/tachy_reaccy/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tachy_reaccy"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | cfg-if = "1"
 8 | futures = "0.3"
 9 | glib = { version = "0.18", optional = true }
10 | lazy_static = "1"
11 | parking_lot = "0.12"
12 | pin-project-lite = "0.2"
13 | rustc-hash = "1"
14 | serde = { version = "1", features = ["derive"] }
15 | serde_json = "1"
16 | slotmap = "1"
17 | wasm-bindgen-futures = { version = "0.4", optional = true }
18 | wasm-bindgen = { version = "0.2", optional = true }
19 | web-sys = { version = "0.3", features = ["console"], optional = true }
20 | serde-wasm-bindgen = { version = "0.6", optional = true }
21 | js-sys = { version = "0.3", optional = true }
22 | tokio = { version = "1", features = ["rt", "macros"], optional = true }
23 | tracing = { version = "0.1.40", optional = true }
24 | smallvec = "1"
25 | thiserror = "1"
26 | 
27 | # serialization formats
28 | serde-lite = { version = "0.5", optional = true }
29 | miniserde = { version = "0.1", optional = true }
30 | rkyv = { version = "0.7.39", features = [
31 | 	"validation",
32 | 	"uuid",
33 | 	"strict",
34 | ], optional = true }
35 | base64 = { version = "0.21", optional = true }
36 | 
37 | [dev-dependencies]
38 | tokio-test = "0.4"
39 | tokio = { version = "1", features = ["rt", "macros"] }
40 | 
41 | [features]
42 | glib = ["dep:glib"]
43 | hydration = []
44 | serde = []
45 | tracing = ["dep:tracing"]
46 | tokio = ["dep:tokio"]
47 | web = [
48 | 	"dep:js-sys",
49 | 	"dep:serde-wasm-bindgen",
50 | 	"dep:wasm-bindgen",
51 | 	"dep:wasm-bindgen-futures",
52 | 	"dep:web-sys",
53 | ]
54 | miniserde = ["dep:miniserde"]
55 | rkyv = ["dep:rkyv", "dep:base64"]
56 | serde-lite = ["dep:serde-lite"]
57 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/async_signal/mod.rs:
--------------------------------------------------------------------------------
 1 | mod derived;
 2 | mod resource;
 3 | use crate::{arena::Owner, source::AnySubscriber, Observer};
 4 | pub use derived::*;
 5 | use futures::Future;
 6 | use pin_project_lite::pin_project;
 7 | pub use resource::*;
 8 | use std::{
 9 |     pin::Pin,
10 |     task::{Context, Poll},
11 | };
12 | 
13 | #[derive(Debug, Default, Clone, PartialEq, Eq)]
14 | pub enum AsyncState<T> {
15 |     #[default]
16 |     Loading,
17 |     Complete(T),
18 |     Reloading(T),
19 | }
20 | 
21 | impl<T> AsyncState<T> {
22 |     pub fn current_value(&self) -> Option<&T> {
23 |         match &self {
24 |             AsyncState::Loading => None,
25 |             AsyncState::Complete(val) | AsyncState::Reloading(val) => Some(val),
26 |         }
27 |     }
28 | 
29 |     pub fn loading(&self) -> bool {
30 |         matches!(&self, AsyncState::Loading | AsyncState::Reloading(_))
31 |     }
32 | }
33 | 
34 | pin_project! {
35 |     pub struct ScopedFuture<Fut> {
36 |         owner: Option<Owner>,
37 |         observer: Option<AnySubscriber>,
38 |         #[pin]
39 |         fut: Fut,
40 |     }
41 | }
42 | 
43 | impl<Fut> ScopedFuture<Fut> {
44 |     pub fn new(fut: Fut) -> Self {
45 |         let owner = Owner::current();
46 |         let observer = Observer::get();
47 |         Self {
48 |             owner,
49 |             observer,
50 |             fut,
51 |         }
52 |     }
53 | }
54 | 
55 | impl<Fut: Future> Future for ScopedFuture<Fut> {
56 |     type Output = Fut::Output;
57 | 
58 |     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
59 |         let this = self.project();
60 |         match (this.owner, this.observer) {
61 |             (None, None) => this.fut.poll(cx),
62 |             (None, Some(obs)) => obs.with_observer(|| this.fut.poll(cx)),
63 |             (Some(owner), None) => owner.with(|| this.fut.poll(cx)),
64 |             (Some(owner), Some(observer)) => {
65 |                 owner.with(|| observer.with_observer(|| this.fut.poll(cx)))
66 |             }
67 |         }
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/context.rs:
--------------------------------------------------------------------------------
 1 | use crate::arena::Owner;
 2 | use std::any::{Any, TypeId};
 3 | 
 4 | impl Owner {
 5 |     fn provide_context<T: Send + Sync + 'static>(&self, value: T) {
 6 |         self.inner
 7 |             .write()
 8 |             .contexts
 9 |             .insert(value.type_id(), Box::new(value));
10 |     }
11 | 
12 |     fn use_context<T: Clone + 'static>(&self) -> Option<T> {
13 |         let ty = TypeId::of::<T>();
14 |         let inner = self.inner.read();
15 |         let mut parent = inner.parent.as_ref().and_then(|p| p.upgrade());
16 |         let contexts = &self.inner.read().contexts;
17 |         if let Some(context) = contexts.get(&ty) {
18 |             context.downcast_ref::<T>().cloned()
19 |         } else {
20 |             while let Some(ref this_parent) = parent.clone() {
21 |                 let this_parent = this_parent.read();
22 |                 let contexts = &this_parent.contexts;
23 |                 let value = contexts.get(&ty);
24 |                 let downcast = value
25 |                     .and_then(|context| context.downcast_ref::<T>().cloned());
26 |                 if let Some(value) = downcast {
27 |                     return Some(value);
28 |                 } else {
29 |                     parent =
30 |                         this_parent.parent.as_ref().and_then(|p| p.upgrade());
31 |                 }
32 |             }
33 |             None
34 |         }
35 |     }
36 | }
37 | 
38 | pub fn provide_context<T: Send + Sync + 'static>(value: T) {
39 |     if let Some(owner) = Owner::current() {
40 |         owner.provide_context(value);
41 |     }
42 | }
43 | 
44 | pub fn use_context<T: Clone + 'static>() -> Option<T> {
45 |     Owner::current().and_then(|owner| owner.use_context())
46 | }
47 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/effect.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     arena::Owner,
  3 |     notify::{channel, Sender},
  4 |     source::{
  5 |         AnySource, AnySubscriber, ReactiveNode, SourceSet, Subscriber,
  6 |         ToAnySubscriber,
  7 |     },
  8 |     spawn::{spawn, spawn_local},
  9 | };
 10 | use futures::StreamExt;
 11 | use parking_lot::RwLock;
 12 | use std::{
 13 |     mem,
 14 |     sync::{Arc, Weak},
 15 | };
 16 | 
 17 | pub struct Effect<T>
 18 | where
 19 |     T: 'static,
 20 | {
 21 |     value: Arc<RwLock<Option<T>>>,
 22 |     inner: Arc<RwLock<EffectInner>>,
 23 | }
 24 | 
 25 | pub(crate) struct EffectInner {
 26 |     pub owner: Owner,
 27 |     pub observer: Sender,
 28 |     pub sources: SourceSet,
 29 | }
 30 | 
 31 | impl<T> Clone for Effect<T> {
 32 |     fn clone(&self) -> Self {
 33 |         Self {
 34 |             value: Arc::clone(&self.value),
 35 |             inner: Arc::clone(&self.inner),
 36 |         }
 37 |     }
 38 | }
 39 | 
 40 | // pulled out into a macro because we need to distinguish between
 41 | // spawn (for Send + Sync) and spawn_local (for !Send) but do it generically
 42 | macro_rules! spawn_effect {
 43 |     ($fun:ident, $spawner:ident) => {{
 44 |         let (mut observer, mut rx) = channel();
 45 | 
 46 |         // spawn the effect asynchronously
 47 |         // we'll notify once so it runs on the next tick,
 48 |         // to register observed values
 49 |         observer.notify();
 50 | 
 51 |         let value = Arc::new(RwLock::new(None));
 52 |         let owner = Owner::new();
 53 |         let inner = Arc::new(RwLock::new(EffectInner {
 54 |             owner: owner.clone(),
 55 |             observer,
 56 |             sources: SourceSet::new(),
 57 |         }));
 58 | 
 59 |         $spawner({
 60 |             let value = Arc::clone(&value);
 61 |             let subscriber = inner.to_any_subscriber();
 62 | 
 63 |             async move {
 64 |                 while rx.next().await.is_some() {
 65 |                     subscriber.clear_sources(&subscriber);
 66 | 
 67 |                     let old_value = mem::take(&mut *value.write());
 68 |                     let new_value = owner.with_cleanup(|| {
 69 |                         subscriber.with_observer(|| $fun(old_value))
 70 |                     });
 71 |                     *value.write() = Some(new_value);
 72 |                 }
 73 |             }
 74 |         });
 75 |         Self { value, inner }
 76 |     }};
 77 | }
 78 | 
 79 | impl<T> Effect<T>
 80 | where
 81 |     T: 'static,
 82 | {
 83 |     pub fn new(mut fun: impl FnMut(Option<T>) -> T + 'static) -> Self {
 84 |         spawn_effect!(fun, spawn_local)
 85 |     }
 86 | 
 87 |     pub fn with_value_mut<U>(
 88 |         &self,
 89 |         fun: impl FnOnce(&mut T) -> U,
 90 |     ) -> Option<U> {
 91 |         self.value.write().as_mut().map(fun)
 92 |     }
 93 | }
 94 | 
 95 | impl<T> Effect<T>
 96 | where
 97 |     T: Send + Sync + 'static,
 98 | {
 99 |     pub fn new_sync(
100 |         mut fun: impl FnMut(Option<T>) -> T + Send + Sync + 'static,
101 |     ) -> Self {
102 |         spawn_effect!(fun, spawn)
103 |     }
104 | }
105 | 
106 | impl<T> ToAnySubscriber for Effect<T> {
107 |     fn to_any_subscriber(&self) -> AnySubscriber {
108 |         self.inner.to_any_subscriber()
109 |     }
110 | }
111 | 
112 | impl ToAnySubscriber for Arc<RwLock<EffectInner>> {
113 |     fn to_any_subscriber(&self) -> AnySubscriber {
114 |         AnySubscriber(
115 |             self.data_ptr() as usize,
116 |             Arc::downgrade(self) as Weak<dyn Subscriber + Send + Sync>,
117 |         )
118 |     }
119 | }
120 | 
121 | impl ReactiveNode for RwLock<EffectInner> {
122 |     fn mark_subscribers_check(&self) {}
123 | 
124 |     fn update_if_necessary(&self) -> bool {
125 |         let mut lock = self.write();
126 |         for source in lock.sources.take() {
127 |             if source.update_if_necessary() {
128 |                 lock.observer.notify();
129 |                 return true;
130 |             }
131 |         }
132 |         false
133 |     }
134 | 
135 |     fn mark_check(&self) {
136 |         self.write().observer.notify()
137 |     }
138 | 
139 |     fn mark_dirty(&self) {
140 |         self.write().observer.notify()
141 |     }
142 | }
143 | 
144 | impl Subscriber for RwLock<EffectInner> {
145 |     fn add_source(&self, source: AnySource) {
146 |         self.write().sources.insert(source);
147 |     }
148 | 
149 |     fn clear_sources(&self, subscriber: &AnySubscriber) {
150 |         self.write().sources.clear_sources(subscriber);
151 |     }
152 | }
153 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/lib.rs:
--------------------------------------------------------------------------------
 1 | mod arena;
 2 | pub mod async_signal;
 3 | pub mod context;
 4 | pub mod effect;
 5 | pub mod memo;
 6 | mod notify;
 7 | pub mod render_effect;
 8 | pub mod selector;
 9 | #[cfg(feature = "serde")]
10 | mod serde;
11 | pub mod serialization;
12 | pub mod shared_context;
13 | pub mod signal;
14 | pub mod signal_traits;
15 | mod source;
16 | pub mod spawn;
17 | pub mod store;
18 | use crate::source::AnySubscriber;
19 | pub use arena::{Owner, Root};
20 | use futures::{Future, Stream};
21 | use std::{cell::RefCell, pin::Pin};
22 | 
23 | pub mod prelude {
24 |     pub use crate::{
25 |         async_signal::{AsyncDerived, Resource},
26 |         context::{provide_context, use_context},
27 |         effect::Effect,
28 |         memo::{ArcMemo, Memo},
29 |         signal::{signal, ArcRwSignal, ReadSignal, RwSignal},
30 |         signal_traits::*,
31 |         store::{StoreField, StoreFieldIndex, StoreFieldIterator},
32 |         Owner, Root,
33 |     };
34 | }
35 | 
36 | thread_local! {
37 |     static OBSERVER: RefCell<Option<AnySubscriber>> = RefCell::new(None);
38 | }
39 | 
40 | pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send + Sync>>;
41 | pub type PinnedStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Sync>>;
42 | 
43 | pub(crate) struct Observer {}
44 | 
45 | impl Observer {
46 |     fn get() -> Option<AnySubscriber> {
47 |         OBSERVER.with(|o| o.borrow().clone())
48 |     }
49 | 
50 |     fn is(observer: &AnySubscriber) -> bool {
51 |         OBSERVER.with(|o| o.borrow().as_ref() == Some(observer))
52 |     }
53 | 
54 |     fn take() -> Option<AnySubscriber> {
55 |         OBSERVER.with(|o| o.borrow_mut().take())
56 |     }
57 | 
58 |     fn set(observer: Option<AnySubscriber>) {
59 |         OBSERVER.with(|o| *o.borrow_mut() = observer);
60 |     }
61 | }
62 | 
63 | pub fn untrack<T>(fun: impl FnOnce() -> T) -> T {
64 |     let prev = Observer::take();
65 |     let value = fun();
66 |     Observer::set(prev);
67 |     value
68 | }
69 | 
70 | #[cfg(feature = "web")]
71 | pub fn log(s: &str) {
72 |     web_sys::console::log_1(&wasm_bindgen::JsValue::from_str(s));
73 | }
74 | 
75 | #[cfg(not(feature = "web"))]
76 | pub fn log(s: &str) {
77 |     println!("{s}");
78 | }
79 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/notify.rs:
--------------------------------------------------------------------------------
 1 | //use browser_only_send::BrowserOnly;
 2 | use core::sync::atomic::Ordering::Relaxed;
 3 | use futures::{task::AtomicWaker, Stream};
 4 | use std::{
 5 |     fmt::Debug,
 6 |     hash::Hash,
 7 |     pin::Pin,
 8 |     sync::{atomic::AtomicBool, Arc},
 9 |     task::{Context, Poll},
10 | };
11 | 
12 | #[derive(Debug)]
13 | pub(crate) struct Sender(Arc<Inner>);
14 | 
15 | #[derive(Debug)]
16 | pub(crate) struct Receiver(Arc<Inner>);
17 | 
18 | #[derive(Debug, Default)]
19 | struct Inner {
20 |     waker: AtomicWaker,
21 |     set: AtomicBool,
22 | }
23 | 
24 | pub fn channel() -> (Sender, Receiver) {
25 |     let inner = Arc::new(Inner {
26 |         waker: AtomicWaker::new(),
27 |         set: AtomicBool::new(false),
28 |     });
29 |     (Sender(Arc::clone(&inner)), Receiver(inner))
30 | }
31 | 
32 | impl Sender {
33 |     pub fn notify(&mut self) {
34 |         self.0.set.store(true, Relaxed);
35 |         self.0.waker.wake();
36 |     }
37 | }
38 | 
39 | impl Stream for Receiver {
40 |     type Item = ();
41 | 
42 |     fn poll_next(
43 |         self: Pin<&mut Self>,
44 |         cx: &mut Context<'_>,
45 |     ) -> Poll<Option<Self::Item>> {
46 |         self.0.waker.register(cx.waker());
47 | 
48 |         if self.0.set.swap(false, Relaxed) {
49 |             Poll::Ready(Some(()))
50 |         } else {
51 |             Poll::Pending
52 |         }
53 |     }
54 | }
55 | 
56 | impl Hash for Sender {
57 |     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
58 |         Arc::as_ptr(&self.0).hash(state)
59 |     }
60 | }
61 | 
62 | impl PartialEq for Sender {
63 |     fn eq(&self, other: &Self) -> bool {
64 |         Arc::ptr_eq(&self.0, &other.0)
65 |     }
66 | }
67 | 
68 | impl Eq for Sender {}
69 | 
70 | impl Hash for Receiver {
71 |     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
72 |         Arc::as_ptr(&self.0).hash(state)
73 |     }
74 | }
75 | 
76 | impl PartialEq for Receiver {
77 |     fn eq(&self, other: &Self) -> bool {
78 |         Arc::ptr_eq(&self.0, &other.0)
79 |     }
80 | }
81 | 
82 | impl Eq for Receiver {}
83 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/render_effect.rs:
--------------------------------------------------------------------------------
 1 | use crate::{
 2 |     arena::Owner,
 3 |     effect::EffectInner,
 4 |     notify::channel,
 5 |     source::{AnySubscriber, SourceSet, Subscriber, ToAnySubscriber},
 6 |     spawn::spawn_local,
 7 | };
 8 | use futures::StreamExt;
 9 | use parking_lot::RwLock;
10 | use std::{
11 |     fmt::Debug,
12 |     mem,
13 |     sync::{Arc, Weak},
14 | };
15 | 
16 | pub struct RenderEffect<T>
17 | where
18 |     T: 'static,
19 | {
20 |     value: Arc<RwLock<Option<T>>>,
21 |     inner: Arc<RwLock<EffectInner>>,
22 | }
23 | 
24 | impl<T> Debug for RenderEffect<T> {
25 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26 |         f.debug_struct("RenderEffect")
27 |             .field("inner", &Arc::as_ptr(&self.inner))
28 |             .finish()
29 |     }
30 | }
31 | 
32 | impl<T> RenderEffect<T>
33 | where
34 |     T: 'static,
35 | {
36 |     pub fn new(fun: impl FnMut(Option<T>) -> T + 'static) -> Self {
37 |         Self::new_with_value(fun, None)
38 |     }
39 | 
40 |     pub fn new_with_value(
41 |         mut fun: impl FnMut(Option<T>) -> T + 'static,
42 |         initial_value: Option<T>,
43 |     ) -> Self {
44 |         let (observer, mut rx) = channel();
45 |         let value = Arc::new(RwLock::new(None));
46 |         let owner = Owner::new();
47 |         let inner = Arc::new(RwLock::new(EffectInner {
48 |             owner: owner.clone(),
49 |             observer,
50 |             sources: SourceSet::new(),
51 |         }));
52 | 
53 |         let initial_value = Some(owner.with(|| {
54 |             inner
55 |                 .to_any_subscriber()
56 |                 .with_observer(|| fun(initial_value))
57 |         }));
58 |         *value.write() = initial_value;
59 | 
60 |         spawn_local({
61 |             let value = Arc::clone(&value);
62 |             let subscriber = inner.to_any_subscriber();
63 | 
64 |             async move {
65 |                 while rx.next().await.is_some() {
66 |                     subscriber.clear_sources(&subscriber);
67 | 
68 |                     let old_value = mem::take(&mut *value.write());
69 |                     let new_value = owner.with_cleanup(|| {
70 |                         subscriber.with_observer(|| fun(old_value))
71 |                     });
72 |                     *value.write() = Some(new_value);
73 |                 }
74 |             }
75 |         });
76 |         RenderEffect { value, inner }
77 |     }
78 | 
79 |     pub fn with_value_mut<U>(
80 |         &self,
81 |         fun: impl FnOnce(&mut T) -> U,
82 |     ) -> Option<U> {
83 |         self.value.write().as_mut().map(fun)
84 |     }
85 | 
86 |     pub fn take_value(&self) -> Option<T> {
87 |         self.value.write().take()
88 |     }
89 | }
90 | 
91 | impl<T> ToAnySubscriber for RenderEffect<T> {
92 |     fn to_any_subscriber(&self) -> AnySubscriber {
93 |         AnySubscriber(
94 |             self.inner.data_ptr() as usize,
95 |             Arc::downgrade(&self.inner) as Weak<dyn Subscriber + Send + Sync>,
96 |         )
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/selector.rs:
--------------------------------------------------------------------------------
 1 | use crate::{
 2 |     prelude::SignalWith, render_effect::RenderEffect, signal::ArcRwSignal,
 3 |     signal_traits::SignalUpdate,
 4 | };
 5 | use parking_lot::RwLock;
 6 | use rustc_hash::FxHashMap;
 7 | use std::{hash::Hash, sync::Arc};
 8 | 
 9 | /// A conditional signal that only notifies subscribers when a change
10 | /// in the source signal’s value changes whether the given function is true.
11 | #[derive(Clone)]
12 | pub struct Selector<T>
13 | where
14 |     T: PartialEq + Eq + Clone + Hash + 'static,
15 | {
16 |     subs: Arc<RwLock<FxHashMap<T, ArcRwSignal<bool>>>>,
17 |     v: Arc<RwLock<Option<T>>>,
18 |     #[allow(clippy::type_complexity)]
19 |     f: Arc<dyn Fn(&T, &T) -> bool>,
20 | }
21 | 
22 | impl<T> Selector<T>
23 | where
24 |     T: PartialEq + Eq + Clone + Hash + 'static,
25 | {
26 |     pub fn new(source: impl Fn() -> T + Clone + 'static) -> Self {
27 |         Self::new_with_fn(source, PartialEq::eq)
28 |     }
29 | 
30 |     pub fn new_with_fn(
31 |         source: impl Fn() -> T + Clone + 'static,
32 |         f: impl Fn(&T, &T) -> bool + Clone + 'static,
33 |     ) -> Self {
34 |         let subs: Arc<RwLock<FxHashMap<T, ArcRwSignal<bool>>>> =
35 |             Default::default();
36 |         let v: Arc<RwLock<Option<T>>> = Default::default();
37 |         let f = Arc::new(f) as Arc<dyn Fn(&T, &T) -> bool>;
38 | 
39 |         RenderEffect::new({
40 |             let subs = Arc::clone(&subs);
41 |             let f = Arc::clone(&f);
42 |             let v = Arc::clone(&v);
43 |             move |prev: Option<T>| {
44 |                 let next_value = source();
45 |                 *v.write() = Some(next_value.clone());
46 |                 if prev.as_ref() != Some(&next_value) {
47 |                     for (key, signal) in &*subs.read() {
48 |                         if f(key, &next_value)
49 |                             || (prev.is_some()
50 |                                 && f(key, prev.as_ref().unwrap()))
51 |                         {
52 |                             signal.update(|n| *n = true);
53 |                         }
54 |                     }
55 |                 }
56 |                 next_value
57 |             }
58 |         });
59 | 
60 |         Selector { subs, v, f }
61 |     }
62 | 
63 |     /// Reactively checks whether the given key is selected.
64 |     pub fn selected(&self, key: T) -> bool {
65 |         let read = {
66 |             let mut subs = self.subs.write();
67 |             subs.entry(key.clone())
68 |                 .or_insert_with(|| ArcRwSignal::new(false))
69 |                 .clone()
70 |         };
71 |         _ = read.try_with(|n| *n);
72 |         (self.f)(&key, self.v.read().as_ref().unwrap())
73 |     }
74 | 
75 |     /// Removes the listener for the given key.
76 |     pub fn remove(&self, key: &T) {
77 |         let mut subs = self.subs.write();
78 |         subs.remove(key);
79 |     }
80 | 
81 |     /// Clears the listeners for all keys.
82 |     pub fn clear(&self) {
83 |         let mut subs = self.subs.write();
84 |         subs.clear();
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/serde.rs:
--------------------------------------------------------------------------------
 1 | use crate::{signal::RwSignal, signal_traits::SignalWith};
 2 | use serde::{Deserialize, Serialize};
 3 | 
 4 | impl<T: Send + Sync + Serialize> Serialize for RwSignal<T> {
 5 |     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 6 |     where
 7 |         S: serde::Serializer,
 8 |     {
 9 |         self.with(|value| value.serialize(serializer))
10 |     }
11 | }
12 | 
13 | impl<'de, T: Send + Sync + Deserialize<'de>> Deserialize<'de> for RwSignal<T> {
14 |     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
15 |     where
16 |         D: serde::Deserializer<'de>,
17 |     {
18 |         T::deserialize(deserializer).map(RwSignal::new)
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/shared_context/hydrate.rs:
--------------------------------------------------------------------------------
 1 | use super::{SerializedDataId, SharedContext};
 2 | use crate::{PinnedFuture, PinnedStream};
 3 | use core::fmt::Debug;
 4 | use js_sys::Array;
 5 | use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 6 | use wasm_bindgen::prelude::wasm_bindgen;
 7 | 
 8 | #[wasm_bindgen]
 9 | extern "C" {
10 |     static __RESOLVED_RESOURCES: Array;
11 | }
12 | 
13 | #[derive(Default)]
14 | pub struct HydrateSharedContext {
15 |     id: AtomicUsize,
16 |     is_hydrating: AtomicBool,
17 | }
18 | 
19 | impl HydrateSharedContext {
20 |     pub fn new() -> Self {
21 |         Self {
22 |             id: AtomicUsize::new(0),
23 |             is_hydrating: AtomicBool::new(true),
24 |         }
25 |     }
26 | 
27 |     pub fn new_islands() -> Self {
28 |         Self {
29 |             id: AtomicUsize::new(0),
30 |             is_hydrating: AtomicBool::new(false),
31 |         }
32 |     }
33 | }
34 | 
35 | impl Debug for HydrateSharedContext {
36 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37 |         f.debug_struct("HydrateSharedContext").finish()
38 |     }
39 | }
40 | 
41 | impl SharedContext for HydrateSharedContext {
42 |     fn next_id(&self) -> SerializedDataId {
43 |         let id = self.id.fetch_add(1, Ordering::Relaxed);
44 |         SerializedDataId(id)
45 |     }
46 | 
47 |     fn write_async(&self, _id: SerializedDataId, _fut: PinnedFuture<String>) {}
48 | 
49 |     fn read_data(&self, id: &SerializedDataId) -> Option<String> {
50 |         __RESOLVED_RESOURCES.get(id.0 as u32).as_string()
51 |     }
52 | 
53 |     fn await_data(&self, _id: &SerializedDataId) -> Option<String> {
54 |         todo!()
55 |     }
56 | 
57 |     fn pending_data(&self) -> Option<PinnedStream<String>> {
58 |         None
59 |     }
60 | 
61 |     fn get_is_hydrating(&self) -> bool {
62 |         self.is_hydrating.load(Ordering::Relaxed)
63 |     }
64 | 
65 |     fn set_is_hydrating(&self, is_hydrating: bool) {
66 |         self.is_hydrating.store(true, Ordering::Relaxed)
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/shared_context/mod.rs:
--------------------------------------------------------------------------------
 1 | #[cfg(feature = "web")]
 2 | mod hydrate;
 3 | mod ssr;
 4 | use crate::{PinnedFuture, PinnedStream};
 5 | #[cfg(feature = "web")]
 6 | pub use hydrate::*;
 7 | use serde::{Deserialize, Serialize};
 8 | pub use ssr::*;
 9 | use std::fmt::Debug;
10 | 
11 | pub trait SharedContext: Debug {
12 |     /// Returns the next in a series of IDs that is unique to a particular request and response.
13 |     ///
14 |     /// This should not be used as a global unique ID mechanism. It is specific to the process
15 |     /// of serializing and deserializing data from the server to the browser as part of an HTTP
16 |     /// response.
17 |     fn next_id(&self) -> SerializedDataId;
18 | 
19 |     /// The given [`Future`] should resolve with some data that can be serialized
20 |     /// from the server to the client. This will be polled as part of the process of
21 |     /// building the HTTP response, *not* when it is first created.
22 |     ///
23 |     /// In browser implementations, this should be a no-op.
24 |     fn write_async(&self, id: SerializedDataId, fut: PinnedFuture<String>);
25 | 
26 |     /// Reads the current value of some data from the shared context, if it has been
27 |     /// sent from the server. This returns the serialized data as a `String` that should
28 |     /// be deserialized using [`Serializable::de`].
29 |     ///
30 |     /// On the server and in client-side rendered implementations, this should
31 |     /// always return [`None`].
32 |     fn read_data(&self, id: &SerializedDataId) -> Option<String>;
33 | 
34 |     /// Returns a [`Future`] that resolves with a `String` that should
35 |     /// be deserialized using [`Serializable::de`] once the given piece of server
36 |     /// data has resolved.
37 |     ///
38 |     /// On the server and in client-side rendered implementations, this should
39 |     /// return a [`Future`] that is immediately ready with [`None`].
40 |     fn await_data(&self, id: &SerializedDataId) -> Option<String>;
41 | 
42 |     /// Returns some [`Stream`] of HTML that contains JavaScript `<script>` tags defining
43 |     /// all values being serialized from the server to the client, with their serialized values
44 |     /// and any boilerplate needed to notify a running application that they exist; or `None`.
45 |     ///
46 |     /// In browser implementations, this return `None`.
47 |     fn pending_data(&self) -> Option<PinnedStream<String>>;
48 | 
49 |     fn get_is_hydrating(&self) -> bool;
50 | 
51 |     fn set_is_hydrating(&self, is_hydrating: bool);
52 | }
53 | 
54 | #[derive(
55 |     Clone, Debug, PartialEq, Eq, Hash, Default, Deserialize, Serialize,
56 | )]
57 | #[serde(transparent)]
58 | pub struct SerializedDataId(usize);
59 | 
60 | /*
61 | enum SerializableData {
62 |     Sync(Box<dyn FnOnce() + Send + Sync>),
63 |     Async(Pin<Box<dyn Future<Output = String> + Send + Sync>>),
64 | }
65 | 
66 | #[derive(Debug)]
67 | pub struct ServerData<T> {
68 |     id: SerializedDataId,
69 |     data: T,
70 | }
71 | 
72 | impl<T: Serializable> ServerData<T> {
73 |     pub fn new(data: T) -> Self {
74 |         let id = Owner::shared_context().map(|n| n.id()).unwrap_or_default();
75 |         Self { id, data }
76 |     }
77 | }
78 | */
79 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/shared_context/ssr.rs:
--------------------------------------------------------------------------------
  1 | use super::{SerializedDataId, SharedContext};
  2 | use crate::{PinnedFuture, PinnedStream};
  3 | use futures::{
  4 |     stream::{self, FuturesUnordered},
  5 |     StreamExt,
  6 | };
  7 | use parking_lot::RwLock;
  8 | use std::{
  9 |     fmt::{Debug, Write},
 10 |     mem,
 11 |     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
 12 | };
 13 | 
 14 | #[derive(Default)]
 15 | pub struct SsrSharedContext {
 16 |     id: AtomicUsize,
 17 |     is_hydrating: AtomicBool,
 18 |     sync_buf: RwLock<Vec<ResolvedData>>,
 19 |     async_buf: RwLock<Vec<(SerializedDataId, PinnedFuture<String>)>>,
 20 | }
 21 | 
 22 | impl SsrSharedContext {
 23 |     pub fn new() -> Self {
 24 |         Self {
 25 |             is_hydrating: AtomicBool::new(true),
 26 |             ..Default::default()
 27 |         }
 28 |     }
 29 | 
 30 |     pub fn new_islands() -> Self {
 31 |         Self {
 32 |             is_hydrating: AtomicBool::new(false),
 33 |             ..Default::default()
 34 |         }
 35 |     }
 36 | }
 37 | 
 38 | impl Debug for SsrSharedContext {
 39 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 40 |         f.debug_struct("SsrSharedContext")
 41 |             .field("id", &self.id)
 42 |             .field("is_hydrating", &self.is_hydrating)
 43 |             .field("sync_buf", &self.sync_buf)
 44 |             .field("async_buf", &self.async_buf.read().len())
 45 |             .finish()
 46 |     }
 47 | }
 48 | 
 49 | impl SharedContext for SsrSharedContext {
 50 |     fn next_id(&self) -> SerializedDataId {
 51 |         let id = self.id.fetch_add(1, Ordering::Relaxed);
 52 |         SerializedDataId(id)
 53 |     }
 54 | 
 55 |     fn write_async(&self, id: SerializedDataId, fut: PinnedFuture<String>) {
 56 |         self.async_buf.write().push((id, fut))
 57 |     }
 58 | 
 59 |     fn pending_data(&self) -> Option<PinnedStream<String>> {
 60 |         let sync_data = mem::take(&mut *self.sync_buf.write());
 61 |         let async_data = mem::take(&mut *self.async_buf.write());
 62 | 
 63 |         // 1) initial, synchronous setup chunk
 64 |         let mut initial_chunk = String::new();
 65 |         // resolved synchronous resources
 66 |         initial_chunk.push_str("__RESOLVED_RESOURCES=[");
 67 |         for resolved in sync_data {
 68 |             resolved.write_to_buf(&mut initial_chunk);
 69 |             initial_chunk.push(',');
 70 |         }
 71 |         initial_chunk.push_str("];");
 72 | 
 73 |         // pending async resources
 74 |         initial_chunk.push_str("__PENDING_RESOURCES=[");
 75 |         for (id, _) in &async_data {
 76 |             write!(&mut initial_chunk, "{},", id.0).unwrap();
 77 |         }
 78 |         initial_chunk.push_str("];");
 79 | 
 80 |         // resolvers
 81 |         initial_chunk.push_str("__RESOURCE_RESOLVERS=[];");
 82 | 
 83 |         // 2) async resources as they resolve
 84 |         let async_data = async_data
 85 |             .into_iter()
 86 |             .map(|(id, data)| async move {
 87 |                 let data = data.await;
 88 |                 format!("__RESOLVED_RESOURCES[{}] = {data:?};", id.0)
 89 |             })
 90 |             .collect::<FuturesUnordered<_>>();
 91 | 
 92 |         let stream =
 93 |             stream::once(async move { initial_chunk }).chain(async_data);
 94 |         Some(Box::pin(stream))
 95 |     }
 96 | 
 97 |     fn read_data(&self, _id: &SerializedDataId) -> Option<String> {
 98 |         None
 99 |     }
100 | 
101 |     fn await_data(&self, _id: &SerializedDataId) -> Option<String> {
102 |         None
103 |     }
104 | 
105 |     fn get_is_hydrating(&self) -> bool {
106 |         self.is_hydrating.load(Ordering::Relaxed)
107 |     }
108 | 
109 |     fn set_is_hydrating(&self, is_hydrating: bool) {
110 |         self.is_hydrating.store(true, Ordering::Relaxed)
111 |     }
112 | }
113 | 
114 | #[derive(Debug)]
115 | struct ResolvedData(SerializedDataId, String);
116 | 
117 | impl ResolvedData {
118 |     pub fn write_to_buf(&self, buf: &mut String) {
119 |         let ResolvedData(id, ser) = self;
120 |         // escapes < to prevent it being interpreted as another opening HTML tag
121 |         let ser = ser.replace('<', "\\u003c");
122 |         write!(buf, "{}: {:?}", id.0, ser).unwrap();
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/signal/mod.rs:
--------------------------------------------------------------------------------
  1 | mod arc_signal;
  2 | mod read;
  3 | mod write;
  4 | use crate::{
  5 |     arena::{Stored, StoredData},
  6 |     signal_traits::*,
  7 |     unwrap_signal,
  8 | };
  9 | pub use arc_signal::ArcRwSignal;
 10 | pub use read::*;
 11 | pub mod trigger;
 12 | use std::{fmt::Debug, sync::Arc};
 13 | pub use write::*;
 14 | 
 15 | pub fn signal<T>(initial_value: T) -> (ReadSignal<T>, WriteSignal<T>)
 16 | where
 17 |     T: Send + Sync + 'static,
 18 | {
 19 |     let signal = RwSignal::new(initial_value);
 20 |     signal.split()
 21 | }
 22 | 
 23 | pub fn arc_signal<T>(initial_value: T) -> (ArcReadSignal<T>, ArcWriteSignal<T>)
 24 | where
 25 |     T: Send + Sync + 'static,
 26 | {
 27 |     let signal = ArcRwSignal::new(initial_value);
 28 |     signal.split()
 29 | }
 30 | 
 31 | pub struct RwSignal<T: Send + Sync + 'static> {
 32 |     inner: Stored<ArcRwSignal<T>>,
 33 | }
 34 | 
 35 | impl<T: Send + Sync + 'static> RwSignal<T> {
 36 |     #[cfg_attr(
 37 |         feature = "tracing",
 38 |         tracing::instrument(level = "debug", skip_all,)
 39 |     )]
 40 |     pub fn new(value: T) -> Self {
 41 |         Self {
 42 |             inner: Stored::new(ArcRwSignal::new(value)),
 43 |         }
 44 |     }
 45 | 
 46 |     #[inline(always)]
 47 |     pub fn read_only(&self) -> ReadSignal<T> {
 48 |         ReadSignal {
 49 |             inner: Stored::new(
 50 |                 self.get_value()
 51 |                     .map(|inner| inner.read_only())
 52 |                     .unwrap_or_else(unwrap_signal!(self)),
 53 |             ),
 54 |         }
 55 |     }
 56 | 
 57 |     #[inline(always)]
 58 |     pub fn write_only(&self) -> WriteSignal<T> {
 59 |         WriteSignal {
 60 |             inner: Stored::new(
 61 |                 self.get_value()
 62 |                     .map(|inner| inner.write_only())
 63 |                     .unwrap_or_else(unwrap_signal!(self)),
 64 |             ),
 65 |         }
 66 |     }
 67 | 
 68 |     #[inline(always)]
 69 |     pub fn split(&self) -> (ReadSignal<T>, WriteSignal<T>) {
 70 |         (self.read_only(), self.write_only())
 71 |     }
 72 | 
 73 |     pub fn unite(read: ReadSignal<T>, write: WriteSignal<T>) -> Option<Self> {
 74 |         match (read.inner.get(), write.inner.get()) {
 75 |             (Some(read), Some(write)) => {
 76 |                 if Arc::ptr_eq(&read.0.value, &write.0.value) {
 77 |                     Some(Self {
 78 |                         inner: Stored::new(read.0.clone()),
 79 |                     })
 80 |                 } else {
 81 |                     None
 82 |                 }
 83 |             }
 84 |             _ => None,
 85 |         }
 86 |     }
 87 | }
 88 | 
 89 | impl<T: Send + Sync + 'static> Copy for RwSignal<T> {}
 90 | 
 91 | impl<T: Send + Sync + 'static> Clone for RwSignal<T> {
 92 |     fn clone(&self) -> Self {
 93 |         *self
 94 |     }
 95 | }
 96 | 
 97 | impl<T: Send + Sync + 'static> Debug for RwSignal<T> {
 98 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 99 |         f.debug_struct("Signal")
100 |             .field("type", &std::any::type_name::<T>())
101 |             .field("store", &self.inner)
102 |             .finish()
103 |     }
104 | }
105 | 
106 | impl<T: Send + Sync + 'static> SignalIsDisposed for RwSignal<T> {
107 |     fn is_disposed(&self) -> bool {
108 |         self.inner.exists()
109 |     }
110 | }
111 | 
112 | impl<T: Send + Sync + 'static> StoredData for RwSignal<T> {
113 |     type Data = ArcRwSignal<T>;
114 | 
115 |     fn get_value(&self) -> Option<Self::Data> {
116 |         self.inner.get()
117 |     }
118 | 
119 |     fn dispose(&self) {
120 |         self.inner.dispose();
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/signal/read.rs:
--------------------------------------------------------------------------------
  1 | use super::ArcRwSignal;
  2 | use crate::{
  3 |     arena::{Stored, StoredData},
  4 |     prelude::{DefinedAt, SignalWithUntracked},
  5 |     source::{AnySource, AnySubscriber, ReactiveNode, Source, ToAnySource},
  6 | };
  7 | use std::{fmt::Debug, panic::Location};
  8 | 
  9 | pub struct ReadSignal<T: Send + Sync + 'static> {
 10 |     pub(crate) inner: Stored<ArcReadSignal<T>>,
 11 | }
 12 | 
 13 | impl<T: Send + Sync + 'static> Debug for ReadSignal<T> {
 14 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 15 |         f.debug_struct("ReadSignal")
 16 |             .field("inner", &self.inner)
 17 |             .finish()
 18 |     }
 19 | }
 20 | 
 21 | impl<T: Send + Sync + 'static> StoredData for ReadSignal<T> {
 22 |     type Data = ArcReadSignal<T>;
 23 | 
 24 |     fn get_value(&self) -> Option<Self::Data> {
 25 |         self.inner.get()
 26 |     }
 27 | 
 28 |     fn dispose(&self) {
 29 |         self.inner.dispose();
 30 |     }
 31 | }
 32 | 
 33 | impl<T: Send + Sync + 'static> Clone for ReadSignal<T> {
 34 |     fn clone(&self) -> Self {
 35 |         *self
 36 |     }
 37 | }
 38 | 
 39 | impl<T: Send + Sync + 'static> Copy for ReadSignal<T> {}
 40 | 
 41 | pub struct ArcReadSignal<T>(pub(crate) ArcRwSignal<T>);
 42 | 
 43 | impl<T> Debug for ArcReadSignal<T> {
 44 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 45 |         f.debug_tuple("ArcReadSignal").field(&self.0).finish()
 46 |     }
 47 | }
 48 | 
 49 | impl<T> Clone for ArcReadSignal<T> {
 50 |     fn clone(&self) -> Self {
 51 |         Self(self.0.clone())
 52 |     }
 53 | }
 54 | 
 55 | impl<T> ReactiveNode for ArcReadSignal<T> {
 56 |     fn mark_dirty(&self) {
 57 |         self.0.mark_dirty();
 58 |     }
 59 | 
 60 |     fn mark_check(&self) {
 61 |         self.0.mark_check();
 62 |     }
 63 | 
 64 |     fn mark_subscribers_check(&self) {
 65 |         self.0.mark_subscribers_check();
 66 |     }
 67 | 
 68 |     fn update_if_necessary(&self) -> bool {
 69 |         self.0.update_if_necessary()
 70 |     }
 71 | }
 72 | 
 73 | impl<T> Source for ArcReadSignal<T> {
 74 |     fn add_subscriber(&self, subscriber: AnySubscriber) {
 75 |         self.0.add_subscriber(subscriber);
 76 |     }
 77 | 
 78 |     fn remove_subscriber(&self, subscriber: &AnySubscriber) {
 79 |         self.0.remove_subscriber(subscriber);
 80 |     }
 81 | 
 82 |     fn clear_subscribers(&self) {
 83 |         self.0.clear_subscribers();
 84 |     }
 85 | }
 86 | 
 87 | impl<T> ToAnySource for ArcReadSignal<T> {
 88 |     fn to_any_source(&self) -> AnySource {
 89 |         self.0.to_any_source()
 90 |     }
 91 | }
 92 | 
 93 | impl<T> DefinedAt for ArcReadSignal<T> {
 94 |     fn defined_at(&self) -> Option<&'static Location<'static>> {
 95 |         self.0.defined_at()
 96 |     }
 97 | }
 98 | 
 99 | impl<T> SignalWithUntracked for ArcReadSignal<T> {
100 |     type Value = T;
101 | 
102 |     fn try_with_untracked<U>(
103 |         &self,
104 |         fun: impl FnOnce(&Self::Value) -> U,
105 |     ) -> Option<U> {
106 |         self.0.try_with_untracked(fun)
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/signal/write.rs:
--------------------------------------------------------------------------------
 1 | use super::ArcRwSignal;
 2 | use crate::{
 3 |     arena::{Stored, StoredData},
 4 |     prelude::{SignalIsDisposed, SignalUpdate, SignalUpdateUntracked, Trigger},
 5 | };
 6 | 
 7 | pub struct WriteSignal<T: Send + Sync + 'static> {
 8 |     pub(crate) inner: Stored<ArcWriteSignal<T>>,
 9 | }
10 | 
11 | impl<T: Send + Sync + 'static> StoredData for WriteSignal<T> {
12 |     type Data = ArcWriteSignal<T>;
13 | 
14 |     fn get_value(&self) -> Option<Self::Data> {
15 |         self.inner.get()
16 |     }
17 | 
18 |     fn dispose(&self) {
19 |         self.inner.dispose();
20 |     }
21 | }
22 | 
23 | impl<T: Send + Sync + 'static> Clone for WriteSignal<T> {
24 |     fn clone(&self) -> Self {
25 |         *self
26 |     }
27 | }
28 | 
29 | impl<T: Send + Sync + 'static> Copy for WriteSignal<T> {}
30 | 
31 | impl<T: Send + Sync + 'static> SignalIsDisposed for WriteSignal<T> {
32 |     fn is_disposed(&self) -> bool {
33 |         !self.inner.exists()
34 |     }
35 | }
36 | 
37 | pub struct ArcWriteSignal<T>(pub(crate) ArcRwSignal<T>);
38 | 
39 | impl<T> Clone for ArcWriteSignal<T> {
40 |     fn clone(&self) -> Self {
41 |         Self(self.0.clone())
42 |     }
43 | }
44 | 
45 | impl<T> Trigger for ArcWriteSignal<T> {
46 |     fn trigger(&self) {
47 |         self.0.trigger();
48 |     }
49 | }
50 | 
51 | impl<T> SignalUpdateUntracked for ArcWriteSignal<T> {
52 |     type Value = T;
53 | 
54 |     fn try_update_untracked<U>(
55 |         &self,
56 |         fun: impl FnOnce(&mut Self::Value) -> U,
57 |     ) -> Option<U> {
58 |         self.0.try_update(fun)
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/signal_traits.rs:
--------------------------------------------------------------------------------
  1 | pub use crate::source::Track;
  2 | use std::panic::Location;
  3 | 
  4 | #[macro_export]
  5 | macro_rules! unwrap_signal {
  6 |     ($signal:ident) => {{
  7 |         #[cfg(debug_assertions)]
  8 |         let location = std::panic::Location::caller();
  9 |         || {
 10 |             #[cfg(debug_assertions)]
 11 |             {
 12 |                 panic!(
 13 |                     "{}",
 14 |                     $crate::signal_traits::panic_getting_disposed_signal(
 15 |                         $signal.defined_at(),
 16 |                         location
 17 |                     )
 18 |                 );
 19 |             }
 20 |             #[cfg(not(debug_assertions))]
 21 |             {
 22 |                 panic!(
 23 |                     "Tried to access a reactive value that has already been \
 24 |                      disposed."
 25 |                 );
 26 |             }
 27 |         }
 28 |     }};
 29 | }
 30 | 
 31 | pub trait SignalWithUntracked: DefinedAt {
 32 |     type Value;
 33 | 
 34 |     #[track_caller]
 35 |     fn try_with_untracked<U>(
 36 |         &self,
 37 |         fun: impl FnOnce(&Self::Value) -> U,
 38 |     ) -> Option<U>;
 39 | 
 40 |     #[track_caller]
 41 |     fn with_untracked<U>(&self, fun: impl FnOnce(&Self::Value) -> U) -> U {
 42 |         self.try_with_untracked(fun)
 43 |             .unwrap_or_else(unwrap_signal!(self))
 44 |     }
 45 | }
 46 | 
 47 | pub trait SignalWith: SignalWithUntracked + Track {
 48 |     #[track_caller]
 49 |     fn try_with<U>(&self, fun: impl FnOnce(&Self::Value) -> U) -> Option<U> {
 50 |         self.track();
 51 |         self.try_with_untracked(fun)
 52 |     }
 53 | 
 54 |     #[track_caller]
 55 |     fn with<U>(&self, fun: impl FnOnce(&Self::Value) -> U) -> U {
 56 |         self.try_with(fun).unwrap_or_else(unwrap_signal!(self))
 57 |     }
 58 | }
 59 | 
 60 | impl<T> SignalWith for T where T: SignalWithUntracked + Track {}
 61 | 
 62 | pub trait SignalGetUntracked: SignalWithUntracked
 63 | where
 64 |     Self::Value: Clone,
 65 | {
 66 |     fn try_get_untracked(&self) -> Option<Self::Value> {
 67 |         self.try_with_untracked(Self::Value::clone)
 68 |     }
 69 | 
 70 |     #[track_caller]
 71 |     fn get_untracked(&self) -> Self::Value {
 72 |         self.try_get_untracked()
 73 |             .unwrap_or_else(unwrap_signal!(self))
 74 |     }
 75 | }
 76 | 
 77 | impl<T> SignalGetUntracked for T
 78 | where
 79 |     T: SignalWithUntracked,
 80 |     T::Value: Clone,
 81 | {
 82 | }
 83 | 
 84 | pub trait SignalGet: SignalWith
 85 | where
 86 |     Self::Value: Clone,
 87 | {
 88 |     fn try_get(&self) -> Option<Self::Value> {
 89 |         self.try_with(Self::Value::clone)
 90 |     }
 91 | 
 92 |     #[track_caller]
 93 |     fn get(&self) -> Self::Value {
 94 |         self.try_with(Self::Value::clone)
 95 |             .unwrap_or_else(unwrap_signal!(self))
 96 |     }
 97 | }
 98 | 
 99 | impl<T> SignalGet for T
100 | where
101 |     T: SignalWith,
102 |     T::Value: Clone,
103 | {
104 | }
105 | 
106 | pub trait Trigger {
107 |     fn trigger(&self);
108 | }
109 | 
110 | pub trait SignalUpdateUntracked {
111 |     type Value;
112 | 
113 |     fn try_update_untracked<U>(
114 |         &self,
115 |         fun: impl FnOnce(&mut Self::Value) -> U,
116 |     ) -> Option<U>;
117 | }
118 | 
119 | pub trait SignalUpdate {
120 |     type Value;
121 | 
122 |     fn update(&self, fun: impl FnOnce(&mut Self::Value)) {
123 |         self.try_update(fun);
124 |     }
125 | 
126 |     fn try_update<U>(
127 |         &self,
128 |         fun: impl FnOnce(&mut Self::Value) -> U,
129 |     ) -> Option<U>;
130 | }
131 | 
132 | impl<T> SignalUpdate for T
133 | where
134 |     T: Trigger + SignalUpdateUntracked,
135 | {
136 |     type Value = T::Value;
137 | 
138 |     fn try_update<U>(
139 |         &self,
140 |         fun: impl FnOnce(&mut Self::Value) -> U,
141 |     ) -> Option<U> {
142 |         let value = self.try_update_untracked(fun);
143 |         self.trigger();
144 |         value
145 |     }
146 | }
147 | 
148 | pub trait SignalSet: SignalUpdate + SignalIsDisposed {
149 |     fn set(&self, value: impl Into<Self::Value>) {
150 |         self.update(|n| *n = value.into());
151 |     }
152 | 
153 |     fn try_set(&self, value: impl Into<Self::Value>) -> Option<Self::Value> {
154 |         if self.is_disposed() {
155 |             Some(value.into())
156 |         } else {
157 |             self.set(value);
158 |             None
159 |         }
160 |     }
161 | }
162 | 
163 | impl<T> SignalSet for T where T: SignalUpdate + SignalIsDisposed {}
164 | 
165 | pub trait SignalIsDisposed {
166 |     fn is_disposed(&self) -> bool;
167 | }
168 | 
169 | pub trait DefinedAt {
170 |     fn defined_at(&self) -> Option<&'static Location<'static>>;
171 | }
172 | 
173 | pub(crate) fn panic_getting_disposed_signal(
174 |     defined_at: Option<&'static Location<'static>>,
175 |     location: &'static Location<'static>,
176 | ) -> String {
177 |     if let Some(defined_at) = defined_at {
178 |         format!(
179 |             "At {location}, you tried to access a reactive value which was \
180 |              defined at {defined_at}, but it has already been disposed."
181 |         )
182 |     } else {
183 |         format!(
184 |             "At {location}, you tried to access a reactive value, but it has \
185 |              already been disposed."
186 |         )
187 |     }
188 | }
189 | 


--------------------------------------------------------------------------------
/tachy_reaccy/src/spawn.rs:
--------------------------------------------------------------------------------
 1 | use cfg_if::cfg_if;
 2 | use std::future::Future;
 3 | 
 4 | pub fn spawn_local<F>(fut: F)
 5 | where
 6 |     F: Future<Output = ()> + 'static,
 7 | {
 8 |     cfg_if! {
 9 |         if #[cfg(target_arch = "wasm32")] {
10 |             wasm_bindgen_futures::spawn_local(fut)
11 |         } else if #[cfg(feature = "glib")] {
12 |             let main_context = glib::MainContext::default();
13 |             main_context.spawn_local(fut);
14 |         } else if #[cfg(any(test, doctest, feature = "tokio"))] {
15 |             tokio::task::spawn_local(fut);
16 |         }  else {
17 |             use std::cell::OnceCell;
18 |             use futures::executor::LocalPool;
19 |             use futures::task::LocalSpawnExt;
20 |             thread_local! {
21 |                 static POOL: OnceCell<LocalPool> = OnceCell::new()
22 |             }
23 |             POOL.with(|pool| pool.get_or_init(|| LocalPool::new()).spawner().spawn_local(fut));
24 |         }
25 |     }
26 | }
27 | 
28 | pub fn spawn<F>(fut: F)
29 | where
30 |     F: Future<Output = ()> + Send + 'static,
31 | {
32 |     cfg_if! {
33 |         if #[cfg(target_arch = "wasm32")] {
34 |             wasm_bindgen_futures::spawn_local(fut)
35 |         } else if #[cfg(feature = "glib")] {
36 |             let main_context = glib::MainContext::default();
37 |             main_context.spawn(fut);
38 |         } else if #[cfg(any(test, doctest, feature = "tokio"))] {
39 |             tokio::task::spawn(fut);
40 |         }  else {
41 |             spawn_local(fut);
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/tachy_reaccy/tests/signal.rs:
--------------------------------------------------------------------------------
 1 | use tachy_reaccy::prelude::*;
 2 | 
 3 | #[test]
 4 | fn create_signal() {
 5 |     let a = RwSignal::new(0);
 6 |     assert_eq!(a.get(), 0);
 7 | }
 8 | 
 9 | #[test]
10 | fn update_signal() {
11 |     let a = RwSignal::new(0);
12 |     a.update(|n| *n += 1);
13 |     assert_eq!(a.get(), 1);
14 | }
15 | 


--------------------------------------------------------------------------------
/tachy_reaccy_macro/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tachy_reaccy_macro"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [lib]
 7 | proc-macro = true
 8 | 
 9 | [dependencies]
10 | proc-macro-error = "1.0.4"
11 | proc-macro2 = "1.0.70"
12 | quote = "1.0.33"
13 | syn = "2"
14 | 


--------------------------------------------------------------------------------
/tachy_route/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tachy_route"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | const_str_slice_concat = { path = "../const_str_slice_concat" }
 8 | next_tuple = { path = "../next_tuple" }
 9 | tachydom = { path = "../tachydom" }
10 | tachy_reaccy = { path = "../tachy_reaccy", optional = true }
11 | paste = "1.0.14"
12 | thiserror = "1.0.49"
13 | tuplestructops = "0.3.0"
14 | url = "2"
15 | js-sys = { version = "0.3" }
16 | wasm-bindgen = { version = "0.2" }
17 | tracing = { version = "0.1", optional = true }
18 | 
19 | [dependencies.web-sys]
20 | version = "0.3"
21 | features = [
22 | 	# History/Routing
23 | 	"History",
24 | 	"HtmlAnchorElement",
25 | 	"Location",
26 | 	"MouseEvent",
27 | 	"Url",
28 | 	# Form
29 | 	"FormData",
30 | 	"HtmlButtonElement",
31 | 	"HtmlFormElement",
32 | 	"HtmlInputElement",
33 | 	"SubmitEvent",
34 | 	"Url",
35 | 	"UrlSearchParams",
36 | 	# Fetching in Hydrate Mode
37 | 	"Headers",
38 | 	"Request",
39 | 	"RequestInit",
40 | 	"RequestMode",
41 | 	"Response",
42 | 	"Window",
43 | ]
44 | 
45 | [features]
46 | tracing = ["dep:tracing"]
47 | reaccy = ["dep:tachy_reaccy"]
48 | 


--------------------------------------------------------------------------------
/tachy_route/src/lib.rs:
--------------------------------------------------------------------------------
 1 | mod generate_route_list;
 2 | pub mod location;
 3 | pub mod matching;
 4 | #[cfg(feature = "reaccy")]
 5 | pub mod reactive;
 6 | mod render_mode;
 7 | pub mod route;
 8 | pub mod router;
 9 | mod static_render;
10 | pub use generate_route_list::*;
11 | pub use render_mode::*;
12 | 


--------------------------------------------------------------------------------
/tachy_route/src/location/state.rs:
--------------------------------------------------------------------------------
 1 | use wasm_bindgen::JsValue;
 2 | 
 3 | #[derive(Debug, Clone, Default, PartialEq)]
 4 | pub struct State(pub Option<JsValue>);
 5 | 
 6 | impl State {
 7 |     pub fn to_js_value(&self) -> JsValue {
 8 |         match &self.0 {
 9 |             Some(v) => v.clone(),
10 |             None => JsValue::UNDEFINED,
11 |         }
12 |     }
13 | }
14 | 
15 | impl<T> From<T> for State
16 | where
17 |     T: Into<JsValue>,
18 | {
19 |     fn from(value: T) -> Self {
20 |         State(Some(value.into()))
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/tachy_route/src/matching/param_segments.rs:
--------------------------------------------------------------------------------
  1 | use super::{PartialPathMatch, RouteMatch};
  2 | use crate::PathSegment;
  3 | use std::str::Chars;
  4 | 
  5 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
  6 | pub struct ParamSegment(pub &'static str);
  7 | 
  8 | impl RouteMatch for ParamSegment {
  9 |     fn matches_iter(&self, test: &mut Chars) -> bool {
 10 |         let mut test = test.peekable();
 11 |         // match an initial /
 12 |         if test.peek() == Some(&'/') {
 13 |             test.next();
 14 |         }
 15 |         for char in test {
 16 |             // when we get a closing /, stop matching
 17 |             if char == '/' {
 18 |                 break;
 19 |             }
 20 |         }
 21 |         true
 22 |     }
 23 | 
 24 |     fn test<'a>(&self, path: &'a str) -> Option<PartialPathMatch<'a>> {
 25 |         let mut matched = String::new();
 26 |         let mut param_value = String::new();
 27 |         let mut test = path.chars();
 28 | 
 29 |         // match an initial /
 30 |         if let Some('/') = test.next() {
 31 |             matched.push('/');
 32 |         }
 33 |         for char in test {
 34 |             // when we get a closing /, stop matching
 35 |             if char == '/' {
 36 |                 break;
 37 |             }
 38 |             // otherwise, push into the matched param
 39 |             else {
 40 |                 matched.push(char);
 41 |                 param_value.push(char);
 42 |             }
 43 |         }
 44 | 
 45 |         let next_index = matched.len();
 46 |         Some(PartialPathMatch::new(
 47 |             &path[next_index..],
 48 |             vec![(self.0, param_value)],
 49 |             matched,
 50 |         ))
 51 |     }
 52 | 
 53 |     fn generate_path(&self, path: &mut Vec<PathSegment>) {
 54 |         path.push(PathSegment::Param(self.0.into()));
 55 |     }
 56 | }
 57 | 
 58 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 59 | pub struct WildcardSegment(pub &'static str);
 60 | 
 61 | impl RouteMatch for WildcardSegment {
 62 |     fn matches_iter(&self, _path: &mut Chars) -> bool {
 63 |         true
 64 |     }
 65 | 
 66 |     fn test<'a>(&self, path: &'a str) -> Option<PartialPathMatch<'a>> {
 67 |         let mut matched = String::new();
 68 |         let mut param_value = String::new();
 69 |         let mut test = path.chars();
 70 | 
 71 |         // match an initial /
 72 |         if let Some('/') = test.next() {
 73 |             matched.push('/');
 74 |         }
 75 |         for char in test {
 76 |             matched.push(char);
 77 |             param_value.push(char);
 78 |         }
 79 | 
 80 |         let next_index = matched.len();
 81 |         Some(PartialPathMatch::new(
 82 |             &path[next_index..],
 83 |             vec![(self.0, param_value)],
 84 |             matched,
 85 |         ))
 86 |     }
 87 | 
 88 |     fn generate_path(&self, path: &mut Vec<PathSegment>) {
 89 |         path.push(PathSegment::Splat(self.0.into()));
 90 |     }
 91 | }
 92 | 
 93 | #[cfg(test)]
 94 | mod tests {
 95 |     use super::RouteMatch;
 96 |     use crate::matching::{ParamSegment, StaticSegment, WildcardSegment};
 97 | 
 98 |     #[test]
 99 |     fn single_param_match() {
100 |         let path = "/foo";
101 |         let def = ParamSegment("a");
102 |         assert!(def.matches(path));
103 |         let matched = def.test(path).expect("couldn't match route");
104 |         assert_eq!(matched.matched(), "/foo");
105 |         assert_eq!(matched.remaining(), "");
106 |         assert_eq!(matched.params()[0], ("a", "foo".to_string()));
107 |     }
108 | 
109 |     #[test]
110 |     fn single_param_match_with_trailing_slash() {
111 |         let path = "/foo/";
112 |         let def = ParamSegment("a");
113 |         assert!(def.matches(path));
114 |         let matched = def.test(path).expect("couldn't match route");
115 |         assert_eq!(matched.matched(), "/foo");
116 |         assert_eq!(matched.remaining(), "/");
117 |         assert_eq!(matched.params()[0], ("a", "foo".to_string()));
118 |     }
119 | 
120 |     #[test]
121 |     fn tuple_of_param_matches() {
122 |         let path = "/foo/bar";
123 |         let def = (ParamSegment("a"), ParamSegment("b"));
124 |         assert!(def.matches(path));
125 |         let matched = def.test(path).expect("couldn't match route");
126 |         assert_eq!(matched.matched(), "/foo/bar");
127 |         assert_eq!(matched.remaining(), "");
128 |         assert_eq!(matched.params()[0], ("a", "foo".to_string()));
129 |         assert_eq!(matched.params()[1], ("b", "bar".to_string()));
130 |     }
131 | 
132 |     #[test]
133 |     fn splat_should_match_all() {
134 |         let path = "/foo/bar/////";
135 |         let def = (
136 |             StaticSegment("foo"),
137 |             StaticSegment("bar"),
138 |             WildcardSegment("rest"),
139 |         );
140 |         assert!(def.matches(path));
141 |         let matched = def.test(path).expect("couldn't match route");
142 |         assert_eq!(matched.matched(), "/foo/bar/////");
143 |         assert_eq!(matched.remaining(), "");
144 |         assert_eq!(matched.params()[0], ("rest", "////".to_string()));
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/tachy_route/src/render_mode.rs:
--------------------------------------------------------------------------------
 1 | /// Indicates which rendering mode should be used for this route during server-side rendering.
 2 | ///
 3 | /// Leptos supports the following ways of rendering HTML that contains `async` data loaded
 4 | /// under `<Suspense/>`.
 5 | /// 1. **Synchronous** (use any mode except `Async`, don't depend on any resource): Serve an HTML shell that includes `fallback` for any `Suspense`. Load data on the client (using `create_local_resource`), replacing `fallback` once they're loaded.
 6 | ///     - *Pros*: App shell appears very quickly: great TTFB (time to first byte).
 7 | ///     - *Cons*: Resources load relatively slowly; you need to wait for JS + Wasm to load before even making a request.
 8 | /// 2. **Out-of-order streaming** (`OutOfOrder`, the default): Serve an HTML shell that includes `fallback` for any `Suspense`. Load data on the **server**, streaming it down to the client as it resolves, and streaming down HTML for `Suspense` nodes.
 9 | ///     - *Pros*: Combines the best of **synchronous** and `Async`, with a very fast shell and resources that begin loading on the server.
10 | ///     - *Cons*: Requires JS for suspended fragments to appear in correct order. Weaker meta tag support when it depends on data that's under suspense (has already streamed down `<head>`)
11 | /// 3. **Partially-blocked out-of-order streaming** (`PartiallyBlocked`): Using `create_blocking_resource` with out-of-order streaming still sends fallbacks and relies on JavaScript to fill them in with the fragments. Partially-blocked streaming does this replacement on the server, making for a slower response but requiring no JavaScript to show blocking resources.
12 | ///     - *Pros*: Works better if JS is disabled.
13 | ///     - *Cons*: Slower initial response because of additional string manipulation on server.
14 | /// 4. **In-order streaming** (`InOrder`): Walk through the tree, returning HTML synchronously as in synchronous rendering and out-of-order streaming until you hit a `Suspense`. At that point, wait for all its data to load, then render it, then the rest of the tree.
15 | ///     - *Pros*: Does not require JS for HTML to appear in correct order.
16 | ///     - *Cons*: Loads the shell more slowly than out-of-order streaming or synchronous rendering because it needs to pause at every `Suspense`. Cannot begin hydration until the entire page has loaded, so earlier pieces
17 | ///       of the page will not be interactive until the suspended chunks have loaded.
18 | /// 5. **`Async`**: Load all resources on the server. Wait until all data are loaded, and render HTML in one sweep.
19 | ///     - *Pros*: Better handling for meta tags (because you know async data even before you render the `<head>`). Faster complete load than **synchronous** because async resources begin loading on server.
20 | ///     - *Cons*: Slower load time/TTFB: you need to wait for all async resources to load before displaying anything on the client.
21 | ///
22 | /// The mode defaults to out-of-order streaming. For a path that includes multiple nested routes, the most
23 | /// restrictive mode will be used: i.e., if even a single nested route asks for `Async` rendering, the whole initial
24 | /// request will be rendered `Async`. (`Async` is the most restricted requirement, followed by `InOrder`, `PartiallyBlocked`, and `OutOfOrder`.)
25 | #[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
26 | pub enum SsrMode {
27 |     #[default]
28 |     OutOfOrder,
29 |     PartiallyBlocked,
30 |     InOrder,
31 |     Async,
32 | }
33 | 


--------------------------------------------------------------------------------
/tachy_route/src/route/method.rs:
--------------------------------------------------------------------------------
 1 | /// Represents an HTTP method that can be handled by this route.
 2 | #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
 3 | pub enum Method {
 4 |     /// The [`GET`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET) method
 5 |     /// requests a representation of the specified resource.
 6 |     #[default]
 7 |     Get,
 8 |     /// The [`POST`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) method
 9 |     /// submits an entity to the specified resource, often causing a change in
10 |     /// state or side effects on the server.
11 |     Post,
12 |     /// The [`PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) method
13 |     /// replaces all current representations of the target resource with the request payload.
14 |     Put,
15 |     /// The [`DELETE`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE) method
16 |     /// deletes the specified resource.
17 |     Delete,
18 |     /// The [`PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) method
19 |     /// applies partial modifications to a resource.
20 |     Patch,
21 | }
22 | 


--------------------------------------------------------------------------------
/tachy_route/src/route/route_child.rs:
--------------------------------------------------------------------------------
  1 | use super::{route_match::RouteMatch, PartialPathMatch};
  2 | 
  3 | /// A set of route definitions that can be nested inside another route definition.
  4 | pub trait PossibleRoutes {
  5 |     fn choose<'a>(&self, path: &'a str) -> Option<PartialPathMatch<'a>>;
  6 | }
  7 | 
  8 | impl PossibleRoutes for () {
  9 |     fn choose<'a>(&self, _path: &'a str) -> Option<PartialPathMatch<'a>> {
 10 |         None
 11 |     }
 12 | }
 13 | 
 14 | impl<A> PossibleRoutes for (A,)
 15 | where
 16 |     A: RouteMatch,
 17 | {
 18 |     fn choose<'a>(&self, path: &'a str) -> Option<PartialPathMatch<'a>> {
 19 |         self.0.test(path)
 20 |     }
 21 | }
 22 | 
 23 | macro_rules! tuples {
 24 |     ($($ty:ident),*) => {
 25 |         impl<$($ty),*> PossibleRoutes for ($($ty,)*)
 26 |         where
 27 | 			$($ty: RouteMatch),*,
 28 |         {
 29 |             fn choose<'a>(&self, path: &'a str) -> Option<PartialPathMatch<'a>>
 30 |             {
 31 |                 paste::paste! {
 32 | 					let ($([<$ty:lower>],)*) = &self;
 33 |                     $(if let Some(matched) = [<$ty:lower>].test(path) {
 34 |                         if matched.is_complete() {
 35 |                             return Some(matched);
 36 |                         }
 37 |                     })*
 38 |                     None
 39 |                 }
 40 |             }
 41 |         }
 42 | 	};
 43 | }
 44 | 
 45 | tuples!(A, B);
 46 | tuples!(A, B, C);
 47 | tuples!(A, B, C, D);
 48 | tuples!(A, B, C, D, E);
 49 | tuples!(A, B, C, D, E, F);
 50 | tuples!(A, B, C, D, E, F, G);
 51 | tuples!(A, B, C, D, E, F, G, H);
 52 | tuples!(A, B, C, D, E, F, G, H, I);
 53 | tuples!(A, B, C, D, E, F, G, H, I, J);
 54 | tuples!(A, B, C, D, E, F, G, H, I, J, K);
 55 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L);
 56 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M);
 57 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
 58 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
 59 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
 60 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q);
 61 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R);
 62 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S);
 63 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T);
 64 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U);
 65 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V);
 66 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W);
 67 | tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X);
 68 | tuples!(
 69 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y
 70 | );
 71 | tuples!(
 72 |     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y,
 73 |     Z
 74 | );
 75 | 
 76 | #[cfg(test)]
 77 | mod tests {
 78 |     use crate::route::{
 79 |         ParamSegment, PossibleRoutes, RouteMatch, StaticSegment,
 80 |     };
 81 | 
 82 |     #[test]
 83 |     fn mixture_of_static_and_params() {
 84 |         /* matches */
 85 |         let possible_routes = (
 86 |             (StaticSegment("")),
 87 |             (StaticSegment("about")),
 88 |             (StaticSegment("foo"), ParamSegment("id")),
 89 |             (
 90 |                 StaticSegment("foo"),
 91 |                 ParamSegment("id"),
 92 |                 (StaticSegment("bar")),
 93 |             ),
 94 |         );
 95 |         let path = "/foo/123/bar";
 96 | 
 97 |         let matched = possible_routes.choose(path);
 98 |         panic!("{matched:#?}");
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/tachy_route/src/static_render.rs:
--------------------------------------------------------------------------------
 1 | /// The mode to use when rendering the route statically.
 2 | /// On mode `Upfront`, the route will be built with the server is started using the provided static
 3 | /// data. On mode `Incremental`, the route will be built on the first request to it and then cached
 4 | /// and returned statically for subsequent requests.
 5 | #[derive(Default, Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 6 | pub enum StaticMode {
 7 |     #[default]
 8 |     Upfront,
 9 |     Incremental,
10 | }
11 | 
12 | // TODO
13 | #[derive(Debug)]
14 | pub struct StaticDataMap;
15 | 
16 | impl StaticDataMap {
17 |     pub fn new() -> Self {
18 |         Self
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tachydom/Cargo.toml:
--------------------------------------------------------------------------------
  1 | [package]
  2 | name = "tachydom"
  3 | version = "0.1.0"
  4 | edition = "2021"
  5 | 
  6 | [dependencies]
  7 | const_str_slice_concat = { path = "../const_str_slice_concat" }
  8 | next_tuple = { path = "../next_tuple" }
  9 | tachy_reaccy = { path = "../tachy_reaccy", optional = true }
 10 | slotmap = { version = "1", optional = true }
 11 | leptos_reactive = { version = "0.5", optional = true }
 12 | once_cell = "1.18.0"
 13 | paste = "1.0.12"
 14 | wasm-bindgen = "0.2"
 15 | js-sys = "0.3"
 16 | web-sys = { version = "0.3.64", features = [
 17 | 	"Window",
 18 | 	"Document",
 19 | 	"HtmlElement",
 20 | 	"HtmlInputElement",
 21 | 	"Element",
 22 | 	"Event",
 23 | 	"console",
 24 | 	"Comment",
 25 | 	"Text",
 26 | 	"Node",
 27 | 	"HtmlTemplateElement",
 28 | 	"DocumentFragment",
 29 | 	"DomTokenList",
 30 | 	"CssStyleDeclaration",
 31 | 	"ShadowRoot",
 32 | 
 33 | 	# Events we cast to in leptos_macro -- added here so we don't force users to import them
 34 | 	"AddEventListenerOptions",
 35 | 	"AnimationEvent",
 36 | 	"BeforeUnloadEvent",
 37 | 	"ClipboardEvent",
 38 | 	"CompositionEvent",
 39 | 	"CustomEvent",
 40 | 	"DeviceMotionEvent",
 41 | 	"DeviceOrientationEvent",
 42 | 	"DragEvent",
 43 | 	"ErrorEvent",
 44 | 	"Event",
 45 | 	"FocusEvent",
 46 | 	"GamepadEvent",
 47 | 	"HashChangeEvent",
 48 | 	"InputEvent",
 49 | 	"KeyboardEvent",
 50 | 	"MessageEvent",
 51 | 	"MouseEvent",
 52 | 	"PageTransitionEvent",
 53 | 	"PointerEvent",
 54 | 	"PopStateEvent",
 55 | 	"ProgressEvent",
 56 | 	"PromiseRejectionEvent",
 57 | 	"SecurityPolicyViolationEvent",
 58 | 	"StorageEvent",
 59 | 	"SubmitEvent",
 60 | 	"TouchEvent",
 61 | 	"TransitionEvent",
 62 | 	"UiEvent",
 63 | 	"WheelEvent",
 64 | 
 65 | 	# HTML Element Types
 66 | 	"HtmlHtmlElement",
 67 | 	"HtmlBaseElement",
 68 | 	"HtmlHeadElement",
 69 | 	"HtmlLinkElement",
 70 | 	"HtmlMetaElement",
 71 | 	"HtmlStyleElement",
 72 | 	"HtmlTitleElement",
 73 | 	"HtmlBodyElement",
 74 | 	"HtmlHeadingElement",
 75 | 	"HtmlQuoteElement",
 76 | 	"HtmlDivElement",
 77 | 	"HtmlDListElement",
 78 | 	"HtmlHrElement",
 79 | 	"HtmlLiElement",
 80 | 	"HtmlOListElement",
 81 | 	"HtmlParagraphElement",
 82 | 	"HtmlPreElement",
 83 | 	"HtmlUListElement",
 84 | 	"HtmlAnchorElement",
 85 | 	"HtmlBrElement",
 86 | 	"HtmlDataElement",
 87 | 	"HtmlQuoteElement",
 88 | 	"HtmlSpanElement",
 89 | 	"HtmlTimeElement",
 90 | 	"HtmlAreaElement",
 91 | 	"HtmlAudioElement",
 92 | 	"HtmlImageElement",
 93 | 	"HtmlMapElement",
 94 | 	"HtmlTrackElement",
 95 | 	"HtmlVideoElement",
 96 | 	"HtmlEmbedElement",
 97 | 	"HtmlIFrameElement",
 98 | 	"HtmlObjectElement",
 99 | 	"HtmlParamElement",
100 | 	"HtmlPictureElement",
101 | 	"HtmlSourceElement",
102 | 	"SvgElement",
103 | 	"HtmlCanvasElement",
104 | 	"HtmlScriptElement",
105 | 	"HtmlModElement",
106 | 	"HtmlTableCaptionElement",
107 | 	"HtmlTableColElement",
108 | 	"HtmlTableColElement",
109 | 	"HtmlTableElement",
110 | 	"HtmlTableSectionElement",
111 | 	"HtmlTableCellElement",
112 | 	"HtmlTableSectionElement",
113 | 	"HtmlTableCellElement",
114 | 	"HtmlTableSectionElement",
115 | 	"HtmlTableRowElement",
116 | 	"HtmlButtonElement",
117 | 	"HtmlDataListElement",
118 | 	"HtmlFieldSetElement",
119 | 	"HtmlFormElement",
120 | 	"HtmlInputElement",
121 | 	"HtmlLabelElement",
122 | 	"HtmlLegendElement",
123 | 	"HtmlMeterElement",
124 | 	"HtmlOptGroupElement",
125 | 	"HtmlOutputElement",
126 | 	"HtmlProgressElement",
127 | 	"HtmlSelectElement",
128 | 	"HtmlTextAreaElement",
129 | 	"HtmlDetailsElement",
130 | 	"HtmlDialogElement",
131 | 	"HtmlMenuElement",
132 | 	"HtmlSlotElement",
133 | 	"HtmlTemplateElement",
134 | 	"HtmlOptionElement",
135 | ] }
136 | drain_filter_polyfill = "0.1.3"
137 | indexmap = "2.0.2"
138 | rustc-hash = "1.1.0"
139 | tokio = { version = "1", optional = true, features = ["rt"] }
140 | wasm-bindgen-futures = { version = "0.4", optional = true }
141 | futures = "0.3"
142 | parking_lot = "0.12"
143 | pin-project-lite = "0.2"
144 | itertools = "0.12.0"
145 | send_wrapper = "0.6.0"
146 | 
147 | [dev-dependencies]
148 | tokio-test = "0.4"
149 | tokio = { version = "1", features = ["rt", "macros"] }
150 | 
151 | [features]
152 | default = ["testing"]
153 | delegation = []                       # enables event delegation
154 | hydrate = []
155 | islands = []
156 | ssr = []
157 | nightly = ["leptos_reactive/nightly"]
158 | testing = ["dep:slotmap"]
159 | leptos = ["dep:leptos_reactive"]
160 | reaccy = ["dep:tachy_reaccy"]
161 | tokio = ["dep:tokio"]
162 | web = ["dep:wasm-bindgen-futures"]
163 | 


--------------------------------------------------------------------------------
/tachydom/TODO.md:
--------------------------------------------------------------------------------
 1 | - hackernews example
 2 |   - SSR
 3 |   - islands
 4 |   - TODOs
 5 |   - Suspense/Transition/Await components
 6 |   - nicer routing components
 7 |   - async routing (waiting for data to load before navigation)
 8 |   - `<A>` component
 9 |   - figure out rebuilding issues: list (needs new signal IDs) vs. regular rebuild
10 | - better import/export API
11 | - escaping HTML correctly (attributes + text nodes)
12 | - nested routes
13 | - Signal wrappers
14 | - SignalDispose implementations on all Copy types
15 | - untracked access warnings
16 | - nicer type than -> `impl RenderHtml<Dom>`
17 | - \_meta package (and use in hackernews)
18 | - building out examples to find missing features
19 | - fix order of el and key so they're the same across traits, in build and rebuild, for attr and property
20 | - update streaming SSR tests
21 | 


--------------------------------------------------------------------------------
/tachydom/src/dom.rs:
--------------------------------------------------------------------------------
 1 | use once_cell::unsync::Lazy;
 2 | use wasm_bindgen::JsCast;
 3 | use web_sys::{Document, HtmlElement, Node, Window};
 4 | 
 5 | pub fn window() -> Window {
 6 |     web_sys::window().unwrap()
 7 | }
 8 | 
 9 | pub fn document() -> Document {
10 |     window().document().unwrap()
11 | }
12 | 
13 | pub fn body() -> HtmlElement {
14 |     document().body().unwrap()
15 | }
16 | 
17 | pub fn comment() -> Node {
18 |     thread_local! {
19 |         static COMMENT: Lazy<Node> = Lazy::new(|| {
20 |             document().create_comment("").unchecked_into()
21 |         });
22 |     }
23 |     COMMENT.with(|n| n.clone_node().unwrap())
24 | }
25 | 
26 | pub fn log(s: &str) {
27 |     web_sys::console::log_1(&wasm_bindgen::JsValue::from_str(s));
28 | }
29 | 
30 | /// Helper function to extract [`Event.target`](https://developer.mozilla.org/en-US/docs/Web/API/Event/target)
31 | /// from any event.
32 | pub fn event_target<T>(event: &web_sys::Event) -> T
33 | where
34 |     T: JsCast,
35 | {
36 |     event.target().unwrap().unchecked_into::<T>()
37 | }
38 | 
39 | /// Helper function to extract `event.target.value` from an event.
40 | ///
41 | /// This is useful in the `on:input` or `on:change` listeners for an `<input>` element.
42 | pub fn event_target_value<T>(event: &T) -> String
43 | where
44 |     T: JsCast,
45 | {
46 |     event
47 |         .unchecked_ref::<web_sys::Event>()
48 |         .target()
49 |         .unwrap()
50 |         .unchecked_into::<web_sys::HtmlInputElement>()
51 |         .value()
52 | }
53 | 
54 | /// Helper function to extract `event.target.checked` from an event.
55 | ///
56 | /// This is useful in the `on:change` listeners for an `<input type="checkbox">` element.
57 | pub fn event_target_checked(ev: &web_sys::Event) -> bool {
58 |     ev.target()
59 |         .unwrap()
60 |         .unchecked_into::<web_sys::HtmlInputElement>()
61 |         .checked()
62 | }
63 | 


--------------------------------------------------------------------------------
/tachydom/src/error.rs:
--------------------------------------------------------------------------------
 1 | use std::{error, fmt, ops};
 2 | 
 3 | /// This is a result type into which any error can be converted,
 4 | /// and which can be used directly in your `view`.
 5 | ///
 6 | /// All errors will be stored as [`struct@Error`].
 7 | pub type Result<T> = core::result::Result<T, Error>;
 8 | 
 9 | /// A generic wrapper for any error.
10 | #[derive(Debug)]
11 | #[repr(transparent)]
12 | pub struct Error(Box<dyn error::Error + Send + Sync>);
13 | 
14 | impl ops::Deref for Error {
15 |     type Target = Box<dyn error::Error + Send + Sync>;
16 | 
17 |     fn deref(&self) -> &Self::Target {
18 |         &self.0
19 |     }
20 | }
21 | 
22 | impl fmt::Display for Error {
23 |     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
24 |         write!(f, "{}", self.0)
25 |     }
26 | }
27 | 
28 | impl<T> From<T> for Error
29 | where
30 |     T: error::Error + Send + Sync + 'static,
31 | {
32 |     fn from(value: T) -> Self {
33 |         Error(Box::new(value))
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tachydom/src/html/attribute/custom.rs:
--------------------------------------------------------------------------------
  1 | use super::global::AddAttribute;
  2 | use crate::{
  3 |     html::attribute::{Attribute, AttributeValue},
  4 |     renderer::DomRenderer,
  5 |     view::{Position, ToTemplate},
  6 | };
  7 | use std::{borrow::Cow, marker::PhantomData, rc::Rc, sync::Arc};
  8 | 
  9 | #[inline(always)]
 10 | pub fn custom_attribute<K, V, R>(key: K, value: V) -> CustomAttr<K, V, R>
 11 | where
 12 |     K: CustomAttributeKey,
 13 |     V: AttributeValue<R>,
 14 |     R: DomRenderer,
 15 | {
 16 |     CustomAttr {
 17 |         key,
 18 |         value,
 19 |         rndr: PhantomData,
 20 |     }
 21 | }
 22 | 
 23 | pub struct CustomAttr<K, V, R>
 24 | where
 25 |     K: CustomAttributeKey,
 26 |     V: AttributeValue<R>,
 27 |     R: DomRenderer,
 28 | {
 29 |     key: K,
 30 |     value: V,
 31 |     rndr: PhantomData<R>,
 32 | }
 33 | 
 34 | impl<K, V, R> Attribute<R> for CustomAttr<K, V, R>
 35 | where
 36 |     K: CustomAttributeKey,
 37 |     V: AttributeValue<R>,
 38 |     R: DomRenderer,
 39 | {
 40 |     const MIN_LENGTH: usize = 0;
 41 |     type State = V::State;
 42 | 
 43 |     fn to_html(
 44 |         self,
 45 |         buf: &mut String,
 46 |         _class: &mut String,
 47 |         _style: &mut String,
 48 |         _inner_html: &mut String,
 49 |     ) {
 50 |         self.value.to_html(self.key.as_ref(), buf);
 51 |     }
 52 | 
 53 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
 54 |         if !K::KEY.is_empty() {
 55 |             self.value.hydrate::<FROM_SERVER>(self.key.as_ref(), el)
 56 |         } else {
 57 |             self.value.build(el, self.key.as_ref())
 58 |         }
 59 |     }
 60 | 
 61 |     fn build(self, el: &R::Element) -> Self::State {
 62 |         self.value.build(el, self.key.as_ref())
 63 |     }
 64 | 
 65 |     fn rebuild(self, state: &mut Self::State) {
 66 |         self.value.rebuild(self.key.as_ref(), state);
 67 |     }
 68 | }
 69 | 
 70 | impl<K, V, R> ToTemplate for CustomAttr<K, V, R>
 71 | where
 72 |     K: CustomAttributeKey,
 73 |     V: AttributeValue<R>,
 74 |     R: DomRenderer,
 75 | {
 76 |     fn to_template(
 77 |         buf: &mut String,
 78 |         _class: &mut String,
 79 |         _style: &mut String,
 80 |         _inner_html: &mut String,
 81 |         _position: &mut Position,
 82 |     ) {
 83 |         if !K::KEY.is_empty() {
 84 |             V::to_template(K::KEY, buf);
 85 |         }
 86 |     }
 87 | }
 88 | 
 89 | pub trait CustomAttributeKey: AsRef<str> {
 90 |     const KEY: &'static str;
 91 | }
 92 | 
 93 | impl<'a> CustomAttributeKey for &'a str {
 94 |     const KEY: &'static str = "";
 95 | }
 96 | 
 97 | impl<'a> CustomAttributeKey for Cow<'a, str> {
 98 |     const KEY: &'static str = "";
 99 | }
100 | 
101 | impl CustomAttributeKey for &String {
102 |     const KEY: &'static str = "";
103 | }
104 | 
105 | impl CustomAttributeKey for String {
106 |     const KEY: &'static str = "";
107 | }
108 | 
109 | impl CustomAttributeKey for Rc<str> {
110 |     const KEY: &'static str = "";
111 | }
112 | 
113 | impl CustomAttributeKey for Arc<str> {
114 |     const KEY: &'static str = "";
115 | }
116 | 
117 | #[cfg(feature = "nightly")]
118 | impl<const K: &'static str> CustomAttributeKey
119 |     for crate::view::static_types::Static<K>
120 | {
121 |     const KEY: &'static str = K;
122 | }
123 | 
124 | pub trait CustomAttribute<K, V, Rndr>
125 | where
126 |     K: CustomAttributeKey,
127 |     V: AttributeValue<Rndr>,
128 |     Rndr: DomRenderer,
129 |     Self: Sized + AddAttribute<CustomAttr<K, V, Rndr>, Rndr>,
130 | {
131 |     fn attr(
132 |         self,
133 |         key: K,
134 |         value: V,
135 |     ) -> <Self as AddAttribute<CustomAttr<K, V, Rndr>, Rndr>>::Output {
136 |         self.add_attr(custom_attribute(key, value))
137 |     }
138 | }
139 | 
140 | impl<T, K, V, Rndr> CustomAttribute<K, V, Rndr> for T
141 | where
142 |     T: AddAttribute<CustomAttr<K, V, Rndr>, Rndr>,
143 |     K: CustomAttributeKey,
144 |     V: AttributeValue<Rndr>,
145 |     Rndr: DomRenderer,
146 | {
147 | }
148 | 


--------------------------------------------------------------------------------
/tachydom/src/html/element/custom.rs:
--------------------------------------------------------------------------------
 1 | use super::ElementWithChildren;
 2 | use crate::{
 3 |     html::element::{CreateElement, ElementType, HtmlElement},
 4 |     renderer::{dom::Dom, Renderer},
 5 | };
 6 | use std::{borrow::Cow, fmt::Debug, marker::PhantomData, rc::Rc, sync::Arc};
 7 | 
 8 | // FIXME custom element HTML rendering is broken because tag names aren't static
 9 | pub fn custom<E, Rndr>(tag: E) -> HtmlElement<Custom<E>, (), (), Rndr>
10 | where
11 |     E: CustomElementKey,
12 |     Rndr: Renderer,
13 | {
14 |     HtmlElement {
15 |         tag: Custom(tag),
16 |         rndr: PhantomData,
17 |         attributes: (),
18 |         children: (),
19 |     }
20 | }
21 | 
22 | #[derive(Debug, Copy, Clone, PartialEq, Eq)]
23 | pub struct Custom<E>(E)
24 | where
25 |     E: CustomElementKey;
26 | 
27 | impl<E> ElementType for Custom<E>
28 | where
29 |     E: CustomElementKey,
30 | {
31 |     type Output = web_sys::HtmlElement;
32 | 
33 |     const TAG: &'static str = E::KEY;
34 |     const SELF_CLOSING: bool = false;
35 | 
36 |     fn tag(&self) -> &str {
37 |         self.0.as_ref()
38 |     }
39 | }
40 | 
41 | impl<E> ElementWithChildren for Custom<E> where E: CustomElementKey {}
42 | 
43 | impl<E> CreateElement<Dom> for Custom<E>
44 | where
45 |     E: CustomElementKey,
46 | {
47 |     fn create_element(&self) -> <Dom as Renderer>::Element {
48 |         use wasm_bindgen::intern;
49 | 
50 |         crate::dom::document()
51 |             .create_element(intern(self.0.as_ref()))
52 |             .unwrap()
53 |     }
54 | }
55 | 
56 | // TODO these are all broken for custom elements
57 | pub trait CustomElementKey: AsRef<str> {
58 |     const KEY: &'static str;
59 | }
60 | 
61 | impl<'a> CustomElementKey for &'a str {
62 |     const KEY: &'static str = "";
63 | }
64 | 
65 | impl<'a> CustomElementKey for Cow<'a, str> {
66 |     const KEY: &'static str = "";
67 | }
68 | 
69 | impl CustomElementKey for &String {
70 |     const KEY: &'static str = "";
71 | }
72 | 
73 | impl CustomElementKey for String {
74 |     const KEY: &'static str = "";
75 | }
76 | 
77 | impl CustomElementKey for Rc<str> {
78 |     const KEY: &'static str = "";
79 | }
80 | 
81 | impl CustomElementKey for Arc<str> {
82 |     const KEY: &'static str = "";
83 | }
84 | 
85 | #[cfg(feature = "nightly")]
86 | impl<const K: &'static str> CustomElementKey
87 |     for crate::view::static_types::Static<K>
88 | {
89 |     const KEY: &'static str = K;
90 | }
91 | 


--------------------------------------------------------------------------------
/tachydom/src/html/element/inner_html.rs:
--------------------------------------------------------------------------------
  1 | use super::{ElementWithChildren, HtmlElement};
  2 | use crate::{
  3 |     html::{attribute::Attribute, element::AddAttribute},
  4 |     prelude::Render,
  5 |     renderer::{DomRenderer, Renderer},
  6 | };
  7 | use std::marker::PhantomData;
  8 | 
  9 | #[inline(always)]
 10 | pub fn inner_html<T, R>(value: T) -> InnerHtml<T, R>
 11 | where
 12 |     T: AsRef<str>,
 13 |     R: DomRenderer,
 14 | {
 15 |     InnerHtml {
 16 |         value,
 17 |         rndr: PhantomData,
 18 |     }
 19 | }
 20 | 
 21 | #[derive(Debug, Clone, Copy)]
 22 | pub struct InnerHtml<T, R>
 23 | where
 24 |     T: AsRef<str>,
 25 |     R: Renderer,
 26 | {
 27 |     value: T,
 28 |     rndr: PhantomData<R>,
 29 | }
 30 | 
 31 | impl<T, R> Attribute<R> for InnerHtml<T, R>
 32 | where
 33 |     T: AsRef<str> + PartialEq,
 34 |     R: DomRenderer,
 35 |     R::Element: Clone,
 36 | {
 37 |     const MIN_LENGTH: usize = 0;
 38 | 
 39 |     type State = (R::Element, T);
 40 | 
 41 |     fn to_html(
 42 |         self,
 43 |         _buf: &mut String,
 44 |         _class: &mut String,
 45 |         _style: &mut String,
 46 |         inner_html: &mut String,
 47 |     ) {
 48 |         inner_html.push_str(self.value.as_ref());
 49 |     }
 50 | 
 51 |     fn hydrate<const FROM_SERVER: bool>(
 52 |         self,
 53 |         el: &<R as Renderer>::Element,
 54 |     ) -> Self::State {
 55 |         (el.clone(), self.value)
 56 |     }
 57 | 
 58 |     fn build(self, el: &<R as Renderer>::Element) -> Self::State {
 59 |         R::set_inner_html(el, self.value.as_ref());
 60 |         (el.clone(), self.value)
 61 |     }
 62 | 
 63 |     fn rebuild(self, state: &mut Self::State) {
 64 |         let (el, prev) = state;
 65 |         if self.value != *prev {
 66 |             R::set_inner_html(el, self.value.as_ref());
 67 |             *prev = self.value;
 68 |         }
 69 |     }
 70 | }
 71 | 
 72 | pub trait InnerHtmlAttribute<T, Rndr>
 73 | where
 74 |     T: AsRef<str>,
 75 |     Rndr: DomRenderer,
 76 |     Self: Sized + AddAttribute<InnerHtml<T, Rndr>, Rndr>,
 77 | {
 78 |     fn inner_html(
 79 |         self,
 80 |         value: T,
 81 |     ) -> <Self as AddAttribute<InnerHtml<T, Rndr>, Rndr>>::Output {
 82 |         self.add_attr(inner_html(value))
 83 |     }
 84 | }
 85 | 
 86 | impl<T, E, At, Rndr> InnerHtmlAttribute<T, Rndr>
 87 |     for HtmlElement<E, At, (), Rndr>
 88 | where
 89 |     Self: AddAttribute<InnerHtml<T, Rndr>, Rndr>,
 90 |     E: ElementWithChildren,
 91 |     At: Attribute<Rndr>,
 92 |     T: AsRef<str>,
 93 |     Rndr: DomRenderer,
 94 | {
 95 |     fn inner_html(
 96 |         self,
 97 |         value: T,
 98 |     ) -> <Self as AddAttribute<InnerHtml<T, Rndr>, Rndr>>::Output {
 99 |         self.add_attr(inner_html(value))
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/tachydom/src/html/mod.rs:
--------------------------------------------------------------------------------
 1 | use crate::{
 2 |     renderer::Renderer,
 3 |     view::{Position, Render, RenderHtml},
 4 | };
 5 | use std::marker::PhantomData;
 6 | 
 7 | pub mod attribute;
 8 | pub mod class;
 9 | pub mod element;
10 | pub mod event;
11 | pub mod islands;
12 | pub mod node_ref;
13 | pub mod property;
14 | pub mod style;
15 | 
16 | pub struct Doctype<R: Renderer> {
17 |     value: &'static str,
18 |     rndr: PhantomData<R>,
19 | }
20 | 
21 | pub fn doctype<R: Renderer>(value: &'static str) -> Doctype<R> {
22 |     Doctype {
23 |         value,
24 |         rndr: PhantomData,
25 |     }
26 | }
27 | 
28 | impl<R: Renderer> Render<R> for Doctype<R> {
29 |     type State = ();
30 | 
31 |     fn build(self) -> Self::State {}
32 | 
33 |     fn rebuild(self, _state: &mut Self::State) {}
34 | }
35 | 
36 | impl<R> RenderHtml<R> for Doctype<R>
37 | where
38 |     R: Renderer,
39 |     R::Element: Clone,
40 |     R::Node: Clone,
41 | {
42 |     const MIN_LENGTH: usize = "<!DOCTYPE html>".len();
43 | 
44 |     fn to_html_with_buf(self, buf: &mut String, _position: &mut Position) {
45 |         buf.push_str("<!DOCTYPE ");
46 |         buf.push_str(self.value);
47 |         buf.push('>');
48 |     }
49 | 
50 |     fn hydrate<const FROM_SERVER: bool>(
51 |         self,
52 |         _cursor: &crate::hydration::Cursor<R>,
53 |         _position: &crate::view::PositionState,
54 |     ) -> Self::State {
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/tachydom/src/html/node_ref.rs:
--------------------------------------------------------------------------------
  1 | use super::{
  2 |     attribute::{global::AddAttribute, Attribute},
  3 |     element::ElementType,
  4 | };
  5 | use crate::{html::element::HtmlElement, prelude::Render, renderer::Renderer};
  6 | use std::marker::PhantomData;
  7 | 
  8 | pub trait NodeRefContainer<E, Rndr>
  9 | where
 10 |     E: ElementType,
 11 |     Rndr: Renderer,
 12 | {
 13 |     fn load(self, el: &Rndr::Element);
 14 | }
 15 | 
 16 | pub struct NodeRefAttr<E, C, Rndr>
 17 | where
 18 |     E: ElementType,
 19 |     C: NodeRefContainer<E, Rndr>,
 20 |     Rndr: Renderer,
 21 | {
 22 |     container: C,
 23 |     ty: PhantomData<E>,
 24 |     rndr: PhantomData<Rndr>,
 25 | }
 26 | 
 27 | pub fn node_ref<E, C, Rndr>(container: C) -> NodeRefAttr<E, C, Rndr>
 28 | where
 29 |     E: ElementType,
 30 |     C: NodeRefContainer<E, Rndr>,
 31 |     Rndr: Renderer,
 32 | {
 33 |     NodeRefAttr {
 34 |         container,
 35 |         ty: PhantomData,
 36 |         rndr: PhantomData,
 37 |     }
 38 | }
 39 | 
 40 | impl<E, C, Rndr> Attribute<Rndr> for NodeRefAttr<E, C, Rndr>
 41 | where
 42 |     E: ElementType,
 43 |     C: NodeRefContainer<E, Rndr>,
 44 |     Rndr: Renderer,
 45 |     Rndr::Element: Clone + PartialEq,
 46 | {
 47 |     const MIN_LENGTH: usize = 0;
 48 |     type State = ();
 49 | 
 50 |     fn to_html(
 51 |         self,
 52 |         _buf: &mut String,
 53 |         _class: &mut String,
 54 |         _style: &mut String,
 55 |         _inner_html: &mut String,
 56 |     ) {
 57 |     }
 58 | 
 59 |     fn hydrate<const FROM_SERVER: bool>(
 60 |         self,
 61 |         el: &<Rndr as Renderer>::Element,
 62 |     ) -> Self::State {
 63 |         self.container.load(el);
 64 |     }
 65 | 
 66 |     fn build(self, el: &<Rndr as Renderer>::Element) -> Self::State {
 67 |         self.container.load(el);
 68 |     }
 69 | 
 70 |     fn rebuild(self, _state: &mut Self::State) {}
 71 | }
 72 | 
 73 | pub trait NodeRefAttribute<E, C, Rndr>
 74 | where
 75 |     E: ElementType,
 76 |     C: NodeRefContainer<E, Rndr>,
 77 |     Rndr: Renderer,
 78 | {
 79 |     fn node_ref(
 80 |         self,
 81 |         container: C,
 82 |     ) -> <Self as AddAttribute<NodeRefAttr<E, C, Rndr>, Rndr>>::Output
 83 |     where
 84 |         Self: Sized + AddAttribute<NodeRefAttr<E, C, Rndr>, Rndr>,
 85 |         <Self as AddAttribute<NodeRefAttr<E, C, Rndr>, Rndr>>::Output:
 86 |             Render<Rndr>,
 87 |     {
 88 |         self.add_attr(node_ref(container))
 89 |     }
 90 | }
 91 | 
 92 | impl<E, At, Ch, C, Rndr> NodeRefAttribute<E, C, Rndr>
 93 |     for HtmlElement<E, At, Ch, Rndr>
 94 | where
 95 |     E: ElementType,
 96 |     At: Attribute<Rndr>,
 97 |     Ch: Render<Rndr>,
 98 |     C: NodeRefContainer<E, Rndr>,
 99 |     Rndr: Renderer,
100 | {
101 | }
102 | 


--------------------------------------------------------------------------------
/tachydom/src/html/property.rs:
--------------------------------------------------------------------------------
  1 | use super::attribute::Attribute;
  2 | use crate::{
  3 |     renderer::DomRenderer,
  4 |     view::{Position, ToTemplate},
  5 | };
  6 | use std::marker::PhantomData;
  7 | use wasm_bindgen::JsValue;
  8 | 
  9 | #[inline(always)]
 10 | pub fn property<K, P, R>(key: K, value: P) -> Property<K, P, R>
 11 | where
 12 |     K: AsRef<str>,
 13 |     P: IntoProperty<R>,
 14 |     R: DomRenderer,
 15 | {
 16 |     Property {
 17 |         key,
 18 |         value,
 19 |         rndr: PhantomData,
 20 |     }
 21 | }
 22 | 
 23 | pub struct Property<K, P, R>
 24 | where
 25 |     K: AsRef<str>,
 26 |     P: IntoProperty<R>,
 27 |     R: DomRenderer,
 28 | {
 29 |     key: K,
 30 |     value: P,
 31 |     rndr: PhantomData<R>,
 32 | }
 33 | 
 34 | impl<K, P, R> Attribute<R> for Property<K, P, R>
 35 | where
 36 |     K: AsRef<str>,
 37 |     P: IntoProperty<R>,
 38 |     R: DomRenderer,
 39 | {
 40 |     const MIN_LENGTH: usize = 0;
 41 |     type State = P::State;
 42 | 
 43 |     fn to_html(
 44 |         self,
 45 |         _buf: &mut String,
 46 |         _class: &mut String,
 47 |         _style: &mut String,
 48 |         _inner_html: &mut String,
 49 |     ) {
 50 |     }
 51 | 
 52 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
 53 |         self.value.hydrate::<FROM_SERVER>(el, self.key.as_ref())
 54 |     }
 55 | 
 56 |     fn build(self, el: &R::Element) -> Self::State {
 57 |         self.value.build(el, self.key.as_ref())
 58 |     }
 59 | 
 60 |     fn rebuild(self, state: &mut Self::State) {
 61 |         self.value.rebuild(state, self.key.as_ref())
 62 |     }
 63 | }
 64 | 
 65 | impl<K, P, R> ToTemplate for Property<K, P, R>
 66 | where
 67 |     K: AsRef<str>,
 68 |     P: IntoProperty<R>,
 69 |     R: DomRenderer,
 70 | {
 71 |     fn to_template(
 72 |         _buf: &mut String,
 73 |         _class: &mut String,
 74 |         _style: &mut String,
 75 |         _inner_html: &mut String,
 76 |         _position: &mut Position,
 77 |     ) {
 78 |     }
 79 | }
 80 | 
 81 | pub trait IntoProperty<R: DomRenderer> {
 82 |     type State;
 83 | 
 84 |     fn hydrate<const FROM_SERVER: bool>(
 85 |         self,
 86 |         el: &R::Element,
 87 |         key: &str,
 88 |     ) -> Self::State;
 89 | 
 90 |     fn build(self, el: &R::Element, key: &str) -> Self::State;
 91 | 
 92 |     fn rebuild(self, state: &mut Self::State, key: &str);
 93 | }
 94 | 
 95 | macro_rules! prop_type {
 96 |     ($prop_type:ty) => {
 97 |         impl<R> IntoProperty<R> for $prop_type
 98 |         where
 99 |             R: DomRenderer,
100 |             R::Element: Clone,
101 |         {
102 |             type State = (R::Element, JsValue);
103 | 
104 |             fn hydrate<const FROM_SERVER: bool>(
105 |                 self,
106 |                 el: &R::Element,
107 |                 key: &str,
108 |             ) -> Self::State {
109 |                 let value = self.into();
110 |                 R::set_property(el, key, &value);
111 |                 (el.clone(), value)
112 |             }
113 | 
114 |             fn build(self, el: &R::Element, key: &str) -> Self::State {
115 |                 let value = self.into();
116 |                 R::set_property(el, key, &value);
117 |                 (el.clone(), value)
118 |             }
119 | 
120 |             fn rebuild(self, state: &mut Self::State, key: &str) {
121 |                 let (el, prev) = state;
122 |                 let value = self.into();
123 |                 if value != *prev {
124 |                     R::set_property(el, key, &value);
125 |                 }
126 |                 *prev = value;
127 |             }
128 |         }
129 |     };
130 | }
131 | 
132 | prop_type!(JsValue);
133 | prop_type!(String);
134 | prop_type!(&String);
135 | prop_type!(&str);
136 | prop_type!(usize);
137 | prop_type!(u8);
138 | prop_type!(u16);
139 | prop_type!(u32);
140 | prop_type!(u64);
141 | prop_type!(u128);
142 | prop_type!(isize);
143 | prop_type!(i8);
144 | prop_type!(i16);
145 | prop_type!(i32);
146 | prop_type!(i64);
147 | prop_type!(i128);
148 | prop_type!(f32);
149 | prop_type!(f64);
150 | prop_type!(bool);
151 | 


--------------------------------------------------------------------------------
/tachydom/src/hydration.rs:
--------------------------------------------------------------------------------
 1 | use crate::renderer::Renderer;
 2 | use std::{cell::RefCell, rc::Rc};
 3 | 
 4 | #[derive(Debug)]
 5 | pub struct Cursor<R: Renderer>(Rc<RefCell<R::Node>>);
 6 | 
 7 | impl<R: Renderer> Clone for Cursor<R> {
 8 |     fn clone(&self) -> Self {
 9 |         Self(Rc::clone(&self.0))
10 |     }
11 | }
12 | 
13 | impl<R> Cursor<R>
14 | where
15 |     R: Renderer,
16 |     R::Node: Clone,
17 |     R::Element: AsRef<R::Node>,
18 | {
19 |     pub fn new(root: R::Element) -> Self {
20 |         Self(Rc::new(RefCell::new(root.as_ref().clone())))
21 |     }
22 | 
23 |     pub fn current(&self) -> R::Node {
24 |         self.0.borrow().clone()
25 |     }
26 | 
27 |     pub fn child(&self) {
28 |         let mut inner = self.0.borrow_mut();
29 |         if let Some(node) = R::first_child(&*inner) {
30 |             *inner = node;
31 |         }
32 |     }
33 | 
34 |     pub fn sibling(&self) {
35 |         let mut inner = self.0.borrow_mut();
36 |         if let Some(node) = R::next_sibling(&*inner) {
37 |             *inner = node;
38 |         }
39 |     }
40 | 
41 |     pub fn parent(&self) {
42 |         let mut inner = self.0.borrow_mut();
43 |         if let Some(node) = R::get_parent(&*inner) {
44 |             *inner = node;
45 |         }
46 |     }
47 | 
48 |     pub fn set(&self, node: R::Node) {
49 |         *self.0.borrow_mut() = node;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/tachydom/src/leptos/class.rs:
--------------------------------------------------------------------------------
  1 | use crate::{html::class::IntoClass, renderer::DomRenderer};
  2 | use leptos_reactive::{create_render_effect, Effect};
  3 | 
  4 | impl<F, C, R> IntoClass<R> for F
  5 | where
  6 |     F: Fn() -> C + 'static,
  7 |     C: IntoClass<R> + 'static,
  8 |     C::State: 'static,
  9 |     R: DomRenderer,
 10 |     R::ClassList: 'static,
 11 |     R::Element: Clone + 'static,
 12 | {
 13 |     type State = Effect<C::State>;
 14 | 
 15 |     fn to_html(self, class: &mut String) {
 16 |         let value = self();
 17 |         value.to_html(class);
 18 |     }
 19 | 
 20 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
 21 |         // TODO FROM_SERVER vs template
 22 |         let el = el.clone();
 23 |         create_render_effect(move |prev| {
 24 |             let value = self();
 25 |             if let Some(mut state) = prev {
 26 |                 value.rebuild(&mut state);
 27 |                 state
 28 |             } else {
 29 |                 value.hydrate::<FROM_SERVER>(&el)
 30 |             }
 31 |         })
 32 |     }
 33 | 
 34 |     fn build(self, el: &R::Element) -> Self::State {
 35 |         let el = el.to_owned();
 36 |         create_render_effect(move |prev| {
 37 |             let value = self();
 38 |             if let Some(mut state) = prev {
 39 |                 value.rebuild(&mut state);
 40 |                 state
 41 |             } else {
 42 |                 value.build(&el)
 43 |             }
 44 |         })
 45 |     }
 46 | 
 47 |     fn rebuild(self, state: &mut Self::State) {}
 48 | }
 49 | 
 50 | impl<F, R> IntoClass<R> for (&'static str, F)
 51 | where
 52 |     F: Fn() -> bool + 'static,
 53 |     R: DomRenderer,
 54 |     R::ClassList: 'static,
 55 |     R::Element: Clone,
 56 | {
 57 |     type State = Effect<bool>;
 58 | 
 59 |     fn to_html(self, class: &mut String) {
 60 |         let (name, f) = self;
 61 |         let include = f();
 62 |         if include {
 63 |             <&str as IntoClass<R>>::to_html(name, class);
 64 |         }
 65 |     }
 66 | 
 67 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
 68 |         // TODO FROM_SERVER vs template
 69 |         let (name, f) = self;
 70 |         let class_list = R::class_list(el);
 71 |         create_render_effect(move |prev| {
 72 |             let include = f();
 73 |             if Some(include) != prev {
 74 |                 if include {
 75 |                     R::add_class(&class_list, name);
 76 |                 } else {
 77 |                     R::remove_class(&class_list, name);
 78 |                 }
 79 |             }
 80 |             include
 81 |         })
 82 |     }
 83 | 
 84 |     fn build(self, el: &R::Element) -> Self::State {
 85 |         let (name, f) = self;
 86 |         let class_list = R::class_list(el);
 87 |         create_render_effect(move |prev| {
 88 |             let include = f();
 89 |             if Some(include) != prev {
 90 |                 if include {
 91 |                     R::add_class(&class_list, name);
 92 |                 } else {
 93 |                     R::remove_class(&class_list, name);
 94 |                 }
 95 |             }
 96 |             include
 97 |         })
 98 |     }
 99 | 
100 |     fn rebuild(self, state: &mut Self::State) {}
101 | }
102 | 


--------------------------------------------------------------------------------
/tachydom/src/leptos/style.rs:
--------------------------------------------------------------------------------
 1 | use crate::{html::style::IntoStyle, renderer::DomRenderer};
 2 | use leptos_reactive::{create_render_effect, Effect};
 3 | use std::borrow::Cow;
 4 | 
 5 | impl<F, S, R> IntoStyle<R> for (&'static str, F)
 6 | where
 7 |     F: Fn() -> S + 'static,
 8 |     S: Into<Cow<'static, str>>,
 9 |     R: DomRenderer,
10 |     R::CssStyleDeclaration: Clone + 'static,
11 | {
12 |     type State = Effect<(R::CssStyleDeclaration, Cow<'static, str>)>;
13 | 
14 |     fn to_html(self, style: &mut String) {
15 |         let (name, f) = self;
16 |         let value = f();
17 |         style.push_str(name);
18 |         style.push(':');
19 |         style.push_str(&value.into());
20 |         style.push(';');
21 |     }
22 | 
23 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
24 |         let (name, f) = self;
25 |         // TODO FROM_SERVER vs template
26 |         let style = R::style(el);
27 |         create_render_effect(move |prev| {
28 |             let value = f().into();
29 |             if let Some(mut state) = prev {
30 |                 let (style, prev): &mut (
31 |                     R::CssStyleDeclaration,
32 |                     Cow<'static, str>,
33 |                 ) = &mut state;
34 |                 if &value != prev {
35 |                     R::set_css_property(style, name, &value);
36 |                 }
37 |                 *prev = value;
38 |                 state
39 |             } else {
40 |                 (style.clone(), value)
41 |             }
42 |         })
43 |     }
44 | 
45 |     fn build(self, el: &R::Element) -> Self::State {
46 |         todo!()
47 |     }
48 | 
49 |     fn rebuild(self, state: &mut Self::State) {}
50 | }
51 | 
52 | impl<F, C, R> IntoStyle<R> for F
53 | where
54 |     F: Fn() -> C + 'static,
55 |     C: IntoStyle<R> + 'static,
56 |     C::State: 'static,
57 |     R: DomRenderer,
58 |     R::Element: Clone + 'static,
59 |     R::CssStyleDeclaration: Clone + 'static,
60 | {
61 |     type State = Effect<C::State>;
62 | 
63 |     fn to_html(self, class: &mut String) {
64 |         let value = self();
65 |         value.to_html(class);
66 |     }
67 | 
68 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
69 |         // TODO FROM_SERVER vs template
70 |         let el = el.clone();
71 |         create_render_effect(move |prev| {
72 |             let value = self();
73 |             if let Some(mut state) = prev {
74 |                 value.rebuild(&mut state);
75 |                 state
76 |             } else {
77 |                 value.hydrate::<FROM_SERVER>(&el)
78 |             }
79 |         })
80 |     }
81 | 
82 |     fn build(self, el: &R::Element) -> Self::State {
83 |         todo!()
84 |     }
85 | 
86 |     fn rebuild(self, state: &mut Self::State) {}
87 | }
88 | 


--------------------------------------------------------------------------------
/tachydom/src/lib.rs:
--------------------------------------------------------------------------------
  1 | #![allow(incomplete_features)] // yolo
  2 | #![cfg_attr(feature = "nightly", feature(adt_const_params))]
  3 | 
  4 | pub mod prelude {
  5 |     pub use crate::{
  6 |         async_views::FutureViewExt,
  7 |         html::{
  8 |             attribute::{
  9 |                 aria::AriaAttributes,
 10 |                 custom::CustomAttribute,
 11 |                 global::{
 12 |                     ClassAttribute, GlobalAttributes, OnAttribute,
 13 |                     PropAttribute, StyleAttribute,
 14 |                 },
 15 |             },
 16 |             element::{ElementChild, InnerHtmlAttribute},
 17 |             node_ref::NodeRefAttribute,
 18 |         },
 19 |         renderer::{dom::Dom, Renderer, SpawningRenderer},
 20 |         view::{
 21 |             error_boundary::TryCatchBoundary, Mountable, Render, RenderHtml,
 22 |         },
 23 |     };
 24 | }
 25 | 
 26 | use wasm_bindgen::JsValue;
 27 | use web_sys::Node;
 28 | 
 29 | pub mod async_views;
 30 | pub mod dom;
 31 | pub mod error;
 32 | pub mod html;
 33 | pub mod hydration;
 34 | pub mod mathml;
 35 | pub mod renderer;
 36 | pub mod spawner;
 37 | pub mod ssr;
 38 | pub mod svg;
 39 | pub mod view;
 40 | 
 41 | #[cfg(feature = "islands")]
 42 | pub use wasm_bindgen;
 43 | #[cfg(feature = "islands")]
 44 | pub use web_sys;
 45 | 
 46 | #[cfg(all(feature = "leptos", not(feature = "reaccy")))]
 47 | mod leptos;
 48 | 
 49 | #[cfg(feature = "reaccy")]
 50 | mod tachy_reaccy;
 51 | #[cfg(feature = "reaccy")]
 52 | pub use tachy_reaccy::node_ref;
 53 | 
 54 | pub fn log(text: &str) {
 55 |     web_sys::console::log_1(&JsValue::from_str(text));
 56 | }
 57 | 
 58 | pub(crate) trait UnwrapOrDebug {
 59 |     type Output;
 60 | 
 61 |     fn or_debug(self, el: &Node, label: &'static str);
 62 | 
 63 |     fn ok_or_debug(
 64 |         self,
 65 |         el: &Node,
 66 |         label: &'static str,
 67 |     ) -> Option<Self::Output>;
 68 | }
 69 | 
 70 | impl<T> UnwrapOrDebug for Result<T, JsValue> {
 71 |     type Output = T;
 72 | 
 73 |     #[track_caller]
 74 |     fn or_debug(self, el: &Node, name: &'static str) {
 75 |         #[cfg(debug_assertions)]
 76 |         {
 77 |             if let Err(err) = self {
 78 |                 let location = std::panic::Location::caller();
 79 |                 web_sys::console::warn_3(
 80 |                     &JsValue::from_str(&format!(
 81 |                         "[WARNING] Non-fatal error at {location}, while \
 82 |                          calling {name} on "
 83 |                     )),
 84 |                     el,
 85 |                     &err,
 86 |                 );
 87 |             }
 88 |         }
 89 |         #[cfg(not(debug_assertions))]
 90 |         {
 91 |             _ = self;
 92 |         }
 93 |     }
 94 | 
 95 |     #[track_caller]
 96 |     fn ok_or_debug(
 97 |         self,
 98 |         el: &Node,
 99 |         name: &'static str,
100 |     ) -> Option<Self::Output> {
101 |         #[cfg(debug_assertions)]
102 |         {
103 |             if let Err(err) = &self {
104 |                 let location = std::panic::Location::caller();
105 |                 web_sys::console::warn_3(
106 |                     &JsValue::from_str(&format!(
107 |                         "[WARNING] Non-fatal error at {location}, while \
108 |                          calling {name} on "
109 |                     )),
110 |                     el,
111 |                     err,
112 |                 );
113 |             }
114 |             self.ok()
115 |         }
116 |         #[cfg(not(debug_assertions))]
117 |         {
118 |             self.ok()
119 |         }
120 |     }
121 | }
122 | 
123 | #[macro_export]
124 | macro_rules! or_debug {
125 |     ($action:expr, $el:expr, $label:literal) => {
126 |         if cfg!(debug_assertions) {
127 |             $crate::UnwrapOrDebug::or_debug($action, $el, $label);
128 |         } else {
129 |             _ = $action;
130 |         }
131 |     };
132 | }
133 | 
134 | #[macro_export]
135 | macro_rules! ok_or_debug {
136 |     ($action:expr, $el:expr, $label:literal) => {
137 |         if cfg!(debug_assertions) {
138 |             $crate::UnwrapOrDebug::ok_or_debug($action, $el, $label)
139 |         } else {
140 |             $action.ok()
141 |         }
142 |     };
143 | }
144 | 


--------------------------------------------------------------------------------
/tachydom/src/spawner/mod.rs:
--------------------------------------------------------------------------------
 1 | use std::future::Future;
 2 | 
 3 | /// Allows spawning a [`Future`] to be run in a separate task.
 4 | pub trait Spawner {
 5 |     fn spawn<Fut>(fut: Fut)
 6 |     where
 7 |         Fut: Future + Send + Sync + 'static;
 8 | 
 9 |     fn spawn_local<Fut>(fut: Fut)
10 |     where
11 |         Fut: Future + 'static;
12 | }
13 | 
14 | /// A spawner that will block in place when spawning an async task.
15 | ///
16 | /// This is mostly useful for testing, and especially for synchronous-only code.
17 | pub struct BlockSpawn;
18 | 
19 | impl Spawner for BlockSpawn {
20 |     fn spawn<Fut>(fut: Fut)
21 |     where
22 |         Fut: Future + Send + Sync + 'static,
23 |     {
24 |         futures::executor::block_on(async move {
25 |             fut.await;
26 |         });
27 |     }
28 | 
29 |     fn spawn_local<Fut>(fut: Fut)
30 |     where
31 |         Fut: Future + 'static,
32 |     {
33 |         futures::executor::block_on(async move {
34 |             fut.await;
35 |         });
36 |     }
37 | }
38 | 
39 | #[cfg(feature = "web")]
40 | pub mod wasm {
41 |     use super::Spawner;
42 |     use wasm_bindgen_futures::spawn_local;
43 | 
44 |     #[derive(Debug, Copy, Clone)]
45 |     pub struct Wasm;
46 | 
47 |     impl Spawner for Wasm {
48 |         fn spawn<Fut>(fut: Fut)
49 |         where
50 |             Fut: futures::Future + Send + Sync + 'static,
51 |         {
52 |             Self::spawn_local(fut);
53 |         }
54 | 
55 |         fn spawn_local<Fut>(fut: Fut)
56 |         where
57 |             Fut: futures::Future + 'static,
58 |         {
59 |             spawn_local(async move {
60 |                 fut.await;
61 |             });
62 |         }
63 |     }
64 | }
65 | 
66 | #[cfg(feature = "tokio")]
67 | pub mod tokio {
68 |     use super::Spawner;
69 |     use tokio::task::{spawn, spawn_local};
70 | 
71 |     #[derive(Debug, Copy, Clone)]
72 |     pub struct Tokio;
73 | 
74 |     impl Spawner for Tokio {
75 |         fn spawn<Fut>(fut: Fut)
76 |         where
77 |             Fut: futures::Future + Send + Sync + 'static,
78 |         {
79 |             spawn(async move {
80 |                 fut.await;
81 |             });
82 |         }
83 | 
84 |         fn spawn_local<Fut>(fut: Fut)
85 |         where
86 |             Fut: futures::Future + 'static,
87 |         {
88 |             spawn_local(async move {
89 |                 fut.await;
90 |             });
91 |         }
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/tachydom/src/tachy_reaccy/node_ref.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     html::{element::ElementType, node_ref::NodeRefContainer},
  3 |     renderer::{dom::Dom, Renderer},
  4 | };
  5 | use send_wrapper::SendWrapper;
  6 | use tachy_reaccy::{
  7 |     signal::RwSignal,
  8 |     signal_traits::{DefinedAt, SignalSet, SignalWithUntracked, Track},
  9 | };
 10 | use wasm_bindgen::JsCast;
 11 | 
 12 | #[derive(Debug)]
 13 | pub struct NodeRef<E>(RwSignal<Option<SendWrapper<E::Output>>>)
 14 | where
 15 |     E: ElementType,
 16 |     E::Output: 'static;
 17 | 
 18 | impl<E> NodeRef<E>
 19 | where
 20 |     E: ElementType,
 21 |     E::Output: 'static,
 22 | {
 23 |     #[track_caller]
 24 |     pub fn new() -> Self {
 25 |         Self(RwSignal::new(None))
 26 |     }
 27 | }
 28 | 
 29 | impl<E> Default for NodeRef<E>
 30 | where
 31 |     E: ElementType,
 32 |     E::Output: 'static,
 33 | {
 34 |     fn default() -> Self {
 35 |         Self::new()
 36 |     }
 37 | }
 38 | 
 39 | impl<E> Clone for NodeRef<E>
 40 | where
 41 |     E: ElementType,
 42 |     E::Output: 'static,
 43 | {
 44 |     fn clone(&self) -> Self {
 45 |         *self
 46 |     }
 47 | }
 48 | 
 49 | impl<E> Copy for NodeRef<E>
 50 | where
 51 |     E: ElementType,
 52 |     E::Output: 'static,
 53 | {
 54 | }
 55 | 
 56 | impl<E> NodeRefContainer<E, Dom> for NodeRef<E>
 57 | where
 58 |     E: ElementType,
 59 |     E::Output: JsCast + 'static,
 60 | {
 61 |     fn load(self, el: &<Dom as Renderer>::Element) {
 62 |         self.0
 63 |             .set(Some(SendWrapper::new(el.clone().unchecked_into())));
 64 |     }
 65 | }
 66 | 
 67 | impl<E> DefinedAt for NodeRef<E>
 68 | where
 69 |     E: ElementType,
 70 |     E::Output: JsCast + 'static,
 71 | {
 72 |     fn defined_at(&self) -> Option<&'static std::panic::Location<'static>> {
 73 |         self.0.defined_at()
 74 |     }
 75 | }
 76 | 
 77 | impl<E> SignalWithUntracked for NodeRef<E>
 78 | where
 79 |     E: ElementType,
 80 |     E::Output: JsCast + Clone + 'static,
 81 | {
 82 |     type Value = Option<E::Output>;
 83 | 
 84 |     fn try_with_untracked<U>(
 85 |         &self,
 86 |         fun: impl FnOnce(&Self::Value) -> U,
 87 |     ) -> Option<U> {
 88 |         self.0
 89 |             .try_with_untracked(|inner| fun(&inner.as_deref().cloned()))
 90 |     }
 91 | }
 92 | 
 93 | impl<E> Track for NodeRef<E>
 94 | where
 95 |     E: ElementType,
 96 |     E::Output: JsCast + 'static,
 97 | {
 98 |     fn track(&self) {
 99 |         self.0.track();
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/tachydom/src/tachy_reaccy/style.rs:
--------------------------------------------------------------------------------
  1 | use super::RenderEffectState;
  2 | use crate::{html::style::IntoStyle, renderer::DomRenderer};
  3 | use std::borrow::Cow;
  4 | use tachy_reaccy::render_effect::RenderEffect;
  5 | 
  6 | impl<F, S, R> IntoStyle<R> for (&'static str, F)
  7 | where
  8 |     F: FnMut() -> S + 'static,
  9 |     S: Into<Cow<'static, str>>,
 10 |     R: DomRenderer,
 11 |     R::CssStyleDeclaration: Clone + 'static,
 12 | {
 13 |     type State = RenderEffectState<(R::CssStyleDeclaration, Cow<'static, str>)>;
 14 | 
 15 |     fn to_html(self, style: &mut String) {
 16 |         let (name, mut f) = self;
 17 |         let value = f();
 18 |         style.push_str(name);
 19 |         style.push(':');
 20 |         style.push_str(&value.into());
 21 |         style.push(';');
 22 |     }
 23 | 
 24 |     fn hydrate<const FROM_SERVER: bool>(self, el: &R::Element) -> Self::State {
 25 |         let (name, mut f) = self;
 26 |         // TODO FROM_SERVER vs template
 27 |         let style = R::style(el);
 28 |         RenderEffect::new(move |prev| {
 29 |             let value = f().into();
 30 |             if let Some(mut state) = prev {
 31 |                 let (style, prev): &mut (
 32 |                     R::CssStyleDeclaration,
 33 |                     Cow<'static, str>,
 34 |                 ) = &mut state;
 35 |                 if &value != prev {
 36 |                     R::set_css_property(style, name, &value);
 37 |                 }
 38 |                 *prev = value;
 39 |                 state
 40 |             } else {
 41 |                 // only set the style in template mode
 42 |                 // in server mode, it's already been set
 43 |                 if !FROM_SERVER {
 44 |                     R::set_css_property(&style, name, &value);
 45 |                 }
 46 |                 (style.clone(), value)
 47 |             }
 48 |         })
 49 |         .into()
 50 |     }
 51 | 
 52 |     fn build(self, el: &R::Element) -> Self::State {
 53 |         let (name, mut f) = self;
 54 |         let style = R::style(el);
 55 |         RenderEffect::new(move |prev| {
 56 |             let value = f().into();
 57 |             if let Some(mut state) = prev {
 58 |                 let (style, prev): &mut (
 59 |                     R::CssStyleDeclaration,
 60 |                     Cow<'static, str>,
 61 |                 ) = &mut state;
 62 |                 if &value != prev {
 63 |                     R::set_css_property(style, name, &value);
 64 |                 }
 65 |                 *prev = value;
 66 |                 state
 67 |             } else {
 68 |                 // always set the style initially without checking
 69 |                 R::set_css_property(&style, name, &value);
 70 |                 (style.clone(), value)
 71 |             }
 72 |         })
 73 |         .into()
 74 |     }
 75 | 
 76 |     fn rebuild(self, state: &mut Self::State) {
 77 |         // TODO
 78 |         /* let (name, mut f) = self;
 79 |         let prev_effect = std::mem::take(&mut state.0);
 80 |         let prev_value = prev_effect.as_ref().and_then(|e| e.take_value());
 81 |         drop(prev_effect);
 82 |         *state = RenderEffect::new_with_value(
 83 |             move |prev| {
 84 |                 let value = f().into();
 85 |                 if let Some(mut state) = prev {
 86 |                     let (style, prev) = &mut state;
 87 |                     if &value != prev {
 88 |                         R::set_css_property(&style, name, &value);
 89 |                     }
 90 |                     *prev = value;
 91 |                     state
 92 |                 } else {
 93 |                     todo!()
 94 |                 }
 95 |             },
 96 |             prev_value,
 97 |         )
 98 |         .into(); */
 99 |     }
100 | }
101 | 
102 | impl<F, C, R> IntoStyle<R> for F
103 | where
104 |     F: FnMut() -> C + 'static,
105 |     C: IntoStyle<R> + 'static,
106 |     C::State: 'static,
107 |     R: DomRenderer,
108 |     R::Element: Clone + 'static,
109 |     R::CssStyleDeclaration: Clone + 'static,
110 | {
111 |     type State = RenderEffect<C::State>;
112 | 
113 |     fn to_html(mut self, class: &mut String) {
114 |         let value = self();
115 |         value.to_html(class);
116 |     }
117 | 
118 |     fn hydrate<const FROM_SERVER: bool>(
119 |         mut self,
120 |         el: &R::Element,
121 |     ) -> Self::State {
122 |         // TODO FROM_SERVER vs template
123 |         let el = el.clone();
124 |         RenderEffect::new(move |prev| {
125 |             let value = self();
126 |             if let Some(mut state) = prev {
127 |                 value.rebuild(&mut state);
128 |                 state
129 |             } else {
130 |                 value.hydrate::<FROM_SERVER>(&el)
131 |             }
132 |         })
133 |     }
134 | 
135 |     fn build(self, el: &R::Element) -> Self::State {
136 |         todo!()
137 |     }
138 | 
139 |     fn rebuild(self, state: &mut Self::State) {}
140 | }
141 | 


--------------------------------------------------------------------------------
/tachydom/src/view/dynamic.rs:
--------------------------------------------------------------------------------
  1 | use super::{Mountable, PositionState, Render, RenderHtml, ToTemplate};
  2 | use crate::{hydration::Cursor, renderer::Renderer};
  3 | use leptos_reactive::{create_render_effect, Effect, SignalDispose};
  4 | 
  5 | impl<F, V> ToTemplate for F
  6 | where
  7 |     F: Fn() -> V,
  8 |     V: ToTemplate,
  9 | {
 10 |     fn to_template(buf: &mut String, position: &mut super::Position) {
 11 |         V::to_template(buf, position)
 12 |     }
 13 | }
 14 | 
 15 | impl<F, V, R> Render<R> for F
 16 | where
 17 |     F: Fn() -> V + 'static,
 18 |     V: Render<R>,
 19 |     V::State: 'static,
 20 |     R: Renderer,
 21 | {
 22 |     type State = Effect<V::State>;
 23 | 
 24 |     fn build(self) -> Self::State {
 25 |         create_render_effect(move |prev| {
 26 |             let value = self();
 27 |             if let Some(mut state) = prev {
 28 |                 value.rebuild(&mut state);
 29 |                 state
 30 |             } else {
 31 |                 value.build()
 32 |             }
 33 |         })
 34 |     }
 35 | 
 36 |     #[track_caller]
 37 |     fn rebuild(self, state: &mut Self::State) {
 38 |         crate::log(&format!(
 39 |             "[REBUILDING EFFECT] Is this a mistake? {}",
 40 |             std::panic::Location::caller(),
 41 |         ));
 42 |         let old_effect = std::mem::replace(state, self.build());
 43 |         old_effect.dispose();
 44 |     }
 45 | }
 46 | 
 47 | impl<F, V, R> RenderHtml<R> for F
 48 | where
 49 |     F: Fn() -> V + 'static,
 50 |     V: RenderHtml<R>,
 51 |     V::State: 'static,
 52 |     R: Renderer + 'static,
 53 |     R::Node: Clone,
 54 |     R::Element: Clone,
 55 | {
 56 |     fn to_html(self, buf: &mut String, position: &PositionState) {
 57 |         let value = self();
 58 |         value.to_html(buf, position)
 59 |     }
 60 | 
 61 |     fn hydrate<const FROM_SERVER: bool>(
 62 |         self,
 63 |         cursor: &Cursor<R>,
 64 |         position: &PositionState,
 65 |     ) -> Self::State {
 66 |         let cursor = cursor.clone();
 67 |         let position = position.clone();
 68 |         create_render_effect(move |prev| {
 69 |             let value = self();
 70 |             if let Some(mut state) = prev {
 71 |                 value.rebuild(&mut state);
 72 |                 state
 73 |             } else {
 74 |                 value.hydrate::<FROM_SERVER>(&cursor, &position)
 75 |             }
 76 |         })
 77 |     }
 78 | }
 79 | 
 80 | impl<M, R> Mountable<R> for Effect<M>
 81 | where
 82 |     M: Mountable<R> + 'static,
 83 |     R: Renderer,
 84 | {
 85 |     fn unmount(&mut self) {
 86 |         self.with_value_mut(|value| {
 87 |             if let Some(value) = value {
 88 |                 value.unmount()
 89 |             }
 90 |         });
 91 |     }
 92 | 
 93 |     fn mount(
 94 |         &mut self,
 95 |         parent: &<R as Renderer>::Element,
 96 |         marker: Option<&<R as Renderer>::Node>,
 97 |     ) {
 98 |         self.with_value_mut(|value| {
 99 |             if let Some(state) = value {
100 |                 state.mount(parent, marker);
101 |             }
102 |         });
103 |     }
104 | }
105 | 
106 | #[cfg(test)]
107 | mod tests {
108 |     use crate::{
109 |         html::element::{button, main, HtmlElement},
110 |         renderer::mock_dom::MockDom,
111 |         view::Render,
112 |     };
113 |     use leptos_reactive::{create_runtime, RwSignal, SignalGet, SignalSet};
114 | 
115 |     #[test]
116 |     fn create_dynamic_element() {
117 |         let rt = create_runtime();
118 |         let count = RwSignal::new(0);
119 |         let app: HtmlElement<_, _, _, MockDom> =
120 |             button((), move || count.get().to_string());
121 |         let el = app.build();
122 |         assert_eq!(el.el.to_debug_html(), "<button>0</button>");
123 |         rt.dispose();
124 |     }
125 | 
126 |     #[test]
127 |     fn update_dynamic_element() {
128 |         let rt = create_runtime();
129 |         let count = RwSignal::new(0);
130 |         let app: HtmlElement<_, _, _, MockDom> =
131 |             button((), move || count.get().to_string());
132 |         let el = app.build();
133 |         assert_eq!(el.el.to_debug_html(), "<button>0</button>");
134 |         count.set(1);
135 |         assert_eq!(el.el.to_debug_html(), "<button>1</button>");
136 |         rt.dispose();
137 |     }
138 | 
139 |     #[test]
140 |     fn update_dynamic_element_among_siblings() {
141 |         let rt = create_runtime();
142 |         let count = RwSignal::new(0);
143 |         let app: HtmlElement<_, _, _, MockDom> = main(
144 |             (),
145 |             button(
146 |                 (),
147 |                 ("Hello, my ", move || count.get().to_string(), " friends."),
148 |             ),
149 |         );
150 |         let el = app.build();
151 |         assert_eq!(
152 |             el.el.to_debug_html(),
153 |             "<main><button>Hello, my 0 friends.</button></main>"
154 |         );
155 |         count.set(42);
156 |         assert_eq!(
157 |             el.el.to_debug_html(),
158 |             "<main><button>Hello, my 42 friends.</button></main>"
159 |         );
160 |         rt.dispose();
161 |     }
162 | }
163 | 


--------------------------------------------------------------------------------
/tachydom/src/view/primitives.rs:
--------------------------------------------------------------------------------
  1 | use super::{
  2 |     InfallibleRender, Mountable, Position, PositionState, Render, RenderHtml,
  3 | };
  4 | use crate::{
  5 |     hydration::Cursor,
  6 |     renderer::{CastFrom, Renderer},
  7 |     view::ToTemplate,
  8 | };
  9 | use std::{
 10 |     fmt::Write,
 11 |     net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
 12 |     num::{
 13 |         NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8,
 14 |         NonZeroIsize, NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64,
 15 |         NonZeroU8, NonZeroUsize,
 16 |     },
 17 | };
 18 | 
 19 | macro_rules! render_primitive {
 20 |   ($($child_type:ty),* $(,)?) => {
 21 |     $(
 22 | 		paste::paste! {
 23 | 			pub struct [<$child_type:camel State>]<R>(R::Text, $child_type) where R: Renderer;
 24 | 
 25 | 			impl<'a, R: Renderer> Mountable<R> for [<$child_type:camel State>]<R> {
 26 | 					fn unmount(&mut self) {
 27 | 						self.0.unmount()
 28 | 					}
 29 | 
 30 | 					fn mount(
 31 | 						&mut self,
 32 | 						parent: &<R as Renderer>::Element,
 33 | 						marker: Option<&<R as Renderer>::Node>,
 34 | 					) {
 35 | 						R::insert_node(parent, self.0.as_ref(), marker);
 36 | 					}
 37 | 
 38 | 					fn insert_before_this(
 39 | 						&self,
 40 | 						parent: &<R as Renderer>::Element,
 41 | 						child: &mut dyn Mountable<R>,
 42 | 					) -> bool {
 43 | 						child.mount(parent, Some(self.0.as_ref()));
 44 | 						true
 45 | 					}
 46 | 			}
 47 | 
 48 | 			impl<'a, R: Renderer> Render<R> for $child_type {
 49 | 				type State = [<$child_type:camel State>]<R>;
 50 | 
 51 | 				fn build(self) -> Self::State {
 52 | 					let node = R::create_text_node(&self.to_string());
 53 | 					[<$child_type:camel State>](node, self)
 54 | 				}
 55 | 
 56 | 				fn rebuild(self, state: &mut Self::State) {
 57 | 					let [<$child_type:camel State>](node, this) = state;
 58 | 					if &self != this {
 59 | 						R::set_text(node, &self.to_string());
 60 | 						*this = self;
 61 | 					}
 62 | 				}
 63 | 			}
 64 | 
 65 | 			impl<'a> InfallibleRender for $child_type {}
 66 | 
 67 | 			impl<'a, R> RenderHtml<R> for $child_type
 68 | 			where
 69 | 				R: Renderer,
 70 | 				R::Node: Clone,
 71 | 				R::Element: Clone,
 72 | 			{
 73 | 				const MIN_LENGTH: usize = 0;
 74 | 
 75 | 				fn to_html_with_buf(self, buf: &mut String, position: &mut Position) {
 76 | 					// add a comment node to separate from previous sibling, if any
 77 | 					if matches!(position, Position::NextChildAfterText) {
 78 | 						buf.push_str("<!>")
 79 | 					}
 80 | 					write!(buf, "{}", self);
 81 | 					*position = Position::NextChildAfterText;
 82 | 				}
 83 | 
 84 | 				fn hydrate<const FROM_SERVER: bool>(
 85 | 					self,
 86 | 					cursor: &Cursor<R>,
 87 | 					position: &PositionState,
 88 | 				) -> Self::State {
 89 | 					if position.get() == Position::FirstChild {
 90 | 						cursor.child();
 91 | 					} else {
 92 | 						cursor.sibling();
 93 | 					}
 94 | 
 95 | 					// separating placeholder marker comes before text node
 96 | 					if matches!(position.get(), Position::NextChildAfterText) {
 97 | 						cursor.sibling();
 98 | 					}
 99 | 
100 | 					let node = cursor.current();
101 | 					let node = R::Text::cast_from(node)
102 | 						.expect("couldn't cast text node from node");
103 | 
104 | 					if !FROM_SERVER {
105 | 						R::set_text(&node, &self.to_string());
106 | 					}
107 | 					position.set(Position::NextChildAfterText);
108 | 
109 | 					[<$child_type:camel State>](node, self)
110 | 				}
111 | 			}
112 | 
113 | 			impl<'a> ToTemplate for $child_type {
114 | 				const TEMPLATE: &'static str = " <!>";
115 | 
116 | 				fn to_template(
117 | 					buf: &mut String,
118 | 					_class: &mut String,
119 | 					_style: &mut String,
120 | 					_inner_html: &mut String,
121 | 					position: &mut Position,
122 | 				) {
123 | 					if matches!(*position, Position::NextChildAfterText) {
124 | 						buf.push_str("<!>")
125 | 					}
126 | 					buf.push(' ');
127 | 					*position = Position::NextChildAfterText;
128 | 				}
129 | 			}
130 | 		}
131 |     )*
132 |   };
133 | }
134 | 
135 | render_primitive![
136 |     usize,
137 |     u8,
138 |     u16,
139 |     u32,
140 |     u64,
141 |     u128,
142 |     isize,
143 |     i8,
144 |     i16,
145 |     i32,
146 |     i64,
147 |     i128,
148 |     f32,
149 |     f64,
150 |     char,
151 |     bool,
152 |     IpAddr,
153 |     SocketAddr,
154 |     SocketAddrV4,
155 |     SocketAddrV6,
156 |     Ipv4Addr,
157 |     Ipv6Addr,
158 |     NonZeroI8,
159 |     NonZeroU8,
160 |     NonZeroI16,
161 |     NonZeroU16,
162 |     NonZeroI32,
163 |     NonZeroU32,
164 |     NonZeroI64,
165 |     NonZeroU64,
166 |     NonZeroI128,
167 |     NonZeroU128,
168 |     NonZeroIsize,
169 |     NonZeroUsize,
170 | ];
171 | 


--------------------------------------------------------------------------------
/tachydom/src/view/template.rs:
--------------------------------------------------------------------------------
  1 | use super::{
  2 |     Mountable, Position, PositionState, Render, RenderHtml, ToTemplate,
  3 | };
  4 | use crate::{dom::document, hydration::Cursor, renderer::dom::Dom};
  5 | use once_cell::unsync::Lazy;
  6 | use rustc_hash::FxHashMap;
  7 | use std::{any::TypeId, cell::RefCell};
  8 | use wasm_bindgen::JsCast;
  9 | use web_sys::HtmlTemplateElement;
 10 | 
 11 | thread_local! {
 12 |     static TEMPLATE_ELEMENT: Lazy<HtmlTemplateElement> =
 13 |         Lazy::new(|| document().create_element("template").unwrap().unchecked_into());
 14 | }
 15 | 
 16 | pub struct ViewTemplate<V: Render<Dom> + ToTemplate> {
 17 |     view: V,
 18 | }
 19 | 
 20 | thread_local! {
 21 |     static TEMPLATES: RefCell<FxHashMap<TypeId, HtmlTemplateElement>> = Default::default();
 22 | }
 23 | 
 24 | impl<V: Render<Dom> + ToTemplate + 'static> ViewTemplate<V> {
 25 |     pub fn new(view: V) -> Self {
 26 |         Self { view }
 27 |     }
 28 | 
 29 |     fn to_template() -> HtmlTemplateElement {
 30 |         TEMPLATES.with(|t| {
 31 |             t.borrow_mut()
 32 |                 .entry(TypeId::of::<V>())
 33 |                 .or_insert_with(|| {
 34 |                     let tpl = TEMPLATE_ELEMENT.with(|t| {
 35 |                         t.clone_node()
 36 |                             .unwrap()
 37 |                             .unchecked_into::<HtmlTemplateElement>()
 38 |                     });
 39 |                     /* let mut buf = String::new();
 40 |                     let mut class = String::new();
 41 |                     let mut style = String::new();
 42 |                     V::to_template(
 43 |                         &mut buf,
 44 |                         &mut class,
 45 |                         &mut style,
 46 |                         &mut Default::default(),
 47 |                     );
 48 |                     tpl.set_inner_html(&buf); */
 49 |                     //log(&format!("setting template to {:?}", V::TEMPLATE));
 50 |                     tpl.set_inner_html(V::TEMPLATE);
 51 |                     tpl
 52 |                 })
 53 |                 .clone()
 54 |         })
 55 |     }
 56 | }
 57 | 
 58 | impl<V> Render<Dom> for ViewTemplate<V>
 59 | where
 60 |     V: Render<Dom> + RenderHtml<Dom> + ToTemplate + 'static,
 61 |     V::State: Mountable<Dom>,
 62 | {
 63 |     type State = V::State;
 64 | 
 65 |     fn build(self) -> Self::State {
 66 |         let tpl = Self::to_template();
 67 |         let contents = tpl.content().clone_node_with_deep(true).unwrap();
 68 |         self.view.hydrate::<false>(
 69 |             &Cursor::new(contents.unchecked_into()),
 70 |             &Default::default(),
 71 |         )
 72 |     }
 73 | 
 74 |     fn rebuild(self, state: &mut Self::State) {
 75 |         self.view.rebuild(state)
 76 |     }
 77 | }
 78 | 
 79 | impl<V> RenderHtml<Dom> for ViewTemplate<V>
 80 | where
 81 |     V: RenderHtml<Dom> + ToTemplate + 'static,
 82 |     V::State: Mountable<Dom>,
 83 | {
 84 |     const MIN_LENGTH: usize = V::MIN_LENGTH;
 85 | 
 86 |     fn to_html_with_buf(self, buf: &mut String, position: &mut Position) {
 87 |         self.view.to_html_with_buf(buf, position)
 88 |     }
 89 | 
 90 |     fn hydrate<const FROM_SERVER: bool>(
 91 |         self,
 92 |         cursor: &Cursor<Dom>,
 93 |         position: &PositionState,
 94 |     ) -> Self::State {
 95 |         self.view.hydrate::<FROM_SERVER>(cursor, position)
 96 |     }
 97 | }
 98 | 
 99 | impl<V> ToTemplate for ViewTemplate<V>
100 | where
101 |     V: RenderHtml<Dom> + ToTemplate + 'static,
102 |     V::State: Mountable<Dom>,
103 | {
104 |     const TEMPLATE: &'static str = V::TEMPLATE;
105 | 
106 |     fn to_template(
107 |         buf: &mut String,
108 |         class: &mut String,
109 |         style: &mut String,
110 |         inner_html: &mut String,
111 |         position: &mut Position,
112 |     ) {
113 |         V::to_template(buf, class, style, inner_html, position);
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/tachys/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tachys"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | leptos_config = "0.6"
 8 | tachydom = { path = "../tachydom", features = ["reaccy"] }
 9 | tachy_maccy = { path = "../tachy_maccy" }
10 | tachy_reaccy = { path = "../tachy_reaccy" }
11 | typed-builder = "0.18"
12 | typed-builder-macro = "0.18"
13 | 
14 | [features]
15 | hydration = ["tachy_reaccy/hydration"]
16 | islands = ["tachydom/islands"]
17 | nightly = ["tachydom/nightly", "tachy_maccy/nightly"]
18 | tokio = ["tachy_reaccy/tokio"]
19 | web = ["tachydom/web", "tachy_reaccy/web"]
20 | 


--------------------------------------------------------------------------------
/tachys/src/children.rs:
--------------------------------------------------------------------------------
  1 | use std::sync::Arc;
  2 | use tachydom::{
  3 |     renderer::dom::Dom,
  4 |     view::{
  5 |         any_view::{AnyView, IntoAny},
  6 |         RenderHtml,
  7 |     },
  8 | };
  9 | 
 10 | /// The most common type for the `children` property on components,
 11 | /// which can only be called once.
 12 | pub type Children = Box<dyn FnOnce() -> AnyView<Dom>>;
 13 | 
 14 | /// A type for the `children` property on components that can be called
 15 | /// more than once.
 16 | pub type ChildrenFn = Arc<dyn Fn() -> AnyView<Dom>>;
 17 | 
 18 | /// A type for the `children` property on components that can be called
 19 | /// more than once, but may mutate the children.
 20 | pub type ChildrenFnMut = Box<dyn FnMut() -> AnyView<Dom>>;
 21 | 
 22 | // This is to still support components that accept `Box<dyn Fn() -> AnyView>` as a children.
 23 | type BoxedChildrenFn = Box<dyn Fn() -> AnyView<Dom>>;
 24 | 
 25 | #[doc(hidden)]
 26 | pub trait ToChildren<F> {
 27 |     fn to_children(f: F) -> Self;
 28 | }
 29 | 
 30 | impl<F, C> ToChildren<F> for Children
 31 | where
 32 |     F: FnOnce() -> C + 'static,
 33 |     C: RenderHtml<Dom> + 'static,
 34 | {
 35 |     #[inline]
 36 |     fn to_children(f: F) -> Self {
 37 |         Box::new(move || f().into_any())
 38 |     }
 39 | }
 40 | 
 41 | impl<F, C> ToChildren<F> for ChildrenFn
 42 | where
 43 |     F: Fn() -> C + 'static,
 44 |     C: RenderHtml<Dom> + 'static,
 45 | {
 46 |     #[inline]
 47 |     fn to_children(f: F) -> Self {
 48 |         Arc::new(move || f().into_any())
 49 |     }
 50 | }
 51 | 
 52 | impl<F, C> ToChildren<F> for ChildrenFnMut
 53 | where
 54 |     F: Fn() -> C + 'static,
 55 |     C: RenderHtml<Dom> + 'static,
 56 | {
 57 |     #[inline]
 58 |     fn to_children(f: F) -> Self {
 59 |         Box::new(move || f().into_any())
 60 |     }
 61 | }
 62 | 
 63 | impl<F, C> ToChildren<F> for BoxedChildrenFn
 64 | where
 65 |     F: Fn() -> C + 'static,
 66 |     C: RenderHtml<Dom> + 'static,
 67 | {
 68 |     #[inline]
 69 |     fn to_children(f: F) -> Self {
 70 |         Box::new(move || f().into_any())
 71 |     }
 72 | }
 73 | 
 74 | /// New-type wrapper for the a function that returns a view with `From` and `Default` traits implemented
 75 | /// to enable optional props in for example `<Show>` and `<Suspense>`.
 76 | #[derive(Clone)]
 77 | pub struct ViewFn(Arc<dyn Fn() -> AnyView<Dom>>);
 78 | 
 79 | impl Default for ViewFn {
 80 |     fn default() -> Self {
 81 |         Self(Arc::new(|| ().into_any()))
 82 |     }
 83 | }
 84 | 
 85 | impl<F, C> From<F> for ViewFn
 86 | where
 87 |     F: Fn() -> C + 'static,
 88 |     C: RenderHtml<Dom> + 'static,
 89 | {
 90 |     fn from(value: F) -> Self {
 91 |         Self(Arc::new(move || value().into_any()))
 92 |     }
 93 | }
 94 | 
 95 | impl ViewFn {
 96 |     /// Execute the wrapped function
 97 |     pub fn run(&self) -> AnyView<Dom> {
 98 |         (self.0)()
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/tachys/src/component.rs:
--------------------------------------------------------------------------------
 1 | //! Utility traits and functions that allow building components,
 2 | //! as either functions of their props or functions with no arguments,
 3 | //! without knowing the name of the props struct.
 4 | 
 5 | pub trait Component<P> {}
 6 | 
 7 | pub trait Props {
 8 |     type Builder;
 9 | 
10 |     fn builder() -> Self::Builder;
11 | }
12 | 
13 | #[doc(hidden)]
14 | pub trait PropsOrNoPropsBuilder {
15 |     type Builder;
16 | 
17 |     fn builder_or_not() -> Self::Builder;
18 | }
19 | 
20 | #[doc(hidden)]
21 | #[derive(Copy, Clone, Debug, Default)]
22 | pub struct EmptyPropsBuilder {}
23 | 
24 | impl EmptyPropsBuilder {
25 |     pub fn build(self) {}
26 | }
27 | 
28 | impl<P: Props> PropsOrNoPropsBuilder for P {
29 |     type Builder = <P as Props>::Builder;
30 | 
31 |     fn builder_or_not() -> Self::Builder {
32 |         Self::builder()
33 |     }
34 | }
35 | 
36 | impl PropsOrNoPropsBuilder for EmptyPropsBuilder {
37 |     type Builder = EmptyPropsBuilder;
38 | 
39 |     fn builder_or_not() -> Self::Builder {
40 |         EmptyPropsBuilder {}
41 |     }
42 | }
43 | 
44 | impl<F, R> Component<EmptyPropsBuilder> for F where F: FnOnce() -> R {}
45 | 
46 | impl<P, F, R> Component<P> for F
47 | where
48 |     F: FnOnce(P) -> R,
49 |     P: Props,
50 | {
51 | }
52 | 
53 | pub fn component_props_builder<P: PropsOrNoPropsBuilder>(
54 |     _f: &impl Component<P>,
55 | ) -> <P as PropsOrNoPropsBuilder>::Builder {
56 |     <P as PropsOrNoPropsBuilder>::builder_or_not()
57 | }
58 | 
59 | pub fn component_view<P, T>(f: impl ComponentConstructor<P, T>, props: P) -> T {
60 |     f.construct(props)
61 | }
62 | pub trait ComponentConstructor<P, T> {
63 |     fn construct(self, props: P) -> T;
64 | }
65 | 
66 | impl<Func, T> ComponentConstructor<(), T> for Func
67 | where
68 |     Func: FnOnce() -> T,
69 | {
70 |     fn construct(self, (): ()) -> T {
71 |         (self)()
72 |     }
73 | }
74 | 
75 | impl<Func, T, P> ComponentConstructor<P, T> for Func
76 | where
77 |     Func: FnOnce(P) -> T,
78 |     P: PropsOrNoPropsBuilder,
79 | {
80 |     fn construct(self, props: P) -> T {
81 |         (self)(props)
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/tachys/src/for_loop.rs:
--------------------------------------------------------------------------------
 1 | use std::{hash::Hash, marker::PhantomData};
 2 | use tachy_maccy::component;
 3 | use tachydom::{
 4 |     renderer::Renderer,
 5 |     view::{keyed::keyed, RenderHtml},
 6 | };
 7 | 
 8 | #[component]
 9 | pub fn For<Rndr, IF, I, T, EF, N, KF, K>(
10 |     /// Items over which the component should iterate.
11 |     each: IF,
12 |     /// A key function that will be applied to each item.
13 |     key: KF,
14 |     /// A function that takes the item, and returns the view that will be displayed for each item.
15 |     children: EF,
16 |     #[prop(optional)] _rndr: PhantomData<Rndr>,
17 | ) -> impl RenderHtml<Rndr>
18 | where
19 |     IF: Fn() -> I + 'static,
20 |     I: IntoIterator<Item = T>,
21 |     EF: Fn(T) -> N + Clone + 'static,
22 |     N: RenderHtml<Rndr> + 'static,
23 |     KF: Fn(&T) -> K + Clone + 'static,
24 |     K: Eq + Hash + 'static,
25 |     T: 'static,
26 |     Rndr: Renderer + 'static,
27 |     Rndr::Node: Clone,
28 |     Rndr::Element: Clone,
29 | {
30 |     move || keyed(each(), key.clone(), children.clone())
31 | }
32 | 
33 | #[cfg(test)]
34 | mod tests {
35 |     use crate::For;
36 |     use tachy_maccy::view;
37 |     use tachy_reaccy::{signal::RwSignal, signal_traits::SignalGet};
38 |     use tachydom::{
39 |         html::element::HtmlElement, prelude::ElementChild,
40 |         renderer::mock_dom::MockDom, view::Render,
41 |     };
42 | 
43 |     #[test]
44 |     fn creates_list() {
45 |         let values = RwSignal::new(vec![1, 2, 3, 4, 5]);
46 |         let list: HtmlElement<_, _, _, MockDom> = view! {
47 |             <ol>
48 |                 <For
49 |                     each=move || values.get()
50 |                     key=|i| *i
51 |                     let:i
52 |                 >
53 |                     <li>{i}</li>
54 |                 </For>
55 |             </ol>
56 |         };
57 |         let list = list.build();
58 |         assert_eq!(
59 |             list.el.to_debug_html(),
60 |             "<ol><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ol>"
61 |         );
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/tachys/src/hydration_scripts/hydration_script.js:
--------------------------------------------------------------------------------
1 | (function (pkg_path, output_name, wasm_output_name) {
2 | 	import(`/${pkg_path}/${output_name}.js`)
3 | 		.then(mod => {
4 | 			mod.default(`/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
5 | 				mod.hydrate();
6 | 			});
7 | 		})
8 | })


--------------------------------------------------------------------------------
/tachys/src/hydration_scripts/island_script.js:
--------------------------------------------------------------------------------
 1 | (function (pkg_path, output_name, wasm_output_name) {
 2 | 	function idle(c) {
 3 | 		if ("requestIdleCallback" in window) {
 4 | 			window.requestIdleCallback(c);
 5 | 		} else {
 6 | 			c();
 7 | 		}
 8 | 	}
 9 | 	idle(() => {
10 | 		import(`/${pkg_path}/${output_name}.js`)
11 | 			.then(mod => {
12 | 				mod.default(`/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
13 | 					mod.hydrate();
14 | 					for (let e of document.querySelectorAll("leptos-island")) {
15 | 						const l = e.dataset.component;
16 | 						const islandFn = mod["_island_" + l];
17 | 						if (islandFn) {
18 | 							islandFn(e);
19 | 						} else {
20 | 							console.warn(`Could not find WASM function for the island ${l}.`);
21 | 						}
22 | 					}
23 | 				});
24 | 			})
25 | 	});
26 | })
27 | 


--------------------------------------------------------------------------------
/tachys/src/hydration_scripts/mod.rs:
--------------------------------------------------------------------------------
 1 | #![allow(clippy::needless_lifetimes)]
 2 | 
 3 | use crate::prelude::*;
 4 | use leptos_config::LeptosOptions;
 5 | use tachydom::view::RenderHtml;
 6 | 
 7 | #[component]
 8 | pub fn AutoReload<'a>(
 9 |     #[prop(optional)] disable_watch: bool,
10 |     #[prop(optional)] nonce: Option<&'a str>,
11 |     options: LeptosOptions,
12 | ) -> impl RenderHtml<Dom> + 'a {
13 |     (!disable_watch && std::env::var("LEPTOS_WATCH").is_ok()).then(|| {
14 |         let reload_port = match options.reload_external_port {
15 |             Some(val) => val,
16 |             None => options.reload_port,
17 |         };
18 |         let protocol = match options.reload_ws_protocol {
19 |             leptos_config::ReloadWSProtocol::WS => "'ws://'",
20 |             leptos_config::ReloadWSProtocol::WSS => "'wss://'",
21 |         };
22 | 
23 |         let script = include_str!("reload_script.js");
24 |         view! {
25 |             <script crossorigin=nonce>
26 |                 {format!("{script}({reload_port:?}, {protocol})")}
27 |             </script>
28 |         }
29 |     })
30 | }
31 | 
32 | #[component]
33 | pub fn HydrationScripts(
34 |     options: LeptosOptions,
35 |     #[prop(optional)] islands: bool,
36 | ) -> impl RenderHtml<Dom> {
37 |     let pkg_path = &options.site_pkg_dir;
38 |     let output_name = &options.output_name;
39 |     let mut wasm_output_name = output_name.clone();
40 |     if std::option_env!("LEPTOS_OUTPUT_NAME").is_none() {
41 |         wasm_output_name.push_str("_bg");
42 |     }
43 |     let nonce = None::<String>; // use_nonce(); // TODO
44 |     let script = if islands {
45 |         include_str!("./island_script.js")
46 |     } else {
47 |         include_str!("./hydration_script.js")
48 |     };
49 | 
50 |     view! {
51 |         <link rel="modulepreload" href=format!("/{pkg_path}/{output_name}.js") nonce=nonce.clone()/>
52 |         <link rel="preload" href=format!("/{pkg_path}/{wasm_output_name}.wasm") r#as="fetch" r#type="application/wasm" crossorigin=nonce.clone().unwrap_or_default()/>
53 |         <script type="module" nonce=nonce>
54 |             {format!("{script}({pkg_path:?}, {output_name:?}, {wasm_output_name:?})")}
55 |         </script>
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/tachys/src/hydration_scripts/reload_script.js:
--------------------------------------------------------------------------------
 1 | (function (reload_port, protocol) {
 2 | let host = window.location.hostname;
 3 | let ws = new WebSocket(`${protocol}${host}:${reload_port}/live_reload`);
 4 | ws.onmessage = (ev) => {
 5 | 	let msg = JSON.parse(ev.data);
 6 | 	if (msg.all) window.location.reload();
 7 | 	if (msg.css) {
 8 | 		let found = false;
 9 | 		document.querySelectorAll("link").forEach((link) => {
10 | 			if (link.getAttribute('href').includes(msg.css)) {
11 | 				let newHref = '/' + msg.css + '?version=' + new Date().getMilliseconds();
12 | 				link.setAttribute('href', newHref);
13 | 				found = true;
14 | 			}
15 | 		});
16 | 		if (!found) console.warn(`CSS hot-reload: Could not find a <link href=/\"${msg.css}\"> element`);
17 | 	};
18 | 	if(msg.view) {
19 | 		patch(msg.view);
20 | 	}
21 | };
22 | ws.onclose = () => console.warn('Live-reload stopped. Manual reload necessary.');
23 | })
24 | 


--------------------------------------------------------------------------------
/tachys/src/lib.rs:
--------------------------------------------------------------------------------
 1 | pub mod prelude {
 2 |     pub use tachy_maccy::{component, view};
 3 |     pub use tachy_reaccy::prelude::*;
 4 |     pub use tachydom::prelude::*;
 5 | }
 6 | 
 7 | pub extern crate self as tachys;
 8 | 
 9 | pub mod children; // TODO fix children
10 | pub mod component;
11 | mod for_loop;
12 | mod hydration_scripts;
13 | mod show;
14 | pub use for_loop::*;
15 | pub use hydration_scripts::*;
16 | pub use show::*;
17 | pub use tachy_maccy::*;
18 | pub use tachy_reaccy;
19 | pub use tachydom;
20 | #[doc(hidden)]
21 | pub use typed_builder;
22 | #[doc(hidden)]
23 | pub use typed_builder_macro;
24 | 


--------------------------------------------------------------------------------
/tachys/src/show.rs:
--------------------------------------------------------------------------------
 1 | use crate::children::{ChildrenFn, ViewFn};
 2 | use tachy_maccy::component;
 3 | use tachy_reaccy::{memo::ArcMemo, signal_traits::SignalGet};
 4 | use tachydom::{
 5 |     renderer::dom::Dom,
 6 |     view::{either::Either, RenderHtml},
 7 | };
 8 | 
 9 | #[component]
10 | pub fn Show<W>(
11 |     /// The children will be shown whenever the condition in the `when` closure returns `true`.
12 |     children: ChildrenFn,
13 |     /// A closure that returns a bool that determines whether this thing runs
14 |     when: W,
15 |     /// A closure that returns what gets rendered if the when statement is false. By default this is the empty view.
16 |     #[prop(optional, into)]
17 |     fallback: ViewFn,
18 | ) -> impl RenderHtml<Dom>
19 | where
20 |     W: Fn() -> bool + Send + Sync + 'static,
21 | {
22 |     let memoized_when = ArcMemo::new(move |_| when());
23 | 
24 |     move || match memoized_when.get() {
25 |         true => Either::Left(children()),
26 |         false => Either::Right(fallback.run()),
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------