release 0.4.1, fix double emit for initially empty reactive collections (#18)

Author: databasedav

CHANGELOG.md

@@ -4,6 +4,18 @@ the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ## unreleased
 
+# 0.4.1 (2025-11-27)
+
+### fixed
+
+- initially empty `MutableVec`s and `MutableBTreeMap`s won't double emit their first additions
+
+# 0.3.1 (2025-11-27)
+
+### fixed
+
+- initially empty `MutableVec`s and `MutableBTreeMap`s won't double emit their first additions
+
 # 0.4.0 (2025-11-20)
 
 ### changed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "jonmo"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2024"
 categories = ["asynchronous", "gui", "game-development"]
 description = "ergonomic Bevy-native reactivity powered by FRP signals"

Cargo.toml

@@ -1121,14 +1121,18 @@ impl<K, V> MutableBTreeMap<K, V> {
         let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
             let broadcaster_system = world.get::<MutableBTreeMapData<K, V>>(self_.entity).unwrap().broadcaster.clone().register(world);
 
+            let was_initially_empty = self_.read(&*world).is_empty();
+
             let replay_entity = LazyEntity::new();
             let replay_system = clone!((self_, replay_entity) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, replay_onces: Query<&ReplayOnce, Allow<Internal>>, mutable_btree_map_datas: Query<&MutableBTreeMapData<K, V>>| {
                 if replay_onces.contains(*replay_entity) {
-                    let initial_map = self_.read(&mutable_btree_map_datas);
-                    if !initial_map.is_empty() {
+                    if !was_initially_empty {
+                        let initial_map = self_.read(&mutable_btree_map_datas);
                         Some(vec![MapDiff::Replace { entries: initial_map.iter().map(|(k, v)| (k.clone(), v.clone())).collect() }])
-                    } else {
+                    } else if upstream_diffs.is_empty() {
                         None
+                    } else {
+                        Some(upstream_diffs)
                     }
                 } else if upstream_diffs.is_empty() { None } else { Some(upstream_diffs) }
             });
@@ -2172,4 +2176,111 @@ pub(crate) mod tests {
 
         cleanup(true);
     }
+
+    #[test]
+    fn test_empty_map_first_insert() {
+        {
+            // Test that when a MutableBTreeMap starts empty and we insert into it,
+            // we only get one Insert diff (not a duplicate with Replace)
+
+            let mut app = create_test_app();
+            app.init_resource::<SignalMapOutput<String, i32>>();
+
+            // Start with an empty map
+            let source_map = MutableBTreeMap::from(app.world_mut());
+
+            // Create a signal_map and register it
+            let signal = source_map.signal_map();
+            let handle = signal.for_each(capture_map_output).register(app.world_mut());
+
+            // Insert the first entry
+            source_map.write(app.world_mut()).insert("a".to_string(), 42);
+            app.update();
+
+            // Should get exactly one Insert diff, not [Replace, Insert]
+            let diffs = get_and_clear_map_output::<String, i32>(app.world_mut());
+            assert_eq!(
+                diffs.len(),
+                1,
+                "Expected exactly one diff for first insert to empty map"
+            );
+            assert_eq!(
+                diffs[0],
+                MapDiff::Insert {
+                    key: "a".to_string(),
+                    value: 42
+                },
+                "Expected an Insert diff, not a Replace"
+            );
+
+            // Insert another entry to verify normal operation continues
+            source_map.write(app.world_mut()).insert("b".to_string(), 99);
+            app.update();
+
+            let diffs = get_and_clear_map_output::<String, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                MapDiff::Insert {
+                    key: "b".to_string(),
+                    value: 99
+                }
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
+    }
+
+    #[test]
+    fn test_nonempty_map_initial_replace() {
+        {
+            // Test that when a MutableBTreeMap starts with entries,
+            // we get an initial Replace diff
+
+            let mut app = create_test_app();
+            app.init_resource::<SignalMapOutput<String, i32>>();
+
+            // Start with a map containing initial entries
+            let source_map =
+                MutableBTreeMapBuilder::from([("x".to_string(), 1), ("y".to_string(), 2), ("z".to_string(), 3)])
+                    .spawn(app.world_mut());
+
+            // Create a signal_map and register it
+            let signal = source_map.signal_map();
+            let handle = signal.for_each(capture_map_output).register(app.world_mut());
+
+            // First update should produce a Replace with initial entries
+            app.update();
+
+            let diffs = get_and_clear_map_output::<String, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Expected exactly one diff for initial state");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Replace {
+                    entries: vec![("x".to_string(), 1), ("y".to_string(), 2), ("z".to_string(), 3),]
+                },
+                "Expected a Replace diff with initial entries"
+            );
+
+            // Insert another entry to verify normal operation continues
+            source_map.write(app.world_mut()).insert("w".to_string(), 4);
+            app.update();
+
+            let diffs = get_and_clear_map_output::<String, i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                MapDiff::Insert {
+                    key: "w".to_string(),
+                    value: 4
+                }
+            );
+
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
+    }
 }