151 lines
4.7 KiB
Rust
151 lines
4.7 KiB
Rust
use dioxus::prelude::*;
|
|
use serde::{de::DeserializeOwned, Serialize};
|
|
use std::any::Any;
|
|
use std::cell::Cell;
|
|
use std::cell::Ref;
|
|
use std::cell::RefCell;
|
|
use std::fmt::Debug;
|
|
use std::future::Future;
|
|
use std::rc::Rc;
|
|
use std::sync::Arc;
|
|
|
|
/// A future that resolves to a value.
|
|
///
|
|
/// This runs the future only once - though the future may be regenerated
|
|
/// through the [`UseServerFuture::restart`] method.
|
|
///
|
|
/// This is commonly used for components that cannot be rendered until some
|
|
/// asynchronous operation has completed.
|
|
///
|
|
/// Whenever the hooks dependencies change, the future will be re-evaluated.
|
|
/// If a future is pending when the dependencies change, the previous future
|
|
/// 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<T, F>(future: impl FnOnce() -> F) -> Option<UseServerFuture<T>>
|
|
where
|
|
T: 'static + Serialize + DeserializeOwned + Debug,
|
|
F: Future<Output = T> + 'static,
|
|
{
|
|
todo!()
|
|
|
|
// let state = use_hook(move || UseServerFuture {
|
|
// update: schedule_update(),
|
|
// needs_regen: Cell::new(true),
|
|
// value: Default::default(),
|
|
// task: Cell::new(None),
|
|
// dependencies: Vec::new(),
|
|
// });
|
|
|
|
// let first_run = { state.value.borrow().as_ref().is_none() && state.task.get().is_none() };
|
|
|
|
// #[cfg(not(feature = "ssr"))]
|
|
// {
|
|
// if first_run {
|
|
// match crate::html_storage::deserialize::take_server_data() {
|
|
// Some(data) => {
|
|
// tracing::trace!("Loaded {data:?} from server");
|
|
// *state.value.borrow_mut() = Some(Box::new(data));
|
|
// state.needs_regen.set(false);
|
|
// return Some(state);
|
|
// }
|
|
// None => {
|
|
// tracing::trace!("Failed to load from server... running future");
|
|
// }
|
|
// };
|
|
// }
|
|
// }
|
|
|
|
// if dependencies.clone().apply(&mut state.dependencies) || state.needs_regen.get() {
|
|
// // We don't need regen anymore
|
|
// state.needs_regen.set(false);
|
|
|
|
// // Create the new future
|
|
// let fut = future(dependencies.out());
|
|
|
|
// // Clone in our cells
|
|
// let value = state.value.clone();
|
|
// let schedule_update = state.update.clone();
|
|
|
|
// // Cancel the current future
|
|
// if let Some(current) = state.task.take() {
|
|
// cx.remove_future(current);
|
|
// }
|
|
|
|
// state.task.set(Some(cx.push_future(async move {
|
|
// let data;
|
|
// #[cfg(feature = "ssr")]
|
|
// {
|
|
// data = fut.await;
|
|
// if first_run {
|
|
// if let Err(err) = crate::prelude::server_context().push_html_data(&data) {
|
|
// tracing::error!("Failed to push HTML data: {}", err);
|
|
// };
|
|
// }
|
|
// }
|
|
// #[cfg(not(feature = "ssr"))]
|
|
// {
|
|
// data = fut.await;
|
|
// }
|
|
// *value.borrow_mut() = Some(Box::new(data));
|
|
|
|
// schedule_update();
|
|
// })));
|
|
// }
|
|
|
|
// if first_run {
|
|
// #[cfg(feature = "ssr")]
|
|
// {
|
|
// tracing::trace!("Suspending first run of use_server_future");
|
|
// cx.suspend();
|
|
// }
|
|
// None
|
|
// } else {
|
|
// Some(state)
|
|
// }
|
|
}
|
|
|
|
pub struct UseServerFuture<T> {
|
|
update: Arc<dyn Fn()>,
|
|
needs_regen: Cell<bool>,
|
|
task: Cell<Option<Task>>,
|
|
dependencies: Vec<Box<dyn Any>>,
|
|
value: Rc<RefCell<Option<Box<T>>>>,
|
|
}
|
|
|
|
impl<T> UseServerFuture<T> {
|
|
// /// Restart the future with new dependencies.
|
|
// ///
|
|
// /// Will not cancel the previous future, but will ignore any values that it
|
|
// /// generates.
|
|
// pub fn restart(&self) {
|
|
// self.needs_regen.set(true);
|
|
// (self.update)();
|
|
// }
|
|
|
|
// /// Forcefully cancel a future
|
|
// pub fn cancel(&self) {
|
|
// if let Some(task) = self.task.take() {
|
|
// cx.remove_future(task);
|
|
// }
|
|
// }
|
|
|
|
// /// Return any value, even old values if the future has not yet resolved.
|
|
// ///
|
|
// /// If the future has never completed, the returned value will be `None`.
|
|
// pub fn value(&self) -> Ref<'_, T> {
|
|
// Ref::map(self.value.borrow(), |v| v.as_deref().unwrap())
|
|
// }
|
|
|
|
// /// Get the ID of the future in Dioxus' internal scheduler
|
|
// pub fn task(&self) -> Option<Task> {
|
|
// self.task.get()
|
|
// }
|
|
|
|
// /// Get the current state of the future.
|
|
// pub fn reloading(&self) -> bool {
|
|
// self.task.get().is_some()
|
|
// }
|
|
}
|