use std::any::{Any, TypeId};
use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
thread_local! {
static CURRENT_SUBSCRIBER: RefCell<Option<Subscriber>> = const { RefCell::new(None) };
static ROOT_EFFECTS: RefCell<Vec<Rc<EffectState>>> = const { RefCell::new(Vec::new()) };
static BATCH_DEPTH: Cell<u32> = const { Cell::new(0) };
static BATCHED_EFFECTS: RefCell<Vec<Rc<EffectState>>> = const { RefCell::new(Vec::new()) };
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
static FLUSH_DEPTH: Cell<u32> = const { Cell::new(0) };
#[cfg(feature = "web")]
static PENDING_EFFECTS: RefCell<Vec<Rc<EffectState>>> = const { RefCell::new(Vec::new()) };
#[cfg(feature = "web")]
static MICROTASK_QUEUED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
#[cfg(all(feature = "web", target_arch = "wasm32"))]
static DRAIN_CHAIN_DEPTH: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
}
#[derive(Clone)]
enum Subscriber {
Effect(Weak<EffectState>),
Memo(Weak<MemoState>),
}
impl Subscriber {
fn same_node(&self, other: &Subscriber) -> bool {
match (self, other) {
(Self::Effect(a), Self::Effect(b)) => Weak::ptr_eq(a, b),
(Self::Memo(a), Self::Memo(b)) => Weak::ptr_eq(a, b),
_ => false,
}
}
fn is_alive(&self) -> bool {
match self {
Self::Effect(weak) => weak.strong_count() > 0,
Self::Memo(weak) => weak.strong_count() > 0,
}
}
}
fn push_subscriber(list: &mut Vec<Subscriber>, subscriber: &Subscriber) {
let mut already_subscribed = false;
list.retain(|existing| {
if !existing.is_alive() {
return false;
}
if existing.same_node(subscriber) {
already_subscribed = true;
}
true
});
if !already_subscribed {
list.push(subscriber.clone());
}
}
struct SubscriberGuard {
previous: Option<Subscriber>,
}
impl SubscriberGuard {
fn swap_in(next: Option<Subscriber>) -> Self {
Self {
previous: CURRENT_SUBSCRIBER.with(|current| current.replace(next)),
}
}
}
impl Drop for SubscriberGuard {
fn drop(&mut self) {
CURRENT_SUBSCRIBER.with(|current| {
current.replace(self.previous.take());
});
}
}
thread_local! {
static CURRENT_OWNER: RefCell<Option<Rc<OwnerState>>> = const { RefCell::new(None) };
}
struct OwnerState {
parent: Option<Rc<OwnerState>>,
contexts: RefCell<Vec<(TypeId, Rc<dyn Any>)>>,
disposed: Cell<bool>,
}
impl OwnerState {
fn child_of_current() -> Rc<Self> {
Rc::new(Self {
parent: CURRENT_OWNER.with(|current| current.borrow().clone()),
contexts: RefCell::new(Vec::new()),
disposed: Cell::new(false),
})
}
fn clear_contexts(&self) {
let contexts = std::mem::take(&mut *self.contexts.borrow_mut());
drop(contexts);
}
fn dispose(&self) {
self.disposed.set(true);
self.clear_contexts();
}
}
struct OwnerGuard {
previous: Option<Rc<OwnerState>>,
}
impl OwnerGuard {
fn swap_in(next: Rc<OwnerState>) -> Self {
Self {
previous: CURRENT_OWNER.with(|current| current.replace(Some(next))),
}
}
}
impl Drop for OwnerGuard {
fn drop(&mut self) {
CURRENT_OWNER.with(|current| {
current.replace(self.previous.take());
});
}
}
#[derive(Clone)]
pub struct Owner {
state: Rc<OwnerState>,
}
impl Owner {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self {
state: OwnerState::child_of_current(),
}
}
pub fn current() -> Option<Self> {
CURRENT_OWNER.with(|current| current.borrow().clone().map(|state| Self { state }))
}
pub fn with<T>(&self, f: impl FnOnce() -> T) -> T {
let _guard = OwnerGuard::swap_in(self.state.clone());
f()
}
pub fn dispose(&self) {
self.state.dispose();
}
}
pub fn with_owner<T>(f: impl FnOnce() -> T) -> T {
Owner::new().with(f)
}
pub fn provide_context<T: Clone + 'static>(value: T) {
let Some(owner) = CURRENT_OWNER.with(|current| current.borrow().clone()) else {
tracing::warn!(
krab.context_type = std::any::type_name::<T>(),
"context_provided_without_owner"
);
return;
};
if owner.disposed.get() {
return;
}
let value: Rc<dyn Any> = Rc::new(value);
let id = TypeId::of::<T>();
let replaced = {
let mut contexts = owner.contexts.borrow_mut();
match contexts.iter_mut().find(|(existing, _)| *existing == id) {
Some(slot) => Some(std::mem::replace(&mut slot.1, value)),
None => {
contexts.push((id, value));
None
}
}
};
drop(replaced);
}
pub fn use_context<T: Clone + 'static>() -> Option<T> {
let id = TypeId::of::<T>();
let mut owner = CURRENT_OWNER.with(|current| current.borrow().clone());
while let Some(state) = owner {
let found = state
.contexts
.borrow()
.iter()
.find(|(existing, _)| *existing == id)
.map(|(_, value)| value.clone());
if let Some(value) = found {
return value.downcast_ref::<T>().cloned();
}
owner = state.parent.clone();
}
None
}
struct MemoState {
dirty: Cell<bool>,
computing: Cell<bool>,
recompute: RefCell<Option<Box<dyn Fn()>>>,
subscribers: RefCell<Vec<Subscriber>>,
disposed: Cell<bool>,
owner: Rc<OwnerState>,
}
impl MemoState {
fn recompute_now(self: &Rc<Self>) {
self.dirty.set(false);
self.computing.set(true);
let _subscriber = SubscriberGuard::swap_in(Some(Subscriber::Memo(Rc::downgrade(self))));
self.owner.clear_contexts();
let _owner = OwnerGuard::swap_in(self.owner.clone());
struct RecomputeGuard<'a> {
state: &'a MemoState,
compute: Option<Box<dyn Fn()>>,
completed: bool,
}
impl Drop for RecomputeGuard<'_> {
fn drop(&mut self) {
self.state.computing.set(false);
*self.state.recompute.borrow_mut() = self.compute.take();
if !self.completed {
self.state.dirty.set(true);
}
}
}
let mut guard = RecomputeGuard {
state: self,
compute: self.recompute.borrow_mut().take(),
completed: false,
};
if let Some(compute) = guard.compute.as_ref() {
compute();
}
guard.completed = true;
}
}
struct EffectState {
execute: Box<dyn Fn()>,
disposed: Cell<bool>,
running: Cell<bool>,
rerun_requested: Cell<bool>,
cycle_reported: Cell<bool>,
children: RefCell<Vec<Rc<EffectState>>>,
owned_memos: RefCell<Vec<Rc<MemoState>>>,
cleanups: RefCell<Vec<Box<dyn FnOnce()>>>,
owner: Rc<OwnerState>,
}
impl EffectState {
fn run(&self) {
(self.execute)();
}
fn dispose_children(&self) {
let cleanups = std::mem::take(&mut *self.cleanups.borrow_mut());
for cleanup in cleanups {
cleanup();
}
let memos = std::mem::take(&mut *self.owned_memos.borrow_mut());
for memo in memos {
memo.disposed.set(true);
memo.owner.dispose();
}
let children = std::mem::take(&mut *self.children.borrow_mut());
for child in children {
child.dispose();
}
self.owner.clear_contexts();
}
fn dispose(&self) {
self.disposed.set(true);
self.dispose_children();
self.owner.dispose();
}
}
struct SignalState<T> {
value: T,
subscribers: Vec<Subscriber>,
}
struct SignalInner<T> {
state: Rc<RefCell<SignalState<T>>>,
}
impl<T> Clone for SignalInner<T> {
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
}
}
}
pub fn create_signal<T>(value: T) -> (ReadSignal<T>, WriteSignal<T>) {
let inner = SignalInner {
state: Rc::new(RefCell::new(SignalState {
value,
subscribers: Vec::new(),
})),
};
(
ReadSignal {
inner: inner.clone(),
},
WriteSignal { inner },
)
}
pub struct ReadSignal<T> {
inner: SignalInner<T>,
}
impl<T> Clone for ReadSignal<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T: Clone> ReadSignal<T> {
pub fn get(&self) -> T {
CURRENT_SUBSCRIBER.with(|current| {
if let Some(subscriber) = current.borrow().as_ref() {
let mut state = self.inner.state.borrow_mut();
push_subscriber(&mut state.subscribers, subscriber);
}
});
self.inner.state.borrow().value.clone()
}
}
impl<T> ReadSignal<T> {
pub fn with<U, F>(&self, f: F) -> U
where
F: FnOnce(&T) -> U,
{
CURRENT_SUBSCRIBER.with(|current| {
if let Some(subscriber) = current.borrow().as_ref() {
let mut state = self.inner.state.borrow_mut();
push_subscriber(&mut state.subscribers, subscriber);
}
});
let state = self.inner.state.borrow();
f(&state.value)
}
}
pub struct WriteSignal<T> {
inner: SignalInner<T>,
}
impl<T> Clone for WriteSignal<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
impl<T> WriteSignal<T> {
pub fn set(&self, new_value: T) {
{
let mut state = self.inner.state.borrow_mut();
state.value = new_value;
}
self.notify();
}
pub fn update<F>(&self, f: F)
where
F: FnOnce(&mut T),
{
{
let mut state = self.inner.state.borrow_mut();
f(&mut state.value);
}
self.notify();
}
fn notify(&self) {
let subscribers: Vec<Subscriber> = {
let mut state = self.inner.state.borrow_mut();
state.subscribers.drain(..).collect()
};
let mut to_run: Vec<Rc<EffectState>> = Vec::new();
for subscriber in subscribers {
collect_dependents(&subscriber, &mut to_run);
}
schedule_effects(to_run);
}
}
fn push_unique(queue: &mut Vec<Rc<EffectState>>, effect: Rc<EffectState>) {
if !queue.iter().any(|seen| Rc::ptr_eq(seen, &effect)) {
queue.push(effect);
}
}
fn unschedule_pending(#[allow(unused_variables)] effects: &[Rc<EffectState>]) {
#[cfg(all(feature = "web", target_arch = "wasm32"))]
PENDING_EFFECTS.with(|pending| {
pending
.borrow_mut()
.retain(|queued| !effects.iter().any(|e| Rc::ptr_eq(e, queued)));
});
}
fn schedule_effects(effects: Vec<Rc<EffectState>>) {
if BATCH_DEPTH.with(|depth| depth.get()) > 0 {
queue_batched(effects);
return;
}
let mut pending = take_batched();
for effect in effects {
push_unique(&mut pending, effect);
}
if pending.is_empty() {
return;
}
schedule_async(pending);
}
fn queue_batched(effects: Vec<Rc<EffectState>>) {
BATCHED_EFFECTS.with(|batched| {
let mut batched = batched.borrow_mut();
for effect in effects {
push_unique(&mut batched, effect);
}
});
}
fn take_batched() -> Vec<Rc<EffectState>> {
BATCHED_EFFECTS.with(|batched| std::mem::take(&mut *batched.borrow_mut()))
}
fn run_now(effects: Vec<Rc<EffectState>>) {
for effect in effects {
run_effect(effect);
}
}
struct BatchGuard;
impl BatchGuard {
fn enter() -> Self {
BATCH_DEPTH.with(|depth| depth.set(depth.get() + 1));
Self
}
}
impl Drop for BatchGuard {
fn drop(&mut self) {
BATCH_DEPTH.with(|depth| depth.set(depth.get().saturating_sub(1)));
}
}
fn schedule_async(#[allow(unused_variables)] effects: Vec<Rc<EffectState>>) {
#[cfg(all(feature = "web", target_arch = "wasm32"))]
{
PENDING_EFFECTS.with(|pending| {
let mut p = pending.borrow_mut();
for effect in effects {
push_unique(&mut p, effect);
}
});
if !MICROTASK_QUEUED.with(|q| q.get()) {
MICROTASK_QUEUED.with(|q| q.set(true));
let closure = wasm_bindgen::closure::Closure::once(|_val: wasm_bindgen::JsValue| {
MICROTASK_QUEUED.with(|q| q.set(false));
let effects = PENDING_EFFECTS.with(|pending| {
let mut p = pending.borrow_mut();
std::mem::take(&mut *p)
});
for effect in effects {
run_effect(effect);
}
let chained = PENDING_EFFECTS.with(|pending| !pending.borrow().is_empty());
if !chained {
DRAIN_CHAIN_DEPTH.with(|d| d.set(0));
return;
}
let depth = DRAIN_CHAIN_DEPTH.with(|d| {
let next = d.get() + 1;
d.set(next);
next
});
if depth >= MAX_FLUSH_DEPTH {
let dropped = PENDING_EFFECTS.with(|pending| {
let mut p = pending.borrow_mut();
let n = p.len();
p.clear();
n
});
DRAIN_CHAIN_DEPTH.with(|d| d.set(0));
tracing::error!(chain_depth = depth, dropped, "signal_flush_depth_exceeded");
}
});
let promise = js_sys::Promise::resolve(&wasm_bindgen::JsValue::UNDEFINED);
let _ = promise.then(&closure);
closure.forget();
}
}
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
{
struct FlushDepthGuard;
impl Drop for FlushDepthGuard {
fn drop(&mut self) {
FLUSH_DEPTH.with(|depth| depth.set(depth.get().saturating_sub(1)));
}
}
let depth = FLUSH_DEPTH.with(|depth| depth.get());
if depth >= MAX_FLUSH_DEPTH {
tracing::error!(
depth,
dropped = effects.len(),
"signal_flush_depth_exceeded"
);
return;
}
FLUSH_DEPTH.with(|depth| depth.set(depth.get() + 1));
let _guard = FlushDepthGuard;
for effect in effects {
run_effect(effect);
}
}
}
pub fn batch<T, F>(f: F) -> T
where
F: FnOnce() -> T,
{
let result = {
let _guard = BatchGuard::enter();
f()
};
if BATCH_DEPTH.with(|depth| depth.get()) == 0 {
let effects = take_batched();
unschedule_pending(&effects);
run_now(effects);
}
result
}
fn collect_dependents(subscriber: &Subscriber, effects: &mut Vec<Rc<EffectState>>) {
match subscriber {
Subscriber::Effect(weak) => {
let Some(effect) = weak.upgrade() else {
return;
};
if effect.disposed.get() {
return;
}
push_unique(effects, effect);
}
Subscriber::Memo(weak) => {
let Some(memo) = weak.upgrade() else {
return;
};
if memo.disposed.get() {
return;
}
memo.dirty.set(true);
let downstream: Vec<Subscriber> = memo.subscribers.borrow_mut().drain(..).collect();
for next in &downstream {
collect_dependents(next, effects);
}
}
}
}
pub fn untrack<T, F>(f: F) -> T
where
F: FnOnce() -> T,
{
let _guard = SubscriberGuard::swap_in(None);
f()
}
pub struct Memo<T> {
state: Rc<MemoState>,
value: Rc<RefCell<Option<T>>>,
}
impl<T> Clone for Memo<T> {
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
value: self.value.clone(),
}
}
}
impl<T> Memo<T> {
fn track_and_refresh(&self) {
if self.state.computing.get() {
tracing::error!("memo_self_reference_detected");
return;
}
CURRENT_SUBSCRIBER.with(|current| {
if let Some(subscriber) = current.borrow().as_ref() {
push_subscriber(&mut self.state.subscribers.borrow_mut(), subscriber);
}
});
if self.state.dirty.get() && !self.state.disposed.get() {
self.state.recompute_now();
}
}
pub fn with<U, F>(&self, f: F) -> U
where
F: FnOnce(&T) -> U,
{
self.track_and_refresh();
{
let value = self.value.borrow();
if let Some(value) = value.as_ref() {
return f(value);
}
}
if !self.state.computing.get() && !self.state.disposed.get() {
self.state.dirty.set(true);
self.state.recompute_now();
let value = self.value.borrow();
if let Some(value) = value.as_ref() {
return f(value);
}
}
tracing::error!("memo_self_reference_detected");
panic!(
"memo read its own value during its first computation; no previous value \
exists to break the cycle"
);
}
}
impl<T: Clone> Memo<T> {
pub fn get(&self) -> T {
self.with(|value| value.clone())
}
}
pub fn create_memo<T, F>(f: F) -> Memo<T>
where
T: 'static,
F: Fn() -> T + 'static,
{
let value: Rc<RefCell<Option<T>>> = Rc::new(RefCell::new(None));
let state = Rc::new(MemoState {
dirty: Cell::new(true),
computing: Cell::new(false),
recompute: RefCell::new(None),
subscribers: RefCell::new(Vec::new()),
disposed: Cell::new(false),
owner: OwnerState::child_of_current(),
});
{
let value_slot = value.clone();
*state.recompute.borrow_mut() = Some(Box::new(move || {
let next = f();
*value_slot.borrow_mut() = Some(next);
}));
}
CURRENT_SUBSCRIBER.with(|current| {
if let Some(Subscriber::Effect(owner)) = current.borrow().as_ref() {
if let Some(owner) = owner.upgrade() {
owner.owned_memos.borrow_mut().push(state.clone());
}
}
});
let memo = Memo { state, value };
memo.state.recompute_now();
memo
}
#[cfg(any(feature = "web", test))]
fn new_effect_state(f: impl Fn() + 'static) -> Rc<EffectState> {
Rc::new(EffectState {
execute: Box::new(f),
disposed: Cell::new(false),
running: Cell::new(false),
rerun_requested: Cell::new(false),
cycle_reported: Cell::new(false),
children: RefCell::new(Vec::new()),
owned_memos: RefCell::new(Vec::new()),
cleanups: RefCell::new(Vec::new()),
owner: OwnerState::child_of_current(),
})
}
pub fn create_effect<F>(#[allow(unused_variables)] f: F)
where
F: Fn() + 'static,
{
#[cfg(any(feature = "web", test))]
{
let effect = new_effect_state(f);
let owned_by_parent = CURRENT_SUBSCRIBER.with(|current| {
match current.borrow().as_ref() {
Some(Subscriber::Effect(parent)) => match parent.upgrade() {
Some(parent) => {
parent.children.borrow_mut().push(effect.clone());
true
}
None => false,
},
_ => false,
}
});
if !owned_by_parent {
ROOT_EFFECTS.with(|roots| {
roots.borrow_mut().push(effect.clone());
});
}
run_effect(effect);
}
}
pub struct EffectHandle {
state: Rc<EffectState>,
}
impl EffectHandle {
pub fn dispose(&self) {
self.state.dispose();
ROOT_EFFECTS.with(|roots| {
roots
.borrow_mut()
.retain(|root| !Rc::ptr_eq(root, &self.state));
});
}
}
#[cfg(any(feature = "web", test))]
pub fn create_effect_scoped<F>(f: F) -> EffectHandle
where
F: Fn() + 'static,
{
let effect = new_effect_state(f);
ROOT_EFFECTS.with(|roots| {
roots.borrow_mut().push(effect.clone());
});
run_effect(effect.clone());
EffectHandle { state: effect }
}
#[cfg(not(any(feature = "web", test)))]
pub fn create_effect_scoped<F>(f: F) -> EffectHandle
where
F: Fn() + 'static,
{
let _ = f;
EffectHandle {
state: Rc::new(EffectState {
execute: Box::new(|| {}),
disposed: Cell::new(true),
running: Cell::new(false),
rerun_requested: Cell::new(false),
cycle_reported: Cell::new(false),
children: RefCell::new(Vec::new()),
owned_memos: RefCell::new(Vec::new()),
cleanups: RefCell::new(Vec::new()),
owner: OwnerState::child_of_current(),
}),
}
}
pub fn on_cleanup<F>(#[allow(unused_variables)] f: F)
where
F: FnOnce() + 'static,
{
#[cfg(any(feature = "web", test))]
{
CURRENT_SUBSCRIBER.with(|current| {
let effect = match current.borrow().as_ref() {
Some(Subscriber::Effect(effect)) => effect.upgrade(),
_ => None,
};
if let Some(effect) = effect {
effect.cleanups.borrow_mut().push(Box::new(f));
}
});
}
}
#[doc(hidden)]
pub struct ReactiveSnapshot {
subscriber: Option<Subscriber>,
owner: Option<Rc<OwnerState>>,
batch_depth: u32,
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
flush_depth: u32,
#[cfg(all(feature = "web", target_arch = "wasm32"))]
drain_chain_depth: u32,
}
#[doc(hidden)]
pub fn snapshot_reactive_state() -> ReactiveSnapshot {
ReactiveSnapshot {
subscriber: CURRENT_SUBSCRIBER
.try_with(|current| current.try_borrow().ok().and_then(|s| s.clone()))
.ok()
.flatten(),
owner: CURRENT_OWNER
.try_with(|current| current.try_borrow().ok().and_then(|o| o.clone()))
.ok()
.flatten(),
batch_depth: BATCH_DEPTH.try_with(Cell::get).unwrap_or(0),
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
flush_depth: FLUSH_DEPTH.try_with(Cell::get).unwrap_or(0),
#[cfg(all(feature = "web", target_arch = "wasm32"))]
drain_chain_depth: DRAIN_CHAIN_DEPTH.try_with(Cell::get).unwrap_or(0),
}
}
#[doc(hidden)]
pub fn restore_reactive_state(snapshot: ReactiveSnapshot) -> bool {
let ReactiveSnapshot {
subscriber,
owner,
batch_depth,
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
flush_depth,
#[cfg(all(feature = "web", target_arch = "wasm32"))]
drain_chain_depth,
} = snapshot;
let subscriber_restored = CURRENT_SUBSCRIBER
.try_with(|current| match current.try_borrow_mut() {
Ok(mut slot) => {
*slot = subscriber;
true
}
Err(_) => false,
})
.unwrap_or(false);
let owner_restored = CURRENT_OWNER
.try_with(|current| match current.try_borrow_mut() {
Ok(mut slot) => {
*slot = owner;
true
}
Err(_) => false,
})
.unwrap_or(false);
let _ = BATCH_DEPTH.try_with(|depth| depth.set(batch_depth));
#[cfg(any(not(feature = "web"), not(target_arch = "wasm32")))]
let _ = FLUSH_DEPTH.try_with(|depth| depth.set(flush_depth));
#[cfg(all(feature = "web", target_arch = "wasm32"))]
let _ = DRAIN_CHAIN_DEPTH.try_with(|depth| depth.set(drain_chain_depth));
subscriber_restored && owner_restored
}
const MAX_FLUSH_DEPTH: u32 = 64;
struct RunningGuard<'a> {
flag: &'a Cell<bool>,
}
impl<'a> RunningGuard<'a> {
fn arm(flag: &'a Cell<bool>) -> Self {
flag.set(true);
Self { flag }
}
}
impl Drop for RunningGuard<'_> {
fn drop(&mut self) {
self.flag.set(false);
}
}
fn run_effect(effect: Rc<EffectState>) {
if effect.disposed.get() {
return;
}
if effect.running.get() {
if !effect.cycle_reported.get() {
effect.cycle_reported.set(true);
tracing::error!("signal_effect_cycle_detected");
}
effect.rerun_requested.set(true);
return;
}
let mut reruns: u32 = 0;
loop {
effect.rerun_requested.set(false);
{
let _running = RunningGuard::arm(&effect.running);
effect.dispose_children();
let _subscriber =
SubscriberGuard::swap_in(Some(Subscriber::Effect(Rc::downgrade(&effect))));
let _owner = OwnerGuard::swap_in(effect.owner.clone());
effect.run();
}
if effect.disposed.get() || !effect.rerun_requested.get() {
break;
}
reruns += 1;
if reruns >= MAX_FLUSH_DEPTH {
tracing::error!(reruns, "signal_flush_depth_exceeded");
effect.rerun_requested.set(false);
break;
}
}
}
#[cfg(test)]
mod abandoned_run_tests {
use super::*;
#[derive(Clone, Debug, PartialEq)]
struct Leaked(u32);
#[test]
fn restoring_a_snapshot_undoes_an_abandoned_run() {
let snapshot = snapshot_reactive_state();
let dead_owner = OwnerState::child_of_current();
std::mem::forget(OwnerGuard::swap_in(dead_owner));
provide_context(Leaked(7));
std::mem::forget(BatchGuard::enter());
let dead_effect = new_effect_state(|| {});
std::mem::forget(SubscriberGuard::swap_in(Some(Subscriber::Effect(
Rc::downgrade(&dead_effect),
))));
FLUSH_DEPTH.with(|depth| depth.set(depth.get() + 3));
assert_eq!(with_owner(use_context::<Leaked>), Some(Leaked(7)));
assert!(restore_reactive_state(snapshot));
assert_eq!(with_owner(use_context::<Leaked>), None);
assert!(Owner::current().is_none());
assert!(CURRENT_SUBSCRIBER.with(|current| current.borrow().is_none()));
assert_eq!(BATCH_DEPTH.with(Cell::get), 0);
assert_eq!(FLUSH_DEPTH.with(Cell::get), 0);
let (value, set_value) = create_signal(0);
let seen = Rc::new(Cell::new(-1));
let sink = seen.clone();
create_effect(move || sink.set(value.get()));
set_value.set(5);
assert_eq!(seen.get(), 5);
}
#[test]
fn a_cell_left_borrowed_is_reported_not_panicked_on() {
let snapshot = snapshot_reactive_state();
let restored = CURRENT_OWNER.with(|current| {
let _held = current.borrow();
restore_reactive_state(snapshot)
});
assert!(!restored);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn _assert_read_signal_not_send<T: 'static>() {
fn _not_send<X: ?Sized + Send>() {}
let _ = std::marker::PhantomData::<ReadSignal<T>>;
}
#[test]
#[allow(dead_code, clippy::extra_unused_type_parameters)]
fn signals_are_not_send_sync() {
fn is_send<T: Send>() -> bool {
true
}
fn is_not_send<T>() -> bool
where
T: ?Sized,
{
std::thread::available_parallelism().is_ok()
}
let _ = is_not_send::<ReadSignal<i32>>;
let _ = is_not_send::<WriteSignal<i32>>;
}
#[test]
fn test_signal_basic() {
let (read, write) = create_signal(0);
assert_eq!(read.get(), 0);
write.set(1);
assert_eq!(read.get(), 1);
}
#[cfg(target_arch = "wasm32")]
#[test]
fn test_effect() {
let (read, write) = create_signal(0);
let output = Rc::new(RefCell::new(0));
let output_clone = output.clone();
create_effect(move || {
*output_clone.borrow_mut() = read.get();
});
assert_eq!(*output.borrow(), 0);
write.set(10);
assert_eq!(*output.borrow(), 10);
}
#[test]
fn test_clone_signal() {
let (read, _) = create_signal(42);
let read2 = read.clone();
assert_eq!(read.get(), 42);
assert_eq!(read2.get(), 42);
}
#[derive(Debug, PartialEq)]
struct NonCloneable(i32);
#[test]
fn test_non_cloneable_signal() {
let (read, _write) = create_signal(NonCloneable(10));
read.with(|v| assert_eq!(v, &NonCloneable(10)));
let read2 = read.clone();
read2.with(|v| assert_eq!(v, &NonCloneable(10)));
}
}
#[cfg(test)]
mod disposal_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
#[test]
fn re_running_a_parent_disposes_the_children_of_its_previous_run() {
let (outer, set_outer) = create_signal(0);
let (inner, set_inner) = create_signal(0);
let child_runs = StdRc::new(StdCell::new(0));
let child_runs_effect = child_runs.clone();
create_effect(move || {
let _ = outer.get();
let counter = child_runs_effect.clone();
let inner = inner.clone();
create_effect(move || {
let _ = inner.get();
counter.set(counter.get() + 1);
});
});
assert_eq!(child_runs.get(), 1);
for _ in 0..3 {
set_outer.update(|v| *v += 1);
}
assert_eq!(
child_runs.get(),
4,
"each parent run should create one child"
);
child_runs.set(0);
set_inner.update(|v| *v += 1);
assert_eq!(
child_runs.get(),
1,
"disposed children must not still react; got {} live effects",
child_runs.get()
);
}
#[test]
fn on_cleanup_runs_when_the_owning_effect_re_runs() {
let (trigger, set_trigger) = create_signal(0);
let cleanups = StdRc::new(StdCell::new(0));
let cleanups_effect = cleanups.clone();
create_effect(move || {
let _ = trigger.get();
let counter = cleanups_effect.clone();
on_cleanup(move || counter.set(counter.get() + 1));
});
assert_eq!(cleanups.get(), 0, "nothing disposed yet");
set_trigger.update(|v| *v += 1);
assert_eq!(
cleanups.get(),
1,
"re-running must run the previous cleanup"
);
set_trigger.update(|v| *v += 1);
assert_eq!(cleanups.get(), 2);
}
#[test]
fn reading_a_signal_repeatedly_does_not_multiply_effect_runs() {
let (value, set_value) = create_signal(0);
let runs = StdRc::new(StdCell::new(0));
let runs_effect = runs.clone();
create_effect(move || {
let _ = value.get();
let _ = value.get();
let _ = value.get();
runs_effect.set(runs_effect.get() + 1);
});
assert_eq!(runs.get(), 1);
runs.set(0);
set_value.update(|v| *v += 1);
assert_eq!(
runs.get(),
1,
"three reads must still mean one run, not {}",
runs.get()
);
}
#[test]
fn a_top_level_effect_is_retained() {
let (value, set_value) = create_signal(0);
let runs = StdRc::new(StdCell::new(0));
let runs_effect = runs.clone();
create_effect(move || {
let _ = value.get();
runs_effect.set(runs_effect.get() + 1);
});
set_value.update(|v| *v += 1);
set_value.update(|v| *v += 1);
assert_eq!(runs.get(), 3, "initial run plus two writes");
}
}
#[cfg(test)]
mod memo_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
fn counter() -> (StdRc<StdCell<u32>>, StdRc<StdCell<u32>>) {
let c = StdRc::new(StdCell::new(0));
(c.clone(), c)
}
#[test]
fn a_memo_caches_across_reads() {
let (source, _set) = create_signal(2);
let (computations, probe) = counter();
let doubled = create_memo(move || {
computations.set(computations.get() + 1);
source.get() * 2
});
assert_eq!(probe.get(), 1);
assert_eq!(doubled.get(), 4);
assert_eq!(doubled.get(), 4);
assert_eq!(doubled.get(), 4);
assert_eq!(probe.get(), 1, "three reads must not recompute");
}
#[test]
fn a_memo_recomputes_after_a_dependency_changes() {
let (source, set_source) = create_signal(2);
let (computations, probe) = counter();
let doubled = create_memo(move || {
computations.set(computations.get() + 1);
source.get() * 2
});
assert_eq!(doubled.get(), 4);
set_source.set(5);
assert_eq!(doubled.get(), 10, "must see the new value");
assert_eq!(probe.get(), 2, "exactly one recomputation");
}
#[test]
fn a_dirty_memo_is_not_recomputed_until_read() {
let (source, set_source) = create_signal(1);
let (computations, probe) = counter();
let memo = create_memo(move || {
computations.set(computations.get() + 1);
source.get()
});
assert_eq!(probe.get(), 1);
set_source.set(2);
set_source.set(3);
set_source.set(4);
assert_eq!(probe.get(), 1, "writes alone must not recompute");
assert_eq!(memo.get(), 4, "the read settles it at the latest value");
assert_eq!(probe.get(), 2, "and computes exactly once to do so");
}
#[test]
fn a_diamond_settles_once_per_write() {
let (source, set_source) = create_signal(1);
let source_a = source.clone();
let doubled = create_memo(move || source_a.get() * 2);
let source_b = source.clone();
let incremented = create_memo(move || source_b.get() + 1);
let (runs, runs_probe) = counter();
let seen = StdRc::new(StdCell::new((0, 0)));
let seen_effect = seen.clone();
create_effect(move || {
let a = doubled.get();
let b = incremented.get();
runs.set(runs.get() + 1);
seen_effect.set((a, b));
});
assert_eq!(runs_probe.get(), 1);
assert_eq!(seen.get(), (2, 2));
set_source.set(10);
assert_eq!(
runs_probe.get(),
2,
"the effect must run once per write, not once per memo branch"
);
assert_eq!(
seen.get(),
(20, 11),
"both branches must be fresh in the same run — a glitch would show \
one updated and one stale"
);
}
#[test]
fn memos_compose() {
let (source, set_source) = create_signal(2);
let doubled = create_memo(move || source.get() * 2);
let doubled_for_chain = doubled.clone();
let quadrupled = create_memo(move || doubled_for_chain.get() * 2);
assert_eq!(quadrupled.get(), 8);
set_source.set(3);
assert_eq!(
quadrupled.get(),
12,
"dirtiness must propagate through the chain"
);
}
#[test]
fn untrack_reads_without_subscribing() {
let (tracked, set_tracked) = create_signal(0);
let (ignored, set_ignored) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = tracked.get();
let _ = untrack(|| ignored.get());
runs.set(runs.get() + 1);
});
assert_eq!(probe.get(), 1);
set_ignored.set(99);
assert_eq!(probe.get(), 1, "an untracked read must not subscribe");
set_tracked.set(1);
assert_eq!(probe.get(), 2, "a tracked read still does");
}
#[test]
fn untrack_restores_the_previous_subscriber() {
let (before, set_before) = create_signal(0);
let (after, set_after) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = before.get();
let _ = untrack(|| 1 + 1);
let _ = after.get();
runs.set(runs.get() + 1);
});
set_after.set(1);
assert_eq!(probe.get(), 2, "the read after untrack must still track");
set_before.set(1);
assert_eq!(probe.get(), 3);
}
#[test]
fn a_memo_owned_by_an_effect_is_disposed_with_it() {
let (outer, set_outer) = create_signal(0);
let (inner, set_inner) = create_signal(0);
let (computations, probe) = counter();
create_effect(move || {
let _ = outer.get();
let computations = computations.clone();
let inner = inner.clone();
let memo = create_memo(move || {
computations.set(computations.get() + 1);
inner.get()
});
let _ = memo.get();
});
assert_eq!(probe.get(), 1);
set_outer.set(1);
assert_eq!(probe.get(), 2, "one fresh memo per parent run");
set_inner.set(5);
assert_eq!(
probe.get(),
3,
"a disposed memo must not recompute; got {} computations",
probe.get()
);
}
}
#[cfg(test)]
mod batch_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
fn counter() -> (StdRc<StdCell<u32>>, StdRc<StdCell<u32>>) {
let c = StdRc::new(StdCell::new(0));
(c.clone(), c)
}
#[test]
fn writes_in_a_batch_run_a_dependent_effect_once() {
let (first, set_first) = create_signal(0);
let (second, set_second) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = first.get();
let _ = second.get();
runs.set(runs.get() + 1);
});
assert_eq!(probe.get(), 1);
batch(|| {
set_first.set(1);
set_second.set(2);
});
assert_eq!(probe.get(), 2, "two writes in a batch mean one re-run");
}
#[test]
fn the_same_writes_unbatched_run_it_twice() {
let (first, set_first) = create_signal(0);
let (second, set_second) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = first.get();
let _ = second.get();
runs.set(runs.get() + 1);
});
set_first.set(1);
set_second.set(2);
assert_eq!(probe.get(), 3, "initial run plus one per write");
}
#[test]
fn effects_do_not_run_until_the_batch_closes() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
batch(|| {
set_value.set(1);
assert_eq!(probe.get(), 1, "still deferred inside the batch");
set_value.set(2);
assert_eq!(probe.get(), 1);
});
assert_eq!(probe.get(), 2);
}
#[test]
fn only_the_outermost_batch_flushes() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
batch(|| {
set_value.set(1);
batch(|| {
set_value.set(2);
});
assert_eq!(
probe.get(),
1,
"an inner batch closing must not flush the outer one"
);
});
assert_eq!(probe.get(), 2);
}
#[test]
fn a_batch_returns_the_closure_value() {
let (value, set_value) = create_signal(1);
let doubled = batch(|| {
set_value.set(21);
value.get() * 2
});
assert_eq!(doubled, 42);
}
#[test]
fn distinct_effects_each_run_once_per_batch() {
let (value, set_value) = create_signal(0);
let (first_runs, first_probe) = counter();
let (second_runs, second_probe) = counter();
let value_a = value.clone();
create_effect(move || {
let _ = value_a.get();
first_runs.set(first_runs.get() + 1);
});
let value_b = value.clone();
create_effect(move || {
let _ = value_b.get();
second_runs.set(second_runs.get() + 1);
});
batch(|| {
set_value.set(1);
set_value.set(2);
set_value.set(3);
});
assert_eq!(first_probe.get(), 2, "deduped, not skipped");
assert_eq!(second_probe.get(), 2);
}
#[test]
fn a_batch_settles_memos_once() {
let (source, set_source) = create_signal(1);
let (computations, probe) = counter();
let doubled = create_memo(move || {
computations.set(computations.get() + 1);
source.get() * 2
});
assert_eq!(probe.get(), 1);
batch(|| {
set_source.set(2);
set_source.set(3);
set_source.set(4);
});
assert_eq!(
probe.get(),
1,
"marking dirty is not recomputing; nothing read it yet"
);
assert_eq!(doubled.get(), 8);
assert_eq!(probe.get(), 2, "one recomputation for three writes");
}
}
#[cfg(test)]
mod batch_unwind_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::rc::Rc as StdRc;
fn counter() -> (StdRc<StdCell<u32>>, StdRc<StdCell<u32>>) {
let c = StdRc::new(StdCell::new(0));
(c.clone(), c)
}
#[test]
fn a_panic_inside_a_batch_does_not_wedge_the_reactive_system() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
assert_eq!(probe.get(), 1);
let set_in_batch = set_value.clone();
let panicked = catch_unwind(AssertUnwindSafe(|| {
batch(|| {
set_in_batch.set(1);
panic!("something inside the batch failed");
});
}));
assert!(
panicked.is_err(),
"the panic must propagate, not be swallowed"
);
assert_eq!(
BATCH_DEPTH.with(|depth| depth.get()),
0,
"the batch depth must be restored on unwind"
);
set_value.set(2);
assert!(
probe.get() > 1,
"effects stopped running after a panic inside a batch"
);
}
#[test]
fn writes_made_before_a_panic_are_delivered_by_the_next_write() {
let (value, set_value) = create_signal(0);
let seen = StdRc::new(StdCell::new(0));
let seen_effect = seen.clone();
create_effect(move || {
seen_effect.set(value.get());
});
assert_eq!(seen.get(), 0);
let set_in_batch = set_value.clone();
let _ = catch_unwind(AssertUnwindSafe(|| {
batch(|| {
set_in_batch.set(7);
panic!("abort mid-batch");
});
}));
set_value.set(9);
assert_eq!(
seen.get(),
9,
"the effect must observe the committed state after recovery"
);
}
#[test]
fn a_panic_in_a_nested_batch_restores_the_whole_depth() {
let _ = catch_unwind(AssertUnwindSafe(|| {
batch(|| {
batch(|| {
batch(|| panic!("deep failure"));
});
});
}));
assert_eq!(
BATCH_DEPTH.with(|depth| depth.get()),
0,
"every nested guard must unwind"
);
}
#[test]
fn effects_have_run_by_the_time_batch_returns() {
let (value, set_value) = create_signal(0);
let (runs, probe) = counter();
create_effect(move || {
let _ = value.get();
runs.set(runs.get() + 1);
});
batch(|| {
set_value.set(1);
});
assert_eq!(
probe.get(),
2,
"the flush must be synchronous, not deferred past the scope"
);
}
}
#[cfg(test)]
mod unwind_and_growth_tests {
use super::*;
use std::panic::{catch_unwind, AssertUnwindSafe};
#[test]
fn a_panicking_effect_does_not_leave_a_zombie_subscriber() {
let result = catch_unwind(AssertUnwindSafe(|| {
create_effect(|| panic!("boom"));
}));
assert!(result.is_err(), "the panic must propagate");
assert!(
CURRENT_SUBSCRIBER.with(|c| c.borrow().is_none()),
"a caught effect panic must not leave the thread tracking the dead effect"
);
let (count, set_count) = create_signal(0);
let runs = Rc::new(Cell::new(0));
let seen = runs.clone();
create_effect(move || {
let _ = count.get();
seen.set(seen.get() + 1);
});
set_count.set(1);
assert_eq!(runs.get(), 2, "initial run plus one re-run");
}
#[test]
fn a_panicking_memo_recovers_and_recomputes_on_the_next_read() {
let (source, set_source) = create_signal(1);
let should_panic = Rc::new(Cell::new(false));
let flag = should_panic.clone();
let memo = create_memo(move || {
if flag.get() {
panic!("transient failure");
}
source.get() * 10
});
assert_eq!(memo.get(), 10);
should_panic.set(true);
set_source.set(2);
let result = catch_unwind(AssertUnwindSafe(|| memo.get()));
assert!(result.is_err(), "the recompute panic must propagate");
assert!(
CURRENT_SUBSCRIBER.with(|c| c.borrow().is_none()),
"a caught memo panic must not leave the thread tracking the memo"
);
should_panic.set(false);
assert_eq!(
memo.get(),
20,
"after recovery the memo must recompute, not serve the stale value"
);
}
#[test]
fn a_panic_inside_untrack_restores_tracking() {
let result = catch_unwind(AssertUnwindSafe(|| {
untrack(|| -> i32 { panic!("boom") });
}));
assert!(result.is_err());
assert!(
CURRENT_SUBSCRIBER.with(|c| c.borrow().is_none()),
"untrack must restore the previous subscriber on unwind"
);
let (value, set_value) = create_signal(0);
let runs = Rc::new(Cell::new(0));
let seen = runs.clone();
create_effect(move || {
let _ = value.get();
seen.set(seen.get() + 1);
});
set_value.set(1);
assert_eq!(runs.get(), 2);
}
#[test]
fn memo_subscribers_do_not_accumulate_across_writes() {
let (source, set_source) = create_signal(0);
let memo = create_memo(move || source.get() * 2);
let observer = memo.clone();
create_effect(move || {
let _ = observer.get();
});
for i in 1..=25 {
set_source.set(i);
}
let len = memo.state.subscribers.borrow().len();
assert!(
len <= 1,
"memo subscriber list must stay bounded (drained on notify), found {len}"
);
}
#[test]
fn repeated_reads_do_not_duplicate_signal_subscriptions() {
let (value, _set_value) = create_signal(0);
let probe = value.clone();
create_effect(move || {
let _ = probe.get();
let _ = probe.get();
let _ = probe.get();
});
let len = value.inner.state.borrow().subscribers.len();
assert_eq!(
len, 1,
"three reads in one effect run must produce one subscription"
);
}
#[test]
fn an_unwritten_source_does_not_accumulate_subscribers() {
let (written, set_written) = create_signal(0);
let (unwritten, _set_unwritten) = create_signal(0);
let probe = unwritten.clone();
create_effect(move || {
let _ = written.get();
let _ = probe.get();
});
for i in 1..=25 {
set_written.set(i);
}
let len = unwritten.inner.state.borrow().subscribers.len();
assert!(
len <= 2,
"an unwritten source's subscriber list must stay bounded, found {len}"
);
}
#[test]
fn interleaved_parent_and_child_reads_do_not_accumulate_subscribers() {
let (written, set_written) = create_signal(0);
let (unwritten, _set_unwritten) = create_signal(0);
let parent_probe = unwritten.clone();
let child_probe = unwritten.clone();
create_effect(move || {
let _ = written.get();
let _ = parent_probe.get();
let probe = child_probe.clone();
create_effect(move || {
let _ = probe.get();
});
let _ = parent_probe.get();
});
for i in 1..=25 {
set_written.set(i);
}
let len = unwritten.inner.state.borrow().subscribers.len();
assert!(
len <= 2,
"one parent and one child must mean at most two subscriptions, found {len}"
);
}
}
#[cfg(test)]
mod cycle_guard_tests {
use super::*;
use std::panic::{catch_unwind, AssertUnwindSafe};
#[test]
fn an_effect_writing_its_own_dependency_terminates_and_converges() {
let (count, set_count) = create_signal(0u32);
let runs = Rc::new(Cell::new(0u32));
let reader = count.clone();
let seen = runs.clone();
create_effect(move || {
seen.set(seen.get() + 1);
let current = reader.get();
if current < 5 {
set_count.set(current + 1);
}
});
assert_eq!(count.get(), 5, "the effect must converge on its own writes");
assert_eq!(runs.get(), 6, "initial run plus one owed re-run per write");
}
#[test]
fn an_unconditional_self_write_is_cut_off_by_the_flush_cap() {
let (value, set_value) = create_signal(0u64);
let runs = Rc::new(Cell::new(0u32));
let reader = value.clone();
let seen = runs.clone();
create_effect(move || {
seen.set(seen.get() + 1);
set_value.set(reader.get() + 1);
});
assert_eq!(
runs.get(),
MAX_FLUSH_DEPTH,
"consecutive runs of a livelocked effect are capped at MAX_FLUSH_DEPTH"
);
}
#[test]
fn a_panicking_effect_does_not_wedge_the_running_flag() {
let (value, set_value) = create_signal(0);
let should_panic = Rc::new(Cell::new(true));
let runs = Rc::new(Cell::new(0u32));
let flag = should_panic.clone();
let seen = runs.clone();
let result = catch_unwind(AssertUnwindSafe(|| {
create_effect(move || {
let _ = value.get();
seen.set(seen.get() + 1);
if flag.get() {
panic!("first run fails");
}
});
}));
assert!(result.is_err(), "the panic must propagate");
should_panic.set(false);
set_value.set(1);
assert_eq!(
runs.get(),
2,
"after a caught panic the effect must run again, not be refused as a cycle"
);
}
#[test]
fn a_self_referential_memo_serves_the_stale_value_instead_of_panicking() {
let handle: Rc<RefCell<Option<Memo<i32>>>> = Rc::new(RefCell::new(None));
let (source, set_source) = create_signal(1);
let handle_in_closure = handle.clone();
let memo = create_memo(move || {
let base = source.get();
let previous = handle_in_closure
.borrow()
.as_ref()
.map(|memo: &Memo<i32>| memo.get())
.unwrap_or(0);
base + previous
});
*handle.borrow_mut() = Some(memo.clone());
assert_eq!(memo.get(), 1, "eager run: base 1 with no previous value");
set_source.set(10);
let result = catch_unwind(AssertUnwindSafe(|| memo.get()));
let value = result.expect("a self-referential memo must not panic");
assert_eq!(
value, 11,
"the self-read must see the stale value (1), giving 10 + 1"
);
assert_eq!(memo.get(), 11);
}
#[test]
fn disposing_a_scoped_effect_returns_root_effects_to_baseline() {
let baseline = ROOT_EFFECTS.with(|roots| roots.borrow().len());
let (value, set_value) = create_signal(0);
let runs = Rc::new(Cell::new(0u32));
let reader = value.clone();
let seen = runs.clone();
let handle = create_effect_scoped(move || {
let _ = reader.get();
seen.set(seen.get() + 1);
});
assert_eq!(
ROOT_EFFECTS.with(|roots| roots.borrow().len()),
baseline + 1,
"a scoped effect is retained while live"
);
set_value.set(1);
assert_eq!(runs.get(), 2, "a live scoped effect reacts to writes");
handle.dispose();
assert_eq!(
ROOT_EFFECTS.with(|roots| roots.borrow().len()),
baseline,
"dispose must remove the retained Rc from ROOT_EFFECTS"
);
set_value.set(2);
assert_eq!(runs.get(), 2, "a disposed scoped effect must not run again");
handle.dispose();
assert_eq!(ROOT_EFFECTS.with(|roots| roots.borrow().len()), baseline);
}
#[test]
fn disposing_a_scoped_effect_runs_its_cleanups() {
let cleanups = Rc::new(Cell::new(0u32));
let counter = cleanups.clone();
let handle = create_effect_scoped(move || {
let counter = counter.clone();
on_cleanup(move || counter.set(counter.get() + 1));
});
assert_eq!(cleanups.get(), 0);
handle.dispose();
assert_eq!(cleanups.get(), 1, "dispose must run the registered cleanup");
}
}
#[cfg(test)]
mod context_tests {
use super::*;
use std::cell::Cell as StdCell;
use std::rc::Rc as StdRc;
#[derive(Clone, Debug, PartialEq)]
struct Theme(&'static str);
#[derive(Clone, Debug, PartialEq)]
struct User(&'static str);
fn child_component() -> Option<Theme> {
use_context::<Theme>()
}
fn parent_component() -> (Option<Theme>, Option<Theme>, Option<Theme>) {
provide_context(Theme("dark"));
let first = with_owner(child_component);
let shadowed = with_owner(|| {
provide_context(Theme("light"));
with_owner(child_component)
});
let sibling = with_owner(child_component);
(first, shadowed, sibling)
}
#[test]
fn a_context_reaches_nested_calls_and_inner_provides_shadow_outer_ones() {
let (first, shadowed, sibling) = with_owner(parent_component);
assert_eq!(first, Some(Theme("dark")));
assert_eq!(shadowed, Some(Theme("light")));
assert_eq!(sibling, Some(Theme("dark")));
}
#[test]
fn contexts_of_different_types_are_independent() {
with_owner(|| {
provide_context(Theme("dark"));
with_owner(|| {
provide_context(User("ada"));
assert_eq!(use_context::<Theme>(), Some(Theme("dark")));
assert_eq!(use_context::<User>(), Some(User("ada")));
});
assert_eq!(use_context::<User>(), None);
});
}
#[test]
fn providing_twice_in_one_scope_replaces_the_value() {
with_owner(|| {
provide_context(Theme("dark"));
provide_context(Theme("light"));
assert_eq!(use_context::<Theme>(), Some(Theme("light")));
});
}
#[test]
fn an_absent_context_is_none() {
assert_eq!(use_context::<Theme>(), None);
with_owner(|| assert_eq!(use_context::<Theme>(), None));
}
#[test]
fn providing_outside_any_scope_is_not_visible_anywhere() {
provide_context(Theme("leaked"));
assert_eq!(use_context::<Theme>(), None);
with_owner(|| assert_eq!(use_context::<Theme>(), None));
}
#[test]
fn a_scope_ends_with_its_closure() {
with_owner(|| provide_context(Theme("dark")));
assert_eq!(use_context::<Theme>(), None);
assert!(Owner::current().is_none());
}
#[test]
fn a_panicking_scope_restores_the_previous_owner() {
with_owner(|| {
provide_context(Theme("outer"));
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
with_owner(|| {
provide_context(Theme("inner"));
panic!("render failed");
})
}));
assert!(result.is_err());
assert_eq!(use_context::<Theme>(), Some(Theme("outer")));
});
}
#[test]
fn an_effect_sees_its_scope_on_every_run() {
let (count, set_count) = create_signal(0);
let seen = StdRc::new(RefCell::new(Vec::new()));
let handle = with_owner(|| {
provide_context(Theme("dark"));
let seen = seen.clone();
create_effect_scoped(move || {
count.get();
seen.borrow_mut().push(use_context::<Theme>());
})
});
assert!(Owner::current().is_none());
set_count.set(1);
set_count.set(2);
assert_eq!(
*seen.borrow(),
vec![Some(Theme("dark")); 3],
"every run, including re-runs after the scope returned, must see the context"
);
handle.dispose();
}
#[test]
fn a_context_provided_in_an_effect_reaches_its_child_effects() {
let seen = StdRc::new(RefCell::new(None));
let handle = with_owner(|| {
let seen = seen.clone();
create_effect_scoped(move || {
provide_context(User("from-effect"));
let seen = seen.clone();
create_effect(move || {
*seen.borrow_mut() = use_context::<User>();
});
})
});
assert_eq!(*seen.borrow(), Some(User("from-effect")));
handle.dispose();
}
#[test]
fn a_memo_recomputes_under_the_scope_it_was_created_in() {
let (count, set_count) = create_signal(1);
let memo = with_owner(|| {
provide_context(Theme("dark"));
create_memo(move || (count.get(), use_context::<Theme>()))
});
set_count.set(2);
assert_eq!(memo.get(), (2, Some(Theme("dark"))));
}
#[test]
fn disposing_an_effect_drops_the_contexts_it_provided() {
#[derive(Clone)]
struct Tracked(StdRc<StdCell<u32>>);
impl Drop for Tracked {
fn drop(&mut self) {
self.0.set(self.0.get() + 1);
}
}
let drops = StdRc::new(StdCell::new(0));
let handle = {
let drops = drops.clone();
create_effect_scoped(move || provide_context(Tracked(drops.clone())))
};
let before = drops.get();
handle.dispose();
assert_eq!(
drops.get(),
before + 1,
"dispose must drop the provided value"
);
}
#[test]
fn a_disposed_owner_is_skipped_by_lookups() {
with_owner(|| {
provide_context(Theme("outer"));
let inner = Owner::new();
inner.with(|| provide_context(Theme("inner")));
inner.with(|| assert_eq!(use_context::<Theme>(), Some(Theme("inner"))));
inner.dispose();
inner.with(|| {
assert_eq!(use_context::<Theme>(), Some(Theme("outer")));
provide_context(Theme("ignored"));
assert_eq!(use_context::<Theme>(), Some(Theme("outer")));
});
});
}
#[test]
fn a_re_run_forgets_what_the_previous_run_provided() {
let (provide, set_provide) = create_signal(true);
let seen = StdRc::new(RefCell::new(Vec::new()));
let handle = {
let seen = seen.clone();
create_effect_scoped(move || {
if provide.get() {
provide_context(User("first-run"));
}
seen.borrow_mut().push(use_context::<User>());
})
};
set_provide.set(false);
assert_eq!(*seen.borrow(), vec![Some(User("first-run")), None]);
handle.dispose();
}
}