feat: make hooks free-functions

packages/core/src/hooks.rs

@@ -0,0 +1,256 @@
+//! Built-in hooks
+//!
+//! This module contains all the low-level built-in hooks that require 1st party support to work.
+//!
+//! Hooks:
+//! - use_hook
+//! - use_state_provider
+//! - use_state_consumer
+//! - use_task
+//! - use_suspense
+
+use crate::innerlude::*;
+use futures_util::FutureExt;
+use std::{
+    any::{Any, TypeId},
+    cell::{Cell, RefCell},
+    future::Future,
+    rc::Rc,
+};
+
+/// This hook enables the ability to expose state to children further down the VirtualDOM Tree.
+///
+/// This is a hook, so it may not be called conditionally!
+///
+/// The init method is ran *only* on first use, otherwise it is ignored. However, it uses hooks (ie `use`)
+/// so don't put it in a conditional.
+///
+/// When the component is dropped, so is the context. Be aware of this behavior when consuming
+/// the context via Rc/Weak.
+///
+///
+///
+pub fn use_provide_state<'src, Pr, T, F>(cx: Context<'src, Pr>, init: F) -> &'src Rc<T>
+where
+    T: 'static,
+    F: FnOnce() -> T,
+{
+    let ty = TypeId::of::<T>();
+    let contains_key = cx.scope.shared_contexts.borrow().contains_key(&ty);
+
+    let is_initialized = cx.use_hook(
+        |_| false,
+        |s| {
+            let i = s.clone();
+            *s = true;
+            i
+        },
+        |_| {},
+    );
+
+    match (is_initialized, contains_key) {
+        // Do nothing, already initialized and already exists
+        (true, true) => {}
+
+        // Needs to be initialized
+        (false, false) => {
+            log::debug!("Initializing context...");
+            cx.add_shared_state(init());
+            log::info!(
+                "There are now {} shared contexts for scope {:?}",
+                cx.scope.shared_contexts.borrow().len(),
+                cx.scope.our_arena_idx,
+            );
+        }
+
+        _ => debug_assert!(false, "Cannot initialize two contexts of the same type"),
+    };
+
+    use_consume_state::<T, _>(cx)
+}
+
+/// There are hooks going on here!
+pub fn use_consume_state<'src, T: 'static, P>(cx: Context<'src, P>) -> &'src Rc<T> {
+    use_try_consume_state::<T, _>(cx).unwrap()
+}
+
+/// Uses a context, storing the cached value around
+///
+/// If a context is not found on the first search, then this call will be  "dud", always returning "None" even if a
+/// context was added later. This allows using another hook as a fallback
+///
+pub fn use_try_consume_state<'src, T: 'static, P>(cx: Context<'src, P>) -> Option<&'src Rc<T>> {
+    struct UseContextHook<C>(Option<Rc<C>>);
+
+    cx.use_hook(
+        move |_| UseContextHook(cx.consume_shared_state::<T>()),
+        move |hook| hook.0.as_ref(),
+        |_| {},
+    )
+}
+
+/// Awaits the given task, forcing the component to re-render when the value is ready.
+///
+///
+///
+///
+pub fn use_task<'src, Out, Fut, Init, P>(
+    cx: Context<'src, P>,
+    task_initializer: Init,
+) -> (&'src TaskHandle, &'src Option<Out>)
+where
+    Out: 'static,
+    Fut: Future<Output = Out> + 'static,
+    Init: FnOnce() -> Fut + 'src,
+{
+    struct TaskHook<T> {
+        handle: TaskHandle,
+        task_dump: Rc<RefCell<Option<T>>>,
+        value: Option<T>,
+    }
+
+    // whenever the task is complete, save it into th
+    cx.use_hook(
+        move |hook_idx| {
+            let task_fut = task_initializer();
+
+            let task_dump = Rc::new(RefCell::new(None));
+
+            let slot = task_dump.clone();
+
+            let updater = cx.prepare_update();
+            let update_id = cx.get_scope_id();
+
+            let originator = cx.scope.our_arena_idx.clone();
+
+            let handle = cx.submit_task(Box::pin(task_fut.then(move |output| async move {
+                *slot.as_ref().borrow_mut() = Some(output);
+                updater(update_id);
+                EventTrigger {
+                    event: VirtualEvent::AsyncEvent { hook_idx },
+                    originator,
+                    priority: EventPriority::Low,
+                    real_node_id: None,
+                }
+            })));
+
+            TaskHook {
+                task_dump,
+                value: None,
+                handle,
+            }
+        },
+        |hook| {
+            if let Some(val) = hook.task_dump.as_ref().borrow_mut().take() {
+                hook.value = Some(val);
+            }
+            (&hook.handle, &hook.value)
+        },
+        |_| {},
+    )
+}
+
+/// Asynchronously render new nodes once the given future has completed.
+///
+/// # Easda
+///
+///
+///
+///
+/// # Example
+///
+///
+pub fn use_suspense<'src, Out, Fut, Cb, P>(
+    cx: Context<'src, P>,
+    task_initializer: impl FnOnce() -> Fut,
+    user_callback: Cb,
+) -> DomTree<'src>
+where
+    Fut: Future<Output = Out> + 'static,
+    Out: 'static,
+    Cb: for<'a> Fn(SuspendedContext<'a>, &Out) -> DomTree<'a> + 'static,
+{
+    cx.use_hook(
+        move |hook_idx| {
+            let value = Rc::new(RefCell::new(None));
+
+            let dom_node_id = Rc::new(empty_cell());
+            let domnode = dom_node_id.clone();
+
+            let slot = value.clone();
+
+            let callback: SuspendedCallback = Box::new(move |ctx: SuspendedContext| {
+                let v: std::cell::Ref<Option<Box<dyn Any>>> = slot.as_ref().borrow();
+                match v.as_ref() {
+                    Some(a) => {
+                        let v: &dyn Any = a.as_ref();
+                        let real_val = v.downcast_ref::<Out>().unwrap();
+                        user_callback(ctx, real_val)
+                    }
+                    None => {
+                        //
+                        Some(VNode {
+                            dom_id: empty_cell(),
+                            key: None,
+                            kind: VNodeKind::Suspended {
+                                node: domnode.clone(),
+                            },
+                        })
+                    }
+                }
+            });
+
+            let originator = cx.scope.our_arena_idx.clone();
+            let task_fut = task_initializer();
+            let domnode = dom_node_id.clone();
+
+            let slot = value.clone();
+            cx.submit_task(Box::pin(task_fut.then(move |output| async move {
+                // When the new value arrives, set the hooks internal slot
+                // Dioxus will call the user's callback to generate new nodes outside of the diffing system
+                *slot.borrow_mut() = Some(Box::new(output) as Box<dyn Any>);
+                EventTrigger {
+                    event: VirtualEvent::SuspenseEvent { hook_idx, domnode },
+                    originator,
+                    priority: EventPriority::Low,
+                    real_node_id: None,
+                }
+            })));
+
+            SuspenseHook {
+                value,
+                callback,
+                dom_node_id,
+            }
+        },
+        move |hook| {
+            let cx = Context {
+                scope: &cx.scope,
+                props: &(),
+            };
+            let csx = SuspendedContext { inner: cx };
+            (&hook.callback)(csx)
+        },
+        |_| {},
+    )
+}
+
+pub(crate) struct SuspenseHook {
+    pub value: Rc<RefCell<Option<Box<dyn Any>>>>,
+    pub callback: SuspendedCallback,
+    pub dom_node_id: Rc<Cell<Option<ElementId>>>,
+}
+type SuspendedCallback = Box<dyn for<'a> Fn(SuspendedContext<'a>) -> DomTree<'a>>;
+pub struct SuspendedContext<'a> {
+    pub(crate) inner: Context<'a, ()>,
+}
+impl<'src> SuspendedContext<'src> {
+    pub fn render<F: FnOnce(NodeFactory<'src>) -> VNode<'src>>(
+        self,
+        lazy_nodes: LazyNodes<'src, F>,
+    ) -> DomTree<'src> {
+        let scope_ref = self.inner.scope;
+
+        Some(lazy_nodes.into_vnode(NodeFactory { scope: scope_ref }))
+    }
+}