(
+ config: CrateConfig,
+ serve_cfg: &ConfigOptsServe,
+) -> Result<()> {
// ctrl-c shutdown checker
let _crate_config = config.clone();
let _ = ctrlc::set_handler(move || {
@@ -43,8 +51,6 @@ pub async fn startup(config: CrateConfig) -> Result<()> {
let hot_reload_tx = broadcast::channel(100).0;
- clear_paths();
-
Some(HotReloadState {
messages: hot_reload_tx.clone(),
file_map: file_map.clone(),
@@ -53,15 +59,18 @@ pub async fn startup(config: CrateConfig) -> Result<()> {
false => None,
};
- serve(config, hot_reload_state).await?;
+ serve::(config, serve_cfg, hot_reload_state).await?;
Ok(())
}
/// Start the server without hot reload
-pub async fn serve(config: CrateConfig, hot_reload_state: Option) -> Result<()> {
- let (child, first_build_result) = start_desktop(&config)?;
- let currently_running_child: RwLock = RwLock::new(child);
+async fn serve(
+ config: CrateConfig,
+ serve: &ConfigOptsServe,
+ hot_reload_state: Option,
+) -> Result<()> {
+ let platform = RwLock::new(P::start(&config, serve)?);
log::info!("🚀 Starting development server...");
@@ -70,14 +79,7 @@ pub async fn serve(config: CrateConfig, hot_reload_state: Option
let _watcher = setup_file_watcher(
{
let config = config.clone();
-
- move || {
- let mut current_child = currently_running_child.write().unwrap();
- current_child.kill()?;
- let (child, result) = start_desktop(&config)?;
- *current_child = child;
- Ok(result)
- }
+ move || platform.write().unwrap().rebuild(&config)
},
&config,
None,
@@ -85,19 +87,9 @@ pub async fn serve(config: CrateConfig, hot_reload_state: Option
)
.await?;
- // Print serve info
- print_console_info(
- &config,
- PrettierOptions {
- changed: vec![],
- warnings: first_build_result.warnings,
- elapsed_time: first_build_result.elapsed_time,
- },
- None,
- );
-
match hot_reload_state {
Some(hot_reload_state) => {
+ // The open interprocess sockets
start_desktop_hot_reload(hot_reload_state).await?;
}
None => {
@@ -109,7 +101,14 @@ pub async fn serve(config: CrateConfig, hot_reload_state: Option
}
async fn start_desktop_hot_reload(hot_reload_state: HotReloadState) -> Result<()> {
- match LocalSocketListener::bind("@dioxusin") {
+ let metadata = cargo_metadata::MetadataCommand::new()
+ .no_deps()
+ .exec()
+ .unwrap();
+ let target_dir = metadata.target_directory.as_std_path();
+ let path = target_dir.join("dioxusin");
+ clear_paths(&path);
+ match LocalSocketListener::bind(path) {
Ok(local_socket_stream) => {
let aborted = Arc::new(Mutex::new(false));
// States
@@ -121,30 +120,41 @@ async fn start_desktop_hot_reload(hot_reload_state: HotReloadState) -> Result<()
let file_map = hot_reload_state.file_map.clone();
let channels = channels.clone();
let aborted = aborted.clone();
- let _ = local_socket_stream.set_nonblocking(true);
move || {
loop {
- if let Ok(mut connection) = local_socket_stream.accept() {
- // send any templates than have changed before the socket connected
- let templates: Vec<_> = {
- file_map
- .lock()
- .unwrap()
- .map
- .values()
- .filter_map(|(_, template_slot)| *template_slot)
- .collect()
- };
- for template in templates {
- if !send_msg(
- HotReloadMsg::UpdateTemplate(template),
- &mut connection,
- ) {
- continue;
+ //accept() will block the thread when local_socket_stream is in blocking mode (default)
+ match local_socket_stream.accept() {
+ Ok(mut connection) => {
+ // send any templates than have changed before the socket connected
+ let templates: Vec<_> = {
+ file_map
+ .lock()
+ .unwrap()
+ .map
+ .values()
+ .filter_map(|(_, template_slot)| *template_slot)
+ .collect()
+ };
+ for template in templates {
+ if !send_msg(
+ HotReloadMsg::UpdateTemplate(template),
+ &mut connection,
+ ) {
+ continue;
+ }
+ }
+ channels.lock().unwrap().push(connection);
+ println!("Connected to hot reloading 🚀");
+ }
+ Err(err) => {
+ let error_string = err.to_string();
+ // Filter out any error messages about a operation that may block and an error message that triggers on some operating systems that says "Waiting for a process to open the other end of the pipe" without WouldBlock being set
+ let display_error = err.kind() != std::io::ErrorKind::WouldBlock
+ && !error_string.contains("Waiting for a process");
+ if display_error {
+ println!("Error connecting to hot reloading: {} (Hot reloading is a feature of the dioxus-cli. If you are not using the CLI, this error can be ignored)", err);
}
}
- channels.lock().unwrap().push(connection);
- println!("Connected to hot reloading 🚀");
}
if *aborted.lock().unwrap() {
break;
@@ -174,17 +184,14 @@ async fn start_desktop_hot_reload(hot_reload_state: HotReloadState) -> Result<()
Ok(())
}
-fn clear_paths() {
- if cfg!(target_os = "macos") {
+fn clear_paths(file_socket_path: &std::path::Path) {
+ if cfg!(unix) {
// On unix, if you force quit the application, it can leave the file socket open
// This will cause the local socket listener to fail to open
// We check if the file socket is already open from an old session and then delete it
- let paths = ["./dioxusin", "./@dioxusin"];
- for path in paths {
- let path = std::path::PathBuf::from(path);
- if path.exists() {
- let _ = std::fs::remove_file(path);
- }
+
+ if file_socket_path.exists() {
+ let _ = std::fs::remove_file(file_socket_path);
}
}
}
@@ -203,9 +210,9 @@ fn send_msg(msg: HotReloadMsg, channel: &mut impl std::io::Write) -> bool {
}
}
-pub fn start_desktop(config: &CrateConfig) -> Result<(Child, BuildResult)> {
+fn start_desktop(config: &CrateConfig, skip_assets: bool) -> Result<(RAIIChild, BuildResult)> {
// Run the desktop application
- let result = crate::builder::build_desktop(config, true)?;
+ let result = crate::builder::build_desktop(config, true, skip_assets)?;
match &config.executable {
crate::ExecutableType::Binary(name)
@@ -215,9 +222,58 @@ pub fn start_desktop(config: &CrateConfig) -> Result<(Child, BuildResult)> {
if cfg!(windows) {
file.set_extension("exe");
}
- let child = Command::new(file.to_str().unwrap()).spawn()?;
+ let active = "DIOXUS_ACTIVE";
+ let child = RAIIChild(
+ Command::new(file.to_str().unwrap())
+ .env(active, "true")
+ .spawn()?,
+ );
Ok((child, result))
}
}
}
+
+pub(crate) struct DesktopPlatform {
+ currently_running_child: RAIIChild,
+ skip_assets: bool,
+}
+
+impl Platform for DesktopPlatform {
+ fn start(config: &CrateConfig, serve: &ConfigOptsServe) -> Result {
+ let (child, first_build_result) = start_desktop(config, serve.skip_assets)?;
+
+ log::info!("🚀 Starting development server...");
+
+ // Print serve info
+ print_console_info(
+ config,
+ PrettierOptions {
+ changed: vec![],
+ warnings: first_build_result.warnings,
+ elapsed_time: first_build_result.elapsed_time,
+ },
+ None,
+ );
+
+ Ok(Self {
+ currently_running_child: child,
+ skip_assets: serve.skip_assets,
+ })
+ }
+
+ fn rebuild(&mut self, config: &CrateConfig) -> Result {
+ self.currently_running_child.0.kill()?;
+ let (child, result) = start_desktop(config, self.skip_assets)?;
+ self.currently_running_child = child;
+ Ok(result)
+ }
+}
+
+struct RAIIChild(Child);
+
+impl Drop for RAIIChild {
+ fn drop(&mut self) {
+ let _ = self.0.kill();
+ }
+}
diff --git a/packages/cli/src/server/fullstack/mod.rs b/packages/cli/src/server/fullstack/mod.rs
new file mode 100644
index 000000000..fa9c77459
--- /dev/null
+++ b/packages/cli/src/server/fullstack/mod.rs
@@ -0,0 +1,161 @@
+use crate::{
+ cfg::{ConfigOptsBuild, ConfigOptsServe},
+ CrateConfig, Result, WebAssetConfigDropGuard,
+};
+
+use super::{desktop, Platform};
+
+pub async fn startup(config: CrateConfig, serve: &ConfigOptsServe) -> Result<()> {
+ desktop::startup_with_platform::(config, serve).await
+}
+
+fn start_web_build_thread(
+ config: &CrateConfig,
+ serve: &ConfigOptsServe,
+) -> std::thread::JoinHandle> {
+ let serve = serve.clone();
+ let target_directory = config.crate_dir.join(".dioxus").join("web");
+ std::fs::create_dir_all(&target_directory).unwrap();
+ std::thread::spawn(move || build_web(serve, &target_directory))
+}
+
+struct FullstackPlatform {
+ serve: ConfigOptsServe,
+ desktop: desktop::DesktopPlatform,
+ _config: WebAssetConfigDropGuard,
+}
+
+impl Platform for FullstackPlatform {
+ fn start(config: &CrateConfig, serve: &ConfigOptsServe) -> Result
+ where
+ Self: Sized,
+ {
+ let thread_handle = start_web_build_thread(config, serve);
+
+ let mut desktop_config = config.clone();
+ let desktop_feature = serve.server_feature.clone();
+ let features = &mut desktop_config.features;
+ match features {
+ Some(features) => {
+ features.push(desktop_feature);
+ }
+ None => desktop_config.features = Some(vec![desktop_feature]),
+ };
+ let config = WebAssetConfigDropGuard::new();
+ let desktop = desktop::DesktopPlatform::start(&desktop_config, serve)?;
+ thread_handle
+ .join()
+ .map_err(|_| anyhow::anyhow!("Failed to join thread"))??;
+
+ Ok(Self {
+ desktop,
+ serve: serve.clone(),
+ _config: config,
+ })
+ }
+
+ fn rebuild(&mut self, crate_config: &CrateConfig) -> Result {
+ let thread_handle = start_web_build_thread(crate_config, &self.serve);
+ let result = {
+ let mut desktop_config = crate_config.clone();
+ let desktop_feature = self.serve.server_feature.clone();
+ let features = &mut desktop_config.features;
+ match features {
+ Some(features) => {
+ features.push(desktop_feature);
+ }
+ None => desktop_config.features = Some(vec![desktop_feature]),
+ };
+ let _gaurd = FullstackServerEnvGuard::new(self.serve.force_debug, self.serve.release);
+ self.desktop.rebuild(&desktop_config)
+ };
+ thread_handle
+ .join()
+ .map_err(|_| anyhow::anyhow!("Failed to join thread"))??;
+ result
+ }
+}
+
+fn build_web(serve: ConfigOptsServe, target_directory: &std::path::Path) -> Result<()> {
+ let mut web_config: ConfigOptsBuild = serve.into();
+ let web_feature = web_config.client_feature.clone();
+ let features = &mut web_config.features;
+ match features {
+ Some(features) => {
+ features.push(web_feature);
+ }
+ None => web_config.features = Some(vec![web_feature]),
+ };
+ web_config.platform = Some(crate::cfg::Platform::Web);
+
+ let _gaurd = FullstackWebEnvGuard::new(&web_config);
+ crate::cli::build::Build { build: web_config }.build(None, Some(target_directory))
+}
+
+// Debug mode web builds have a very large size by default. If debug mode is not enabled, we strip some of the debug info by default
+// This reduces a hello world from ~40MB to ~2MB
+pub(crate) struct FullstackWebEnvGuard {
+ old_rustflags: Option,
+}
+
+impl FullstackWebEnvGuard {
+ pub fn new(serve: &ConfigOptsBuild) -> Self {
+ Self {
+ old_rustflags: (!serve.force_debug).then(|| {
+ let old_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
+ let debug_assertions = if serve.release {
+ ""
+ } else {
+ " -C debug-assertions"
+ };
+
+ std::env::set_var(
+ "RUSTFLAGS",
+ format!(
+ "{old_rustflags} -C debuginfo=none -C strip=debuginfo{debug_assertions}"
+ ),
+ );
+ old_rustflags
+ }),
+ }
+ }
+}
+
+impl Drop for FullstackWebEnvGuard {
+ fn drop(&mut self) {
+ if let Some(old_rustflags) = self.old_rustflags.take() {
+ std::env::set_var("RUSTFLAGS", old_rustflags);
+ }
+ }
+}
+
+// Debug mode web builds have a very large size by default. If debug mode is not enabled, we strip some of the debug info by default
+// This reduces a hello world from ~40MB to ~2MB
+pub(crate) struct FullstackServerEnvGuard {
+ old_rustflags: Option,
+}
+
+impl FullstackServerEnvGuard {
+ pub fn new(debug: bool, release: bool) -> Self {
+ Self {
+ old_rustflags: (!debug).then(|| {
+ let old_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
+ let debug_assertions = if release { "" } else { " -C debug-assertions" };
+
+ std::env::set_var(
+ "RUSTFLAGS",
+ format!("{old_rustflags} -C opt-level=2 {debug_assertions}"),
+ );
+ old_rustflags
+ }),
+ }
+ }
+}
+
+impl Drop for FullstackServerEnvGuard {
+ fn drop(&mut self) {
+ if let Some(old_rustflags) = self.old_rustflags.take() {
+ std::env::set_var("RUSTFLAGS", old_rustflags);
+ }
+ }
+}
diff --git a/packages/cli/src/server/mod.rs b/packages/cli/src/server/mod.rs
index c6073d787..895d9e51e 100644
--- a/packages/cli/src/server/mod.rs
+++ b/packages/cli/src/server/mod.rs
@@ -1,4 +1,4 @@
-use crate::{BuildResult, CrateConfig, Result};
+use crate::{cfg::ConfigOptsServe, BuildResult, CrateConfig, Result};
use cargo_metadata::diagnostic::Diagnostic;
use dioxus_core::Template;
@@ -14,6 +14,7 @@ use tokio::sync::broadcast::{self};
mod output;
use output::*;
pub mod desktop;
+pub mod fullstack;
pub mod web;
/// Sets up a file watcher
@@ -32,7 +33,7 @@ async fn setup_file_watcher Result + Send + 'static>(
.watcher
.watch_path
.clone()
- .unwrap_or_else(|| vec![PathBuf::from("src")]);
+ .unwrap_or_else(|| vec![PathBuf::from("src"), PathBuf::from("examples")]);
let watcher_config = config.clone();
let mut watcher = notify::recommended_watcher(move |info: notify::Result| {
@@ -55,6 +56,16 @@ async fn setup_file_watcher Result + Send + 'static>(
break;
}
+ // Workaround for notify and vscode-like editor:
+ // when edit & save a file in vscode, there will be two notifications,
+ // the first one is a file with empty content.
+ // filter the empty file notification to avoid false rebuild during hot-reload
+ if let Ok(metadata) = fs::metadata(path) {
+ if metadata.len() == 0 {
+ continue;
+ }
+ }
+
match rsx_file_map.update_rsx(path, &config.crate_dir) {
Ok(UpdateResult::UpdatedRsx(msgs)) => {
messages.extend(msgs);
@@ -121,16 +132,23 @@ async fn setup_file_watcher Result + Send + 'static>(
.unwrap();
for sub_path in allow_watch_path {
- watcher
- .watch(
- &config.crate_dir.join(sub_path),
- notify::RecursiveMode::Recursive,
- )
- .unwrap();
+ if let Err(err) = watcher.watch(
+ &config.crate_dir.join(sub_path),
+ notify::RecursiveMode::Recursive,
+ ) {
+ log::error!("Failed to watch path: {}", err);
+ }
}
Ok(watcher)
}
+pub(crate) trait Platform {
+ fn start(config: &CrateConfig, serve: &ConfigOptsServe) -> Result
+ where
+ Self: Sized;
+ fn rebuild(&mut self, config: &CrateConfig) -> Result;
+}
+
#[derive(Clone)]
pub struct HotReloadState {
pub messages: broadcast::Sender>,
diff --git a/packages/cli/src/server/output.rs b/packages/cli/src/server/output.rs
index ce0f55064..4e148b0f1 100644
--- a/packages/cli/src/server/output.rs
+++ b/packages/cli/src/server/output.rs
@@ -22,17 +22,20 @@ pub fn print_console_info(
options: PrettierOptions,
web_info: Option,
) {
- if let Ok(native_clearseq) = Command::new(if cfg!(target_os = "windows") {
- "cls"
- } else {
- "clear"
- })
- .output()
- {
- print!("{}", String::from_utf8_lossy(&native_clearseq.stdout));
- } else {
- // Try ANSI-Escape characters
- print!("\x1b[2J\x1b[H");
+ // Don't clear the screen if the user has set the DIOXUS_LOG environment variable to "trace" so that we can see the logs
+ if Some("trace") != std::env::var("DIOXUS_LOG").ok().as_deref() {
+ if let Ok(native_clearseq) = Command::new(if cfg!(target_os = "windows") {
+ "cls"
+ } else {
+ "clear"
+ })
+ .output()
+ {
+ print!("{}", String::from_utf8_lossy(&native_clearseq.stdout));
+ } else {
+ // Try ANSI-Escape characters
+ print!("\x1b[2J\x1b[H");
+ }
}
let mut profile = if config.release { "Release" } else { "Debug" }.to_string();
@@ -129,7 +132,7 @@ pub fn print_console_info(
log::warn!(
"{}",
format!(
- "There were {} warning messages during the build.",
+ "There were {} warning messages during the build. Run `cargo check` to see them.",
options.warnings.len() - 1
)
.yellow()
diff --git a/packages/cli/src/server/web/mod.rs b/packages/cli/src/server/web/mod.rs
index 0e1413597..896d08643 100644
--- a/packages/cli/src/server/web/mod.rs
+++ b/packages/cli/src/server/web/mod.rs
@@ -11,6 +11,7 @@ use axum::{
body::{Full, HttpBody},
extract::{ws::Message, Extension, TypedHeader, WebSocketUpgrade},
http::{
+ self,
header::{HeaderName, HeaderValue},
Method, Response, StatusCode,
},
@@ -47,7 +48,12 @@ struct WsReloadState {
update: broadcast::Sender<()>,
}
-pub async fn startup(port: u16, config: CrateConfig, start_browser: bool) -> Result<()> {
+pub async fn startup(
+ port: u16,
+ config: CrateConfig,
+ start_browser: bool,
+ skip_assets: bool,
+) -> Result<()> {
// ctrl-c shutdown checker
let _crate_config = config.clone();
let _ = ctrlc::set_handler(move || {
@@ -79,7 +85,15 @@ pub async fn startup(port: u16, config: CrateConfig, start_browser: bool) -> Res
false => None,
};
- serve(ip, port, config, start_browser, hot_reload_state).await?;
+ serve(
+ ip,
+ port,
+ config,
+ start_browser,
+ skip_assets,
+ hot_reload_state,
+ )
+ .await?;
Ok(())
}
@@ -90,9 +104,10 @@ pub async fn serve(
port: u16,
config: CrateConfig,
start_browser: bool,
+ skip_assets: bool,
hot_reload_state: Option,
) -> Result<()> {
- let first_build_result = crate::builder::build(&config, true)?;
+ let first_build_result = crate::builder::build(&config, false, skip_assets)?;
log::info!("🚀 Starting development server...");
@@ -105,7 +120,7 @@ pub async fn serve(
{
let config = config.clone();
let reload_tx = reload_tx.clone();
- move || build(&config, &reload_tx)
+ move || build(&config, &reload_tx, skip_assets)
},
&config,
Some(WebServerInfo {
@@ -262,7 +277,7 @@ async fn setup_router(
.override_response_header(HeaderName::from_static("cross-origin-opener-policy"), coop)
.and_then(
move |response: Response| async move {
- let response = if file_service_config
+ let mut response = if file_service_config
.dioxus_config
.web
.watcher
@@ -290,6 +305,13 @@ async fn setup_router(
} else {
response.map(|body| body.boxed())
};
+ let headers = response.headers_mut();
+ headers.insert(
+ http::header::CACHE_CONTROL,
+ HeaderValue::from_static("no-cache"),
+ );
+ headers.insert(http::header::PRAGMA, HeaderValue::from_static("no-cache"));
+ headers.insert(http::header::EXPIRES, HeaderValue::from_static("0"));
Ok(response)
},
)
@@ -412,8 +434,8 @@ async fn ws_handler(
})
}
-fn build(config: &CrateConfig, reload_tx: &Sender<()>) -> Result {
- let result = builder::build(config, true)?;
+fn build(config: &CrateConfig, reload_tx: &Sender<()>, skip_assets: bool) -> Result {
+ let result = builder::build(config, true, skip_assets)?;
// change the websocket reload state to true;
// the page will auto-reload.
if config
@@ -423,7 +445,7 @@ fn build(config: &CrateConfig, reload_tx: &Sender<()>) -> Result {
.reload_html
.unwrap_or(false)
{
- let _ = Serve::regen_dev_page(config);
+ let _ = Serve::regen_dev_page(config, skip_assets);
}
let _ = reload_tx.send(());
Ok(result)
diff --git a/packages/core-macro/Cargo.toml b/packages/core-macro/Cargo.toml
index d928d5fec..ae3dc9cdd 100644
--- a/packages/core-macro/Cargo.toml
+++ b/packages/core-macro/Cargo.toml
@@ -15,10 +15,12 @@ proc-macro = true
[dependencies]
proc-macro2 = { version = "1.0" }
quote = "1.0"
-syn = { version = "2.0", features = ["full", "extra-traits"] }
+syn = { version = "2.0", features = ["full", "extra-traits", "visit"] }
dioxus-rsx = { workspace = true }
dioxus-core = { workspace = true }
constcat = "0.3.0"
+convert_case = "^0.6.0"
+prettyplease = "0.2.15"
# testing
[dev-dependencies]
diff --git a/packages/core-macro/README.md b/packages/core-macro/README.md
index 31b0cca90..497c7c587 100644
--- a/packages/core-macro/README.md
+++ b/packages/core-macro/README.md
@@ -23,9 +23,12 @@
`dioxus-core-macro` provides a handful of helpful macros used by the `dioxus` crate. These include:
-- The `rsx!` macro that underpins templates and node creation
-- The `inline_props` macro transforms function arguments into an auto-derived struct
-- The `format_args_f` macro which allows f-string formatting with support for expressions
+- The `rsx!` macro that underpins templates and node creation.
+- The `component` attribute macro denotes a function as a Dioxus component. Currently, this:
+ - Transforms function arguments into an auto-derived struct.
+ - Ensures that your component name uses PascalCase.
+ - Probably more stuff in the future. This macro allows us to have a way of distinguishing functions and components, which can be quite handy.
+- The `format_args_f` macro which allows f-string formatting with support for expressions.
## Contributing
diff --git a/packages/core-macro/src/component_body_deserializers/component.rs b/packages/core-macro/src/component_body_deserializers/component.rs
index e43b1819f..994e51709 100644
--- a/packages/core-macro/src/component_body_deserializers/component.rs
+++ b/packages/core-macro/src/component_body_deserializers/component.rs
@@ -31,6 +31,7 @@ fn get_out_comp_fn(orig_comp_fn: &ItemFn, cx_pat: &Pat) -> ItemFn {
block: parse_quote! {
{
#[warn(non_snake_case)]
+ #[allow(clippy::inline_always)]
#[inline(always)]
#inner_comp_fn
#inner_comp_ident (#cx_pat)
@@ -57,8 +58,11 @@ impl ToTokens for ComponentDeserializerOutput {
fn to_tokens(&self, tokens: &mut TokenStream2) {
let comp_fn = &self.comp_fn;
let props_struct = &self.props_struct;
+ let fn_ident = &comp_fn.sig.ident;
+ let doc = format!("Properties for the [`{fn_ident}`] component.");
tokens.append_all(quote! {
+ #[doc = #doc]
#props_struct
#[allow(non_snake_case)]
#comp_fn
diff --git a/packages/core-macro/src/component_body_deserializers/inline_props.rs b/packages/core-macro/src/component_body_deserializers/inline_props.rs
index 8e4581c19..d51132623 100644
--- a/packages/core-macro/src/component_body_deserializers/inline_props.rs
+++ b/packages/core-macro/src/component_body_deserializers/inline_props.rs
@@ -30,166 +30,312 @@ impl ToTokens for InlinePropsDeserializerOutput {
impl DeserializerArgs for InlinePropsDeserializerArgs {
fn to_output(&self, component_body: &ComponentBody) -> Result {
Ok(InlinePropsDeserializerOutput {
- comp_fn: Self::get_function(component_body),
- props_struct: Self::get_props_struct(component_body),
+ comp_fn: get_function(component_body),
+ props_struct: get_props_struct(component_body),
})
}
}
-impl InlinePropsDeserializerArgs {
- fn get_props_struct(component_body: &ComponentBody) -> ItemStruct {
- let ComponentBody { item_fn, .. } = component_body;
- let ItemFn { vis, sig, .. } = item_fn;
- let Signature {
- inputs,
- ident: fn_ident,
- generics,
- ..
- } = sig;
+fn get_props_struct(component_body: &ComponentBody) -> ItemStruct {
+ let ComponentBody { item_fn, .. } = component_body;
+ let ItemFn { vis, sig, .. } = item_fn;
+ let Signature {
+ inputs,
+ ident: fn_ident,
+ generics,
+ ..
+ } = sig;
- // Skip first arg since that's the context
- let struct_fields = inputs.iter().skip(1).map(move |f| {
- match f {
- FnArg::Receiver(_) => unreachable!(), // Unreachable because of ComponentBody parsing
- FnArg::Typed(pt) => {
- let arg_pat = &pt.pat; // Pattern (identifier)
- let arg_colon = &pt.colon_token;
- let arg_ty = &pt.ty; // Type
- let arg_attrs = &pt.attrs; // Attributes
+ // Skip first arg since that's the context
+ let struct_fields = inputs.iter().skip(1).map(move |f| {
+ match f {
+ FnArg::Receiver(_) => unreachable!(), // Unreachable because of ComponentBody parsing
+ FnArg::Typed(pt) => {
+ let arg_pat = &pt.pat; // Pattern (identifier)
+ let arg_colon = &pt.colon_token;
+ let arg_ty = &pt.ty; // Type
+ let arg_attrs = &pt.attrs; // Attributes
- quote! {
- #(#arg_attrs)
- *
- #vis #arg_pat #arg_colon #arg_ty
- }
+ quote! {
+ #(#arg_attrs)
+ *
+ #vis #arg_pat #arg_colon #arg_ty
}
}
- });
-
- let struct_ident = Ident::new(&format!("{fn_ident}Props"), fn_ident.span());
-
- let first_lifetime = if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
- Some(lt)
- } else {
- None
- };
-
- let struct_attrs = if first_lifetime.is_some() {
- quote! { #[derive(Props)] }
- } else {
- quote! { #[derive(Props, PartialEq)] }
- };
-
- let struct_generics = if first_lifetime.is_some() {
- let struct_generics: Punctuated = component_body
- .item_fn
- .sig
- .generics
- .params
- .iter()
- .map(|it| match it {
- GenericParam::Type(tp) => {
- let mut tp = tp.clone();
- tp.bounds.push(parse_quote!( 'a ));
-
- GenericParam::Type(tp)
- }
- _ => it.clone(),
- })
- .collect();
-
- quote! { <#struct_generics> }
- } else {
- quote! { #generics }
- };
-
- parse_quote! {
- #struct_attrs
- #[allow(non_camel_case_types)]
- #vis struct #struct_ident #struct_generics
- {
- #(#struct_fields),*
- }
}
- }
+ });
- fn get_function(component_body: &ComponentBody) -> ItemFn {
- let ComponentBody {
- item_fn,
- cx_pat_type,
- ..
- } = component_body;
- let ItemFn {
- attrs: fn_attrs,
- vis,
- sig,
- block: fn_block,
- } = item_fn;
- let Signature {
- inputs,
- ident: fn_ident,
- generics,
- output: fn_output,
- asyncness,
- ..
- } = sig;
- let Generics { where_clause, .. } = generics;
+ let struct_ident = Ident::new(&format!("{fn_ident}Props"), fn_ident.span());
- let cx_pat = &cx_pat_type.pat;
- let struct_ident = Ident::new(&format!("{fn_ident}Props"), fn_ident.span());
+ let first_lifetime = if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
+ Some(lt)
+ } else {
+ None
+ };
- // Skip first arg since that's the context
- let struct_field_names = inputs.iter().skip(1).filter_map(|f| match f {
- FnArg::Receiver(_) => unreachable!(), // ComponentBody prohibits receiver parameters.
- FnArg::Typed(t) => Some(&t.pat),
- });
+ let struct_attrs = if first_lifetime.is_some() {
+ quote! { #[derive(Props)] }
+ } else {
+ quote! { #[derive(Props, PartialEq)] }
+ };
- let first_lifetime = if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
- Some(lt)
- } else {
- None
- };
+ let struct_generics = if first_lifetime.is_some() {
+ let struct_generics: Punctuated = component_body
+ .item_fn
+ .sig
+ .generics
+ .params
+ .iter()
+ .map(|it| match it {
+ GenericParam::Type(tp) => {
+ let mut tp = tp.clone();
+ tp.bounds.push(parse_quote!( 'a ));
- let (scope_lifetime, fn_generics) = if let Some(lt) = first_lifetime {
- (quote! { #lt, }, generics.clone())
- } else {
- let lifetime: LifetimeParam = parse_quote! { 'a };
+ GenericParam::Type(tp)
+ }
+ _ => it.clone(),
+ })
+ .collect();
- let mut fn_generics = generics.clone();
- fn_generics
- .params
- .insert(0, GenericParam::Lifetime(lifetime.clone()));
+ quote! { <#struct_generics> }
+ } else {
+ quote! { #generics }
+ };
- (quote! { #lifetime, }, fn_generics)
- };
-
- let generics_no_bounds = {
- let mut generics = generics.clone();
- generics.params = generics
- .params
- .iter()
- .map(|it| match it {
- GenericParam::Type(tp) => {
- let mut tp = tp.clone();
- tp.bounds.clear();
-
- GenericParam::Type(tp)
- }
- _ => it.clone(),
- })
- .collect();
-
- generics
- };
-
- parse_quote! {
- #(#fn_attrs)*
- #asyncness #vis fn #fn_ident #fn_generics (#cx_pat: Scope<#scope_lifetime #struct_ident #generics_no_bounds>) #fn_output
- #where_clause
- {
- let #struct_ident { #(#struct_field_names),* } = &#cx_pat.props;
- #fn_block
- }
+ parse_quote! {
+ #struct_attrs
+ #[allow(non_camel_case_types)]
+ #vis struct #struct_ident #struct_generics
+ {
+ #(#struct_fields),*
}
}
}
+
+fn get_props_docs(fn_ident: &Ident, inputs: Vec<&FnArg>) -> Vec {
+ if inputs.len() <= 1 {
+ return Vec::new();
+ }
+
+ let arg_docs = inputs
+ .iter()
+ .filter_map(|f| match f {
+ FnArg::Receiver(_) => unreachable!(), // ComponentBody prohibits receiver parameters.
+ FnArg::Typed(pt) => {
+ let arg_doc = pt
+ .attrs
+ .iter()
+ .filter_map(|attr| {
+ // TODO: Error reporting
+ // Check if the path of the attribute is "doc"
+ if !is_attr_doc(attr) {
+ return None;
+ };
+
+ let Meta::NameValue(meta_name_value) = &attr.meta else {
+ return None;
+ };
+
+ let Expr::Lit(doc_lit) = &meta_name_value.value else {
+ return None;
+ };
+
+ let Lit::Str(doc_lit_str) = &doc_lit.lit else {
+ return None;
+ };
+
+ Some(doc_lit_str.value())
+ })
+ .fold(String::new(), |mut doc, next_doc_line| {
+ doc.push('\n');
+ doc.push_str(&next_doc_line);
+ doc
+ });
+
+ Some((
+ &pt.pat,
+ &pt.ty,
+ pt.attrs.iter().find_map(|attr| {
+ if attr.path() != &parse_quote!(deprecated) {
+ return None;
+ }
+
+ let res = crate::utils::DeprecatedAttribute::from_meta(&attr.meta);
+
+ match res {
+ Err(e) => panic!("{}", e.to_string()),
+ Ok(v) => Some(v),
+ }
+ }),
+ arg_doc,
+ ))
+ }
+ })
+ .collect::>();
+
+ let mut props_docs = Vec::with_capacity(5);
+ let props_def_link = fn_ident.to_string() + "Props";
+ let header =
+ format!("# Props\n*For details, see the [props struct definition]({props_def_link}).*");
+
+ props_docs.push(parse_quote! {
+ #[doc = #header]
+ });
+
+ for (arg_name, arg_type, deprecation, input_arg_doc) in arg_docs {
+ let arg_name = arg_name.into_token_stream().to_string();
+ let arg_type = crate::utils::format_type_string(arg_type);
+
+ let input_arg_doc = keep_up_to_n_consecutive_chars(input_arg_doc.trim(), 2, '\n')
+ .replace("\n\n", "
");
+ let prop_def_link = format!("{props_def_link}::{arg_name}");
+ let mut arg_doc = format!("- [`{arg_name}`]({prop_def_link}) : `{arg_type}`");
+
+ if let Some(deprecation) = deprecation {
+ arg_doc.push_str("
👎 Deprecated");
+
+ if let Some(since) = deprecation.since {
+ arg_doc.push_str(&format!(" since {since}"));
+ }
+
+ if let Some(note) = deprecation.note {
+ let note = keep_up_to_n_consecutive_chars(¬e, 1, '\n').replace('\n', " ");
+ let note = keep_up_to_n_consecutive_chars(¬e, 1, '\t').replace('\t', " ");
+
+ arg_doc.push_str(&format!(": {note}"));
+ }
+
+ arg_doc.push_str("
");
+
+ if !input_arg_doc.is_empty() {
+ arg_doc.push_str("
");
+ }
+ }
+
+ if !input_arg_doc.is_empty() {
+ arg_doc.push_str(&format!("{input_arg_doc}
"));
+ }
+
+ props_docs.push(parse_quote! {
+ #[doc = #arg_doc]
+ });
+ }
+
+ props_docs
+}
+
+fn get_function(component_body: &ComponentBody) -> ItemFn {
+ let ComponentBody {
+ item_fn,
+ cx_pat_type,
+ ..
+ } = component_body;
+ let ItemFn {
+ attrs: fn_attrs,
+ vis,
+ sig,
+ block: fn_block,
+ } = item_fn;
+ let Signature {
+ inputs,
+ ident: fn_ident,
+ generics,
+ output: fn_output,
+ asyncness,
+ ..
+ } = sig;
+ let Generics { where_clause, .. } = generics;
+
+ let cx_pat = &cx_pat_type.pat;
+ let struct_ident = Ident::new(&format!("{fn_ident}Props"), fn_ident.span());
+
+ // Skip first arg since that's the context
+ let struct_field_names = inputs.iter().skip(1).filter_map(|f| match f {
+ FnArg::Receiver(_) => unreachable!(), // ComponentBody prohibits receiver parameters.
+ FnArg::Typed(pt) => Some(&pt.pat),
+ });
+
+ let first_lifetime = if let Some(GenericParam::Lifetime(lt)) = generics.params.first() {
+ Some(lt)
+ } else {
+ None
+ };
+
+ let (scope_lifetime, fn_generics) = if let Some(lt) = first_lifetime {
+ (quote! { #lt, }, generics.clone())
+ } else {
+ let lifetime: LifetimeParam = parse_quote! { 'a };
+
+ let mut fn_generics = generics.clone();
+ fn_generics
+ .params
+ .insert(0, GenericParam::Lifetime(lifetime.clone()));
+
+ (quote! { #lifetime, }, fn_generics)
+ };
+
+ let generics_no_bounds = {
+ let mut generics = generics.clone();
+ generics.params = generics
+ .params
+ .iter()
+ .map(|it| match it {
+ GenericParam::Type(tp) => {
+ let mut tp = tp.clone();
+ tp.bounds.clear();
+
+ GenericParam::Type(tp)
+ }
+ _ => it.clone(),
+ })
+ .collect();
+
+ generics
+ };
+
+ let props_docs = get_props_docs(fn_ident, inputs.iter().skip(1).collect());
+
+ parse_quote! {
+ #(#fn_attrs)*
+ #(#props_docs)*
+ #asyncness #vis fn #fn_ident #fn_generics (#cx_pat: Scope<#scope_lifetime #struct_ident #generics_no_bounds>) #fn_output
+ #where_clause
+ {
+ let #struct_ident { #(#struct_field_names),* } = &#cx_pat.props;
+ #fn_block
+ }
+ }
+}
+
+/// Checks if the attribute is a `#[doc]` attribute.
+fn is_attr_doc(attr: &Attribute) -> bool {
+ attr.path() == &parse_quote!(doc)
+}
+
+fn keep_up_to_n_consecutive_chars(
+ input: &str,
+ n_of_consecutive_chars_allowed: usize,
+ target_char: char,
+) -> String {
+ let mut output = String::new();
+ let mut prev_char: Option = None;
+ let mut consecutive_count = 0;
+
+ for c in input.chars() {
+ match prev_char {
+ Some(prev) if c == target_char && prev == target_char => {
+ if consecutive_count < n_of_consecutive_chars_allowed {
+ output.push(c);
+ consecutive_count += 1;
+ }
+ }
+ _ => {
+ output.push(c);
+ prev_char = Some(c);
+ consecutive_count = 1;
+ }
+ }
+ }
+
+ output
+}
diff --git a/packages/core-macro/src/lib.rs b/packages/core-macro/src/lib.rs
index d91c72e39..4686bc797 100644
--- a/packages/core-macro/src/lib.rs
+++ b/packages/core-macro/src/lib.rs
@@ -1,3 +1,7 @@
+#![doc = include_str!("../README.md")]
+#![doc(html_logo_url = "https://avatars.githubusercontent.com/u/79236386")]
+#![doc(html_favicon_url = "https://avatars.githubusercontent.com/u/79236386")]
+
use proc_macro::TokenStream;
use quote::ToTokens;
use rsx::RenderCallBody;
@@ -8,6 +12,7 @@ use syn::{parse_macro_input, Path, Token};
mod component_body;
mod component_body_deserializers;
mod props;
+mod utils;
// mod rsx;
use crate::component_body::ComponentBody;
diff --git a/packages/core-macro/src/props/mod.rs b/packages/core-macro/src/props/mod.rs
index c1931e497..fff8bcbf1 100644
--- a/packages/core-macro/src/props/mod.rs
+++ b/packages/core-macro/src/props/mod.rs
@@ -24,6 +24,10 @@ pub fn impl_my_derive(ast: &syn::DeriveInput) -> Result {
.included_fields()
.map(|f| struct_info.field_impl(f))
.collect::, _>>()?;
+ let extends = struct_info
+ .extend_fields()
+ .map(|f| struct_info.extends_impl(f))
+ .collect::, _>>()?;
let fields = quote!(#(#fields)*).into_iter();
let required_fields = struct_info
.included_fields()
@@ -36,6 +40,7 @@ pub fn impl_my_derive(ast: &syn::DeriveInput) -> Result {
#builder_creation
#conversion_helper
#( #fields )*
+ #( #extends )*
#( #required_fields )*
#build_method
}
@@ -167,8 +172,8 @@ mod field_info {
use proc_macro2::TokenStream;
use quote::quote;
use syn::spanned::Spanned;
- use syn::Expr;
use syn::{parse::Error, punctuated::Punctuated};
+ use syn::{Expr, Path};
use super::util::{
expr_to_single_string, ident_to_type, path_to_single_string, strip_raw_ident_prefix,
@@ -199,6 +204,13 @@ mod field_info {
);
}
+ // extended field is automatically empty
+ if !builder_attr.extends.is_empty() {
+ builder_attr.default = Some(
+ syn::parse(quote!(::core::default::Default::default()).into()).unwrap(),
+ );
+ }
+
// auto detect optional
let strip_option_auto = builder_attr.strip_option
|| !builder_attr.ignore_option
@@ -243,10 +255,6 @@ mod field_info {
}
.into()
}
-
- pub fn type_from_inside_option(&self, check_option_name: bool) -> Option<&syn::Type> {
- type_from_inside_option(self.ty, check_option_name)
- }
}
#[derive(Debug, Default, Clone)]
@@ -257,6 +265,7 @@ mod field_info {
pub auto_into: bool,
pub strip_option: bool,
pub ignore_option: bool,
+ pub extends: Vec,
}
impl FieldBuilderAttr {
@@ -309,6 +318,17 @@ mod field_info {
let name = expr_to_single_string(&assign.left)
.ok_or_else(|| Error::new_spanned(&assign.left, "Expected identifier"))?;
match name.as_str() {
+ "extends" => {
+ if let syn::Expr::Path(path) = *assign.right {
+ self.extends.push(path.path);
+ Ok(())
+ } else {
+ Err(Error::new_spanned(
+ assign.right,
+ "Expected simple identifier",
+ ))
+ }
+ }
"default" => {
self.default = Some(*assign.right);
Ok(())
@@ -363,6 +383,11 @@ mod field_info {
Ok(())
}
+ "extend" => {
+ self.extends.push(path.path);
+ Ok(())
+ }
+
_ => {
macro_rules! handle_fields {
( $( $flag:expr, $field:ident, $already:expr; )* ) => {
@@ -466,11 +491,14 @@ fn type_from_inside_option(ty: &syn::Type, check_option_name: bool) -> Option<&s
}
mod struct_info {
+ use convert_case::{Case, Casing};
use proc_macro2::TokenStream;
use quote::quote;
use syn::parse::Error;
use syn::punctuated::Punctuated;
- use syn::Expr;
+ use syn::spanned::Spanned;
+ use syn::visit::Visit;
+ use syn::{parse_quote, Expr, Ident};
use super::field_info::{FieldBuilderAttr, FieldInfo};
use super::util::{
@@ -493,7 +521,46 @@ mod struct_info {
impl<'a> StructInfo<'a> {
pub fn included_fields(&self) -> impl Iterator- > {
- self.fields.iter().filter(|f| !f.builder_attr.skip)
+ self.fields
+ .iter()
+ .filter(|f| !f.builder_attr.skip && f.builder_attr.extends.is_empty())
+ }
+
+ pub fn extend_fields(&self) -> impl Iterator
- > {
+ self.fields
+ .iter()
+ .filter(|f| !f.builder_attr.extends.is_empty())
+ }
+
+ fn extend_lifetime(&self) -> syn::Result> {
+ let first_extend = self.extend_fields().next();
+
+ match first_extend {
+ Some(f) => {
+ struct VisitFirstLifetime(Option);
+
+ impl Visit<'_> for VisitFirstLifetime {
+ fn visit_lifetime(&mut self, lifetime: &'_ syn::Lifetime) {
+ if self.0.is_none() {
+ self.0 = Some(lifetime.clone());
+ }
+ }
+ }
+
+ let name = f.name;
+ let mut visitor = VisitFirstLifetime(None);
+
+ visitor.visit_type(f.ty);
+
+ visitor.0.ok_or_else(|| {
+ syn::Error::new_spanned(
+ name,
+ "Unable to find lifetime for extended field. Please specify it manually",
+ )
+ }).map(Some)
+ }
+ None => Ok(None),
+ }
}
pub fn new(
@@ -540,7 +607,17 @@ mod struct_info {
// Therefore, we will generate code that shortcircuits the "comparison" in memoization
let are_there_generics = !self.generics.params.is_empty();
- let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
+ let extend_lifetime = self.extend_lifetime()?;
+
+ let generics = self.generics.clone();
+ let (_, ty_generics, where_clause) = generics.split_for_impl();
+ let impl_generics = self.modify_generics(|g| {
+ if extend_lifetime.is_none() {
+ g.params.insert(0, parse_quote!('__bump));
+ }
+ });
+ let (impl_generics, _, _) = impl_generics.split_for_impl();
+ let (_, b_initial_generics, _) = self.generics.split_for_impl();
let all_fields_param = syn::GenericParam::Type(
syn::Ident::new("TypedBuilderFields", proc_macro2::Span::call_site()).into(),
);
@@ -548,21 +625,19 @@ mod struct_info {
g.params.insert(0, all_fields_param.clone());
});
let empties_tuple = type_tuple(self.included_fields().map(|_| empty_type()));
- let generics_with_empty = modify_types_generics_hack(&ty_generics, |args| {
+ let generics_with_empty = modify_types_generics_hack(&b_initial_generics, |args| {
args.insert(0, syn::GenericArgument::Type(empties_tuple.clone().into()));
});
- let phantom_generics = self.generics.params.iter().map(|param| match param {
+ let phantom_generics = self.generics.params.iter().filter_map(|param| match param {
syn::GenericParam::Lifetime(lifetime) => {
let lifetime = &lifetime.lifetime;
- quote!(::core::marker::PhantomData<&#lifetime ()>)
+ Some(quote!(::core::marker::PhantomData<&#lifetime ()>))
}
syn::GenericParam::Type(ty) => {
let ty = &ty.ident;
- quote!(::core::marker::PhantomData<#ty>)
- }
- syn::GenericParam::Const(_cnst) => {
- quote!()
+ Some(quote!(::core::marker::PhantomData<#ty>))
}
+ syn::GenericParam::Const(_cnst) => None,
});
let builder_method_doc = match self.builder_attr.builder_method_doc {
Some(ref doc) => quote!(#doc),
@@ -609,8 +684,7 @@ Finally, call `.build()` to create the instance of `{name}`.
quote!(#[doc(hidden)])
};
- let (b_generics_impl, b_generics_ty, b_generics_where_extras_predicates) =
- b_generics.split_for_impl();
+ let (_, _, b_generics_where_extras_predicates) = b_generics.split_for_impl();
let mut b_generics_where: syn::WhereClause = syn::parse2(quote! {
where TypedBuilderFields: Clone
})?;
@@ -630,12 +704,39 @@ Finally, call `.build()` to create the instance of `{name}`.
false => quote! { true },
};
+ let extend_fields = self.extend_fields().map(|f| {
+ let name = f.name;
+ let ty = f.ty;
+ quote!(#name: #ty)
+ });
+ let extend_fields_value = self.extend_fields().map(|f| {
+ let name = f.name;
+ quote!(#name: Vec::new())
+ });
+ let has_extend_fields = self.extend_fields().next().is_some();
+ let take_bump = if has_extend_fields {
+ quote!(bump: _cx.bump(),)
+ } else {
+ quote!()
+ };
+ let bump_field = if has_extend_fields {
+ quote!(bump: & #extend_lifetime ::dioxus::core::exports::bumpalo::Bump,)
+ } else {
+ quote!()
+ };
+ let extend_lifetime = extend_lifetime.unwrap_or(syn::Lifetime::new(
+ "'__bump",
+ proc_macro2::Span::call_site(),
+ ));
+
Ok(quote! {
impl #impl_generics #name #ty_generics #where_clause {
#[doc = #builder_method_doc]
- #[allow(dead_code)]
- #vis fn builder() -> #builder_name #generics_with_empty {
+ #[allow(dead_code, clippy::type_complexity)]
+ #vis fn builder(_cx: & #extend_lifetime ::dioxus::prelude::ScopeState) -> #builder_name #generics_with_empty {
#builder_name {
+ #(#extend_fields_value,)*
+ #take_bump
fields: #empties_tuple,
_phantom: ::core::default::Default::default(),
}
@@ -646,26 +747,19 @@ Finally, call `.build()` to create the instance of `{name}`.
#builder_type_doc
#[allow(dead_code, non_camel_case_types, non_snake_case)]
#vis struct #builder_name #b_generics {
+ #(#extend_fields,)*
+ #bump_field
fields: #all_fields_param,
_phantom: (#( #phantom_generics ),*),
}
- impl #b_generics_impl Clone for #builder_name #b_generics_ty #b_generics_where {
- fn clone(&self) -> Self {
- Self {
- fields: self.fields.clone(),
- _phantom: ::core::default::Default::default(),
- }
- }
- }
-
- impl #impl_generics ::dioxus::prelude::Properties for #name #ty_generics
+ impl #impl_generics ::dioxus::prelude::Properties<#extend_lifetime> for #name #ty_generics
#b_generics_where_extras_predicates
{
type Builder = #builder_name #generics_with_empty;
const IS_STATIC: bool = #is_static;
- fn builder() -> Self::Builder {
- #name::builder()
+ fn builder(_cx: &#extend_lifetime ::dioxus::prelude::ScopeState) -> Self::Builder {
+ #name::builder(_cx)
}
unsafe fn memoize(&self, other: &Self) -> bool {
#can_memoize
@@ -700,7 +794,147 @@ Finally, call `.build()` to create the instance of `{name}`.
})
}
+ pub fn extends_impl(&self, field: &FieldInfo) -> Result {
+ let StructInfo {
+ ref builder_name, ..
+ } = *self;
+
+ let field_name = field.name;
+
+ let descructuring = self.included_fields().map(|f| {
+ if f.ordinal == field.ordinal {
+ quote!(_)
+ } else {
+ let name = f.name;
+ quote!(#name)
+ }
+ });
+ let reconstructing = self.included_fields().map(|f| f.name);
+
+ // Add the bump lifetime to the generics
+ let mut ty_generics: Vec = self
+ .generics
+ .params
+ .iter()
+ .map(|generic_param| match generic_param {
+ syn::GenericParam::Type(type_param) => {
+ let ident = type_param.ident.clone();
+ syn::parse(quote!(#ident).into()).unwrap()
+ }
+ syn::GenericParam::Lifetime(lifetime_def) => {
+ syn::GenericArgument::Lifetime(lifetime_def.lifetime.clone())
+ }
+ syn::GenericParam::Const(const_param) => {
+ let ident = const_param.ident.clone();
+ syn::parse(quote!(#ident).into()).unwrap()
+ }
+ })
+ .collect();
+ let mut target_generics_tuple = empty_type_tuple();
+ let mut ty_generics_tuple = empty_type_tuple();
+ let generics = self.modify_generics(|g| {
+ let index_after_lifetime_in_generics = g
+ .params
+ .iter()
+ .filter(|arg| matches!(arg, syn::GenericParam::Lifetime(_)))
+ .count();
+ for f in self.included_fields() {
+ if f.ordinal == field.ordinal {
+ ty_generics_tuple.elems.push_value(empty_type());
+ target_generics_tuple
+ .elems
+ .push_value(f.tuplized_type_ty_param());
+ } else {
+ g.params
+ .insert(index_after_lifetime_in_generics, f.generic_ty_param());
+ let generic_argument: syn::Type = f.type_ident();
+ ty_generics_tuple.elems.push_value(generic_argument.clone());
+ target_generics_tuple.elems.push_value(generic_argument);
+ }
+ ty_generics_tuple.elems.push_punct(Default::default());
+ target_generics_tuple.elems.push_punct(Default::default());
+ }
+ });
+ let mut target_generics = ty_generics.clone();
+ let index_after_lifetime_in_generics = target_generics
+ .iter()
+ .filter(|arg| matches!(arg, syn::GenericArgument::Lifetime(_)))
+ .count();
+ target_generics.insert(
+ index_after_lifetime_in_generics,
+ syn::GenericArgument::Type(target_generics_tuple.into()),
+ );
+ ty_generics.insert(
+ index_after_lifetime_in_generics,
+ syn::GenericArgument::Type(ty_generics_tuple.into()),
+ );
+ let (impl_generics, _, where_clause) = generics.split_for_impl();
+
+ let forward_extended_fields = self.extend_fields().map(|f| {
+ let name = f.name;
+ quote!(#name: self.#name)
+ });
+
+ let extend_lifetime = self.extend_lifetime()?.ok_or(Error::new_spanned(
+ field_name,
+ "Unable to find lifetime for extended field. Please specify it manually",
+ ))?;
+
+ let extends_impl = field.builder_attr.extends.iter().map(|path| {
+ let name_str = path_to_single_string(path).unwrap();
+ let camel_name = name_str.to_case(Case::UpperCamel);
+ let marker_name = Ident::new(
+ format!("{}Extension", &camel_name).as_str(),
+ path.span(),
+ );
+ quote! {
+ #[allow(dead_code, non_camel_case_types, missing_docs)]
+ impl #impl_generics dioxus_elements::extensions::#marker_name < #extend_lifetime > for #builder_name < #( #ty_generics ),* > #where_clause {}
+ }
+ });
+
+ Ok(quote! {
+ #[allow(dead_code, non_camel_case_types, missing_docs)]
+ impl #impl_generics ::dioxus::prelude::HasAttributes<#extend_lifetime> for #builder_name < #( #ty_generics ),* > #where_clause {
+ fn push_attribute(
+ mut self,
+ name: &#extend_lifetime str,
+ ns: Option<&'static str>,
+ attr: impl ::dioxus::prelude::IntoAttributeValue<#extend_lifetime>,
+ volatile: bool
+ ) -> Self {
+ let ( #(#descructuring,)* ) = self.fields;
+ self.#field_name.push(
+ ::dioxus::core::Attribute::new(
+ name,
+ {
+ use ::dioxus::prelude::IntoAttributeValue;
+ attr.into_value(self.bump)
+ },
+ ns,
+ volatile,
+ )
+ );
+ #builder_name {
+ #(#forward_extended_fields,)*
+ bump: self.bump,
+ fields: ( #(#reconstructing,)* ),
+ _phantom: self._phantom,
+ }
+ }
+ }
+
+ #(#extends_impl)*
+ })
+ }
+
pub fn field_impl(&self, field: &FieldInfo) -> Result {
+ let FieldInfo {
+ name: field_name, ..
+ } = field;
+ if *field_name == "key" {
+ return Err(Error::new_spanned(field_name, "Naming a prop `key` is not allowed because the name can conflict with the built in key attribute. See https://dioxuslabs.com/learn/0.4/reference/dynamic_rendering#rendering-lists for more information about keys"));
+ }
let StructInfo {
ref builder_name, ..
} = *self;
@@ -720,6 +954,7 @@ Finally, call `.build()` to create the instance of `{name}`.
ty: field_type,
..
} = field;
+ // Add the bump lifetime to the generics
let mut ty_generics: Vec = self
.generics
.params
@@ -782,31 +1017,16 @@ Finally, call `.build()` to create the instance of `{name}`.
None => quote!(),
};
- // NOTE: both auto_into and strip_option affect `arg_type` and `arg_expr`, but the order of
- // nesting is different so we have to do this little dance.
- let arg_type = if field.builder_attr.strip_option {
- field.type_from_inside_option(false).ok_or_else(|| {
- Error::new_spanned(
- field_type,
- "can't `strip_option` - field is not `Option<...>`",
+ let arg_type = field_type;
+ let (arg_type, arg_expr) =
+ if field.builder_attr.auto_into || field.builder_attr.strip_option {
+ (
+ quote!(impl ::core::convert::Into<#arg_type>),
+ quote!(#field_name.into()),
)
- })?
- } else {
- field_type
- };
- let (arg_type, arg_expr) = if field.builder_attr.auto_into {
- (
- quote!(impl ::core::convert::Into<#arg_type>),
- quote!(#field_name.into()),
- )
- } else {
- (quote!(#arg_type), quote!(#field_name))
- };
- let arg_expr = if field.builder_attr.strip_option {
- quote!(Some(#arg_expr))
- } else {
- arg_expr
- };
+ } else {
+ (quote!(#arg_type), quote!(#field_name))
+ };
let repeated_fields_error_type_name = syn::Ident::new(
&format!(
@@ -818,14 +1038,27 @@ Finally, call `.build()` to create the instance of `{name}`.
);
let repeated_fields_error_message = format!("Repeated field {field_name}");
+ let forward_extended_fields = self.extend_fields().map(|f| {
+ let name = f.name;
+ quote!(#name: self.#name)
+ });
+ let forward_bump = if self.extend_fields().next().is_some() {
+ quote!(bump: self.bump,)
+ } else {
+ quote!()
+ };
+
Ok(quote! {
#[allow(dead_code, non_camel_case_types, missing_docs)]
impl #impl_generics #builder_name < #( #ty_generics ),* > #where_clause {
#doc
+ #[allow(clippy::type_complexity)]
pub fn #field_name (self, #field_name: #arg_type) -> #builder_name < #( #target_generics ),* > {
let #field_name = (#arg_expr,);
let ( #(#descructuring,)* ) = self.fields;
#builder_name {
+ #(#forward_extended_fields,)*
+ #forward_bump
fields: ( #(#reconstructing,)* ),
_phantom: self._phantom,
}
@@ -840,6 +1073,7 @@ Finally, call `.build()` to create the instance of `{name}`.
#[deprecated(
note = #repeated_fields_error_message
)]
+ #[allow(clippy::type_complexity)]
pub fn #field_name (self, _: #repeated_fields_error_type_name) -> #builder_name < #( #target_generics ),* > {
self
}
@@ -858,6 +1092,7 @@ Finally, call `.build()` to create the instance of `{name}`.
name: ref field_name,
..
} = field;
+ // Add a bump lifetime to the generics
let mut builder_generics: Vec = self
.generics
.params
@@ -1025,7 +1260,9 @@ Finally, call `.build()` to create the instance of `{name}`.
// reordering based on that, but for now this much simpler thing is a reasonable approach.
let assignments = self.fields.iter().map(|field| {
let name = &field.name;
- if let Some(ref default) = field.builder_attr.default {
+ if !field.builder_attr.extends.is_empty() {
+ quote!(let #name = self.#name;)
+ } else if let Some(ref default) = field.builder_attr.default {
if field.builder_attr.skip {
quote!(let #name = #default;)
} else {
diff --git a/packages/core-macro/src/utils.rs b/packages/core-macro/src/utils.rs
new file mode 100644
index 000000000..7e066f773
--- /dev/null
+++ b/packages/core-macro/src/utils.rs
@@ -0,0 +1,129 @@
+use quote::ToTokens;
+use syn::parse::{Parse, ParseStream};
+use syn::spanned::Spanned;
+use syn::{parse_quote, Expr, Lit, Meta, Token, Type};
+
+const FORMATTED_TYPE_START: &str = "static TY_AFTER_HERE:";
+const FORMATTED_TYPE_END: &str = "= todo!();";
+
+/// Attempts to convert the given literal to a string.
+/// Converts ints and floats to their base 10 counterparts.
+///
+/// Returns `None` if the literal is [`Lit::Verbatim`] or if the literal is [`Lit::ByteStr`]
+/// and the byte string could not be converted to UTF-8.
+pub fn lit_to_string(lit: Lit) -> Option {
+ match lit {
+ Lit::Str(l) => Some(l.value()),
+ Lit::ByteStr(l) => String::from_utf8(l.value()).ok(),
+ Lit::Byte(l) => Some(String::from(l.value() as char)),
+ Lit::Char(l) => Some(l.value().to_string()),
+ Lit::Int(l) => Some(l.base10_digits().to_string()),
+ Lit::Float(l) => Some(l.base10_digits().to_string()),
+ Lit::Bool(l) => Some(l.value().to_string()),
+ Lit::Verbatim(_) => None,
+ _ => None,
+ }
+}
+
+pub fn format_type_string(ty: &Type) -> String {
+ let ty_unformatted = ty.into_token_stream().to_string();
+ let ty_unformatted = ty_unformatted.trim();
+
+ // This should always be valid syntax.
+ // Not Rust code, but syntax, which is the only thing that `syn` cares about.
+ let Ok(file_unformatted) = syn::parse_file(&format!(
+ "{FORMATTED_TYPE_START}{ty_unformatted}{FORMATTED_TYPE_END}"
+ )) else {
+ return ty_unformatted.to_string();
+ };
+
+ let file_formatted = prettyplease::unparse(&file_unformatted);
+
+ let file_trimmed = file_formatted.trim();
+ let start_removed = file_trimmed.trim_start_matches(FORMATTED_TYPE_START);
+ let end_removed = start_removed.trim_end_matches(FORMATTED_TYPE_END);
+ let ty_formatted = end_removed.trim();
+
+ ty_formatted.to_string()
+}
+
+/// Represents the `#[deprecated]` attribute.
+///
+/// You can use the [`DeprecatedAttribute::from_meta`] function to try to parse an attribute to this struct.
+#[derive(Default)]
+pub struct DeprecatedAttribute {
+ pub since: Option,
+ pub note: Option,
+}
+
+impl DeprecatedAttribute {
+ /// Returns `None` if the given attribute was not a valid form of the `#[deprecated]` attribute.
+ pub fn from_meta(meta: &Meta) -> syn::Result {
+ if meta.path() != &parse_quote!(deprecated) {
+ return Err(syn::Error::new(
+ meta.span(),
+ "attribute path is not `deprecated`",
+ ));
+ }
+
+ match &meta {
+ Meta::Path(_) => Ok(Self::default()),
+ Meta::NameValue(name_value) => {
+ let Expr::Lit(expr_lit) = &name_value.value else {
+ return Err(syn::Error::new(
+ name_value.span(),
+ "literal in `deprecated` value must be a string",
+ ));
+ };
+
+ Ok(Self {
+ since: None,
+ note: lit_to_string(expr_lit.lit.clone()).map(|s| s.trim().to_string()),
+ })
+ }
+ Meta::List(list) => {
+ let parsed = list.parse_args::()?;
+
+ Ok(Self {
+ since: parsed.since.map(|s| s.trim().to_string()),
+ note: parsed.note.map(|s| s.trim().to_string()),
+ })
+ }
+ }
+ }
+}
+
+mod kw {
+ use syn::custom_keyword;
+ custom_keyword!(since);
+ custom_keyword!(note);
+}
+
+struct DeprecatedAttributeArgsParser {
+ since: Option,
+ note: Option,
+}
+
+impl Parse for DeprecatedAttributeArgsParser {
+ fn parse(input: ParseStream) -> syn::Result {
+ let mut since: Option = None;
+ let mut note: Option = None;
+
+ if input.peek(kw::since) {
+ input.parse::()?;
+ input.parse::()?;
+
+ since = lit_to_string(input.parse()?);
+ }
+
+ if input.peek(Token![,]) && input.peek2(kw::note) {
+ input.parse::()?;
+ input.parse::()?;
+ input.parse::()?;
+
+ note = lit_to_string(input.parse()?);
+ }
+
+ Ok(Self { since, note })
+ }
+}
diff --git a/packages/core/Cargo.toml b/packages/core/Cargo.toml
index ce7c6bccf..6cc7b3ad3 100644
--- a/packages/core/Cargo.toml
+++ b/packages/core/Cargo.toml
@@ -36,6 +36,7 @@ serde = { version = "1", features = ["derive"], optional = true }
[dev-dependencies]
tokio = { workspace = true, features = ["full"] }
dioxus = { workspace = true }
+dioxus-html = { workspace = true, features = ["serialize"] }
pretty_assertions = "1.3.0"
rand = "0.8.5"
dioxus-ssr = { workspace = true }
diff --git a/packages/core/src/arena.rs b/packages/core/src/arena.rs
index b7f768755..ffdd4656b 100644
--- a/packages/core/src/arena.rs
+++ b/packages/core/src/arena.rs
@@ -13,62 +13,50 @@ use crate::{
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct ElementId(pub usize);
-pub(crate) struct ElementRef {
+/// An Element that can be bubbled to's unique identifier.
+///
+/// `BubbleId` is a `usize` that is unique across the entire VirtualDOM - but not unique across time. If a component is
+/// unmounted, then the `BubbleId` will be reused for a new component.
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct VNodeId(pub usize);
+
+#[derive(Debug, Clone, Copy)]
+pub struct ElementRef {
// the pathway of the real element inside the template
- pub path: ElementPath,
+ pub(crate) path: ElementPath,
// The actual template
- pub template: Option>>,
+ pub(crate) template: VNodeId,
// The scope the element belongs to
- pub scope: ScopeId,
+ pub(crate) scope: ScopeId,
}
#[derive(Clone, Copy, Debug)]
-pub enum ElementPath {
- Deep(&'static [u8]),
- Root(usize),
-}
-
-impl ElementRef {
- pub(crate) fn none() -> Self {
- Self {
- template: None,
- path: ElementPath::Root(0),
- scope: ScopeId::ROOT,
- }
- }
+pub struct ElementPath {
+ pub(crate) path: &'static [u8],
}
impl VirtualDom {
- pub(crate) fn next_element(&mut self, template: &VNode, path: &'static [u8]) -> ElementId {
- self.next_reference(template, ElementPath::Deep(path))
+ pub(crate) fn next_element(&mut self) -> ElementId {
+ ElementId(self.elements.insert(None))
}
- pub(crate) fn next_root(&mut self, template: &VNode, path: usize) -> ElementId {
- self.next_reference(template, ElementPath::Root(path))
- }
+ pub(crate) fn next_vnode_ref(&mut self, vnode: &VNode) -> VNodeId {
+ let new_id = VNodeId(self.element_refs.insert(Some(unsafe {
+ std::mem::transmute::, _>(vnode.into())
+ })));
- pub(crate) fn next_null(&mut self) -> ElementId {
- let entry = self.elements.vacant_entry();
- let id = entry.key();
+ // Set this id to be dropped when the scope is rerun
+ if let Some(scope) = self.runtime.current_scope_id() {
+ self.scopes[scope.0]
+ .element_refs_to_drop
+ .borrow_mut()
+ .push(new_id);
+ }
- entry.insert(ElementRef::none());
- ElementId(id)
- }
-
- fn next_reference(&mut self, template: &VNode, path: ElementPath) -> ElementId {
- let entry = self.elements.vacant_entry();
- let id = entry.key();
- let scope = self.runtime.current_scope_id().unwrap_or(ScopeId::ROOT);
-
- entry.insert(ElementRef {
- // We know this is non-null because it comes from a reference
- template: Some(unsafe { NonNull::new_unchecked(template as *const _ as *mut _) }),
- path,
- scope,
- });
- ElementId(id)
+ new_id
}
pub(crate) fn reclaim(&mut self, el: ElementId) {
@@ -76,7 +64,7 @@ impl VirtualDom {
.unwrap_or_else(|| panic!("cannot reclaim {:?}", el));
}
- pub(crate) fn try_reclaim(&mut self, el: ElementId) -> Option {
+ pub(crate) fn try_reclaim(&mut self, el: ElementId) -> Option<()> {
if el.0 == 0 {
panic!(
"Cannot reclaim the root element - {:#?}",
@@ -84,12 +72,12 @@ impl VirtualDom {
);
}
- self.elements.try_remove(el.0)
+ self.elements.try_remove(el.0).map(|_| ())
}
- pub(crate) fn update_template(&mut self, el: ElementId, node: &VNode) {
- let node: *const VNode = node as *const _;
- self.elements[el.0].template = unsafe { std::mem::transmute(node) };
+ pub(crate) fn set_template(&mut self, id: VNodeId, vnode: &VNode) {
+ self.element_refs[id.0] =
+ Some(unsafe { std::mem::transmute::, _>(vnode.into()) });
}
// Drop a scope and all its children
@@ -101,6 +89,15 @@ impl VirtualDom {
id,
});
+ // Remove all VNode ids from the scope
+ for id in self.scopes[id.0]
+ .element_refs_to_drop
+ .borrow_mut()
+ .drain(..)
+ {
+ self.element_refs.try_remove(id.0);
+ }
+
self.ensure_drop_safety(id);
if recursive {
@@ -145,14 +142,25 @@ impl VirtualDom {
}
/// Descend through the tree, removing any borrowed props and listeners
- pub(crate) fn ensure_drop_safety(&self, scope_id: ScopeId) {
+ pub(crate) fn ensure_drop_safety(&mut self, scope_id: ScopeId) {
let scope = &self.scopes[scope_id.0];
+ {
+ // Drop all element refs that could be invalidated when the component was rerun
+ let mut element_refs = self.scopes[scope_id.0].element_refs_to_drop.borrow_mut();
+ let element_refs_slab = &mut self.element_refs;
+ for element_ref in element_refs.drain(..) {
+ if let Some(element_ref) = element_refs_slab.get_mut(element_ref.0) {
+ *element_ref = None;
+ }
+ }
+ }
+
// make sure we drop all borrowed props manually to guarantee that their drop implementation is called before we
// run the hooks (which hold an &mut Reference)
// recursively call ensure_drop_safety on all children
- let mut props = scope.borrowed_props.borrow_mut();
- props.drain(..).for_each(|comp| {
+ let props = { scope.borrowed_props.borrow_mut().clone() };
+ for comp in props {
let comp = unsafe { &*comp };
match comp.scope.get() {
Some(child) if child != scope_id => self.ensure_drop_safety(child),
@@ -161,20 +169,16 @@ impl VirtualDom {
if let Ok(mut props) = comp.props.try_borrow_mut() {
*props = None;
}
- });
+ }
+ let scope = &self.scopes[scope_id.0];
+ scope.borrowed_props.borrow_mut().clear();
// Now that all the references are gone, we can safely drop our own references in our listeners.
- let mut listeners = scope.attributes_to_drop.borrow_mut();
+ let mut listeners = scope.attributes_to_drop_before_render.borrow_mut();
listeners.drain(..).for_each(|listener| {
let listener = unsafe { &*listener };
- match &listener.value {
- AttributeValue::Listener(l) => {
- _ = l.take();
- }
- AttributeValue::Any(a) => {
- _ = a.take();
- }
- _ => (),
+ if let AttributeValue::Listener(l) = &listener.value {
+ _ = l.take();
}
});
}
@@ -182,18 +186,12 @@ impl VirtualDom {
impl ElementPath {
pub(crate) fn is_decendant(&self, small: &&[u8]) -> bool {
- match *self {
- ElementPath::Deep(big) => small.len() <= big.len() && *small == &big[..small.len()],
- ElementPath::Root(r) => small.len() == 1 && small[0] == r as u8,
- }
+ small.len() <= self.path.len() && *small == &self.path[..small.len()]
}
}
impl PartialEq<&[u8]> for ElementPath {
fn eq(&self, other: &&[u8]) -> bool {
- match *self {
- ElementPath::Deep(deep) => deep.eq(*other),
- ElementPath::Root(r) => other.len() == 1 && other[0] == r as u8,
- }
+ self.path.eq(*other)
}
}
diff --git a/packages/core/src/bump_frame.rs b/packages/core/src/bump_frame.rs
index 0fe7b3867..6927bd8bc 100644
--- a/packages/core/src/bump_frame.rs
+++ b/packages/core/src/bump_frame.rs
@@ -1,10 +1,16 @@
use crate::nodes::RenderReturn;
+use crate::{Attribute, AttributeValue, VComponent};
use bumpalo::Bump;
+use std::cell::RefCell;
use std::cell::{Cell, UnsafeCell};
pub(crate) struct BumpFrame {
pub bump: UnsafeCell,
pub node: Cell<*const RenderReturn<'static>>,
+
+ // The bump allocator will not call the destructor of the objects it allocated. Attributes and props need to have there destructor called, so we keep a list of them to drop before the bump allocator is reset.
+ pub(crate) attributes_to_drop_before_reset: RefCell>>,
+ pub(crate) props_to_drop_before_reset: RefCell>>,
}
impl BumpFrame {
@@ -13,6 +19,8 @@ impl BumpFrame {
Self {
bump: UnsafeCell::new(bump),
node: Cell::new(std::ptr::null()),
+ attributes_to_drop_before_reset: Default::default(),
+ props_to_drop_before_reset: Default::default(),
}
}
@@ -31,8 +39,38 @@ impl BumpFrame {
unsafe { &*self.bump.get() }
}
- #[allow(clippy::mut_from_ref)]
- pub(crate) unsafe fn bump_mut(&self) -> &mut Bump {
- unsafe { &mut *self.bump.get() }
+ pub(crate) fn add_attribute_to_drop(&self, attribute: *const Attribute<'static>) {
+ self.attributes_to_drop_before_reset
+ .borrow_mut()
+ .push(attribute);
+ }
+
+ /// Reset the bump allocator and drop all the attributes and props that were allocated in it.
+ ///
+ /// # Safety
+ /// The caller must insure that no reference to anything allocated in the bump allocator is available after this function is called.
+ pub(crate) unsafe fn reset(&self) {
+ let mut attributes = self.attributes_to_drop_before_reset.borrow_mut();
+ attributes.drain(..).for_each(|attribute| {
+ let attribute = unsafe { &*attribute };
+ if let AttributeValue::Any(l) = &attribute.value {
+ _ = l.take();
+ }
+ });
+ let mut props = self.props_to_drop_before_reset.borrow_mut();
+ props.drain(..).for_each(|prop| {
+ let prop = unsafe { &*prop };
+ _ = prop.props.borrow_mut().take();
+ });
+ unsafe {
+ let bump = &mut *self.bump.get();
+ bump.reset();
+ }
+ }
+}
+
+impl Drop for BumpFrame {
+ fn drop(&mut self) {
+ unsafe { self.reset() }
}
}
diff --git a/packages/core/src/create.rs b/packages/core/src/create.rs
index a61a8cace..8602b93bd 100644
--- a/packages/core/src/create.rs
+++ b/packages/core/src/create.rs
@@ -1,5 +1,8 @@
use crate::any_props::AnyProps;
-use crate::innerlude::{BorrowedAttributeValue, VComponent, VPlaceholder, VText};
+use crate::innerlude::{
+ AttributeType, BorrowedAttributeValue, ElementPath, ElementRef, MountedAttribute, VComponent,
+ VPlaceholder, VText,
+};
use crate::mutations::Mutation;
use crate::mutations::Mutation::*;
use crate::nodes::VNode;
@@ -94,6 +97,9 @@ impl<'b> VirtualDom {
nodes_mut.resize(len, ElementId::default());
};
+ // Set this node id
+ node.stable_id.set(Some(self.next_vnode_ref(node)));
+
// The best renderers will have templates prehydrated and registered
// Just in case, let's create the template using instructions anyways
self.register_template(node.template.get());
@@ -181,15 +187,30 @@ impl<'b> VirtualDom {
use DynamicNode::*;
match &template.dynamic_nodes[idx] {
node @ Component { .. } | node @ Fragment(_) => {
- self.create_dynamic_node(template, node, idx)
+ let template_ref = ElementRef {
+ path: ElementPath {
+ path: template.template.get().node_paths[idx],
+ },
+ template: template.stable_id().unwrap(),
+ scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
+ };
+ self.create_dynamic_node(template_ref, node)
}
- Placeholder(VPlaceholder { id }) => {
- let id = self.set_slot(template, id, idx);
+ Placeholder(VPlaceholder { id, parent }) => {
+ let template_ref = ElementRef {
+ path: ElementPath {
+ path: template.template.get().node_paths[idx],
+ },
+ template: template.stable_id().unwrap(),
+ scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
+ };
+ parent.set(Some(template_ref));
+ let id = self.set_slot(id);
self.mutations.push(CreatePlaceholder { id });
1
}
Text(VText { id, value }) => {
- let id = self.set_slot(template, id, idx);
+ let id = self.set_slot(id);
self.create_static_text(value, id);
1
}
@@ -205,7 +226,7 @@ impl<'b> VirtualDom {
});
}
- /// We write all the descndent data for this element
+ /// We write all the descendent data for this element
///
/// Elements can contain other nodes - and those nodes can be dynamic or static
///
@@ -265,7 +286,14 @@ impl<'b> VirtualDom {
.map(|sorted_index| dynamic_nodes[sorted_index].0);
for idx in reversed_iter {
- let m = self.create_dynamic_node(template, &template.dynamic_nodes[idx], idx);
+ let boundary_ref = ElementRef {
+ path: ElementPath {
+ path: template.template.get().node_paths[idx],
+ },
+ template: template.stable_id().unwrap(),
+ scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
+ };
+ let m = self.create_dynamic_node(boundary_ref, &template.dynamic_nodes[idx]);
if m > 0 {
// The path is one shorter because the top node is the root
let path = &template.template.get().node_paths[idx][1..];
@@ -279,15 +307,15 @@ impl<'b> VirtualDom {
attrs: &mut Peekable>,
root_idx: u8,
root: ElementId,
- node: &VNode,
+ node: &'b VNode<'b>,
) {
while let Some((mut attr_id, path)) =
attrs.next_if(|(_, p)| p.first().copied() == Some(root_idx))
{
- let id = self.assign_static_node_as_dynamic(path, root, node, attr_id);
+ let id = self.assign_static_node_as_dynamic(path, root);
loop {
- self.write_attribute(&node.dynamic_attrs[attr_id], id);
+ self.write_attribute_type(node, &node.dynamic_attrs[attr_id], attr_id, id);
// Only push the dynamic attributes forward if they match the current path (same element)
match attrs.next_if(|(_, p)| *p == path) {
@@ -298,15 +326,44 @@ impl<'b> VirtualDom {
}
}
- fn write_attribute(&mut self, attribute: &'b crate::Attribute<'b>, id: ElementId) {
+ fn write_attribute_type(
+ &mut self,
+ vnode: &'b VNode<'b>,
+ attribute: &'b MountedAttribute<'b>,
+ idx: usize,
+ id: ElementId,
+ ) {
// Make sure we set the attribute's associated id
attribute.mounted_element.set(id);
+ match &attribute.ty {
+ AttributeType::Single(attribute) => self.write_attribute(vnode, attribute, idx, id),
+ AttributeType::Many(attribute) => {
+ for attribute in *attribute {
+ self.write_attribute(vnode, attribute, idx, id);
+ }
+ }
+ }
+ }
+ pub(crate) fn write_attribute(
+ &mut self,
+ vnode: &'b VNode<'b>,
+ attribute: &'b crate::Attribute<'b>,
+ idx: usize,
+ id: ElementId,
+ ) {
// Safety: we promise not to re-alias this text later on after committing it to the mutation
let unbounded_name: &str = unsafe { std::mem::transmute(attribute.name) };
match &attribute.value {
AttributeValue::Listener(_) => {
+ let path = &vnode.template.get().attr_paths[idx];
+ let element_ref = ElementRef {
+ path: ElementPath { path },
+ template: vnode.stable_id().unwrap(),
+ scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
+ };
+ self.elements[id.0] = Some(element_ref);
self.mutations.push(NewEventListener {
// all listeners start with "on"
name: &unbounded_name[2..],
@@ -330,7 +387,7 @@ impl<'b> VirtualDom {
fn load_template_root(&mut self, template: &VNode, root_idx: usize) -> ElementId {
// Get an ID for this root since it's a real root
- let this_id = self.next_root(template, root_idx);
+ let this_id = self.next_element();
template.root_ids.borrow_mut()[root_idx] = this_id;
self.mutations.push(LoadTemplate {
@@ -353,8 +410,6 @@ impl<'b> VirtualDom {
&mut self,
path: &'static [u8],
this_id: ElementId,
- template: &VNode,
- attr_id: usize,
) -> ElementId {
if path.len() == 1 {
return this_id;
@@ -362,7 +417,7 @@ impl<'b> VirtualDom {
// if attribute is on a root node, then we've already created the element
// Else, it's deep in the template and we should create a new id for it
- let id = self.next_element(template, template.template.get().attr_paths[attr_id]);
+ let id = self.next_element();
self.mutations.push(Mutation::AssignId {
path: &path[1..],
@@ -405,6 +460,7 @@ impl<'b> VirtualDom {
#[allow(unused_mut)]
pub(crate) fn register_template(&mut self, mut template: Template<'static>) {
let (path, byte_index) = template.name.rsplit_once(':').unwrap();
+
let byte_index = byte_index.parse::().unwrap();
// First, check if we've already seen this template
if self
@@ -439,27 +495,21 @@ impl<'b> VirtualDom {
pub(crate) fn create_dynamic_node(
&mut self,
- template: &'b VNode<'b>,
+ parent: ElementRef,
node: &'b DynamicNode<'b>,
- idx: usize,
) -> usize {
use DynamicNode::*;
match node {
- Text(text) => self.create_dynamic_text(template, text, idx),
- Placeholder(place) => self.create_placeholder(place, template, idx),
- Component(component) => self.create_component_node(template, component),
- Fragment(frag) => frag.iter().map(|child| self.create(child)).sum(),
+ Text(text) => self.create_dynamic_text(parent, text),
+ Placeholder(place) => self.create_placeholder(place, parent),
+ Component(component) => self.create_component_node(Some(parent), component),
+ Fragment(frag) => self.create_children(*frag, Some(parent)),
}
}
- fn create_dynamic_text(
- &mut self,
- template: &'b VNode<'b>,
- text: &'b VText<'b>,
- idx: usize,
- ) -> usize {
+ fn create_dynamic_text(&mut self, parent: ElementRef, text: &'b VText<'b>) -> usize {
// Allocate a dynamic element reference for this text node
- let new_id = self.next_element(template, template.template.get().node_paths[idx]);
+ let new_id = self.next_element();
// Make sure the text node is assigned to the correct element
text.id.set(Some(new_id));
@@ -470,7 +520,7 @@ impl<'b> VirtualDom {
// Add the mutation to the list
self.mutations.push(HydrateText {
id: new_id,
- path: &template.template.get().node_paths[idx][1..],
+ path: &parent.path.path[1..],
value,
});
@@ -481,18 +531,20 @@ impl<'b> VirtualDom {
pub(crate) fn create_placeholder(
&mut self,
placeholder: &VPlaceholder,
- template: &'b VNode<'b>,
- idx: usize,
+ parent: ElementRef,
) -> usize {
// Allocate a dynamic element reference for this text node
- let id = self.next_element(template, template.template.get().node_paths[idx]);
+ let id = self.next_element();
// Make sure the text node is assigned to the correct element
placeholder.id.set(Some(id));
+ // Assign the placeholder's parent
+ placeholder.parent.set(Some(parent));
+
// Assign the ID to the existing node in the template
self.mutations.push(AssignId {
- path: &template.template.get().node_paths[idx][1..],
+ path: &parent.path.path[1..],
id,
});
@@ -502,7 +554,7 @@ impl<'b> VirtualDom {
pub(super) fn create_component_node(
&mut self,
- template: &'b VNode<'b>,
+ parent: Option,
component: &'b VComponent<'b>,
) -> usize {
use RenderReturn::*;
@@ -514,8 +566,11 @@ impl<'b> VirtualDom {
match unsafe { self.run_scope(scope).extend_lifetime_ref() } {
// Create the component's root element
- Ready(t) => self.create_scope(scope, t),
- Aborted(t) => self.mount_aborted(template, t),
+ Ready(t) => {
+ self.assign_boundary_ref(parent, t);
+ self.create_scope(scope, t)
+ }
+ Aborted(t) => self.mount_aborted(t, parent),
}
}
@@ -531,20 +586,17 @@ impl<'b> VirtualDom {
.unwrap_or_else(|| component.scope.get().unwrap())
}
- fn mount_aborted(&mut self, parent: &'b VNode<'b>, placeholder: &VPlaceholder) -> usize {
- let id = self.next_element(parent, &[]);
+ fn mount_aborted(&mut self, placeholder: &VPlaceholder, parent: Option) -> usize {
+ let id = self.next_element();
self.mutations.push(Mutation::CreatePlaceholder { id });
placeholder.id.set(Some(id));
+ placeholder.parent.set(parent);
+
1
}
- fn set_slot(
- &mut self,
- template: &'b VNode<'b>,
- slot: &'b Cell>,
- id: usize,
- ) -> ElementId {
- let id = self.next_element(template, template.template.get().node_paths[id]);
+ fn set_slot(&mut self, slot: &'b Cell>) -> ElementId {
+ let id = self.next_element();
slot.set(Some(id));
id
}
diff --git a/packages/core/src/diff.rs b/packages/core/src/diff.rs
index 74017db0f..a116aee4d 100644
--- a/packages/core/src/diff.rs
+++ b/packages/core/src/diff.rs
@@ -1,7 +1,10 @@
use crate::{
any_props::AnyProps,
arena::ElementId,
- innerlude::{BorrowedAttributeValue, DirtyScope, VComponent, VPlaceholder, VText},
+ innerlude::{
+ AttributeType, BorrowedAttributeValue, DirtyScope, ElementPath, ElementRef, VComponent,
+ VPlaceholder, VText,
+ },
mutations::Mutation,
nodes::RenderReturn,
nodes::{DynamicNode, VNode},
@@ -39,19 +42,27 @@ impl<'b> VirtualDom {
(Ready(l), Aborted(p)) => self.diff_ok_to_err(l, p),
// Just move over the placeholder
- (Aborted(l), Aborted(r)) => r.id.set(l.id.get()),
+ (Aborted(l), Aborted(r)) => {
+ r.id.set(l.id.get());
+ r.parent.set(l.parent.get())
+ }
// Placeholder becomes something
// We should also clear the error now
- (Aborted(l), Ready(r)) => self.replace_placeholder(l, [r]),
+ (Aborted(l), Ready(r)) => self.replace_placeholder(
+ l,
+ [r],
+ l.parent.get().expect("root node should not be none"),
+ ),
};
}
self.runtime.scope_stack.borrow_mut().pop();
}
fn diff_ok_to_err(&mut self, l: &'b VNode<'b>, p: &'b VPlaceholder) {
- let id = self.next_null();
+ let id = self.next_element();
p.id.set(Some(id));
+ p.parent.set(l.parent.get());
self.mutations.push(Mutation::CreatePlaceholder { id });
let pre_edits = self.mutations.edits.len();
@@ -81,12 +92,24 @@ impl<'b> VirtualDom {
if let Some(&template) = map.get(&byte_index) {
right_template.template.set(template);
if template != left_template.template.get() {
- return self.replace(left_template, [right_template]);
+ let parent = left_template.parent.take();
+ return self.replace(left_template, [right_template], parent);
}
}
}
}
+ // Copy over the parent
+ {
+ right_template.parent.set(left_template.parent.get());
+ }
+
+ // Update the bubble id pointer
+ right_template.stable_id.set(left_template.stable_id.get());
+ if let Some(bubble_id) = right_template.stable_id.get() {
+ self.set_template(bubble_id, right_template);
+ }
+
// If the templates are the same, we don't need to do anything, nor do we want to
if templates_are_the_same(left_template, right_template) {
return;
@@ -103,18 +126,54 @@ impl<'b> VirtualDom {
.dynamic_attrs
.iter()
.zip(right_template.dynamic_attrs.iter())
- .for_each(|(left_attr, right_attr)| {
+ .enumerate()
+ .for_each(|(idx, (left_attr, right_attr))| {
// Move over the ID from the old to the new
- right_attr
- .mounted_element
- .set(left_attr.mounted_element.get());
+ let mounted_id = left_attr.mounted_element.get();
+ right_attr.mounted_element.set(mounted_id);
- // We want to make sure anything that gets pulled is valid
- self.update_template(left_attr.mounted_element.get(), right_template);
+ match (&left_attr.ty, &right_attr.ty) {
+ (AttributeType::Single(left), AttributeType::Single(right)) => {
+ self.diff_attribute(left, right, mounted_id)
+ }
+ (AttributeType::Many(left), AttributeType::Many(right)) => {
+ let mut left_iter = left.iter().peekable();
+ let mut right_iter = right.iter().peekable();
- // If the attributes are different (or volatile), we need to update them
- if left_attr.value != right_attr.value || left_attr.volatile {
- self.update_attribute(right_attr, left_attr);
+ loop {
+ match (left_iter.peek(), right_iter.peek()) {
+ (Some(left), Some(right)) => {
+ // check which name is greater
+ match left.name.cmp(right.name) {
+ std::cmp::Ordering::Less => self.remove_attribute(
+ left.name,
+ left.namespace,
+ mounted_id,
+ ),
+ std::cmp::Ordering::Greater => self.write_attribute(
+ right_template,
+ right,
+ idx,
+ mounted_id,
+ ),
+ std::cmp::Ordering::Equal => {
+ self.diff_attribute(left, right, mounted_id)
+ }
+ }
+ }
+ (Some(_), None) => {
+ let left = left_iter.next().unwrap();
+ self.remove_attribute(left.name, left.namespace, mounted_id)
+ }
+ (None, Some(_)) => {
+ let right = right_iter.next().unwrap();
+ self.write_attribute(right_template, right, idx, mounted_id)
+ }
+ (None, None) => break,
+ }
+ }
+ }
+ _ => unreachable!("The macro should never generate this case"),
}
});
@@ -123,8 +182,16 @@ impl<'b> VirtualDom {
.dynamic_nodes
.iter()
.zip(right_template.dynamic_nodes.iter())
- .for_each(|(left_node, right_node)| {
- self.diff_dynamic_node(left_node, right_node, right_template);
+ .enumerate()
+ .for_each(|(dyn_node_idx, (left_node, right_node))| {
+ let current_ref = ElementRef {
+ template: right_template.stable_id().unwrap(),
+ path: ElementPath {
+ path: left_template.template.get().node_paths[dyn_node_idx],
+ },
+ scope: self.runtime.scope_stack.borrow().last().copied().unwrap(),
+ };
+ self.diff_dynamic_node(left_node, right_node, current_ref);
});
// Make sure the roots get transferred over while we're here
@@ -135,14 +202,17 @@ impl<'b> VirtualDom {
right.push(element);
}
}
+ }
- let root_ids = right_template.root_ids.borrow();
-
- // Update the node refs
- for i in 0..root_ids.len() {
- if let Some(root_id) = root_ids.get(i) {
- self.update_template(*root_id, right_template);
- }
+ fn diff_attribute(
+ &mut self,
+ left_attr: &'b Attribute<'b>,
+ right_attr: &'b Attribute<'b>,
+ id: ElementId,
+ ) {
+ // If the attributes are different (or volatile), we need to update them
+ if left_attr.value != right_attr.value || left_attr.volatile {
+ self.update_attribute(right_attr, left_attr, id);
}
}
@@ -150,25 +220,45 @@ impl<'b> VirtualDom {
&mut self,
left_node: &'b DynamicNode<'b>,
right_node: &'b DynamicNode<'b>,
- node: &'b VNode<'b>,
+ parent: ElementRef,
) {
match (left_node, right_node) {
- (Text(left), Text(right)) => self.diff_vtext(left, right, node),
- (Fragment(left), Fragment(right)) => self.diff_non_empty_fragment(left, right),
- (Placeholder(left), Placeholder(right)) => right.id.set(left.id.get()),
- (Component(left), Component(right)) => self.diff_vcomponent(left, right, node),
- (Placeholder(left), Fragment(right)) => self.replace_placeholder(left, *right),
- (Fragment(left), Placeholder(right)) => self.node_to_placeholder(left, right),
+ (Text(left), Text(right)) => self.diff_vtext(left, right),
+ (Fragment(left), Fragment(right)) => self.diff_non_empty_fragment(left, right, parent),
+ (Placeholder(left), Placeholder(right)) => {
+ right.id.set(left.id.get());
+ right.parent.set(left.parent.get());
+ },
+ (Component(left), Component(right)) => self.diff_vcomponent(left, right, Some(parent)),
+ (Placeholder(left), Fragment(right)) => self.replace_placeholder(left, *right, parent),
+ (Fragment(left), Placeholder(right)) => self.node_to_placeholder(left, right, parent),
_ => todo!("This is an usual custom case for dynamic nodes. We don't know how to handle it yet."),
};
}
- fn update_attribute(&mut self, right_attr: &'b Attribute<'b>, left_attr: &'b Attribute) {
+ fn remove_attribute(&mut self, name: &'b str, ns: Option<&'static str>, id: ElementId) {
+ let name = unsafe { std::mem::transmute(name) };
+ let value: BorrowedAttributeValue<'b> = BorrowedAttributeValue::None;
+ let value = unsafe { std::mem::transmute(value) };
+ self.mutations.push(Mutation::SetAttribute {
+ id,
+ ns,
+ name,
+ value,
+ });
+ }
+
+ fn update_attribute(
+ &mut self,
+ right_attr: &'b Attribute<'b>,
+ left_attr: &'b Attribute<'b>,
+ id: ElementId,
+ ) {
let name = unsafe { std::mem::transmute(left_attr.name) };
let value: BorrowedAttributeValue<'b> = (&right_attr.value).into();
let value = unsafe { std::mem::transmute(value) };
self.mutations.push(Mutation::SetAttribute {
- id: left_attr.mounted_element.get(),
+ id,
ns: right_attr.namespace,
name,
value,
@@ -179,7 +269,7 @@ impl<'b> VirtualDom {
&mut self,
left: &'b VComponent<'b>,
right: &'b VComponent<'b>,
- right_template: &'b VNode<'b>,
+ parent: Option,
) {
if std::ptr::eq(left, right) {
return;
@@ -187,7 +277,7 @@ impl<'b> VirtualDom {
// Replace components that have different render fns
if left.render_fn != right.render_fn {
- return self.replace_vcomponent(right_template, right, left);
+ return self.replace_vcomponent(right, left, parent);
}
// Make sure the new vcomponent has the right scopeid associated to it
@@ -228,11 +318,11 @@ impl<'b> VirtualDom {
fn replace_vcomponent(
&mut self,
- right_template: &'b VNode<'b>,
right: &'b VComponent<'b>,
left: &'b VComponent<'b>,
+ parent: Option,
) {
- let m = self.create_component_node(right_template, right);
+ let m = self.create_component_node(parent, right);
let pre_edits = self.mutations.edits.len();
@@ -287,11 +377,12 @@ impl<'b> VirtualDom {
/// }
/// ```
fn light_diff_templates(&mut self, left: &'b VNode<'b>, right: &'b VNode<'b>) {
+ let parent = left.parent.take();
match matching_components(left, right) {
- None => self.replace(left, [right]),
+ None => self.replace(left, [right], parent),
Some(components) => components
.into_iter()
- .for_each(|(l, r)| self.diff_vcomponent(l, r, right)),
+ .for_each(|(l, r)| self.diff_vcomponent(l, r, parent)),
}
}
@@ -299,11 +390,8 @@ impl<'b> VirtualDom {
///
/// This just moves the ID of the old node over to the new node, and then sets the text of the new node if it's
/// different.
- fn diff_vtext(&mut self, left: &'b VText<'b>, right: &'b VText<'b>, node: &'b VNode<'b>) {
- let id = left
- .id
- .get()
- .unwrap_or_else(|| self.next_element(node, &[0]));
+ fn diff_vtext(&mut self, left: &'b VText<'b>, right: &'b VText<'b>) {
+ let id = left.id.get().unwrap_or_else(|| self.next_element());
right.id.set(Some(id));
if left.value != right.value {
@@ -312,7 +400,12 @@ impl<'b> VirtualDom {
}
}
- fn diff_non_empty_fragment(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
+ fn diff_non_empty_fragment(
+ &mut self,
+ old: &'b [VNode<'b>],
+ new: &'b [VNode<'b>],
+ parent: ElementRef,
+ ) {
let new_is_keyed = new[0].key.is_some();
let old_is_keyed = old[0].key.is_some();
debug_assert!(
@@ -325,9 +418,9 @@ impl<'b> VirtualDom {
);
if new_is_keyed && old_is_keyed {
- self.diff_keyed_children(old, new);
+ self.diff_keyed_children(old, new, parent);
} else {
- self.diff_non_keyed_children(old, new);
+ self.diff_non_keyed_children(old, new, parent);
}
}
@@ -339,7 +432,12 @@ impl<'b> VirtualDom {
// [... parent]
//
// the change list stack is in the same state when this function returns.
- fn diff_non_keyed_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
+ fn diff_non_keyed_children(
+ &mut self,
+ old: &'b [VNode<'b>],
+ new: &'b [VNode<'b>],
+ parent: ElementRef,
+ ) {
use std::cmp::Ordering;
// Handled these cases in `diff_children` before calling this function.
@@ -348,7 +446,9 @@ impl<'b> VirtualDom {
match old.len().cmp(&new.len()) {
Ordering::Greater => self.remove_nodes(&old[new.len()..]),
- Ordering::Less => self.create_and_insert_after(&new[old.len()..], old.last().unwrap()),
+ Ordering::Less => {
+ self.create_and_insert_after(&new[old.len()..], old.last().unwrap(), parent)
+ }
Ordering::Equal => {}
}
@@ -373,7 +473,12 @@ impl<'b> VirtualDom {
// https://github.com/infernojs/inferno/blob/36fd96/packages/inferno/src/DOM/patching.ts#L530-L739
//
// The stack is empty upon entry.
- fn diff_keyed_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
+ fn diff_keyed_children(
+ &mut self,
+ old: &'b [VNode<'b>],
+ new: &'b [VNode<'b>],
+ parent: ElementRef,
+ ) {
if cfg!(debug_assertions) {
let mut keys = rustc_hash::FxHashSet::default();
let mut assert_unique_keys = |children: &'b [VNode<'b>]| {
@@ -401,7 +506,7 @@ impl<'b> VirtualDom {
//
// `shared_prefix_count` is the count of how many nodes at the start of
// `new` and `old` share the same keys.
- let (left_offset, right_offset) = match self.diff_keyed_ends(old, new) {
+ let (left_offset, right_offset) = match self.diff_keyed_ends(old, new, parent) {
Some(count) => count,
None => return,
};
@@ -427,18 +532,18 @@ impl<'b> VirtualDom {
if left_offset == 0 {
// insert at the beginning of the old list
let foothold = &old[old.len() - right_offset];
- self.create_and_insert_before(new_middle, foothold);
+ self.create_and_insert_before(new_middle, foothold, parent);
} else if right_offset == 0 {
// insert at the end the old list
let foothold = old.last().unwrap();
- self.create_and_insert_after(new_middle, foothold);
+ self.create_and_insert_after(new_middle, foothold, parent);
} else {
// inserting in the middle
let foothold = &old[left_offset - 1];
- self.create_and_insert_after(new_middle, foothold);
+ self.create_and_insert_after(new_middle, foothold, parent);
}
} else {
- self.diff_keyed_middle(old_middle, new_middle);
+ self.diff_keyed_middle(old_middle, new_middle, parent);
}
}
@@ -451,6 +556,7 @@ impl<'b> VirtualDom {
&mut self,
old: &'b [VNode<'b>],
new: &'b [VNode<'b>],
+ parent: ElementRef,
) -> Option<(usize, usize)> {
let mut left_offset = 0;
@@ -466,7 +572,7 @@ impl<'b> VirtualDom {
// If that was all of the old children, then create and append the remaining
// new children and we're finished.
if left_offset == old.len() {
- self.create_and_insert_after(&new[left_offset..], old.last().unwrap());
+ self.create_and_insert_after(&new[left_offset..], old.last().unwrap(), parent);
return None;
}
@@ -505,7 +611,12 @@ impl<'b> VirtualDom {
//
// Upon exit from this function, it will be restored to that same self.
#[allow(clippy::too_many_lines)]
- fn diff_keyed_middle(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
+ fn diff_keyed_middle(
+ &mut self,
+ old: &'b [VNode<'b>],
+ new: &'b [VNode<'b>],
+ parent: ElementRef,
+ ) {
/*
1. Map the old keys into a numerical ordering based on indices.
2. Create a map of old key to its index
@@ -560,9 +671,9 @@ impl<'b> VirtualDom {
// If none of the old keys are reused by the new children, then we remove all the remaining old children and
// create the new children afresh.
if shared_keys.is_empty() {
- if old.get(0).is_some() {
+ if !old.is_empty() {
self.remove_nodes(&old[1..]);
- self.replace(&old[0], new);
+ self.replace(&old[0], new, Some(parent));
} else {
// I think this is wrong - why are we appending?
// only valid of the if there are no trailing elements
@@ -739,20 +850,38 @@ impl<'b> VirtualDom {
.sum()
}
- fn create_children(&mut self, nodes: impl IntoIterator
- >) -> usize {
+ pub(crate) fn create_children(
+ &mut self,
+ nodes: impl IntoIterator
- >,
+ parent: Option,
+ ) -> usize {
nodes
.into_iter()
- .fold(0, |acc, child| acc + self.create(child))
+ .map(|child| {
+ self.assign_boundary_ref(parent, child);
+ self.create(child)
+ })
+ .sum()
}
- fn create_and_insert_before(&mut self, new: &'b [VNode<'b>], before: &'b VNode<'b>) {
- let m = self.create_children(new);
+ fn create_and_insert_before(
+ &mut self,
+ new: &'b [VNode<'b>],
+ before: &'b VNode<'b>,
+ parent: ElementRef,
+ ) {
+ let m = self.create_children(new, Some(parent));
let id = self.find_first_element(before);
self.mutations.push(Mutation::InsertBefore { id, m })
}
- fn create_and_insert_after(&mut self, new: &'b [VNode<'b>], after: &'b VNode<'b>) {
- let m = self.create_children(new);
+ fn create_and_insert_after(
+ &mut self,
+ new: &'b [VNode<'b>],
+ after: &'b VNode<'b>,
+ parent: ElementRef,
+ ) {
+ let m = self.create_children(new, Some(parent));
let id = self.find_last_element(after);
self.mutations.push(Mutation::InsertAfter { id, m })
}
@@ -762,15 +891,21 @@ impl<'b> VirtualDom {
&mut self,
l: &'b VPlaceholder,
r: impl IntoIterator
- >,
+ parent: ElementRef,
) {
- let m = self.create_children(r);
+ let m = self.create_children(r, Some(parent));
let id = l.id.get().unwrap();
self.mutations.push(Mutation::ReplaceWith { id, m });
self.reclaim(id);
}
- fn replace(&mut self, left: &'b VNode<'b>, right: impl IntoIterator
- >) {
- let m = self.create_children(right);
+ fn replace(
+ &mut self,
+ left: &'b VNode<'b>,
+ right: impl IntoIterator
- >,
+ parent: Option,
+ ) {
+ let m = self.create_children(right, parent);
let pre_edits = self.mutations.edits.len();
@@ -789,11 +924,12 @@ impl<'b> VirtualDom {
};
}
- fn node_to_placeholder(&mut self, l: &'b [VNode<'b>], r: &'b VPlaceholder) {
+ fn node_to_placeholder(&mut self, l: &'b [VNode<'b>], r: &'b VPlaceholder, parent: ElementRef) {
// Create the placeholder first, ensuring we get a dedicated ID for the placeholder
- let placeholder = self.next_element(&l[0], &[]);
+ let placeholder = self.next_element();
r.id.set(Some(placeholder));
+ r.parent.set(Some(parent));
self.mutations
.push(Mutation::CreatePlaceholder { id: placeholder });
@@ -831,6 +967,16 @@ impl<'b> VirtualDom {
// Clean up the roots, assuming we need to generate mutations for these
// This is done last in order to preserve Node ID reclaim order (reclaim in reverse order of claim)
self.reclaim_roots(node, gen_muts);
+
+ // Clean up the vnode id
+ self.reclaim_vnode_id(node);
+ }
+
+ fn reclaim_vnode_id(&mut self, node: &'b VNode<'b>) {
+ // Clean up the vnode id
+ if let Some(id) = node.stable_id() {
+ self.element_refs.remove(id.0);
+ }
}
fn reclaim_roots(&mut self, node: &VNode, gen_muts: bool) {
@@ -989,6 +1135,13 @@ impl<'b> VirtualDom {
}
}
}
+
+ pub(crate) fn assign_boundary_ref(&mut self, parent: Option, child: &'b VNode<'b>) {
+ if let Some(parent) = parent {
+ // assign the parent of the child
+ child.parent.set(Some(parent));
+ }
+ }
}
/// Are the templates the same?
diff --git a/packages/core/src/error_boundary.rs b/packages/core/src/error_boundary.rs
index 819d2f99e..26155704b 100644
--- a/packages/core/src/error_boundary.rs
+++ b/packages/core/src/error_boundary.rs
@@ -1,25 +1,68 @@
-use crate::{ScopeId, ScopeState};
+use crate::{
+ scope_context::{consume_context, current_scope_id, schedule_update_any},
+ Element, IntoDynNode, LazyNodes, Properties, Scope, ScopeId, ScopeState, Template,
+ TemplateAttribute, TemplateNode, VNode,
+};
use std::{
any::{Any, TypeId},
- cell::RefCell,
- fmt::Debug,
+ backtrace::Backtrace,
+ cell::{Cell, RefCell},
+ error::Error,
+ fmt::{Debug, Display},
+ rc::Rc,
+ sync::Arc,
};
-/// A boundary that will capture any errors from child components
-pub struct ErrorBoundary {
- error: RefCell>,
- _id: ScopeId,
+/// Provide an error boundary to catch errors from child components
+pub fn use_error_boundary(cx: &ScopeState) -> &ErrorBoundary {
+ cx.use_hook(|| cx.provide_context(ErrorBoundary::new()))
}
+/// A boundary that will capture any errors from child components
+#[derive(Debug, Clone, Default)]
+pub struct ErrorBoundary {
+ inner: Rc,
+}
+
+/// A boundary that will capture any errors from child components
+pub struct ErrorBoundaryInner {
+ error: RefCell>,
+ _id: ScopeId,
+ rerun_boundary: Arc,
+}
+
+impl Debug for ErrorBoundaryInner {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("ErrorBoundaryInner")
+ .field("error", &self.error)
+ .finish()
+ }
+}
+
+#[derive(Debug)]
/// An instance of an error captured by a descendant component.
pub struct CapturedError {
/// The error captured by the error boundary
pub error: Box,
+ /// The backtrace of the error
+ pub backtrace: Backtrace,
+
/// The scope that threw the error
pub scope: ScopeId,
}
+impl Display for CapturedError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_fmt(format_args!(
+ "Encountered error: {:?}\nIn scope: {:?}\nBacktrace: {}",
+ self.error, self.scope, self.backtrace
+ ))
+ }
+}
+
+impl Error for CapturedError {}
+
impl CapturedError {
/// Downcast the error type into a concrete error type
pub fn downcast(&self) -> Option<&T> {
@@ -32,17 +75,56 @@ impl CapturedError {
}
}
-impl ErrorBoundary {
- pub fn new(id: ScopeId) -> Self {
+impl Default for ErrorBoundaryInner {
+ fn default() -> Self {
Self {
error: RefCell::new(None),
- _id: id,
+ _id: current_scope_id()
+ .expect("Cannot create an error boundary outside of a component's scope."),
+ rerun_boundary: schedule_update_any().unwrap(),
+ }
+ }
+}
+
+impl ErrorBoundary {
+ /// Create a new error boundary
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Create a new error boundary in the current scope
+ pub(crate) fn new_in_scope(
+ scope: ScopeId,
+ rerun_boundary: Arc,
+ ) -> Self {
+ Self {
+ inner: Rc::new(ErrorBoundaryInner {
+ error: RefCell::new(None),
+ _id: scope,
+ rerun_boundary,
+ }),
}
}
/// Push an error into this Error Boundary
- pub fn insert_error(&self, scope: ScopeId, error: Box) {
- self.error.replace(Some(CapturedError { error, scope }));
+ pub fn insert_error(
+ &self,
+ scope: ScopeId,
+ error: Box,
+ backtrace: Backtrace,
+ ) {
+ println!("{:?} {:?}", error, self.inner._id);
+ self.inner.error.replace(Some(CapturedError {
+ error,
+ scope,
+ backtrace,
+ }));
+ (self.inner.rerun_boundary)(self.inner._id);
+ }
+
+ /// Take any error that has been captured by this error boundary
+ pub fn take_error(&self) -> Option {
+ self.inner.error.take()
}
}
@@ -59,7 +141,7 @@ impl ErrorBoundary {
/// ```rust, ignore
/// #[component]
/// fn App(cx: Scope, count: String) -> Element {
-/// let id: i32 = count.parse().throw(cx)?;
+/// let id: i32 = count.parse().throw()?;
///
/// cx.render(rsx! {
/// div { "Count {}" }
@@ -84,14 +166,14 @@ pub trait Throw
: Sized {
/// ```rust, ignore
/// #[component]
/// fn App(cx: Scope, count: String) -> Element {
- /// let id: i32 = count.parse().throw(cx)?;
+ /// let id: i32 = count.parse().throw()?;
///
/// cx.render(rsx! {
/// div { "Count {}" }
/// })
/// }
/// ```
- fn throw(self, cx: &ScopeState) -> Option;
+ fn throw(self) -> Option;
/// Returns an option that evaluates to None if there is an error, injecting the error to the nearest error boundary.
///
@@ -107,45 +189,46 @@ pub trait Throw: Sized {
/// ```rust, ignore
/// #[component]
/// fn App(cx: Scope, count: String) -> Element {
- /// let id: i32 = count.parse().throw(cx)?;
+ /// let id: i32 = count.parse().throw()?;
///
/// cx.render(rsx! {
/// div { "Count {}" }
/// })
/// }
/// ```
- fn throw_with(
- self,
- cx: &ScopeState,
- e: impl FnOnce() -> D,
- ) -> Option;
+ fn throw_with(self, e: impl FnOnce() -> D) -> Option {
+ self.throw().or_else(|| throw_error(e()))
+ }
+}
+
+fn throw_error(e: impl Debug + 'static) -> Option {
+ if let Some(cx) = consume_context::() {
+ match current_scope_id() {
+ Some(id) => cx.insert_error(id, Box::new(e), Backtrace::capture()),
+ None => {
+ tracing::error!("Cannot throw error outside of a component's scope.")
+ }
+ }
+ }
+
+ None
}
/// We call clone on any errors that can be owned out of a reference
impl<'a, T, O: Debug + 'static, E: ToOwned> Throw for &'a Result {
type Out = &'a T;
- fn throw(self, cx: &ScopeState) -> Option {
+ fn throw(self) -> Option {
match self {
Ok(t) => Some(t),
- Err(e) => {
- cx.throw(e.to_owned());
- None
- }
+ Err(e) => throw_error(e.to_owned()),
}
}
- fn throw_with(
- self,
- cx: &ScopeState,
- err: impl FnOnce() -> D,
- ) -> Option {
+ fn throw_with(self, err: impl FnOnce() -> D) -> Option {
match self {
Ok(t) => Some(t),
- Err(_e) => {
- cx.throw(err());
- None
- }
+ Err(_e) => throw_error(err()),
}
}
}
@@ -154,25 +237,15 @@ impl<'a, T, O: Debug + 'static, E: ToOwned> Throw for &'a Result Throw for Result {
type Out = T;
- fn throw(self, cx: &ScopeState) -> Option {
+ fn throw(self) -> Option {
match self {
Ok(t) => Some(t),
- Err(e) => {
- cx.throw(e);
- None
- }
+ Err(e) => throw_error(e),
}
}
- fn throw_with(
- self,
- cx: &ScopeState,
- error: impl FnOnce() -> D,
- ) -> Option {
- self.ok().or_else(|| {
- cx.throw(error());
- None
- })
+ fn throw_with(self, error: impl FnOnce() -> D) -> Option {
+ self.ok().or_else(|| throw_error(error()))
}
}
@@ -180,21 +253,236 @@ impl Throw for Result {
impl Throw for Option {
type Out = T;
- fn throw(self, cx: &ScopeState) -> Option {
- self.or_else(|| {
- cx.throw("None error.");
- None
- })
+ fn throw(self) -> Option {
+ self.or_else(|| throw_error("Attempted to unwrap a None value."))
}
- fn throw_with(
- self,
- cx: &ScopeState,
- error: impl FnOnce() -> D,
- ) -> Option {
- self.or_else(|| {
- cx.throw(error());
- None
- })
+ fn throw_with(self, error: impl FnOnce() -> D) -> Option {
+ self.or_else(|| throw_error(error()))
+ }
+}
+
+pub struct ErrorHandler<'a>(Box LazyNodes<'a, 'a> + 'a>);
+impl<'a, F: Fn(CapturedError) -> LazyNodes<'a, 'a> + 'a> From for ErrorHandler<'a> {
+ fn from(value: F) -> Self {
+ Self(Box::new(value))
+ }
+}
+fn default_handler<'a>(error: CapturedError) -> LazyNodes<'a, 'a> {
+ LazyNodes::new(move |__cx: &ScopeState| -> VNode {
+ static TEMPLATE: Template = Template {
+ name: "error_handle.rs:42:5:884",
+ roots: &[TemplateNode::Element {
+ tag: "pre",
+ namespace: None,
+ attrs: &[TemplateAttribute::Static {
+ name: "color",
+ namespace: Some("style"),
+ value: "red",
+ }],
+ children: &[TemplateNode::DynamicText { id: 0usize }],
+ }],
+ node_paths: &[&[0u8, 0u8]],
+ attr_paths: &[],
+ };
+ VNode {
+ parent: Default::default(),
+ stable_id: Default::default(),
+ key: None,
+ template: std::cell::Cell::new(TEMPLATE),
+ root_ids: bumpalo::collections::Vec::with_capacity_in(1usize, __cx.bump()).into(),
+ dynamic_nodes: __cx
+ .bump()
+ .alloc([__cx.text_node(format_args!("{0}", error))]),
+ dynamic_attrs: __cx.bump().alloc([]),
+ }
+ })
+}
+pub struct ErrorBoundaryProps<'a> {
+ children: Element<'a>,
+ handle_error: ErrorHandler<'a>,
+}
+impl<'a> ErrorBoundaryProps<'a> {
+ /**
+ Create a builder for building `ErrorBoundaryProps`.
+ On the builder, call `.children(...)`(optional), `.handle_error(...)`(optional) to set the values of the fields.
+ Finally, call `.build()` to create the instance of `ErrorBoundaryProps`.
+ */
+ #[allow(dead_code)]
+ pub fn builder() -> ErrorBoundaryPropsBuilder<'a, ((), ())> {
+ ErrorBoundaryPropsBuilder {
+ fields: ((), ()),
+ _phantom: ::core::default::Default::default(),
+ }
+ }
+}
+#[must_use]
+#[doc(hidden)]
+#[allow(dead_code, non_camel_case_types, non_snake_case)]
+pub struct ErrorBoundaryPropsBuilder<'a, TypedBuilderFields> {
+ fields: TypedBuilderFields,
+ _phantom: ::core::marker::PhantomData<&'a ()>,
+}
+impl<'a, TypedBuilderFields> Clone for ErrorBoundaryPropsBuilder<'a, TypedBuilderFields>
+where
+ TypedBuilderFields: Clone,
+{
+ fn clone(&self) -> Self {
+ Self {
+ fields: self.fields.clone(),
+ _phantom: ::core::default::Default::default(),
+ }
+ }
+}
+impl<'a> Properties<'a> for ErrorBoundaryProps<'a> {
+ type Builder = ErrorBoundaryPropsBuilder<'a, ((), ())>;
+ const IS_STATIC: bool = false;
+ fn builder(_: &'a ScopeState) -> Self::Builder {
+ ErrorBoundaryProps::builder()
+ }
+ unsafe fn memoize(&self, _: &Self) -> bool {
+ false
+ }
+}
+#[doc(hidden)]
+#[allow(dead_code, non_camel_case_types, non_snake_case)]
+pub trait ErrorBoundaryPropsBuilder_Optional {
+ fn into_value T>(self, default: F) -> T;
+}
+impl ErrorBoundaryPropsBuilder_Optional for () {
+ fn into_value T>(self, default: F) -> T {
+ default()
+ }
+}
+impl ErrorBoundaryPropsBuilder_Optional for (T,) {
+ fn into_value T>(self, _: F) -> T {
+ self.0
+ }
+}
+#[allow(dead_code, non_camel_case_types, missing_docs)]
+impl<'a, __handle_error> ErrorBoundaryPropsBuilder<'a, ((), __handle_error)> {
+ pub fn children(
+ self,
+ children: Element<'a>,
+ ) -> ErrorBoundaryPropsBuilder<'a, ((Element<'a>,), __handle_error)> {
+ let children = (children,);
+ let (_, handle_error) = self.fields;
+ ErrorBoundaryPropsBuilder {
+ fields: (children, handle_error),
+ _phantom: self._phantom,
+ }
+ }
+}
+#[doc(hidden)]
+#[allow(dead_code, non_camel_case_types, non_snake_case)]
+pub enum ErrorBoundaryPropsBuilder_Error_Repeated_field_children {}
+#[doc(hidden)]
+#[allow(dead_code, non_camel_case_types, missing_docs)]
+impl<'a, __handle_error> ErrorBoundaryPropsBuilder<'a, ((Element<'a>,), __handle_error)> {
+ #[deprecated(note = "Repeated field children")]
+ pub fn children(
+ self,
+ _: ErrorBoundaryPropsBuilder_Error_Repeated_field_children,
+ ) -> ErrorBoundaryPropsBuilder<'a, ((Element<'a>,), __handle_error)> {
+ self
+ }
+}
+#[allow(dead_code, non_camel_case_types, missing_docs)]
+impl<'a, __children> ErrorBoundaryPropsBuilder<'a, (__children, ())> {
+ pub fn handle_error(
+ self,
+ handle_error: impl ::core::convert::Into