loro-crdt 1.3.2 → 1.3.4

package/bundler/loro_wasm.d.ts

@@ -1023,6 +1023,7 @@ interface LoroMovableList<T = unknown> {
      */
     setContainer<C extends Container>(pos: number, child: C): T extends C ? T : C;
 }
+
 interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroMap<T>;
     /**
@@ -1076,9 +1077,13 @@ interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
      */
     get<Key extends keyof T>(key: Key): T[Key];
     /**
-     * Set the key with the value.
+     *  Set the key with the value.
+     *
+     *  If the key already exists, its value will be updated. If the key doesn't exist,
+     *  a new key-value pair will be created.
      *
-     *  If the value of the key is exist, the old value will be updated.
+     *  > **Note**: When calling `map.set(key, value)` on a LoroMap, if `map.get(key)` already returns `value`, 
+     *  > the operation will be a no-op (no operation recorded) to avoid unnecessary updates.
      *
      *  @example
      *  ```ts
@@ -1155,7 +1160,7 @@ interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>>
     /**
      * Get LoroTreeNode by the TreeID.
      */
-    getNodeByID(target: TreeID): LoroTreeNode<T>;
+    getNodeByID(target: TreeID): LoroTreeNode<T> | undefined;
     subscribe(listener: Listener): Subscription;
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted?: boolean } ): LoroTreeNode<T>[];
@@ -1449,6 +1454,10 @@ export class LoroCounter {
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"

package/bundler/loro_wasm_bg.js

@@ -895,6 +895,10 @@ const LoroDocFinalization = (typeof FinalizationRegistry === 'undefined')
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -5984,13 +5988,13 @@ export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 };
 
