ywasm: working YArray

y-crdt · Horusiath · Mar 9, 2024 · Feb 11, 2024 · Feb 15, 2024 · Feb 16, 2024
commit c1f1ce4eabe429764eda2ed59c8dc72ac30766be
diff --git a/tests-wasm/package.json b/tests-wasm/package.json
@@ -5,6 +5,7 @@
   "description": "Test suite for Yrs Web Assembly package.",
   "main": "index.js",
   "scripts": {
+    "build": "wasm-pack build --target nodejs ../ywasm",
     "test": "node  --experimental-wasm-modules index.js"
   },
   "contributors": [

diff --git a/yrs/src/branch.rs b/yrs/src/branch.rs
@@ -588,7 +588,7 @@ impl<'a, T: ReadTxn> Iterator for Iter<'a, T> {
 ///
 /// // logical descriptors of both TextRef are the same as they refer to the
 /// // same logical entity
-/// assert_eq!(txt1.desc(), txt2.desc());
+/// assert_eq!(txt1.hook(), txt2.hook());
 /// ```
 #[repr(transparent)]
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -650,7 +650,7 @@ impl<S> Into<BranchID> for Root<S> {
 /// let text = root.insert(&mut txn, "nested", TextPrelim::new("")); // nested collection
 ///
 /// // convert nested TextRef into logical pointer
-/// let nested: Nested<TextRef> = text.desc().into_nested().unwrap();
+/// let nested: Nested<TextRef> = text.hook().into_nested().unwrap();
 ///
 /// // logical reference can be used to retrieve accessible TextRef when its alive
 /// assert_eq!(nested.get(&txn), Some(text));
@@ -706,60 +706,66 @@ impl<S> Into<BranchID> for Nested<S> {
 
 /// A descriptor used to reference to shared collections by their unique logical identifiers,
 /// which can be either [Root]-level collections or shared collections [Nested] into each other.
-/// It can be resolved from any shared reference using [SharedRef::desc].
-#[derive(Debug, Clone)]
-pub struct Desc<S> {
+/// It can be resolved from any shared reference using [SharedRef::hook].
+#[derive(Clone)]
+pub struct Hook<S> {
     id: BranchID,
     _tag: PhantomData<S>,
 }
 
-impl<S> Desc<S> {
+impl<S> Hook<S> {
     /// Unique logical identifier of a shared collection.
     pub fn id(&self) -> &BranchID {
         &self.id
     }
 }
 
-impl<S> Eq for Desc<S> {}
+impl<S> std::fmt::Debug for Hook<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{:?}", self.id)
+    }
+}
+
+impl<S> Eq for Hook<S> {}
 
-impl<S> PartialEq for Desc<S> {
+impl<S> PartialEq for Hook<S> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
-impl<S> Hash for Desc<S> {
+impl<S> Hash for Hook<S> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.id.hash(state)
     }
 }
 
-impl<S: SharedRef> Desc<S> {
-    /// Returns a reference to a shared collection current descriptor points to, if it exists and
+impl<S: SharedRef> Hook<S> {
+    /// Returns a reference to a shared collection current hook points to, if it exists and
     /// (in case of nested collections) has not been deleted.
     ///
     /// # Example
     ///
     /// ```rust
-    /// use yrs::{Desc, Doc, Map, MapRef, Nested, SharedRef, TextPrelim, TextRef, Transact, WriteTxn};
+    /// use yrs::{Hook, Doc, Map, MapRef, Nested, SharedRef, TextPrelim, TextRef, Transact, WriteTxn};
     ///
     /// let doc = Doc::new();
     /// let mut txn = doc.transact_mut();
     /// let root = txn.get_or_insert_map("root"); // root-level collection
     /// let nested = root.insert(&mut txn, "nested", TextPrelim::new("")); // nested collection
     ///
-    /// let root_desc: Desc<MapRef> = root.desc();
-    /// let nested_desc: Desc<TextRef> = nested.desc();
+    /// let root_hook: Hook<MapRef> = root.hook();
+    /// let nested_hook: Hook<TextRef> = nested.hook();
     ///
-    /// // descriptor can be used to retrieve collection reference as long as its alive
-    /// assert_eq!(nested_desc.get(&txn), Some(nested));
+    /// // hook can be used to retrieve collection reference as long as its alive
+    /// assert_eq!(nested_hook.get(&txn), Some(nested));
     ///
     /// // after nested collection is deleted it can no longer be referenced
     /// root.remove(&mut txn, "nested");
-    /// assert_eq!(nested_desc.get(&txn), None, "wtf");
+    /// assert_eq!(nested_hook.get(&txn), None, "wtf");
     ///
     /// // descriptors work also for root types
-    /// assert_eq!(root_desc.get(&txn), Some(root));
+    /// assert_eq!(root_hook.get(&txn), Some(root));
     /// ```
     pub fn get<T: ReadTxn>(&self, txn: &T) -> Option<S> {
         let branch = self.id.get_branch(txn)?;
@@ -769,7 +775,7 @@ impl<S: SharedRef> Desc<S> {
         }
     }
 
-    /// Attempts to convert current [Desc] type into [Nested] one.
+    /// Attempts to convert current [Hook] type into [Nested] one.
     /// Returns `None` if current descriptor doesn't reference a nested shared collection.  
     pub fn into_nested(self) -> Option<Nested<S>> {
         match self.id {
@@ -779,8 +785,8 @@ impl<S: SharedRef> Desc<S> {
     }
 }
 
-impl<S: RootRef> Desc<S> {
-    /// Attempts to convert current [Desc] type into [Root] one.
+impl<S: RootRef> Hook<S> {
+    /// Attempts to convert current [Hook] type into [Root] one.
     /// Returns `None` if current descriptor doesn't reference a root-level shared collection.
     pub fn into_root(self) -> Option<Root<S>> {
         match self.id {
@@ -790,34 +796,34 @@ impl<S: RootRef> Desc<S> {
     }
 }
 
-impl<S> From<Root<S>> for Desc<S> {
+impl<S> From<Root<S>> for Hook<S> {
     fn from(root: Root<S>) -> Self {
-        Desc {
+        Hook {
             id: root.into(),
             _tag: PhantomData::default(),
         }
     }
 }
 
-impl<S> From<Nested<S>> for Desc<S> {
+impl<S> From<Nested<S>> for Hook<S> {
     fn from(nested: Nested<S>) -> Self {
-        Desc {
+        Hook {
             id: nested.into(),
             _tag: PhantomData::default(),
         }
     }
 }
 
-impl<S> From<BranchID> for Desc<S> {
+impl<S> From<BranchID> for Hook<S> {
     fn from(id: BranchID) -> Self {
-        Desc {
+        Hook {
             id,
             _tag: PhantomData::default(),
         }
     }
 }
 
-impl<S> Into<BranchID> for Desc<S> {
+impl<S> Into<BranchID> for Hook<S> {
     fn into(self) -> BranchID {
         self.id
     }

diff --git a/yrs/src/lib.rs b/yrs/src/lib.rs
@@ -528,7 +528,7 @@ pub use crate::alt::{
 pub use crate::any::Any;
 pub use crate::block::ID;
 pub use crate::branch::BranchID;
-pub use crate::branch::Desc;
+pub use crate::branch::Hook;
 pub use crate::branch::Nested;
 pub use crate::branch::Root;
 pub use crate::doc::Doc;

diff --git a/yrs/src/transaction.rs b/yrs/src/transaction.rs
@@ -91,8 +91,8 @@ pub trait ReadTxn: Sized {
 
     /// Check if given node is alive. Returns false if node has been deleted.
     fn is_alive<B>(&self, node: &B) -> bool
-        where
-            B: SharedRef,
+    where
+        B: SharedRef,
     {
         let ptr = BranchPtr::from(node.as_ref());
         self.store().is_alive(&ptr)

diff --git a/yrs/src/types/array.rs b/yrs/src/types/array.rs
@@ -1015,12 +1015,12 @@ mod test {
         let c1 = Rc::new(RefCell::new(None));
         let c1c = c1.clone();
         let _s1 = a1.observe(move |_, e| {
-            *c1c.borrow_mut() = Some(e.target().desc());
+            *c1c.borrow_mut() = Some(e.target().hook());
         });
         let c2 = Rc::new(RefCell::new(None));
         let c2c = c2.clone();
         let _s2 = a2.observe(move |_, e| {
-            *c2c.borrow_mut() = Some(e.target().desc());
+            *c2c.borrow_mut() = Some(e.target().hook());
         });
 
         {
@@ -1029,8 +1029,8 @@ mod test {
         }
         exchange_updates(&[&d1, &d2]);
 
-        assert_eq!(c1.borrow_mut().take(), Some(a1.desc()));
-        assert_eq!(c2.borrow_mut().take(), Some(a2.desc()));
+        assert_eq!(c1.borrow_mut().take(), Some(a1.hook()));
+        assert_eq!(c2.borrow_mut().take(), Some(a2.hook()));
     }
 
     use crate::transaction::ReadTxn;

diff --git a/yrs/src/types/mod.rs b/yrs/src/types/mod.rs
@@ -252,9 +252,9 @@ pub trait RootRef: SharedRef {
 /// Common trait for shared collaborative collection types in Yrs.
 pub trait SharedRef: From<BranchPtr> + AsRef<Branch> {
     /// Returns a logical descriptor of a current shared collection.
-    fn desc(&self) -> Desc<Self> {
+    fn hook(&self) -> Hook<Self> {
         let branch = self.as_ref();
-        Desc::from(branch.id())
+        Hook::from(branch.id())
     }
 }
 

diff --git a/yrs/src/types/xml.rs b/yrs/src/types/xml.rs
@@ -1304,13 +1304,13 @@ mod test {
             "query selector should found two paragraphs"
         );
         assert_eq!(
-            actual[0].desc(),
-            p1.desc(),
+            actual[0].hook(),
+            p1.hook(),
             "query selector found 1st paragraph"
         );
         assert_eq!(
-            actual[1].desc(),
-            p2.desc(),
+            actual[1].hook(),
+            p2.hook(),
             "query selector found 2nd paragraph"
         );
     }
@@ -1338,23 +1338,23 @@ mod test {
 
         assert_eq!(
             &first.siblings(&txn).next().unwrap().id(),
-            second.desc().id(),
+            second.hook().id(),
             "first.next_sibling should point to second"
         );
         assert_eq!(
             &second.siblings(&txn).next_back().unwrap().id(),
-            first.desc().id(),
+            first.hook().id(),
             "second.prev_sibling should point to first"
         );
         assert_eq!(
             &first.parent().unwrap().id(),
-            root.desc().id(),
+            root.hook().id(),
             "first.parent should point to root"
         );
         assert!(root.parent().is_none(), "root parent should not exist");
         assert_eq!(
             &root.first_child().unwrap().id(),
-            first.desc().id(),
+            first.hook().id(),
             "root.first_child should point to first"
         );
     }

diff --git a/ywasm/Cargo.toml b/ywasm/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "ywasm"
 version = "0.17.4"
-authors = ["Kevin Jahns <kevin.jahns@protonmail.com>","Bartosz Sypytkowski <b.sypytkowski@gmail.com>"]
+authors = ["Kevin Jahns <kevin.jahns@protonmail.com>", "Bartosz Sypytkowski <b.sypytkowski@gmail.com>"]
 keywords = ["crdt", "wasm", "yrs"]
 edition = "2018"
 license = "MIT"

diff --git a/ywasm/src/array.rs b/ywasm/src/array.rs
@@ -7,7 +7,7 @@ use std::iter::FromIterator;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
 use yrs::types::array::ArrayEvent;
-use yrs::types::ToJson;
+use yrs::types::{ToJson, TYPE_REFS_ARRAY};
 use yrs::{Array, ArrayRef, DeepObservable, Observable, SharedRef, TransactionMut};
 
 /// A collection used to store data in an indexed sequence structure. This type is internally
@@ -44,6 +44,11 @@ impl YArray {
         YArray(SharedCollection::prelim(items.unwrap_or_default()))
     }
 
+    #[wasm_bindgen(getter, js_name = type)]
+    pub fn get_type(&self) -> u8 {
+        TYPE_REFS_ARRAY
+    }
+
     /// Returns true if this is a preliminary instance of `YArray`.
     ///
     /// Preliminary instances can be nested into other shared data types such as `YArray` and `YMap`.
@@ -83,7 +88,8 @@ impl YArray {
                 Ok(a.into())
             }
             SharedCollection::Integrated(c) => c.readonly(txn, |c, txn| {
-                JsValue::from_serde(&c.to_json(txn)).map_err(|e| JsValue::from_str(&e.to_string()))
+                let any = c.to_json(txn);
+                JsValue::from_serde(&any).map_err(|e| JsValue::from_str(&e.to_string()))
             }),
         }
     }
@@ -305,17 +311,22 @@ pub(crate) trait ArrayExt: Array + SharedRef {
             let js = Js::from(value);
             match js.as_value()? {
                 ValueRef::Any(any) => primitive.push(any),
-                ValueRef::Shared(shared) if shared.prelim() => {
-                    let len = primitive.len() as u32;
-                    if len > 0 {
-                        self.insert_range(txn, j, std::mem::take(&mut primitive));
-                        j += len;
+                ValueRef::Shared(shared) => {
+                    if shared.prelim() {
+                        let len = primitive.len() as u32;
+                        if len > 0 {
+                            self.insert_range(txn, j, std::mem::take(&mut primitive));
+                            j += len;
+                        }
+                        self.insert(txn, j, shared);
+                        j += 1;
+                    } else {
+                        let err = format!("cannot insert item at index {}: shared collection is not a preliminary type", i);
+                        return Err(JsValue::from(&err));
                     }
-                    self.insert(txn, j, shared);
-                    j += 1;
                 }
                 _ => {
-                    let err = format!("item at position {} cannot be inserted", i);
+                    let err = format!("cannot insert item at index {}", i);
                     return Err(JsValue::from(&err));
                 }
             }
@@ -370,6 +381,16 @@ impl YArrayEvent {
         js.clone()
     }
 
+    #[wasm_bindgen(getter)]
+    pub fn origin(&mut self) -> JsValue {
+        let origin = self.txn.origin();
+        if let Some(origin) = origin {
+            Js::from(origin).into()
+        } else {
+            JsValue::UNDEFINED
+        }
+    }
+
     /// Returns a list of text changes made over corresponding `YArray` collection within
     /// bounds of current transaction. These changes follow a format:
     ///