context 与全局 signal

pub fn try_use_context<T: 'static + Clone>() -> Option<T> {
    use_hook(|| try_consume_context::<T>())
}

pub fn use_context<T: 'static + Clone>() -> T {
    use_hook(|| consume_context::<T>())
}

pub fn use_context_provider<T: 'static + Clone>(f: impl FnOnce() -> T) -> T {
    use_hook(|| provide_context(f()))
}

pub fn use_root_context<T: 'static + Clone>(new: impl FnOnce() -> T) -> T {
    use_hook(|| {
        try_consume_context::<T>()
            // If no context is provided, create a new one at the root
            .unwrap_or_else(|| provide_root_context(new()))
    })
}

static COUNT: GlobalSignal<i32> = Signal::global(|| 0);

pub struct Global<T, R = T> {
    constructor: fn() -> R,
    key: GlobalKey<'static>,
    phantom: std::marker::PhantomData<fn() -> T>,
}

    pub fn resolve(&self) -> T
    where
        T: 'static,
    {
        let key = self.key();

        let context = get_global_context();

        // Get the entry if it already exists
        let mut evicted_stale_entry = false;
        {
            let read = context.map.borrow();
            if let Some(signal) = read.get(&key) {
                if let Some(signal) = signal.downcast_ref::<T>() {
                    return signal.clone();
                }
                evicted_stale_entry = true;
            }
        }

        if evicted_stale_entry {
            context.map.borrow_mut().remove(&key);
        }
        // Otherwise, create it
        // Constructors are always run in the root scope
        let signal = dioxus_core::Runtime::current().in_scope(ScopeId::ROOT, || {
            T::initialize_from_function(self.constructor)
        });
        context
            .map
            .borrow_mut()
            .insert(key, Box::new(signal.clone()));
        signal
    }

pub fn get_global_context() -> GlobalLazyContext {
    let rt = Runtime::current();
    match rt.has_context(ScopeId::ROOT) {
        Some(context) => context,
        None => rt.provide_context(ScopeId::ROOT, Default::default()),
    }
}

static COUNT: GlobalSignal<i32> = Signal::global(|| {
  log("  [COUNT constructor runs]");
  0
});
static DOUBLE: GlobalMemo<i32> = Signal::global_memo(|| COUNT() * 2);
static SHARED: Mutex<i32> = Mutex::new(0);

fn app() -> Element {
  use_hook(|| *SHARED.lock().unwrap() += 1); // once per mount
  rsx! { "COUNT={COUNT} DOUBLE={DOUBLE} SHARED={SHARED.lock().unwrap()}" }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  log(format!("size_of_val(&COUNT) = {}", std::mem::size_of_val(&COUNT)));
  let mut dom1 = VirtualDom::new(app);
  dom1.rebuild_in_place();
  log(format!("dom1: {}", dioxus_ssr::render(&dom1)));
  let mut dom2 = VirtualDom::new(app);
  dom2.rebuild_in_place();
  log(format!("dom2: {}", dioxus_ssr::render(&dom2)));
  dom1.in_runtime(|| *COUNT.write() += 100);
  dom1.process_events();
  dom1.render_immediate_to_vec();
  log(format!("dom1 after +100: {}", dioxus_ssr::render(&dom1)));
  log(format!("dom2 untouched:  {}", dioxus_ssr::render(&dom2)));
  log(format!("COUNT id in dom1 = {:?}", dom1.in_runtime(|| COUNT.id())));
  log(format!("COUNT id in dom2 = {:?}", dom2.in_runtime(|| COUNT.id())));
  drop(dom1);
  let mut dom3 = VirtualDom::new(app);
  dom3.rebuild_in_place();
  log(format!("dom3 (after dom1 dropped): {}", dioxus_ssr::render(&dom3)));
  *SHARED.lock().unwrap() = 99;
  let woke = tokio::time::timeout(std::time::Duration::from_millis(50), dom3.wait_for_work()).await.is_ok();
  log(format!("SHARED = 99 -> dom3 has work: {woke}"));
  dom3.in_runtime(|| *COUNT.write() = 7);
  let woke = tokio::time::timeout(std::time::Duration::from_millis(50), dom3.wait_for_work()).await.is_ok();
  log(format!("COUNT = 7  -> dom3 has work: {woke}"));
  dom3.render_immediate_to_vec();
  log(format!("dom3: {}", dioxus_ssr::render(&dom3)));
  let r = std::panic::catch_unwind(|| COUNT.peek().clone());
  log(format!("outside any VirtualDom: is_err={}", r.is_err()));
}

