swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cargo check all

Browse Source
This commit is contained in:
Jonathan Kelley committed 2024-01-23 16:58:29 -08:00
1 parent a5e61b0765
commit c0522bc152
10 files changed
+123 -329
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/hooks/src/use_future.rs
+14 -34
View File
@@ -7,21 +7,14 @@ use dioxus_signals::*;
use futures_util::{future, pin_mut, FutureExt};
use std::{any::Any, cell::Cell, future::Future, pin::Pin, rc::Rc, sync::Arc, task::Poll};
/// A future that resolves to a value.
/// A hook that allows you to spawn a future
///
/// This runs the future only once - though the future may be regenerated
/// through the [`UseFuture::restart`] method.
///
/// This is commonly used for components that cannot be rendered until some
/// asynchronous operation has completed.
///
///
pub fn use_future<T, F>(mut future: impl FnMut() -> F) -> UseFuture<T>
/// Does not regenerate the future when dependencies change. If you're looking for a future that does, check out
/// `use_resource` instead.
pub fn use_future<F>(mut future: impl FnMut() -> F) -> UseFuture
where
T: 'static,
F: Future<Output = T> + 'static,
F: Future + 'static,
{
let mut value = use_signal(|| None);
let mut state = use_signal(|| UseFutureState::Pending);
let task = use_signal(|| {
@@ -47,22 +40,21 @@ where
.await;
// Set the value
value.set(Some(res));
// value.set(Some(res));
});
Some(task)
});
UseFuture { task, value, state }
UseFuture { task, state }
}
pub struct UseFuture<T: 'static> {
value: Signal<Option<T>>,
pub struct UseFuture {
task: Signal<Option<Task>>,
state: Signal<UseFutureState<T>>,
state: Signal<UseFutureState>,
}
impl<T> UseFuture<T> {
impl UseFuture {
/// Restart the future with new dependencies.
///
/// Will not cancel the previous future, but will ignore any values that it
@@ -79,18 +71,6 @@ impl<T> UseFuture<T> {
// }
}
// Manually set the value in the future slot without starting the future over
pub fn set(&mut self, new_value: T) {
self.value.set(Some(new_value));
}
/// 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) -> Signal<Option<T>> {
self.value
}
/// Get the ID of the future in Dioxus' internal scheduler
pub fn task(&self) -> Option<Task> {
todo!()
@@ -98,7 +78,7 @@ impl<T> UseFuture<T> {
}
/// Get the current state of the future.
pub fn state(&self) -> UseFutureState<T> {
pub fn state(&self) -> UseFutureState {
todo!()
// match (&self.task.get(), &self.value()) {
// // If we have a task and an existing value, we're reloading
@@ -116,8 +96,8 @@ impl<T> UseFuture<T> {
}
}
pub enum UseFutureState<T: 'static> {
pub enum UseFutureState {
Pending,
Complete(Signal<T>),
Regenerating(Signal<T>), // the old value
Complete,
Regenerating, // the old value
}
packages/hooks/src/use_on_destroy.rs
+2 -104
View File
@@ -1,4 +1,4 @@
use dioxus_core::use_hook;
use dioxus_core::{prelude::use_drop, use_hook};
#[deprecated(
note = "Use `use_on_destroy` instead, which has the same functionality. \
@@ -6,107 +6,5 @@ This is deprecated because of the introduction of `use_on_create` which is bette
The reason why `use_on_create` is not `use_on_mount` is because of potential confusion with `dioxus::events::onmounted`."
)]
pub fn use_on_unmount<D: FnOnce() + 'static>(destroy: D) {
use_on_destroy(destroy);
}
/// Creates a callback that will be run before the component is removed.
/// This can be used to clean up side effects from the component
/// (created with [`use_effect`](crate::use_effect)).
///
/// Example:
/// ```rust
/// use dioxus::prelude::*;
///
/// fn app() -> Element {
/// let state = use_signal(|| true);
/// rsx! {
/// for _ in 0..100 {
/// h1 {
/// "spacer"
/// }
/// }
/// if **state {
/// rsx! {
/// child_component {}
/// }
/// }
/// button {
/// onclick: move |_| {
/// state.set(!*state.get());
/// },
/// "Unmount element"
/// }
/// }
/// }
///
/// fn child_component() -> Element {
/// let original_scroll_position = use_signal(|| 0.0);
/// use_effect((), move |_| {
/// to_owned![original_scroll_position];
/// async move {
/// let window = web_sys::window().unwrap();
/// let document = window.document().unwrap();
/// let element = document.get_element_by_id("my_element").unwrap();
/// element.scroll_into_view();
/// original_scroll_position.set(window.scroll_y().unwrap());
/// }
/// });
///
/// use_on_destroy({
/// to_owned![original_scroll_position];
/// /// restore scroll to the top of the page
/// move || {
/// let window = web_sys::window().unwrap();
/// window.scroll_with_x_and_y(*original_scroll_position.current(), 0.0);
/// }
/// });
///
/// rsx!{
/// div {
/// id: "my_element",
/// "hello"
/// }
/// }
/// }
/// ```
pub fn use_on_destroy<D: FnOnce() + 'static>(destroy: D) {
struct LifeCycle<D: FnOnce()> {
/// Wrap the closure in an option so that we can take it out on drop.
ondestroy: Option<D>,
}
/// On drop, we want to run the closure.
impl<D: FnOnce()> Drop for LifeCycle<D> {
fn drop(&mut self) {
if let Some(f) = self.ondestroy.take() {
f();
}
}
}
// We need to impl clone for the lifecycle, but we don't want the drop handler for the closure to be called twice.
impl<D: FnOnce()> Clone for LifeCycle<D> {
fn clone(&self) -> Self {
Self { ondestroy: None }
}
}
use_hook(|| LifeCycle {
ondestroy: Some(destroy),
});
}
/// Creates a callback that will be run before the component is dropped
pub fn use_on_drop<D: FnOnce() + 'static>(ondrop: D) {
use_on_destroy(ondrop);
}
pub fn use_hook_with_cleanup<T: Clone + 'static>(
hook: impl FnOnce() -> T,
cleanup: impl FnOnce(T) + 'static,
) -> T {
let value = use_hook(hook);
let _value = value.clone();
use_on_destroy(move || cleanup(_value));
value
use_drop(destroy);
}