ywasm: YDoc and YTransaction methods

y-crdt · Horusiath · Mar 9, 2024 · Feb 11, 2024 · Feb 15, 2024 · Feb 16, 2024
commit 7afa7b9aaadde42e8b12f990bfba3718090372d6
diff --git a/tests-wasm/testHelper.js b/tests-wasm/testHelper.js
@@ -3,22 +3,22 @@ import * as Y from 'ywasm'
 /**
  * @this {YDoc}
  */
-Y.YDoc.prototype.transact = function(callback, origin) {
-  let txn = this.writeTransaction(origin)
-  try {
-      return callback(txn)
-  } finally {
-      txn.commit()
-      txn.free()
-  }
+Y.YDoc.prototype.transact = function (callback, origin) {
+    let txn = this.transaction(origin)
+    try {
+        return callback(txn)
+    } finally {
+        txn.commit()
+        txn.free()
+    }
 };
 
 /**
  * @param {Array<YDoc>} docs
  */
 export const exchangeUpdates = docs => {
-    for(let d1 of docs) {
-        for(let d2 of docs) {
+    for (let d1 of docs) {
+        for (let d2 of docs) {
             if (d1 !== d2) {
                 let stateVector = Y.encodeStateVector(d1)
                 let diff = Y.encodeStateAsUpdate(d2, stateVector)

diff --git a/tests-wasm/y-array.tests.js b/tests-wasm/y-array.tests.js
@@ -1,4 +1,4 @@
-import { exchangeUpdates } from './testHelper.js' // eslint-disable-line
+import {exchangeUpdates} from './testHelper.js' // eslint-disable-line
 
 import * as Y from 'ywasm'
 import * as t from 'lib0/testing'
@@ -7,19 +7,19 @@ import * as t from 'lib0/testing'
  * @param {t.TestCase} tc
  */
 export const testInserts = tc => {
-    const d1 = new Y.YDoc({clientID:1})
+    const d1 = new Y.YDoc({clientID: 1})
     t.compare(d1.id, 1)
     var x = d1.getArray('test');
 
     x.insert(0, [1, 2.5, 'hello', ['world'], true])
-    x.push( [{key:'value'}])
+    x.push([{key: 'value'}])
 
-    const expected = [1, 2.5, 'hello', ['world'], true, {key:'value'}]
+    const expected = [1, 2.5, 'hello', ['world'], true, {key: 'value'}]
 
     var value = x.toJson()
     t.compare(value, expected)
 
-    const d2 = new Y.YDoc({clientID:2})
+    const d2 = new Y.YDoc({clientID: 2})
     x = d2.getArray('test');
 
     exchangeUpdates([d1, d2])
@@ -58,7 +58,7 @@ export const testInsertsNested = tc => {
  * @param {t.TestCase} tc
  */
 export const testDelete = tc => {
-    const d1 = new Y.YDoc({clientID:1})
+    const d1 = new Y.YDoc({clientID: 1})
     t.compare(d1.id, 1)
     var x = d1.getArray('test')
 
@@ -70,7 +70,7 @@ export const testDelete = tc => {
     var value = x.toJson()
     t.compare(value, expected)
 
-    const d2 = new Y.YDoc({clientID:2})
+    const d2 = new Y.YDoc({clientID: 2})
     x = d2.getArray('test')
 
     exchangeUpdates([d1, d2])
@@ -118,7 +118,7 @@ export const testIterator = tc => {
     t.compare(x.length(), 3)
 
     let i = 1;
-    let txn = d1.readTransaction()
+    let txn = d1.transaction()
     for (let v of x.values(txn)) {
         t.compare(v, i)
         i++
@@ -146,26 +146,26 @@ export const testObserver = tc => {
 
     // insert initial data to an empty YArray
     d1.transact((txn) => {
-        x.insert(0, [1,2,3,4], txn)
+        x.insert(0, [1, 2, 3, 4], txn)
     }, 'TEST_ORIGIN')
     t.compare(target.toJson(), x.toJson())
-    t.compare(delta, [{insert: [1,2,3,4]}])
+    t.compare(delta, [{insert: [1, 2, 3, 4]}])
     t.compare(origin, 'TEST_ORIGIN')
     target = null
     delta = null
 
     // remove 2 items from the middle
     x.delete(1, 2)
     t.compare(target.toJson(), x.toJson())
-    t.compare(delta, [{retain:1}, {delete: 2}])
+    t.compare(delta, [{retain: 1}, {delete: 2}])
     t.compare(origin, undefined)
     target = null
     delta = null
 
     // insert new item in the middle
     x.insert(1, [5])
     t.compare(target.toJson(), x.toJson())
-    t.compare(delta, [{retain:1}, {insert: [5]}])
+    t.compare(delta, [{retain: 1}, {insert: [5]}])
     target = null
     delta = null
 
@@ -195,7 +195,7 @@ export const testObserveDeepEventOrder = tc => {
         arr.get(0, txn).set('a', 'a', txn)
         arr.insert(0, [0], txn)
     })
-    t.compare(paths, [ [], [ 1 ] ])
+    t.compare(paths, [[], [1]])
     subscription.free()
 }
 

diff --git a/yrs/src/transaction.rs b/yrs/src/transaction.rs
@@ -64,6 +64,12 @@ pub trait ReadTxn: Sized {
         encoder.to_vec()
     }
 
+    fn encode_diff_v2(&self, state_vector: &StateVector) -> Vec<u8> {
+        let mut encoder = EncoderV2::new();
+        self.encode_diff(state_vector, &mut encoder);
+        encoder.to_vec()
+    }
+
     fn encode_state_as_update<E: Encoder>(&self, sv: &StateVector, encoder: &mut E) {
         let store = self.store();
         store.write_blocks_from(sv, encoder);
@@ -85,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/ywasm/src/array.rs b/ywasm/src/array.rs
@@ -129,7 +129,7 @@ impl YArray {
 
     /// Deletes a range of items of given `length` from current `YArray` instance,
     /// starting from given `index`.
-    #[wasm_bindgen(method, js_name = delete)]
+    #[wasm_bindgen(method, js_name = "delete")]
     pub fn delete(
         &mut self,
         index: u32,
@@ -177,11 +177,11 @@ impl YArray {
         match &self.0 {
             SharedCollection::Prelim(c) => match c.get(index as usize) {
                 Some(item) => Ok(item.clone()),
-                None => Err(JsValue::from_str("index outside of the bounds of an array")),
+                None => Err(JsValue::from_str(crate::js::errors::OUT_OF_BOUNDS)),
             },
             SharedCollection::Integrated(c) => c.readonly(txn, |c, txn| match c.get(txn, index) {
                 Some(item) => Ok(Js::from_value(&item, txn.doc()).into()),
-                None => Err(JsValue::from_str("index outside of the bounds of an array")),
+                None => Err(JsValue::from_str(crate::js::errors::OUT_OF_BOUNDS)),
             }),
         }
     }
@@ -255,7 +255,7 @@ impl YArray {
     pub fn observe(&self, f: js_sys::Function) -> Result<Observer> {
         match &self.0 {
             SharedCollection::Prelim(_) => {
-                Err(JsValue::from_str("cannot observe preliminary type"))
+                Err(JsValue::from_str(crate::js::errors::INVALID_PRELIM_OP))
             }
             SharedCollection::Integrated(c) => {
                 let txn = c.transact()?;
@@ -278,7 +278,7 @@ impl YArray {
     pub fn observe_deep(&self, f: js_sys::Function) -> Result<Observer> {
         match &self.0 {
             SharedCollection::Prelim(_) => {
-                Err(JsValue::from_str("cannot observe preliminary type"))
+                Err(JsValue::from_str(crate::js::errors::INVALID_PRELIM_OP))
             }
             SharedCollection::Integrated(c) => {
                 let txn = c.transact()?;

diff --git a/ywasm/src/collection.rs b/ywasm/src/collection.rs
@@ -1,9 +1,8 @@
-use crate::js::Js;
 use crate::transaction::{ImplicitTransaction, YTransaction};
 use crate::Result;
 use std::ops::Deref;
 use wasm_bindgen::JsValue;
-use yrs::{Desc, Doc, Origin, ReadTxn, SharedRef, Transact, Transaction, TransactionMut};
+use yrs::{Desc, Doc, ReadTxn, SharedRef, Transact, Transaction, TransactionMut};
 
 pub enum SharedCollection<P, S> {
     Prelim(P),
@@ -52,10 +51,10 @@ impl<S: SharedRef + 'static> Integrated<S> {
     }
 
     pub fn readonly<F, T>(&self, txn: ImplicitTransaction, f: F) -> Result<T>
-    where
-        F: FnOnce(&S, &TransactionMut<'_>) -> Result<T>,
+        where
+            F: FnOnce(&S, &TransactionMut<'_>) -> Result<T>,
     {
-        match YTransaction::from_implicit(&txn) {
+        match YTransaction::from_implicit(&txn)? {
             Some(txn) => {
                 let txn: &TransactionMut = &*txn;
                 let shared_ref = self.unpack(txn)?;
@@ -70,10 +69,10 @@ impl<S: SharedRef + 'static> Integrated<S> {
     }
 
     pub fn mutably<F, T>(&self, mut txn: ImplicitTransaction, f: F) -> Result<T>
-    where
-        F: FnOnce(&S, &mut TransactionMut<'_>) -> Result<T>,
+        where
+            F: FnOnce(&S, &mut TransactionMut<'_>) -> Result<T>,
     {
-        match YTransaction::from_implicit_mut(&mut txn) {
+        match YTransaction::from_implicit_mut(&mut txn)? {
             Some(mut txn) => {
                 let txn = txn.as_mut()?;
                 let shared_ref = self.unpack(txn)?;
@@ -90,31 +89,21 @@ impl<S: SharedRef + 'static> Integrated<S> {
     pub fn unpack<T: ReadTxn>(&self, txn: &T) -> Result<S> {
         match self.desc.get(txn) {
             Some(shared_ref) => Ok(shared_ref),
-            None => Err(JsValue::from_str("shared collection has been destroyed")),
+            None => Err(JsValue::from_str(crate::js::errors::REF_DISPOSED)),
         }
     }
 
     pub fn transact(&self) -> Result<Transaction> {
         match self.doc.try_transact() {
             Ok(tx) => Ok(tx),
-            Err(_) => Err(JsValue::from_str(
-                "another read-write transaction is in progress",
-            )),
+            Err(_) => Err(JsValue::from_str(crate::js::errors::ANOTHER_RW_TX)),
         }
     }
 
     pub fn transact_mut(&self) -> Result<TransactionMut> {
         match self.doc.try_transact_mut() {
             Ok(tx) => Ok(tx),
-            Err(_) => Err(JsValue::from_str("another transaction is in progress")),
-        }
-    }
-
-    pub fn transact_mut_with(&self, js: &JsValue) -> Result<TransactionMut> {
-        let origin: Origin = Js::from(js.clone()).into();
-        match self.doc.try_transact_mut_with(origin) {
-            Ok(tx) => Ok(tx),
-            Err(_) => Err(JsValue::from_str("another transaction is in progress")),
+            Err(_) => Err(JsValue::from_str(crate::js::errors::ANOTHER_TX)),
         }
     }
 }