(root: Component, props: P, cfg: Config)
// iOS panics if we create a window before the event loop is started
let props = Rc::new(Cell::new(Some(props)));
let cfg = Rc::new(Cell::new(Some(cfg)));
+ let mut is_visible_before_start = true;
event_loop.run(move |window_event, event_loop, control_flow| {
*control_flow = ControlFlow::Wait;
@@ -214,6 +217,8 @@ pub fn launch_with_props(root: Component, props: P, cfg: Config)
// Create a dom
let dom = VirtualDom::new_with_props(root, props);
+ is_visible_before_start = cfg.window.window.visible;
+
let handler = create_new_window(
cfg,
event_loop,
@@ -327,6 +332,10 @@ pub fn launch_with_props(root: Component, props: P, cfg: Config)
EventData::Ipc(msg) if msg.method() == "initialize" => {
let view = webviews.get_mut(&event.1).unwrap();
send_edits(view.dom.rebuild(), &view.desktop_context.webview);
+ view.desktop_context
+ .webview
+ .window()
+ .set_visible(is_visible_before_start);
}
EventData::Ipc(msg) if msg.method() == "browser_open" => {
diff --git a/packages/desktop/src/webview.rs b/packages/desktop/src/webview.rs
index 47ff8e1f5..7f12562ce 100644
--- a/packages/desktop/src/webview.rs
+++ b/packages/desktop/src/webview.rs
@@ -13,7 +13,7 @@ pub fn build(
proxy: EventLoopProxy,
) -> (WebView, WebContext) {
let builder = cfg.window.clone();
- let window = builder.build(event_loop).unwrap();
+ let window = builder.with_visible(false).build(event_loop).unwrap();
let file_handler = cfg.file_drop_handler.take();
let custom_head = cfg.custom_head.clone();
let index_file = cfg.custom_index.clone();
diff --git a/packages/dioxus-tui/examples/colorpicker.rs b/packages/dioxus-tui/examples/colorpicker.rs
index 00f8ef7e0..01cc38cda 100644
--- a/packages/dioxus-tui/examples/colorpicker.rs
+++ b/packages/dioxus-tui/examples/colorpicker.rs
@@ -15,21 +15,21 @@ fn app(cx: Scope) -> Element {
let mapping: DioxusElementToNodeId = cx.consume_context().unwrap();
// disable templates so that every node has an id and can be queried
cx.render(rsx! {
- div{
+ div {
width: "100%",
background_color: "hsl({hue}, 70%, {brightness}%)",
onmousemove: move |evt| {
if let RenderReturn::Ready(node) = cx.root_node() {
- if let Some(id) = node.root_ids.borrow().get(0).cloned() {
+ if let Some(id) = node.root_ids.borrow().first().cloned() {
let node = tui_query.get(mapping.get_node_id(id).unwrap());
- let Size{width, height} = node.size().unwrap();
+ let Size { width, height } = node.size().unwrap();
let pos = evt.inner().element_coordinates();
- hue.set((pos.x as f32/width as f32)*255.0);
- brightness.set((pos.y as f32/height as f32)*100.0);
+ hue.set((pos.x as f32 / width as f32) * 255.0);
+ brightness.set((pos.y as f32 / height as f32) * 100.0);
}
}
},
- "hsl({hue}, 70%, {brightness}%)",
+ "hsl({hue}, 70%, {brightness}%)"
}
})
}
diff --git a/packages/extension/src/lib.rs b/packages/extension/src/lib.rs
index abcdaf598..fb9cca8a9 100644
--- a/packages/extension/src/lib.rs
+++ b/packages/extension/src/lib.rs
@@ -1,17 +1,39 @@
//! This file exports functions into the vscode extension
-use dioxus_autofmt::FormattedBlock;
+use dioxus_autofmt::{FormattedBlock, IndentOptions, IndentType};
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
-pub fn format_rsx(raw: String) -> String {
- let block = dioxus_autofmt::fmt_block(&raw, 0);
+pub fn format_rsx(raw: String, use_tabs: bool, indent_size: usize) -> String {
+ let block = dioxus_autofmt::fmt_block(
+ &raw,
+ 0,
+ IndentOptions::new(
+ if use_tabs {
+ IndentType::Tabs
+ } else {
+ IndentType::Spaces
+ },
+ indent_size,
+ ),
+ );
block.unwrap()
}
#[wasm_bindgen]
-pub fn format_selection(raw: String) -> String {
- let block = dioxus_autofmt::fmt_block(&raw, 0);
+pub fn format_selection(raw: String, use_tabs: bool, indent_size: usize) -> String {
+ let block = dioxus_autofmt::fmt_block(
+ &raw,
+ 0,
+ IndentOptions::new(
+ if use_tabs {
+ IndentType::Tabs
+ } else {
+ IndentType::Spaces
+ },
+ indent_size,
+ ),
+ );
block.unwrap()
}
@@ -35,8 +57,18 @@ impl FormatBlockInstance {
}
#[wasm_bindgen]
-pub fn format_file(contents: String) -> FormatBlockInstance {
- let _edits = dioxus_autofmt::fmt_file(&contents);
+pub fn format_file(contents: String, use_tabs: bool, indent_size: usize) -> FormatBlockInstance {
+ let _edits = dioxus_autofmt::fmt_file(
+ &contents,
+ IndentOptions::new(
+ if use_tabs {
+ IndentType::Tabs
+ } else {
+ IndentType::Spaces
+ },
+ indent_size,
+ ),
+ );
let out = dioxus_autofmt::apply_formats(&contents, _edits.clone());
FormatBlockInstance { new: out, _edits }
}
diff --git a/packages/extension/src/main.ts b/packages/extension/src/main.ts
index fc12457ad..76b7261f1 100644
--- a/packages/extension/src/main.ts
+++ b/packages/extension/src/main.ts
@@ -90,7 +90,13 @@ function fmtDocument(document: vscode.TextDocument) {
if (!editor) return; // Need an editor to apply text edits.
const contents = editor.document.getText();
- const formatted = dioxus.format_file(contents);
+ let tabSize: number;
+ if (typeof editor.options.tabSize === 'number') {
+ tabSize = editor.options.tabSize;
+ } else {
+ tabSize = 4;
+ }
+ const formatted = dioxus.format_file(contents, !editor.options.insertSpaces, tabSize);
// Replace the entire text document
// Yes, this is a bit heavy handed, but the dioxus side doesn't know the line/col scheme that vscode is using
diff --git a/packages/fermi/src/callback.rs b/packages/fermi/src/callback.rs
index a7ca9155f..bb9f61bf2 100644
--- a/packages/fermi/src/callback.rs
+++ b/packages/fermi/src/callback.rs
@@ -28,6 +28,7 @@ impl CallbackApi {
}
}
+#[must_use]
pub fn use_atom_context(cx: &ScopeState) -> &CallbackApi {
todo!()
}
diff --git a/packages/fermi/src/hooks/atom_ref.rs b/packages/fermi/src/hooks/atom_ref.rs
index 74dd9268b..8dbeb2c4d 100644
--- a/packages/fermi/src/hooks/atom_ref.rs
+++ b/packages/fermi/src/hooks/atom_ref.rs
@@ -13,6 +13,7 @@ use std::{
///
///
///
+#[must_use]
pub fn use_atom_ref<'a, T: 'static>(
cx: &'a ScopeState,
atom: &'static AtomRef,
diff --git a/packages/fermi/src/hooks/atom_root.rs b/packages/fermi/src/hooks/atom_root.rs
index 24fd70093..468f5f980 100644
--- a/packages/fermi/src/hooks/atom_root.rs
+++ b/packages/fermi/src/hooks/atom_root.rs
@@ -7,6 +7,6 @@ use dioxus_core::ScopeState;
pub fn use_atom_root(cx: &ScopeState) -> &Rc {
cx.use_hook(|| match cx.consume_context::>() {
Some(root) => root,
- None => panic!("No atom root found in context. Did you forget place an AtomRoot component at the top of your app?"),
+ None => panic!("No atom root found in context. Did you forget to call use_init_atom_root at the top of your app?"),
})
}
diff --git a/packages/fermi/src/hooks/read.rs b/packages/fermi/src/hooks/read.rs
index 57a544e93..c2538c74d 100644
--- a/packages/fermi/src/hooks/read.rs
+++ b/packages/fermi/src/hooks/read.rs
@@ -2,10 +2,12 @@ use crate::{use_atom_root, AtomId, AtomRoot, Readable};
use dioxus_core::{ScopeId, ScopeState};
use std::rc::Rc;
+#[must_use]
pub fn use_read(cx: &ScopeState, f: impl Readable) -> &V {
use_read_rc(cx, f).as_ref()
}
+#[must_use]
pub fn use_read_rc(cx: &ScopeState, f: impl Readable) -> &Rc {
let root = use_atom_root(cx);
diff --git a/packages/fermi/src/hooks/set.rs b/packages/fermi/src/hooks/set.rs
index 5e5141227..89fe48b0f 100644
--- a/packages/fermi/src/hooks/set.rs
+++ b/packages/fermi/src/hooks/set.rs
@@ -2,6 +2,7 @@ use crate::{use_atom_root, Writable};
use dioxus_core::ScopeState;
use std::rc::Rc;
+#[must_use]
pub fn use_set(cx: &ScopeState, f: impl Writable) -> &Rc {
let root = use_atom_root(cx);
cx.use_hook(|| {
diff --git a/packages/fermi/src/hooks/state.rs b/packages/fermi/src/hooks/state.rs
index 071b18059..7d473588a 100644
--- a/packages/fermi/src/hooks/state.rs
+++ b/packages/fermi/src/hooks/state.rs
@@ -30,6 +30,7 @@ use std::{
/// ))
/// }
/// ```
+#[must_use]
pub fn use_atom_state(cx: &ScopeState, f: impl Writable) -> &AtomState {
let root = crate::use_atom_root(cx);
@@ -85,7 +86,9 @@ impl AtomState {
/// ```
#[must_use]
pub fn current(&self) -> Rc {
- self.value.as_ref().unwrap().clone()
+ let atoms = self.root.atoms.borrow();
+ let slot = atoms.get(&self.id).unwrap();
+ slot.value.clone().downcast().unwrap()
}
/// Get the `setter` function directly without the `AtomState` wrapper.
diff --git a/packages/fermi/src/lib.rs b/packages/fermi/src/lib.rs
index 52bf4cd09..dc5ccf010 100644
--- a/packages/fermi/src/lib.rs
+++ b/packages/fermi/src/lib.rs
@@ -22,8 +22,6 @@ mod atoms {
pub use atom::*;
pub use atomfamily::*;
pub use atomref::*;
- pub use selector::*;
- pub use selectorfamily::*;
}
pub mod hooks {
diff --git a/packages/fullstack/Cargo.toml b/packages/fullstack/Cargo.toml
index 9051b3994..2867c1c72 100644
--- a/packages/fullstack/Cargo.toml
+++ b/packages/fullstack/Cargo.toml
@@ -11,7 +11,7 @@ keywords = ["ui", "gui", "react", "ssr", "fullstack"]
[dependencies]
# server functions
-server_fn = { version = "0.4.6", default-features = false }
+server_fn = { version = "0.5.2", default-features = false }
dioxus_server_macro = { workspace = true }
# warp
diff --git a/packages/fullstack/examples/axum-hello-world/src/main.rs b/packages/fullstack/examples/axum-hello-world/src/main.rs
index 8f1d3c8c6..64e5b44a0 100644
--- a/packages/fullstack/examples/axum-hello-world/src/main.rs
+++ b/packages/fullstack/examples/axum-hello-world/src/main.rs
@@ -24,6 +24,7 @@ fn app(cx: Scope) -> Element {
let mut count = use_state(cx, || 0);
let text = use_state(cx, || "...".to_string());
+ let eval = use_eval(cx);
cx.render(rsx! {
div {
diff --git a/packages/fullstack/src/adapters/axum_adapter.rs b/packages/fullstack/src/adapters/axum_adapter.rs
index baa10e3a5..9f9f3b11e 100644
--- a/packages/fullstack/src/adapters/axum_adapter.rs
+++ b/packages/fullstack/src/adapters/axum_adapter.rs
@@ -372,15 +372,65 @@ fn apply_request_parts_to_response(
}
}
-/// SSR renderer handler for Axum
-pub async fn render_handler(
- State((cfg, ssr_state)): State<(ServeConfig, SSRState)>,
+/// SSR renderer handler for Axum with added context injection.
+///
+/// # Example
+/// ```rust,no_run
+/// #![allow(non_snake_case)]
+/// use std::sync::{Arc, Mutex};
+///
+/// use axum::routing::get;
+/// use dioxus::prelude::*;
+/// use dioxus_fullstack::{axum_adapter::render_handler_with_context, prelude::*};
+///
+/// fn app(cx: Scope) -> Element {
+/// render! {
+/// "hello!"
+/// }
+/// }
+///
+/// #[tokio::main]
+/// async fn main() {
+/// let cfg = ServeConfigBuilder::new(app, ())
+/// .assets_path("dist")
+/// .build();
+/// let ssr_state = SSRState::new(&cfg);
+///
+/// // This could be any state you want to be accessible from your server
+/// // functions using `[DioxusServerContext::get]`.
+/// let state = Arc::new(Mutex::new("state".to_string()));
+///
+/// let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 8080));
+/// axum::Server::bind(&addr)
+/// .serve(
+/// axum::Router::new()
+/// // Register server functions, etc.
+/// // Note you probably want to use `register_server_fns_with_handler`
+/// // to inject the context into server functions running outside
+/// // of an SSR render context.
+/// .fallback(get(render_handler_with_context).with_state((
+/// move |ctx| ctx.insert(state.clone()).unwrap(),
+/// cfg,
+/// ssr_state,
+/// )))
+/// .into_make_service(),
+/// )
+/// .await
+/// .unwrap();
+/// }
+/// ```
+pub async fn render_handler_with_context<
+ P: Clone + serde::Serialize + Send + Sync + 'static,
+ F: FnMut(&mut DioxusServerContext),
+>(
+ State((mut inject_context, cfg, ssr_state)): State<(F, ServeConfig
, SSRState)>,
request: Request
,
) -> impl IntoResponse {
let (parts, _) = request.into_parts();
let url = parts.uri.path_and_query().unwrap().to_string();
let parts: Arc> = Arc::new(RwLock::new(parts.into()));
- let server_context = DioxusServerContext::new(parts.clone());
+ let mut server_context = DioxusServerContext::new(parts.clone());
+ inject_context(&mut server_context);
match ssr_state.render(url, &cfg, &server_context).await {
Ok(rendered) => {
@@ -398,6 +448,14 @@ pub async fn render_handler
}
}
+/// SSR renderer handler for Axum
+pub async fn render_handler(
+ State((cfg, ssr_state)): State<(ServeConfig, SSRState)>,
+ request: Request
,
+) -> impl IntoResponse {
+ render_handler_with_context(State((|_: &mut _| (), cfg, ssr_state)), request).await
+}
+
fn report_err(e: E) -> Response {
Response::builder()
.status(StatusCode::INTERNAL_SERVER_ERROR)
diff --git a/packages/fullstack/src/adapters/mod.rs b/packages/fullstack/src/adapters/mod.rs
index 98d190919..d368b9c73 100644
--- a/packages/fullstack/src/adapters/mod.rs
+++ b/packages/fullstack/src/adapters/mod.rs
@@ -89,26 +89,26 @@ impl Service for ServerFnHandler {
let parts = Arc::new(RwLock::new(parts));
// Because the future returned by `server_fn_handler` is `Send`, and the future returned by this function must be send, we need to spawn a new runtime
- let (resp_tx, resp_rx) = tokio::sync::oneshot::channel();
let pool = get_local_pool();
- pool.spawn_pinned({
- let function = function.clone();
- let mut server_context = server_context.clone();
- server_context.parts = parts;
- move || async move {
- let data = match function.encoding() {
- Encoding::Url | Encoding::Cbor => &body,
- Encoding::GetJSON | Encoding::GetCBOR => &query,
- };
- let server_function_future = function.call((), data);
- let server_function_future =
- ProvideServerContext::new(server_function_future, server_context.clone());
- let resp = server_function_future.await;
-
- resp_tx.send(resp).unwrap();
- }
- });
- let result = resp_rx.await.unwrap();
+ let result = pool
+ .spawn_pinned({
+ let function = function.clone();
+ let mut server_context = server_context.clone();
+ server_context.parts = parts;
+ move || async move {
+ let data = match function.encoding() {
+ Encoding::Url | Encoding::Cbor => &body,
+ Encoding::GetJSON | Encoding::GetCBOR => &query,
+ };
+ let server_function_future = function.call((), data);
+ let server_function_future = ProvideServerContext::new(
+ server_function_future,
+ server_context.clone(),
+ );
+ server_function_future.await
+ }
+ })
+ .await?;
let mut res = http::Response::builder();
// Set the headers from the server context
diff --git a/packages/fullstack/src/hooks/server_future.rs b/packages/fullstack/src/hooks/server_future.rs
index e4d89480e..f8eaef963 100644
--- a/packages/fullstack/src/hooks/server_future.rs
+++ b/packages/fullstack/src/hooks/server_future.rs
@@ -22,6 +22,7 @@ use std::sync::Arc;
/// will be allowed to continue
///
/// - dependencies: a tuple of references to values that are PartialEq + Clone
+#[must_use = "Consider using `cx.spawn` to run a future without reading its value"]
pub fn use_server_future(
cx: &ScopeState,
dependencies: D,
diff --git a/packages/fullstack/src/launch.rs b/packages/fullstack/src/launch.rs
index c982a1c90..bd145f363 100644
--- a/packages/fullstack/src/launch.rs
+++ b/packages/fullstack/src/launch.rs
@@ -121,8 +121,15 @@ impl BoxedService;
}
@@ -17,7 +19,9 @@ where
}
}
+/// A service is a function that takes a request and returns an async response
pub trait Service {
+ /// Run the service and produce a future that resolves to a response
fn run(
&mut self,
req: http::Request,
@@ -55,6 +59,7 @@ where
}
}
+/// A boxed service is a type-erased service that can be used without knowing the underlying type
pub struct BoxedService(pub Box);
impl tower::Service> for BoxedService {
diff --git a/packages/fullstack/src/lib.rs b/packages/fullstack/src/lib.rs
index 96cd4b17b..8b166757f 100644
--- a/packages/fullstack/src/lib.rs
+++ b/packages/fullstack/src/lib.rs
@@ -41,6 +41,8 @@ pub mod prelude {
#[cfg(not(feature = "ssr"))]
pub use crate::html_storage::deserialize::get_root_props_from_document;
pub use crate::launch::LaunchBuilder;
+ #[cfg(feature = "ssr")]
+ pub use crate::layer::{Layer, Service};
#[cfg(all(feature = "ssr", feature = "router"))]
pub use crate::render::pre_cache_static_routes_with_props;
#[cfg(feature = "ssr")]
@@ -65,3 +67,10 @@ pub mod prelude {
pub use hooks::{server_cached::server_cached, server_future::use_server_future};
}
+
+// Warn users about overlapping features
+#[cfg(all(feature = "ssr", feature = "web"))]
+compile_error!("The `ssr` feature (enabled by `warp`, `axum`, or `salvo`) and `web` feature are overlapping. Please choose one or the other.");
+
+#[cfg(all(feature = "ssr", feature = "desktop"))]
+compile_error!("The `ssr` feature (enabled by `warp`, `axum`, or `salvo`) and `desktop` feature are overlapping. Please choose one or the other.");
diff --git a/packages/fullstack/src/render.rs b/packages/fullstack/src/render.rs
index cda41f82c..886a5bd99 100644
--- a/packages/fullstack/src/render.rs
+++ b/packages/fullstack/src/render.rs
@@ -45,6 +45,8 @@ impl SsrRendererPool {
.expect("couldn't spawn runtime")
.block_on(async move {
let mut vdom = VirtualDom::new_with_props(component, props);
+ // Make sure the evaluator is initialized
+ dioxus_ssr::eval::init_eval(vdom.base_scope());
let mut to = WriteBuffer { buffer: Vec::new() };
// before polling the future, we need to set the context
let prev_context =
diff --git a/packages/fullstack/src/router.rs b/packages/fullstack/src/router.rs
index b556aa000..b8d93f0e0 100644
--- a/packages/fullstack/src/router.rs
+++ b/packages/fullstack/src/router.rs
@@ -53,7 +53,7 @@ fn default_external_navigation_handler() -> fn(Scope) -> Element {
dioxus_router::prelude::FailureExternalNavigation
}
-/// The configeration for the router
+/// The configuration for the router
#[derive(Props, serde::Serialize, serde::Deserialize)]
pub struct FullstackRouterConfig
where
diff --git a/packages/fullstack/src/server_fn.rs b/packages/fullstack/src/server_fn.rs
index 539a0d70a..fd0639372 100644
--- a/packages/fullstack/src/server_fn.rs
+++ b/packages/fullstack/src/server_fn.rs
@@ -125,14 +125,6 @@ impl server_fn::ServerFunctionRegistry<()> for DioxusServerFnRegistry {
}
}
- fn register(
- url: &'static str,
- server_function: ServerFunction,
- encoding: server_fn::Encoding,
- ) -> Result<(), Self::Error> {
- Self::register_explicit("", url, server_function, encoding)
- }
-
/// Returns the server function registered at the given URL, or `None` if no function is registered at that URL.
fn get(url: &str) -> Option> {
REGISTERED_SERVER_FUNCTIONS
diff --git a/packages/generational-box/Cargo.toml b/packages/generational-box/Cargo.toml
index 6c5a5a841..64d36bd13 100644
--- a/packages/generational-box/Cargo.toml
+++ b/packages/generational-box/Cargo.toml
@@ -1,9 +1,12 @@
[package]
name = "generational-box"
authors = ["Evan Almloff"]
-version = "0.0.0"
+version = "0.4.3"
edition = "2018"
-
+description = "A box backed by a generational runtime"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/DioxusLabs/dioxus/"
+keywords = ["generational", "box", "memory", "allocator"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
@@ -15,3 +18,5 @@ rand = "0.8.5"
[features]
default = ["check_generation"]
check_generation = []
+debug_borrows = []
+debug_ownership = []
diff --git a/packages/generational-box/README.md b/packages/generational-box/README.md
index 63c539e08..95aab8402 100644
--- a/packages/generational-box/README.md
+++ b/packages/generational-box/README.md
@@ -11,6 +11,8 @@ Three main types manage state in Generational Box:
Example:
```rust
+use generational_box::Store;
+
// Create a store for this thread
let store = Store::default();
@@ -31,4 +33,4 @@ let store = Store::default();
## How it works
-Internally
\ No newline at end of file
+Internally, `generational-box` creates an arena of generational RefCell's that are recyled when the owner is dropped. You can think of the cells as something like `&'static RefCell>` with a generational check to make recyling a cell easier to debug. Then GenerationalBox's are `Copy` because the `&'static` pointer is `Copy`
diff --git a/packages/generational-box/src/lib.rs b/packages/generational-box/src/lib.rs
index 60bd41419..f56904ede 100644
--- a/packages/generational-box/src/lib.rs
+++ b/packages/generational-box/src/lib.rs
@@ -2,9 +2,12 @@
#![warn(missing_docs)]
use std::{
+ any::Any,
cell::{Cell, Ref, RefCell, RefMut},
- fmt::Debug,
+ error::Error,
+ fmt::{Debug, Display},
marker::PhantomData,
+ ops::{Deref, DerefMut},
rc::Rc,
};
@@ -29,12 +32,12 @@ fn reused() {
let first_ptr;
{
let owner = store.owner();
- first_ptr = owner.insert(1).raw.data.as_ptr();
+ first_ptr = owner.insert(1).raw.0.data.as_ptr();
drop(owner);
}
{
let owner = store.owner();
- let second_ptr = owner.insert(1234).raw.data.as_ptr();
+ let second_ptr = owner.insert(1234).raw.0.data.as_ptr();
assert_eq!(first_ptr, second_ptr);
drop(owner);
}
@@ -53,7 +56,10 @@ fn leaking_is_ok() {
// don't drop the owner
std::mem::forget(owner);
}
- assert_eq!(key.try_read().as_deref(), Some(&"hello world".to_string()));
+ assert_eq!(
+ key.try_read().as_deref().unwrap(),
+ &"hello world".to_string()
+ );
}
#[test]
@@ -68,7 +74,7 @@ fn drops() {
key = owner.insert(data);
// drop the owner
}
- assert!(key.try_read().is_none());
+ assert!(key.try_read().is_err());
}
#[test]
@@ -129,7 +135,7 @@ fn fuzz() {
println!("{:?}", path);
for key in valid_keys.iter() {
let value = key.read();
- println!("{:?}", value);
+ println!("{:?}", &*value);
assert!(value.starts_with("hello world"));
}
#[cfg(any(debug_assertions, feature = "check_generation"))]
@@ -153,6 +159,8 @@ pub struct GenerationalBox {
raw: MemoryLocation,
#[cfg(any(debug_assertions, feature = "check_generation"))]
generation: u32,
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at: &'static std::panic::Location<'static>,
_marker: PhantomData,
}
@@ -161,7 +169,7 @@ impl Debug for GenerationalBox {
#[cfg(any(debug_assertions, feature = "check_generation"))]
f.write_fmt(format_args!(
"{:?}@{:?}",
- self.raw.data.as_ptr(),
+ self.raw.0.data.as_ptr(),
self.generation
))?;
#[cfg(not(any(debug_assertions, feature = "check_generation")))]
@@ -175,7 +183,7 @@ impl GenerationalBox {
fn validate(&self) -> bool {
#[cfg(any(debug_assertions, feature = "check_generation"))]
{
- self.raw.generation.get() == self.generation
+ self.raw.0.generation.get() == self.generation
}
#[cfg(not(any(debug_assertions, feature = "check_generation")))]
{
@@ -184,43 +192,51 @@ impl GenerationalBox {
}
/// Try to read the value. Returns None if the value is no longer valid.
- pub fn try_read(&self) -> Option> {
- self.validate()
- .then(|| {
- Ref::filter_map(self.raw.data.borrow(), |any| {
- any.as_ref()?.downcast_ref::()
- })
- .ok()
- })
- .flatten()
+ #[track_caller]
+ pub fn try_read(&self) -> Result, BorrowError> {
+ if !self.validate() {
+ return Err(BorrowError::Dropped(ValueDroppedError {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ created_at: self.created_at,
+ }));
+ }
+ self.raw.try_borrow(
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ self.created_at,
+ )
}
/// Read the value. Panics if the value is no longer valid.
- pub fn read(&self) -> Ref<'_, T> {
+ #[track_caller]
+ pub fn read(&self) -> GenerationalRef {
self.try_read().unwrap()
}
/// Try to write the value. Returns None if the value is no longer valid.
- pub fn try_write(&self) -> Option> {
- self.validate()
- .then(|| {
- RefMut::filter_map(self.raw.data.borrow_mut(), |any| {
- any.as_mut()?.downcast_mut::()
- })
- .ok()
- })
- .flatten()
+ #[track_caller]
+ pub fn try_write(&self) -> Result, BorrowMutError> {
+ if !self.validate() {
+ return Err(BorrowMutError::Dropped(ValueDroppedError {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ created_at: self.created_at,
+ }));
+ }
+ self.raw.try_borrow_mut(
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ self.created_at,
+ )
}
/// Write the value. Panics if the value is no longer valid.
- pub fn write(&self) -> RefMut<'_, T> {
+ #[track_caller]
+ pub fn write(&self) -> GenerationalRefMut {
self.try_write().unwrap()
}
/// Set the value. Panics if the value is no longer valid.
pub fn set(&self, value: T) {
self.validate().then(|| {
- *self.raw.data.borrow_mut() = Some(Box::new(value));
+ *self.raw.0.data.borrow_mut() = Some(Box::new(value));
});
}
@@ -228,7 +244,8 @@ impl GenerationalBox {
pub fn ptr_eq(&self, other: &Self) -> bool {
#[cfg(any(debug_assertions, feature = "check_generation"))]
{
- self.raw.data.as_ptr() == other.raw.data.as_ptr() && self.generation == other.generation
+ self.raw.0.data.as_ptr() == other.raw.0.data.as_ptr()
+ && self.generation == other.generation
}
#[cfg(not(any(debug_assertions, feature = "check_generation")))]
{
@@ -246,26 +263,37 @@ impl Clone for GenerationalBox {
}
#[derive(Clone, Copy)]
-struct MemoryLocation {
- data: &'static RefCell>>,
+struct MemoryLocation(&'static MemoryLocationInner);
+
+struct MemoryLocationInner {
+ data: RefCell>>,
#[cfg(any(debug_assertions, feature = "check_generation"))]
- generation: &'static Cell,
+ generation: Cell,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_at: RefCell>>,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_mut_at: Cell>>,
}
impl MemoryLocation {
#[allow(unused)]
fn drop(&self) {
- let old = self.data.borrow_mut().take();
+ let old = self.0.data.borrow_mut().take();
#[cfg(any(debug_assertions, feature = "check_generation"))]
if old.is_some() {
drop(old);
- let new_generation = self.generation.get() + 1;
- self.generation.set(new_generation);
+ let new_generation = self.0.generation.get() + 1;
+ self.0.generation.set(new_generation);
}
}
- fn replace(&mut self, value: T) -> GenerationalBox {
- let mut inner_mut = self.data.borrow_mut();
+ fn replace_with_caller(
+ &mut self,
+ value: T,
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ caller: &'static std::panic::Location<'static>,
+ ) -> GenerationalBox {
+ let mut inner_mut = self.0.data.borrow_mut();
let raw = Box::new(value);
let old = inner_mut.replace(raw);
@@ -273,10 +301,315 @@ impl MemoryLocation {
GenerationalBox {
raw: *self,
#[cfg(any(debug_assertions, feature = "check_generation"))]
- generation: self.generation.get(),
+ generation: self.0.generation.get(),
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at: caller,
_marker: PhantomData,
}
}
+
+ #[track_caller]
+ fn try_borrow(
+ &self,
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at: &'static std::panic::Location<'static>,
+ ) -> Result, BorrowError> {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ self.0
+ .borrowed_at
+ .borrow_mut()
+ .push(std::panic::Location::caller());
+ match self.0.data.try_borrow() {
+ Ok(borrow) => match Ref::filter_map(borrow, |any| any.as_ref()?.downcast_ref::()) {
+ Ok(reference) => Ok(GenerationalRef {
+ inner: reference,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: GenerationalRefBorrowInfo {
+ borrowed_at: std::panic::Location::caller(),
+ borrowed_from: self.0,
+ },
+ }),
+ Err(_) => Err(BorrowError::Dropped(ValueDroppedError {
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at,
+ })),
+ },
+ Err(_) => Err(BorrowError::AlreadyBorrowedMut(AlreadyBorrowedMutError {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_mut_at: self.0.borrowed_mut_at.get().unwrap(),
+ })),
+ }
+ }
+
+ #[track_caller]
+ fn try_borrow_mut(
+ &self,
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at: &'static std::panic::Location<'static>,
+ ) -> Result, BorrowMutError> {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ {
+ self.0
+ .borrowed_mut_at
+ .set(Some(std::panic::Location::caller()));
+ }
+ match self.0.data.try_borrow_mut() {
+ Ok(borrow_mut) => {
+ match RefMut::filter_map(borrow_mut, |any| any.as_mut()?.downcast_mut::()) {
+ Ok(reference) => Ok(GenerationalRefMut {
+ inner: reference,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: GenerationalRefMutBorrowInfo {
+ borrowed_from: self.0,
+ },
+ }),
+ Err(_) => Err(BorrowMutError::Dropped(ValueDroppedError {
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at,
+ })),
+ }
+ }
+ Err(_) => Err(BorrowMutError::AlreadyBorrowed(AlreadyBorrowedError {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_at: self.0.borrowed_at.borrow().clone(),
+ })),
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+/// An error that can occur when trying to borrow a value.
+pub enum BorrowError {
+ /// The value was dropped.
+ Dropped(ValueDroppedError),
+ /// The value was already borrowed mutably.
+ AlreadyBorrowedMut(AlreadyBorrowedMutError),
+}
+
+impl Display for BorrowError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ BorrowError::Dropped(error) => Display::fmt(error, f),
+ BorrowError::AlreadyBorrowedMut(error) => Display::fmt(error, f),
+ }
+ }
+}
+
+impl Error for BorrowError {}
+
+#[derive(Debug, Clone)]
+/// An error that can occur when trying to borrow a value mutably.
+pub enum BorrowMutError {
+ /// The value was dropped.
+ Dropped(ValueDroppedError),
+ /// The value was already borrowed.
+ AlreadyBorrowed(AlreadyBorrowedError),
+ /// The value was already borrowed mutably.
+ AlreadyBorrowedMut(AlreadyBorrowedMutError),
+}
+
+impl Display for BorrowMutError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ BorrowMutError::Dropped(error) => Display::fmt(error, f),
+ BorrowMutError::AlreadyBorrowedMut(error) => Display::fmt(error, f),
+ BorrowMutError::AlreadyBorrowed(error) => Display::fmt(error, f),
+ }
+ }
+}
+
+impl Error for BorrowMutError {}
+
+/// An error that can occur when trying to use a value that has been dropped.
+#[derive(Debug, Copy, Clone)]
+pub struct ValueDroppedError {
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at: &'static std::panic::Location<'static>,
+}
+
+impl Display for ValueDroppedError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str("Failed to borrow because the value was dropped.")?;
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ f.write_fmt(format_args!("created_at: {}", self.created_at))?;
+ Ok(())
+ }
+}
+
+impl std::error::Error for ValueDroppedError {}
+
+/// An error that can occur when trying to borrow a value that has already been borrowed mutably.
+#[derive(Debug, Copy, Clone)]
+pub struct AlreadyBorrowedMutError {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_mut_at: &'static std::panic::Location<'static>,
+}
+
+impl Display for AlreadyBorrowedMutError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str("Failed to borrow because the value was already borrowed mutably.")?;
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ f.write_fmt(format_args!("borrowed_mut_at: {}", self.borrowed_mut_at))?;
+ Ok(())
+ }
+}
+
+impl std::error::Error for AlreadyBorrowedMutError {}
+
+/// An error that can occur when trying to borrow a value mutably that has already been borrowed immutably.
+#[derive(Debug, Clone)]
+pub struct AlreadyBorrowedError {
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_at: Vec<&'static std::panic::Location<'static>>,
+}
+
+impl Display for AlreadyBorrowedError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str("Failed to borrow mutably because the value was already borrowed immutably.")?;
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ f.write_str("borrowed_at:")?;
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ for location in self.borrowed_at.iter() {
+ f.write_fmt(format_args!("\t{}", location))?;
+ }
+ Ok(())
+ }
+}
+
+impl std::error::Error for AlreadyBorrowedError {}
+
+/// A reference to a value in a generational box.
+pub struct GenerationalRef {
+ inner: Ref<'static, T>,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: GenerationalRefBorrowInfo,
+}
+
+impl GenerationalRef {
+ /// Map one ref type to another.
+ pub fn map(orig: GenerationalRef, f: F) -> GenerationalRef
+ where
+ F: FnOnce(&T) -> &U,
+ {
+ GenerationalRef {
+ inner: Ref::map(orig.inner, f),
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: GenerationalRefBorrowInfo {
+ borrowed_at: orig.borrow.borrowed_at,
+ borrowed_from: orig.borrow.borrowed_from,
+ },
+ }
+ }
+
+ /// Filter one ref type to another.
+ pub fn filter_map(orig: GenerationalRef, f: F) -> Option>
+ where
+ F: FnOnce(&T) -> Option<&U>,
+ {
+ let Self {
+ inner,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow,
+ } = orig;
+ Ref::filter_map(inner, f).ok().map(|inner| GenerationalRef {
+ inner,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: GenerationalRefBorrowInfo {
+ borrowed_at: borrow.borrowed_at,
+ borrowed_from: borrow.borrowed_from,
+ },
+ })
+ }
+}
+
+impl Deref for GenerationalRef {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ self.inner.deref()
+ }
+}
+
+#[cfg(any(debug_assertions, feature = "debug_borrows"))]
+struct GenerationalRefBorrowInfo {
+ borrowed_at: &'static std::panic::Location<'static>,
+ borrowed_from: &'static MemoryLocationInner,
+}
+
+#[cfg(any(debug_assertions, feature = "debug_borrows"))]
+impl Drop for GenerationalRefBorrowInfo {
+ fn drop(&mut self) {
+ self.borrowed_from
+ .borrowed_at
+ .borrow_mut()
+ .retain(|location| std::ptr::eq(*location, self.borrowed_at as *const _));
+ }
+}
+
+/// A mutable reference to a value in a generational box.
+pub struct GenerationalRefMut {
+ inner: RefMut<'static, T>,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: GenerationalRefMutBorrowInfo,
+}
+
+impl GenerationalRefMut {
+ /// Map one ref type to another.
+ pub fn map(orig: GenerationalRefMut, f: F) -> GenerationalRefMut
+ where
+ F: FnOnce(&mut T) -> &mut U,
+ {
+ GenerationalRefMut {
+ inner: RefMut::map(orig.inner, f),
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow: orig.borrow,
+ }
+ }
+
+ /// Filter one ref type to another.
+ pub fn filter_map(orig: GenerationalRefMut, f: F) -> Option>
+ where
+ F: FnOnce(&mut T) -> Option<&mut U>,
+ {
+ let Self {
+ inner,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow,
+ } = orig;
+ RefMut::filter_map(inner, f)
+ .ok()
+ .map(|inner| GenerationalRefMut {
+ inner,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrow,
+ })
+ }
+}
+
+impl Deref for GenerationalRefMut {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ self.inner.deref()
+ }
+}
+
+impl DerefMut for GenerationalRefMut {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ self.inner.deref_mut()
+ }
+}
+
+#[cfg(any(debug_assertions, feature = "debug_borrows"))]
+struct GenerationalRefMutBorrowInfo {
+ borrowed_from: &'static MemoryLocationInner,
+}
+
+#[cfg(any(debug_assertions, feature = "debug_borrows"))]
+impl Drop for GenerationalRefMutBorrowInfo {
+ fn drop(&mut self) {
+ self.borrowed_from.borrowed_mut_at.take();
+ }
}
/// Handles recycling generational boxes that have been dropped. Your application should have one store or one store per thread.
@@ -305,12 +638,16 @@ impl Store {
if let Some(location) = self.recycled.borrow_mut().pop() {
location
} else {
- let data: &'static RefCell<_> = self.bump.alloc(RefCell::new(None));
- MemoryLocation {
- data,
+ let data: &'static MemoryLocationInner = self.bump.alloc(MemoryLocationInner {
+ data: RefCell::new(None),
#[cfg(any(debug_assertions, feature = "check_generation"))]
- generation: self.bump.alloc(Cell::new(0)),
- }
+ generation: Cell::new(0),
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_at: Default::default(),
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ borrowed_mut_at: Default::default(),
+ });
+ MemoryLocation(data)
}
}
@@ -331,9 +668,31 @@ pub struct Owner {
impl Owner {
/// Insert a value into the store. The value will be dropped when the owner is dropped.
+ #[track_caller]
pub fn insert(&self, value: T) -> GenerationalBox {
let mut location = self.store.claim();
- let key = location.replace(value);
+ let key = location.replace_with_caller(
+ value,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ std::panic::Location::caller(),
+ );
+ self.owned.borrow_mut().push(location);
+ key
+ }
+
+ /// Insert a value into the store with a specific location blamed for creating the value. The value will be dropped when the owner is dropped.
+ pub fn insert_with_caller(
+ &self,
+ value: T,
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ caller: &'static std::panic::Location<'static>,
+ ) -> GenerationalBox {
+ let mut location = self.store.claim();
+ let key = location.replace_with_caller(
+ value,
+ #[cfg(any(debug_assertions, feature = "debug_borrows"))]
+ caller,
+ );
self.owned.borrow_mut().push(location);
key
}
@@ -344,7 +703,9 @@ impl Owner {
GenerationalBox {
raw: location,
#[cfg(any(debug_assertions, feature = "check_generation"))]
- generation: location.generation.get(),
+ generation: location.0.generation.get(),
+ #[cfg(any(debug_assertions, feature = "debug_ownership"))]
+ created_at: std::panic::Location::caller(),
_marker: PhantomData,
}
}
diff --git a/packages/hooks/src/computed.rs b/packages/hooks/src/computed.rs
index 3369d6832..dbea75d73 100644
--- a/packages/hooks/src/computed.rs
+++ b/packages/hooks/src/computed.rs
@@ -37,6 +37,7 @@ use std::{
/// }
/// }
/// ```
+#[must_use]
pub fn use_tracked_state(cx: &ScopeState, init: impl FnOnce() -> T) -> &Tracked {
cx.use_hook(|| {
let init = init();
@@ -160,6 +161,7 @@ impl Drop for Tracker {
}
}
+#[must_use = "Consider using the `use_effect` hook to rerun an effect whenever the tracked state changes if you don't need the result of the computation"]
pub fn use_selector(
cx: &ScopeState,
tracked: &Tracked,
diff --git a/packages/hooks/src/lib.rs b/packages/hooks/src/lib.rs
index a5b92a036..8178d4d3d 100644
--- a/packages/hooks/src/lib.rs
+++ b/packages/hooks/src/lib.rs
@@ -60,6 +60,9 @@ pub mod computed;
mod use_on_destroy;
pub use use_on_destroy::*;
+mod use_const;
+pub use use_const::*;
+
mod use_context;
pub use use_context::*;
diff --git a/packages/hooks/src/use_callback.rs b/packages/hooks/src/use_callback.rs
index 3f223b581..52e592f6b 100644
--- a/packages/hooks/src/use_callback.rs
+++ b/packages/hooks/src/use_callback.rs
@@ -24,6 +24,7 @@ macro_rules! use_callback {
)
};
}
+
pub fn use_callback(cx: &ScopeState, make: impl FnOnce() -> R) -> impl FnMut(T) + '_
where
R: FnMut(T) -> F + 'static,
diff --git a/packages/hooks/src/use_const.rs b/packages/hooks/src/use_const.rs
new file mode 100644
index 000000000..47ddb1ed2
--- /dev/null
+++ b/packages/hooks/src/use_const.rs
@@ -0,0 +1,76 @@
+use std::rc::Rc;
+
+use dioxus_core::prelude::*;
+
+/// Store constant state between component renders.
+///
+/// UseConst allows you to store state that is initialized once and then remains constant across renders.
+/// You can only get an immutable reference after initalization.
+/// This can be useful for values that don't need to update reactively, thus can be memoized easily
+///
+/// ```rust, ignore
+/// struct ComplexData(i32);
+///
+/// fn Component(cx: Scope) -> Element {
+/// let id = use_const(cx, || ComplexData(100));
+///
+/// cx.render(rsx! {
+/// div { "{id.0}" }
+/// })
+/// }
+/// ```
+#[must_use]
+pub fn use_const(
+ cx: &ScopeState,
+ initial_state_fn: impl FnOnce() -> T,
+) -> &UseConst {
+ cx.use_hook(|| UseConst {
+ value: Rc::new(initial_state_fn()),
+ })
+}
+
+#[derive(Clone)]
+pub struct UseConst {
+ value: Rc,
+}
+
+impl PartialEq for UseConst {
+ fn eq(&self, other: &Self) -> bool {
+ Rc::ptr_eq(&self.value, &other.value)
+ }
+}
+
+impl core::fmt::Display for UseConst {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ self.value.fmt(f)
+ }
+}
+
+impl UseConst {
+ pub fn get_rc(&self) -> &Rc {
+ &self.value
+ }
+}
+
+impl std::ops::Deref for UseConst {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ self.value.as_ref()
+ }
+}
+
+#[test]
+fn use_const_makes_sense() {
+ #[allow(unused)]
+
+ fn app(cx: Scope) -> Element {
+ let const_val = use_const(cx, || vec![0, 1, 2, 3]);
+
+ assert!(const_val[0] == 0);
+
+ // const_val.remove(0); // Cannot Compile, cannot get mutable reference now
+
+ None
+ }
+}
diff --git a/packages/hooks/src/use_context.rs b/packages/hooks/src/use_context.rs
index fdf363252..0d94492f6 100644
--- a/packages/hooks/src/use_context.rs
+++ b/packages/hooks/src/use_context.rs
@@ -3,6 +3,7 @@ use dioxus_core::ScopeState;
/// Consume some context in the tree, providing a sharable handle to the value
///
/// Does not regenerate the value if the value is changed at the parent.
+#[must_use]
pub fn use_context(cx: &ScopeState) -> Option<&T> {
cx.use_hook(|| cx.consume_context::()).as_ref()
}
diff --git a/packages/hooks/src/use_coroutine.rs b/packages/hooks/src/use_coroutine.rs
index e5563d793..f2577b90c 100644
--- a/packages/hooks/src/use_coroutine.rs
+++ b/packages/hooks/src/use_coroutine.rs
@@ -79,6 +79,7 @@ where
/// Get a handle to a coroutine higher in the tree
///
/// See the docs for [`use_coroutine`] for more details.
+#[must_use]
pub fn use_coroutine_handle(cx: &ScopeState) -> Option<&Coroutine> {
cx.use_hook(|| cx.consume_context::>())
.as_ref()
diff --git a/packages/hooks/src/use_effect.rs b/packages/hooks/src/use_effect.rs
index e72afe27f..6fb2fcf9e 100644
--- a/packages/hooks/src/use_effect.rs
+++ b/packages/hooks/src/use_effect.rs
@@ -1,5 +1,10 @@
use dioxus_core::{ScopeState, TaskId};
-use std::{any::Any, cell::Cell, future::Future};
+use std::{
+ any::Any,
+ cell::{Cell, RefCell},
+ future::Future,
+ rc::Rc,
+};
use crate::UseFutureDep;
@@ -14,7 +19,7 @@ use crate::UseFutureDep;
/// ## Arguments
///
/// - `dependencies`: a tuple of references to values that are `PartialEq` + `Clone`.
-/// - `future`: a closure that takes the `dependencies` as arguments and returns a `'static` future.
+/// - `future`: a closure that takes the `dependencies` as arguments and returns a `'static` future. That future may return nothing or a closure that will be executed when the dependencies change to clean up the effect.
///
/// ## Examples
///
@@ -33,6 +38,16 @@ use crate::UseFutureDep;
/// }
/// });
///
+/// // Only fetch the user data when the id changes.
+/// use_effect(cx, (id,), |(id,)| {
+/// to_owned![name];
+/// async move {
+/// let user = fetch_user(id).await;
+/// name.set(user.name);
+/// move || println!("Cleaning up from {}", id)
+/// }
+/// });
+///
/// let name = name.get().clone().unwrap_or("Loading...".to_string());
///
/// render!(
@@ -45,34 +60,80 @@ use crate::UseFutureDep;
/// render!(Profile { id: 0 })
/// }
/// ```
-pub fn use_effect(cx: &ScopeState, dependencies: D, future: impl FnOnce(D::Out) -> F)
+pub fn use_effect(cx: &ScopeState, dependencies: D, future: impl FnOnce(D::Out) -> R)
where
- T: 'static,
- F: Future