Move TaskFuture to composer module

src/composer.rs

@@ -1,4 +1,4 @@
-use crate::{prelude::*, ScopeData, TaskWaker};
+use crate::{prelude::*, ScopeData};
 use compose::AnyCompose;
 use slotmap::{DefaultKey, SlotMap};
 use std::{
@@ -7,7 +7,7 @@ use std::{
     pin::Pin,
     rc::Rc,
     sync::{mpsc, Arc},
-    task::{Context, Waker},
+    task::{Context, Wake, Waker},
 };
 use tokio::sync::{RwLock, RwLockWriteGuard};
 
@@ -111,6 +111,24 @@ impl<U: Updater> Updater for UpdateWrapper<U> {
     }
 }
 
+struct TaskWaker {
+    key: DefaultKey,
+    updater: Arc<dyn Updater>,
+    tx: mpsc::Sender<DefaultKey>,
+}
+
+impl Wake for TaskWaker {
+    fn wake(self: Arc<Self>) {
+        let key = self.key;
+        let pending = self.tx.clone();
+        self.updater.update(Update {
+            f: Box::new(move || {
+                pending.send(key).unwrap();
+            }),
+        });
+    }
+}
+
 /// Composer for composable content.
 pub struct Composer {
     compose: Box<dyn AnyCompose>,

src/lib.rs

@@ -100,8 +100,7 @@
 #![deny(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
-use composer::{Runtime, Update, Updater};
-use slotmap::DefaultKey;
+use composer::Runtime;
 use std::{
     any::{Any, TypeId},
     cell::{Cell, RefCell, UnsafeCell},
@@ -115,8 +114,7 @@ use std::{
     pin::Pin,
     ptr::NonNull,
     rc::Rc,
-    sync::{mpsc, Arc},
-    task::Wake,
+    sync::Arc,
 };
 use thiserror::Error;
 
@@ -943,24 +941,6 @@ pub fn use_drop<'a>(cx: ScopeState<'a>, f: impl FnOnce() + 'a) {
     }
 }
 
-struct TaskWaker {
-    key: DefaultKey,
-    updater: Arc<dyn Updater>,
-    tx: mpsc::Sender<DefaultKey>,
-}
-
-impl Wake for TaskWaker {
-    fn wake(self: Arc<Self>) {
-        let key = self.key;
-        let pending = self.tx.clone();
-        self.updater.update(Update {
-            f: Box::new(move || {
-                pending.send(key).unwrap();
-            }),
-        });
-    }
-}
-
 /// Use a local task that runs on the current thread.
 ///
 /// This will run on the window event loop, polling the task until it completes.