Merge pull request #95 from Kannen/main

jkelleyrtp · web-flow · commit 5a79ae348cb2 · 2025-11-06T17:46:03.000-03:00
update to dioxus 0.7.0
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,14 +26,14 @@ dioxus-util = { path = "packages/util", version = "0.1.0-alpha.1" }
 dioxus-window = { path = "packages/window", version = "0.1.0-alpha.1" }
 
 # Dioxus
-dioxus = "0.6.0"
-dioxus-signals = "0.6.0"
-dioxus-desktop = "0.6.0"
-dioxus-config-macro = "0.6.0"
+dioxus = "0.7.0"
+dioxus-signals = "0.7.0"
+dioxus-desktop = "0.7.0"
+dioxus-config-macro = "0.7.0"
 
 # Deps
 cfg-if = "1.0.0"
-tokio = "1.43.0"
+tokio = "1.48.0"
 futures = "0.3.31"
 futures-util = "0.3.31"
 
diff --git a/packages/geolocation/src/lib.rs b/packages/geolocation/src/lib.rs
@@ -8,6 +8,7 @@ cfg_if::cfg_if! {
         pub use self::core::*;
         pub use self::use_geolocation::*;
     }
+
     else {
         compile_error!("the `geolocation` feature is only available on wasm and windows targets");
     }
diff --git a/packages/geolocation/src/use_geolocation.rs b/packages/geolocation/src/use_geolocation.rs
@@ -3,18 +3,18 @@
 use super::core::{Error, Event, Geocoordinates, Geolocator, PowerMode, Status};
 use dioxus::{
     prelude::{
-        ReadOnlySignal, Signal, UnboundedReceiver, provide_context, try_consume_context,
-        use_coroutine, use_hook, use_signal,
+        ReadSignal, Signal, UnboundedReceiver, provide_context, try_consume_context, use_coroutine,
+        use_hook, use_signal,
     },
-    signals::{Readable, Writable},
+    signals::{ReadableExt, WritableExt},
 };
 use futures_util::stream::StreamExt;
 use std::sync::Once;
 
 static INIT: Once = Once::new();
 
 /// Provides the latest geocoordinates. Good for navigation-type apps.
-pub fn use_geolocation() -> ReadOnlySignal<Result<Geocoordinates, Error>> {
+pub fn use_geolocation() -> ReadSignal<Result<Geocoordinates, Error>> {
     // Store the coords
     let mut coords: Signal<Result<Geocoordinates, Error>> =
         use_signal(|| Err(Error::NotInitialized));
@@ -52,7 +52,7 @@ pub fn use_geolocation() -> ReadOnlySignal<Result<Geocoordinates, Error>> {
         }
     }
 
-    use_hook(|| ReadOnlySignal::new(coords))
+    use_hook(|| ReadSignal::new(coords))
 }
 
 /// Must be called before any use of the geolocation abstraction.
diff --git a/packages/notification/src/lib.rs b/packages/notification/src/lib.rs
@@ -8,7 +8,6 @@ use std::{
     fmt::{self, Display},
     path::{Path, PathBuf},
 };
-
 /// Provides a builder API and contains relevant notification info.
 ///
 /// # Examples
diff --git a/packages/storage/src/client_storage/memory.rs b/packages/storage/src/client_storage/memory.rs
@@ -5,6 +5,8 @@ use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 use std::sync::Arc;
 
+use dioxus::core::{consume_context_from_scope, provide_root_context};
+
 use crate::StorageBacking;
 
 #[derive(Clone)]
@@ -42,15 +44,14 @@ impl SessionStore {
 
     /// Get the current session store from the root context, or create a new one if it doesn't exist.
     fn get_current_session() -> Self {
-        dioxus::prelude::consume_context_from_scope::<Self>(dioxus::prelude::ScopeId::ROOT)
-            .map_or_else(
-                || {
-                    let session = Self::new();
-                    dioxus::prelude::provide_root_context(session.clone());
-                    session
-                },
-                |s| s,
-            )
+        consume_context_from_scope::<Self>(dioxus::prelude::ScopeId::ROOT).map_or_else(
+            || {
+                let session = Self::new();
+                provide_root_context(session.clone());
+                session
+            },
+            |s| s,
+        )
     }
 }
 
