Merge branch 'main' of https://github.com/marc2332/dioxus-query

Author: marc2332

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "dioxus-query"
 description = "Fully-typed, async, reusable cached state management for Dioxus 🧬"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2021"
 license = "MIT"
 authors = ["Marc Espín <[email protected]>"]
@@ -12,11 +12,16 @@ keywords = ["dioxus", "async", "state", "synchronization"]
 categories = ["gui", "asynchronous"]
 
 [dependencies]
-dioxus-lib = { version = "0.6", default-features = false, features = ["macro", "hooks", "signals"] }
+dioxus = { version = "0.7.0", default-features = false, features = ["macro", "hooks", "signals"] }
+dioxus-core = { version = "0.7.0", default-features = false }
 futures-util = "0.3.28"
-warnings = "0.2.1"
 tokio = { version = "^1", features = ["sync", "time"] }
 
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasmtimer = "0.4.1"
+web-time = "1.1.0"
+tokio = { version = "^1", features = ["sync"] }
+
 [dev-dependencies]
-dioxus = { version = "0.6", features = ["desktop"] }
+dioxus = { version = "0.7.0", features = ["desktop"] }
 tokio = { version = "^1", features = ["time"] }

README.md

@@ -8,9 +8,8 @@ See the [Docs](https://docs.rs/dioxus-query/latest/dioxus_query/) or join the [D
 
 ## Support
 
-- **Dioxus v0.6** 🧬
-- All renderers ([web](https://dioxuslabs.com/learn/0.4/getting_started/wasm), [desktop](https://dioxuslabs.com/learn/0.4/getting_started/desktop), [freya](https://github.com/marc2332/freya), etc)
-- Both WASM and native targets
+- **Dioxus v0.7** 🧬
+- Web, Desktop, and Blitz support
 
 ## Features
 - [x] **Renderer-agnostic**

src/mutation.rs

@@ -1,4 +1,10 @@
 use core::fmt;
+use dioxus::prelude::*;
+use dioxus::{
+    hooks::{use_memo, use_reactive},
+    signals::CopyValue,
+};
+use dioxus_core::{provide_root_context, spawn_forever, use_drop, ReactiveContext, Task};
 use std::{
     cell::{Ref, RefCell},
     collections::{HashMap, HashSet},
@@ -9,14 +15,14 @@ use std::{
     sync::{Arc, Mutex},
     time::Duration,
 };
-
-use dioxus_lib::prelude::*;
-use dioxus_lib::signals::{Readable, Writable};
-use dioxus_lib::{
-    hooks::{use_memo, use_reactive},
-    signals::CopyValue,
-};
+#[cfg(not(target_family = "wasm"))]
+use tokio::time;
+#[cfg(not(target_family = "wasm"))]
 use tokio::time::Instant;
+#[cfg(target_family = "wasm")]
+use wasmtimer::tokio as time;
+#[cfg(target_family = "wasm")]
+use web_time::Instant;
 
 pub trait MutationCapability
 where
@@ -180,14 +186,14 @@ impl<Q: MutationCapability> MutationsStorage<Q> {
 
         // Spawn clean up task if there no more reactive contexts
         if mutation_data.reactive_contexts.lock().unwrap().is_empty() {
-            *mutation_data.clean_task.borrow_mut() = spawn_forever(async move {
+            *mutation_data.clean_task.borrow_mut() = Some(spawn_forever(async move {
                 // Wait as long as the stale time is configured
-                tokio::time::sleep(mutation.clean_time).await;
+                time::sleep(mutation.clean_time).await;
 
                 // Finally clear the mutation
                 let mut storage = storage_clone.write();
                 storage.remove(&mutation);
-            });
+            }));
         }
     }
 

src/query.rs

@@ -10,16 +10,24 @@ use std::{
     time::Duration,
 };
 
-use ::warnings::Warning;
-use dioxus_lib::prelude::Task;
-use dioxus_lib::prelude::*;
-use dioxus_lib::signals::{Readable, Writable};
-use dioxus_lib::{
+use dioxus::prelude::*;
+use dioxus::{
     hooks::{use_memo, use_reactive},
     signals::CopyValue,
 };
+use dioxus_core::{
+    provide_root_context, spawn_forever, use_drop, ReactiveContext, SuspendedFuture, Task,
+};
 use futures_util::stream::{FuturesUnordered, StreamExt};
-use tokio::{sync::Notify, time::Instant};
+use tokio::sync::Notify;
+#[cfg(not(target_family = "wasm"))]
+use tokio::time;
+#[cfg(not(target_family = "wasm"))]
+use tokio::time::Instant;
+#[cfg(target_family = "wasm")]
+use wasmtimer::tokio as time;
+#[cfg(target_family = "wasm")]
+use web_time::Instant;
 
 pub trait QueryCapability
 where
@@ -222,13 +230,12 @@ impl<Q: QueryCapability> QueriesStorage<Q> {
             let task = spawn_forever(async move {
                 loop {
                     // Wait as long as the stale time is configured
-                    tokio::time::sleep(interval).await;
+                    time::sleep(interval).await;
 
                     // Run the query
                     QueriesStorage::<Q>::run_queries(&[(&query_clone, &query_data_clone)]).await;
                 }
-            })
-            .expect("Failed to spawn interval task.");
+            });
             *interval_task = Some((interval, task));
         }
 
@@ -248,14 +255,14 @@ impl<Q: QueryCapability> QueriesStorage<Q> {
 
         // Spawn clean up task if there no more reactive contexts
         if query_data.reactive_contexts.lock().unwrap().is_empty() {
-            *query_data.clean_task.borrow_mut() = spawn_forever(async move {
+            *query_data.clean_task.borrow_mut() = Some(spawn_forever(async move {
                 // Wait as long as the stale time is configured
-                tokio::time::sleep(query.clean_time).await;
+                time::sleep(query.clean_time).await;
 
                 // Finally clear the query
                 let mut storage = storage_clone.write();
                 storage.remove(&query);
-            });
+            }));
         }
     }
 
@@ -301,23 +308,23 @@ impl<Q: QueryCapability> QueriesStorage<Q> {
             for reactive_context in query_data.reactive_contexts.lock().unwrap().iter() {
                 reactive_context.mark_dirty();
             }
-        }
 
-        // Notify the suspense task if any
-        if let Some(suspense_task) = &*query_data.suspense_task.borrow() {
-            suspense_task.notifier.notify_waiters();
-        };
+            // Notify the suspense task if any
+            if let Some(suspense_task) = &*query_data.suspense_task.borrow() {
+                suspense_task.notifier.notify_waiters();
+            };
+        }
 
         // Spawn clean up task if there no more reactive contexts
         if query_data.reactive_contexts.lock().unwrap().is_empty() {
-            *query_data.clean_task.borrow_mut() = spawn_forever(async move {
+            *query_data.clean_task.borrow_mut() = Some(spawn_forever(async move {
                 // Wait as long as the stale time is configured
-                tokio::time::sleep(query.clean_time).await;
+                time::sleep(query.clean_time).await;
 
                 // Finally clear the query
                 let mut storage = storage.storage.write();
                 storage.remove(&query);
-            });
+            }));
         }
 
         QueryReader {
@@ -387,6 +394,11 @@ impl<Q: QueryCapability> QueriesStorage<Q> {
                 for reactive_context in query_data.reactive_contexts.lock().unwrap().iter() {
                     reactive_context.mark_dirty();
                 }
+
+                // Notify the suspense task if any
+                if let Some(suspense_task) = &*query_data.suspense_task.borrow() {
+                    suspense_task.notifier.notify_waiters();
+                };
             }));
         }
 
@@ -597,9 +609,6 @@ impl<Q: QueryCapability> UseQuery<Q> {
         Q::Ok: Clone,
         Q::Err: Clone,
     {
-        let _allow_write_in_component_body =
-            ::warnings::Allow::new(warnings::signal_write_in_component_body::ID);
-
         let storage = consume_context::<QueriesStorage<Q>>();
         let mut storage = storage.storage.write_unchecked();
         let query_data = storage.get_mut(&self.query.peek()).unwrap();