dioxus-mirror/packages/hooks/docs/old.md

mod use2 {

#![allow(missing_docs)]

use dioxus_core::{ScopeState, TaskId};
use std::{
    any::Any,
    cell::{Cell, RefCell},
    future::Future,
    rc::Rc,
};

/// A future that resolves to a value.
///
/// 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<'a>(
    // pub fn use_future<'a, T: 'static, F: Future<Output = T> + 'static>(
    cx: &'a ScopeState,
) -> &'a UseFuture<()> {
    //     let state = cx.use_hook(move |_| UseFuture {
    //         update: cx.schedule_update(),
    //         needs_regen: Cell::new(true),
    //         slot: Rc::new(Cell::new(None)),
    //         value: None,
    //         task: None,
    //         pending: true,
    //         dep_cont: Cell::new(0),
    //         deps: RefCell::new(Vec::new()),
    //         first_time: true,
    //     });

    //     if let Some(value) = state.slot.take() {
    //         state.value = Some(value);
    //         state.task = None;
    //     }

    //     if state.needs_regen.get() {
    //         // We don't need regen anymore
    //         state.needs_regen.set(false);
    //         state.pending = false;

    //         // Create the new future
    //         let fut = new_fut();

    //         // Clone in our cells
    //         let slot = state.slot.clone();
    //         let updater = state.update.clone();

    //         state.task = Some(cx.push_future(async move {
    //             let res = fut.await;
    //             slot.set(Some(res));
    //             updater();
    //         }));
    //     }

    //     state.first_time = false;

    //     state

    // new_fut: impl FnOnce() -> F,

    todo!()
}

pub enum FutureState<'a, T> {
    Pending,
    Complete(&'a T),
    Regenerating(&'a T), // the old value
}

pub struct UseFuture<T> {
    update: Rc<dyn Fn()>,
    needs_regen: Cell<bool>,
    value: Option<T>,
    slot: Rc<Cell<Option<T>>>,
    task: Option<TaskId>,
    pending: bool,
    deps: RefCell<Vec<Box<dyn Any>>>,
    dep_cont: Cell<usize>,
    first_time: bool,
}

impl<T> UseFuture<T> {
    pub fn restart(&self) {
        self.needs_regen.set(true);
        (self.update)();
    }

    // clears the value in the future slot without starting the future over
    pub fn clear(&self) -> Option<T> {
        (self.update)();
        self.slot.replace(None)
    }

    // Manually set the value in the future slot without starting the future over
    pub fn set(&self, new_value: T) {
        self.slot.set(Some(new_value));
        self.needs_regen.set(true);
        (self.update)();
    }

    pub fn value(&self) -> Option<&T> {
        self.value.as_ref()
    }

    pub fn state(&self) -> FutureState<T> {
        // self.value.as_ref()
        FutureState::Pending
    }

    pub fn build<F>(&self, new_fut: impl FnOnce() -> F) {}
}

#[test]
fn test_use_future_deps() {
    use dioxus_core::prelude::*;

    struct MyProps {
        val: String,
        name: i32,
    }

    fn app(cx: Scope<MyProps>) -> Element {
        let MyProps { val, name } = cx.props;

        // let val = use_c(&cx)
        //     .use_dep(val)
        //     .restart_if(|| false)
        //     .use_dep(name)
        //     .build(|(val, name)| async move {});

        // async fn fetch_thing(name: String, num: i32) -> String {
        //     format!("{} {}", name, num)
        // }

        // let val = use_future(&cx, || fetch_thing(val.clone(), *name))
        //     .with_dep(val)
        //     .with_dep(name)
        //     .restart_if(|| false);

        None
    }
}

// pub struct CoroutineBuilder<'a, const PARAM: usize> {
//     deps: Vec<Box<dyn Any>>,
//     cx: &'a ScopeState,
// }

// macro_rules! dep_impl {
//     ($id1:literal to $id2:literal) => {
//         impl<'a> CoroutineBuilder<'a, $id1> {
//             pub fn use_dep<F: 'static + PartialEq + Clone>(
//                 mut self,
//                 dep: &F,
//             ) -> CoroutineBuilder<'a, $id2> {
//                 self.deps.push(Box::new(dep.clone()));
//                 unsafe { std::mem::transmute(self) }
//             }
//         }
//     };
// }

// dep_impl!(0 to 1);
// dep_impl!(1 to 2);
// dep_impl!(2 to 3);
// dep_impl!(3 to 4);
// dep_impl!(4 to 5);
// dep_impl!(5 to 6);
// dep_impl!(6 to 7);
// dep_impl!(7 to 8);
// dep_impl!(8 to 9);

}