actuate-v0.20.1

0.20.1 - 2024-12-13

Documentation

• Fix formatting in crate example

actuate-v0.20.0

0.20.0 - 2024-12-13

Breaking changes

• Fix Data impl for &T (63d89ed)
• Remove Data from root exports (677b160)
• Replace Memoize trait with more specific Generational trait (febe238)

Features

• Impl Data for Rc<dyn Fn(..)> and derive Clone for Catch composable (e038307)
• Impl Clone for from_fn, from_iter, and memo composables (21c016f)
• Add material_ui composable (5dad9a3)

Fixes

• Replace std deps with core (68d44a2)
• Simplify styling in scroll_view composable and update http example (f90e4c4)
• Check for removed entities in Spawn composable (c23e158)

Documentation

• Add docs to use_local_task (63d89ed)
• Add docs to use_task (7ddbe84)
• Update counter example (3b79bb1)
• Update borrowing docs (efcdfe3)

actuate-v0.19.1

0.19.1 - 2024-12-09

Features

• Add use_effect hook (5ae0a51)
  • fn use_effect<D, T>(cx: ScopeState, dependency: D, effect: impl FnOnce(&D))

Fixes

• Remove AnyItemState in from_iter composable to pass stacked borrows check in miri (2360814)

Documentation

• Add docs for from_fn and from_iter composables (5c379e1)

actuate-v0.19.0

0.19.0 - 2024-12-08

Breaking changes

• Require 'static items in from_iter composable
  • This prevents edge cases where an item may have been removed from a collection, but references still exist down the tree.

Documentation

• Add logo to rustdocs (702b1e0)
• Update material docs (3084286)
• Update link to core::error::Error in Catch composable (b664206)

actuate-v0.18.0

0.18.0 - 2024-12-07

Breaking changes

• Create ScrollView composable and new ui module (28628f4, ebb17b0)
  • The material module is now located under ui

Features

• Add support for reactive Bevy desktop apps (7c65ba9, 6918000)
• Add more picking handler methods to Modify (64404b3)
• More advanced typography with new Text composable (825e007)
• Derive Clone for Spawn and refactor (6c4e457)
• Add methods to modify all Node fields

actuate-v0.17.2

0.17.2 - 2024-12-07

Fixes

• Update pending composable ordering and track child index in Spawn composable (fdf89ed)
• Reverse node IDs and refactor internals (42e1971)

Documentation

• Add docs to spawn constructor and split up ecs module (9c06bfe)
• Move examples for catch and dyn_compose to rustdocs (9502a4b)
• Move traits example to data module and add docs, reorganize examples (67ec922)
• Update Data docs (829c6d9)

actuate-v0.17.1

0.17.1 - 2024-12-06

Features

• Create FromFn composable

  • You can now create a composable without input using from_fn (433ab1d)

  •  fn from_fn<F, C>(f: F) -> FromFn<F, C>
     where
         F: Fn(ScopeState) -> C,
         C: Compose

• Derive Clone and Debug for Button, Container, and RadioButton (4f337ed)

Documentation

• Update docs for feature flags (869aa89)

actuate-v0.17.0

0.17.0 - 2024-12-06

Breaking changes

• Move Modifier and Modify to ecs module (behind new picking feature) (35b10ea)
  • These items can be useful for other design systems than Material 3
• Call on_insert on every insertion of a spawned bundle (this now requires Fn instead of FnOnce) (533da07)

Fixes

• Revert from breadth-first traversal of the composition to depth-first (8b3acd2)
• Update styling for Container (9cca3a7)

actuate-v0.16.1

0.16.1 - 2024-12-05

Features

• Material UI components

  • Button
  • Container
  • RadioButton
  • text
    • label
    • heading

• New scheduling algorithm based on BTreeSet (2a457a9)

actuate-v0.16.0

0.16.0 - 2024-12-05

Breaking changes

• Major internal rewrite! (9ef73eb) The new internals allow for more dynamic control over the composition
  , enabling features like pause and resume of a composition.
  Composer::try_compose will now also skip directly to changed composables, rather than setting change flags.
  • Removes exported methods for ScopeData
  • The Runtime struct is now private to ensure safety

Features

• Composer is now an iterator! This allows for stepping through each composable in the composition.

• Composer also implements fmt::Debug:

  use actuate::prelude::*;
  use actuate::composer::Composer;
  
  #[derive(Data)]
  struct A;
  
  impl Compose for A {
      fn compose(cx: Scope<Self>) -> impl Compose {
          (B, C)
      }
  }
  
  #[derive(Data)]
  struct B;
  
  impl Compose for B {
      fn compose(cx: Scope<Self>) -> impl Compose {}
  }
  
  #[derive(Data)]
  struct C;
  
  impl Compose for C {
      fn compose(cx: Scope<Self>) -> impl Compose {}
  }
  
  let mut composer = Composer::new(A);
  composer.try_compose().unwrap();
  
  assert_eq!(format!("{:?}", composer), "Composer(A(B, C))")