feat: loro-ffi 1.5.0

Author: Leeeon233

crates/loro-ffi/src/awareness.rs

@@ -35,11 +35,7 @@ impl Awareness {
     }
 
     pub fn get_local_state(&self) -> Option<LoroValue> {
-        self.0
-            .lock()
-            .unwrap()
-            .get_local_state()
-            .map(|x| x.into())
+        self.0.lock().unwrap().get_local_state().map(|x| x.into())
     }
 
     pub fn remove_outdated(&self) -> Vec<PeerID> {

crates/loro-ffi/src/doc.rs

@@ -780,6 +780,38 @@ impl LoroDoc {
     pub fn has_container(&self, id: &ContainerID) -> bool {
         self.doc.has_container(&id.into())
     }
+
+    /// Subscribe to the first commit from a peer. Operations performed on the `LoroDoc` within this callback
+    /// will be merged into the current commit.
+    ///
+    /// This is useful for managing the relationship between `PeerID` and user information.
+    /// For example, you could store user names in a `LoroMap` using `PeerID` as the key and the `UserID` as the value.
+    pub fn subscribe_first_commit_from_peer(
+        &self,
+        subscriber: Arc<dyn FirstCommitFromPeerCallback>,
+    ) -> Arc<Subscription> {
+        let subscriber: loro::FirstCommitFromPeerCallback = Box::new(move |e| {
+            subscriber.on_first_commit_from_peer(FirstCommitFromPeerPayload { peer: e.peer });
+            true
+        });
+        Arc::new(self.doc.subscribe_first_commit_from_peer(subscriber).into())
+    }
+
+    /// Subscribe to the pre-commit event.
+    ///
+    /// The callback will be called when the changes are committed but not yet applied to the OpLog.
+    /// You can modify the commit message and timestamp in the callback by [`ChangeModifier`].
+    pub fn subscribe_pre_commit(&self, callback: Arc<dyn PreCommitCallback>) -> Arc<Subscription> {
+        let subscriber: loro::PreCommitCallback = Box::new(move |e| {
+            callback.on_pre_commit(PreCommitCallbackPayload {
+                change_meta: e.change_meta.clone().into(),
+                origin: e.origin.clone(),
+                modifier: Arc::new(ChangeModifier(e.modifier.clone())),
+            });
+            true
+        });
+        Arc::new(self.doc.subscribe_pre_commit(subscriber).into())
+    }
 }
 
 pub trait ChangeAncestorsTraveler: Sync + Send {
@@ -896,6 +928,35 @@ pub trait LocalUpdateCallback: Sync + Send {
     fn on_local_update(&self, update: Vec<u8>);
 }
 
+pub trait FirstCommitFromPeerCallback: Sync + Send {
+    fn on_first_commit_from_peer(&self, e: FirstCommitFromPeerPayload);
+}
+
+pub struct FirstCommitFromPeerPayload {
+    pub peer: PeerID,
+}
+
+pub trait PreCommitCallback: Sync + Send {
+    fn on_pre_commit(&self, e: PreCommitCallbackPayload);
+}
+
+pub struct PreCommitCallbackPayload {
+    pub change_meta: ChangeMeta,
+    pub origin: String,
+    pub modifier: Arc<ChangeModifier>,
+}
+
+pub struct ChangeModifier(loro::ChangeModifier);
+
+impl ChangeModifier {
+    pub fn set_message(&self, msg: &str) {
+        self.0.set_message(msg);
+    }
+    pub fn set_timestamp(&self, timestamp: Timestamp) {
+        self.0.set_timestamp(timestamp);
+    }
+}
+
 pub trait Unsubscriber: Sync + Send {
     fn on_unsubscribe(&self);
 }

crates/loro-ffi/src/ephemeral.rs

@@ -1,13 +1,14 @@
 use crate::{LoroValue, LoroValueLike, Subscription};
-use loro::awareness::{EphemeralEventTrigger, EphemeralStore as InternalEphemeralStore};
+pub use loro::awareness::EphemeralEventTrigger;
+use loro::awareness::EphemeralStore as InternalEphemeralStore;
 use std::sync::{Arc, Mutex};
 
 #[derive(Debug, Clone)]
 pub struct EphemeralStoreEvent {
     pub by: EphemeralEventTrigger,
-    pub added: Arc<Vec<String>>,
-    pub removed: Arc<Vec<String>>,
-    pub updated: Arc<Vec<String>>,
+    pub added: Vec<String>,
+    pub removed: Vec<String>,
+    pub updated: Vec<String>,
 }
 
 pub trait LocalEphemeralListener: Sync + Send {
@@ -88,19 +89,15 @@ impl EphemeralStore {
     }
 
     pub fn subscribe(&self, listener: Arc<dyn EphemeralSubscriber>) -> Arc<Subscription> {
-        let s = self
-            .0
-            .lock()
-            .unwrap()
-            .subscribe(Box::new(move |update| {
-                listener.on_ephemeral_event(EphemeralStoreEvent {
-                    by: update.by,
-                    added: update.added.clone(),
-                    removed: update.removed.clone(),
-                    updated: update.updated.clone(),
-                });
-                true
-            }));
+        let s = self.0.lock().unwrap().subscribe(Box::new(move |update| {
+            listener.on_ephemeral_event(EphemeralStoreEvent {
+                by: update.by,
+                added: update.added.to_vec(),
+                removed: update.removed.to_vec(),
+                updated: update.updated.to_vec(),
+            });
+            true
+        }));
         Arc::new(Subscription(Mutex::new(Some(s))))
     }
 }

crates/loro-ffi/src/lib.rs

@@ -12,31 +12,21 @@ pub use std::cmp::Ordering;
 use std::sync::Arc;
 pub use value::{ContainerID, ContainerType, LoroValue, LoroValueLike};
 mod doc;
-pub use doc::{
-    decode_import_blob_meta, ChangeAncestorsTraveler, ChangeMeta, CommitOptions, ContainerPath,
-    FrontiersOrID, ImportBlobMetadata, ImportStatus, JsonSchemaLike, LocalUpdateCallback, LoroDoc,
-    PosQueryResult, Subscription, Unsubscriber,
-};
+pub use doc::*;
 mod container;
-pub use container::{
-    ContainerIdLike, Cursor, LoroCounter, LoroList, LoroMap, LoroMovableList, LoroText, LoroTree,
-    LoroUnknown, TreeParentId,
-};
+pub use container::*;
 mod event;
-pub use event::{
-    ContainerDiff, ContainerIDAndDiff, Diff, DiffBatch, DiffEvent, Index, ListDiffItem, MapDelta,
-    PathItem, Subscriber, TextDelta, TreeDiff, TreeDiffItem, TreeExternalDiff,
-};
+pub use event::*;
 mod undo;
-pub use undo::{AbsolutePosition, CursorWithPos, OnPop, OnPush, UndoItemMeta, UndoManager};
+pub use undo::*;
 mod config;
 pub use config::{Configure, StyleConfigMap};
 mod version;
 pub use version::{Frontiers, VersionVector, VersionVectorDiff};
 mod awareness;
-pub use awareness::{Awareness, AwarenessPeerUpdate, PeerInfo};
+pub use awareness::*;
 mod ephemeral;
-pub use ephemeral::{EphemeralStore, LocalEphemeralListener};
+pub use ephemeral::*;
 
 // https://github.com/mozilla/uniffi-rs/issues/1372
 pub trait ValueOrContainer: Send + Sync {

crates/loro/src/lib.rs

@@ -13,7 +13,8 @@ pub use loro_internal::encoding::ImportStatus;
 use loro_internal::handler::{HandlerTrait, ValueOrHandler};
 pub use loro_internal::loro::ChangeTravelError;
 pub use loro_internal::pre_commit::{
-    ChangeModifier, FirstCommitFromPeerCallback, PreCommitCallback,
+    ChangeModifier, FirstCommitFromPeerCallback, FirstCommitFromPeerPayload, PreCommitCallback,
+    PreCommitCallbackPayload,
 };
 pub use loro_internal::sync;
 pub use loro_internal::undo::{OnPop, UndoItemMeta, UndoOrRedo};