loro-crdt 1.3.1 → 1.3.3

package/web/loro_wasm.d.ts

@@ -48,7 +48,7 @@ export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean):
 * const text = list.insertContainer(1, new LoroText());
 * ```
 */
-export type ContainerType = "Text" | "Map" | "List"| "Tree" | "MovableList";
+export type ContainerType = "Text" | "Map" | "List"| "Tree" | "MovableList" | "Counter";
 
 export type PeerID = `${number}`;
 /**
@@ -292,7 +292,7 @@ export type UndoConfig = {
     onPush?: (isUndo: boolean, counterRange: { start: number, end: number }, event?: LoroEventBatch) => { value: Value, cursors: Cursor[] },
     onPop?: (isUndo: boolean, value: { value: Value, cursors: Cursor[] }, counterRange: { start: number, end: number }) => void
 };
-export type Container = LoroList | LoroMap | LoroText | LoroTree | LoroMovableList;
+export type Container = LoroList | LoroMap | LoroText | LoroTree | LoroMovableList | LoroCounter;
 
 export interface ImportBlobMetadata {
     /**
@@ -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>[];
@@ -1378,7 +1383,7 @@ export class Cursor {
   kind(): any;
 }
 /**
-* The handler of a tree(forest) container.
+* The handler of a counter container.
 */
 export class LoroCounter {
   free(): void;
@@ -1387,6 +1392,11 @@ export class LoroCounter {
 */
   constructor();
 /**
+* "Counter"
+* @returns {'Counter'}
+*/
+  kind(): 'Counter';
+/**
 * Increment the counter by the given value.
 * @param {number} value
 */
@@ -1431,6 +1441,10 @@ export class LoroCounter {
 */
   getShallowValue(): number;
 /**
+* The container id of this handler.
+*/
+  readonly id: ContainerID;
+/**
 * Get the value of the counter.
 */
   readonly value: number;
@@ -1440,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"
@@ -3498,12 +3516,6 @@ export class UndoManager {
 */
   addExcludeOriginPrefix(prefix: string): void;
 /**
-* Check if the undo manager is bound to the given document.
-* @param {LoroDoc} doc
-* @returns {boolean}
-*/
-  checkBinding(doc: LoroDoc): boolean;
-/**
 */
   clear(): void;
 }
@@ -3583,6 +3595,8 @@ export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_lorocounter_free: (a: number) => void;
   readonly lorocounter_new: () => number;
+  readonly lorocounter_kind: (a: number) => number;
+  readonly lorocounter_id: (a: number) => number;
   readonly lorocounter_increment: (a: number, b: number, c: number) => void;
   readonly lorocounter_decrement: (a: number, b: number, c: number) => void;
   readonly lorocounter_value: (a: number) => number;
@@ -3658,7 +3672,6 @@ export interface InitOutput {
   readonly lorodoc_exportJsonInIdSpan: (a: number, b: number, c: number) => void;
   readonly lorodoc_importJsonUpdates: (a: number, b: number, c: number) => void;
   readonly lorodoc_import: (a: number, b: number, c: number, d: number) => void;
-  readonly lorodoc_importUpdateBatch: (a: number, b: number, c: number) => void;
   readonly lorodoc_importBatch: (a: number, b: number, c: number) => void;
   readonly lorodoc_getShallowValue: (a: number, b: number) => void;
   readonly lorodoc_toJSON: (a: number, b: number) => void;
@@ -3833,7 +3846,6 @@ export interface InitOutput {
   readonly undomanager_setMaxUndoSteps: (a: number, b: number) => void;
   readonly undomanager_setMergeInterval: (a: number, b: number) => void;
   readonly undomanager_addExcludeOriginPrefix: (a: number, b: number, c: number) => void;
-  readonly undomanager_checkBinding: (a: number, b: number) => number;
   readonly undomanager_setOnPush: (a: number, b: number) => void;
   readonly undomanager_setOnPop: (a: number, b: number) => void;
   readonly undomanager_clear: (a: number) => void;
@@ -3851,6 +3863,7 @@ export interface InitOutput {
   readonly versionvector_length: (a: number) => number;
   readonly decodeImportBlobMeta: (a: number, b: number, c: number, d: number) => void;
   readonly __wbg_loromovablelist_free: (a: number) => void;
+  readonly lorodoc_importUpdateBatch: (a: number, b: number, c: number) => void;
   readonly loromovablelist_parent: (a: number) => number;
   readonly lorotext_isAttached: (a: number) => number;
   readonly loromap_isAttached: (a: number) => number;

package/web/loro_wasm.js

@@ -728,7 +728,7 @@ const LoroCounterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lorocounter_free(ptr >>> 0));
 /**
-* The handler of a tree(forest) container.
+* The handler of a counter container.
 */
 export class LoroCounter {
 
@@ -760,6 +760,22 @@ export class LoroCounter {
         return this;
     }
     /**
+    * "Counter"
+    * @returns {'Counter'}
+    */
+    kind() {
+        const ret = wasm.lorocounter_kind(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * The container id of this handler.
+    * @returns {ContainerID}
+    */
+    get id() {
+        const ret = wasm.lorocounter_id(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
     * Increment the counter by the given value.
     * @param {number} value
     */
@@ -871,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"
@@ -2087,7 +2107,7 @@ export class LoroDoc {
     importUpdateBatch(data) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_importUpdateBatch(retptr, this.__wbg_ptr, addHeapObject(data));
+            wasm.lorodoc_importBatch(retptr, this.__wbg_ptr, addHeapObject(data));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -5715,16 +5735,6 @@ export class UndoManager {
         wasm.undomanager_addExcludeOriginPrefix(this.__wbg_ptr, ptr0, len0);
     }
     /**
-    * Check if the undo manager is bound to the given document.
-    * @param {LoroDoc} doc
-    * @returns {boolean}
-    */
-    checkBinding(doc) {
-        _assertClass(doc, LoroDoc);
-        const ret = wasm.undomanager_checkBinding(this.__wbg_ptr, doc.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
     * Set the on push event listener.
     *
     * Every time an undo step or redo step is pushed, the on push event listener will be called.
@@ -6003,36 +6013,36 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_lorolist_new = function(arg0) {
-        const ret = LoroList.__wrap(arg0);
+    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);
         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);
+    imports.wbg.__wbg_lorotext_new = function(arg0) {
+        const ret = LoroText.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotree_new = function(arg0) {
-        const ret = LoroTree.__wrap(arg0);
+    imports.wbg.__wbg_lorolist_new = function(arg0) {
+        const ret = LoroList.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_loromovablelist_new = function(arg0) {
-        const ret = LoroMovableList.__wrap(arg0);
+    imports.wbg.__wbg_loromap_new = function(arg0) {
+        const ret = LoroMap.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_cursor_new = function(arg0) {
         const ret = Cursor.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotext_new = function(arg0) {
-        const ret = LoroText.__wrap(arg0);
+    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) {
@@ -6136,10 +6146,10 @@ function __wbg_get_imports() {
         const ret = typeof getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_error_c8c2cca30a630316 = function(arg0, arg1) {
+    imports.wbg.__wbg_error_9384d761bf46409d = function(arg0, arg1) {
         console.error(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_log_d8fdbde28117925d = function(arg0, arg1) {
+    imports.wbg.__wbg_log_c86c3e1bf097ba35 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbindgen_is_falsy = function(arg0) {
@@ -6227,7 +6237,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export_5(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_now_15d99db1ebc1f0b2 = 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);
@@ -6490,12 +6500,12 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper491 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_60);
+    imports.wbg.__wbindgen_closure_wrapper482 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper494 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_63);
+    imports.wbg.__wbindgen_closure_wrapper484 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
         return addHeapObject(ret);
     };
 

package/web/loro_wasm_bg.wasm.d.ts

@@ -3,6 +3,8 @@
 export const memory: WebAssembly.Memory;
 export function __wbg_lorocounter_free(a: number): void;
 export function lorocounter_new(): number;
+export function lorocounter_kind(a: number): number;
+export function lorocounter_id(a: number): number;
 export function lorocounter_increment(a: number, b: number, c: number): void;
 export function lorocounter_decrement(a: number, b: number, c: number): void;
 export function lorocounter_value(a: number): number;
@@ -78,7 +80,6 @@ export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: nu
 export function lorodoc_exportJsonInIdSpan(a: number, b: number, c: number): void;
 export function lorodoc_importJsonUpdates(a: number, b: number, c: number): void;
 export function lorodoc_import(a: number, b: number, c: number, d: number): void;
-export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
 export function lorodoc_importBatch(a: number, b: number, c: number): void;
 export function lorodoc_getShallowValue(a: number, b: number): void;
 export function lorodoc_toJSON(a: number, b: number): void;
@@ -253,7 +254,6 @@ export function undomanager_canRedo(a: number): number;
 export function undomanager_setMaxUndoSteps(a: number, b: number): void;
 export function undomanager_setMergeInterval(a: number, b: number): void;
 export function undomanager_addExcludeOriginPrefix(a: number, b: number, c: number): void;
-export function undomanager_checkBinding(a: number, b: number): number;
 export function undomanager_setOnPush(a: number, b: number): void;
 export function undomanager_setOnPop(a: number, b: number): void;
 export function undomanager_clear(a: number): void;
@@ -271,6 +271,7 @@ export function versionvector_remove(a: number, b: number, c: number): void;
 export function versionvector_length(a: number): number;
 export function decodeImportBlobMeta(a: number, b: number, c: number, d: number): void;
 export function __wbg_loromovablelist_free(a: number): void;
+export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
 export function loromovablelist_parent(a: number): number;
 export function lorotext_isAttached(a: number): number;
 export function loromap_isAttached(a: number): number;