static VISITS: GlobalSignal<u32> = Signal::global(|| 0);
static SHARED: AtomicU32 = AtomicU32::new(0);

#[post("/api/slow")]
async fn slow(ms: u64) -> Result<u64, ServerFnError> {
  tokio::time::sleep(std::time::Duration::from_millis(ms)).await;
  Ok(ms)
}

#[get("/api/peek")]
async fn peek_global() -> Result<u32, ServerFnError> {
  Ok(*VISITS.peek())
}

fn app() -> Element {
  // once per VirtualDom (once per request on the server)
  let (global_at_mount, shared_at_mount) = use_hook(|| {
    *VISITS.write() += 1;
    (*VISITS.peek(), SHARED.fetch_add(1, Ordering::SeqCst) + 1)
  });
  let waited = use_server_future(|| async { slow(300).await })?;
  rsx! {
    div { id: "out",
      "global_at_mount={global_at_mount} shared_at_mount={shared_at_mount} "
      "after_wait: global={VISITS} shared={SHARED.load(Ordering::SeqCst)} waited={waited():?}"
    }
  }
}

<div id="out" data-node-hydration="0"><!--node-id1-->global_at_mount=1 shared_at_mount=2 <!--#--><!--node-id2-->after_wait: global=1 shared=2 waited=Some(Ok(300))<!--#--></div>
 t=0.303963
<div id="out" data-node-hydration="0"><!--node-id1-->global_at_mount=1 shared_at_mount=1 <!--#--><!--node-id2-->after_wait: global=1 shared=2 waited=Some(Ok(300))<!--#--></div>
 t=0.302841
-- third, sequential
<div id="out" data-node-hydration="0"><!--node-id1-->global_at_mount=1 shared_at_mount=3 <!--#--><!--node-id2-->after_wait: global=1 shared=3 waited=Some(Ok(300))<!--#--></div>

HTTP/1.1 500 Internal Server Error
content-length: 1239
date: Wed, 28 Oct 2026 11:58:37 GMT

Server function panicked: task 23 panicked with message "Must be called from inside a Dioxus runtime.\n\nHelp: Some APIs in dioxus require a global runtime to be present.\n ...

<div id="out" data-node-hydration="0"><!--node-id1-->global_at_mount=1 shared_at_mount=1 <!--#--><!--node-id2-->after_wait: global=1 shared=1 waited=Some(Ok(300)) peeked=Some(Ok(1))<!--#--></div>

size_of_val(&COUNT) = 40
  [COUNT constructor runs]
dom1: COUNT=0 DOUBLE=0 SHARED=1
  [COUNT constructor runs]
dom2: COUNT=0 DOUBLE=0 SHARED=2
dom1 after +100: COUNT=100 DOUBLE=200 SHARED=2
dom2 untouched:  COUNT=0 DOUBLE=0 SHARED=2
COUNT id in dom1 = 0x101a9f218@1
COUNT id in dom2 = 0x759102c428@1
  [COUNT constructor runs]
dom3 (after dom1 dropped): COUNT=0 DOUBLE=0 SHARED=3
SHARED = 99 -> dom3 has work: false
COUNT = 7  -> dom3 has work: true
dom3: COUNT=7 DOUBLE=14 SHARED=99
thread 'main' (1943975) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dioxus-core-0.7.10/src/runtime.rs:100:17:
Must be called from inside a Dioxus runtime.
...
outside any VirtualDom: is_err=true