1  use leptos::{MaybeSignal, Signal, SignalGet, SignalGetUntracked, SignalWith, StoredValue};
 2  
 3  #[derive(Clone)]
 4  pub enum StoredMaybeSignal<T>
 5  where
 6      T: 'static,
 7  {
 8      StoredValue(StoredValue<T>),
 9      Signal(Signal<T>),
10  }
11  
12  impl<T: Clone> Copy for StoredMaybeSignal<T> {}
13  
14  impl<T: Clone> SignalGet for StoredMaybeSignal<T> {
15      type Value = T;
16  
17      fn get(&self) -> Self::Value {
18          match self {
19              StoredMaybeSignal::StoredValue(value) => value.get_value(),
20              StoredMaybeSignal::Signal(signal) => signal.get(),
21          }
22      }
23  
24      fn try_get(&self) -> Option<Self::Value> {
25          match self {
26              StoredMaybeSignal::StoredValue(value) => value.try_get_value(),
27              StoredMaybeSignal::Signal(signal) => signal.try_get(),
28          }
29      }
30  }
31  
32  impl<T: Clone> SignalGetUntracked for StoredMaybeSignal<T> {
33      type Value = T;
34  
35      fn get_untracked(&self) -> Self::Value {
36          match self {
37              StoredMaybeSignal::StoredValue(value) => value.get_value(),
38              StoredMaybeSignal::Signal(signal) => signal.get_untracked(),
39          }
40      }
41  
42      fn try_get_untracked(&self) -> Option<Self::Value> {
43          match self {
44              StoredMaybeSignal::StoredValue(value) => value.try_get_value(),
45              StoredMaybeSignal::Signal(signal) => signal.try_get_untracked(),
46          }
47      }
48  }
49  
50  impl<T> SignalWith for StoredMaybeSignal<T> {
51      type Value = T;
52  
53      fn with<O>(&self, f: impl FnOnce(&Self::Value) -> O) -> O {
54          match self {
55              StoredMaybeSignal::StoredValue(value) => value.with_value(f),
56              StoredMaybeSignal::Signal(signal) => signal.with(f),
57          }
58      }
59  
60      fn try_with<O>(&self, f: impl FnOnce(&Self::Value) -> O) -> Option<O> {
61          match self {
62              StoredMaybeSignal::StoredValue(value) => value.try_with_value(f),
63              StoredMaybeSignal::Signal(signal) => signal.try_with(f),
64          }
65      }
66  }
67  
68  impl<T> From<MaybeSignal<T>> for StoredMaybeSignal<T> {
69      fn from(value: MaybeSignal<T>) -> Self {
70          match value {
71              MaybeSignal::Static(value) => Self::StoredValue(StoredValue::new(value)),
72              MaybeSignal::Dynamic(signal) => Self::Signal(signal),
73          }
74      }
75  }