diff --git a/packages/storage/src/lib.rs b/packages/storage/src/lib.rs
@@ -30,6 +30,7 @@ mod client_storage;
 mod persistence;
 
 pub use client_storage::{LocalStorage, SessionStorage};
+use dioxus::core::{ReactiveContext, current_scope_id, generation, needs_update};
 use dioxus::logger::tracing::trace;
 use futures_util::stream::StreamExt;
 pub use persistence::{
@@ -401,10 +402,7 @@ where
     pub fn new(key: S::Key, data: T) -> Self {
         Self {
             key,
-            data: Signal::new_in_scope(
-                data,
-                current_scope_id().expect("must be called from inside of the dioxus context"),
-            ),
+            data: Signal::new_in_scope(data, current_scope_id()),
         }
     }
 }
diff --git a/packages/time/src/debounce.rs b/packages/time/src/debounce.rs
@@ -2,7 +2,7 @@ use crate::{TimeoutHandle, UseTimeout, use_timeout};
 use dioxus::{
     dioxus_core::SpawnIfAsync,
     hooks::use_signal,
-    signals::{Signal, Writable},
+    signals::{Signal, WritableExt as _},
 };
 use std::time::Duration;
 
diff --git a/packages/time/src/interval.rs b/packages/time/src/interval.rs
@@ -1,7 +1,8 @@
 use dioxus::{
+    core::Task,
     dioxus_core::SpawnIfAsync,
-    prelude::{Callback, Task, Writable, spawn, use_hook},
-    signals::Signal,
+    prelude::{Callback, spawn, use_hook},
+    signals::{Signal, WritableExt as _},
 };
 use std::time::Duration;
 