-export function __wbg_lorotree_new(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+export function __wbg_lorotreenode_new(arg0) {
+    const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorolist_new(arg0) {
-    const ret = LoroList.__wrap(arg0);
+export function __wbg_lorocounter_new(arg0) {
+    const ret = LoroCounter.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -5999,8 +6003,8 @@ export function __wbg_lorotext_new(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_cursor_new(arg0) {
-    const ret = Cursor.__wrap(arg0);
+export function __wbg_lorolist_new(arg0) {
+    const ret = LoroList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6009,18 +6013,18 @@ export function __wbg_loromap_new(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotreenode_new(arg0) {
-    const ret = LoroTreeNode.__wrap(arg0);
+export function __wbg_cursor_new(arg0) {
+    const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorocounter_new(arg0) {
-    const ret = LoroCounter.__wrap(arg0);
+export function __wbg_loromovablelist_new(arg0) {
+    const ret = LoroMovableList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_loromovablelist_new(arg0) {
-    const ret = LoroMovableList.__wrap(arg0);
+export function __wbg_lorotree_new(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6252,7 +6256,7 @@ export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
     }
 };
 
-export const __wbg_now_2d57022b1935b215 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+export const __wbg_now_6dd635953150ee31 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 export function __wbg_crypto_1d1f22824a6a080c(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6581,7 +6585,7 @@ export function __wbindgen_closure_wrapper482(arg0, arg1, arg2) {
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper485(arg0, arg1, arg2) {
+export function __wbindgen_closure_wrapper484(arg0, arg1, arg2) {
     const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
     return addHeapObject(ret);
 };

package/nodejs/loro_wasm.d.ts

@@ -1023,6 +1023,7 @@ interface LoroMovableList<T = unknown> {
      */
     setContainer<C extends Container>(pos: number, child: C): T extends C ? T : C;
 }
+
 interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroMap<T>;
     /**
@@ -1076,9 +1077,13 @@ interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
      */
     get<Key extends keyof T>(key: Key): T[Key];
     /**
-     * Set the key with the value.
+     *  Set the key with the value.
+     *
+     *  If the key already exists, its value will be updated. If the key doesn't exist,
+     *  a new key-value pair will be created.
      *
-     *  If the value of the key is exist, the old value will be updated.
+     *  > **Note**: When calling `map.set(key, value)` on a LoroMap, if `map.get(key)` already returns `value`, 
+     *  > the operation will be a no-op (no operation recorded) to avoid unnecessary updates.
      *
      *  @example
      *  ```ts
@@ -1155,7 +1160,7 @@ interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>>
     /**
      * Get LoroTreeNode by the TreeID.
      */
-    getNodeByID(target: TreeID): LoroTreeNode<T>;
+    getNodeByID(target: TreeID): LoroTreeNode<T> | undefined;
     subscribe(listener: Listener): Subscription;
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted?: boolean } ): LoroTreeNode<T>[];
@@ -1449,6 +1454,10 @@ export class LoroCounter {
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"

package/nodejs/loro_wasm.js

@@ -893,6 +893,10 @@ const LoroDocFinalization = (typeof FinalizationRegistry === 'undefined')
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -5991,13 +5995,13 @@ module.exports.__wbindgen_object_drop_ref = function(arg0) {
     takeObject(arg0);
 };
 
-module.exports.__wbg_lorotree_new = function(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+module.exports.__wbg_lorotreenode_new = function(arg0) {
+    const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorolist_new = function(arg0) {
-    const ret = LoroList.__wrap(arg0);
+module.exports.__wbg_lorocounter_new = function(arg0) {
+    const ret = LoroCounter.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6006,8 +6010,8 @@ module.exports.__wbg_lorotext_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_cursor_new = function(arg0) {
-    const ret = Cursor.__wrap(arg0);
+module.exports.__wbg_lorolist_new = function(arg0) {
+    const ret = LoroList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6016,18 +6020,18 @@ module.exports.__wbg_loromap_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotreenode_new = function(arg0) {
-    const ret = LoroTreeNode.__wrap(arg0);
+module.exports.__wbg_cursor_new = function(arg0) {
+    const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorocounter_new = function(arg0) {
-    const ret = LoroCounter.__wrap(arg0);
+module.exports.__wbg_loromovablelist_new = function(arg0) {
+    const ret = LoroMovableList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_loromovablelist_new = function(arg0) {
-    const ret = LoroMovableList.__wrap(arg0);
+module.exports.__wbg_lorotree_new = function(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6259,7 +6263,7 @@ module.exports.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_now_2d57022b1935b215 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+module.exports.__wbg_now_6dd635953150ee31 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 module.exports.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6588,7 +6592,7 @@ module.exports.__wbindgen_closure_wrapper482 = function(arg0, arg1, arg2) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper485 = function(arg0, arg1, arg2) {
+module.exports.__wbindgen_closure_wrapper484 = function(arg0, arg1, arg2) {
     const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
     return addHeapObject(ret);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loro-crdt",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "Loro CRDTs is a high-performance CRDT framework that makes your app state synchronized, collaborative and maintainable effortlessly.",
   "keywords": [
     "crdt",

package/web/loro_wasm.d.ts

@@ -1023,6 +1023,7 @@ interface LoroMovableList<T = unknown> {
      */
     setContainer<C extends Container>(pos: number, child: C): T extends C ? T : C;
 }
+
 interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroMap<T>;
     /**
@@ -1076,9 +1077,13 @@ interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
      */
     get<Key extends keyof T>(key: Key): T[Key];
     /**
-     * Set the key with the value.
+     *  Set the key with the value.
+     *
+     *  If the key already exists, its value will be updated. If the key doesn't exist,
+     *  a new key-value pair will be created.
      *
-     *  If the value of the key is exist, the old value will be updated.
+     *  > **Note**: When calling `map.set(key, value)` on a LoroMap, if `map.get(key)` already returns `value`, 
+     *  > the operation will be a no-op (no operation recorded) to avoid unnecessary updates.
      *
      *  @example
      *  ```ts
@@ -1155,7 +1160,7 @@ interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>>
     /**
      * Get LoroTreeNode by the TreeID.
      */
-    getNodeByID(target: TreeID): LoroTreeNode<T>;
+    getNodeByID(target: TreeID): LoroTreeNode<T> | undefined;
     subscribe(listener: Listener): Subscription;
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted?: boolean } ): LoroTreeNode<T>[];
@@ -1449,6 +1454,10 @@ export class LoroCounter {
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"

package/web/loro_wasm.js

@@ -887,6 +887,10 @@ const LoroDocFinalization = (typeof FinalizationRegistry === 'undefined')
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -6009,38 +6013,38 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_lorotree_new = function(arg0) {
-        const ret = LoroTree.__wrap(arg0);
+    imports.wbg.__wbg_lorotreenode_new = function(arg0) {
+        const ret = LoroTreeNode.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorolist_new = function(arg0) {
-        const ret = LoroList.__wrap(arg0);
+    imports.wbg.__wbg_lorocounter_new = function(arg0) {
+        const ret = LoroCounter.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_lorotext_new = function(arg0) {
         const ret = LoroText.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_cursor_new = function(arg0) {
-        const ret = Cursor.__wrap(arg0);
+    imports.wbg.__wbg_lorolist_new = function(arg0) {
+        const ret = LoroList.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_loromap_new = function(arg0) {
         const ret = LoroMap.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotreenode_new = function(arg0) {
-        const ret = LoroTreeNode.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_lorocounter_new = function(arg0) {
-        const ret = LoroCounter.__wrap(arg0);
+    imports.wbg.__wbg_cursor_new = function(arg0) {
+        const ret = Cursor.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_loromovablelist_new = function(arg0) {
         const ret = LoroMovableList.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_lorotree_new = function(arg0) {
+        const ret = LoroTree.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_versionvector_new = function(arg0) {
         const ret = VersionVector.__wrap(arg0);
         return addHeapObject(ret);
@@ -6233,7 +6237,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export_5(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_now_2d57022b1935b215 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+    imports.wbg.__wbg_now_6dd635953150ee31 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -6500,7 +6504,7 @@ function __wbg_get_imports() {
         const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper485 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper484 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
         return addHeapObject(ret);
     };