swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Stores: Externally tracked state and reactive collections (#4483)

Browse Source 
* map signals mutably

* boxed signals

* remove mutable borrow type from boxed writable

* improve map mut example

* restore boxed_mut helper

* make boxed readable/writable types copy

* Move away from the ReadOnlySignal alias in examples

* automatically convert Write

* Fix some tests

* ReadSignal and WriteSignal

* move read only signal alias

* make maps copy

* store prototype

* implement derive macro

* Handle generics in the derive macro

* Make Selector boxable

* derive boxed conversion

* Get rid of store type

* Remove hardcoded type from derive macro

* selector -> store

* Refactor store implementation

* more vec methods

* todo mvc store example

* Implement Storable for HashMap

* fix write

* restore sorting logic in todomvc

* derive readable and writable

* improve todomvc store example

* Result store

* Option store

* collect dead subscribers

* fix clippy and formatting

* recognize some common foreign types automatically

* fix foreign stores in props

* slice and array selectors

* clean up store example

* writable is child owned

* box selector

* read and write to builtins

* re-use the proc macro in the derive macro

* Switch to a extension trait based approach

* switch to extension traits in the derive macro

* transposed method

* derive enums

* Expose Store::new

* remove stores from the prelude

* More consistent naming scheme for SelectorScope methods

* document hashmap methods

* document index extension

* document option ext

* document result ext

* document slice extension

* document the vec extension

* make more methods borrow the store mutably

* Move to impls to have higher priority over the builtin write extension traits

* fix deadlock

* finish stores documentation

* Document the store macro

* cleanup docs and organization

* finish derive docs

* fix typo

* fix clippy

* fix doc tests

* fix derive macro with generics

* fix clippy

* test and fix empty structs

* clean up todomvc store example

* default to a boxed store writer to make it easier to type when providing to the context api

* fix cargo doc

* fix clippy in store example

* relax generational box lifetime bounds

* relax bounds

* relax signal bounds

* fix compilation

* read store

* relax bounds on default store impls

* fix enum derive

* Convert to readsignal and writesignal automatically

* simplify type matching logic

* add write store

* unsized stores

* shrink the path vec type

* use more concrete types

* remove opaque types

* remove copy bounds

* use lens as generic name everywhere

* more consistent borrow semantics

* use a concrete type for the signal metadata and mention references in the map docs

* improve todomvc store docs

* document store derive macro internals

* refactor macro

* improve selector node documentation

* fix clippy

* add btreemap

* fix doc tests

* more option methods

* fix doc

* fix clippy

* add a bunch more result methods

* add a bunch of bounds to the iterators

* fix clippy

* remove option from subscribers

* add store macro to generate extension traits

* fix store example

* fix deadlock

* fix docs

* fix doc tests

* fix clippy

* add stores to public api

* add store macro, and then update todomvc_store example

---------

Co-authored-by: Jonathan Kelley <jkelleyrtp@gmail.com>
This commit is contained in:
Evan AlmloffandJonathan Kelley authored and GitHub committed 2025-08-05 11:30:21 -07:00
1 parent 5591070e92
commit 58c41f8561
57 files changed
+4958 -436
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/signals/src/impls.rs
+27 -27
View File
@@ -6,33 +6,33 @@
/// use dioxus::prelude::*;
/// use dioxus_core::Subscribers;
///
/// struct MyCopyValue<T: 'static, S: Storage<T>> {
/// struct MyCopyValue<T, S: 'static> {
/// value: CopyValue<T, S>,
/// }
///
/// impl<T: 'static, S: Storage<T>> MyCopyValue<T, S> {
/// impl<T: 'static, S: Storage<T> + 'static> MyCopyValue<T, S> {
/// fn new_maybe_sync(value: T) -> Self {
/// Self { value: CopyValue::new_maybe_sync(value) }
/// }
/// }
///
/// impl<T: 'static, S: Storage<T>> Readable for MyCopyValue<T, S> {
/// impl<T, S: Storage<T> + 'static> Readable for MyCopyValue<T, S> {
/// type Target = T;
/// type Storage = S;
///
/// fn try_read_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn try_peek_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn subscribers(&self) -> Option<Subscribers> {
/// fn subscribers(&self) -> Subscribers where T: 'static {
/// self.value.subscribers()
/// }
/// }
@@ -79,27 +79,27 @@ macro_rules! default_impl {
/// use dioxus::prelude::*;
/// use dioxus_core::Subscribers;
///
/// struct MyCopyValue<T: 'static, S: Storage<T>> {
/// struct MyCopyValue<T, S: 'static> {
/// value: CopyValue<T, S>,
/// }
///
/// impl<T: 'static, S: Storage<T>> Readable for MyCopyValue<T, S> {
/// impl<T: 'static, S: Storage<T> + 'static> Readable for MyCopyValue<T, S> where T: 'static {
/// type Target = T;
/// type Storage = S;
///
/// fn try_read_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn try_peek_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn subscribers(&self) -> Option<Subscribers> {
/// fn subscribers(&self) -> Subscribers where T: 'static {
/// self.value.subscribers()
/// }
/// }
@@ -157,27 +157,27 @@ macro_rules! read_impls {
/// use dioxus::prelude::*;
/// use dioxus_core::Subscribers;
///
/// struct MyCopyValue<T: 'static, S: Storage<T>> {
/// struct MyCopyValue<T, S: 'static> {
/// value: CopyValue<T, S>,
/// }
///
/// impl<T: 'static, S: Storage<T>> Readable for MyCopyValue<T, S> {
/// impl<T: 'static, S: Storage<T> + 'static> Readable for MyCopyValue<T, S> {
/// type Target = T;
/// type Storage = S;
///
/// fn try_read_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn try_peek_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn subscribers(&self) -> Option<Subscribers> {
/// fn subscribers(&self) -> Subscribers where T: 'static {
/// self.value.subscribers()
/// }
/// }
@@ -238,27 +238,27 @@ macro_rules! fmt_impls {
/// use dioxus::prelude::*;
/// use dioxus_core::Subscribers;
///
/// struct MyCopyValue<T: 'static, S: Storage<T>> {
/// struct MyCopyValue<T, S: 'static> {
/// value: CopyValue<T, S>,
/// }
///
/// impl<T: 'static, S: Storage<T>> Readable for MyCopyValue<T, S> {
/// impl<T: 'static, S: Storage<T> + 'static> Readable for MyCopyValue<T, S> {
/// type Target = T;
/// type Storage = S;
///
/// fn try_read_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn try_peek_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn subscribers(&self) -> Option<Subscribers> {
/// fn subscribers(&self) -> Subscribers where T: 'static {
/// self.value.subscribers()
/// }
/// }
@@ -303,29 +303,29 @@ macro_rules! eq_impls {
/// use generational_box::*;
/// use dioxus::prelude::*;
///
/// struct MyCopyValue<T: 'static, S: Storage<T>> {
/// struct MyCopyValue<T, S: 'static> {
/// value: CopyValue<T, S>,
/// }
///
/// impl<T: 'static, S: Storage<T>> Readable for MyCopyValue<T, S> {
/// impl<T: 'static, S: Storage<T> + 'static> Readable for MyCopyValue<T, S> {
/// type Target = T;
/// type Storage = S;
///
/// fn try_read_unchecked(
/// &self,
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> {
/// ) -> Result<ReadableRef<'static, Self>, generational_box::BorrowError> where T: 'static {
/// self.value.try_read_unchecked()
/// }
///
/// fn peek_unchecked(&self) -> ReadableRef<'static, Self> {
/// fn peek_unchecked(&self) -> ReadableRef<'static, Self> where T: 'static {
/// self.value.read_unchecked()
/// }
/// }
///
/// impl<T: 'static, S: Storage<T>> Writable for MyCopyValue<T, S> {
/// impl<T: 'static, S: Storage<T> + 'static> Writable for MyCopyValue<T, S> {
/// fn try_write_unchecked(
/// &self,
/// ) -> Result<WritableRef<'static, Self>, generational_box::BorrowMutError> {
/// ) -> Result<WritableRef<'static, Self>, generational_box::BorrowMutError> where T: 'static {
/// self.value.try_write_unchecked()
/// }
///