@@ -52,7 +53,7 @@ impl UseInterval {
 ///     let mut time_elapsed = use_signal(|| 0);
 ///     // Create an interval that increases the time elapsed signal by one every second.
 ///     use_interval(Duration::from_secs(1), move |()| time_elapsed += 1);
-///     
+///
 ///     rsx! {
 ///         "It has been {time_elapsed} since the app started."
 ///     }
@@ -70,7 +71,7 @@ impl UseInterval {
 /// fn App() -> Element {
 ///     let mut time_elapsed = use_signal(|| 0);
 ///     let mut interval = use_interval(Duration::from_secs(1), move |()| time_elapsed += 1);
-///     
+///
 ///     rsx! {
 ///         "It has been {time_elapsed} since the app started."
 ///         button {
@@ -99,7 +100,7 @@ impl UseInterval {
 ///         tokio::time::sleep(Duration::from_secs(1)).await;
 ///         println!("Done!");
 ///     });
-///     
+///
 ///     rsx! {
 ///         "It has been {time_elapsed} since the app started."
 ///     }
diff --git a/packages/time/src/lib.rs b/packages/time/src/lib.rs
@@ -30,7 +30,7 @@ pub use timeout::{TimeoutHandle, UseTimeout, use_timeout};
 /// #[component]
 /// pub fn App() -> Element {
 ///     let mut has_slept = use_signal(|| false);
-///     
+///
 ///     use_effect(move || {
 ///         spawn(async move {
 ///             dioxus_time::sleep(Duration::from_secs(3)).await;
diff --git a/packages/time/src/timeout.rs b/packages/time/src/timeout.rs
@@ -1,6 +1,7 @@
 use dioxus::{
+    core::Task,
     dioxus_core::SpawnIfAsync,
-    prelude::{Callback, Task, spawn, use_hook},
+    prelude::{Callback, spawn, use_hook},
     signals::Signal,
 };
 use futures::{SinkExt, StreamExt, channel::mpsc};
@@ -91,7 +92,7 @@ impl TimeoutHandle {
 ///     // Create a timeout for two seconds.
 ///     // Once triggered, this timeout will print "timeout called" after two seconds.
 ///     let timeout = use_timeout(Duration::from_secs(2), |()| println!("timeout called"));
-///     
+///
 ///     rsx! {
 ///         button {
 ///             onclick: move |_| {
@@ -118,7 +119,7 @@ impl TimeoutHandle {
 ///         current_timeout.set(None);
 ///         println!("timeout called");
 ///     });
-///     
+///
 ///     rsx! {
 ///         button {
 ///             onclick: move |_| {
@@ -153,7 +154,7 @@ impl TimeoutHandle {
 ///         tokio::time::sleep(Duration::from_secs(2)).await;
 ///         println!("Timeout after four total seconds.");
 ///     });
-///     
+///
 ///     rsx! {
 ///         button {
 ///             onclick: move |_| {
diff --git a/packages/util/src/scroll.rs b/packages/util/src/scroll.rs
@@ -1,4 +1,4 @@
-use dioxus::prelude::*;
+use dioxus::{core::use_drop, prelude::*};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 /// Scroll metrics.
@@ -31,7 +31,7 @@ static SCROLL_TRACKER_COUNTER: AtomicUsize = AtomicUsize::new(0);
 /// #[component]
 /// fn App() -> Element {
 ///     let random_text = "This is some random repeating text. ".repeat(1000);
-///     
+///
 ///     let scroll_metrics = use_root_scroll();
 ///     use_effect(move || {
 ///         let scroll_metrics = scroll_metrics();
@@ -40,9 +40,9 @@ static SCROLL_TRACKER_COUNTER: AtomicUsize = AtomicUsize::new(0);
 ///         let scroll_percentage = (scroll_metrics.scroll_top + scroll_metrics.client_height) / scroll_metrics.scroll_height;
 ///         info!("Scroll percentage: {}", scroll_percentage);
 ///     });
-///  
+///
 ///     rsx! {
-///         p { "{random_text}" }  
+///         p { "{random_text}" }
 ///     }
 /// }
 /// ```
diff --git a/packages/window/src/size.rs b/packages/window/src/size.rs
@@ -13,21 +13,18 @@
 //!
 //! fn App() -> Element {
 //!     let size = use_window_size();
-//!     let size = size().unwrap();    
+//!     let size = size().unwrap();
 //!
 //!     rsx! {
 //!         p { "Width: {size.width}" }
 //!         p { "Height: {size.height}" }
 //!     }
 //! }
 //! ```
+use dioxus::core::provide_root_context;
 use dioxus::hooks::use_effect;
-use dioxus::prelude::{
-    ReadOnlySignal, ScopeId, Signal, Writable, provide_root_context, try_use_context, use_hook,
-    warnings::signal_write_in_component_body,
-};
-use dioxus::signals::Readable;
-use dioxus::warnings::Warning as _;
+use dioxus::prelude::{ReadableExt, ScopeId, Signal, try_use_context, use_hook};
+use dioxus::signals::{ReadSignal, Readable, WritableExt};
 use std::error::Error;
 use std::fmt::Display;
 
@@ -75,7 +72,7 @@ type WindowSizeResult = Result<WindowSize, WindowSizeError>;
 ///
 /// fn App() -> Element {
 ///     let size = use_window_size();
-///     
+///
 ///     let half_of_width = use_memo(move || {
 ///         let width = size.width().unwrap();
 ///         width / 2
@@ -120,15 +117,15 @@ impl<R> ReadableWindowSizeExt for R where R: Readable<Target = WindowSizeResult>
 ///
 /// fn App() -> Element {
 ///     let size = use_window_size();
-///     let size = size().unwrap();    
+///     let size = size().unwrap();
 ///
 ///     rsx! {
 ///         p { "Width: {size.width}" }
 ///         p { "Height: {size.height}" }
 ///     }
 /// }
 /// ```
-pub fn use_window_size() -> ReadOnlySignal<WindowSizeResult> {
+pub fn use_window_size() -> ReadSignal<WindowSizeResult> {
     let mut window_size = match try_use_context::<Signal<WindowSizeResult>>() {
         Some(w) => w,
         // This should only run once.
@@ -144,7 +141,7 @@ pub fn use_window_size() -> ReadOnlySignal<WindowSizeResult> {
         listen(window_size);
     });
 
-    use_hook(|| ReadOnlySignal::new(window_size))
+    use_hook(|| ReadSignal::new(window_size))
 }
 
 // Listener for the web implementation.
@@ -177,9 +174,7 @@ fn listen(mut window_size: Signal<WindowSizeResult>) {
             _ => Err(WindowSizeError::CheckFailed),
         };
 
-        signal_write_in_component_body::allow(move || {
-            window_size.set(value);
-        });
+        window_size.set(value);
     }) as Box<dyn FnMut()>);
 
     let on_resize_cb = on_resize.as_ref().clone();
@@ -199,12 +194,10 @@ fn listen(mut window_size: Signal<WindowSizeResult>) {
             ..
         } = event
         {
-            signal_write_in_component_body::allow(move || {
-                window_size.set(Ok(WindowSize {
-                    width: size.width,
-                    height: size.height,
-                }));
-            });
+            window_size.set(Ok(WindowSize {
+                width: size.width,
+                height: size.height,
+            }));
         }
     });
 }
@@ -223,7 +216,7 @@ fn listen(mut window_size: Signal<WindowSizeResult>) {
 ///
 /// fn App() -> Element {
 ///     let size = use_signal(get_window_size);
-///     let size = size().unwrap();    
+///     let size = size().unwrap();
 ///
 ///     rsx! {
 ///         p { "Width: {size.width}" }
diff --git a/packages/window/src/theme.rs b/packages/window/src/theme.rs
@@ -17,7 +17,7 @@
 //! #[component]
 //! fn App() -> Element {
 //!     let theme = use_system_theme();
-//!     
+//!
 //!     // Default to a light theme in the event of an error.
 //!     let class = match theme().unwrap_or(Theme::Light) {
 //!         Theme::Light => "bg-light",
@@ -32,7 +32,7 @@
 //!     }
 //! }
 //! ```
-use dioxus::prelude::*;
+use dioxus::{core::provide_root_context, prelude::*};
 use std::{error::Error, fmt::Display};
 
 /// A color theme.
@@ -109,7 +109,7 @@ type ThemeResult = Result<Theme, ThemeError>;
 ///     }
 /// }
 /// ```
-pub fn use_system_theme() -> ReadOnlySignal<ThemeResult> {
+pub fn use_system_theme() -> ReadSignal<ThemeResult> {
     let mut system_theme = match try_use_context::<Signal<ThemeResult>>() {
         Some(s) => s,
         // This should only run once.
@@ -125,7 +125,7 @@ pub fn use_system_theme() -> ReadOnlySignal<ThemeResult> {
         listen(system_theme);
     });
 
-    use_hook(|| ReadOnlySignal::new(system_theme))
+    use_hook(|| ReadSignal::new(system_theme))
 }
 
 // The listener implementation for wasm targets.

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ cfg_if::cfg_if! {`
`8`	`8`	`pub use self::core::*;`
`9`	`9`	`pub use self::use_geolocation::*;`
`10`	`10`	`}`
	`11`	`+`
`11`	`12`	`else {`
`12`	`13`	compile_error!("the `geolocation` feature is only available on wasm and windows targets");
`13`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ mod client_storage;`
`30`	`30`	`mod persistence;`
`31`	`31`
`32`	`32`	`pub use client_storage::{LocalStorage, SessionStorage};`
	`33`	`+use dioxus::core::{ReactiveContext, current_scope_id, generation, needs_update};`
`33`	`34`	`use dioxus::logger::tracing::trace;`
`34`	`35`	`use futures_util::stream::StreamExt;`
`35`	`36`	`pub use persistence::{`
`@@ -401,10 +402,7 @@ where`
`401`	`402`	`pub fn new(key: S::Key, data: T) -> Self {`
`402`	`403`	`Self {`
`403`	`404`	`key,`
`404`		`- data: Signal::new_in_scope(`
`405`		`- data,`
`406`		`- current_scope_id().expect("must be called from inside of the dioxus context"),`
`407`		`- ),`
	`405`	`+ data: Signal::new_in_scope(data, current_scope_id()),`
`408`	`406`	`}`
`409`	`407`	`}`
`410`	`408`	`}`